[tint] Rename core::Function to BuiltinFn
Also do a pass of the codebase to use BuiltinFn consistently.
There's poor naming between builtin-functions, builtin-types, and
builtin-values.
Change-Id: I9100d2e35d485f3b398c2ae3b852b63d0705c40e
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/152542
Reviewed-by: dan sinclair <dsinclair@chromium.org>
Commit-Queue: Ben Clayton <bclayton@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
diff --git a/src/tint/lang/core/BUILD.bazel b/src/tint/lang/core/BUILD.bazel
index 8f69c1d..76b7de4 100644
--- a/src/tint/lang/core/BUILD.bazel
+++ b/src/tint/lang/core/BUILD.bazel
@@ -31,8 +31,8 @@
"attribute.cc",
"binary_op.cc",
"builtin.cc",
+ "builtin_fn.cc",
"builtin_value.cc",
- "function.cc",
"interpolation_sampling.cc",
"interpolation_type.cc",
"number.cc",
@@ -46,10 +46,10 @@
"attribute.h",
"binary_op.h",
"builtin.h",
+ "builtin_fn.h",
"builtin_value.h",
"evaluation_stage.h",
"fluent_types.h",
- "function.h",
"interpolation.h",
"interpolation_sampling.h",
"interpolation_type.h",
diff --git a/src/tint/lang/core/BUILD.cmake b/src/tint/lang/core/BUILD.cmake
index 5e02dac..9ce2fe3 100644
--- a/src/tint/lang/core/BUILD.cmake
+++ b/src/tint/lang/core/BUILD.cmake
@@ -41,12 +41,12 @@
lang/core/binary_op.h
lang/core/builtin.cc
lang/core/builtin.h
+ lang/core/builtin_fn.cc
+ lang/core/builtin_fn.h
lang/core/builtin_value.cc
lang/core/builtin_value.h
lang/core/evaluation_stage.h
lang/core/fluent_types.h
- lang/core/function.cc
- lang/core/function.h
lang/core/interpolation.h
lang/core/interpolation_sampling.cc
lang/core/interpolation_sampling.h
diff --git a/src/tint/lang/core/BUILD.gn b/src/tint/lang/core/BUILD.gn
index c096493..8922c2a 100644
--- a/src/tint/lang/core/BUILD.gn
+++ b/src/tint/lang/core/BUILD.gn
@@ -41,12 +41,12 @@
"binary_op.h",
"builtin.cc",
"builtin.h",
+ "builtin_fn.cc",
+ "builtin_fn.h",
"builtin_value.cc",
"builtin_value.h",
"evaluation_stage.h",
"fluent_types.h",
- "function.cc",
- "function.h",
"interpolation.h",
"interpolation_sampling.cc",
"interpolation_sampling.h",
diff --git a/src/tint/lang/core/builtin_fn.cc b/src/tint/lang/core/builtin_fn.cc
new file mode 100644
index 0000000..c74963f
--- /dev/null
+++ b/src/tint/lang/core/builtin_fn.cc
@@ -0,0 +1,713 @@
+// 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/lang/core/builtin_fn.cc.tmpl
+//
+// To regenerate run: './tools/run gen'
+//
+// Do not modify this file directly
+////////////////////////////////////////////////////////////////////////////////
+
+#include "src/tint/lang/core/builtin_fn.h"
+
+namespace tint::core {
+
+BuiltinFn ParseBuiltinFn(std::string_view name) {
+ if (name == "abs") {
+ return BuiltinFn::kAbs;
+ }
+ if (name == "acos") {
+ return BuiltinFn::kAcos;
+ }
+ if (name == "acosh") {
+ return BuiltinFn::kAcosh;
+ }
+ if (name == "all") {
+ return BuiltinFn::kAll;
+ }
+ if (name == "any") {
+ return BuiltinFn::kAny;
+ }
+ if (name == "arrayLength") {
+ return BuiltinFn::kArrayLength;
+ }
+ if (name == "asin") {
+ return BuiltinFn::kAsin;
+ }
+ if (name == "asinh") {
+ return BuiltinFn::kAsinh;
+ }
+ if (name == "atan") {
+ return BuiltinFn::kAtan;
+ }
+ if (name == "atan2") {
+ return BuiltinFn::kAtan2;
+ }
+ if (name == "atanh") {
+ return BuiltinFn::kAtanh;
+ }
+ if (name == "ceil") {
+ return BuiltinFn::kCeil;
+ }
+ if (name == "clamp") {
+ return BuiltinFn::kClamp;
+ }
+ if (name == "cos") {
+ return BuiltinFn::kCos;
+ }
+ if (name == "cosh") {
+ return BuiltinFn::kCosh;
+ }
+ if (name == "countLeadingZeros") {
+ return BuiltinFn::kCountLeadingZeros;
+ }
+ if (name == "countOneBits") {
+ return BuiltinFn::kCountOneBits;
+ }
+ if (name == "countTrailingZeros") {
+ return BuiltinFn::kCountTrailingZeros;
+ }
+ if (name == "cross") {
+ return BuiltinFn::kCross;
+ }
+ if (name == "degrees") {
+ return BuiltinFn::kDegrees;
+ }
+ if (name == "determinant") {
+ return BuiltinFn::kDeterminant;
+ }
+ if (name == "distance") {
+ return BuiltinFn::kDistance;
+ }
+ if (name == "dot") {
+ return BuiltinFn::kDot;
+ }
+ if (name == "dot4I8Packed") {
+ return BuiltinFn::kDot4I8Packed;
+ }
+ if (name == "dot4U8Packed") {
+ return BuiltinFn::kDot4U8Packed;
+ }
+ if (name == "dpdx") {
+ return BuiltinFn::kDpdx;
+ }
+ if (name == "dpdxCoarse") {
+ return BuiltinFn::kDpdxCoarse;
+ }
+ if (name == "dpdxFine") {
+ return BuiltinFn::kDpdxFine;
+ }
+ if (name == "dpdy") {
+ return BuiltinFn::kDpdy;
+ }
+ if (name == "dpdyCoarse") {
+ return BuiltinFn::kDpdyCoarse;
+ }
+ if (name == "dpdyFine") {
+ return BuiltinFn::kDpdyFine;
+ }
+ if (name == "exp") {
+ return BuiltinFn::kExp;
+ }
+ if (name == "exp2") {
+ return BuiltinFn::kExp2;
+ }
+ if (name == "extractBits") {
+ return BuiltinFn::kExtractBits;
+ }
+ if (name == "faceForward") {
+ return BuiltinFn::kFaceForward;
+ }
+ if (name == "firstLeadingBit") {
+ return BuiltinFn::kFirstLeadingBit;
+ }
+ if (name == "firstTrailingBit") {
+ return BuiltinFn::kFirstTrailingBit;
+ }
+ if (name == "floor") {
+ return BuiltinFn::kFloor;
+ }
+ if (name == "fma") {
+ return BuiltinFn::kFma;
+ }
+ if (name == "fract") {
+ return BuiltinFn::kFract;
+ }
+ if (name == "frexp") {
+ return BuiltinFn::kFrexp;
+ }
+ if (name == "fwidth") {
+ return BuiltinFn::kFwidth;
+ }
+ if (name == "fwidthCoarse") {
+ return BuiltinFn::kFwidthCoarse;
+ }
+ if (name == "fwidthFine") {
+ return BuiltinFn::kFwidthFine;
+ }
+ if (name == "insertBits") {
+ return BuiltinFn::kInsertBits;
+ }
+ if (name == "inverseSqrt") {
+ return BuiltinFn::kInverseSqrt;
+ }
+ if (name == "ldexp") {
+ return BuiltinFn::kLdexp;
+ }
+ if (name == "length") {
+ return BuiltinFn::kLength;
+ }
+ if (name == "log") {
+ return BuiltinFn::kLog;
+ }
+ if (name == "log2") {
+ return BuiltinFn::kLog2;
+ }
+ if (name == "max") {
+ return BuiltinFn::kMax;
+ }
+ if (name == "min") {
+ return BuiltinFn::kMin;
+ }
+ if (name == "mix") {
+ return BuiltinFn::kMix;
+ }
+ if (name == "modf") {
+ return BuiltinFn::kModf;
+ }
+ if (name == "normalize") {
+ return BuiltinFn::kNormalize;
+ }
+ if (name == "pack2x16float") {
+ return BuiltinFn::kPack2X16Float;
+ }
+ if (name == "pack2x16snorm") {
+ return BuiltinFn::kPack2X16Snorm;
+ }
+ if (name == "pack2x16unorm") {
+ return BuiltinFn::kPack2X16Unorm;
+ }
+ if (name == "pack4x8snorm") {
+ return BuiltinFn::kPack4X8Snorm;
+ }
+ if (name == "pack4x8unorm") {
+ return BuiltinFn::kPack4X8Unorm;
+ }
+ if (name == "pow") {
+ return BuiltinFn::kPow;
+ }
+ if (name == "quantizeToF16") {
+ return BuiltinFn::kQuantizeToF16;
+ }
+ if (name == "radians") {
+ return BuiltinFn::kRadians;
+ }
+ if (name == "reflect") {
+ return BuiltinFn::kReflect;
+ }
+ if (name == "refract") {
+ return BuiltinFn::kRefract;
+ }
+ if (name == "reverseBits") {
+ return BuiltinFn::kReverseBits;
+ }
+ if (name == "round") {
+ return BuiltinFn::kRound;
+ }
+ if (name == "saturate") {
+ return BuiltinFn::kSaturate;
+ }
+ if (name == "select") {
+ return BuiltinFn::kSelect;
+ }
+ if (name == "sign") {
+ return BuiltinFn::kSign;
+ }
+ if (name == "sin") {
+ return BuiltinFn::kSin;
+ }
+ if (name == "sinh") {
+ return BuiltinFn::kSinh;
+ }
+ if (name == "smoothstep") {
+ return BuiltinFn::kSmoothstep;
+ }
+ if (name == "sqrt") {
+ return BuiltinFn::kSqrt;
+ }
+ if (name == "step") {
+ return BuiltinFn::kStep;
+ }
+ if (name == "storageBarrier") {
+ return BuiltinFn::kStorageBarrier;
+ }
+ if (name == "tan") {
+ return BuiltinFn::kTan;
+ }
+ if (name == "tanh") {
+ return BuiltinFn::kTanh;
+ }
+ if (name == "transpose") {
+ return BuiltinFn::kTranspose;
+ }
+ if (name == "trunc") {
+ return BuiltinFn::kTrunc;
+ }
+ if (name == "unpack2x16float") {
+ return BuiltinFn::kUnpack2X16Float;
+ }
+ if (name == "unpack2x16snorm") {
+ return BuiltinFn::kUnpack2X16Snorm;
+ }
+ if (name == "unpack2x16unorm") {
+ return BuiltinFn::kUnpack2X16Unorm;
+ }
+ if (name == "unpack4x8snorm") {
+ return BuiltinFn::kUnpack4X8Snorm;
+ }
+ if (name == "unpack4x8unorm") {
+ return BuiltinFn::kUnpack4X8Unorm;
+ }
+ if (name == "workgroupBarrier") {
+ return BuiltinFn::kWorkgroupBarrier;
+ }
+ if (name == "workgroupUniformLoad") {
+ return BuiltinFn::kWorkgroupUniformLoad;
+ }
+ if (name == "textureBarrier") {
+ return BuiltinFn::kTextureBarrier;
+ }
+ if (name == "textureDimensions") {
+ return BuiltinFn::kTextureDimensions;
+ }
+ if (name == "textureGather") {
+ return BuiltinFn::kTextureGather;
+ }
+ if (name == "textureGatherCompare") {
+ return BuiltinFn::kTextureGatherCompare;
+ }
+ if (name == "textureNumLayers") {
+ return BuiltinFn::kTextureNumLayers;
+ }
+ if (name == "textureNumLevels") {
+ return BuiltinFn::kTextureNumLevels;
+ }
+ if (name == "textureNumSamples") {
+ return BuiltinFn::kTextureNumSamples;
+ }
+ if (name == "textureSample") {
+ return BuiltinFn::kTextureSample;
+ }
+ if (name == "textureSampleBias") {
+ return BuiltinFn::kTextureSampleBias;
+ }
+ if (name == "textureSampleCompare") {
+ return BuiltinFn::kTextureSampleCompare;
+ }
+ if (name == "textureSampleCompareLevel") {
+ return BuiltinFn::kTextureSampleCompareLevel;
+ }
+ if (name == "textureSampleGrad") {
+ return BuiltinFn::kTextureSampleGrad;
+ }
+ if (name == "textureSampleLevel") {
+ return BuiltinFn::kTextureSampleLevel;
+ }
+ if (name == "textureSampleBaseClampToEdge") {
+ return BuiltinFn::kTextureSampleBaseClampToEdge;
+ }
+ if (name == "textureStore") {
+ return BuiltinFn::kTextureStore;
+ }
+ if (name == "textureLoad") {
+ return BuiltinFn::kTextureLoad;
+ }
+ if (name == "atomicLoad") {
+ return BuiltinFn::kAtomicLoad;
+ }
+ if (name == "atomicStore") {
+ return BuiltinFn::kAtomicStore;
+ }
+ if (name == "atomicAdd") {
+ return BuiltinFn::kAtomicAdd;
+ }
+ if (name == "atomicSub") {
+ return BuiltinFn::kAtomicSub;
+ }
+ if (name == "atomicMax") {
+ return BuiltinFn::kAtomicMax;
+ }
+ if (name == "atomicMin") {
+ return BuiltinFn::kAtomicMin;
+ }
+ if (name == "atomicAnd") {
+ return BuiltinFn::kAtomicAnd;
+ }
+ if (name == "atomicOr") {
+ return BuiltinFn::kAtomicOr;
+ }
+ if (name == "atomicXor") {
+ return BuiltinFn::kAtomicXor;
+ }
+ if (name == "atomicExchange") {
+ return BuiltinFn::kAtomicExchange;
+ }
+ if (name == "atomicCompareExchangeWeak") {
+ return BuiltinFn::kAtomicCompareExchangeWeak;
+ }
+ if (name == "subgroupBallot") {
+ return BuiltinFn::kSubgroupBallot;
+ }
+ if (name == "subgroupBroadcast") {
+ return BuiltinFn::kSubgroupBroadcast;
+ }
+ if (name == "_tint_materialize") {
+ return BuiltinFn::kTintMaterialize;
+ }
+ return BuiltinFn::kNone;
+}
+
+const char* str(BuiltinFn i) {
+ switch (i) {
+ case BuiltinFn::kNone:
+ return "<none>";
+ case BuiltinFn::kAbs:
+ return "abs";
+ case BuiltinFn::kAcos:
+ return "acos";
+ case BuiltinFn::kAcosh:
+ return "acosh";
+ case BuiltinFn::kAll:
+ return "all";
+ case BuiltinFn::kAny:
+ return "any";
+ case BuiltinFn::kArrayLength:
+ return "arrayLength";
+ case BuiltinFn::kAsin:
+ return "asin";
+ case BuiltinFn::kAsinh:
+ return "asinh";
+ case BuiltinFn::kAtan:
+ return "atan";
+ case BuiltinFn::kAtan2:
+ return "atan2";
+ case BuiltinFn::kAtanh:
+ return "atanh";
+ case BuiltinFn::kCeil:
+ return "ceil";
+ case BuiltinFn::kClamp:
+ return "clamp";
+ case BuiltinFn::kCos:
+ return "cos";
+ case BuiltinFn::kCosh:
+ return "cosh";
+ case BuiltinFn::kCountLeadingZeros:
+ return "countLeadingZeros";
+ case BuiltinFn::kCountOneBits:
+ return "countOneBits";
+ case BuiltinFn::kCountTrailingZeros:
+ return "countTrailingZeros";
+ case BuiltinFn::kCross:
+ return "cross";
+ case BuiltinFn::kDegrees:
+ return "degrees";
+ case BuiltinFn::kDeterminant:
+ return "determinant";
+ case BuiltinFn::kDistance:
+ return "distance";
+ case BuiltinFn::kDot:
+ return "dot";
+ case BuiltinFn::kDot4I8Packed:
+ return "dot4I8Packed";
+ case BuiltinFn::kDot4U8Packed:
+ return "dot4U8Packed";
+ case BuiltinFn::kDpdx:
+ return "dpdx";
+ case BuiltinFn::kDpdxCoarse:
+ return "dpdxCoarse";
+ case BuiltinFn::kDpdxFine:
+ return "dpdxFine";
+ case BuiltinFn::kDpdy:
+ return "dpdy";
+ case BuiltinFn::kDpdyCoarse:
+ return "dpdyCoarse";
+ case BuiltinFn::kDpdyFine:
+ return "dpdyFine";
+ case BuiltinFn::kExp:
+ return "exp";
+ case BuiltinFn::kExp2:
+ return "exp2";
+ case BuiltinFn::kExtractBits:
+ return "extractBits";
+ case BuiltinFn::kFaceForward:
+ return "faceForward";
+ case BuiltinFn::kFirstLeadingBit:
+ return "firstLeadingBit";
+ case BuiltinFn::kFirstTrailingBit:
+ return "firstTrailingBit";
+ case BuiltinFn::kFloor:
+ return "floor";
+ case BuiltinFn::kFma:
+ return "fma";
+ case BuiltinFn::kFract:
+ return "fract";
+ case BuiltinFn::kFrexp:
+ return "frexp";
+ case BuiltinFn::kFwidth:
+ return "fwidth";
+ case BuiltinFn::kFwidthCoarse:
+ return "fwidthCoarse";
+ case BuiltinFn::kFwidthFine:
+ return "fwidthFine";
+ case BuiltinFn::kInsertBits:
+ return "insertBits";
+ case BuiltinFn::kInverseSqrt:
+ return "inverseSqrt";
+ case BuiltinFn::kLdexp:
+ return "ldexp";
+ case BuiltinFn::kLength:
+ return "length";
+ case BuiltinFn::kLog:
+ return "log";
+ case BuiltinFn::kLog2:
+ return "log2";
+ case BuiltinFn::kMax:
+ return "max";
+ case BuiltinFn::kMin:
+ return "min";
+ case BuiltinFn::kMix:
+ return "mix";
+ case BuiltinFn::kModf:
+ return "modf";
+ case BuiltinFn::kNormalize:
+ return "normalize";
+ case BuiltinFn::kPack2X16Float:
+ return "pack2x16float";
+ case BuiltinFn::kPack2X16Snorm:
+ return "pack2x16snorm";
+ case BuiltinFn::kPack2X16Unorm:
+ return "pack2x16unorm";
+ case BuiltinFn::kPack4X8Snorm:
+ return "pack4x8snorm";
+ case BuiltinFn::kPack4X8Unorm:
+ return "pack4x8unorm";
+ case BuiltinFn::kPow:
+ return "pow";
+ case BuiltinFn::kQuantizeToF16:
+ return "quantizeToF16";
+ case BuiltinFn::kRadians:
+ return "radians";
+ case BuiltinFn::kReflect:
+ return "reflect";
+ case BuiltinFn::kRefract:
+ return "refract";
+ case BuiltinFn::kReverseBits:
+ return "reverseBits";
+ case BuiltinFn::kRound:
+ return "round";
+ case BuiltinFn::kSaturate:
+ return "saturate";
+ case BuiltinFn::kSelect:
+ return "select";
+ case BuiltinFn::kSign:
+ return "sign";
+ case BuiltinFn::kSin:
+ return "sin";
+ case BuiltinFn::kSinh:
+ return "sinh";
+ case BuiltinFn::kSmoothstep:
+ return "smoothstep";
+ case BuiltinFn::kSqrt:
+ return "sqrt";
+ case BuiltinFn::kStep:
+ return "step";
+ case BuiltinFn::kStorageBarrier:
+ return "storageBarrier";
+ case BuiltinFn::kTan:
+ return "tan";
+ case BuiltinFn::kTanh:
+ return "tanh";
+ case BuiltinFn::kTranspose:
+ return "transpose";
+ case BuiltinFn::kTrunc:
+ return "trunc";
+ case BuiltinFn::kUnpack2X16Float:
+ return "unpack2x16float";
+ case BuiltinFn::kUnpack2X16Snorm:
+ return "unpack2x16snorm";
+ case BuiltinFn::kUnpack2X16Unorm:
+ return "unpack2x16unorm";
+ case BuiltinFn::kUnpack4X8Snorm:
+ return "unpack4x8snorm";
+ case BuiltinFn::kUnpack4X8Unorm:
+ return "unpack4x8unorm";
+ case BuiltinFn::kWorkgroupBarrier:
+ return "workgroupBarrier";
+ case BuiltinFn::kWorkgroupUniformLoad:
+ return "workgroupUniformLoad";
+ case BuiltinFn::kTextureBarrier:
+ return "textureBarrier";
+ case BuiltinFn::kTextureDimensions:
+ return "textureDimensions";
+ case BuiltinFn::kTextureGather:
+ return "textureGather";
+ case BuiltinFn::kTextureGatherCompare:
+ return "textureGatherCompare";
+ case BuiltinFn::kTextureNumLayers:
+ return "textureNumLayers";
+ case BuiltinFn::kTextureNumLevels:
+ return "textureNumLevels";
+ case BuiltinFn::kTextureNumSamples:
+ return "textureNumSamples";
+ case BuiltinFn::kTextureSample:
+ return "textureSample";
+ case BuiltinFn::kTextureSampleBias:
+ return "textureSampleBias";
+ case BuiltinFn::kTextureSampleCompare:
+ return "textureSampleCompare";
+ case BuiltinFn::kTextureSampleCompareLevel:
+ return "textureSampleCompareLevel";
+ case BuiltinFn::kTextureSampleGrad:
+ return "textureSampleGrad";
+ case BuiltinFn::kTextureSampleLevel:
+ return "textureSampleLevel";
+ case BuiltinFn::kTextureSampleBaseClampToEdge:
+ return "textureSampleBaseClampToEdge";
+ case BuiltinFn::kTextureStore:
+ return "textureStore";
+ case BuiltinFn::kTextureLoad:
+ return "textureLoad";
+ case BuiltinFn::kAtomicLoad:
+ return "atomicLoad";
+ case BuiltinFn::kAtomicStore:
+ return "atomicStore";
+ case BuiltinFn::kAtomicAdd:
+ return "atomicAdd";
+ case BuiltinFn::kAtomicSub:
+ return "atomicSub";
+ case BuiltinFn::kAtomicMax:
+ return "atomicMax";
+ case BuiltinFn::kAtomicMin:
+ return "atomicMin";
+ case BuiltinFn::kAtomicAnd:
+ return "atomicAnd";
+ case BuiltinFn::kAtomicOr:
+ return "atomicOr";
+ case BuiltinFn::kAtomicXor:
+ return "atomicXor";
+ case BuiltinFn::kAtomicExchange:
+ return "atomicExchange";
+ case BuiltinFn::kAtomicCompareExchangeWeak:
+ return "atomicCompareExchangeWeak";
+ case BuiltinFn::kSubgroupBallot:
+ return "subgroupBallot";
+ case BuiltinFn::kSubgroupBroadcast:
+ return "subgroupBroadcast";
+ case BuiltinFn::kTintMaterialize:
+ return "_tint_materialize";
+ }
+ return "<unknown>";
+}
+
+bool IsCoarseDerivative(BuiltinFn f) {
+ return f == BuiltinFn::kDpdxCoarse || f == BuiltinFn::kDpdyCoarse ||
+ f == BuiltinFn::kFwidthCoarse;
+}
+
+bool IsFineDerivative(BuiltinFn f) {
+ return f == BuiltinFn::kDpdxFine || f == BuiltinFn::kDpdyFine || f == BuiltinFn::kFwidthFine;
+}
+
+bool IsDerivative(BuiltinFn f) {
+ return f == BuiltinFn::kDpdx || f == BuiltinFn::kDpdy || f == BuiltinFn::kFwidth ||
+ IsCoarseDerivative(f) || IsFineDerivative(f);
+}
+
+bool IsTexture(BuiltinFn f) {
+ return IsImageQuery(f) || //
+ f == BuiltinFn::kTextureGather || //
+ f == BuiltinFn::kTextureGatherCompare || //
+ f == BuiltinFn::kTextureLoad || //
+ f == BuiltinFn::kTextureSample || //
+ f == BuiltinFn::kTextureSampleBaseClampToEdge || //
+ f == BuiltinFn::kTextureSampleBias || //
+ f == BuiltinFn::kTextureSampleCompare || //
+ f == BuiltinFn::kTextureSampleCompareLevel || //
+ f == BuiltinFn::kTextureSampleGrad || //
+ f == BuiltinFn::kTextureSampleLevel || //
+ f == BuiltinFn::kTextureStore;
+}
+
+bool IsImageQuery(BuiltinFn f) {
+ return f == BuiltinFn::kTextureDimensions || f == BuiltinFn::kTextureNumLayers ||
+ f == BuiltinFn::kTextureNumLevels || f == BuiltinFn::kTextureNumSamples;
+}
+
+bool IsDataPacking(BuiltinFn f) {
+ return f == BuiltinFn::kPack4X8Snorm || f == BuiltinFn::kPack4X8Unorm ||
+ f == BuiltinFn::kPack2X16Snorm || f == BuiltinFn::kPack2X16Unorm ||
+ f == BuiltinFn::kPack2X16Float;
+}
+
+bool IsDataUnpacking(BuiltinFn f) {
+ return f == BuiltinFn::kUnpack4X8Snorm || f == BuiltinFn::kUnpack4X8Unorm ||
+ f == BuiltinFn::kUnpack2X16Snorm || f == BuiltinFn::kUnpack2X16Unorm ||
+ f == BuiltinFn::kUnpack2X16Float;
+}
+
+bool IsBarrier(BuiltinFn f) {
+ return f == BuiltinFn::kWorkgroupBarrier || f == BuiltinFn::kStorageBarrier ||
+ f == BuiltinFn::kTextureBarrier;
+}
+
+bool IsAtomic(BuiltinFn f) {
+ return f == BuiltinFn::kAtomicLoad || f == BuiltinFn::kAtomicStore ||
+ f == BuiltinFn::kAtomicAdd || f == BuiltinFn::kAtomicSub || f == BuiltinFn::kAtomicMax ||
+ f == BuiltinFn::kAtomicMin || f == BuiltinFn::kAtomicAnd || f == BuiltinFn::kAtomicOr ||
+ f == BuiltinFn::kAtomicXor || f == BuiltinFn::kAtomicExchange ||
+ f == BuiltinFn::kAtomicCompareExchangeWeak;
+}
+
+bool IsDP4a(BuiltinFn f) {
+ return f == BuiltinFn::kDot4I8Packed || f == BuiltinFn::kDot4U8Packed;
+}
+
+bool IsSubgroup(BuiltinFn f) {
+ return f == BuiltinFn::kSubgroupBallot || f == BuiltinFn::kSubgroupBroadcast;
+}
+
+bool HasSideEffects(BuiltinFn f) {
+ switch (f) {
+ case BuiltinFn::kAtomicAdd:
+ case BuiltinFn::kAtomicAnd:
+ case BuiltinFn::kAtomicCompareExchangeWeak:
+ case BuiltinFn::kAtomicExchange:
+ case BuiltinFn::kAtomicMax:
+ case BuiltinFn::kAtomicMin:
+ case BuiltinFn::kAtomicOr:
+ case BuiltinFn::kAtomicStore:
+ case BuiltinFn::kAtomicSub:
+ case BuiltinFn::kAtomicXor:
+ case BuiltinFn::kTextureStore:
+ case BuiltinFn::kWorkgroupUniformLoad:
+ return true;
+ default:
+ break;
+ }
+ return false;
+}
+
+} // namespace tint::core
diff --git a/src/tint/lang/core/builtin_fn.cc.tmpl b/src/tint/lang/core/builtin_fn.cc.tmpl
new file mode 100644
index 0000000..5a0d100
--- /dev/null
+++ b/src/tint/lang/core/builtin_fn.cc.tmpl
@@ -0,0 +1,132 @@
+{{- /*
+--------------------------------------------------------------------------------
+Template file for use with tools/src/cmd/gen to generate builtin_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
+--------------------------------------------------------------------------------
+*/ -}}
+
+{{- $I := LoadIntrinsics "src/tint/lang/core/core.def" -}}
+#include "src/tint/lang/core/builtin_fn.h"
+
+namespace tint::core {
+
+BuiltinFn ParseBuiltinFn(std::string_view name) {
+{{- range $I.Sem.Builtins }}
+ if (name == "{{.Name}}") {
+ return BuiltinFn::k{{PascalCase .Name}};
+ }
+{{- end }}
+ return BuiltinFn::kNone;
+}
+
+const char* str(BuiltinFn i) {
+ switch (i) {
+ case BuiltinFn::kNone:
+ return "<none>";
+{{- range $I.Sem.Builtins }}
+ case BuiltinFn::k{{PascalCase .Name}}:
+ return "{{.Name}}";
+{{- end }}
+ }
+ return "<unknown>";
+}
+
+bool IsCoarseDerivative(BuiltinFn f) {
+ return f == BuiltinFn::kDpdxCoarse || f == BuiltinFn::kDpdyCoarse ||
+ f == BuiltinFn::kFwidthCoarse;
+}
+
+bool IsFineDerivative(BuiltinFn f) {
+ return f == BuiltinFn::kDpdxFine || f == BuiltinFn::kDpdyFine ||
+ f == BuiltinFn::kFwidthFine;
+}
+
+bool IsDerivative(BuiltinFn f) {
+ return f == BuiltinFn::kDpdx || f == BuiltinFn::kDpdy ||
+ f == BuiltinFn::kFwidth || IsCoarseDerivative(f) ||
+ IsFineDerivative(f);
+}
+
+bool IsTexture(BuiltinFn f) {
+ return IsImageQuery(f) || //
+ f == BuiltinFn::kTextureGather || //
+ f == BuiltinFn::kTextureGatherCompare || //
+ f == BuiltinFn::kTextureLoad || //
+ f == BuiltinFn::kTextureSample || //
+ f == BuiltinFn::kTextureSampleBaseClampToEdge || //
+ f == BuiltinFn::kTextureSampleBias || //
+ f == BuiltinFn::kTextureSampleCompare || //
+ f == BuiltinFn::kTextureSampleCompareLevel || //
+ f == BuiltinFn::kTextureSampleGrad || //
+ f == BuiltinFn::kTextureSampleLevel || //
+ f == BuiltinFn::kTextureStore;
+}
+
+bool IsImageQuery(BuiltinFn f) {
+ return f == BuiltinFn::kTextureDimensions ||
+ f == BuiltinFn::kTextureNumLayers || f == BuiltinFn::kTextureNumLevels ||
+ f == BuiltinFn::kTextureNumSamples;
+}
+
+bool IsDataPacking(BuiltinFn f) {
+ return f == BuiltinFn::kPack4X8Snorm || f == BuiltinFn::kPack4X8Unorm ||
+ f == BuiltinFn::kPack2X16Snorm || f == BuiltinFn::kPack2X16Unorm ||
+ f == BuiltinFn::kPack2X16Float;
+}
+
+bool IsDataUnpacking(BuiltinFn f) {
+ return f == BuiltinFn::kUnpack4X8Snorm || f == BuiltinFn::kUnpack4X8Unorm ||
+ f == BuiltinFn::kUnpack2X16Snorm || f == BuiltinFn::kUnpack2X16Unorm ||
+ f == BuiltinFn::kUnpack2X16Float;
+}
+
+bool IsBarrier(BuiltinFn f) {
+ return f == BuiltinFn::kWorkgroupBarrier || f == BuiltinFn::kStorageBarrier ||
+ f == BuiltinFn::kTextureBarrier;
+}
+
+bool IsAtomic(BuiltinFn f) {
+ return f == BuiltinFn::kAtomicLoad || f == BuiltinFn::kAtomicStore ||
+ f == BuiltinFn::kAtomicAdd || f == BuiltinFn::kAtomicSub ||
+ f == BuiltinFn::kAtomicMax || f == BuiltinFn::kAtomicMin ||
+ f == BuiltinFn::kAtomicAnd || f == BuiltinFn::kAtomicOr ||
+ f == BuiltinFn::kAtomicXor || f == BuiltinFn::kAtomicExchange ||
+ f == BuiltinFn::kAtomicCompareExchangeWeak;
+}
+
+bool IsDP4a(BuiltinFn f) {
+ return f == BuiltinFn::kDot4I8Packed || f == BuiltinFn::kDot4U8Packed;
+}
+
+bool IsSubgroup(BuiltinFn f) {
+ return f == BuiltinFn::kSubgroupBallot || f == BuiltinFn::kSubgroupBroadcast;
+}
+
+bool HasSideEffects(BuiltinFn f) {
+ switch (f) {
+ case BuiltinFn::kAtomicAdd:
+ case BuiltinFn::kAtomicAnd:
+ case BuiltinFn::kAtomicCompareExchangeWeak:
+ case BuiltinFn::kAtomicExchange:
+ case BuiltinFn::kAtomicMax:
+ case BuiltinFn::kAtomicMin:
+ case BuiltinFn::kAtomicOr:
+ case BuiltinFn::kAtomicStore:
+ case BuiltinFn::kAtomicSub:
+ case BuiltinFn::kAtomicXor:
+ case BuiltinFn::kTextureStore:
+ case BuiltinFn::kWorkgroupUniformLoad:
+ return true;
+ default:
+ break;
+ }
+ return false;
+}
+
+} // namespace tint::core
diff --git a/src/tint/lang/core/function.h b/src/tint/lang/core/builtin_fn.h
similarity index 64%
rename from src/tint/lang/core/function.h
rename to src/tint/lang/core/builtin_fn.h
index e9b52fa..5e58b5e 100644
--- a/src/tint/lang/core/function.h
+++ b/src/tint/lang/core/builtin_fn.h
@@ -14,15 +14,15 @@
////////////////////////////////////////////////////////////////////////////////
// File generated by 'tools/src/cmd/gen' using the template:
-// src/tint/lang/core/function.h.tmpl
+// src/tint/lang/core/builtin_fn.h.tmpl
//
// To regenerate run: './tools/run gen'
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
-#ifndef SRC_TINT_LANG_CORE_FUNCTION_H_
-#define SRC_TINT_LANG_CORE_FUNCTION_H_
+#ifndef SRC_TINT_LANG_CORE_BUILTIN_FN_H_
+#define SRC_TINT_LANG_CORE_BUILTIN_FN_H_
#include <cstdint>
#include <string>
@@ -33,7 +33,7 @@
namespace tint::core {
/// Enumerator of all builtin functions
-enum class Function : uint8_t {
+enum class BuiltinFn : uint8_t {
kAbs,
kAcos,
kAcosh,
@@ -154,146 +154,146 @@
kNone,
};
-/// Matches the Function by name
+/// Matches the BuiltinFn by name
/// @param name the builtin name to parse
-/// @returns the parsed Function, or Function::kNone if `name` did not
+/// @returns the parsed BuiltinFn, or BuiltinFn::kNone if `name` did not
/// match any builtin function.
-Function ParseFunction(std::string_view name);
+BuiltinFn ParseBuiltinFn(std::string_view 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);
+const char* str(BuiltinFn i);
/// Emits the name of the builtin function type. The spelling, including case,
/// matches the name in the WGSL spec.
template <typename STREAM, typename = traits::EnableIfIsOStream<STREAM>>
-auto& operator<<(STREAM& o, Function i) {
+auto& operator<<(STREAM& o, BuiltinFn i) {
return o << str(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::kTextureBarrier,
- 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::kSubgroupBallot,
- Function::kSubgroupBroadcast,
- Function::kTintMaterialize,
+constexpr BuiltinFn kBuiltinFns[] = {
+ BuiltinFn::kAbs,
+ BuiltinFn::kAcos,
+ BuiltinFn::kAcosh,
+ BuiltinFn::kAll,
+ BuiltinFn::kAny,
+ BuiltinFn::kArrayLength,
+ BuiltinFn::kAsin,
+ BuiltinFn::kAsinh,
+ BuiltinFn::kAtan,
+ BuiltinFn::kAtan2,
+ BuiltinFn::kAtanh,
+ BuiltinFn::kCeil,
+ BuiltinFn::kClamp,
+ BuiltinFn::kCos,
+ BuiltinFn::kCosh,
+ BuiltinFn::kCountLeadingZeros,
+ BuiltinFn::kCountOneBits,
+ BuiltinFn::kCountTrailingZeros,
+ BuiltinFn::kCross,
+ BuiltinFn::kDegrees,
+ BuiltinFn::kDeterminant,
+ BuiltinFn::kDistance,
+ BuiltinFn::kDot,
+ BuiltinFn::kDot4I8Packed,
+ BuiltinFn::kDot4U8Packed,
+ BuiltinFn::kDpdx,
+ BuiltinFn::kDpdxCoarse,
+ BuiltinFn::kDpdxFine,
+ BuiltinFn::kDpdy,
+ BuiltinFn::kDpdyCoarse,
+ BuiltinFn::kDpdyFine,
+ BuiltinFn::kExp,
+ BuiltinFn::kExp2,
+ BuiltinFn::kExtractBits,
+ BuiltinFn::kFaceForward,
+ BuiltinFn::kFirstLeadingBit,
+ BuiltinFn::kFirstTrailingBit,
+ BuiltinFn::kFloor,
+ BuiltinFn::kFma,
+ BuiltinFn::kFract,
+ BuiltinFn::kFrexp,
+ BuiltinFn::kFwidth,
+ BuiltinFn::kFwidthCoarse,
+ BuiltinFn::kFwidthFine,
+ BuiltinFn::kInsertBits,
+ BuiltinFn::kInverseSqrt,
+ BuiltinFn::kLdexp,
+ BuiltinFn::kLength,
+ BuiltinFn::kLog,
+ BuiltinFn::kLog2,
+ BuiltinFn::kMax,
+ BuiltinFn::kMin,
+ BuiltinFn::kMix,
+ BuiltinFn::kModf,
+ BuiltinFn::kNormalize,
+ BuiltinFn::kPack2X16Float,
+ BuiltinFn::kPack2X16Snorm,
+ BuiltinFn::kPack2X16Unorm,
+ BuiltinFn::kPack4X8Snorm,
+ BuiltinFn::kPack4X8Unorm,
+ BuiltinFn::kPow,
+ BuiltinFn::kQuantizeToF16,
+ BuiltinFn::kRadians,
+ BuiltinFn::kReflect,
+ BuiltinFn::kRefract,
+ BuiltinFn::kReverseBits,
+ BuiltinFn::kRound,
+ BuiltinFn::kSaturate,
+ BuiltinFn::kSelect,
+ BuiltinFn::kSign,
+ BuiltinFn::kSin,
+ BuiltinFn::kSinh,
+ BuiltinFn::kSmoothstep,
+ BuiltinFn::kSqrt,
+ BuiltinFn::kStep,
+ BuiltinFn::kStorageBarrier,
+ BuiltinFn::kTan,
+ BuiltinFn::kTanh,
+ BuiltinFn::kTranspose,
+ BuiltinFn::kTrunc,
+ BuiltinFn::kUnpack2X16Float,
+ BuiltinFn::kUnpack2X16Snorm,
+ BuiltinFn::kUnpack2X16Unorm,
+ BuiltinFn::kUnpack4X8Snorm,
+ BuiltinFn::kUnpack4X8Unorm,
+ BuiltinFn::kWorkgroupBarrier,
+ BuiltinFn::kWorkgroupUniformLoad,
+ BuiltinFn::kTextureBarrier,
+ BuiltinFn::kTextureDimensions,
+ BuiltinFn::kTextureGather,
+ BuiltinFn::kTextureGatherCompare,
+ BuiltinFn::kTextureNumLayers,
+ BuiltinFn::kTextureNumLevels,
+ BuiltinFn::kTextureNumSamples,
+ BuiltinFn::kTextureSample,
+ BuiltinFn::kTextureSampleBias,
+ BuiltinFn::kTextureSampleCompare,
+ BuiltinFn::kTextureSampleCompareLevel,
+ BuiltinFn::kTextureSampleGrad,
+ BuiltinFn::kTextureSampleLevel,
+ BuiltinFn::kTextureSampleBaseClampToEdge,
+ BuiltinFn::kTextureStore,
+ BuiltinFn::kTextureLoad,
+ BuiltinFn::kAtomicLoad,
+ BuiltinFn::kAtomicStore,
+ BuiltinFn::kAtomicAdd,
+ BuiltinFn::kAtomicSub,
+ BuiltinFn::kAtomicMax,
+ BuiltinFn::kAtomicMin,
+ BuiltinFn::kAtomicAnd,
+ BuiltinFn::kAtomicOr,
+ BuiltinFn::kAtomicXor,
+ BuiltinFn::kAtomicExchange,
+ BuiltinFn::kAtomicCompareExchangeWeak,
+ BuiltinFn::kSubgroupBallot,
+ BuiltinFn::kSubgroupBroadcast,
+ BuiltinFn::kTintMaterialize,
};
/// All builtin function names
-constexpr const char* kFunctionStrings[] = {
+constexpr const char* kBuiltinFnStrings[] = {
"abs",
"acos",
"acosh",
@@ -416,63 +416,63 @@
/// Determines if the given `f` is a coarse derivative.
/// @param f the builtin type
/// @returns true if the given derivative is coarse.
-bool IsCoarseDerivativeBuiltin(Function f);
+bool IsCoarseDerivative(BuiltinFn f);
/// Determines if the given `f` is a fine derivative.
/// @param f the builtin type
/// @returns true if the given derivative is fine.
-bool IsFineDerivativeBuiltin(Function f);
+bool IsFineDerivative(BuiltinFn f);
/// Determine if the given `f` is a derivative builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a derivative builtin
-bool IsDerivativeBuiltin(Function f);
+bool IsDerivative(BuiltinFn f);
/// Determines if the given `f` is a texture operation builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a texture operation builtin
-bool IsTextureBuiltin(Function f);
+bool IsTexture(BuiltinFn f);
/// Determines if the given `f` is an image query builtin.
/// @param f the builtin type
/// @returns true if the given `f` is an image query builtin
-bool IsImageQueryBuiltin(Function f);
+bool IsImageQuery(BuiltinFn f);
/// Determines if the given `f` is a data packing builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a data packing builtin
-bool IsDataPackingBuiltin(Function f);
+bool IsDataPacking(BuiltinFn f);
/// Determines if the given `f` is a data unpacking builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a data unpacking builtin
-bool IsDataUnpackingBuiltin(Function f);
+bool IsDataUnpacking(BuiltinFn f);
/// Determines if the given `f` is a barrier builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a barrier builtin
-bool IsBarrierBuiltin(Function f);
+bool IsBarrier(BuiltinFn f);
/// Determines if the given `f` is an atomic builtin.
/// @param f the builtin type
/// @returns true if the given `f` is an atomic builtin
-bool IsAtomicBuiltin(Function f);
+bool IsAtomic(BuiltinFn f);
/// Determines if the given `f` is a DP4a builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a DP4a builtin
-bool IsDP4aBuiltin(Function f);
+bool IsDP4a(BuiltinFn f);
/// Determines if the given `f` is a subgroup builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a subgroup builtin
-bool IsSubgroupBuiltin(Function f);
+bool IsSubgroup(BuiltinFn f);
/// Determines if the given `f` may have side-effects (i.e. writes to at least one of its inputs)
/// @returns true if intrinsic may have side-effects
-bool HasSideEffects(Function f);
+bool HasSideEffects(BuiltinFn f);
} // namespace tint::core
// \endcond
-#endif // SRC_TINT_LANG_CORE_FUNCTION_H_
+#endif // SRC_TINT_LANG_CORE_BUILTIN_FN_H_
diff --git a/src/tint/lang/core/function.h.tmpl b/src/tint/lang/core/builtin_fn.h.tmpl
similarity index 75%
rename from src/tint/lang/core/function.h.tmpl
rename to src/tint/lang/core/builtin_fn.h.tmpl
index 546b385..3a10674 100644
--- a/src/tint/lang/core/function.h.tmpl
+++ b/src/tint/lang/core/builtin_fn.h.tmpl
@@ -1,6 +1,6 @@
{{- /*
--------------------------------------------------------------------------------
-Template file for use with tools/src/cmd/gen to generate function.h
+Template file for use with tools/src/cmd/gen to generate builtin_function.h
To update the generated file, run:
./tools/run gen
@@ -13,8 +13,8 @@
{{- $I := LoadIntrinsics "src/tint/lang/core/core.def" -}}
-#ifndef SRC_TINT_LANG_CORE_FUNCTION_H_
-#define SRC_TINT_LANG_CORE_FUNCTION_H_
+#ifndef SRC_TINT_LANG_CORE_BUILTIN_FN_H_
+#define SRC_TINT_LANG_CORE_BUILTIN_FN_H_
#include <cstdint>
#include <string>
@@ -25,39 +25,39 @@
namespace tint::core {
/// Enumerator of all builtin functions
-enum class Function : uint8_t {
+enum class BuiltinFn : uint8_t {
{{- range $I.Sem.Builtins }}
k{{PascalCase .Name}},
{{- end }}
kNone,
};
-/// Matches the Function by name
+/// Matches the BuiltinFn by name
/// @param name the builtin name to parse
-/// @returns the parsed Function, or Function::kNone if `name` did not
+/// @returns the parsed BuiltinFn, or BuiltinFn::kNone if `name` did not
/// match any builtin function.
-Function ParseFunction(std::string_view name);
+BuiltinFn ParseBuiltinFn(std::string_view 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);
+const char* str(BuiltinFn i);
/// Emits the name of the builtin function type. The spelling, including case,
/// matches the name in the WGSL spec.
template <typename STREAM, typename = traits::EnableIfIsOStream<STREAM>>
-auto& operator<<(STREAM& o, Function i) {
+auto& operator<<(STREAM& o, BuiltinFn i) {
return o << str(i);
}
/// All builtin functions
-constexpr Function kFunctions[] = {
+constexpr BuiltinFn kBuiltinFns[] = {
{{- range $I.Sem.Builtins }}
- Function::k{{PascalCase .Name}},
+ BuiltinFn::k{{PascalCase .Name}},
{{- end }}
};
/// All builtin function names
-constexpr const char* kFunctionStrings[] = {
+constexpr const char* kBuiltinFnStrings[] = {
{{- range $I.Sem.Builtins }}
"{{.Name}}",
{{- end }}
@@ -66,63 +66,63 @@
/// Determines if the given `f` is a coarse derivative.
/// @param f the builtin type
/// @returns true if the given derivative is coarse.
-bool IsCoarseDerivativeBuiltin(Function f);
+bool IsCoarseDerivative(BuiltinFn f);
/// Determines if the given `f` is a fine derivative.
/// @param f the builtin type
/// @returns true if the given derivative is fine.
-bool IsFineDerivativeBuiltin(Function f);
+bool IsFineDerivative(BuiltinFn f);
/// Determine if the given `f` is a derivative builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a derivative builtin
-bool IsDerivativeBuiltin(Function f);
+bool IsDerivative(BuiltinFn f);
/// Determines if the given `f` is a texture operation builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a texture operation builtin
-bool IsTextureBuiltin(Function f);
+bool IsTexture(BuiltinFn f);
/// Determines if the given `f` is an image query builtin.
/// @param f the builtin type
/// @returns true if the given `f` is an image query builtin
-bool IsImageQueryBuiltin(Function f);
+bool IsImageQuery(BuiltinFn f);
/// Determines if the given `f` is a data packing builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a data packing builtin
-bool IsDataPackingBuiltin(Function f);
+bool IsDataPacking(BuiltinFn f);
/// Determines if the given `f` is a data unpacking builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a data unpacking builtin
-bool IsDataUnpackingBuiltin(Function f);
+bool IsDataUnpacking(BuiltinFn f);
/// Determines if the given `f` is a barrier builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a barrier builtin
-bool IsBarrierBuiltin(Function f);
+bool IsBarrier(BuiltinFn f);
/// Determines if the given `f` is an atomic builtin.
/// @param f the builtin type
/// @returns true if the given `f` is an atomic builtin
-bool IsAtomicBuiltin(Function f);
+bool IsAtomic(BuiltinFn f);
/// Determines if the given `f` is a DP4a builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a DP4a builtin
-bool IsDP4aBuiltin(Function f);
+bool IsDP4a(BuiltinFn f);
/// Determines if the given `f` is a subgroup builtin.
/// @param f the builtin type
/// @returns true if the given `f` is a subgroup builtin
-bool IsSubgroupBuiltin(Function f);
+bool IsSubgroup(BuiltinFn f);
/// Determines if the given `f` may have side-effects (i.e. writes to at least one of its inputs)
/// @returns true if intrinsic may have side-effects
-bool HasSideEffects(Function f);
+bool HasSideEffects(BuiltinFn f);
} // namespace tint::core
// \endcond
-#endif // SRC_TINT_LANG_CORE_FUNCTION_H_
+#endif // SRC_TINT_LANG_CORE_BUILTIN_FN_H_
diff --git a/src/tint/lang/core/constant/eval_builtin_test.cc b/src/tint/lang/core/constant/eval_builtin_test.cc
index 6a31120..cca292d 100644
--- a/src/tint/lang/core/constant/eval_builtin_test.cc
+++ b/src/tint/lang/core/constant/eval_builtin_test.cc
@@ -139,7 +139,7 @@
return Case{std::move(args), std::move(err)};
}
-using ConstEvalBuiltinTest = ConstEvalTestWithParam<std::tuple<core::Function, Case>>;
+using ConstEvalBuiltinTest = ConstEvalTestWithParam<std::tuple<core::BuiltinFn, Case>>;
TEST_P(ConstEvalBuiltinTest, Test) {
Enable(wgsl::Extension::kF16);
@@ -186,7 +186,7 @@
INSTANTIATE_TEST_SUITE_P(MixedAbstractArgs_Atan2,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kAtan2),
+ testing::Combine(testing::Values(core::BuiltinFn::kAtan2),
testing::ValuesIn(std::vector{
C({0.0_a, 1_a}, AFloat{0}),
C({0_a, 1.0_a}, AFloat{0}),
@@ -196,7 +196,7 @@
INSTANTIATE_TEST_SUITE_P(MixedAbstractArgs_Max,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kMax),
+ testing::Combine(testing::Values(core::BuiltinFn::kMax),
testing::ValuesIn(std::vector{
// AbstractInt first, AbstractFloat second
C({1_a, 2.0_a}, AFloat{2}),
@@ -247,7 +247,7 @@
INSTANTIATE_TEST_SUITE_P( //
Abs,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kAbs),
+ testing::Combine(testing::Values(core::BuiltinFn::kAbs),
testing::ValuesIn(Concat(AbsCases<AInt>(), //
AbsCases<i32>(),
AbsCases<u32>(),
@@ -282,7 +282,7 @@
INSTANTIATE_TEST_SUITE_P( //
All,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kAll), testing::ValuesIn(AllCases())));
+ testing::Combine(testing::Values(core::BuiltinFn::kAll), testing::ValuesIn(AllCases())));
static std::vector<Case> AnyCases() {
return {
@@ -311,7 +311,7 @@
INSTANTIATE_TEST_SUITE_P( //
Any,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kAny), testing::ValuesIn(AnyCases())));
+ testing::Combine(testing::Values(core::BuiltinFn::kAny), testing::ValuesIn(AnyCases())));
template <typename T>
std::vector<Case> Atan2Cases() {
@@ -346,7 +346,7 @@
INSTANTIATE_TEST_SUITE_P( //
Atan2,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kAtan2),
+ testing::Combine(testing::Values(core::BuiltinFn::kAtan2),
testing::ValuesIn(Concat(Atan2Cases<AFloat>(), //
Atan2Cases<f32>(),
Atan2Cases<f16>()))));
@@ -367,7 +367,7 @@
INSTANTIATE_TEST_SUITE_P( //
Atan,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kAtan),
+ testing::Combine(testing::Values(core::BuiltinFn::kAtan),
testing::ValuesIn(Concat(AtanCases<AFloat>(), //
AtanCases<f32>(),
AtanCases<f16>()))));
@@ -392,7 +392,7 @@
INSTANTIATE_TEST_SUITE_P( //
Atanh,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kAtanh),
+ testing::Combine(testing::Values(core::BuiltinFn::kAtanh),
testing::ValuesIn(Concat(AtanhCases<AFloat>(), //
AtanhCases<f32>(),
AtanhCases<f16>()))));
@@ -418,7 +418,7 @@
INSTANTIATE_TEST_SUITE_P( //
Acos,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kAcos),
+ testing::Combine(testing::Values(core::BuiltinFn::kAcos),
testing::ValuesIn(Concat(AcosCases<AFloat>(), //
AcosCases<f32>(),
AcosCases<f16>()))));
@@ -440,7 +440,7 @@
INSTANTIATE_TEST_SUITE_P( //
Acosh,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kAcosh),
+ testing::Combine(testing::Values(core::BuiltinFn::kAcosh),
testing::ValuesIn(Concat(AcoshCases<AFloat>(), //
AcoshCases<f32>(),
AcoshCases<f16>()))));
@@ -467,7 +467,7 @@
INSTANTIATE_TEST_SUITE_P( //
Asin,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kAsin),
+ testing::Combine(testing::Values(core::BuiltinFn::kAsin),
testing::ValuesIn(Concat(AsinCases<AFloat>(), //
AsinCases<f32>(),
AsinCases<f16>()))));
@@ -491,7 +491,7 @@
INSTANTIATE_TEST_SUITE_P( //
Asinh,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kAsinh),
+ testing::Combine(testing::Values(core::BuiltinFn::kAsinh),
testing::ValuesIn(Concat(AsinhCases<AFloat>(), //
AsinhCases<f32>(),
AsinhCases<f16>()))));
@@ -513,7 +513,7 @@
Ceil,
ConstEvalBuiltinTest,
testing::Combine(
- testing::Values(core::Function::kCeil),
+ testing::Values(core::BuiltinFn::kCeil),
testing::ValuesIn(Concat(CeilCases<AFloat>(), CeilCases<f32>(), CeilCases<f16>()))));
template <typename T>
@@ -558,7 +558,7 @@
INSTANTIATE_TEST_SUITE_P( //
Clamp,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kClamp),
+ testing::Combine(testing::Values(core::BuiltinFn::kClamp),
testing::ValuesIn(Concat(ClampCases<AInt>(), //
ClampCases<i32>(),
ClampCases<u32>(),
@@ -581,7 +581,7 @@
INSTANTIATE_TEST_SUITE_P( //
Cos,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kCos),
+ testing::Combine(testing::Values(core::BuiltinFn::kCos),
testing::ValuesIn(Concat(CosCases<AFloat>(), //
CosCases<f32>(),
CosCases<f16>()))));
@@ -607,7 +607,7 @@
INSTANTIATE_TEST_SUITE_P( //
Cosh,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kCosh),
+ testing::Combine(testing::Values(core::BuiltinFn::kCosh),
testing::ValuesIn(Concat(CoshCases<AFloat>(), //
CoshCases<f32>(),
CoshCases<f16>()))));
@@ -654,7 +654,7 @@
INSTANTIATE_TEST_SUITE_P( //
CountLeadingZeros,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kCountLeadingZeros),
+ testing::Combine(testing::Values(core::BuiltinFn::kCountLeadingZeros),
testing::ValuesIn(Concat(CountLeadingZerosCases<i32>(), //
CountLeadingZerosCases<u32>()))));
@@ -700,7 +700,7 @@
INSTANTIATE_TEST_SUITE_P( //
CountTrailingZeros,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kCountTrailingZeros),
+ testing::Combine(testing::Values(core::BuiltinFn::kCountTrailingZeros),
testing::ValuesIn(Concat(CountTrailingZerosCases<i32>(), //
CountTrailingZerosCases<u32>()))));
@@ -737,7 +737,7 @@
INSTANTIATE_TEST_SUITE_P( //
CountOneBits,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kCountOneBits),
+ testing::Combine(testing::Values(core::BuiltinFn::kCountOneBits),
testing::ValuesIn(Concat(CountOneBitsCases<i32>(), //
CountOneBitsCases<u32>()))));
@@ -836,7 +836,7 @@
INSTANTIATE_TEST_SUITE_P( //
Cross,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kCross),
+ testing::Combine(testing::Values(core::BuiltinFn::kCross),
testing::ValuesIn(Concat(CrossCases<AFloat>(), //
CrossCases<f32>(), //
CrossCases<f16>()))));
@@ -863,7 +863,7 @@
INSTANTIATE_TEST_SUITE_P( //
Distance,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kDistance),
+ testing::Combine(testing::Values(core::BuiltinFn::kDistance),
testing::ValuesIn(Concat(DistanceCases<AFloat>(), //
DistanceCases<f32>(), //
DistanceCases<f16>()))));
@@ -911,7 +911,7 @@
INSTANTIATE_TEST_SUITE_P( //
Dot,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kDot),
+ testing::Combine(testing::Values(core::BuiltinFn::kDot),
testing::ValuesIn(Concat(DotCases<AInt>(), //
DotCases<i32>(), //
DotCases<u32>(), //
@@ -991,7 +991,7 @@
INSTANTIATE_TEST_SUITE_P( //
Determinant,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kDeterminant),
+ testing::Combine(testing::Values(core::BuiltinFn::kDeterminant),
testing::ValuesIn(Concat(DeterminantCases<AFloat>(), //
DeterminantCases<f32>(), //
DeterminantCases<f16>()))));
@@ -1073,7 +1073,7 @@
INSTANTIATE_TEST_SUITE_P( //
FaceForward,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kFaceForward),
+ testing::Combine(testing::Values(core::BuiltinFn::kFaceForward),
testing::ValuesIn(Concat(FaceForwardCases<AFloat>(), //
FaceForwardCases<f32>(), //
FaceForwardCases<f16>()))));
@@ -1136,7 +1136,7 @@
INSTANTIATE_TEST_SUITE_P( //
FirstLeadingBit,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kFirstLeadingBit),
+ testing::Combine(testing::Values(core::BuiltinFn::kFirstLeadingBit),
testing::ValuesIn(Concat(FirstLeadingBitCases<i32>(), //
FirstLeadingBitCases<u32>()))));
@@ -1169,7 +1169,7 @@
INSTANTIATE_TEST_SUITE_P( //
FirstTrailingBit,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kFirstTrailingBit),
+ testing::Combine(testing::Values(core::BuiltinFn::kFirstTrailingBit),
testing::ValuesIn(Concat(FirstTrailingBitCases<i32>(), //
FirstTrailingBitCases<u32>()))));
@@ -1189,7 +1189,7 @@
INSTANTIATE_TEST_SUITE_P( //
Floor,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kFloor),
+ testing::Combine(testing::Values(core::BuiltinFn::kFloor),
testing::ValuesIn(Concat(FloorCases<AFloat>(), //
FloorCases<f32>(),
FloorCases<f16>()))));
@@ -1213,7 +1213,7 @@
INSTANTIATE_TEST_SUITE_P( //
Fma,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kFma),
+ testing::Combine(testing::Values(core::BuiltinFn::kFma),
testing::ValuesIn(Concat(FmaCases<AFloat>(), //
FmaCases<f32>(),
FmaCases<f16>()))));
@@ -1245,7 +1245,7 @@
INSTANTIATE_TEST_SUITE_P( //
Fract,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kFract),
+ testing::Combine(testing::Values(core::BuiltinFn::kFract),
testing::ValuesIn(Concat(FractCases<AFloat>(), //
FractCases<f32>(),
FractCases<f16>()))));
@@ -1302,7 +1302,7 @@
INSTANTIATE_TEST_SUITE_P( //
Frexp,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kFrexp),
+ testing::Combine(testing::Values(core::BuiltinFn::kFrexp),
testing::ValuesIn(Concat(FrexpCases<AFloat>(), //
FrexpCases<f32>(), //
FrexpCases<f16>()))));
@@ -1384,7 +1384,7 @@
INSTANTIATE_TEST_SUITE_P( //
InsertBits,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kInsertBits),
+ testing::Combine(testing::Values(core::BuiltinFn::kInsertBits),
testing::ValuesIn(Concat(InsertBitsCases<i32>(), //
InsertBitsCases<u32>()))));
@@ -1404,7 +1404,7 @@
INSTANTIATE_TEST_SUITE_P( //
InverseSqrt,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kInverseSqrt),
+ testing::Combine(testing::Values(core::BuiltinFn::kInverseSqrt),
testing::ValuesIn(Concat(InverseSqrtCases<AFloat>(), //
InverseSqrtCases<f32>(),
InverseSqrtCases<f16>()))));
@@ -1423,7 +1423,7 @@
INSTANTIATE_TEST_SUITE_P( //
DegreesAFloat,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kDegrees),
+ testing::Combine(testing::Values(core::BuiltinFn::kDegrees),
testing::ValuesIn(DegreesAFloatCases<AFloat>())));
template <typename T>
@@ -1440,7 +1440,7 @@
INSTANTIATE_TEST_SUITE_P( //
DegreesF32,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kDegrees),
+ testing::Combine(testing::Values(core::BuiltinFn::kDegrees),
testing::ValuesIn(DegreesF32Cases<f32>())));
template <typename T>
@@ -1457,7 +1457,7 @@
INSTANTIATE_TEST_SUITE_P( //
DegreesF16,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kDegrees),
+ testing::Combine(testing::Values(core::BuiltinFn::kDegrees),
testing::ValuesIn(DegreesF16Cases<f16>())));
template <typename T>
@@ -1474,7 +1474,7 @@
INSTANTIATE_TEST_SUITE_P( //
Exp,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kExp),
+ testing::Combine(testing::Values(core::BuiltinFn::kExp),
testing::ValuesIn(Concat(ExpCases<AFloat>(), //
ExpCases<f32>(),
ExpCases<f16>()))));
@@ -1495,7 +1495,7 @@
INSTANTIATE_TEST_SUITE_P( //
Exp2,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kExp2),
+ testing::Combine(testing::Values(core::BuiltinFn::kExp2),
testing::ValuesIn(Concat(Exp2Cases<AFloat>(), //
Exp2Cases<f32>(),
Exp2Cases<f16>()))));
@@ -1592,7 +1592,7 @@
INSTANTIATE_TEST_SUITE_P( //
ExtractBits,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kExtractBits),
+ testing::Combine(testing::Values(core::BuiltinFn::kExtractBits),
testing::ValuesIn(Concat(ExtractBitsCases<i32>(), //
ExtractBitsCases<u32>()))));
@@ -1656,7 +1656,7 @@
INSTANTIATE_TEST_SUITE_P( //
Ldexp,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kLdexp),
+ testing::Combine(testing::Values(core::BuiltinFn::kLdexp),
testing::ValuesIn(Concat(LdexpCases<AFloat>(), //
LdexpCases<f32>(),
LdexpCases<f16>()))));
@@ -1715,7 +1715,7 @@
INSTANTIATE_TEST_SUITE_P( //
Length,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kLength),
+ testing::Combine(testing::Values(core::BuiltinFn::kLength),
testing::ValuesIn(Concat(LengthCases<AFloat>(), //
LengthCases<f32>(),
LengthCases<f16>()))));
@@ -1731,7 +1731,7 @@
INSTANTIATE_TEST_SUITE_P( //
Log,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kLog),
+ testing::Combine(testing::Values(core::BuiltinFn::kLog),
testing::ValuesIn(Concat(LogCases<AFloat>(), //
LogCases<f32>(),
LogCases<f16>()))));
@@ -1744,7 +1744,8 @@
INSTANTIATE_TEST_SUITE_P( //
LogF16,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kLog), testing::ValuesIn(LogF16Cases<f16>())));
+ testing::Combine(testing::Values(core::BuiltinFn::kLog),
+ testing::ValuesIn(LogF16Cases<f16>())));
template <typename T>
std::vector<Case> LogF32Cases() {
return {
@@ -1754,7 +1755,8 @@
INSTANTIATE_TEST_SUITE_P( //
LogF32,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kLog), testing::ValuesIn(LogF32Cases<f32>())));
+ testing::Combine(testing::Values(core::BuiltinFn::kLog),
+ testing::ValuesIn(LogF32Cases<f32>())));
template <typename T>
std::vector<Case> LogAbstractCases() {
@@ -1765,7 +1767,7 @@
INSTANTIATE_TEST_SUITE_P( //
LogAbstract,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kLog),
+ testing::Combine(testing::Values(core::BuiltinFn::kLog),
testing::ValuesIn(LogAbstractCases<AFloat>())));
template <typename T>
@@ -1783,7 +1785,7 @@
INSTANTIATE_TEST_SUITE_P( //
Log2,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kLog2),
+ testing::Combine(testing::Values(core::BuiltinFn::kLog2),
testing::ValuesIn(Concat(Log2Cases<AFloat>(), //
Log2Cases<f32>(),
Log2Cases<f16>()))));
@@ -1796,7 +1798,7 @@
INSTANTIATE_TEST_SUITE_P( //
Log2F16,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kLog2),
+ testing::Combine(testing::Values(core::BuiltinFn::kLog2),
testing::ValuesIn(Log2F16Cases<f16>())));
template <typename T>
std::vector<Case> Log2F32Cases() {
@@ -1807,7 +1809,7 @@
INSTANTIATE_TEST_SUITE_P( //
Log2F32,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kLog2),
+ testing::Combine(testing::Values(core::BuiltinFn::kLog2),
testing::ValuesIn(Log2F32Cases<f32>())));
template <typename T>
std::vector<Case> Log2AbstractCases() {
@@ -1818,7 +1820,7 @@
INSTANTIATE_TEST_SUITE_P( //
Log2Abstract,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kLog2),
+ testing::Combine(testing::Values(core::BuiltinFn::kLog2),
testing::ValuesIn(Log2AbstractCases<AFloat>())));
template <typename T>
@@ -1841,7 +1843,7 @@
INSTANTIATE_TEST_SUITE_P( //
Max,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kMax),
+ testing::Combine(testing::Values(core::BuiltinFn::kMax),
testing::ValuesIn(Concat(MaxCases<AInt>(), //
MaxCases<i32>(),
MaxCases<u32>(),
@@ -1867,7 +1869,7 @@
INSTANTIATE_TEST_SUITE_P( //
Min,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kMin),
+ testing::Combine(testing::Values(core::BuiltinFn::kMin),
testing::ValuesIn(Concat(MinCases<AInt>(), //
MinCases<i32>(),
MinCases<u32>(),
@@ -1957,7 +1959,7 @@
INSTANTIATE_TEST_SUITE_P( //
Mix,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kMix),
+ testing::Combine(testing::Values(core::BuiltinFn::kMix),
testing::ValuesIn(Concat(MixCases<AFloat>(), //
MixCases<f32>(), //
MixCases<f16>()))));
@@ -1991,7 +1993,7 @@
INSTANTIATE_TEST_SUITE_P( //
Modf,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kModf),
+ testing::Combine(testing::Values(core::BuiltinFn::kModf),
testing::ValuesIn(Concat(ModfCases<AFloat>(), //
ModfCases<f32>(), //
ModfCases<f16>()))));
@@ -2021,7 +2023,7 @@
INSTANTIATE_TEST_SUITE_P( //
Normalize,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kNormalize),
+ testing::Combine(testing::Values(core::BuiltinFn::kNormalize),
testing::ValuesIn(Concat(NormalizeCases<AFloat>(), //
NormalizeCases<f32>(), //
NormalizeCases<f16>()))));
@@ -2041,7 +2043,7 @@
INSTANTIATE_TEST_SUITE_P( //
Pack4x8snorm,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kPack4X8Snorm),
+ testing::Combine(testing::Values(core::BuiltinFn::kPack4X8Snorm),
testing::ValuesIn(Pack4x8snormCases())));
std::vector<Case> Pack4x8unormCases() {
@@ -2058,7 +2060,7 @@
INSTANTIATE_TEST_SUITE_P( //
Pack4x8unorm,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kPack4X8Unorm),
+ testing::Combine(testing::Values(core::BuiltinFn::kPack4X8Unorm),
testing::ValuesIn(Pack4x8unormCases())));
std::vector<Case> Pack2x16floatCases() {
@@ -2079,7 +2081,7 @@
INSTANTIATE_TEST_SUITE_P( //
Pack2x16float,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kPack2X16Float),
+ testing::Combine(testing::Values(core::BuiltinFn::kPack2X16Float),
testing::ValuesIn(Pack2x16floatCases())));
std::vector<Case> Pack2x16snormCases() {
@@ -2097,7 +2099,7 @@
INSTANTIATE_TEST_SUITE_P( //
Pack2x16snorm,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kPack2X16Snorm),
+ testing::Combine(testing::Values(core::BuiltinFn::kPack2X16Snorm),
testing::ValuesIn(Pack2x16snormCases())));
std::vector<Case> Pack2x16unormCases() {
@@ -2111,7 +2113,7 @@
INSTANTIATE_TEST_SUITE_P( //
Pack2x16unorm,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kPack2X16Unorm),
+ testing::Combine(testing::Values(core::BuiltinFn::kPack2X16Unorm),
testing::ValuesIn(Pack2x16unormCases())));
template <typename T>
@@ -2157,7 +2159,7 @@
INSTANTIATE_TEST_SUITE_P( //
Pow,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kPow),
+ testing::Combine(testing::Values(core::BuiltinFn::kPow),
testing::ValuesIn(Concat(PowCases<AFloat>(), //
PowCases<f32>(), //
PowCases<f16>()))));
@@ -2204,7 +2206,7 @@
INSTANTIATE_TEST_SUITE_P( //
ReverseBits,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kReverseBits),
+ testing::Combine(testing::Values(core::BuiltinFn::kReverseBits),
testing::ValuesIn(Concat(ReverseBitsCases<i32>(), //
ReverseBitsCases<u32>()))));
@@ -2256,7 +2258,7 @@
INSTANTIATE_TEST_SUITE_P( //
Reflect,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kReflect),
+ testing::Combine(testing::Values(core::BuiltinFn::kReflect),
testing::ValuesIn(Concat(ReflectCases<AFloat>(), //
ReflectCases<f32>(), //
ReflectCases<f16>()))));
@@ -2346,7 +2348,7 @@
INSTANTIATE_TEST_SUITE_P( //
Refract,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kRefract),
+ testing::Combine(testing::Values(core::BuiltinFn::kRefract),
testing::ValuesIn(Concat(RefractCases<AFloat>(), //
RefractCases<f32>(), //
RefractCases<f16>()))));
@@ -2365,7 +2367,7 @@
INSTANTIATE_TEST_SUITE_P( //
Radians,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kRadians),
+ testing::Combine(testing::Values(core::BuiltinFn::kRadians),
testing::ValuesIn(Concat(RadiansCases<AFloat>(), //
RadiansCases<f32>()))));
@@ -2383,7 +2385,7 @@
INSTANTIATE_TEST_SUITE_P( //
RadiansF16,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kRadians),
+ testing::Combine(testing::Values(core::BuiltinFn::kRadians),
testing::ValuesIn(RadiansF16Cases<f16>())));
template <typename T>
@@ -2409,7 +2411,7 @@
INSTANTIATE_TEST_SUITE_P( //
Round,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kRound),
+ testing::Combine(testing::Values(core::BuiltinFn::kRound),
testing::ValuesIn(Concat(RoundCases<AFloat>(), //
RoundCases<f32>(),
RoundCases<f16>()))));
@@ -2434,7 +2436,7 @@
INSTANTIATE_TEST_SUITE_P( //
Saturate,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kSaturate),
+ testing::Combine(testing::Values(core::BuiltinFn::kSaturate),
testing::ValuesIn(Concat(SaturateCases<AFloat>(), //
SaturateCases<f32>(),
SaturateCases<f16>()))));
@@ -2476,7 +2478,7 @@
INSTANTIATE_TEST_SUITE_P( //
Select,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kSelect),
+ testing::Combine(testing::Values(core::BuiltinFn::kSelect),
testing::ValuesIn(Concat(SelectCases<AInt>(), //
SelectCases<i32>(),
SelectCases<u32>(),
@@ -2517,7 +2519,7 @@
INSTANTIATE_TEST_SUITE_P( //
Sign,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kSign),
+ testing::Combine(testing::Values(core::BuiltinFn::kSign),
testing::ValuesIn(Concat(SignCases<AInt>(), //
SignCases<i32>(),
SignCases<AFloat>(),
@@ -2539,7 +2541,7 @@
INSTANTIATE_TEST_SUITE_P( //
Sin,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kSin),
+ testing::Combine(testing::Values(core::BuiltinFn::kSin),
testing::ValuesIn(Concat(SinCases<AFloat>(), //
SinCases<f32>(),
SinCases<f16>()))));
@@ -2564,7 +2566,7 @@
INSTANTIATE_TEST_SUITE_P( //
Sinh,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kSinh),
+ testing::Combine(testing::Values(core::BuiltinFn::kSinh),
testing::ValuesIn(Concat(SinhCases<AFloat>(), //
SinhCases<f32>(),
SinhCases<f16>()))));
@@ -2597,7 +2599,7 @@
INSTANTIATE_TEST_SUITE_P( //
Smoothstep,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kSmoothstep),
+ testing::Combine(testing::Values(core::BuiltinFn::kSmoothstep),
testing::ValuesIn(Concat(SmoothstepCases<AFloat>(), //
SmoothstepCases<f32>(),
SmoothstepCases<f16>()))));
@@ -2629,7 +2631,7 @@
INSTANTIATE_TEST_SUITE_P( //
Step,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kStep),
+ testing::Combine(testing::Values(core::BuiltinFn::kStep),
testing::ValuesIn(Concat(StepCases<AFloat>(), //
StepCases<f32>(),
StepCases<f16>()))));
@@ -2650,7 +2652,7 @@
INSTANTIATE_TEST_SUITE_P( //
Sqrt,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kSqrt),
+ testing::Combine(testing::Values(core::BuiltinFn::kSqrt),
testing::ValuesIn(Concat(SqrtCases<AFloat>(), //
SqrtCases<f32>(),
SqrtCases<f16>()))));
@@ -2669,7 +2671,7 @@
INSTANTIATE_TEST_SUITE_P( //
Tan,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kTan),
+ testing::Combine(testing::Values(core::BuiltinFn::kTan),
testing::ValuesIn(Concat(TanCases<AFloat>(), //
TanCases<f32>(),
TanCases<f16>()))));
@@ -2689,7 +2691,7 @@
INSTANTIATE_TEST_SUITE_P( //
Tanh,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kTanh),
+ testing::Combine(testing::Values(core::BuiltinFn::kTanh),
testing::ValuesIn(Concat(TanhCases<AFloat>(), //
TanhCases<f32>(),
TanhCases<f16>()))));
@@ -2755,7 +2757,7 @@
INSTANTIATE_TEST_SUITE_P( //
Transpose,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kTranspose),
+ testing::Combine(testing::Values(core::BuiltinFn::kTranspose),
testing::ValuesIn(Concat(TransposeCases<AFloat>(), //
TransposeCases<f32>(),
TransposeCases<f16>()))));
@@ -2773,7 +2775,7 @@
INSTANTIATE_TEST_SUITE_P( //
Trunc,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kTrunc),
+ testing::Combine(testing::Values(core::BuiltinFn::kTrunc),
testing::ValuesIn(Concat(TruncCases<AFloat>(), //
TruncCases<f32>(),
TruncCases<f16>()))));
@@ -2794,7 +2796,7 @@
INSTANTIATE_TEST_SUITE_P( //
Unpack4x8snorm,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kUnpack4X8Snorm),
+ testing::Combine(testing::Values(core::BuiltinFn::kUnpack4X8Snorm),
testing::ValuesIn(Unpack4x8snormCases())));
std::vector<Case> Unpack4x8unormCases() {
@@ -2811,7 +2813,7 @@
INSTANTIATE_TEST_SUITE_P( //
Unpack4x8unorm,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kUnpack4X8Unorm),
+ testing::Combine(testing::Values(core::BuiltinFn::kUnpack4X8Unorm),
testing::ValuesIn(Unpack4x8unormCases())));
std::vector<Case> Unpack2x16floatCases() {
@@ -2825,7 +2827,7 @@
INSTANTIATE_TEST_SUITE_P( //
Unpack2x16float,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kUnpack2X16Float),
+ testing::Combine(testing::Values(core::BuiltinFn::kUnpack2X16Float),
testing::ValuesIn(Unpack2x16floatCases())));
std::vector<Case> Unpack2x16snormCases() {
@@ -2843,7 +2845,7 @@
INSTANTIATE_TEST_SUITE_P( //
Unpack2x16snorm,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kUnpack2X16Snorm),
+ testing::Combine(testing::Values(core::BuiltinFn::kUnpack2X16Snorm),
testing::ValuesIn(Unpack2x16snormCases())));
std::vector<Case> Unpack2x16unormCases() {
@@ -2857,7 +2859,7 @@
INSTANTIATE_TEST_SUITE_P( //
Unpack2x16unorm,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kUnpack2X16Unorm),
+ testing::Combine(testing::Values(core::BuiltinFn::kUnpack2X16Unorm),
testing::ValuesIn(Unpack2x16unormCases())));
std::vector<Case> QuantizeToF16Cases() {
@@ -2916,7 +2918,7 @@
INSTANTIATE_TEST_SUITE_P( //
QuantizeToF16,
ConstEvalBuiltinTest,
- testing::Combine(testing::Values(core::Function::kQuantizeToF16),
+ testing::Combine(testing::Values(core::BuiltinFn::kQuantizeToF16),
testing::ValuesIn(QuantizeToF16Cases())));
} // namespace
diff --git a/src/tint/lang/core/constant/eval_conversion_test.cc b/src/tint/lang/core/constant/eval_conversion_test.cc
index 2ff6ce6..200666e 100644
--- a/src/tint/lang/core/constant/eval_conversion_test.cc
+++ b/src/tint/lang/core/constant/eval_conversion_test.cc
@@ -453,7 +453,7 @@
// const c = modf(4.0);
// var v = c;
// }
- auto* expr_c = Call(core::Function::kModf, 0_a);
+ auto* expr_c = Call(core::BuiltinFn::kModf, 0_a);
auto* materialized = Expr("c");
WrapInFunction(Decl(Const("c", expr_c)), Decl(Var("v", materialized)));
diff --git a/src/tint/lang/core/function.cc b/src/tint/lang/core/function.cc
deleted file mode 100644
index afa1150..0000000
--- a/src/tint/lang/core/function.cc
+++ /dev/null
@@ -1,711 +0,0 @@
-// 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/lang/core/function.cc.tmpl
-//
-// To regenerate run: './tools/run gen'
-//
-// Do not modify this file directly
-////////////////////////////////////////////////////////////////////////////////
-
-#include "src/tint/lang/core/function.h"
-
-namespace tint::core {
-
-Function ParseFunction(std::string_view 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 == "textureBarrier") {
- return Function::kTextureBarrier;
- }
- 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 == "subgroupBallot") {
- return Function::kSubgroupBallot;
- }
- if (name == "subgroupBroadcast") {
- return Function::kSubgroupBroadcast;
- }
- 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::kTextureBarrier:
- return "textureBarrier";
- 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::kSubgroupBallot:
- return "subgroupBallot";
- case Function::kSubgroupBroadcast:
- return "subgroupBroadcast";
- case Function::kTintMaterialize:
- return "_tint_materialize";
- }
- return "<unknown>";
-}
-
-bool IsCoarseDerivativeBuiltin(Function f) {
- return f == Function::kDpdxCoarse || f == Function::kDpdyCoarse || f == Function::kFwidthCoarse;
-}
-
-bool IsFineDerivativeBuiltin(Function f) {
- return f == Function::kDpdxFine || f == Function::kDpdyFine || f == Function::kFwidthFine;
-}
-
-bool IsDerivativeBuiltin(Function f) {
- return f == Function::kDpdx || f == Function::kDpdy || f == Function::kFwidth ||
- IsCoarseDerivativeBuiltin(f) || IsFineDerivativeBuiltin(f);
-}
-
-bool IsTextureBuiltin(Function f) {
- return IsImageQueryBuiltin(f) || //
- f == Function::kTextureGather || //
- f == Function::kTextureGatherCompare || //
- f == Function::kTextureLoad || //
- f == Function::kTextureSample || //
- f == Function::kTextureSampleBaseClampToEdge || //
- f == Function::kTextureSampleBias || //
- f == Function::kTextureSampleCompare || //
- f == Function::kTextureSampleCompareLevel || //
- f == Function::kTextureSampleGrad || //
- f == Function::kTextureSampleLevel || //
- f == Function::kTextureStore;
-}
-
-bool IsImageQueryBuiltin(Function f) {
- return f == Function::kTextureDimensions || f == Function::kTextureNumLayers ||
- f == Function::kTextureNumLevels || f == Function::kTextureNumSamples;
-}
-
-bool IsDataPackingBuiltin(Function f) {
- return f == Function::kPack4X8Snorm || f == Function::kPack4X8Unorm ||
- f == Function::kPack2X16Snorm || f == Function::kPack2X16Unorm ||
- f == Function::kPack2X16Float;
-}
-
-bool IsDataUnpackingBuiltin(Function f) {
- return f == Function::kUnpack4X8Snorm || f == Function::kUnpack4X8Unorm ||
- f == Function::kUnpack2X16Snorm || f == Function::kUnpack2X16Unorm ||
- f == Function::kUnpack2X16Float;
-}
-
-bool IsBarrierBuiltin(Function f) {
- return f == Function::kWorkgroupBarrier || f == Function::kStorageBarrier ||
- f == Function::kTextureBarrier;
-}
-
-bool IsAtomicBuiltin(Function f) {
- return f == Function::kAtomicLoad || f == Function::kAtomicStore || f == Function::kAtomicAdd ||
- f == Function::kAtomicSub || f == Function::kAtomicMax || f == Function::kAtomicMin ||
- f == Function::kAtomicAnd || f == Function::kAtomicOr || f == Function::kAtomicXor ||
- f == Function::kAtomicExchange || f == Function::kAtomicCompareExchangeWeak;
-}
-
-bool IsDP4aBuiltin(Function f) {
- return f == Function::kDot4I8Packed || f == Function::kDot4U8Packed;
-}
-
-bool IsSubgroupBuiltin(Function f) {
- return f == Function::kSubgroupBallot || f == Function::kSubgroupBroadcast;
-}
-
-bool HasSideEffects(Function f) {
- switch (f) {
- case Function::kAtomicAdd:
- case Function::kAtomicAnd:
- case Function::kAtomicCompareExchangeWeak:
- case Function::kAtomicExchange:
- case Function::kAtomicMax:
- case Function::kAtomicMin:
- case Function::kAtomicOr:
- case Function::kAtomicStore:
- case Function::kAtomicSub:
- case Function::kAtomicXor:
- case Function::kTextureStore:
- case Function::kWorkgroupUniformLoad:
- return true;
- default:
- break;
- }
- return false;
-}
-
-} // namespace tint::core
diff --git a/src/tint/lang/core/function.cc.tmpl b/src/tint/lang/core/function.cc.tmpl
deleted file mode 100644
index e594eb6..0000000
--- a/src/tint/lang/core/function.cc.tmpl
+++ /dev/null
@@ -1,132 +0,0 @@
-{{- /*
---------------------------------------------------------------------------------
-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
---------------------------------------------------------------------------------
-*/ -}}
-
-{{- $I := LoadIntrinsics "src/tint/lang/core/core.def" -}}
-#include "src/tint/lang/core/function.h"
-
-namespace tint::core {
-
-Function ParseFunction(std::string_view name) {
-{{- range $I.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 $I.Sem.Builtins }}
- case Function::k{{PascalCase .Name}}:
- return "{{.Name}}";
-{{- end }}
- }
- return "<unknown>";
-}
-
-bool IsCoarseDerivativeBuiltin(Function f) {
- return f == Function::kDpdxCoarse || f == Function::kDpdyCoarse ||
- f == Function::kFwidthCoarse;
-}
-
-bool IsFineDerivativeBuiltin(Function f) {
- return f == Function::kDpdxFine || f == Function::kDpdyFine ||
- f == Function::kFwidthFine;
-}
-
-bool IsDerivativeBuiltin(Function f) {
- return f == Function::kDpdx || f == Function::kDpdy ||
- f == Function::kFwidth || IsCoarseDerivativeBuiltin(f) ||
- IsFineDerivativeBuiltin(f);
-}
-
-bool IsTextureBuiltin(Function f) {
- return IsImageQueryBuiltin(f) || //
- f == Function::kTextureGather || //
- f == Function::kTextureGatherCompare || //
- f == Function::kTextureLoad || //
- f == Function::kTextureSample || //
- f == Function::kTextureSampleBaseClampToEdge || //
- f == Function::kTextureSampleBias || //
- f == Function::kTextureSampleCompare || //
- f == Function::kTextureSampleCompareLevel || //
- f == Function::kTextureSampleGrad || //
- f == Function::kTextureSampleLevel || //
- f == Function::kTextureStore;
-}
-
-bool IsImageQueryBuiltin(Function f) {
- return f == Function::kTextureDimensions ||
- f == Function::kTextureNumLayers || f == Function::kTextureNumLevels ||
- f == Function::kTextureNumSamples;
-}
-
-bool IsDataPackingBuiltin(Function f) {
- return f == Function::kPack4X8Snorm || f == Function::kPack4X8Unorm ||
- f == Function::kPack2X16Snorm || f == Function::kPack2X16Unorm ||
- f == Function::kPack2X16Float;
-}
-
-bool IsDataUnpackingBuiltin(Function f) {
- return f == Function::kUnpack4X8Snorm || f == Function::kUnpack4X8Unorm ||
- f == Function::kUnpack2X16Snorm || f == Function::kUnpack2X16Unorm ||
- f == Function::kUnpack2X16Float;
-}
-
-bool IsBarrierBuiltin(Function f) {
- return f == Function::kWorkgroupBarrier || f == Function::kStorageBarrier ||
- f == Function::kTextureBarrier;
-}
-
-bool IsAtomicBuiltin(Function f) {
- return f == Function::kAtomicLoad || f == Function::kAtomicStore ||
- f == Function::kAtomicAdd || f == Function::kAtomicSub ||
- f == Function::kAtomicMax || f == Function::kAtomicMin ||
- f == Function::kAtomicAnd || f == Function::kAtomicOr ||
- f == Function::kAtomicXor || f == Function::kAtomicExchange ||
- f == Function::kAtomicCompareExchangeWeak;
-}
-
-bool IsDP4aBuiltin(Function f) {
- return f == Function::kDot4I8Packed || f == Function::kDot4U8Packed;
-}
-
-bool IsSubgroupBuiltin(Function f) {
- return f == Function::kSubgroupBallot || f == Function::kSubgroupBroadcast;
-}
-
-bool HasSideEffects(Function f) {
- switch (f) {
- case Function::kAtomicAdd:
- case Function::kAtomicAnd:
- case Function::kAtomicCompareExchangeWeak:
- case Function::kAtomicExchange:
- case Function::kAtomicMax:
- case Function::kAtomicMin:
- case Function::kAtomicOr:
- case Function::kAtomicStore:
- case Function::kAtomicSub:
- case Function::kAtomicXor:
- case Function::kTextureStore:
- case Function::kWorkgroupUniformLoad:
- return true;
- default:
- break;
- }
- return false;
-}
-
-} // namespace tint::core
diff --git a/src/tint/lang/core/intrinsic/table.cc b/src/tint/lang/core/intrinsic/table.cc
index 221f43b..ce4c23e 100644
--- a/src/tint/lang/core/intrinsic/table.cc
+++ b/src/tint/lang/core/intrinsic/table.cc
@@ -584,7 +584,7 @@
} // namespace
Result<Overload> Lookup(Context& context,
- core::Function builtin_type,
+ core::BuiltinFn builtin_type,
VectorRef<const core::type::Type*> args,
EvaluationStage earliest_eval_stage,
const Source& source) {
diff --git a/src/tint/lang/core/intrinsic/table.h b/src/tint/lang/core/intrinsic/table.h
index edae840..1f38b3d 100644
--- a/src/tint/lang/core/intrinsic/table.h
+++ b/src/tint/lang/core/intrinsic/table.h
@@ -19,7 +19,7 @@
#include <string>
#include "src/tint/lang/core/binary_op.h"
-#include "src/tint/lang/core/function.h"
+#include "src/tint/lang/core/builtin_fn.h"
#include "src/tint/lang/core/intrinsic/ctor_conv.h"
#include "src/tint/lang/core/intrinsic/table_data.h"
#include "src/tint/lang/core/parameter_usage.h"
@@ -110,7 +110,7 @@
/// @param source the source of the builtin call
/// @return the resolved builtin function overload
Result<Overload> Lookup(Context& context,
- core::Function builtin_type,
+ core::BuiltinFn builtin_type,
VectorRef<const core::type::Type*> args,
EvaluationStage earliest_eval_stage,
const Source& source);
diff --git a/src/tint/lang/core/intrinsic/table_test.cc b/src/tint/lang/core/intrinsic/table_test.cc
index c0a3387..7b90ec7 100644
--- a/src/tint/lang/core/intrinsic/table_test.cc
+++ b/src/tint/lang/core/intrinsic/table_test.cc
@@ -56,7 +56,7 @@
TEST_F(IntrinsicTableTest, MatchF32) {
auto* f32 = create<core::type::F32>();
auto result =
- Lookup(context, core::Function::kCos, Vector{f32}, EvaluationStage::kConstant, Source{});
+ Lookup(context, core::BuiltinFn::kCos, Vector{f32}, EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
EXPECT_EQ(result->return_type, f32);
@@ -67,7 +67,7 @@
TEST_F(IntrinsicTableTest, MismatchF32) {
auto* i32 = create<core::type::I32>();
auto result =
- Lookup(context, core::Function::kCos, Vector{i32}, EvaluationStage::kConstant, Source{});
+ Lookup(context, core::BuiltinFn::kCos, Vector{i32}, EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
}
@@ -76,7 +76,7 @@
auto* f32 = create<core::type::F32>();
auto* u32 = create<core::type::U32>();
auto* vec2_f32 = create<core::type::Vector>(f32, 2u);
- auto result = Lookup(context, core::Function::kUnpack2X16Float, Vector{u32},
+ auto result = Lookup(context, core::BuiltinFn::kUnpack2X16Float, Vector{u32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -87,7 +87,7 @@
TEST_F(IntrinsicTableTest, MismatchU32) {
auto* f32 = create<core::type::F32>();
- auto result = Lookup(context, core::Function::kUnpack2X16Float, Vector{f32},
+ auto result = Lookup(context, core::BuiltinFn::kUnpack2X16Float, Vector{f32},
EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -98,7 +98,7 @@
auto* i32 = create<core::type::I32>();
auto* vec4_f32 = create<core::type::Vector>(f32, 4u);
auto* tex = create<core::type::SampledTexture>(core::type::TextureDimension::k1d, f32);
- auto result = Lookup(context, core::Function::kTextureLoad, Vector{tex, i32, i32},
+ auto result = Lookup(context, core::BuiltinFn::kTextureLoad, Vector{tex, i32, i32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -115,7 +115,7 @@
TEST_F(IntrinsicTableTest, MismatchI32) {
auto* f32 = create<core::type::F32>();
auto* tex = create<core::type::SampledTexture>(core::type::TextureDimension::k1d, f32);
- auto result = Lookup(context, core::Function::kTextureLoad, Vector{tex, f32},
+ auto result = Lookup(context, core::BuiltinFn::kTextureLoad, Vector{tex, f32},
EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -123,7 +123,7 @@
TEST_F(IntrinsicTableTest, MatchIU32AsI32) {
auto* i32 = create<core::type::I32>();
- auto result = Lookup(context, core::Function::kCountOneBits, Vector{i32},
+ auto result = Lookup(context, core::BuiltinFn::kCountOneBits, Vector{i32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -134,7 +134,7 @@
TEST_F(IntrinsicTableTest, MatchIU32AsU32) {
auto* u32 = create<core::type::U32>();
- auto result = Lookup(context, core::Function::kCountOneBits, Vector{u32},
+ auto result = Lookup(context, core::BuiltinFn::kCountOneBits, Vector{u32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -145,7 +145,7 @@
TEST_F(IntrinsicTableTest, MismatchIU32) {
auto* f32 = create<core::type::F32>();
- auto result = Lookup(context, core::Function::kCountOneBits, Vector{f32},
+ auto result = Lookup(context, core::BuiltinFn::kCountOneBits, Vector{f32},
EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -153,7 +153,7 @@
TEST_F(IntrinsicTableTest, MatchFIU32AsI32) {
auto* i32 = create<core::type::I32>();
- auto result = Lookup(context, core::Function::kClamp, Vector{i32, i32, i32},
+ auto result = Lookup(context, core::BuiltinFn::kClamp, Vector{i32, i32, i32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -166,7 +166,7 @@
TEST_F(IntrinsicTableTest, MatchFIU32AsU32) {
auto* u32 = create<core::type::U32>();
- auto result = Lookup(context, core::Function::kClamp, Vector{u32, u32, u32},
+ auto result = Lookup(context, core::BuiltinFn::kClamp, Vector{u32, u32, u32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -179,7 +179,7 @@
TEST_F(IntrinsicTableTest, MatchFIU32AsF32) {
auto* f32 = create<core::type::F32>();
- auto result = Lookup(context, core::Function::kClamp, Vector{f32, f32, f32},
+ auto result = Lookup(context, core::BuiltinFn::kClamp, Vector{f32, f32, f32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -192,7 +192,7 @@
TEST_F(IntrinsicTableTest, MismatchFIU32) {
auto* bool_ = create<core::type::Bool>();
- auto result = Lookup(context, core::Function::kClamp, Vector{bool_, bool_, bool_},
+ auto result = Lookup(context, core::BuiltinFn::kClamp, Vector{bool_, bool_, bool_},
EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -201,7 +201,7 @@
TEST_F(IntrinsicTableTest, MatchBool) {
auto* f32 = create<core::type::F32>();
auto* bool_ = create<core::type::Bool>();
- auto result = Lookup(context, core::Function::kSelect, Vector{f32, f32, bool_},
+ auto result = Lookup(context, core::BuiltinFn::kSelect, Vector{f32, f32, bool_},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -214,7 +214,7 @@
TEST_F(IntrinsicTableTest, MismatchBool) {
auto* f32 = create<core::type::F32>();
- auto result = Lookup(context, core::Function::kSelect, Vector{f32, f32, f32},
+ auto result = Lookup(context, core::BuiltinFn::kSelect, Vector{f32, f32, f32},
EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -225,7 +225,7 @@
auto* atomicI32 = create<core::type::Atomic>(i32);
auto* ptr = create<core::type::Pointer>(core::AddressSpace::kWorkgroup, atomicI32,
core::Access::kReadWrite);
- auto result = Lookup(context, core::Function::kAtomicLoad, Vector{ptr},
+ auto result = Lookup(context, core::BuiltinFn::kAtomicLoad, Vector{ptr},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -237,7 +237,7 @@
TEST_F(IntrinsicTableTest, MismatchPointer) {
auto* i32 = create<core::type::I32>();
auto* atomicI32 = create<core::type::Atomic>(i32);
- auto result = Lookup(context, core::Function::kAtomicLoad, Vector{atomicI32},
+ auto result = Lookup(context, core::BuiltinFn::kAtomicLoad, Vector{atomicI32},
EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -248,7 +248,7 @@
create<core::type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
auto* arr_ptr =
create<core::type::Pointer>(core::AddressSpace::kStorage, arr, core::Access::kReadWrite);
- auto result = Lookup(context, core::Function::kArrayLength, Vector{arr_ptr},
+ auto result = Lookup(context, core::BuiltinFn::kArrayLength, Vector{arr_ptr},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -261,7 +261,7 @@
TEST_F(IntrinsicTableTest, MismatchArray) {
auto* f32 = create<core::type::F32>();
- auto result = Lookup(context, core::Function::kArrayLength, Vector{f32},
+ auto result = Lookup(context, core::BuiltinFn::kArrayLength, Vector{f32},
EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -273,7 +273,7 @@
auto* vec4_f32 = create<core::type::Vector>(f32, 4u);
auto* tex = create<core::type::SampledTexture>(core::type::TextureDimension::k2d, f32);
auto* sampler = create<core::type::Sampler>(core::type::SamplerKind::kSampler);
- auto result = Lookup(context, core::Function::kTextureSample, Vector{tex, sampler, vec2_f32},
+ auto result = Lookup(context, core::BuiltinFn::kTextureSample, Vector{tex, sampler, vec2_f32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -291,7 +291,7 @@
auto* f32 = create<core::type::F32>();
auto* vec2_f32 = create<core::type::Vector>(f32, 2u);
auto* tex = create<core::type::SampledTexture>(core::type::TextureDimension::k2d, f32);
- auto result = Lookup(context, core::Function::kTextureSample, Vector{tex, f32, vec2_f32},
+ auto result = Lookup(context, core::BuiltinFn::kTextureSample, Vector{tex, f32, vec2_f32},
EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -303,7 +303,7 @@
auto* vec2_i32 = create<core::type::Vector>(i32, 2u);
auto* vec4_f32 = create<core::type::Vector>(f32, 4u);
auto* tex = create<core::type::SampledTexture>(core::type::TextureDimension::k2d, f32);
- auto result = Lookup(context, core::Function::kTextureLoad, Vector{tex, vec2_i32, i32},
+ auto result = Lookup(context, core::BuiltinFn::kTextureLoad, Vector{tex, vec2_i32, i32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -323,7 +323,7 @@
auto* vec2_i32 = create<core::type::Vector>(i32, 2u);
auto* vec4_f32 = create<core::type::Vector>(f32, 4u);
auto* tex = create<core::type::MultisampledTexture>(core::type::TextureDimension::k2d, f32);
- auto result = Lookup(context, core::Function::kTextureLoad, Vector{tex, vec2_i32, i32},
+ auto result = Lookup(context, core::BuiltinFn::kTextureLoad, Vector{tex, vec2_i32, i32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -342,7 +342,7 @@
auto* i32 = create<core::type::I32>();
auto* vec2_i32 = create<core::type::Vector>(i32, 2u);
auto* tex = create<core::type::DepthTexture>(core::type::TextureDimension::k2d);
- auto result = Lookup(context, core::Function::kTextureLoad, Vector{tex, vec2_i32, i32},
+ auto result = Lookup(context, core::BuiltinFn::kTextureLoad, Vector{tex, vec2_i32, i32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -361,7 +361,7 @@
auto* i32 = create<core::type::I32>();
auto* vec2_i32 = create<core::type::Vector>(i32, 2u);
auto* tex = create<core::type::DepthMultisampledTexture>(core::type::TextureDimension::k2d);
- auto result = Lookup(context, core::Function::kTextureLoad, Vector{tex, vec2_i32, i32},
+ auto result = Lookup(context, core::BuiltinFn::kTextureLoad, Vector{tex, vec2_i32, i32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -381,7 +381,7 @@
auto* vec2_i32 = create<core::type::Vector>(i32, 2u);
auto* vec4_f32 = create<core::type::Vector>(f32, 4u);
auto* tex = create<core::type::ExternalTexture>();
- auto result = Lookup(context, core::Function::kTextureLoad, Vector{tex, vec2_i32},
+ auto result = Lookup(context, core::BuiltinFn::kTextureLoad, Vector{tex, vec2_i32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -403,7 +403,7 @@
core::TexelFormat::kR32Float,
core::Access::kWrite, subtype);
- auto result = Lookup(context, core::Function::kTextureStore, Vector{tex, vec2_i32, vec4_f32},
+ auto result = Lookup(context, core::BuiltinFn::kTextureStore, Vector{tex, vec2_i32, vec4_f32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -421,7 +421,7 @@
auto* f32 = create<core::type::F32>();
auto* i32 = create<core::type::I32>();
auto* vec2_i32 = create<core::type::Vector>(i32, 2u);
- auto result = Lookup(context, core::Function::kTextureLoad, Vector{f32, vec2_i32},
+ auto result = Lookup(context, core::BuiltinFn::kTextureLoad, Vector{f32, vec2_i32},
EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -429,7 +429,7 @@
TEST_F(IntrinsicTableTest, ImplicitLoadOnReference) {
auto* f32 = create<core::type::F32>();
- auto result = Lookup(context, core::Function::kCos,
+ auto result = Lookup(context, core::BuiltinFn::kCos,
Vector{
create<core::type::Reference>(core::AddressSpace::kFunction, f32,
core::Access::kReadWrite),
@@ -444,7 +444,7 @@
TEST_F(IntrinsicTableTest, MatchTemplateType) {
auto* f32 = create<core::type::F32>();
- auto result = Lookup(context, core::Function::kClamp, Vector{f32, f32, f32},
+ auto result = Lookup(context, core::BuiltinFn::kClamp, Vector{f32, f32, f32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -457,7 +457,7 @@
TEST_F(IntrinsicTableTest, MismatchTemplateType) {
auto* f32 = create<core::type::F32>();
auto* u32 = create<core::type::U32>();
- auto result = Lookup(context, core::Function::kClamp, Vector{f32, u32, f32},
+ auto result = Lookup(context, core::BuiltinFn::kClamp, Vector{f32, u32, f32},
EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -466,7 +466,7 @@
TEST_F(IntrinsicTableTest, MatchOpenSizeVector) {
auto* f32 = create<core::type::F32>();
auto* vec2_f32 = create<core::type::Vector>(f32, 2u);
- auto result = Lookup(context, core::Function::kClamp, Vector{vec2_f32, vec2_f32, vec2_f32},
+ auto result = Lookup(context, core::BuiltinFn::kClamp, Vector{vec2_f32, vec2_f32, vec2_f32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -481,7 +481,7 @@
auto* f32 = create<core::type::F32>();
auto* u32 = create<core::type::U32>();
auto* vec2_f32 = create<core::type::Vector>(f32, 2u);
- auto result = Lookup(context, core::Function::kClamp, Vector{vec2_f32, u32, vec2_f32},
+ auto result = Lookup(context, core::BuiltinFn::kClamp, Vector{vec2_f32, u32, vec2_f32},
EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -491,7 +491,7 @@
auto* f32 = create<core::type::F32>();
auto* vec3_f32 = create<core::type::Vector>(f32, 3u);
auto* mat3_f32 = create<core::type::Matrix>(vec3_f32, 3u);
- auto result = Lookup(context, core::Function::kDeterminant, Vector{mat3_f32},
+ auto result = Lookup(context, core::BuiltinFn::kDeterminant, Vector{mat3_f32},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -504,7 +504,7 @@
auto* f32 = create<core::type::F32>();
auto* vec2_f32 = create<core::type::Vector>(f32, 2u);
auto* mat3x2_f32 = create<core::type::Matrix>(vec2_f32, 3u);
- auto result = Lookup(context, core::Function::kDeterminant, Vector{mat3x2_f32},
+ auto result = Lookup(context, core::BuiltinFn::kDeterminant, Vector{mat3x2_f32},
EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -513,7 +513,7 @@
TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Builtin_ConstantEval) {
auto* af = create<core::type::AbstractFloat>();
auto* bool_ = create<core::type::Bool>();
- auto result = Lookup(context, core::Function::kSelect, Vector{af, af, bool_},
+ auto result = Lookup(context, core::BuiltinFn::kSelect, Vector{af, af, bool_},
EvaluationStage::kConstant, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -529,7 +529,7 @@
auto* af = create<core::type::AbstractFloat>();
auto* bool_ref = create<core::type::Reference>(
core::AddressSpace::kFunction, create<core::type::Bool>(), core::Access::kReadWrite);
- auto result = Lookup(context, core::Function::kSelect, Vector{af, af, bool_ref},
+ auto result = Lookup(context, core::BuiltinFn::kSelect, Vector{af, af, bool_ref},
EvaluationStage::kRuntime, Source{});
ASSERT_TRUE(result) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -571,7 +571,7 @@
// None of the arguments match, so expect the overloads with 2 parameters to
// come first
auto* bool_ = create<core::type::Bool>();
- auto result = Lookup(context, core::Function::kTextureDimensions, Vector{bool_, bool_},
+ auto result = Lookup(context, core::BuiltinFn::kTextureDimensions, Vector{bool_, bool_},
EvaluationStage::kConstant, Source{});
EXPECT_FALSE(result);
ASSERT_EQ(Diagnostics().str(),
@@ -611,7 +611,7 @@
TEST_F(IntrinsicTableTest, OverloadOrderByMatchingParameter) {
auto* tex = create<core::type::DepthTexture>(core::type::TextureDimension::k2d);
auto* bool_ = create<core::type::Bool>();
- auto result = Lookup(context, core::Function::kTextureDimensions, Vector{tex, bool_},
+ auto result = Lookup(context, core::BuiltinFn::kTextureDimensions, Vector{tex, bool_},
EvaluationStage::kConstant, Source{});
EXPECT_FALSE(result);
ASSERT_EQ(Diagnostics().str(),
@@ -980,7 +980,7 @@
auto* f32 = create<core::type::F32>();
Vector<const core::type::Type*, 0> arg_tys;
arg_tys.Resize(257, f32);
- auto result = Lookup(context, core::Function::kAbs, std::move(arg_tys),
+ auto result = Lookup(context, core::BuiltinFn::kAbs, std::move(arg_tys),
EvaluationStage::kConstant, Source{});
ASSERT_FALSE(result);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -1221,7 +1221,7 @@
auto* arg_a = GetParam().arg_a(*this);
auto* arg_b = GetParam().arg_b(*this);
auto* arg_c = GetParam().arg_c(*this);
- auto builtin = Lookup(context, core::Function::kClamp, Vector{arg_a, arg_b, arg_c},
+ auto builtin = Lookup(context, core::BuiltinFn::kClamp, Vector{arg_a, arg_b, arg_c},
EvaluationStage::kConstant, Source{{12, 34}});
bool expected_match = GetParam().expected_match;
diff --git a/src/tint/lang/core/ir/builder.h b/src/tint/lang/core/ir/builder.h
index 7088ee0..76de594 100644
--- a/src/tint/lang/core/ir/builder.h
+++ b/src/tint/lang/core/ir/builder.h
@@ -672,7 +672,7 @@
/// @param args the call arguments
/// @returns the instruction
template <typename... ARGS>
- ir::CoreBuiltinCall* Call(const core::type::Type* type, core::Function func, ARGS&&... args) {
+ ir::CoreBuiltinCall* Call(const core::type::Type* type, core::BuiltinFn func, ARGS&&... args) {
return Append(ir.instructions.Create<ir::CoreBuiltinCall>(
InstructionResult(type), func, Values(std::forward<ARGS>(args)...)));
}
diff --git a/src/tint/lang/core/ir/core_builtin_call.cc b/src/tint/lang/core/ir/core_builtin_call.cc
index ada7835..86325ac 100644
--- a/src/tint/lang/core/ir/core_builtin_call.cc
+++ b/src/tint/lang/core/ir/core_builtin_call.cc
@@ -25,11 +25,11 @@
namespace tint::core::ir {
CoreBuiltinCall::CoreBuiltinCall(InstructionResult* result,
- core::Function func,
+ core::BuiltinFn func,
VectorRef<Value*> arguments)
: Base(result, arguments), func_(func) {
- TINT_ASSERT(func != core::Function::kNone);
- TINT_ASSERT(func != core::Function::kTintMaterialize);
+ TINT_ASSERT(func != core::BuiltinFn::kNone);
+ TINT_ASSERT(func != core::BuiltinFn::kTintMaterialize);
}
CoreBuiltinCall::~CoreBuiltinCall() = default;
diff --git a/src/tint/lang/core/ir/core_builtin_call.h b/src/tint/lang/core/ir/core_builtin_call.h
index c887b4b..24c998d 100644
--- a/src/tint/lang/core/ir/core_builtin_call.h
+++ b/src/tint/lang/core/ir/core_builtin_call.h
@@ -17,7 +17,7 @@
#include <string>
-#include "src/tint/lang/core/function.h"
+#include "src/tint/lang/core/builtin_fn.h"
#include "src/tint/lang/core/intrinsic/data/data.h"
#include "src/tint/lang/core/intrinsic/table_data.h"
#include "src/tint/lang/core/ir/builtin_call.h"
@@ -33,7 +33,7 @@
/// @param func the builtin function
/// @param args the conversion arguments
CoreBuiltinCall(InstructionResult* result,
- core::Function func,
+ core::BuiltinFn func,
VectorRef<Value*> args = tint::Empty);
~CoreBuiltinCall() override;
@@ -41,7 +41,7 @@
CoreBuiltinCall* Clone(CloneContext& ctx) override;
/// @returns the builtin function
- core::Function Func() { return func_; }
+ core::BuiltinFn Func() { return func_; }
/// @returns the identifier for the function
size_t FuncId() override { return static_cast<size_t>(func_); }
@@ -56,7 +56,7 @@
const core::intrinsic::TableData& TableData() override { return core::intrinsic::data::kData; }
private:
- core::Function func_;
+ core::BuiltinFn func_;
};
} // namespace tint::core::ir
diff --git a/src/tint/lang/core/ir/core_builtin_call_test.cc b/src/tint/lang/core/ir/core_builtin_call_test.cc
index e05e564..290af5a 100644
--- a/src/tint/lang/core/ir/core_builtin_call_test.cc
+++ b/src/tint/lang/core/ir/core_builtin_call_test.cc
@@ -26,7 +26,7 @@
TEST_F(IR_CoreBuiltinCallTest, Usage) {
auto* arg1 = b.Constant(1_u);
auto* arg2 = b.Constant(2_u);
- auto* builtin = b.Call(mod.Types().f32(), core::Function::kAbs, arg1, arg2);
+ auto* builtin = b.Call(mod.Types().f32(), core::BuiltinFn::kAbs, arg1, arg2);
EXPECT_THAT(arg1->Usages(), testing::UnorderedElementsAre(Usage{builtin, 0u}));
EXPECT_THAT(arg2->Usages(), testing::UnorderedElementsAre(Usage{builtin, 1u}));
@@ -35,7 +35,7 @@
TEST_F(IR_CoreBuiltinCallTest, Result) {
auto* arg1 = b.Constant(1_u);
auto* arg2 = b.Constant(2_u);
- auto* builtin = b.Call(mod.Types().f32(), core::Function::kAbs, arg1, arg2);
+ auto* builtin = b.Call(mod.Types().f32(), core::BuiltinFn::kAbs, arg1, arg2);
EXPECT_TRUE(builtin->HasResults());
EXPECT_FALSE(builtin->HasMultiResults());
@@ -48,7 +48,7 @@
{
Module mod;
Builder b{mod};
- b.Call(nullptr, core::Function::kAbs);
+ b.Call(nullptr, core::BuiltinFn::kAbs);
},
"");
}
@@ -58,7 +58,7 @@
{
Module mod;
Builder b{mod};
- b.Call(mod.Types().f32(), core::Function::kNone);
+ b.Call(mod.Types().f32(), core::BuiltinFn::kNone);
},
"");
}
@@ -68,13 +68,13 @@
{
Module mod;
Builder b{mod};
- b.Call(mod.Types().f32(), core::Function::kTintMaterialize);
+ b.Call(mod.Types().f32(), core::BuiltinFn::kTintMaterialize);
},
"");
}
TEST_F(IR_CoreBuiltinCallTest, Clone) {
- auto* builtin = b.Call(mod.Types().f32(), core::Function::kAbs, 1_u, 2_u);
+ auto* builtin = b.Call(mod.Types().f32(), core::BuiltinFn::kAbs, 1_u, 2_u);
auto* new_b = clone_ctx.Clone(builtin);
@@ -82,7 +82,7 @@
EXPECT_NE(builtin->Result(), new_b->Result());
EXPECT_EQ(mod.Types().f32(), new_b->Result()->Type());
- EXPECT_EQ(core::Function::kAbs, new_b->Func());
+ EXPECT_EQ(core::BuiltinFn::kAbs, new_b->Func());
auto args = new_b->Args();
EXPECT_EQ(2u, args.Length());
@@ -95,13 +95,13 @@
}
TEST_F(IR_CoreBuiltinCallTest, CloneNoArgs) {
- auto* builtin = b.Call(mod.Types().f32(), core::Function::kAbs);
+ auto* builtin = b.Call(mod.Types().f32(), core::BuiltinFn::kAbs);
auto* new_b = clone_ctx.Clone(builtin);
EXPECT_NE(builtin->Result(), new_b->Result());
EXPECT_EQ(mod.Types().f32(), new_b->Result()->Type());
- EXPECT_EQ(core::Function::kAbs, new_b->Func());
+ EXPECT_EQ(core::BuiltinFn::kAbs, new_b->Func());
auto args = new_b->Args();
EXPECT_TRUE(args.IsEmpty());
diff --git a/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.cc b/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.cc
index d4fcbf2..4acfbfb 100644
--- a/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.cc
+++ b/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.cc
@@ -140,7 +140,7 @@
[&](CoreBuiltinCall* call) {
// Replace arguments to builtin functions and add swizzles if necessary.
call->SetOperand(use.operand_index, new_value);
- if (call->Func() == core::Function::kTextureStore) {
+ if (call->Func() == core::BuiltinFn::kTextureStore) {
// Swizzle the value argument of a `textureStore()` builtin.
auto* tex = old_value->Type()->As<core::type::StorageTexture>();
auto index = core::type::IsTextureArray(tex->dim()) ? 3u : 2u;
@@ -148,7 +148,7 @@
auto* swizzle = b.Swizzle(value->Type(), value, Vector{2u, 1u, 0u, 3u});
swizzle->InsertBefore(call);
call->SetOperand(index, swizzle->Result());
- } else if (call->Func() == core::Function::kTextureLoad) {
+ } else if (call->Func() == core::BuiltinFn::kTextureLoad) {
// Swizzle the result of a `textureLoad()` builtin.
auto* swizzle =
b.Swizzle(call->Result()->Type(), nullptr, Vector{2u, 1u, 0u, 3u});
diff --git a/src/tint/lang/core/ir/transform/bgra8unorm_polyfill_test.cc b/src/tint/lang/core/ir/transform/bgra8unorm_polyfill_test.cc
index e8d19a3..aab9aa5 100644
--- a/src/tint/lang/core/ir/transform/bgra8unorm_polyfill_test.cc
+++ b/src/tint/lang/core/ir/transform/bgra8unorm_polyfill_test.cc
@@ -60,7 +60,7 @@
func->SetParams({value, coords});
b.Append(func->Block(), [&] {
auto* load = b.Load(var->Result());
- b.Call(ty.void_(), core::Function::kTextureStore, load, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, load, coords, value);
b.Return(func);
});
@@ -97,7 +97,7 @@
auto* value = b.FunctionParam("value", ty.vec4<f32>());
func->SetParams({texture, coords, value});
b.Append(func->Block(), [&] {
- b.Call(ty.void_(), core::Function::kTextureStore, texture, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, texture, coords, value);
b.Return(func);
});
@@ -133,7 +133,7 @@
func->SetParams({value, coords});
b.Append(func->Block(), [&] {
auto* load = b.Load(var->Result());
- b.Call(ty.void_(), core::Function::kTextureStore, load, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, load, coords, value);
b.Return(func);
});
@@ -183,7 +183,7 @@
auto* value = b.FunctionParam("value", ty.vec4<f32>());
func->SetParams({texture, coords, value});
b.Append(func->Block(), [&] {
- b.Call(ty.void_(), core::Function::kTextureStore, texture, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, texture, coords, value);
b.Return(func);
});
@@ -228,7 +228,7 @@
auto* value = b.FunctionParam("value", ty.vec4<f32>());
bar->SetParams({texture, coords, value});
b.Append(bar->Block(), [&] {
- b.Call(ty.void_(), core::Function::kTextureStore, texture, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, texture, coords, value);
b.Return(bar);
});
}
@@ -316,9 +316,9 @@
auto* value = b.FunctionParam("value", ty.vec4<f32>());
bar->SetParams({texture_a, texture_b, texture_c, coords, value});
b.Append(bar->Block(), [&] {
- b.Call(ty.void_(), core::Function::kTextureStore, texture_a, coords, value);
- b.Call(ty.void_(), core::Function::kTextureStore, texture_b, coords, value);
- b.Call(ty.void_(), core::Function::kTextureStore, texture_c, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, texture_a, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, texture_b, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, texture_c, coords, value);
b.Return(bar);
});
}
@@ -414,9 +414,9 @@
auto* value = b.FunctionParam("value", ty.vec4<f32>());
bar->SetParams({texture, coords, value});
b.Append(bar->Block(), [&] {
- b.Call(ty.void_(), core::Function::kTextureStore, texture, coords, value);
- b.Call(ty.void_(), core::Function::kTextureStore, texture, coords, value);
- b.Call(ty.void_(), core::Function::kTextureStore, texture, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, texture, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, texture, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, texture, coords, value);
b.Return(bar);
});
}
@@ -428,7 +428,7 @@
foo->SetParams({coords, value});
b.Append(foo->Block(), [&] {
auto* load_a = b.Load(var_a->Result());
- b.Call(ty.void_(), core::Function::kTextureStore, load_a, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, load_a, coords, value);
auto* load_b = b.Load(var_a->Result());
b.Call(ty.void_(), bar, load_b, coords, value);
auto* load_c = b.Load(var_a->Result());
@@ -515,7 +515,7 @@
func->SetParams({value, coords});
b.Append(func->Block(), [&] {
auto* load = b.Load(var->Result());
- b.Call(ty.void_(), core::Function::kTextureStore, load, coords, index, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, load, coords, index, value);
b.Return(func);
});
@@ -566,7 +566,7 @@
auto* func = b.Function("foo", ty.vec2<u32>());
b.Append(func->Block(), [&] {
auto* load = b.Load(var->Result());
- auto* dims = b.Call(ty.vec2<u32>(), core::Function::kTextureDimensions, load);
+ auto* dims = b.Call(ty.vec2<u32>(), core::BuiltinFn::kTextureDimensions, load);
b.Return(func, dims);
mod.SetName(dims, "dims");
});
@@ -619,7 +619,7 @@
func->SetParams({coords});
b.Append(func->Block(), [&] {
auto* load = b.Load(var->Result());
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, load, coords);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, load, coords);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -673,8 +673,8 @@
func->SetParams({coords});
b.Append(func->Block(), [&] {
auto* load = b.Load(var->Result());
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, load, coords);
- b.Call(ty.void_(), core::Function::kTextureStore, load, coords, result);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, load, coords);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, load, coords, result);
b.Return(func);
mod.SetName(result, "result");
});
diff --git a/src/tint/lang/core/ir/transform/binary_polyfill.cc b/src/tint/lang/core/ir/transform/binary_polyfill.cc
index fcf6b7e..e4bed28 100644
--- a/src/tint/lang/core/ir/transform/binary_polyfill.cc
+++ b/src/tint/lang/core/ir/transform/binary_polyfill.cc
@@ -180,7 +180,7 @@
auto* rhs_is_minus_one = b.Equal(bool_ty, rhs, minus_one);
cond = b.Or(bool_ty, cond, b.And(bool_ty, lhs_is_lowest, rhs_is_minus_one));
}
- auto* rhs_or_one = b.Call(result_ty, core::Function::kSelect, rhs, one, cond);
+ auto* rhs_or_one = b.Call(result_ty, core::BuiltinFn::kSelect, rhs, one, cond);
if (binary->Kind() == Binary::Kind::kDivide) {
// Perform the divide with the modified RHS.
diff --git a/src/tint/lang/core/ir/transform/builtin_polyfill.cc b/src/tint/lang/core/ir/transform/builtin_polyfill.cc
index d8dc094..e5d13d88 100644
--- a/src/tint/lang/core/ir/transform/builtin_polyfill.cc
+++ b/src/tint/lang/core/ir/transform/builtin_polyfill.cc
@@ -55,32 +55,32 @@
}
if (auto* builtin = inst->As<ir::CoreBuiltinCall>()) {
switch (builtin->Func()) {
- case core::Function::kCountLeadingZeros:
+ case core::BuiltinFn::kCountLeadingZeros:
if (config.count_leading_zeros) {
worklist.Push(builtin);
}
break;
- case core::Function::kCountTrailingZeros:
+ case core::BuiltinFn::kCountTrailingZeros:
if (config.count_trailing_zeros) {
worklist.Push(builtin);
}
break;
- case core::Function::kFirstLeadingBit:
+ case core::BuiltinFn::kFirstLeadingBit:
if (config.first_leading_bit) {
worklist.Push(builtin);
}
break;
- case core::Function::kFirstTrailingBit:
+ case core::BuiltinFn::kFirstTrailingBit:
if (config.first_trailing_bit) {
worklist.Push(builtin);
}
break;
- case core::Function::kSaturate:
+ case core::BuiltinFn::kSaturate:
if (config.saturate) {
worklist.Push(builtin);
}
break;
- case core::Function::kTextureSampleBaseClampToEdge:
+ case core::BuiltinFn::kTextureSampleBaseClampToEdge:
if (config.texture_sample_base_clamp_to_edge_2d_f32) {
auto* tex =
builtin->Args()[0]->Type()->As<core::type::SampledTexture>();
@@ -100,22 +100,22 @@
for (auto* builtin : worklist) {
ir::Value* replacement = nullptr;
switch (builtin->Func()) {
- case core::Function::kCountLeadingZeros:
+ case core::BuiltinFn::kCountLeadingZeros:
replacement = CountLeadingZeros(builtin);
break;
- case core::Function::kCountTrailingZeros:
+ case core::BuiltinFn::kCountTrailingZeros:
replacement = CountTrailingZeros(builtin);
break;
- case core::Function::kFirstLeadingBit:
+ case core::BuiltinFn::kFirstLeadingBit:
replacement = FirstLeadingBit(builtin);
break;
- case core::Function::kFirstTrailingBit:
+ case core::BuiltinFn::kFirstTrailingBit:
replacement = FirstTrailingBit(builtin);
break;
- case core::Function::kSaturate:
+ case core::BuiltinFn::kSaturate:
replacement = Saturate(builtin);
break;
- case core::Function::kTextureSampleBaseClampToEdge:
+ case core::BuiltinFn::kTextureSampleBaseClampToEdge:
replacement = TextureSampleBaseClampToEdge_2d_f32(builtin);
break;
default:
@@ -191,22 +191,22 @@
if (result_ty->is_signed_integer_scalar_or_vector()) {
x = b.Bitcast(uint_ty, x)->Result();
}
- auto* b16 = b.Call(uint_ty, core::Function::kSelect, V(0), V(16),
+ auto* b16 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(16),
b.LessThanEqual(bool_ty, x, V(0x0000ffff)));
x = b.ShiftLeft(uint_ty, x, b16)->Result();
- auto* b8 = b.Call(uint_ty, core::Function::kSelect, V(0), V(8),
+ auto* b8 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(8),
b.LessThanEqual(bool_ty, x, V(0x00ffffff)));
x = b.ShiftLeft(uint_ty, x, b8)->Result();
- auto* b4 = b.Call(uint_ty, core::Function::kSelect, V(0), V(4),
+ auto* b4 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(4),
b.LessThanEqual(bool_ty, x, V(0x0fffffff)));
x = b.ShiftLeft(uint_ty, x, b4)->Result();
- auto* b2 = b.Call(uint_ty, core::Function::kSelect, V(0), V(2),
+ auto* b2 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(2),
b.LessThanEqual(bool_ty, x, V(0x3fffffff)));
x = b.ShiftLeft(uint_ty, x, b2)->Result();
- auto* b1 = b.Call(uint_ty, core::Function::kSelect, V(0), V(1),
+ auto* b1 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(1),
b.LessThanEqual(bool_ty, x, V(0x7fffffff)));
auto* b0 =
- b.Call(uint_ty, core::Function::kSelect, V(0), V(1), b.Equal(bool_ty, x, V(0)));
+ b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(1), b.Equal(bool_ty, x, V(0)));
result = b.Add(uint_ty,
b.Or(uint_ty, b16,
b.Or(uint_ty, b8,
@@ -254,22 +254,22 @@
if (result_ty->is_signed_integer_scalar_or_vector()) {
x = b.Bitcast(uint_ty, x)->Result();
}
- auto* b16 = b.Call(uint_ty, core::Function::kSelect, V(0), V(16),
+ auto* b16 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(16),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x0000ffff)), V(0)));
x = b.ShiftRight(uint_ty, x, b16)->Result();
- auto* b8 = b.Call(uint_ty, core::Function::kSelect, V(0), V(8),
+ auto* b8 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(8),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x000000ff)), V(0)));
x = b.ShiftRight(uint_ty, x, b8)->Result();
- auto* b4 = b.Call(uint_ty, core::Function::kSelect, V(0), V(4),
+ auto* b4 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(4),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x0000000f)), V(0)));
x = b.ShiftRight(uint_ty, x, b4)->Result();
- auto* b2 = b.Call(uint_ty, core::Function::kSelect, V(0), V(2),
+ auto* b2 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(2),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x00000003)), V(0)));
x = b.ShiftRight(uint_ty, x, b2)->Result();
- auto* b1 = b.Call(uint_ty, core::Function::kSelect, V(0), V(1),
+ auto* b1 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(1),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x00000001)), V(0)));
auto* b0 =
- b.Call(uint_ty, core::Function::kSelect, V(0), V(1), b.Equal(bool_ty, x, V(0)));
+ b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(1), b.Equal(bool_ty, x, V(0)));
result = b.Add(uint_ty,
b.Or(uint_ty, b16,
b.Or(uint_ty, b8, b.Or(uint_ty, b4, b.Or(uint_ty, b2, b1)))),
@@ -316,27 +316,27 @@
if (result_ty->is_signed_integer_scalar_or_vector()) {
x = b.Bitcast(uint_ty, x)->Result();
auto* inverted = b.Complement(uint_ty, x);
- x = b.Call(uint_ty, core::Function::kSelect, inverted, x,
+ x = b.Call(uint_ty, core::BuiltinFn::kSelect, inverted, x,
b.LessThan(bool_ty, x, V(0x80000000)))
->Result();
}
- auto* b16 = b.Call(uint_ty, core::Function::kSelect, V(16), V(0),
+ auto* b16 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(16), V(0),
b.Equal(bool_ty, b.And(uint_ty, x, V(0xffff0000)), V(0)));
x = b.ShiftRight(uint_ty, x, b16)->Result();
- auto* b8 = b.Call(uint_ty, core::Function::kSelect, V(8), V(0),
+ auto* b8 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(8), V(0),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x0000ff00)), V(0)));
x = b.ShiftRight(uint_ty, x, b8)->Result();
- auto* b4 = b.Call(uint_ty, core::Function::kSelect, V(4), V(0),
+ auto* b4 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(4), V(0),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x000000f0)), V(0)));
x = b.ShiftRight(uint_ty, x, b4)->Result();
- auto* b2 = b.Call(uint_ty, core::Function::kSelect, V(2), V(0),
+ auto* b2 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(2), V(0),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x0000000c)), V(0)));
x = b.ShiftRight(uint_ty, x, b2)->Result();
- auto* b1 = b.Call(uint_ty, core::Function::kSelect, V(1), V(0),
+ auto* b1 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(1), V(0),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x00000002)), V(0)));
result = b.Or(uint_ty, b16, b.Or(uint_ty, b8, b.Or(uint_ty, b4, b.Or(uint_ty, b2, b1))))
->Result();
- result = b.Call(uint_ty, core::Function::kSelect, result, V(0xffffffff),
+ result = b.Call(uint_ty, core::BuiltinFn::kSelect, result, V(0xffffffff),
b.Equal(bool_ty, x, V(0)))
->Result();
if (result_ty->is_signed_integer_scalar_or_vector()) {
@@ -380,23 +380,23 @@
if (result_ty->is_signed_integer_scalar_or_vector()) {
x = b.Bitcast(uint_ty, x)->Result();
}
- auto* b16 = b.Call(uint_ty, core::Function::kSelect, V(0), V(16),
+ auto* b16 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(16),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x0000ffff)), V(0)));
x = b.ShiftRight(uint_ty, x, b16)->Result();
- auto* b8 = b.Call(uint_ty, core::Function::kSelect, V(0), V(8),
+ auto* b8 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(8),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x000000ff)), V(0)));
x = b.ShiftRight(uint_ty, x, b8)->Result();
- auto* b4 = b.Call(uint_ty, core::Function::kSelect, V(0), V(4),
+ auto* b4 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(4),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x0000000f)), V(0)));
x = b.ShiftRight(uint_ty, x, b4)->Result();
- auto* b2 = b.Call(uint_ty, core::Function::kSelect, V(0), V(2),
+ auto* b2 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(2),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x00000003)), V(0)));
x = b.ShiftRight(uint_ty, x, b2)->Result();
- auto* b1 = b.Call(uint_ty, core::Function::kSelect, V(0), V(1),
+ auto* b1 = b.Call(uint_ty, core::BuiltinFn::kSelect, V(0), V(1),
b.Equal(bool_ty, b.And(uint_ty, x, V(0x00000001)), V(0)));
result = b.Or(uint_ty, b16, b.Or(uint_ty, b8, b.Or(uint_ty, b4, b.Or(uint_ty, b2, b1))))
->Result();
- result = b.Call(uint_ty, core::Function::kSelect, result, V(0xffffffff),
+ result = b.Call(uint_ty, core::BuiltinFn::kSelect, result, V(0xffffffff),
b.Equal(bool_ty, x, V(0)))
->Result();
if (result_ty->is_signed_integer_scalar_or_vector()) {
@@ -421,7 +421,7 @@
zero = MatchWidth(b.Constant(0_h), type);
one = MatchWidth(b.Constant(1_h), type);
}
- auto* clamp = b.Call(type, core::Function::kClamp, Vector{call->Args()[0], zero, one});
+ auto* clamp = b.Call(type, core::BuiltinFn::kClamp, Vector{call->Args()[0], zero, one});
clamp->InsertBefore(call);
return clamp->Result();
}
@@ -441,13 +441,13 @@
auto* coords = call->Args()[2];
b.InsertBefore(call, [&] {
auto* vec2f = ty.vec2<f32>();
- auto* dims = b.Call(ty.vec2<u32>(), core::Function::kTextureDimensions, texture);
+ auto* dims = b.Call(ty.vec2<u32>(), core::BuiltinFn::kTextureDimensions, texture);
auto* fdims = b.Convert(vec2f, dims);
auto* half_texel = b.Divide(vec2f, b.Splat(vec2f, 0.5_f, 2), fdims);
auto* one_minus_half_texel = b.Subtract(vec2f, b.Splat(vec2f, 1_f, 2), half_texel);
auto* clamped =
- b.Call(vec2f, core::Function::kClamp, coords, half_texel, one_minus_half_texel);
- result = b.Call(ty.vec4<f32>(), core::Function::kTextureSampleLevel, texture, sampler,
+ b.Call(vec2f, core::BuiltinFn::kClamp, coords, half_texel, one_minus_half_texel);
+ result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleLevel, texture, sampler,
clamped, 0_f)
->Result();
});
diff --git a/src/tint/lang/core/ir/transform/builtin_polyfill_test.cc b/src/tint/lang/core/ir/transform/builtin_polyfill_test.cc
index a89ed53..869c89c 100644
--- a/src/tint/lang/core/ir/transform/builtin_polyfill_test.cc
+++ b/src/tint/lang/core/ir/transform/builtin_polyfill_test.cc
@@ -31,7 +31,7 @@
/// @param builtin the builtin to call
/// @param result_ty the result type of the builtin call
/// @param arg_types the arguments types for the builtin call
- void Build(core::Function builtin,
+ void Build(core::BuiltinFn builtin,
const core::type::Type* result_ty,
VectorRef<const core::type::Type*> arg_types) {
Vector<FunctionParam*, 4> args;
@@ -49,7 +49,7 @@
};
TEST_F(IR_BuiltinPolyfillTest, Saturate_NoPolyfill) {
- Build(core::Function::kSaturate, ty.f32(), Vector{ty.f32()});
+ Build(core::BuiltinFn::kSaturate, ty.f32(), Vector{ty.f32()});
auto* src = R"(
%foo = func(%arg:f32):f32 -> %b1 {
%b1 = block {
@@ -69,7 +69,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, Saturate_F32) {
- Build(core::Function::kSaturate, ty.f32(), Vector{ty.f32()});
+ Build(core::BuiltinFn::kSaturate, ty.f32(), Vector{ty.f32()});
auto* src = R"(
%foo = func(%arg:f32):f32 -> %b1 {
%b1 = block {
@@ -96,7 +96,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, Saturate_F16) {
- Build(core::Function::kSaturate, ty.f16(), Vector{ty.f16()});
+ Build(core::BuiltinFn::kSaturate, ty.f16(), Vector{ty.f16()});
auto* src = R"(
%foo = func(%arg:f16):f16 -> %b1 {
%b1 = block {
@@ -122,7 +122,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, Saturate_Vec2F32) {
- Build(core::Function::kSaturate, ty.vec2<f32>(), Vector{ty.vec2<f32>()});
+ Build(core::BuiltinFn::kSaturate, ty.vec2<f32>(), Vector{ty.vec2<f32>()});
auto* src = R"(
%foo = func(%arg:vec2<f32>):vec2<f32> -> %b1 {
%b1 = block {
@@ -149,7 +149,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, Saturate_Vec4F16) {
- Build(core::Function::kSaturate, ty.vec4<f16>(), Vector{ty.vec4<f16>()});
+ Build(core::BuiltinFn::kSaturate, ty.vec4<f16>(), Vector{ty.vec4<f16>()});
auto* src = R"(
%foo = func(%arg:vec4<f16>):vec4<f16> -> %b1 {
%b1 = block {
@@ -176,7 +176,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, CountLeadingZeros_NoPolyfill) {
- Build(core::Function::kCountLeadingZeros, ty.u32(), Vector{ty.u32()});
+ Build(core::BuiltinFn::kCountLeadingZeros, ty.u32(), Vector{ty.u32()});
auto* src = R"(
%foo = func(%arg:u32):u32 -> %b1 {
%b1 = block {
@@ -196,7 +196,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, CountLeadingZeros_U32) {
- Build(core::Function::kCountLeadingZeros, ty.u32(), Vector{ty.u32()});
+ Build(core::BuiltinFn::kCountLeadingZeros, ty.u32(), Vector{ty.u32()});
auto* src = R"(
%foo = func(%arg:u32):u32 -> %b1 {
%b1 = block {
@@ -244,7 +244,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, CountLeadingZeros_I32) {
- Build(core::Function::kCountLeadingZeros, ty.i32(), Vector{ty.i32()});
+ Build(core::BuiltinFn::kCountLeadingZeros, ty.i32(), Vector{ty.i32()});
auto* src = R"(
%foo = func(%arg:i32):i32 -> %b1 {
%b1 = block {
@@ -294,7 +294,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, CountLeadingZeros_Vec2U32) {
- Build(core::Function::kCountLeadingZeros, ty.vec2<u32>(), Vector{ty.vec2<u32>()});
+ Build(core::BuiltinFn::kCountLeadingZeros, ty.vec2<u32>(), Vector{ty.vec2<u32>()});
auto* src = R"(
%foo = func(%arg:vec2<u32>):vec2<u32> -> %b1 {
%b1 = block {
@@ -342,7 +342,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, CountLeadingZeros_Vec4I32) {
- Build(core::Function::kCountLeadingZeros, ty.vec4<i32>(), Vector{ty.vec4<i32>()});
+ Build(core::BuiltinFn::kCountLeadingZeros, ty.vec4<i32>(), Vector{ty.vec4<i32>()});
auto* src = R"(
%foo = func(%arg:vec4<i32>):vec4<i32> -> %b1 {
%b1 = block {
@@ -392,7 +392,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, CountTrailingZeros_NoPolyfill) {
- Build(core::Function::kCountTrailingZeros, ty.u32(), Vector{ty.u32()});
+ Build(core::BuiltinFn::kCountTrailingZeros, ty.u32(), Vector{ty.u32()});
auto* src = R"(
%foo = func(%arg:u32):u32 -> %b1 {
%b1 = block {
@@ -412,7 +412,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, CountTrailingZeros_U32) {
- Build(core::Function::kCountTrailingZeros, ty.u32(), Vector{ty.u32()});
+ Build(core::BuiltinFn::kCountTrailingZeros, ty.u32(), Vector{ty.u32()});
auto* src = R"(
%foo = func(%arg:u32):u32 -> %b1 {
%b1 = block {
@@ -464,7 +464,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, CountTrailingZeros_I32) {
- Build(core::Function::kCountTrailingZeros, ty.i32(), Vector{ty.i32()});
+ Build(core::BuiltinFn::kCountTrailingZeros, ty.i32(), Vector{ty.i32()});
auto* src = R"(
%foo = func(%arg:i32):i32 -> %b1 {
%b1 = block {
@@ -518,7 +518,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, CountTrailingZeros_Vec2U32) {
- Build(core::Function::kCountTrailingZeros, ty.vec2<u32>(), Vector{ty.vec2<u32>()});
+ Build(core::BuiltinFn::kCountTrailingZeros, ty.vec2<u32>(), Vector{ty.vec2<u32>()});
auto* src = R"(
%foo = func(%arg:vec2<u32>):vec2<u32> -> %b1 {
%b1 = block {
@@ -570,7 +570,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, CountTrailingZeros_Vec4I32) {
- Build(core::Function::kCountTrailingZeros, ty.vec4<i32>(), Vector{ty.vec4<i32>()});
+ Build(core::BuiltinFn::kCountTrailingZeros, ty.vec4<i32>(), Vector{ty.vec4<i32>()});
auto* src = R"(
%foo = func(%arg:vec4<i32>):vec4<i32> -> %b1 {
%b1 = block {
@@ -597,7 +597,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, FirstLeadingBit_NoPolyfill) {
- Build(core::Function::kFirstLeadingBit, ty.u32(), Vector{ty.u32()});
+ Build(core::BuiltinFn::kFirstLeadingBit, ty.u32(), Vector{ty.u32()});
auto* src = R"(
%foo = func(%arg:u32):u32 -> %b1 {
%b1 = block {
@@ -617,7 +617,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, FirstLeadingBit_U32) {
- Build(core::Function::kFirstLeadingBit, ty.u32(), Vector{ty.u32()});
+ Build(core::BuiltinFn::kFirstLeadingBit, ty.u32(), Vector{ty.u32()});
auto* src = R"(
%foo = func(%arg:u32):u32 -> %b1 {
%b1 = block {
@@ -668,7 +668,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, FirstLeadingBit_I32) {
- Build(core::Function::kFirstLeadingBit, ty.i32(), Vector{ty.i32()});
+ Build(core::BuiltinFn::kFirstLeadingBit, ty.i32(), Vector{ty.i32()});
auto* src = R"(
%foo = func(%arg:i32):i32 -> %b1 {
%b1 = block {
@@ -724,7 +724,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, FirstLeadingBit_Vec2U32) {
- Build(core::Function::kFirstLeadingBit, ty.vec2<u32>(), Vector{ty.vec2<u32>()});
+ Build(core::BuiltinFn::kFirstLeadingBit, ty.vec2<u32>(), Vector{ty.vec2<u32>()});
auto* src = R"(
%foo = func(%arg:vec2<u32>):vec2<u32> -> %b1 {
%b1 = block {
@@ -775,7 +775,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, FirstLeadingBit_Vec4I32) {
- Build(core::Function::kFirstLeadingBit, ty.vec4<i32>(), Vector{ty.vec4<i32>()});
+ Build(core::BuiltinFn::kFirstLeadingBit, ty.vec4<i32>(), Vector{ty.vec4<i32>()});
auto* src = R"(
%foo = func(%arg:vec4<i32>):vec4<i32> -> %b1 {
%b1 = block {
@@ -831,7 +831,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, FirstTrailingBit_NoPolyfill) {
- Build(core::Function::kFirstTrailingBit, ty.u32(), Vector{ty.u32()});
+ Build(core::BuiltinFn::kFirstTrailingBit, ty.u32(), Vector{ty.u32()});
auto* src = R"(
%foo = func(%arg:u32):u32 -> %b1 {
%b1 = block {
@@ -851,7 +851,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, FirstTrailingBit_U32) {
- Build(core::Function::kFirstTrailingBit, ty.u32(), Vector{ty.u32()});
+ Build(core::BuiltinFn::kFirstTrailingBit, ty.u32(), Vector{ty.u32()});
auto* src = R"(
%foo = func(%arg:u32):u32 -> %b1 {
%b1 = block {
@@ -902,7 +902,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, FirstTrailingBit_I32) {
- Build(core::Function::kFirstTrailingBit, ty.i32(), Vector{ty.i32()});
+ Build(core::BuiltinFn::kFirstTrailingBit, ty.i32(), Vector{ty.i32()});
auto* src = R"(
%foo = func(%arg:i32):i32 -> %b1 {
%b1 = block {
@@ -955,7 +955,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, FirstTrailingBit_Vec2U32) {
- Build(core::Function::kFirstTrailingBit, ty.vec2<u32>(), Vector{ty.vec2<u32>()});
+ Build(core::BuiltinFn::kFirstTrailingBit, ty.vec2<u32>(), Vector{ty.vec2<u32>()});
auto* src = R"(
%foo = func(%arg:vec2<u32>):vec2<u32> -> %b1 {
%b1 = block {
@@ -1006,7 +1006,7 @@
}
TEST_F(IR_BuiltinPolyfillTest, FirstTrailingBit_Vec4I32) {
- Build(core::Function::kFirstTrailingBit, ty.vec4<i32>(), Vector{ty.vec4<i32>()});
+ Build(core::BuiltinFn::kFirstTrailingBit, ty.vec4<i32>(), Vector{ty.vec4<i32>()});
auto* src = R"(
%foo = func(%arg:vec4<i32>):vec4<i32> -> %b1 {
%b1 = block {
@@ -1061,7 +1061,7 @@
TEST_F(IR_BuiltinPolyfillTest, TextureSampleBaseClampToEdge_2d_f32_NoPolyfill) {
auto* texture_ty =
ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32());
- Build(core::Function::kTextureSampleBaseClampToEdge, ty.vec4<f32>(),
+ Build(core::BuiltinFn::kTextureSampleBaseClampToEdge, ty.vec4<f32>(),
Vector{texture_ty, ty.sampler(), ty.vec2<f32>()});
auto* src = R"(
%foo = func(%arg:texture_2d<f32>, %arg_1:sampler, %arg_2:vec2<f32>):vec4<f32> -> %b1 { # %arg_1: 'arg', %arg_2: 'arg'
@@ -1084,7 +1084,7 @@
TEST_F(IR_BuiltinPolyfillTest, TextureSampleBaseClampToEdge_2d_f32) {
auto* texture_ty =
ty.Get<core::type::SampledTexture>(core::type::TextureDimension::k2d, ty.f32());
- Build(core::Function::kTextureSampleBaseClampToEdge, ty.vec4<f32>(),
+ Build(core::BuiltinFn::kTextureSampleBaseClampToEdge, ty.vec4<f32>(),
Vector{texture_ty, ty.sampler(), ty.vec2<f32>()});
auto* src = R"(
%foo = func(%arg:texture_2d<f32>, %arg_1:sampler, %arg_2:vec2<f32>):vec4<f32> -> %b1 { # %arg_1: 'arg', %arg_2: 'arg'
diff --git a/src/tint/lang/core/ir/transform/demote_to_helper_test.cc b/src/tint/lang/core/ir/transform/demote_to_helper_test.cc
index 655c714..cc10af2 100644
--- a/src/tint/lang/core/ir/transform/demote_to_helper_test.cc
+++ b/src/tint/lang/core/ir/transform/demote_to_helper_test.cc
@@ -536,7 +536,7 @@
b.Discard();
b.ExitIf(ifelse);
});
- b.Call(ty.void_(), core::Function::kTextureStore, b.Load(texture), coord,
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, b.Load(texture), coord,
b.Splat(b.ir.Types().vec4<f32>(), 0.5_f, 4));
b.Return(ep, 0.5_f);
});
@@ -618,7 +618,7 @@
b.Discard();
b.ExitIf(ifelse);
});
- b.Call(ty.void_(), core::Function::kAtomicStore, buffer, 42_i);
+ b.Call(ty.void_(), core::BuiltinFn::kAtomicStore, buffer, 42_i);
b.Return(ep, 0.5_f);
});
@@ -697,7 +697,7 @@
b.Discard();
b.ExitIf(ifelse);
});
- auto* old = b.Call(ty.i32(), core::Function::kAtomicAdd, buffer, 42_i);
+ auto* old = b.Call(ty.i32(), core::BuiltinFn::kAtomicAdd, buffer, 42_i);
b.Add(ty.i32(), old, 1_i);
b.Return(ep, 0.5_f);
});
@@ -782,7 +782,7 @@
});
auto* result =
b.Call(core::type::CreateAtomicCompareExchangeResult(ty, mod.symbols, ty.i32()),
- core::Function::kAtomicCompareExchangeWeak, buffer, 0_i, 42_i);
+ core::BuiltinFn::kAtomicCompareExchangeWeak, buffer, 0_i, 42_i);
b.Add(ty.i32(), b.Access(ty.i32(), result, 0_i), 1_i);
b.Return(ep, 0.5_f);
});
diff --git a/src/tint/lang/core/ir/transform/multiplanar_external_texture.cc b/src/tint/lang/core/ir/transform/multiplanar_external_texture.cc
index 06eb634..2a94be1 100644
--- a/src/tint/lang/core/ir/transform/multiplanar_external_texture.cc
+++ b/src/tint/lang/core/ir/transform/multiplanar_external_texture.cc
@@ -202,10 +202,10 @@
load->Destroy();
},
[&](CoreBuiltinCall* call) {
- if (call->Func() == core::Function::kTextureDimensions) {
+ if (call->Func() == core::BuiltinFn::kTextureDimensions) {
// Use the first plane for the `textureDimensions()` call.
call->SetOperand(use.operand_index, plane_0);
- } else if (call->Func() == core::Function::kTextureLoad) {
+ } else if (call->Func() == core::BuiltinFn::kTextureLoad) {
// Convert the coordinates to unsigned integers if necessary.
auto* coords = call->Args()[1];
if (coords->Type()->is_signed_integer_vector()) {
@@ -220,7 +220,7 @@
helper->InsertBefore(call);
call->Result()->ReplaceAllUsesWith(helper->Result());
call->Destroy();
- } else if (call->Func() == core::Function::kTextureSampleBaseClampToEdge) {
+ } else if (call->Func() == core::BuiltinFn::kTextureSampleBaseClampToEdge) {
// Call the `TextureSampleExternal()` helper function.
auto* sampler = call->Args()[1];
auto* coords = call->Args()[2];
@@ -320,17 +320,17 @@
auto* F = b.Access(ty.f32(), params, 6_u);
auto* G_splat = b.Construct(vec3f, G);
auto* D_splat = b.Construct(vec3f, D);
- auto* abs_v = b.Call(vec3f, core::Function::kAbs, v);
- auto* sign_v = b.Call(vec3f, core::Function::kSign, v);
+ auto* abs_v = b.Call(vec3f, core::BuiltinFn::kAbs, v);
+ auto* sign_v = b.Call(vec3f, core::BuiltinFn::kSign, v);
auto* cond = b.LessThan(ty.vec3<bool>(), abs_v, D_splat);
auto* t = b.Multiply(vec3f, sign_v, b.Add(vec3f, b.Multiply(vec3f, C, abs_v), F));
auto* f =
b.Multiply(vec3f, sign_v,
b.Add(vec3f,
- b.Call(vec3f, core::Function::kPow,
+ b.Call(vec3f, core::BuiltinFn::kPow,
b.Add(vec3f, b.Multiply(vec3f, A, abs_v), B), G_splat),
E));
- b.Return(gamma_correction, b.Call(vec3f, core::Function::kSelect, f, t, cond));
+ b.Return(gamma_correction, b.Call(vec3f, core::BuiltinFn::kSelect, f, t, cond));
});
return gamma_correction;
@@ -390,7 +390,7 @@
if_planes_eq_1->SetResults(rgb_result, alpha_result);
b.Append(if_planes_eq_1->True(), [&] {
// Load the texel from the first plane and split into separate rgb and a values.
- auto* texel = b.Call(vec4f, core::Function::kTextureLoad, plane_0, coords, 0_u);
+ auto* texel = b.Call(vec4f, core::BuiltinFn::kTextureLoad, plane_0, coords, 0_u);
auto* rgb = b.Swizzle(vec3f, texel, {0u, 1u, 2u});
auto* a = b.Access(ty.f32(), texel, 3_u);
b.ExitIf(if_planes_eq_1, rgb, a);
@@ -398,14 +398,14 @@
b.Append(if_planes_eq_1->False(), [&] {
// Load the y value from the first plane.
auto* y = b.Access(
- ty.f32(), b.Call(vec4f, core::Function::kTextureLoad, plane_0, coords, 0_u),
+ ty.f32(), b.Call(vec4f, core::BuiltinFn::kTextureLoad, plane_0, coords, 0_u),
0_u);
// Load the uv value from the second plane.
auto* coord_uv =
b.ShiftRight(ty.vec2<u32>(), coords, b.Splat(ty.vec2<u32>(), 1_u, 2u));
auto* uv = b.Swizzle(
- vec2f, b.Call(vec4f, core::Function::kTextureLoad, plane_1, coord_uv, 0_u),
+ vec2f, b.Call(vec4f, core::BuiltinFn::kTextureLoad, plane_1, coord_uv, 0_u),
{0u, 1u});
// Convert the combined yuv value into rgb and set the alpha to 1.0.
@@ -498,16 +498,16 @@
auto* modified_coords =
b.Multiply(vec2f, transformation_matrix, b.Construct(vec3f, coords, 1_f));
auto* plane0_dims = b.Convert(
- vec2f, b.Call(ty.vec2<u32>(), core::Function::kTextureDimensions, plane_0));
+ vec2f, b.Call(ty.vec2<u32>(), core::BuiltinFn::kTextureDimensions, plane_0));
auto* plane0_half_texel = b.Divide(vec2f, b.Splat(vec2f, 0.5_f, 2u), plane0_dims);
auto* plane0_clamped =
- b.Call(vec2f, core::Function::kClamp, modified_coords, plane0_half_texel,
+ b.Call(vec2f, core::BuiltinFn::kClamp, modified_coords, plane0_half_texel,
b.Subtract(vec2f, 1_f, plane0_half_texel));
auto* plane1_dims = b.Convert(
- vec2f, b.Call(ty.vec2<u32>(), core::Function::kTextureDimensions, plane_1));
+ vec2f, b.Call(ty.vec2<u32>(), core::BuiltinFn::kTextureDimensions, plane_1));
auto* plane1_half_texel = b.Divide(vec2f, b.Splat(vec2f, 0.5_f, 2u), plane1_dims);
auto* plane1_clamped =
- b.Call(vec2f, core::Function::kClamp, modified_coords, plane1_half_texel,
+ b.Call(vec2f, core::BuiltinFn::kClamp, modified_coords, plane1_half_texel,
b.Subtract(vec2f, 1_f, plane1_half_texel));
auto* rgb_result = b.InstructionResult(vec3f);
@@ -517,7 +517,7 @@
if_planes_eq_1->SetResults(rgb_result, alpha_result);
b.Append(if_planes_eq_1->True(), [&] {
// Sample the texel from the first plane and split into separate rgb and a values.
- auto* texel = b.Call(vec4f, core::Function::kTextureSampleLevel, plane_0, sampler,
+ auto* texel = b.Call(vec4f, core::BuiltinFn::kTextureSampleLevel, plane_0, sampler,
plane0_clamped, 0_f);
auto* rgb = b.Swizzle(vec3f, texel, {0u, 1u, 2u});
auto* a = b.Access(ty.f32(), texel, 3_u);
@@ -526,13 +526,13 @@
b.Append(if_planes_eq_1->False(), [&] {
// Sample the y value from the first plane.
auto* y = b.Access(ty.f32(),
- b.Call(vec4f, core::Function::kTextureSampleLevel, plane_0,
+ b.Call(vec4f, core::BuiltinFn::kTextureSampleLevel, plane_0,
sampler, plane0_clamped, 0_f),
0_u);
// Sample the uv value from the second plane.
auto* uv = b.Swizzle(vec2f,
- b.Call(vec4f, core::Function::kTextureSampleLevel, plane_1,
+ b.Call(vec4f, core::BuiltinFn::kTextureSampleLevel, plane_1,
sampler, plane1_clamped, 0_f),
{0u, 1u});
diff --git a/src/tint/lang/core/ir/transform/multiplanar_external_texture_test.cc b/src/tint/lang/core/ir/transform/multiplanar_external_texture_test.cc
index 25cba9b..d38c80a 100644
--- a/src/tint/lang/core/ir/transform/multiplanar_external_texture_test.cc
+++ b/src/tint/lang/core/ir/transform/multiplanar_external_texture_test.cc
@@ -185,7 +185,7 @@
auto* func = b.Function("foo", ty.vec2<u32>());
b.Append(func->Block(), [&] {
auto* load = b.Load(var->Result());
- auto* result = b.Call(ty.vec2<u32>(), core::Function::kTextureDimensions, load);
+ auto* result = b.Call(ty.vec2<u32>(), core::BuiltinFn::kTextureDimensions, load);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -260,7 +260,7 @@
func->SetParams({coords});
b.Append(func->Block(), [&] {
auto* load = b.Load(var->Result());
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, load, coords);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, load, coords);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -404,7 +404,7 @@
func->SetParams({coords});
b.Append(func->Block(), [&] {
auto* load = b.Load(var->Result());
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, load, coords);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, load, coords);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -550,7 +550,7 @@
func->SetParams({sampler, coords});
b.Append(func->Block(), [&] {
auto* load = b.Load(var->Result());
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSampleBaseClampToEdge, load,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleBaseClampToEdge, load,
sampler, coords);
b.Return(func, result);
mod.SetName(result, "result");
@@ -709,7 +709,7 @@
auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
foo->SetParams({texture, sampler, coords});
b.Append(foo->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSampleBaseClampToEdge,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleBaseClampToEdge,
texture, sampler, coords);
b.Return(foo, result);
mod.SetName(result, "result");
@@ -894,7 +894,7 @@
auto* coords = b.FunctionParam("coords", ty.vec2<f32>());
foo->SetParams({texture, sampler, coords});
b.Append(foo->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSampleBaseClampToEdge,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleBaseClampToEdge,
texture, sampler, coords);
b.Return(foo, result);
mod.SetName(result, "result");
@@ -908,12 +908,12 @@
bar->SetParams({sampler, coords_f});
b.Append(bar->Block(), [&] {
auto* load_a = b.Load(var->Result());
- b.Call(ty.vec2<u32>(), core::Function::kTextureDimensions, load_a);
+ b.Call(ty.vec2<u32>(), core::BuiltinFn::kTextureDimensions, load_a);
auto* load_b = b.Load(var->Result());
- b.Call(ty.vec4<f32>(), core::Function::kTextureSampleBaseClampToEdge, load_b, sampler,
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleBaseClampToEdge, load_b, sampler,
coords_f);
auto* load_c = b.Load(var->Result());
- b.Call(ty.vec4<f32>(), core::Function::kTextureSampleBaseClampToEdge, load_c, sampler,
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleBaseClampToEdge, load_c, sampler,
coords_f);
auto* load_d = b.Load(var->Result());
auto* result_a = b.Call(ty.vec4<f32>(), foo, load_d, sampler, coords_f);
@@ -1117,11 +1117,11 @@
foo->SetParams({coords});
b.Append(foo->Block(), [&] {
auto* load_a = b.Load(var_a->Result());
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, load_a, coords);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, load_a, coords);
auto* load_b = b.Load(var_b->Result());
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, load_b, coords);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, load_b, coords);
auto* load_c = b.Load(var_c->Result());
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, load_c, coords);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, load_c, coords);
b.Return(foo);
});
diff --git a/src/tint/lang/core/ir/transform/robustness.cc b/src/tint/lang/core/ir/transform/robustness.cc
index 6eef036..77216e1 100644
--- a/src/tint/lang/core/ir/transform/robustness.cc
+++ b/src/tint/lang/core/ir/transform/robustness.cc
@@ -86,9 +86,9 @@
[&](ir::CoreBuiltinCall* call) {
// Check if this is a texture builtin that needs to be clamped.
if (config.clamp_texture) {
- if (call->Func() == core::Function::kTextureDimensions ||
- call->Func() == core::Function::kTextureLoad ||
- call->Func() == core::Function::kTextureStore) {
+ if (call->Func() == core::BuiltinFn::kTextureDimensions ||
+ call->Func() == core::BuiltinFn::kTextureLoad ||
+ call->Func() == core::BuiltinFn::kTextureStore) {
texture_calls.Push(call);
}
}
@@ -192,7 +192,7 @@
const_limit->Value()->ValueAs<uint32_t>())));
} else {
// Clamp it to the dynamic limit.
- clamped_idx = b.Call(ty.u32(), core::Function::kMin, CastToU32(idx), limit)->Result();
+ clamped_idx = b.Call(ty.u32(), core::BuiltinFn::kMin, CastToU32(idx), limit)->Result();
}
// Replace the index operand with the clamped version.
@@ -242,7 +242,7 @@
}
// Use the `arrayLength` builtin to get the limit of a runtime-sized array.
- auto* length = b.Call(ty.u32(), core::Function::kArrayLength, object);
+ auto* length = b.Call(ty.u32(), core::BuiltinFn::kArrayLength, object);
return b.Subtract(ty.u32(), length, b.Constant(1_u))->Result();
});
@@ -268,10 +268,10 @@
// Keep hold of the clamped value to use for clamping the coordinates.
Value* clamped_level = nullptr;
auto clamp_level = [&](uint32_t idx) {
- auto* num_levels = b.Call(ty.u32(), core::Function::kTextureNumLevels, args[0]);
+ auto* num_levels = b.Call(ty.u32(), core::BuiltinFn::kTextureNumLevels, args[0]);
auto* limit = b.Subtract(ty.u32(), num_levels, 1_u);
clamped_level =
- b.Call(ty.u32(), core::Function::kMin, CastToU32(args[idx]), limit)->Result();
+ b.Call(ty.u32(), core::BuiltinFn::kMin, CastToU32(args[idx]), limit)->Result();
call->SetOperand(CoreBuiltinCall::kArgsOperandOffset + idx, clamped_level);
};
@@ -283,33 +283,33 @@
type = ty.vec(type, vec->Width());
one = b.Splat(type, one, vec->Width());
}
- auto* dims = clamped_level ? b.Call(type, core::Function::kTextureDimensions, args[0],
+ auto* dims = clamped_level ? b.Call(type, core::BuiltinFn::kTextureDimensions, args[0],
clamped_level)
- : b.Call(type, core::Function::kTextureDimensions, args[0]);
+ : b.Call(type, core::BuiltinFn::kTextureDimensions, args[0]);
auto* limit = b.Subtract(type, dims, one);
call->SetOperand(
CoreBuiltinCall::kArgsOperandOffset + idx,
- b.Call(type, core::Function::kMin, CastToU32(args[idx]), limit)->Result());
+ b.Call(type, core::BuiltinFn::kMin, CastToU32(args[idx]), limit)->Result());
};
// Helper for clamping the array index.
auto clamp_array_index = [&](uint32_t idx) {
- auto* num_layers = b.Call(ty.u32(), core::Function::kTextureNumLayers, args[0]);
+ auto* num_layers = b.Call(ty.u32(), core::BuiltinFn::kTextureNumLayers, args[0]);
auto* limit = b.Subtract(ty.u32(), num_layers, 1_u);
call->SetOperand(
CoreBuiltinCall::kArgsOperandOffset + idx,
- b.Call(ty.u32(), core::Function::kMin, CastToU32(args[idx]), limit)->Result());
+ b.Call(ty.u32(), core::BuiltinFn::kMin, CastToU32(args[idx]), limit)->Result());
};
// Select which arguments to clamp based on the function overload.
switch (call->Func()) {
- case core::Function::kTextureDimensions: {
+ case core::BuiltinFn::kTextureDimensions: {
if (args.Length() > 1) {
clamp_level(1u);
}
break;
}
- case core::Function::kTextureLoad: {
+ case core::BuiltinFn::kTextureLoad: {
clamp_coords(1u);
uint32_t next_arg = 2u;
if (type::IsTextureArray(texture->dim())) {
@@ -320,7 +320,7 @@
}
break;
}
- case core::Function::kTextureStore: {
+ case core::BuiltinFn::kTextureStore: {
clamp_coords(1u);
if (type::IsTextureArray(texture->dim())) {
clamp_array_index(2u);
diff --git a/src/tint/lang/core/ir/transform/robustness_test.cc b/src/tint/lang/core/ir/transform/robustness_test.cc
index e55a5de..b44f547 100644
--- a/src/tint/lang/core/ir/transform/robustness_test.cc
+++ b/src/tint/lang/core/ir/transform/robustness_test.cc
@@ -1944,7 +1944,7 @@
auto* func = b.Function("foo", ty.vec2<u32>());
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* dims = b.Call(ty.vec2<u32>(), core::Function::kTextureDimensions, handle);
+ auto* dims = b.Call(ty.vec2<u32>(), core::BuiltinFn::kTextureDimensions, handle);
b.Return(func, dims);
});
@@ -1984,7 +1984,7 @@
func->SetParams({level});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* dims = b.Call(ty.vec2<u32>(), core::Function::kTextureDimensions, handle, level);
+ auto* dims = b.Call(ty.vec2<u32>(), core::BuiltinFn::kTextureDimensions, handle, level);
b.Return(func, dims);
});
@@ -2042,7 +2042,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords, level);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords, level);
b.Return(func, texel);
});
}
@@ -2055,7 +2055,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords, level);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords, level);
b.Return(func, texel);
});
}
@@ -2139,7 +2139,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords, level);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords, level);
b.Return(func, texel);
});
}
@@ -2152,7 +2152,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords, level);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords, level);
b.Return(func, texel);
});
}
@@ -2238,7 +2238,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords, layer, level);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords, layer, level);
b.Return(func, texel);
});
}
@@ -2252,7 +2252,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords, layer, level);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords, layer, level);
b.Return(func, texel);
});
}
@@ -2343,7 +2343,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords, level);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords, level);
b.Return(func, texel);
});
}
@@ -2356,7 +2356,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords, level);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords, level);
b.Return(func, texel);
});
}
@@ -2441,7 +2441,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords, level);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords, level);
b.Return(func, texel);
});
}
@@ -2454,7 +2454,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords, level);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords, level);
b.Return(func, texel);
});
}
@@ -2529,7 +2529,7 @@
func->SetParams({coords, level});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* texel = b.Call(ty.f32(), core::Function::kTextureLoad, handle, coords, level);
+ auto* texel = b.Call(ty.f32(), core::BuiltinFn::kTextureLoad, handle, coords, level);
b.Return(func, texel);
});
}
@@ -2541,7 +2541,7 @@
func->SetParams({coords, level});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* texel = b.Call(ty.f32(), core::Function::kTextureLoad, handle, coords, level);
+ auto* texel = b.Call(ty.f32(), core::BuiltinFn::kTextureLoad, handle, coords, level);
b.Return(func, texel);
});
}
@@ -2626,7 +2626,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.f32(), core::Function::kTextureLoad, handle, coords, layer, level);
+ b.Call(ty.f32(), core::BuiltinFn::kTextureLoad, handle, coords, layer, level);
b.Return(func, texel);
});
}
@@ -2640,7 +2640,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.f32(), core::Function::kTextureLoad, handle, coords, layer, level);
+ b.Call(ty.f32(), core::BuiltinFn::kTextureLoad, handle, coords, layer, level);
b.Return(func, texel);
});
}
@@ -2730,7 +2730,7 @@
func->SetParams({coords, index});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* texel = b.Call(ty.f32(), core::Function::kTextureLoad, handle, coords, index);
+ auto* texel = b.Call(ty.f32(), core::BuiltinFn::kTextureLoad, handle, coords, index);
b.Return(func, texel);
});
}
@@ -2742,7 +2742,7 @@
func->SetParams({coords, index});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* texel = b.Call(ty.f32(), core::Function::kTextureLoad, handle, coords, index);
+ auto* texel = b.Call(ty.f32(), core::BuiltinFn::kTextureLoad, handle, coords, index);
b.Return(func, texel);
});
}
@@ -2815,7 +2815,7 @@
func->SetParams({coords});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* texel = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords);
+ auto* texel = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords);
b.Return(func, texel);
});
}
@@ -2826,7 +2826,7 @@
func->SetParams({coords});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* texel = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords);
+ auto* texel = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords);
b.Return(func, texel);
});
}
@@ -2905,7 +2905,7 @@
func->SetParams({coords});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* texel = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords);
+ auto* texel = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords);
b.Return(func, texel);
});
}
@@ -2916,7 +2916,7 @@
func->SetParams({coords});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* texel = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords);
+ auto* texel = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords);
b.Return(func, texel);
});
}
@@ -2995,7 +2995,7 @@
func->SetParams({coords});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* texel = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords);
+ auto* texel = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords);
b.Return(func, texel);
});
}
@@ -3006,7 +3006,7 @@
func->SetParams({coords});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* texel = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords);
+ auto* texel = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords);
b.Return(func, texel);
});
}
@@ -3087,7 +3087,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords, layer);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords, layer);
b.Return(func, texel);
});
}
@@ -3100,7 +3100,7 @@
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
auto* texel =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords, layer);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords, layer);
b.Return(func, texel);
});
}
@@ -3186,7 +3186,7 @@
func->SetParams({coords});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* texel = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords);
+ auto* texel = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords);
b.Return(func, texel);
});
}
@@ -3197,7 +3197,7 @@
func->SetParams({coords});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- auto* texel = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, handle, coords);
+ auto* texel = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, handle, coords);
b.Return(func, texel);
});
}
@@ -3277,7 +3277,7 @@
func->SetParams({coords, value});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- b.Call(ty.void_(), core::Function::kTextureStore, handle, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, handle, coords, value);
b.Return(func);
});
}
@@ -3289,7 +3289,7 @@
func->SetParams({coords, value});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- b.Call(ty.void_(), core::Function::kTextureStore, handle, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, handle, coords, value);
b.Return(func);
});
}
@@ -3369,7 +3369,7 @@
func->SetParams({coords, value});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- b.Call(ty.void_(), core::Function::kTextureStore, handle, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, handle, coords, value);
b.Return(func);
});
}
@@ -3381,7 +3381,7 @@
func->SetParams({coords, value});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- b.Call(ty.void_(), core::Function::kTextureStore, handle, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, handle, coords, value);
b.Return(func);
});
}
@@ -3462,7 +3462,7 @@
func->SetParams({coords, layer, value});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- b.Call(ty.void_(), core::Function::kTextureStore, handle, coords, layer, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, handle, coords, layer, value);
b.Return(func);
});
}
@@ -3475,7 +3475,7 @@
func->SetParams({coords, layer, value});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- b.Call(ty.void_(), core::Function::kTextureStore, handle, coords, layer, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, handle, coords, layer, value);
b.Return(func);
});
}
@@ -3562,7 +3562,7 @@
func->SetParams({coords, value});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- b.Call(ty.void_(), core::Function::kTextureStore, handle, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, handle, coords, value);
b.Return(func);
});
}
@@ -3574,7 +3574,7 @@
func->SetParams({coords, value});
b.Append(func->Block(), [&] {
auto* handle = b.Load(texture);
- b.Call(ty.void_(), core::Function::kTextureStore, handle, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, handle, coords, value);
b.Return(func);
});
}
diff --git a/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc b/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
index 839cdb1..1eb6050 100644
--- a/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
@@ -820,7 +820,7 @@
Switch(
call->Target(), //
[&](const sem::Function* fn) { EmitFunctionCall(out, call, fn); },
- [&](const sem::Builtin* builtin) { EmitBuiltinCall(out, call, builtin); },
+ [&](const sem::BuiltinFn* builtin) { EmitBuiltinCall(out, call, builtin); },
[&](const sem::ValueConversion* conv) { EmitValueConversion(out, call, conv); },
[&](const sem::ValueConstructor* ctor) { EmitValueConstructor(out, call, ctor); },
[&](Default) {
@@ -850,40 +850,39 @@
void ASTPrinter::EmitBuiltinCall(StringStream& out,
const sem::Call* call,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
auto* expr = call->Declaration();
if (builtin->IsTexture()) {
EmitTextureCall(out, call, builtin);
- } else if (builtin->Type() == core::Function::kCountOneBits) {
+ } else if (builtin->Fn() == core::BuiltinFn::kCountOneBits) {
EmitCountOneBitsCall(out, expr);
- } else if (builtin->Type() == core::Function::kSelect) {
+ } else if (builtin->Fn() == core::BuiltinFn::kSelect) {
EmitSelectCall(out, expr, builtin);
- } else if (builtin->Type() == core::Function::kDot) {
+ } else if (builtin->Fn() == core::BuiltinFn::kDot) {
EmitDotCall(out, expr, builtin);
- } else if (builtin->Type() == core::Function::kModf) {
+ } else if (builtin->Fn() == core::BuiltinFn::kModf) {
EmitModfCall(out, expr, builtin);
- } else if (builtin->Type() == core::Function::kFrexp) {
+ } else if (builtin->Fn() == core::BuiltinFn::kFrexp) {
EmitFrexpCall(out, expr, builtin);
- } else if (builtin->Type() == core::Function::kDegrees) {
+ } else if (builtin->Fn() == core::BuiltinFn::kDegrees) {
EmitDegreesCall(out, expr, builtin);
- } else if (builtin->Type() == core::Function::kRadians) {
+ } else if (builtin->Fn() == core::BuiltinFn::kRadians) {
EmitRadiansCall(out, expr, builtin);
- } else if (builtin->Type() == core::Function::kQuantizeToF16) {
+ } else if (builtin->Fn() == core::BuiltinFn::kQuantizeToF16) {
EmitQuantizeToF16Call(out, expr, builtin);
- } else if (builtin->Type() == core::Function::kArrayLength) {
+ } else if (builtin->Fn() == core::BuiltinFn::kArrayLength) {
EmitArrayLength(out, expr);
- } else if (builtin->Type() == core::Function::kExtractBits) {
+ } else if (builtin->Fn() == core::BuiltinFn::kExtractBits) {
EmitExtractBits(out, expr);
- } else if (builtin->Type() == core::Function::kInsertBits) {
+ } else if (builtin->Fn() == core::BuiltinFn::kInsertBits) {
EmitInsertBits(out, expr);
- } else if (builtin->Type() == core::Function::kFma && version_.IsES()) {
+ } else if (builtin->Fn() == core::BuiltinFn::kFma && version_.IsES()) {
EmitEmulatedFMA(out, expr);
- } else if (builtin->Type() == core::Function::kAbs &&
+ } else if (builtin->Fn() == core::BuiltinFn::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.
EmitExpression(out, expr->args[0]);
- } else if ((builtin->Type() == core::Function::kAny ||
- builtin->Type() == core::Function::kAll) &&
+ } else if ((builtin->Fn() == core::BuiltinFn::kAny || builtin->Fn() == core::BuiltinFn::kAll) &&
TypeOf(expr->args[0])->UnwrapRef()->Is<core::type::Scalar>()) {
// GLSL does not support any() or all() on scalar arguments. It's a no-op.
EmitExpression(out, expr->args[0]);
@@ -948,7 +947,7 @@
void ASTPrinter::EmitWorkgroupAtomicCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
auto call = [&](const char* name) {
out << name;
{
@@ -964,8 +963,8 @@
return;
};
- switch (builtin->Type()) {
- case core::Function::kAtomicLoad: {
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kAtomicLoad: {
// GLSL does not have an atomicLoad, so we emulate it with
// atomicOr using 0 as the OR value
out << "atomicOr";
@@ -979,7 +978,7 @@
}
return;
}
- case core::Function::kAtomicCompareExchangeWeak: {
+ case core::BuiltinFn::kAtomicCompareExchangeWeak: {
EmitStructType(&helpers_, builtin->ReturnType()->As<core::type::Struct>());
auto* dest = expr->args[0];
@@ -1018,33 +1017,33 @@
return;
}
- case core::Function::kAtomicAdd:
- case core::Function::kAtomicSub:
+ case core::BuiltinFn::kAtomicAdd:
+ case core::BuiltinFn::kAtomicSub:
call("atomicAdd");
return;
- case core::Function::kAtomicMax:
+ case core::BuiltinFn::kAtomicMax:
call("atomicMax");
return;
- case core::Function::kAtomicMin:
+ case core::BuiltinFn::kAtomicMin:
call("atomicMin");
return;
- case core::Function::kAtomicAnd:
+ case core::BuiltinFn::kAtomicAnd:
call("atomicAnd");
return;
- case core::Function::kAtomicOr:
+ case core::BuiltinFn::kAtomicOr:
call("atomicOr");
return;
- case core::Function::kAtomicXor:
+ case core::BuiltinFn::kAtomicXor:
call("atomicXor");
return;
- case core::Function::kAtomicExchange:
- case core::Function::kAtomicStore:
+ case core::BuiltinFn::kAtomicExchange:
+ case core::BuiltinFn::kAtomicStore:
// GLSL does not have an atomicStore, so we emulate it with
// atomicExchange.
call("atomicExchange");
@@ -1054,7 +1053,7 @@
break;
}
- TINT_UNREACHABLE() << "unsupported atomic builtin: " << builtin->Type();
+ TINT_UNREACHABLE() << "unsupported atomic builtin: " << builtin->Fn();
}
void ASTPrinter::EmitArrayLength(StringStream& out, const ast::CallExpression* expr) {
@@ -1107,7 +1106,7 @@
void ASTPrinter::EmitSelectCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
// GLSL does not support ternary expressions with a bool vector conditional,
// so polyfill with a helper.
if (auto* vec = builtin->Parameters()[2]->Type()->As<core::type::Vector>()) {
@@ -1147,7 +1146,7 @@
void ASTPrinter::EmitDotCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
auto* vec_ty = builtin->Parameters()[0]->Type()->As<core::type::Vector>();
std::string fn = "dot";
if (vec_ty->type()->is_integer_scalar()) {
@@ -1202,7 +1201,7 @@
void ASTPrinter::EmitModfCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
TINT_ASSERT(expr->args.Length() == 1);
CallBuiltinHelper(
out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
@@ -1223,7 +1222,7 @@
void ASTPrinter::EmitFrexpCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
TINT_ASSERT(expr->args.Length() == 1);
CallBuiltinHelper(
out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
@@ -1244,7 +1243,7 @@
void ASTPrinter::EmitDegreesCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
auto* return_elem_type = builtin->ReturnType()->DeepestElement();
const std::string suffix = Is<core::type::F16>(return_elem_type) ? "hf" : "f";
CallBuiltinHelper(out, expr, builtin,
@@ -1256,7 +1255,7 @@
void ASTPrinter::EmitRadiansCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
auto* return_elem_type = builtin->ReturnType()->DeepestElement();
const std::string suffix = Is<core::type::F16>(return_elem_type) ? "hf" : "f";
CallBuiltinHelper(out, expr, builtin,
@@ -1268,7 +1267,7 @@
void ASTPrinter::EmitQuantizeToF16Call(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
// Emulate by casting to f16 and back again.
CallBuiltinHelper(
out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
@@ -1297,17 +1296,17 @@
});
}
-void ASTPrinter::EmitBarrierCall(StringStream& out, const sem::Builtin* builtin) {
+void ASTPrinter::EmitBarrierCall(StringStream& out, const sem::BuiltinFn* builtin) {
// TODO(crbug.com/tint/661): Combine sequential barriers to a single
// instruction.
- if (builtin->Type() == core::Function::kWorkgroupBarrier) {
+ if (builtin->Fn() == core::BuiltinFn::kWorkgroupBarrier) {
out << "barrier()";
- } else if (builtin->Type() == core::Function::kStorageBarrier) {
+ } else if (builtin->Fn() == core::BuiltinFn::kStorageBarrier) {
out << "{ barrier(); memoryBarrierBuffer(); }";
- } else if (builtin->Type() == core::Function::kTextureBarrier) {
+ } else if (builtin->Fn() == core::BuiltinFn::kTextureBarrier) {
out << "{ barrier(); memoryBarrierImage(); }";
} else {
- TINT_UNREACHABLE() << "unexpected barrier builtin type " << core::str(builtin->Type());
+ TINT_UNREACHABLE() << "unexpected barrier builtin type " << core::str(builtin->Fn());
}
}
@@ -1323,7 +1322,7 @@
void ASTPrinter::EmitTextureCall(StringStream& out,
const sem::Call* call,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
using Usage = core::ParameterUsage;
auto& signature = builtin->Signature();
@@ -1374,8 +1373,8 @@
return;
};
- switch (builtin->Type()) {
- case core::Function::kTextureDimensions: {
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kTextureDimensions: {
// textureDimensions() returns an unsigned scalar / vector in WGSL.
// textureSize() / imageSize() returns a signed scalar / vector in GLSL.
// Cast.
@@ -1410,7 +1409,7 @@
}
return;
}
- case core::Function::kTextureNumLayers: {
+ case core::BuiltinFn::kTextureNumLayers: {
// textureNumLayers() returns an unsigned scalar in WGSL.
// textureSize() / imageSize() returns a signed scalar / vector in GLSL.
// Cast.
@@ -1441,7 +1440,7 @@
out << ").z";
return;
}
- case core::Function::kTextureNumLevels: {
+ case core::BuiltinFn::kTextureNumLevels: {
// textureNumLevels() returns an unsigned scalar in WGSL.
// textureQueryLevels() returns a signed scalar in GLSL.
// Cast.
@@ -1453,7 +1452,7 @@
out << ")";
return;
}
- case core::Function::kTextureNumSamples: {
+ case core::BuiltinFn::kTextureNumSamples: {
// textureNumSamples() returns an unsigned scalar in WGSL.
// textureSamples() returns a signed scalar in GLSL.
// Cast.
@@ -1473,41 +1472,41 @@
bool append_depth_ref_to_coords = true;
bool is_depth = texture_type->Is<core::type::DepthTexture>();
- switch (builtin->Type()) {
- case core::Function::kTextureSample:
- case core::Function::kTextureSampleBias:
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kTextureSample:
+ case core::BuiltinFn::kTextureSampleBias:
out << "texture";
if (is_depth) {
glsl_ret_width = 1u;
}
break;
- case core::Function::kTextureSampleLevel:
+ case core::BuiltinFn::kTextureSampleLevel:
out << "textureLod";
if (is_depth) {
glsl_ret_width = 1u;
}
break;
- case core::Function::kTextureGather:
- case core::Function::kTextureGatherCompare:
+ case core::BuiltinFn::kTextureGather:
+ case core::BuiltinFn::kTextureGatherCompare:
out << "textureGather";
append_depth_ref_to_coords = false;
break;
- case core::Function::kTextureSampleGrad:
+ case core::BuiltinFn::kTextureSampleGrad:
out << "textureGrad";
break;
- case core::Function::kTextureSampleCompare:
- case core::Function::kTextureSampleCompareLevel:
+ case core::BuiltinFn::kTextureSampleCompare:
+ case core::BuiltinFn::kTextureSampleCompareLevel:
out << "texture";
glsl_ret_width = 1;
break;
- case core::Function::kTextureLoad:
+ case core::BuiltinFn::kTextureLoad:
if (texture_type->Is<core::type::StorageTexture>()) {
out << "imageLoad";
} else {
out << "texelFetch";
}
break;
- case core::Function::kTextureStore:
+ case core::BuiltinFn::kTextureStore:
out << "imageStore";
break;
default:
@@ -1578,7 +1577,7 @@
}
// GLSL's textureGather always requires a refZ parameter.
- if (is_depth && builtin->Type() == core::Function::kTextureGather) {
+ if (is_depth && builtin->Fn() == core::BuiltinFn::kTextureGather) {
out << ", 0.0";
}
@@ -1587,7 +1586,7 @@
if (auto* e = arg(Usage::kDepthRef)) {
out << ", ";
EmitExpression(out, e);
- } else if (builtin->Type() == core::Function::kTextureSample) {
+ } else if (builtin->Fn() == core::BuiltinFn::kTextureSample) {
out << ", 0.0f";
}
}
@@ -1620,121 +1619,121 @@
if (TINT_UNLIKELY(wgsl_ret_width > glsl_ret_width)) {
TINT_ICE() << "WGSL return width (" << wgsl_ret_width
<< ") is wider than GLSL return width (" << glsl_ret_width << ") for "
- << builtin->Type();
+ << builtin->Fn();
return;
}
}
-std::string ASTPrinter::generate_builtin_name(const sem::Builtin* builtin) {
- switch (builtin->Type()) {
- case core::Function::kAbs:
- case core::Function::kAcos:
- case core::Function::kAcosh:
- case core::Function::kAll:
- case core::Function::kAny:
- case core::Function::kAsin:
- case core::Function::kAsinh:
- case core::Function::kAtan:
- case core::Function::kAtanh:
- case core::Function::kCeil:
- case core::Function::kClamp:
- case core::Function::kCos:
- case core::Function::kCosh:
- case core::Function::kCross:
- case core::Function::kDeterminant:
- case core::Function::kDistance:
- case core::Function::kDot:
- case core::Function::kExp:
- case core::Function::kExp2:
- case core::Function::kFloor:
- case core::Function::kFrexp:
- case core::Function::kLdexp:
- case core::Function::kLength:
- case core::Function::kLog:
- case core::Function::kLog2:
- case core::Function::kMax:
- case core::Function::kMin:
- case core::Function::kModf:
- case core::Function::kNormalize:
- case core::Function::kPow:
- case core::Function::kReflect:
- case core::Function::kRefract:
- case core::Function::kRound:
- case core::Function::kSign:
- case core::Function::kSin:
- case core::Function::kSinh:
- case core::Function::kSqrt:
- case core::Function::kStep:
- case core::Function::kTan:
- case core::Function::kTanh:
- case core::Function::kTranspose:
- case core::Function::kTrunc:
+std::string ASTPrinter::generate_builtin_name(const sem::BuiltinFn* builtin) {
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kAbs:
+ case core::BuiltinFn::kAcos:
+ case core::BuiltinFn::kAcosh:
+ case core::BuiltinFn::kAll:
+ case core::BuiltinFn::kAny:
+ case core::BuiltinFn::kAsin:
+ case core::BuiltinFn::kAsinh:
+ case core::BuiltinFn::kAtan:
+ case core::BuiltinFn::kAtanh:
+ case core::BuiltinFn::kCeil:
+ case core::BuiltinFn::kClamp:
+ case core::BuiltinFn::kCos:
+ case core::BuiltinFn::kCosh:
+ case core::BuiltinFn::kCross:
+ case core::BuiltinFn::kDeterminant:
+ case core::BuiltinFn::kDistance:
+ case core::BuiltinFn::kDot:
+ case core::BuiltinFn::kExp:
+ case core::BuiltinFn::kExp2:
+ case core::BuiltinFn::kFloor:
+ case core::BuiltinFn::kFrexp:
+ case core::BuiltinFn::kLdexp:
+ case core::BuiltinFn::kLength:
+ case core::BuiltinFn::kLog:
+ case core::BuiltinFn::kLog2:
+ case core::BuiltinFn::kMax:
+ case core::BuiltinFn::kMin:
+ case core::BuiltinFn::kModf:
+ case core::BuiltinFn::kNormalize:
+ case core::BuiltinFn::kPow:
+ case core::BuiltinFn::kReflect:
+ case core::BuiltinFn::kRefract:
+ case core::BuiltinFn::kRound:
+ case core::BuiltinFn::kSign:
+ case core::BuiltinFn::kSin:
+ case core::BuiltinFn::kSinh:
+ case core::BuiltinFn::kSqrt:
+ case core::BuiltinFn::kStep:
+ case core::BuiltinFn::kTan:
+ case core::BuiltinFn::kTanh:
+ case core::BuiltinFn::kTranspose:
+ case core::BuiltinFn::kTrunc:
return builtin->str();
- case core::Function::kAtan2:
+ case core::BuiltinFn::kAtan2:
return "atan";
- case core::Function::kCountOneBits:
+ case core::BuiltinFn::kCountOneBits:
return "bitCount";
- case core::Function::kDpdx:
+ case core::BuiltinFn::kDpdx:
return "dFdx";
- case core::Function::kDpdxCoarse:
+ case core::BuiltinFn::kDpdxCoarse:
if (version_.IsES()) {
return "dFdx";
}
return "dFdxCoarse";
- case core::Function::kDpdxFine:
+ case core::BuiltinFn::kDpdxFine:
if (version_.IsES()) {
return "dFdx";
}
return "dFdxFine";
- case core::Function::kDpdy:
+ case core::BuiltinFn::kDpdy:
return "dFdy";
- case core::Function::kDpdyCoarse:
+ case core::BuiltinFn::kDpdyCoarse:
if (version_.IsES()) {
return "dFdy";
}
return "dFdyCoarse";
- case core::Function::kDpdyFine:
+ case core::BuiltinFn::kDpdyFine:
if (version_.IsES()) {
return "dFdy";
}
return "dFdyFine";
- case core::Function::kFaceForward:
+ case core::BuiltinFn::kFaceForward:
return "faceforward";
- case core::Function::kFract:
+ case core::BuiltinFn::kFract:
return "fract";
- case core::Function::kFma:
+ case core::BuiltinFn::kFma:
return "fma";
- case core::Function::kFwidth:
- case core::Function::kFwidthCoarse:
- case core::Function::kFwidthFine:
+ case core::BuiltinFn::kFwidth:
+ case core::BuiltinFn::kFwidthCoarse:
+ case core::BuiltinFn::kFwidthFine:
return "fwidth";
- case core::Function::kInverseSqrt:
+ case core::BuiltinFn::kInverseSqrt:
return "inversesqrt";
- case core::Function::kMix:
+ case core::BuiltinFn::kMix:
return "mix";
- case core::Function::kPack2X16Float:
+ case core::BuiltinFn::kPack2X16Float:
return "packHalf2x16";
- case core::Function::kPack2X16Snorm:
+ case core::BuiltinFn::kPack2X16Snorm:
return "packSnorm2x16";
- case core::Function::kPack2X16Unorm:
+ case core::BuiltinFn::kPack2X16Unorm:
return "packUnorm2x16";
- case core::Function::kPack4X8Snorm:
+ case core::BuiltinFn::kPack4X8Snorm:
return "packSnorm4x8";
- case core::Function::kPack4X8Unorm:
+ case core::BuiltinFn::kPack4X8Unorm:
return "packUnorm4x8";
- case core::Function::kReverseBits:
+ case core::BuiltinFn::kReverseBits:
return "bitfieldReverse";
- case core::Function::kSmoothstep:
+ case core::BuiltinFn::kSmoothstep:
return "smoothstep";
- case core::Function::kUnpack2X16Float:
+ case core::BuiltinFn::kUnpack2X16Float:
return "unpackHalf2x16";
- case core::Function::kUnpack2X16Snorm:
+ case core::BuiltinFn::kUnpack2X16Snorm:
return "unpackSnorm2x16";
- case core::Function::kUnpack2X16Unorm:
+ case core::BuiltinFn::kUnpack2X16Unorm:
return "unpackUnorm2x16";
- case core::Function::kUnpack4X8Snorm:
+ case core::BuiltinFn::kUnpack4X8Snorm:
return "unpackSnorm4x8";
- case core::Function::kUnpack4X8Unorm:
+ case core::BuiltinFn::kUnpack4X8Unorm:
return "unpackUnorm4x8";
default:
diagnostics_.add_error(diag::System::Writer,
@@ -2956,14 +2955,14 @@
template <typename F>
void ASTPrinter::CallBuiltinHelper(StringStream& out,
const ast::CallExpression* call,
- const sem::Builtin* builtin,
+ const sem::BuiltinFn* builtin,
F&& build) {
// Generate the helper function if it hasn't been created already
auto fn = tint::GetOrCreate(builtins_, builtin, [&]() -> std::string {
TextBuffer b;
TINT_DEFER(helpers_.Append(b));
- auto fn_name = UniqueIdentifier(std::string("tint_") + core::str(builtin->Type()));
+ auto fn_name = UniqueIdentifier(std::string("tint_") + core::str(builtin->Fn()));
std::vector<std::string> parameter_names;
{
auto decl = Line(&b);
diff --git a/src/tint/lang/glsl/writer/ast_printer/ast_printer.h b/src/tint/lang/glsl/writer/ast_printer/ast_printer.h
index ad44120..eafc002 100644
--- a/src/tint/lang/glsl/writer/ast_printer/ast_printer.h
+++ b/src/tint/lang/glsl/writer/ast_printer/ast_printer.h
@@ -32,7 +32,7 @@
// Forward declarations
namespace tint::sem {
-class Builtin;
+class BuiltinFn;
class Call;
class ValueConstructor;
class ValueConversion;
@@ -143,7 +143,7 @@
/// @param out the output of the expression stream
/// @param call the call expression
/// @param builtin the builtin being called
- void EmitBuiltinCall(StringStream& out, const sem::Call* call, const sem::Builtin* builtin);
+ void EmitBuiltinCall(StringStream& out, const sem::Call* call, const sem::BuiltinFn* builtin);
/// Handles generating a value conversion expression
/// @param out the output of the expression stream
/// @param call the call expression
@@ -161,14 +161,14 @@
/// Handles generating a barrier builtin call
/// @param out the output of the expression stream
/// @param builtin the semantic information for the barrier builtin
- void EmitBarrierCall(StringStream& out, const sem::Builtin* builtin);
+ void EmitBarrierCall(StringStream& out, const sem::BuiltinFn* builtin);
/// Handles generating an atomic builtin call for a workgroup variable
/// @param out the output of the expression stream
/// @param expr the call expression
/// @param builtin the semantic information for the atomic builtin
void EmitWorkgroupAtomicCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating an array.length() call
/// @param out the output of the expression stream
/// @param expr the call expression
@@ -195,7 +195,7 @@
/// @param out the output of the expression stream
/// @param call the call expression
/// @param builtin the semantic information for the texture builtin
- void EmitTextureCall(StringStream& out, const sem::Call* call, const sem::Builtin* builtin);
+ void EmitTextureCall(StringStream& out, const sem::Call* call, const sem::BuiltinFn* builtin);
/// Handles generating a call to the `select()` builtin
/// @param out the output of the expression stream
/// @param expr the call expression
@@ -206,49 +206,49 @@
/// @param builtin the semantic information for the builtin
void EmitSelectCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `dot()` builtin
/// @param out the output of the expression stream
/// @param expr the call expression
/// @param builtin the semantic information for the builtin
void EmitDotCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `modf()` builtin
/// @param out the output of the expression stream
/// @param expr the call expression
/// @param builtin the semantic information for the builtin
void EmitModfCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `frexp()` builtin
/// @param out the output of the expression stream
/// @param expr the call expression
/// @param builtin the semantic information for the builtin
void EmitFrexpCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `degrees()` builtin
/// @param out the output of the expression stream
/// @param expr the call expression
/// @param builtin the semantic information for the builtin
void EmitDegreesCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `radians()` builtin
/// @param out the output of the expression stream
/// @param expr the call expression
/// @param builtin the semantic information for the builtin
void EmitRadiansCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `quantizeToF16()` intrinsic
/// @param out the output of the expression stream
/// @param expr the call expression
/// @param builtin the semantic information for the builtin
void EmitQuantizeToF16Call(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles a case statement
/// @param stmt the statement
void EmitCase(const ast::CaseStatement* stmt);
@@ -402,7 +402,7 @@
/// Handles generating a builtin method name
/// @param builtin the semantic info for the builtin
/// @returns the name or "" if not valid
- std::string generate_builtin_name(const sem::Builtin* builtin);
+ std::string generate_builtin_name(const sem::BuiltinFn* builtin);
/// Converts a builtin to a gl_ string
/// @param builtin the builtin to convert
/// @param stage pipeline stage in which this builtin is used
@@ -440,7 +440,7 @@
template <typename F>
void CallBuiltinHelper(StringStream& out,
const ast::CallExpression* call,
- const sem::Builtin* builtin,
+ const sem::BuiltinFn* builtin,
F&& build);
/// Create a uint type corresponding to the given bool or bool vector type.
@@ -473,7 +473,7 @@
/// Map of builtin structure to unique generated name
std::unordered_map<const core::type::Struct*, std::string> builtin_struct_names_;
std::function<void()> emit_continuing_;
- std::unordered_map<const sem::Builtin*, std::string> builtins_;
+ std::unordered_map<const sem::BuiltinFn*, std::string> builtins_;
std::unordered_map<const core::type::Vector*, std::string> dynamic_vector_write_;
std::unordered_map<const core::type::Vector*, std::string> int_dot_funcs_;
std::unordered_map<BinaryOperandType, std::string> float_modulo_funcs_;
diff --git a/src/tint/lang/glsl/writer/ast_printer/builtin_test.cc b/src/tint/lang/glsl/writer/ast_printer/builtin_test.cc
index 2694b2c..c23b308 100644
--- a/src/tint/lang/glsl/writer/ast_printer/builtin_test.cc
+++ b/src/tint/lang/glsl/writer/ast_printer/builtin_test.cc
@@ -36,7 +36,7 @@
};
struct BuiltinData {
- core::Function builtin;
+ core::BuiltinFn builtin;
CallParamType type;
const char* glsl_name;
};
@@ -60,86 +60,86 @@
return out;
}
-const ast::CallExpression* GenerateCall(core::Function builtin,
+const ast::CallExpression* GenerateCall(core::BuiltinFn builtin,
CallParamType type,
ProgramBuilder* builder) {
std::string name;
StringStream str;
str << name << builtin;
switch (builtin) {
- case core::Function::kAcos:
- case core::Function::kAsin:
- case core::Function::kAtan:
- case core::Function::kCeil:
- case core::Function::kCos:
- case core::Function::kCosh:
- case core::Function::kDpdx:
- case core::Function::kDpdxCoarse:
- case core::Function::kDpdxFine:
- case core::Function::kDpdy:
- case core::Function::kDpdyCoarse:
- case core::Function::kDpdyFine:
- case core::Function::kExp:
- case core::Function::kExp2:
- case core::Function::kFloor:
- case core::Function::kFract:
- case core::Function::kFwidth:
- case core::Function::kFwidthCoarse:
- case core::Function::kFwidthFine:
- case core::Function::kInverseSqrt:
- case core::Function::kLength:
- case core::Function::kLog:
- case core::Function::kLog2:
- case core::Function::kNormalize:
- case core::Function::kRound:
- case core::Function::kSin:
- case core::Function::kSinh:
- case core::Function::kSqrt:
- case core::Function::kTan:
- case core::Function::kTanh:
- case core::Function::kTrunc:
- case core::Function::kSign:
+ case core::BuiltinFn::kAcos:
+ case core::BuiltinFn::kAsin:
+ case core::BuiltinFn::kAtan:
+ case core::BuiltinFn::kCeil:
+ case core::BuiltinFn::kCos:
+ case core::BuiltinFn::kCosh:
+ case core::BuiltinFn::kDpdx:
+ case core::BuiltinFn::kDpdxCoarse:
+ case core::BuiltinFn::kDpdxFine:
+ case core::BuiltinFn::kDpdy:
+ case core::BuiltinFn::kDpdyCoarse:
+ case core::BuiltinFn::kDpdyFine:
+ case core::BuiltinFn::kExp:
+ case core::BuiltinFn::kExp2:
+ case core::BuiltinFn::kFloor:
+ case core::BuiltinFn::kFract:
+ case core::BuiltinFn::kFwidth:
+ case core::BuiltinFn::kFwidthCoarse:
+ case core::BuiltinFn::kFwidthFine:
+ case core::BuiltinFn::kInverseSqrt:
+ case core::BuiltinFn::kLength:
+ case core::BuiltinFn::kLog:
+ case core::BuiltinFn::kLog2:
+ case core::BuiltinFn::kNormalize:
+ case core::BuiltinFn::kRound:
+ case core::BuiltinFn::kSin:
+ case core::BuiltinFn::kSinh:
+ case core::BuiltinFn::kSqrt:
+ case core::BuiltinFn::kTan:
+ case core::BuiltinFn::kTanh:
+ case core::BuiltinFn::kTrunc:
+ case core::BuiltinFn::kSign:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2");
} else {
return builder->Call(str.str(), "f2");
}
- case core::Function::kLdexp:
+ case core::BuiltinFn::kLdexp:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "i2");
} else {
return builder->Call(str.str(), "f2", "i2");
}
- case core::Function::kAtan2:
- case core::Function::kDot:
- case core::Function::kDistance:
- case core::Function::kPow:
- case core::Function::kReflect:
- case core::Function::kStep:
+ case core::BuiltinFn::kAtan2:
+ case core::BuiltinFn::kDot:
+ case core::BuiltinFn::kDistance:
+ case core::BuiltinFn::kPow:
+ case core::BuiltinFn::kReflect:
+ case core::BuiltinFn::kStep:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2");
} else {
return builder->Call(str.str(), "f2", "f2");
}
- case core::Function::kCross:
+ case core::BuiltinFn::kCross:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h3", "h3");
} else {
return builder->Call(str.str(), "f3", "f3");
}
- case core::Function::kFma:
- case core::Function::kMix:
- case core::Function::kFaceForward:
- case core::Function::kSmoothstep:
+ case core::BuiltinFn::kFma:
+ case core::BuiltinFn::kMix:
+ case core::BuiltinFn::kFaceForward:
+ case core::BuiltinFn::kSmoothstep:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2", "h2");
} else {
return builder->Call(str.str(), "f2", "f2", "f2");
}
- case core::Function::kAll:
- case core::Function::kAny:
+ case core::BuiltinFn::kAll:
+ case core::BuiltinFn::kAny:
return builder->Call(str.str(), "b2");
- case core::Function::kAbs:
+ case core::BuiltinFn::kAbs:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2");
} else if (type == CallParamType::kF16) {
@@ -147,11 +147,11 @@
} else {
return builder->Call(str.str(), "u2");
}
- case core::Function::kCountOneBits:
- case core::Function::kReverseBits:
+ case core::BuiltinFn::kCountOneBits:
+ case core::BuiltinFn::kReverseBits:
return builder->Call(str.str(), "u2");
- case core::Function::kMax:
- case core::Function::kMin:
+ case core::BuiltinFn::kMax:
+ case core::BuiltinFn::kMin:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2", "f2");
} else if (type == CallParamType::kF16) {
@@ -159,7 +159,7 @@
} else {
return builder->Call(str.str(), "u2", "u2");
}
- case core::Function::kClamp:
+ case core::BuiltinFn::kClamp:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2", "f2", "f2");
} else if (type == CallParamType::kF16) {
@@ -167,19 +167,19 @@
} else {
return builder->Call(str.str(), "u2", "u2", "u2");
}
- case core::Function::kSelect:
+ case core::BuiltinFn::kSelect:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2", "b2");
} else {
return builder->Call(str.str(), "f2", "f2", "b2");
}
- case core::Function::kDeterminant:
+ case core::BuiltinFn::kDeterminant:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "hm2x2");
} else {
return builder->Call(str.str(), "m2x2");
}
- case core::Function::kTranspose:
+ case core::BuiltinFn::kTranspose:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "hm3x2");
} else {
@@ -225,7 +225,7 @@
ASSERT_NE(sem, nullptr);
auto* target = sem->Target();
ASSERT_NE(target, nullptr);
- auto* builtin = target->As<sem::Builtin>();
+ auto* builtin = target->As<sem::BuiltinFn>();
ASSERT_NE(builtin, nullptr);
EXPECT_EQ(gen.generate_builtin_name(builtin), param.glsl_name);
@@ -234,110 +234,110 @@
GlslASTPrinterTest_Builtin,
GlslBuiltinTest,
testing::Values(/* Logical built-in */
- BuiltinData{core::Function::kAll, CallParamType::kBool, "all"},
- BuiltinData{core::Function::kAny, CallParamType::kBool, "any"},
+ BuiltinData{core::BuiltinFn::kAll, CallParamType::kBool, "all"},
+ BuiltinData{core::BuiltinFn::kAny, CallParamType::kBool, "any"},
/* Float built-in */
- BuiltinData{core::Function::kAbs, CallParamType::kF32, "abs"},
- BuiltinData{core::Function::kAbs, CallParamType::kF16, "abs"},
- BuiltinData{core::Function::kAcos, CallParamType::kF32, "acos"},
- BuiltinData{core::Function::kAcos, CallParamType::kF16, "acos"},
- BuiltinData{core::Function::kAsin, CallParamType::kF32, "asin"},
- BuiltinData{core::Function::kAsin, CallParamType::kF16, "asin"},
- BuiltinData{core::Function::kAtan, CallParamType::kF32, "atan"},
- BuiltinData{core::Function::kAtan, CallParamType::kF16, "atan"},
- BuiltinData{core::Function::kAtan2, CallParamType::kF32, "atan"},
- BuiltinData{core::Function::kAtan2, CallParamType::kF16, "atan"},
- BuiltinData{core::Function::kCeil, CallParamType::kF32, "ceil"},
- BuiltinData{core::Function::kCeil, CallParamType::kF16, "ceil"},
- BuiltinData{core::Function::kClamp, CallParamType::kF32, "clamp"},
- BuiltinData{core::Function::kClamp, CallParamType::kF16, "clamp"},
- BuiltinData{core::Function::kCos, CallParamType::kF32, "cos"},
- BuiltinData{core::Function::kCos, CallParamType::kF16, "cos"},
- BuiltinData{core::Function::kCosh, CallParamType::kF32, "cosh"},
- BuiltinData{core::Function::kCosh, CallParamType::kF16, "cosh"},
- BuiltinData{core::Function::kCross, CallParamType::kF32, "cross"},
- BuiltinData{core::Function::kCross, CallParamType::kF16, "cross"},
- BuiltinData{core::Function::kDistance, CallParamType::kF32, "distance"},
- BuiltinData{core::Function::kDistance, CallParamType::kF16, "distance"},
- BuiltinData{core::Function::kExp, CallParamType::kF32, "exp"},
- BuiltinData{core::Function::kExp, CallParamType::kF16, "exp"},
- BuiltinData{core::Function::kExp2, CallParamType::kF32, "exp2"},
- BuiltinData{core::Function::kExp2, CallParamType::kF16, "exp2"},
- BuiltinData{core::Function::kFaceForward, CallParamType::kF32, "faceforward"},
- BuiltinData{core::Function::kFaceForward, CallParamType::kF16, "faceforward"},
- BuiltinData{core::Function::kFloor, CallParamType::kF32, "floor"},
- BuiltinData{core::Function::kFloor, CallParamType::kF16, "floor"},
- BuiltinData{core::Function::kFma, CallParamType::kF32, "fma"},
- BuiltinData{core::Function::kFma, CallParamType::kF16, "fma"},
- BuiltinData{core::Function::kFract, CallParamType::kF32, "fract"},
- BuiltinData{core::Function::kFract, CallParamType::kF16, "fract"},
- BuiltinData{core::Function::kInverseSqrt, CallParamType::kF32, "inversesqrt"},
- BuiltinData{core::Function::kInverseSqrt, CallParamType::kF16, "inversesqrt"},
- BuiltinData{core::Function::kLdexp, CallParamType::kF32, "ldexp"},
- BuiltinData{core::Function::kLdexp, CallParamType::kF16, "ldexp"},
- BuiltinData{core::Function::kLength, CallParamType::kF32, "length"},
- BuiltinData{core::Function::kLength, CallParamType::kF16, "length"},
- BuiltinData{core::Function::kLog, CallParamType::kF32, "log"},
- BuiltinData{core::Function::kLog, CallParamType::kF16, "log"},
- BuiltinData{core::Function::kLog2, CallParamType::kF32, "log2"},
- BuiltinData{core::Function::kLog2, CallParamType::kF16, "log2"},
- BuiltinData{core::Function::kMax, CallParamType::kF32, "max"},
- BuiltinData{core::Function::kMax, CallParamType::kF16, "max"},
- BuiltinData{core::Function::kMin, CallParamType::kF32, "min"},
- BuiltinData{core::Function::kMin, CallParamType::kF16, "min"},
- BuiltinData{core::Function::kMix, CallParamType::kF32, "mix"},
- BuiltinData{core::Function::kMix, CallParamType::kF16, "mix"},
- BuiltinData{core::Function::kNormalize, CallParamType::kF32, "normalize"},
- BuiltinData{core::Function::kNormalize, CallParamType::kF16, "normalize"},
- BuiltinData{core::Function::kPow, CallParamType::kF32, "pow"},
- BuiltinData{core::Function::kPow, CallParamType::kF16, "pow"},
- BuiltinData{core::Function::kReflect, CallParamType::kF32, "reflect"},
- BuiltinData{core::Function::kReflect, CallParamType::kF16, "reflect"},
- BuiltinData{core::Function::kSign, CallParamType::kF32, "sign"},
- BuiltinData{core::Function::kSign, CallParamType::kF16, "sign"},
- BuiltinData{core::Function::kSin, CallParamType::kF32, "sin"},
- BuiltinData{core::Function::kSin, CallParamType::kF16, "sin"},
- BuiltinData{core::Function::kSinh, CallParamType::kF32, "sinh"},
- BuiltinData{core::Function::kSinh, CallParamType::kF16, "sinh"},
- BuiltinData{core::Function::kSmoothstep, CallParamType::kF32, "smoothstep"},
- BuiltinData{core::Function::kSmoothstep, CallParamType::kF16, "smoothstep"},
- BuiltinData{core::Function::kSqrt, CallParamType::kF32, "sqrt"},
- BuiltinData{core::Function::kSqrt, CallParamType::kF16, "sqrt"},
- BuiltinData{core::Function::kStep, CallParamType::kF32, "step"},
- BuiltinData{core::Function::kStep, CallParamType::kF16, "step"},
- BuiltinData{core::Function::kTan, CallParamType::kF32, "tan"},
- BuiltinData{core::Function::kTan, CallParamType::kF16, "tan"},
- BuiltinData{core::Function::kTanh, CallParamType::kF32, "tanh"},
- BuiltinData{core::Function::kTanh, CallParamType::kF16, "tanh"},
- BuiltinData{core::Function::kTrunc, CallParamType::kF32, "trunc"},
- BuiltinData{core::Function::kTrunc, CallParamType::kF16, "trunc"},
+ BuiltinData{core::BuiltinFn::kAbs, CallParamType::kF32, "abs"},
+ BuiltinData{core::BuiltinFn::kAbs, CallParamType::kF16, "abs"},
+ BuiltinData{core::BuiltinFn::kAcos, CallParamType::kF32, "acos"},
+ BuiltinData{core::BuiltinFn::kAcos, CallParamType::kF16, "acos"},
+ BuiltinData{core::BuiltinFn::kAsin, CallParamType::kF32, "asin"},
+ BuiltinData{core::BuiltinFn::kAsin, CallParamType::kF16, "asin"},
+ BuiltinData{core::BuiltinFn::kAtan, CallParamType::kF32, "atan"},
+ BuiltinData{core::BuiltinFn::kAtan, CallParamType::kF16, "atan"},
+ BuiltinData{core::BuiltinFn::kAtan2, CallParamType::kF32, "atan"},
+ BuiltinData{core::BuiltinFn::kAtan2, CallParamType::kF16, "atan"},
+ BuiltinData{core::BuiltinFn::kCeil, CallParamType::kF32, "ceil"},
+ BuiltinData{core::BuiltinFn::kCeil, CallParamType::kF16, "ceil"},
+ BuiltinData{core::BuiltinFn::kClamp, CallParamType::kF32, "clamp"},
+ BuiltinData{core::BuiltinFn::kClamp, CallParamType::kF16, "clamp"},
+ BuiltinData{core::BuiltinFn::kCos, CallParamType::kF32, "cos"},
+ BuiltinData{core::BuiltinFn::kCos, CallParamType::kF16, "cos"},
+ BuiltinData{core::BuiltinFn::kCosh, CallParamType::kF32, "cosh"},
+ BuiltinData{core::BuiltinFn::kCosh, CallParamType::kF16, "cosh"},
+ BuiltinData{core::BuiltinFn::kCross, CallParamType::kF32, "cross"},
+ BuiltinData{core::BuiltinFn::kCross, CallParamType::kF16, "cross"},
+ BuiltinData{core::BuiltinFn::kDistance, CallParamType::kF32, "distance"},
+ BuiltinData{core::BuiltinFn::kDistance, CallParamType::kF16, "distance"},
+ BuiltinData{core::BuiltinFn::kExp, CallParamType::kF32, "exp"},
+ BuiltinData{core::BuiltinFn::kExp, CallParamType::kF16, "exp"},
+ BuiltinData{core::BuiltinFn::kExp2, CallParamType::kF32, "exp2"},
+ BuiltinData{core::BuiltinFn::kExp2, CallParamType::kF16, "exp2"},
+ BuiltinData{core::BuiltinFn::kFaceForward, CallParamType::kF32, "faceforward"},
+ BuiltinData{core::BuiltinFn::kFaceForward, CallParamType::kF16, "faceforward"},
+ BuiltinData{core::BuiltinFn::kFloor, CallParamType::kF32, "floor"},
+ BuiltinData{core::BuiltinFn::kFloor, CallParamType::kF16, "floor"},
+ BuiltinData{core::BuiltinFn::kFma, CallParamType::kF32, "fma"},
+ BuiltinData{core::BuiltinFn::kFma, CallParamType::kF16, "fma"},
+ BuiltinData{core::BuiltinFn::kFract, CallParamType::kF32, "fract"},
+ BuiltinData{core::BuiltinFn::kFract, CallParamType::kF16, "fract"},
+ BuiltinData{core::BuiltinFn::kInverseSqrt, CallParamType::kF32, "inversesqrt"},
+ BuiltinData{core::BuiltinFn::kInverseSqrt, CallParamType::kF16, "inversesqrt"},
+ BuiltinData{core::BuiltinFn::kLdexp, CallParamType::kF32, "ldexp"},
+ BuiltinData{core::BuiltinFn::kLdexp, CallParamType::kF16, "ldexp"},
+ BuiltinData{core::BuiltinFn::kLength, CallParamType::kF32, "length"},
+ BuiltinData{core::BuiltinFn::kLength, CallParamType::kF16, "length"},
+ BuiltinData{core::BuiltinFn::kLog, CallParamType::kF32, "log"},
+ BuiltinData{core::BuiltinFn::kLog, CallParamType::kF16, "log"},
+ BuiltinData{core::BuiltinFn::kLog2, CallParamType::kF32, "log2"},
+ BuiltinData{core::BuiltinFn::kLog2, CallParamType::kF16, "log2"},
+ BuiltinData{core::BuiltinFn::kMax, CallParamType::kF32, "max"},
+ BuiltinData{core::BuiltinFn::kMax, CallParamType::kF16, "max"},
+ BuiltinData{core::BuiltinFn::kMin, CallParamType::kF32, "min"},
+ BuiltinData{core::BuiltinFn::kMin, CallParamType::kF16, "min"},
+ BuiltinData{core::BuiltinFn::kMix, CallParamType::kF32, "mix"},
+ BuiltinData{core::BuiltinFn::kMix, CallParamType::kF16, "mix"},
+ BuiltinData{core::BuiltinFn::kNormalize, CallParamType::kF32, "normalize"},
+ BuiltinData{core::BuiltinFn::kNormalize, CallParamType::kF16, "normalize"},
+ BuiltinData{core::BuiltinFn::kPow, CallParamType::kF32, "pow"},
+ BuiltinData{core::BuiltinFn::kPow, CallParamType::kF16, "pow"},
+ BuiltinData{core::BuiltinFn::kReflect, CallParamType::kF32, "reflect"},
+ BuiltinData{core::BuiltinFn::kReflect, CallParamType::kF16, "reflect"},
+ BuiltinData{core::BuiltinFn::kSign, CallParamType::kF32, "sign"},
+ BuiltinData{core::BuiltinFn::kSign, CallParamType::kF16, "sign"},
+ BuiltinData{core::BuiltinFn::kSin, CallParamType::kF32, "sin"},
+ BuiltinData{core::BuiltinFn::kSin, CallParamType::kF16, "sin"},
+ BuiltinData{core::BuiltinFn::kSinh, CallParamType::kF32, "sinh"},
+ BuiltinData{core::BuiltinFn::kSinh, CallParamType::kF16, "sinh"},
+ BuiltinData{core::BuiltinFn::kSmoothstep, CallParamType::kF32, "smoothstep"},
+ BuiltinData{core::BuiltinFn::kSmoothstep, CallParamType::kF16, "smoothstep"},
+ BuiltinData{core::BuiltinFn::kSqrt, CallParamType::kF32, "sqrt"},
+ BuiltinData{core::BuiltinFn::kSqrt, CallParamType::kF16, "sqrt"},
+ BuiltinData{core::BuiltinFn::kStep, CallParamType::kF32, "step"},
+ BuiltinData{core::BuiltinFn::kStep, CallParamType::kF16, "step"},
+ BuiltinData{core::BuiltinFn::kTan, CallParamType::kF32, "tan"},
+ BuiltinData{core::BuiltinFn::kTan, CallParamType::kF16, "tan"},
+ BuiltinData{core::BuiltinFn::kTanh, CallParamType::kF32, "tanh"},
+ BuiltinData{core::BuiltinFn::kTanh, CallParamType::kF16, "tanh"},
+ BuiltinData{core::BuiltinFn::kTrunc, CallParamType::kF32, "trunc"},
+ BuiltinData{core::BuiltinFn::kTrunc, CallParamType::kF16, "trunc"},
/* Integer built-in */
- BuiltinData{core::Function::kAbs, CallParamType::kU32, "abs"},
- BuiltinData{core::Function::kClamp, CallParamType::kU32, "clamp"},
- BuiltinData{core::Function::kCountOneBits, CallParamType::kU32, "bitCount"},
- BuiltinData{core::Function::kMax, CallParamType::kU32, "max"},
- BuiltinData{core::Function::kMin, CallParamType::kU32, "min"},
- BuiltinData{core::Function::kReverseBits, CallParamType::kU32,
+ BuiltinData{core::BuiltinFn::kAbs, CallParamType::kU32, "abs"},
+ BuiltinData{core::BuiltinFn::kClamp, CallParamType::kU32, "clamp"},
+ BuiltinData{core::BuiltinFn::kCountOneBits, CallParamType::kU32, "bitCount"},
+ BuiltinData{core::BuiltinFn::kMax, CallParamType::kU32, "max"},
+ BuiltinData{core::BuiltinFn::kMin, CallParamType::kU32, "min"},
+ BuiltinData{core::BuiltinFn::kReverseBits, CallParamType::kU32,
"bitfieldReverse"},
- BuiltinData{core::Function::kRound, CallParamType::kU32, "round"},
+ BuiltinData{core::BuiltinFn::kRound, CallParamType::kU32, "round"},
/* Matrix built-in */
- BuiltinData{core::Function::kDeterminant, CallParamType::kF32, "determinant"},
- BuiltinData{core::Function::kDeterminant, CallParamType::kF16, "determinant"},
- BuiltinData{core::Function::kTranspose, CallParamType::kF32, "transpose"},
- BuiltinData{core::Function::kTranspose, CallParamType::kF16, "transpose"},
+ BuiltinData{core::BuiltinFn::kDeterminant, CallParamType::kF32, "determinant"},
+ BuiltinData{core::BuiltinFn::kDeterminant, CallParamType::kF16, "determinant"},
+ BuiltinData{core::BuiltinFn::kTranspose, CallParamType::kF32, "transpose"},
+ BuiltinData{core::BuiltinFn::kTranspose, CallParamType::kF16, "transpose"},
/* Vector built-in */
- BuiltinData{core::Function::kDot, CallParamType::kF32, "dot"},
- BuiltinData{core::Function::kDot, CallParamType::kF16, "dot"},
+ BuiltinData{core::BuiltinFn::kDot, CallParamType::kF32, "dot"},
+ BuiltinData{core::BuiltinFn::kDot, CallParamType::kF16, "dot"},
/* Derivate built-in */
- BuiltinData{core::Function::kDpdx, CallParamType::kF32, "dFdx"},
- BuiltinData{core::Function::kDpdxCoarse, CallParamType::kF32, "dFdx"},
- BuiltinData{core::Function::kDpdxFine, CallParamType::kF32, "dFdx"},
- BuiltinData{core::Function::kDpdy, CallParamType::kF32, "dFdy"},
- BuiltinData{core::Function::kDpdyCoarse, CallParamType::kF32, "dFdy"},
- BuiltinData{core::Function::kDpdyFine, CallParamType::kF32, "dFdy"},
- BuiltinData{core::Function::kFwidth, CallParamType::kF32, "fwidth"},
- BuiltinData{core::Function::kFwidthCoarse, CallParamType::kF32, "fwidth"},
- BuiltinData{core::Function::kFwidthFine, CallParamType::kF32, "fwidth"}));
+ BuiltinData{core::BuiltinFn::kDpdx, CallParamType::kF32, "dFdx"},
+ BuiltinData{core::BuiltinFn::kDpdxCoarse, CallParamType::kF32, "dFdx"},
+ BuiltinData{core::BuiltinFn::kDpdxFine, CallParamType::kF32, "dFdx"},
+ BuiltinData{core::BuiltinFn::kDpdy, CallParamType::kF32, "dFdy"},
+ BuiltinData{core::BuiltinFn::kDpdyCoarse, CallParamType::kF32, "dFdy"},
+ BuiltinData{core::BuiltinFn::kDpdyFine, CallParamType::kF32, "dFdy"},
+ BuiltinData{core::BuiltinFn::kFwidth, CallParamType::kF32, "fwidth"},
+ BuiltinData{core::BuiltinFn::kFwidthCoarse, CallParamType::kF32, "fwidth"},
+ BuiltinData{core::BuiltinFn::kFwidthFine, CallParamType::kF32, "fwidth"}));
TEST_F(GlslASTPrinterTest_Builtin, Builtin_Call) {
auto* call = Call("dot", "param1", "param2");
diff --git a/src/tint/lang/glsl/writer/ast_raise/combine_samplers.cc b/src/tint/lang/glsl/writer/ast_raise/combine_samplers.cc
index 84647d0..a8f8267 100644
--- a/src/tint/lang/glsl/writer/ast_raise/combine_samplers.cc
+++ b/src/tint/lang/glsl/writer/ast_raise/combine_samplers.cc
@@ -226,7 +226,7 @@
if (auto* call = sem.Get(expr)->UnwrapMaterialize()->As<sem::Call>()) {
Vector<const ast::Expression*, 8> args;
// Replace all texture builtin calls.
- if (auto* builtin = call->Target()->As<sem::Builtin>()) {
+ if (auto* builtin = call->Target()->As<sem::BuiltinFn>()) {
const auto& signature = builtin->Signature();
auto sampler_index = signature.IndexOf(core::ParameterUsage::kSampler);
auto texture_index = signature.IndexOf(core::ParameterUsage::kTexture);
@@ -270,7 +270,7 @@
}
}
const ast::Expression* value = ctx.dst->Call(ctx.Clone(expr->target), args);
- if (builtin->Type() == core::Function::kTextureLoad &&
+ if (builtin->Fn() == core::BuiltinFn::kTextureLoad &&
texture_var->Type()->UnwrapRef()->Is<core::type::DepthTexture>() &&
!call->Stmt()->Declaration()->Is<ast::CallStatement>()) {
value = ctx.dst->MemberAccessor(value, "x");
diff --git a/src/tint/lang/glsl/writer/ast_raise/texture_1d_to_2d.cc b/src/tint/lang/glsl/writer/ast_raise/texture_1d_to_2d.cc
index aa23d0b..9636e07 100644
--- a/src/tint/lang/glsl/writer/ast_raise/texture_1d_to_2d.cc
+++ b/src/tint/lang/glsl/writer/ast_raise/texture_1d_to_2d.cc
@@ -126,7 +126,7 @@
if (!call) {
return nullptr;
}
- auto* builtin = call->Target()->As<sem::Builtin>();
+ auto* builtin = call->Target()->As<sem::BuiltinFn>();
if (!builtin) {
return nullptr;
}
@@ -140,7 +140,7 @@
return nullptr;
}
- if (builtin->Type() == core::Function::kTextureDimensions) {
+ if (builtin->Fn() == core::BuiltinFn::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/lang/glsl/writer/ast_raise/texture_builtins_from_uniform.cc b/src/tint/lang/glsl/writer/ast_raise/texture_builtins_from_uniform.cc
index 02c056d..db883b0 100644
--- a/src/tint/lang/glsl/writer/ast_raise/texture_builtins_from_uniform.cc
+++ b/src/tint/lang/glsl/writer/ast_raise/texture_builtins_from_uniform.cc
@@ -51,10 +51,10 @@
for (auto* builtin : sem_fn->DirectlyCalledBuiltins()) {
// GLSL ES has no native support for the counterpart of
// textureNumLevels (textureQueryLevels) and textureNumSamples (textureSamples)
- if (builtin->Type() == core::Function::kTextureNumLevels) {
+ if (builtin->Fn() == core::BuiltinFn::kTextureNumLevels) {
return true;
}
- if (builtin->Type() == core::Function::kTextureNumSamples) {
+ if (builtin->Fn() == core::BuiltinFn::kTextureNumSamples) {
return true;
}
}
@@ -110,9 +110,9 @@
tint::Switch(
call->Target(),
- [&](const sem::Builtin* builtin) {
- if (builtin->Type() != core::Function::kTextureNumLevels &&
- builtin->Type() != core::Function::kTextureNumSamples) {
+ [&](const sem::BuiltinFn* builtin) {
+ if (builtin->Fn() != core::BuiltinFn::kTextureNumLevels &&
+ builtin->Fn() != core::BuiltinFn::kTextureNumSamples) {
return;
}
if (auto* call_stmt =
@@ -131,7 +131,7 @@
TINT_ASSERT(texture_sem);
TextureBuiltinsFromUniformOptions::Field dataType =
- GetFieldFromBuiltinFunctionType(builtin->Type());
+ GetFieldFromBuiltinFunctionType(builtin->Fn());
tint::Switch(
texture_sem,
@@ -462,11 +462,11 @@
/// @param type of the builtin function
/// @returns corresponding TextureBuiltinsFromUniformOptions::Field for the builtin
static TextureBuiltinsFromUniformOptions::Field GetFieldFromBuiltinFunctionType(
- core::Function type) {
+ core::BuiltinFn type) {
switch (type) {
- case core::Function::kTextureNumLevels:
+ case core::BuiltinFn::kTextureNumLevels:
return TextureBuiltinsFromUniformOptions::Field::TextureNumLevels;
- case core::Function::kTextureNumSamples:
+ case core::BuiltinFn::kTextureNumSamples:
return TextureBuiltinsFromUniformOptions::Field::TextureNumSamples;
default:
TINT_UNREACHABLE() << "unsupported builtin function type " << type;
diff --git a/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc b/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc
index 20b7775..f51312a 100644
--- a/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc
@@ -1087,7 +1087,7 @@
return Switch(
target, //
[&](const sem::Function* func) { return EmitFunctionCall(out, call, func); },
- [&](const sem::Builtin* builtin) { return EmitBuiltinCall(out, call, builtin); },
+ [&](const sem::BuiltinFn* builtin) { return EmitBuiltinCall(out, call, builtin); },
[&](const sem::ValueConversion* conv) { return EmitValueConversion(out, call, conv); },
[&](const sem::ValueConstructor* ctor) { return EmitValueConstructor(out, call, ctor); },
[&](Default) {
@@ -1166,35 +1166,35 @@
bool ASTPrinter::EmitBuiltinCall(StringStream& out,
const sem::Call* call,
- const sem::Builtin* builtin) {
- const auto type = builtin->Type();
+ const sem::BuiltinFn* builtin) {
+ const auto type = builtin->Fn();
auto* expr = call->Declaration();
if (builtin->IsTexture()) {
return EmitTextureCall(out, call, builtin);
}
- if (type == core::Function::kSelect) {
+ if (type == core::BuiltinFn::kSelect) {
return EmitSelectCall(out, expr);
}
- if (type == core::Function::kModf) {
+ if (type == core::BuiltinFn::kModf) {
return EmitModfCall(out, expr, builtin);
}
- if (type == core::Function::kFrexp) {
+ if (type == core::BuiltinFn::kFrexp) {
return EmitFrexpCall(out, expr, builtin);
}
- if (type == core::Function::kDegrees) {
+ if (type == core::BuiltinFn::kDegrees) {
return EmitDegreesCall(out, expr, builtin);
}
- if (type == core::Function::kRadians) {
+ if (type == core::BuiltinFn::kRadians) {
return EmitRadiansCall(out, expr, builtin);
}
- if (type == core::Function::kSign) {
+ if (type == core::BuiltinFn::kSign) {
return EmitSignCall(out, call, builtin);
}
- if (type == core::Function::kQuantizeToF16) {
+ if (type == core::BuiltinFn::kQuantizeToF16) {
return EmitQuantizeToF16Call(out, expr, builtin);
}
- if (type == core::Function::kTrunc) {
+ if (type == core::BuiltinFn::kTrunc) {
return EmitTruncCall(out, expr, builtin);
}
if (builtin->IsDataPacking()) {
@@ -1213,7 +1213,7 @@
return EmitDP4aCall(out, expr, builtin);
}
if (builtin->IsSubgroup()) {
- if (builtin->Type() == core::Function::kSubgroupBroadcast) {
+ if (builtin->Fn() == core::BuiltinFn::kSubgroupBroadcast) {
// Fall through the regular path.
} else {
return EmitSubgroupCall(out, expr, builtin);
@@ -1228,7 +1228,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 == core::Function::kCountOneBits || type == core::Function::kReverseBits) {
+ if (type == core::BuiltinFn::kCountOneBits || type == core::BuiltinFn::kReverseBits) {
auto* arg = call->Arguments()[0];
if (arg->Type()->UnwrapRef()->is_signed_integer_scalar_or_vector()) {
out << "asint(" << name << "(asuint(";
@@ -1991,7 +1991,7 @@
bool ASTPrinter::EmitWorkgroupAtomicCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
std::string result = UniqueIdentifier("atomic_result");
if (!builtin->ReturnType()->Is<core::type::Void>()) {
@@ -2018,7 +2018,7 @@
if (i > 0) {
pre << ", ";
}
- if (i == 1 && builtin->Type() == core::Function::kAtomicSub) {
+ if (i == 1 && builtin->Fn() == core::BuiltinFn::kAtomicSub) {
// Sub uses InterlockedAdd with the operand negated.
pre << "-";
}
@@ -2036,8 +2036,8 @@
return true;
};
- switch (builtin->Type()) {
- case core::Function::kAtomicLoad: {
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kAtomicLoad: {
// HLSL does not have an InterlockedLoad, so we emulate it with
// InterlockedOr using 0 as the OR value
auto pre = Line();
@@ -2054,7 +2054,7 @@
out << result;
return true;
}
- case core::Function::kAtomicStore: {
+ case core::BuiltinFn::kAtomicStore: {
// HLSL does not have an InterlockedStore, so we emulate it with
// InterlockedExchange and discard the returned value
{ // T result = 0;
@@ -2085,7 +2085,7 @@
}
return true;
}
- case core::Function::kAtomicCompareExchangeWeak: {
+ case core::BuiltinFn::kAtomicCompareExchangeWeak: {
if (!EmitStructType(&helpers_, builtin->ReturnType()->As<core::type::Struct>())) {
return false;
}
@@ -2134,33 +2134,33 @@
return true;
}
- case core::Function::kAtomicAdd:
- case core::Function::kAtomicSub:
+ case core::BuiltinFn::kAtomicAdd:
+ case core::BuiltinFn::kAtomicSub:
return call("InterlockedAdd");
- case core::Function::kAtomicMax:
+ case core::BuiltinFn::kAtomicMax:
return call("InterlockedMax");
- case core::Function::kAtomicMin:
+ case core::BuiltinFn::kAtomicMin:
return call("InterlockedMin");
- case core::Function::kAtomicAnd:
+ case core::BuiltinFn::kAtomicAnd:
return call("InterlockedAnd");
- case core::Function::kAtomicOr:
+ case core::BuiltinFn::kAtomicOr:
return call("InterlockedOr");
- case core::Function::kAtomicXor:
+ case core::BuiltinFn::kAtomicXor:
return call("InterlockedXor");
- case core::Function::kAtomicExchange:
+ case core::BuiltinFn::kAtomicExchange:
return call("InterlockedExchange");
default:
break;
}
- TINT_UNREACHABLE() << "unsupported atomic builtin: " << builtin->Type();
+ TINT_UNREACHABLE() << "unsupported atomic builtin: " << builtin->Fn();
return false;
}
@@ -2190,7 +2190,7 @@
bool ASTPrinter::EmitModfCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
return CallBuiltinHelper(
out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
auto* ty = builtin->Parameters()[0]->Type();
@@ -2223,7 +2223,7 @@
bool ASTPrinter::EmitFrexpCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
return CallBuiltinHelper(
out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
auto* ty = builtin->Parameters()[0]->Type();
@@ -2264,7 +2264,7 @@
bool ASTPrinter::EmitDegreesCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
return CallBuiltinHelper(out, expr, builtin,
[&](TextBuffer* b, const std::vector<std::string>& params) {
Line(b) << "return " << params[0] << " * " << std::setprecision(20)
@@ -2275,7 +2275,7 @@
bool ASTPrinter::EmitRadiansCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
return CallBuiltinHelper(out, expr, builtin,
[&](TextBuffer* b, const std::vector<std::string>& params) {
Line(b) << "return " << params[0] << " * " << std::setprecision(20)
@@ -2287,7 +2287,7 @@
// The HLSL `sign` method always returns an `int` result (scalar or vector). In WGSL the result is
// expected to be the same type as the argument. This injects a cast to the expected WGSL result
// type after the call to `sign`.
-bool ASTPrinter::EmitSignCall(StringStream& out, const sem::Call* call, const sem::Builtin*) {
+bool ASTPrinter::EmitSignCall(StringStream& out, const sem::Call* call, const sem::BuiltinFn*) {
auto* arg = call->Arguments()[0];
if (!EmitType(out, arg->Type(), core::AddressSpace::kUndefined, core::Access::kReadWrite, "")) {
return false;
@@ -2302,7 +2302,7 @@
bool ASTPrinter::EmitQuantizeToF16Call(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
// Cast to f16 and back
std::string width;
if (auto* vec = builtin->ReturnType()->As<core::type::Vector>()) {
@@ -2319,7 +2319,7 @@
bool ASTPrinter::EmitTruncCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
// HLSL's trunc is broken for very large/small float values.
// See crbug.com/tint/1883
return CallBuiltinHelper( //
@@ -2333,27 +2333,27 @@
bool ASTPrinter::EmitDataPackingCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
return CallBuiltinHelper(
out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
uint32_t dims = 2;
bool is_signed = false;
uint32_t scale = 65535;
- if (builtin->Type() == core::Function::kPack4X8Snorm ||
- builtin->Type() == core::Function::kPack4X8Unorm) {
+ if (builtin->Fn() == core::BuiltinFn::kPack4X8Snorm ||
+ builtin->Fn() == core::BuiltinFn::kPack4X8Unorm) {
dims = 4;
scale = 255;
}
- if (builtin->Type() == core::Function::kPack4X8Snorm ||
- builtin->Type() == core::Function::kPack2X16Snorm) {
+ if (builtin->Fn() == core::BuiltinFn::kPack4X8Snorm ||
+ builtin->Fn() == core::BuiltinFn::kPack2X16Snorm) {
is_signed = true;
scale = (scale - 1) / 2;
}
- switch (builtin->Type()) {
- case core::Function::kPack4X8Snorm:
- case core::Function::kPack4X8Unorm:
- case core::Function::kPack2X16Snorm:
- case core::Function::kPack2X16Unorm: {
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kPack4X8Snorm:
+ case core::BuiltinFn::kPack4X8Unorm:
+ case core::BuiltinFn::kPack2X16Snorm:
+ case core::BuiltinFn::kPack2X16Unorm: {
{
auto l = Line(b);
l << (is_signed ? "" : "u") << "int" << dims
@@ -2379,7 +2379,7 @@
}
break;
}
- case core::Function::kPack2X16Float: {
+ case core::BuiltinFn::kPack2X16Float: {
Line(b) << "uint2 i = f32tof16(" << params[0] << ");";
Line(b) << "return i.x | (i.y << 16);";
break;
@@ -2396,25 +2396,25 @@
bool ASTPrinter::EmitDataUnpackingCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
return CallBuiltinHelper(
out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
uint32_t dims = 2;
bool is_signed = false;
uint32_t scale = 65535;
- if (builtin->Type() == core::Function::kUnpack4X8Snorm ||
- builtin->Type() == core::Function::kUnpack4X8Unorm) {
+ if (builtin->Fn() == core::BuiltinFn::kUnpack4X8Snorm ||
+ builtin->Fn() == core::BuiltinFn::kUnpack4X8Unorm) {
dims = 4;
scale = 255;
}
- if (builtin->Type() == core::Function::kUnpack4X8Snorm ||
- builtin->Type() == core::Function::kUnpack2X16Snorm) {
+ if (builtin->Fn() == core::BuiltinFn::kUnpack4X8Snorm ||
+ builtin->Fn() == core::BuiltinFn::kUnpack2X16Snorm) {
is_signed = true;
scale = (scale - 1) / 2;
}
- switch (builtin->Type()) {
- case core::Function::kUnpack4X8Snorm:
- case core::Function::kUnpack2X16Snorm: {
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kUnpack4X8Snorm:
+ case core::BuiltinFn::kUnpack2X16Snorm: {
Line(b) << "int j = int(" << params[0] << ");";
{ // Perform sign extension on the converted values.
auto l = Line(b);
@@ -2430,8 +2430,8 @@
<< (is_signed ? "-1.0" : "0.0") << ", 1.0);";
break;
}
- case core::Function::kUnpack4X8Unorm:
- case core::Function::kUnpack2X16Unorm: {
+ case core::BuiltinFn::kUnpack4X8Unorm:
+ case core::BuiltinFn::kUnpack2X16Unorm: {
Line(b) << "uint j = " << params[0] << ";";
{
auto l = Line(b);
@@ -2447,7 +2447,7 @@
Line(b) << "return float" << dims << "(i) / " << scale << ".0;";
break;
}
- case core::Function::kUnpack2X16Float:
+ case core::BuiltinFn::kUnpack2X16Float:
Line(b) << "uint i = " << params[0] << ";";
Line(b) << "return f16tof32(uint2(i & 0xffff, i >> 16));";
break;
@@ -2463,17 +2463,17 @@
bool ASTPrinter::EmitDP4aCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
// TODO(crbug.com/tint/1497): support the polyfill version of DP4a functions.
return CallBuiltinHelper(
out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
std::string functionName;
- switch (builtin->Type()) {
- case core::Function::kDot4I8Packed:
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kDot4I8Packed:
Line(b) << "int accumulator = 0;";
functionName = "dot4add_i8packed";
break;
- case core::Function::kDot4U8Packed:
+ case core::BuiltinFn::kDot4U8Packed:
Line(b) << "uint accumulator = 0u;";
functionName = "dot4add_u8packed";
break;
@@ -2489,17 +2489,17 @@
});
}
-bool ASTPrinter::EmitBarrierCall(StringStream& out, const sem::Builtin* builtin) {
+bool ASTPrinter::EmitBarrierCall(StringStream& out, const sem::BuiltinFn* builtin) {
// TODO(crbug.com/tint/661): Combine sequential barriers to a single
// instruction.
- if (builtin->Type() == core::Function::kWorkgroupBarrier) {
+ if (builtin->Fn() == core::BuiltinFn::kWorkgroupBarrier) {
out << "GroupMemoryBarrierWithGroupSync()";
- } else if (builtin->Type() == core::Function::kStorageBarrier) {
+ } else if (builtin->Fn() == core::BuiltinFn::kStorageBarrier) {
out << "DeviceMemoryBarrierWithGroupSync()";
- } else if (builtin->Type() == core::Function::kTextureBarrier) {
+ } else if (builtin->Fn() == core::BuiltinFn::kTextureBarrier) {
out << "DeviceMemoryBarrierWithGroupSync()";
} else {
- TINT_UNREACHABLE() << "unexpected barrier builtin type " << core::str(builtin->Type());
+ TINT_UNREACHABLE() << "unexpected barrier builtin type " << core::str(builtin->Fn());
return false;
}
return true;
@@ -2507,12 +2507,12 @@
bool ASTPrinter::EmitSubgroupCall(StringStream& out,
[[maybe_unused]] const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
- if (builtin->Type() == core::Function::kSubgroupBallot) {
+ const sem::BuiltinFn* builtin) {
+ if (builtin->Fn() == core::BuiltinFn::kSubgroupBallot) {
out << "WaveActiveBallot(true)";
} else {
// subgroupBroadcast is already handled in the regular builtin flow.
- TINT_UNREACHABLE() << "unexpected subgroup builtin type " << core::str(builtin->Type());
+ TINT_UNREACHABLE() << "unexpected subgroup builtin type " << core::str(builtin->Fn());
return false;
}
return true;
@@ -2551,7 +2551,7 @@
bool ASTPrinter::EmitTextureCall(StringStream& out,
const sem::Call* call,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
using Usage = core::ParameterUsage;
auto& signature = builtin->Signature();
@@ -2572,19 +2572,19 @@
auto* texture_type = TypeOf(texture)->UnwrapRef()->As<core::type::Texture>();
- switch (builtin->Type()) {
- case core::Function::kTextureDimensions:
- case core::Function::kTextureNumLayers:
- case core::Function::kTextureNumLevels:
- case core::Function::kTextureNumSamples: {
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kTextureDimensions:
+ case core::BuiltinFn::kTextureNumLayers:
+ case core::BuiltinFn::kTextureNumLevels:
+ case core::BuiltinFn::kTextureNumSamples: {
// All of these builtins use the GetDimensions() method on the texture
bool is_ms = texture_type->IsAnyOf<core::type::MultisampledTexture,
core::type::DepthMultisampledTexture>();
int num_dimensions = 0;
std::string swizzle;
- switch (builtin->Type()) {
- case core::Function::kTextureDimensions:
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kTextureDimensions:
switch (texture_type->dim()) {
case core::type::TextureDimension::kNone:
TINT_ICE() << "texture dimension is kNone";
@@ -2612,7 +2612,7 @@
break;
}
break;
- case core::Function::kTextureNumLayers:
+ case core::BuiltinFn::kTextureNumLayers:
switch (texture_type->dim()) {
default:
TINT_ICE() << "texture dimension is not arrayed";
@@ -2627,7 +2627,7 @@
break;
}
break;
- case core::Function::kTextureNumLevels:
+ case core::BuiltinFn::kTextureNumLevels:
switch (texture_type->dim()) {
default:
TINT_ICE() << "texture dimension does not support mips";
@@ -2649,7 +2649,7 @@
break;
}
break;
- case core::Function::kTextureNumSamples:
+ case core::BuiltinFn::kTextureNumSamples:
switch (texture_type->dim()) {
default:
TINT_ICE() << "texture dimension does not support multisampling";
@@ -2712,7 +2712,7 @@
return false;
}
pre << ", ";
- } else if (builtin->Type() == core::Function::kTextureNumLevels) {
+ } else if (builtin->Fn() == core::BuiltinFn::kTextureNumLevels) {
pre << "0, ";
}
@@ -2757,35 +2757,35 @@
uint32_t hlsl_ret_width = 4u;
- switch (builtin->Type()) {
- case core::Function::kTextureSample:
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kTextureSample:
out << ".Sample(";
break;
- case core::Function::kTextureSampleBias:
+ case core::BuiltinFn::kTextureSampleBias:
out << ".SampleBias(";
break;
- case core::Function::kTextureSampleLevel:
+ case core::BuiltinFn::kTextureSampleLevel:
out << ".SampleLevel(";
break;
- case core::Function::kTextureSampleGrad:
+ case core::BuiltinFn::kTextureSampleGrad:
out << ".SampleGrad(";
break;
- case core::Function::kTextureSampleCompare:
+ case core::BuiltinFn::kTextureSampleCompare:
out << ".SampleCmp(";
hlsl_ret_width = 1;
break;
- case core::Function::kTextureSampleCompareLevel:
+ case core::BuiltinFn::kTextureSampleCompareLevel:
out << ".SampleCmpLevelZero(";
hlsl_ret_width = 1;
break;
- case core::Function::kTextureLoad:
+ case core::BuiltinFn::kTextureLoad:
out << ".Load(";
// Multisampled textures do not support mip-levels.
if (!texture_type->Is<core::type::MultisampledTexture>()) {
pack_level_in_coords = true;
}
break;
- case core::Function::kTextureGather:
+ case core::BuiltinFn::kTextureGather:
out << ".Gather";
if (builtin->Parameters()[0]->Usage() == core::ParameterUsage::kComponent) {
switch (call->Arguments()[0]->ConstantValue()->ValueAs<AInt>()) {
@@ -2805,10 +2805,10 @@
}
out << "(";
break;
- case core::Function::kTextureGatherCompare:
+ case core::BuiltinFn::kTextureGatherCompare:
out << ".GatherCmp(";
break;
- case core::Function::kTextureStore:
+ case core::BuiltinFn::kTextureStore:
out << "[";
break;
default:
@@ -2869,7 +2869,7 @@
if (!emit_vector_appended_with_level(param_coords)) {
return false;
}
- } else if (builtin->Type() == core::Function::kTextureStore) {
+ } else if (builtin->Fn() == core::BuiltinFn::kTextureStore) {
// param_coords is an index expression, not a function arg
if (!EmitExpression(out, param_coords)) {
return false;
@@ -2891,7 +2891,7 @@
}
}
- if (builtin->Type() == core::Function::kTextureStore) {
+ if (builtin->Fn() == core::BuiltinFn::kTextureStore) {
out << "] = ";
if (!EmitExpression(out, arg(Usage::kValue))) {
return false;
@@ -2915,7 +2915,7 @@
if (TINT_UNLIKELY(wgsl_ret_width > hlsl_ret_width)) {
TINT_ICE() << "WGSL return width (" << wgsl_ret_width
<< ") is wider than HLSL return width (" << hlsl_ret_width << ") for "
- << builtin->Type();
+ << builtin->Fn();
return false;
}
}
@@ -2923,81 +2923,81 @@
return true;
}
-std::string ASTPrinter::generate_builtin_name(const sem::Builtin* builtin) {
- switch (builtin->Type()) {
- case core::Function::kAbs:
- case core::Function::kAcos:
- case core::Function::kAll:
- case core::Function::kAny:
- case core::Function::kAsin:
- case core::Function::kAtan:
- case core::Function::kAtan2:
- case core::Function::kCeil:
- case core::Function::kClamp:
- case core::Function::kCos:
- case core::Function::kCosh:
- case core::Function::kCross:
- case core::Function::kDeterminant:
- case core::Function::kDistance:
- case core::Function::kDot:
- case core::Function::kExp:
- case core::Function::kExp2:
- case core::Function::kFloor:
- case core::Function::kFrexp:
- case core::Function::kLdexp:
- case core::Function::kLength:
- case core::Function::kLog:
- case core::Function::kLog2:
- case core::Function::kMax:
- case core::Function::kMin:
- case core::Function::kModf:
- case core::Function::kNormalize:
- case core::Function::kPow:
- case core::Function::kReflect:
- case core::Function::kRefract:
- case core::Function::kRound:
- case core::Function::kSaturate:
- case core::Function::kSin:
- case core::Function::kSinh:
- case core::Function::kSqrt:
- case core::Function::kStep:
- case core::Function::kTan:
- case core::Function::kTanh:
- case core::Function::kTranspose:
+std::string ASTPrinter::generate_builtin_name(const sem::BuiltinFn* builtin) {
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kAbs:
+ case core::BuiltinFn::kAcos:
+ case core::BuiltinFn::kAll:
+ case core::BuiltinFn::kAny:
+ case core::BuiltinFn::kAsin:
+ case core::BuiltinFn::kAtan:
+ case core::BuiltinFn::kAtan2:
+ case core::BuiltinFn::kCeil:
+ case core::BuiltinFn::kClamp:
+ case core::BuiltinFn::kCos:
+ case core::BuiltinFn::kCosh:
+ case core::BuiltinFn::kCross:
+ case core::BuiltinFn::kDeterminant:
+ case core::BuiltinFn::kDistance:
+ case core::BuiltinFn::kDot:
+ case core::BuiltinFn::kExp:
+ case core::BuiltinFn::kExp2:
+ case core::BuiltinFn::kFloor:
+ case core::BuiltinFn::kFrexp:
+ case core::BuiltinFn::kLdexp:
+ case core::BuiltinFn::kLength:
+ case core::BuiltinFn::kLog:
+ case core::BuiltinFn::kLog2:
+ case core::BuiltinFn::kMax:
+ case core::BuiltinFn::kMin:
+ case core::BuiltinFn::kModf:
+ case core::BuiltinFn::kNormalize:
+ case core::BuiltinFn::kPow:
+ case core::BuiltinFn::kReflect:
+ case core::BuiltinFn::kRefract:
+ case core::BuiltinFn::kRound:
+ case core::BuiltinFn::kSaturate:
+ case core::BuiltinFn::kSin:
+ case core::BuiltinFn::kSinh:
+ case core::BuiltinFn::kSqrt:
+ case core::BuiltinFn::kStep:
+ case core::BuiltinFn::kTan:
+ case core::BuiltinFn::kTanh:
+ case core::BuiltinFn::kTranspose:
return builtin->str();
- case core::Function::kCountOneBits: // uint
+ case core::BuiltinFn::kCountOneBits: // uint
return "countbits";
- case core::Function::kDpdx:
+ case core::BuiltinFn::kDpdx:
return "ddx";
- case core::Function::kDpdxCoarse:
+ case core::BuiltinFn::kDpdxCoarse:
return "ddx_coarse";
- case core::Function::kDpdxFine:
+ case core::BuiltinFn::kDpdxFine:
return "ddx_fine";
- case core::Function::kDpdy:
+ case core::BuiltinFn::kDpdy:
return "ddy";
- case core::Function::kDpdyCoarse:
+ case core::BuiltinFn::kDpdyCoarse:
return "ddy_coarse";
- case core::Function::kDpdyFine:
+ case core::BuiltinFn::kDpdyFine:
return "ddy_fine";
- case core::Function::kFaceForward:
+ case core::BuiltinFn::kFaceForward:
return "faceforward";
- case core::Function::kFract:
+ case core::BuiltinFn::kFract:
return "frac";
- case core::Function::kFma:
+ case core::BuiltinFn::kFma:
return "mad";
- case core::Function::kFwidth:
- case core::Function::kFwidthCoarse:
- case core::Function::kFwidthFine:
+ case core::BuiltinFn::kFwidth:
+ case core::BuiltinFn::kFwidthCoarse:
+ case core::BuiltinFn::kFwidthFine:
return "fwidth";
- case core::Function::kInverseSqrt:
+ case core::BuiltinFn::kInverseSqrt:
return "rsqrt";
- case core::Function::kMix:
+ case core::BuiltinFn::kMix:
return "lerp";
- case core::Function::kReverseBits: // uint
+ case core::BuiltinFn::kReverseBits: // uint
return "reversebits";
- case core::Function::kSmoothstep:
+ case core::BuiltinFn::kSmoothstep:
return "smoothstep";
- case core::Function::kSubgroupBroadcast:
+ case core::BuiltinFn::kSubgroupBroadcast:
return "WaveReadLaneAt";
default:
diagnostics_.add_error(diag::System::Writer,
@@ -4584,14 +4584,14 @@
template <typename F>
bool ASTPrinter::CallBuiltinHelper(StringStream& out,
const ast::CallExpression* call,
- const sem::Builtin* builtin,
+ const sem::BuiltinFn* builtin,
F&& build) {
// Generate the helper function if it hasn't been created already
auto fn = tint::GetOrCreate(builtins_, builtin, [&]() -> std::string {
TextBuffer b;
TINT_DEFER(helpers_.Append(b));
- auto fn_name = UniqueIdentifier(std::string("tint_") + core::str(builtin->Type()));
+ auto fn_name = UniqueIdentifier(std::string("tint_") + core::str(builtin->Fn()));
std::vector<std::string> parameter_names;
{
auto decl = Line(&b);
diff --git a/src/tint/lang/hlsl/writer/ast_printer/ast_printer.h b/src/tint/lang/hlsl/writer/ast_printer/ast_printer.h
index 7b7966b..0c8072a 100644
--- a/src/tint/lang/hlsl/writer/ast_printer/ast_printer.h
+++ b/src/tint/lang/hlsl/writer/ast_printer/ast_printer.h
@@ -33,7 +33,7 @@
// Forward declarations
namespace tint::sem {
-class Builtin;
+class BuiltinFn;
class Call;
class ValueConstructor;
class ValueConversion;
@@ -129,7 +129,7 @@
/// @param call the call expression
/// @param builtin the builtin being called
/// @returns true if the expression is emitted
- bool EmitBuiltinCall(StringStream& out, const sem::Call* call, const sem::Builtin* builtin);
+ bool EmitBuiltinCall(StringStream& out, const sem::Call* call, const sem::BuiltinFn* builtin);
/// Handles generating a value conversion expression
/// @param out the output stream
/// @param call the call expression
@@ -168,7 +168,7 @@
/// @param out the output stream
/// @param builtin the semantic information for the barrier builtin
/// @returns true if the call expression is emitted
- bool EmitBarrierCall(StringStream& out, const sem::Builtin* builtin);
+ bool EmitBarrierCall(StringStream& out, const sem::BuiltinFn* builtin);
/// Handles generating an atomic intrinsic call for a storage buffer variable
/// @param out the output stream
/// @param expr the call expression
@@ -190,14 +190,14 @@
/// @returns true if the call expression is emitted
bool EmitWorkgroupAtomicCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to a texture function (`textureSample`,
/// `textureSampleGrad`, etc)
/// @param out the output stream
/// @param call the call expression
/// @param builtin the semantic information for the texture builtin
/// @returns true if the call expression is emitted
- bool EmitTextureCall(StringStream& out, const sem::Call* call, const sem::Builtin* builtin);
+ bool EmitTextureCall(StringStream& out, const sem::Call* call, const sem::BuiltinFn* builtin);
/// Handles generating a call to the `select()` builtin
/// @param out the output stream
/// @param expr the call expression
@@ -210,7 +210,7 @@
/// @returns true if the call expression is emitted
bool EmitModfCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `frexp()` builtin
/// @param out the output stream
/// @param expr the call expression
@@ -218,7 +218,7 @@
/// @returns true if the call expression is emitted
bool EmitFrexpCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `degrees()` builtin
/// @param out the output stream
/// @param expr the call expression
@@ -226,7 +226,7 @@
/// @returns true if the call expression is emitted
bool EmitDegreesCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `radians()` builtin
/// @param out the output stream
/// @param expr the call expression
@@ -234,13 +234,13 @@
/// @returns true if the call expression is emitted
bool EmitRadiansCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `sign()` builtin
/// @param out the output stream
/// @param call the call semantic node
/// @param builtin the semantic information for the builtin
/// @returns true if the call expression is emitted
- bool EmitSignCall(StringStream& out, const sem::Call* call, const sem::Builtin* builtin);
+ bool EmitSignCall(StringStream& out, const sem::Call* call, const sem::BuiltinFn* builtin);
/// Handles generating a call to data packing builtin
/// @param out the output stream
/// @param expr the call expression
@@ -248,7 +248,7 @@
/// @returns true if the call expression is emitted
bool EmitDataPackingCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to data unpacking builtin
/// @param out the output stream
/// @param expr the call expression
@@ -256,7 +256,7 @@
/// @returns true if the call expression is emitted
bool EmitDataUnpackingCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `quantizeToF16()` intrinsic
/// @param out the output stream
/// @param expr the call expression
@@ -264,7 +264,7 @@
/// @returns true if the call expression is emitted
bool EmitQuantizeToF16Call(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `trunc()` intrinsic
/// @param out the output stream
/// @param expr the call expression
@@ -272,7 +272,7 @@
/// @returns true if the call expression is emitted
bool EmitTruncCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to DP4a builtins (dot4I8Packed and dot4U8Packed)
/// @param out the output stream
/// @param expr the call expression
@@ -280,7 +280,7 @@
/// @returns true if the call expression is emitted
bool EmitDP4aCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to subgroup builtins.
/// @param out the output stream
/// @param expr the call expression
@@ -288,7 +288,7 @@
/// @returns true if the call expression is emitted
bool EmitSubgroupCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles a case statement
/// @param s the switch statement
/// @param case_idx the index of the switch case in the switch statement
@@ -507,7 +507,7 @@
/// Handles generating a builtin method name
/// @param builtin the semantic info for the builtin
/// @returns the name or "" if not valid
- std::string generate_builtin_name(const sem::Builtin* builtin);
+ std::string generate_builtin_name(const sem::BuiltinFn* builtin);
/// Converts a builtin to an attribute name
/// @param builtin the builtin to convert
/// @returns the string name of the builtin or blank on error
@@ -562,7 +562,7 @@
template <typename F>
bool CallBuiltinHelper(StringStream& out,
const ast::CallExpression* call,
- const sem::Builtin* builtin,
+ const sem::BuiltinFn* builtin,
F&& build);
/// @param s the structure
@@ -591,7 +591,7 @@
std::unordered_map<const core::type::Struct*, std::string> builtin_struct_names_;
std::function<bool()> emit_continuing_;
std::unordered_map<const core::type::Matrix*, std::string> matrix_scalar_inits_;
- std::unordered_map<const sem::Builtin*, std::string> builtins_;
+ std::unordered_map<const sem::BuiltinFn*, std::string> builtins_;
// Polyfill functions for bitcast expression, BinaryType indicates the source type and the
// destination type.
std::unordered_map<BinaryType, std::string> bitcast_funcs_;
diff --git a/src/tint/lang/hlsl/writer/ast_printer/builtin_test.cc b/src/tint/lang/hlsl/writer/ast_printer/builtin_test.cc
index a7bbede..9445273 100644
--- a/src/tint/lang/hlsl/writer/ast_printer/builtin_test.cc
+++ b/src/tint/lang/hlsl/writer/ast_printer/builtin_test.cc
@@ -36,7 +36,7 @@
};
struct BuiltinData {
- core::Function builtin;
+ core::BuiltinFn builtin;
CallParamType type;
const char* hlsl_name;
};
@@ -60,84 +60,84 @@
return out;
}
-const ast::CallExpression* GenerateCall(core::Function builtin,
+const ast::CallExpression* GenerateCall(core::BuiltinFn builtin,
CallParamType type,
ProgramBuilder* builder) {
std::string name;
StringStream str;
str << name << builtin;
switch (builtin) {
- case core::Function::kAcos:
- case core::Function::kAsin:
- case core::Function::kAtan:
- case core::Function::kCeil:
- case core::Function::kCos:
- case core::Function::kCosh:
- case core::Function::kDpdx:
- case core::Function::kDpdxCoarse:
- case core::Function::kDpdxFine:
- case core::Function::kDpdy:
- case core::Function::kDpdyCoarse:
- case core::Function::kDpdyFine:
- case core::Function::kExp:
- case core::Function::kExp2:
- case core::Function::kFloor:
- case core::Function::kFract:
- case core::Function::kFwidth:
- case core::Function::kFwidthCoarse:
- case core::Function::kFwidthFine:
- case core::Function::kInverseSqrt:
- case core::Function::kLength:
- case core::Function::kLog:
- case core::Function::kLog2:
- case core::Function::kNormalize:
- case core::Function::kRound:
- case core::Function::kSin:
- case core::Function::kSinh:
- case core::Function::kSqrt:
- case core::Function::kTan:
- case core::Function::kTanh:
+ case core::BuiltinFn::kAcos:
+ case core::BuiltinFn::kAsin:
+ case core::BuiltinFn::kAtan:
+ case core::BuiltinFn::kCeil:
+ case core::BuiltinFn::kCos:
+ case core::BuiltinFn::kCosh:
+ case core::BuiltinFn::kDpdx:
+ case core::BuiltinFn::kDpdxCoarse:
+ case core::BuiltinFn::kDpdxFine:
+ case core::BuiltinFn::kDpdy:
+ case core::BuiltinFn::kDpdyCoarse:
+ case core::BuiltinFn::kDpdyFine:
+ case core::BuiltinFn::kExp:
+ case core::BuiltinFn::kExp2:
+ case core::BuiltinFn::kFloor:
+ case core::BuiltinFn::kFract:
+ case core::BuiltinFn::kFwidth:
+ case core::BuiltinFn::kFwidthCoarse:
+ case core::BuiltinFn::kFwidthFine:
+ case core::BuiltinFn::kInverseSqrt:
+ case core::BuiltinFn::kLength:
+ case core::BuiltinFn::kLog:
+ case core::BuiltinFn::kLog2:
+ case core::BuiltinFn::kNormalize:
+ case core::BuiltinFn::kRound:
+ case core::BuiltinFn::kSin:
+ case core::BuiltinFn::kSinh:
+ case core::BuiltinFn::kSqrt:
+ case core::BuiltinFn::kTan:
+ case core::BuiltinFn::kTanh:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2");
} else {
return builder->Call(str.str(), "f2");
}
- case core::Function::kLdexp:
+ case core::BuiltinFn::kLdexp:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "i2");
} else {
return builder->Call(str.str(), "f2", "i2");
}
- case core::Function::kAtan2:
- case core::Function::kDot:
- case core::Function::kDistance:
- case core::Function::kPow:
- case core::Function::kReflect:
- case core::Function::kStep:
+ case core::BuiltinFn::kAtan2:
+ case core::BuiltinFn::kDot:
+ case core::BuiltinFn::kDistance:
+ case core::BuiltinFn::kPow:
+ case core::BuiltinFn::kReflect:
+ case core::BuiltinFn::kStep:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2");
} else {
return builder->Call(str.str(), "f2", "f2");
}
- case core::Function::kCross:
+ case core::BuiltinFn::kCross:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h3", "h3");
} else {
return builder->Call(str.str(), "f3", "f3");
}
- case core::Function::kFma:
- case core::Function::kMix:
- case core::Function::kFaceForward:
- case core::Function::kSmoothstep:
+ case core::BuiltinFn::kFma:
+ case core::BuiltinFn::kMix:
+ case core::BuiltinFn::kFaceForward:
+ case core::BuiltinFn::kSmoothstep:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2", "h2");
} else {
return builder->Call(str.str(), "f2", "f2", "f2");
}
- case core::Function::kAll:
- case core::Function::kAny:
+ case core::BuiltinFn::kAll:
+ case core::BuiltinFn::kAny:
return builder->Call(str.str(), "b2");
- case core::Function::kAbs:
+ case core::BuiltinFn::kAbs:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2");
} else if (type == CallParamType::kF16) {
@@ -145,11 +145,11 @@
} else {
return builder->Call(str.str(), "u2");
}
- case core::Function::kCountOneBits:
- case core::Function::kReverseBits:
+ case core::BuiltinFn::kCountOneBits:
+ case core::BuiltinFn::kReverseBits:
return builder->Call(str.str(), "u2");
- case core::Function::kMax:
- case core::Function::kMin:
+ case core::BuiltinFn::kMax:
+ case core::BuiltinFn::kMin:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2", "f2");
} else if (type == CallParamType::kF16) {
@@ -157,7 +157,7 @@
} else {
return builder->Call(str.str(), "u2", "u2");
}
- case core::Function::kClamp:
+ case core::BuiltinFn::kClamp:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2", "f2", "f2");
} else if (type == CallParamType::kF16) {
@@ -165,19 +165,19 @@
} else {
return builder->Call(str.str(), "u2", "u2", "u2");
}
- case core::Function::kSelect:
+ case core::BuiltinFn::kSelect:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2", "b2");
} else {
return builder->Call(str.str(), "f2", "f2", "b2");
}
- case core::Function::kDeterminant:
+ case core::BuiltinFn::kDeterminant:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "hm2x2");
} else {
return builder->Call(str.str(), "m2x2");
}
- case core::Function::kTranspose:
+ case core::BuiltinFn::kTranspose:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "hm3x2");
} else {
@@ -224,7 +224,7 @@
ASSERT_NE(sem, nullptr);
auto* target = sem->Target();
ASSERT_NE(target, nullptr);
- auto* builtin = target->As<sem::Builtin>();
+ auto* builtin = target->As<sem::BuiltinFn>();
ASSERT_NE(builtin, nullptr);
EXPECT_EQ(gen.generate_builtin_name(builtin), param.hlsl_name);
@@ -233,105 +233,105 @@
HlslASTPrinterTest_Builtin,
HlslBuiltinTest,
testing::Values(/* Logical built-in */
- BuiltinData{core::Function::kAll, CallParamType::kBool, "all"},
- BuiltinData{core::Function::kAny, CallParamType::kBool, "any"},
+ BuiltinData{core::BuiltinFn::kAll, CallParamType::kBool, "all"},
+ BuiltinData{core::BuiltinFn::kAny, CallParamType::kBool, "any"},
/* Float built-in */
- BuiltinData{core::Function::kAbs, CallParamType::kF32, "abs"},
- BuiltinData{core::Function::kAbs, CallParamType::kF16, "abs"},
- BuiltinData{core::Function::kAcos, CallParamType::kF32, "acos"},
- BuiltinData{core::Function::kAcos, CallParamType::kF16, "acos"},
- BuiltinData{core::Function::kAsin, CallParamType::kF32, "asin"},
- BuiltinData{core::Function::kAsin, CallParamType::kF16, "asin"},
- BuiltinData{core::Function::kAtan, CallParamType::kF32, "atan"},
- BuiltinData{core::Function::kAtan, CallParamType::kF16, "atan"},
- BuiltinData{core::Function::kAtan2, CallParamType::kF32, "atan2"},
- BuiltinData{core::Function::kAtan2, CallParamType::kF16, "atan2"},
- BuiltinData{core::Function::kCeil, CallParamType::kF32, "ceil"},
- BuiltinData{core::Function::kCeil, CallParamType::kF16, "ceil"},
- BuiltinData{core::Function::kClamp, CallParamType::kF32, "clamp"},
- BuiltinData{core::Function::kClamp, CallParamType::kF16, "clamp"},
- BuiltinData{core::Function::kCos, CallParamType::kF32, "cos"},
- BuiltinData{core::Function::kCos, CallParamType::kF16, "cos"},
- BuiltinData{core::Function::kCosh, CallParamType::kF32, "cosh"},
- BuiltinData{core::Function::kCosh, CallParamType::kF16, "cosh"},
- BuiltinData{core::Function::kCross, CallParamType::kF32, "cross"},
- BuiltinData{core::Function::kCross, CallParamType::kF16, "cross"},
- BuiltinData{core::Function::kDistance, CallParamType::kF32, "distance"},
- BuiltinData{core::Function::kDistance, CallParamType::kF16, "distance"},
- BuiltinData{core::Function::kExp, CallParamType::kF32, "exp"},
- BuiltinData{core::Function::kExp, CallParamType::kF16, "exp"},
- BuiltinData{core::Function::kExp2, CallParamType::kF32, "exp2"},
- BuiltinData{core::Function::kExp2, CallParamType::kF16, "exp2"},
- BuiltinData{core::Function::kFaceForward, CallParamType::kF32, "faceforward"},
- BuiltinData{core::Function::kFaceForward, CallParamType::kF16, "faceforward"},
- BuiltinData{core::Function::kFloor, CallParamType::kF32, "floor"},
- BuiltinData{core::Function::kFloor, CallParamType::kF16, "floor"},
- BuiltinData{core::Function::kFma, CallParamType::kF32, "mad"},
- BuiltinData{core::Function::kFma, CallParamType::kF16, "mad"},
- BuiltinData{core::Function::kFract, CallParamType::kF32, "frac"},
- BuiltinData{core::Function::kFract, CallParamType::kF16, "frac"},
- BuiltinData{core::Function::kInverseSqrt, CallParamType::kF32, "rsqrt"},
- BuiltinData{core::Function::kInverseSqrt, CallParamType::kF16, "rsqrt"},
- BuiltinData{core::Function::kLdexp, CallParamType::kF32, "ldexp"},
- BuiltinData{core::Function::kLdexp, CallParamType::kF16, "ldexp"},
- BuiltinData{core::Function::kLength, CallParamType::kF32, "length"},
- BuiltinData{core::Function::kLength, CallParamType::kF16, "length"},
- BuiltinData{core::Function::kLog, CallParamType::kF32, "log"},
- BuiltinData{core::Function::kLog, CallParamType::kF16, "log"},
- BuiltinData{core::Function::kLog2, CallParamType::kF32, "log2"},
- BuiltinData{core::Function::kLog2, CallParamType::kF16, "log2"},
- BuiltinData{core::Function::kMax, CallParamType::kF32, "max"},
- BuiltinData{core::Function::kMax, CallParamType::kF16, "max"},
- BuiltinData{core::Function::kMin, CallParamType::kF32, "min"},
- BuiltinData{core::Function::kMin, CallParamType::kF16, "min"},
- BuiltinData{core::Function::kMix, CallParamType::kF32, "lerp"},
- BuiltinData{core::Function::kMix, CallParamType::kF16, "lerp"},
- BuiltinData{core::Function::kNormalize, CallParamType::kF32, "normalize"},
- BuiltinData{core::Function::kNormalize, CallParamType::kF16, "normalize"},
- BuiltinData{core::Function::kPow, CallParamType::kF32, "pow"},
- BuiltinData{core::Function::kPow, CallParamType::kF16, "pow"},
- BuiltinData{core::Function::kReflect, CallParamType::kF32, "reflect"},
- BuiltinData{core::Function::kReflect, CallParamType::kF16, "reflect"},
- BuiltinData{core::Function::kSin, CallParamType::kF32, "sin"},
- BuiltinData{core::Function::kSin, CallParamType::kF16, "sin"},
- BuiltinData{core::Function::kSinh, CallParamType::kF32, "sinh"},
- BuiltinData{core::Function::kSinh, CallParamType::kF16, "sinh"},
- BuiltinData{core::Function::kSmoothstep, CallParamType::kF32, "smoothstep"},
- BuiltinData{core::Function::kSmoothstep, CallParamType::kF16, "smoothstep"},
- BuiltinData{core::Function::kSqrt, CallParamType::kF32, "sqrt"},
- BuiltinData{core::Function::kSqrt, CallParamType::kF16, "sqrt"},
- BuiltinData{core::Function::kStep, CallParamType::kF32, "step"},
- BuiltinData{core::Function::kStep, CallParamType::kF16, "step"},
- BuiltinData{core::Function::kTan, CallParamType::kF32, "tan"},
- BuiltinData{core::Function::kTan, CallParamType::kF16, "tan"},
- BuiltinData{core::Function::kTanh, CallParamType::kF32, "tanh"},
- BuiltinData{core::Function::kTanh, CallParamType::kF16, "tanh"},
+ BuiltinData{core::BuiltinFn::kAbs, CallParamType::kF32, "abs"},
+ BuiltinData{core::BuiltinFn::kAbs, CallParamType::kF16, "abs"},
+ BuiltinData{core::BuiltinFn::kAcos, CallParamType::kF32, "acos"},
+ BuiltinData{core::BuiltinFn::kAcos, CallParamType::kF16, "acos"},
+ BuiltinData{core::BuiltinFn::kAsin, CallParamType::kF32, "asin"},
+ BuiltinData{core::BuiltinFn::kAsin, CallParamType::kF16, "asin"},
+ BuiltinData{core::BuiltinFn::kAtan, CallParamType::kF32, "atan"},
+ BuiltinData{core::BuiltinFn::kAtan, CallParamType::kF16, "atan"},
+ BuiltinData{core::BuiltinFn::kAtan2, CallParamType::kF32, "atan2"},
+ BuiltinData{core::BuiltinFn::kAtan2, CallParamType::kF16, "atan2"},
+ BuiltinData{core::BuiltinFn::kCeil, CallParamType::kF32, "ceil"},
+ BuiltinData{core::BuiltinFn::kCeil, CallParamType::kF16, "ceil"},
+ BuiltinData{core::BuiltinFn::kClamp, CallParamType::kF32, "clamp"},
+ BuiltinData{core::BuiltinFn::kClamp, CallParamType::kF16, "clamp"},
+ BuiltinData{core::BuiltinFn::kCos, CallParamType::kF32, "cos"},
+ BuiltinData{core::BuiltinFn::kCos, CallParamType::kF16, "cos"},
+ BuiltinData{core::BuiltinFn::kCosh, CallParamType::kF32, "cosh"},
+ BuiltinData{core::BuiltinFn::kCosh, CallParamType::kF16, "cosh"},
+ BuiltinData{core::BuiltinFn::kCross, CallParamType::kF32, "cross"},
+ BuiltinData{core::BuiltinFn::kCross, CallParamType::kF16, "cross"},
+ BuiltinData{core::BuiltinFn::kDistance, CallParamType::kF32, "distance"},
+ BuiltinData{core::BuiltinFn::kDistance, CallParamType::kF16, "distance"},
+ BuiltinData{core::BuiltinFn::kExp, CallParamType::kF32, "exp"},
+ BuiltinData{core::BuiltinFn::kExp, CallParamType::kF16, "exp"},
+ BuiltinData{core::BuiltinFn::kExp2, CallParamType::kF32, "exp2"},
+ BuiltinData{core::BuiltinFn::kExp2, CallParamType::kF16, "exp2"},
+ BuiltinData{core::BuiltinFn::kFaceForward, CallParamType::kF32, "faceforward"},
+ BuiltinData{core::BuiltinFn::kFaceForward, CallParamType::kF16, "faceforward"},
+ BuiltinData{core::BuiltinFn::kFloor, CallParamType::kF32, "floor"},
+ BuiltinData{core::BuiltinFn::kFloor, CallParamType::kF16, "floor"},
+ BuiltinData{core::BuiltinFn::kFma, CallParamType::kF32, "mad"},
+ BuiltinData{core::BuiltinFn::kFma, CallParamType::kF16, "mad"},
+ BuiltinData{core::BuiltinFn::kFract, CallParamType::kF32, "frac"},
+ BuiltinData{core::BuiltinFn::kFract, CallParamType::kF16, "frac"},
+ BuiltinData{core::BuiltinFn::kInverseSqrt, CallParamType::kF32, "rsqrt"},
+ BuiltinData{core::BuiltinFn::kInverseSqrt, CallParamType::kF16, "rsqrt"},
+ BuiltinData{core::BuiltinFn::kLdexp, CallParamType::kF32, "ldexp"},
+ BuiltinData{core::BuiltinFn::kLdexp, CallParamType::kF16, "ldexp"},
+ BuiltinData{core::BuiltinFn::kLength, CallParamType::kF32, "length"},
+ BuiltinData{core::BuiltinFn::kLength, CallParamType::kF16, "length"},
+ BuiltinData{core::BuiltinFn::kLog, CallParamType::kF32, "log"},
+ BuiltinData{core::BuiltinFn::kLog, CallParamType::kF16, "log"},
+ BuiltinData{core::BuiltinFn::kLog2, CallParamType::kF32, "log2"},
+ BuiltinData{core::BuiltinFn::kLog2, CallParamType::kF16, "log2"},
+ BuiltinData{core::BuiltinFn::kMax, CallParamType::kF32, "max"},
+ BuiltinData{core::BuiltinFn::kMax, CallParamType::kF16, "max"},
+ BuiltinData{core::BuiltinFn::kMin, CallParamType::kF32, "min"},
+ BuiltinData{core::BuiltinFn::kMin, CallParamType::kF16, "min"},
+ BuiltinData{core::BuiltinFn::kMix, CallParamType::kF32, "lerp"},
+ BuiltinData{core::BuiltinFn::kMix, CallParamType::kF16, "lerp"},
+ BuiltinData{core::BuiltinFn::kNormalize, CallParamType::kF32, "normalize"},
+ BuiltinData{core::BuiltinFn::kNormalize, CallParamType::kF16, "normalize"},
+ BuiltinData{core::BuiltinFn::kPow, CallParamType::kF32, "pow"},
+ BuiltinData{core::BuiltinFn::kPow, CallParamType::kF16, "pow"},
+ BuiltinData{core::BuiltinFn::kReflect, CallParamType::kF32, "reflect"},
+ BuiltinData{core::BuiltinFn::kReflect, CallParamType::kF16, "reflect"},
+ BuiltinData{core::BuiltinFn::kSin, CallParamType::kF32, "sin"},
+ BuiltinData{core::BuiltinFn::kSin, CallParamType::kF16, "sin"},
+ BuiltinData{core::BuiltinFn::kSinh, CallParamType::kF32, "sinh"},
+ BuiltinData{core::BuiltinFn::kSinh, CallParamType::kF16, "sinh"},
+ BuiltinData{core::BuiltinFn::kSmoothstep, CallParamType::kF32, "smoothstep"},
+ BuiltinData{core::BuiltinFn::kSmoothstep, CallParamType::kF16, "smoothstep"},
+ BuiltinData{core::BuiltinFn::kSqrt, CallParamType::kF32, "sqrt"},
+ BuiltinData{core::BuiltinFn::kSqrt, CallParamType::kF16, "sqrt"},
+ BuiltinData{core::BuiltinFn::kStep, CallParamType::kF32, "step"},
+ BuiltinData{core::BuiltinFn::kStep, CallParamType::kF16, "step"},
+ BuiltinData{core::BuiltinFn::kTan, CallParamType::kF32, "tan"},
+ BuiltinData{core::BuiltinFn::kTan, CallParamType::kF16, "tan"},
+ BuiltinData{core::BuiltinFn::kTanh, CallParamType::kF32, "tanh"},
+ BuiltinData{core::BuiltinFn::kTanh, CallParamType::kF16, "tanh"},
/* Integer built-in */
- BuiltinData{core::Function::kAbs, CallParamType::kU32, "abs"},
- BuiltinData{core::Function::kClamp, CallParamType::kU32, "clamp"},
- BuiltinData{core::Function::kCountOneBits, CallParamType::kU32, "countbits"},
- BuiltinData{core::Function::kMax, CallParamType::kU32, "max"},
- BuiltinData{core::Function::kMin, CallParamType::kU32, "min"},
- BuiltinData{core::Function::kReverseBits, CallParamType::kU32, "reversebits"},
- BuiltinData{core::Function::kRound, CallParamType::kU32, "round"},
+ BuiltinData{core::BuiltinFn::kAbs, CallParamType::kU32, "abs"},
+ BuiltinData{core::BuiltinFn::kClamp, CallParamType::kU32, "clamp"},
+ BuiltinData{core::BuiltinFn::kCountOneBits, CallParamType::kU32, "countbits"},
+ BuiltinData{core::BuiltinFn::kMax, CallParamType::kU32, "max"},
+ BuiltinData{core::BuiltinFn::kMin, CallParamType::kU32, "min"},
+ BuiltinData{core::BuiltinFn::kReverseBits, CallParamType::kU32, "reversebits"},
+ BuiltinData{core::BuiltinFn::kRound, CallParamType::kU32, "round"},
/* Matrix built-in */
- BuiltinData{core::Function::kDeterminant, CallParamType::kF32, "determinant"},
- BuiltinData{core::Function::kDeterminant, CallParamType::kF16, "determinant"},
- BuiltinData{core::Function::kTranspose, CallParamType::kF32, "transpose"},
- BuiltinData{core::Function::kTranspose, CallParamType::kF16, "transpose"},
+ BuiltinData{core::BuiltinFn::kDeterminant, CallParamType::kF32, "determinant"},
+ BuiltinData{core::BuiltinFn::kDeterminant, CallParamType::kF16, "determinant"},
+ BuiltinData{core::BuiltinFn::kTranspose, CallParamType::kF32, "transpose"},
+ BuiltinData{core::BuiltinFn::kTranspose, CallParamType::kF16, "transpose"},
/* Vector built-in */
- BuiltinData{core::Function::kDot, CallParamType::kF32, "dot"},
- BuiltinData{core::Function::kDot, CallParamType::kF16, "dot"},
+ BuiltinData{core::BuiltinFn::kDot, CallParamType::kF32, "dot"},
+ BuiltinData{core::BuiltinFn::kDot, CallParamType::kF16, "dot"},
/* Derivate built-in */
- BuiltinData{core::Function::kDpdx, CallParamType::kF32, "ddx"},
- BuiltinData{core::Function::kDpdxCoarse, CallParamType::kF32, "ddx_coarse"},
- BuiltinData{core::Function::kDpdxFine, CallParamType::kF32, "ddx_fine"},
- BuiltinData{core::Function::kDpdy, CallParamType::kF32, "ddy"},
- BuiltinData{core::Function::kDpdyCoarse, CallParamType::kF32, "ddy_coarse"},
- BuiltinData{core::Function::kDpdyFine, CallParamType::kF32, "ddy_fine"},
- BuiltinData{core::Function::kFwidth, CallParamType::kF32, "fwidth"},
- BuiltinData{core::Function::kFwidthCoarse, CallParamType::kF32, "fwidth"},
- BuiltinData{core::Function::kFwidthFine, CallParamType::kF32, "fwidth"}));
+ BuiltinData{core::BuiltinFn::kDpdx, CallParamType::kF32, "ddx"},
+ BuiltinData{core::BuiltinFn::kDpdxCoarse, CallParamType::kF32, "ddx_coarse"},
+ BuiltinData{core::BuiltinFn::kDpdxFine, CallParamType::kF32, "ddx_fine"},
+ BuiltinData{core::BuiltinFn::kDpdy, CallParamType::kF32, "ddy"},
+ BuiltinData{core::BuiltinFn::kDpdyCoarse, CallParamType::kF32, "ddy_coarse"},
+ BuiltinData{core::BuiltinFn::kDpdyFine, CallParamType::kF32, "ddy_fine"},
+ BuiltinData{core::BuiltinFn::kFwidth, CallParamType::kF32, "fwidth"},
+ BuiltinData{core::BuiltinFn::kFwidthCoarse, CallParamType::kF32, "fwidth"},
+ BuiltinData{core::BuiltinFn::kFwidthFine, CallParamType::kF32, "fwidth"}));
TEST_F(HlslASTPrinterTest_Builtin, Builtin_Call) {
auto* call = Call("dot", "param1", "param2");
diff --git a/src/tint/lang/hlsl/writer/ast_raise/calculate_array_length.cc b/src/tint/lang/hlsl/writer/ast_raise/calculate_array_length.cc
index 604700f..95c0661 100644
--- a/src/tint/lang/hlsl/writer/ast_raise/calculate_array_length.cc
+++ b/src/tint/lang/hlsl/writer/ast_raise/calculate_array_length.cc
@@ -47,7 +47,7 @@
for (auto* fn : program->AST().Functions()) {
if (auto* sem_fn = program->Sem().Get(fn)) {
for (auto* builtin : sem_fn->DirectlyCalledBuiltins()) {
- if (builtin->Type() == core::Function::kArrayLength) {
+ if (builtin->Fn() == core::BuiltinFn::kArrayLength) {
return true;
}
}
@@ -129,8 +129,8 @@
for (auto* node : src->ASTNodes().Objects()) {
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() == core::Function::kArrayLength) {
+ if (auto* builtin = call->Target()->As<sem::BuiltinFn>()) {
+ if (builtin->Fn() == core::BuiltinFn::kArrayLength) {
// We're dealing with an arrayLength() call
if (auto* call_stmt = call->Stmt()->Declaration()->As<ast::CallStatement>()) {
diff --git a/src/tint/lang/hlsl/writer/ast_raise/decompose_memory_access.cc b/src/tint/lang/hlsl/writer/ast_raise/decompose_memory_access.cc
index 9cff4ce..fe6977e 100644
--- a/src/tint/lang/hlsl/writer/ast_raise/decompose_memory_access.cc
+++ b/src/tint/lang/hlsl/writer/ast_raise/decompose_memory_access.cc
@@ -129,7 +129,7 @@
/// AtomicKey is the unordered map key to an atomic intrinsic.
struct AtomicKey {
core::type::Type const* el_ty = nullptr; // element type
- core::Function const op; // atomic op
+ core::BuiltinFn 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;
@@ -254,42 +254,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(ast::Builder* builder,
- core::Function ity,
+ core::BuiltinFn ity,
const core::type::Type* ty,
const Symbol& buffer) {
auto op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicLoad;
switch (ity) {
- case core::Function::kAtomicLoad:
+ case core::BuiltinFn::kAtomicLoad:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicLoad;
break;
- case core::Function::kAtomicStore:
+ case core::BuiltinFn::kAtomicStore:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicStore;
break;
- case core::Function::kAtomicAdd:
+ case core::BuiltinFn::kAtomicAdd:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicAdd;
break;
- case core::Function::kAtomicSub:
+ case core::BuiltinFn::kAtomicSub:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicSub;
break;
- case core::Function::kAtomicMax:
+ case core::BuiltinFn::kAtomicMax:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicMax;
break;
- case core::Function::kAtomicMin:
+ case core::BuiltinFn::kAtomicMin:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicMin;
break;
- case core::Function::kAtomicAnd:
+ case core::BuiltinFn::kAtomicAnd:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicAnd;
break;
- case core::Function::kAtomicOr:
+ case core::BuiltinFn::kAtomicOr:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicOr;
break;
- case core::Function::kAtomicXor:
+ case core::BuiltinFn::kAtomicXor:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicXor;
break;
- case core::Function::kAtomicExchange:
+ case core::BuiltinFn::kAtomicExchange:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicExchange;
break;
- case core::Function::kAtomicCompareExchangeWeak:
+ case core::BuiltinFn::kAtomicCompareExchangeWeak:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicCompareExchangeWeak;
break;
default:
@@ -629,38 +629,38 @@
});
}
- /// AtomicFunc() returns a symbol to an intrinsic function that performs an atomic operation on
+ /// AtomicFunc() returns a symbol to an builtin function that performs an atomic operation on
/// the storage buffer @p buffer. The function has the signature:
// `fn atomic_op(offset : u32, ...) -> T`
/// @param el_ty the storage buffer element type
- /// @param intrinsic the atomic intrinsic
+ /// @param builtin the atomic builtin
/// @param buffer the symbol of the storage buffer variable, owned by the target ProgramBuilder.
/// @return the name of the function that performs the load
Symbol AtomicFunc(const core::type::Type* el_ty,
- const sem::Builtin* intrinsic,
+ const sem::BuiltinFn* builtin,
const Symbol& buffer) {
- auto op = intrinsic->Type();
- return tint::GetOrCreate(atomic_funcs, AtomicKey{el_ty, op, buffer}, [&] {
+ auto fn = builtin->Fn();
+ return tint::GetOrCreate(atomic_funcs, AtomicKey{el_ty, fn, buffer}, [&] {
// The first parameter to all WGSL atomics is the expression to the
// atomic. This is replaced with two parameters: the buffer and offset.
Vector params{b.Param("offset", b.ty.u32())};
// Other parameters are copied as-is:
- for (size_t i = 1; i < intrinsic->Parameters().Length(); i++) {
- auto* param = intrinsic->Parameters()[i];
+ for (size_t i = 1; i < builtin->Parameters().Length(); i++) {
+ auto* param = builtin->Parameters()[i];
auto ty = CreateASTTypeFor(ctx, param->Type());
params.Push(b.Param("param_" + std::to_string(i), ty));
}
- auto* atomic = IntrinsicAtomicFor(ctx.dst, op, el_ty, buffer);
+ auto* atomic = IntrinsicAtomicFor(ctx.dst, fn, el_ty, buffer);
if (TINT_UNLIKELY(!atomic)) {
- TINT_ICE() << "IntrinsicAtomicFor() returned nullptr for op " << op << " and type "
+ TINT_ICE() << "IntrinsicAtomicFor() returned nullptr for fn " << fn << " and type "
<< el_ty->TypeInfo().name;
}
- ast::Type ret_ty = CreateASTTypeFor(ctx, intrinsic->ReturnType());
+ ast::Type ret_ty = CreateASTTypeFor(ctx, builtin->ReturnType());
- auto name = b.Symbols().New(buffer.Name() + intrinsic->str());
+ auto name = b.Symbols().New(buffer.Name() + builtin->str());
b.Func(name, std::move(params), ret_ty, nullptr,
Vector{
atomic,
@@ -921,8 +921,8 @@
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() == core::Function::kArrayLength) {
+ if (auto* builtin = call->Target()->As<sem::BuiltinFn>()) {
+ if (builtin->Fn() == core::BuiltinFn::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/lang/msl/writer/ast_printer/ast_printer.cc b/src/tint/lang/msl/writer/ast_printer/ast_printer.cc
index e2fd37e..dc72ff3 100644
--- a/src/tint/lang/msl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/msl/writer/ast_printer/ast_printer.cc
@@ -630,7 +630,7 @@
auto* target = call->Target();
return Switch(
target, [&](const sem::Function* func) { return EmitFunctionCall(out, call, func); },
- [&](const sem::Builtin* builtin) { return EmitBuiltinCall(out, call, builtin); },
+ [&](const sem::BuiltinFn* builtin) { return EmitBuiltinCall(out, call, builtin); },
[&](const sem::ValueConversion* conv) { return EmitTypeConversion(out, call, conv); },
[&](const sem::ValueConstructor* ctor) { return EmitTypeInitializer(out, call, ctor); },
[&](Default) {
@@ -668,7 +668,7 @@
bool ASTPrinter::EmitBuiltinCall(StringStream& out,
const sem::Call* call,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
auto* expr = call->Declaration();
if (builtin->IsAtomic()) {
return EmitAtomicCall(out, expr, builtin);
@@ -679,25 +679,25 @@
auto name = generate_builtin_name(builtin);
- switch (builtin->Type()) {
- case core::Function::kDot:
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kDot:
return EmitDotCall(out, expr, builtin);
- case core::Function::kModf:
+ case core::BuiltinFn::kModf:
return EmitModfCall(out, expr, builtin);
- case core::Function::kFrexp:
+ case core::BuiltinFn::kFrexp:
return EmitFrexpCall(out, expr, builtin);
- case core::Function::kDegrees:
+ case core::BuiltinFn::kDegrees:
return EmitDegreesCall(out, expr, builtin);
- case core::Function::kRadians:
+ case core::BuiltinFn::kRadians:
return EmitRadiansCall(out, expr, builtin);
- case core::Function::kDot4I8Packed:
+ case core::BuiltinFn::kDot4I8Packed:
return EmitDot4I8PackedCall(out, expr, builtin);
- case core::Function::kDot4U8Packed:
+ case core::BuiltinFn::kDot4U8Packed:
return EmitDot4U8PackedCall(out, expr, builtin);
- case core::Function::kPack2X16Float:
- case core::Function::kUnpack2X16Float: {
- if (builtin->Type() == core::Function::kPack2X16Float) {
+ case core::BuiltinFn::kPack2X16Float:
+ case core::BuiltinFn::kUnpack2X16Float: {
+ if (builtin->Fn() == core::BuiltinFn::kPack2X16Float) {
out << "as_type<uint>(half2(";
} else {
out << "float2(as_type<half2>(";
@@ -708,7 +708,7 @@
out << "))";
return true;
}
- case core::Function::kQuantizeToF16: {
+ case core::BuiltinFn::kQuantizeToF16: {
std::string width = "";
if (auto* vec = builtin->ReturnType()->As<core::type::Vector>()) {
width = std::to_string(vec->Width());
@@ -722,20 +722,20 @@
}
// TODO(crbug.com/tint/661): Combine sequential barriers to a single
// instruction.
- case core::Function::kStorageBarrier: {
+ case core::BuiltinFn::kStorageBarrier: {
out << "threadgroup_barrier(mem_flags::mem_device)";
return true;
}
- case core::Function::kWorkgroupBarrier: {
+ case core::BuiltinFn::kWorkgroupBarrier: {
out << "threadgroup_barrier(mem_flags::mem_threadgroup)";
return true;
}
- case core::Function::kTextureBarrier: {
+ case core::BuiltinFn::kTextureBarrier: {
out << "threadgroup_barrier(mem_flags::mem_texture)";
return true;
}
- case core::Function::kLength: {
+ case core::BuiltinFn::kLength: {
auto* sem = builder_.Sem().GetVal(expr->args[0]);
if (sem->Type()->UnwrapRef()->Is<core::type::Scalar>()) {
// Emulate scalar overload using fabs(x).
@@ -744,7 +744,7 @@
break;
}
- case core::Function::kDistance: {
+ case core::BuiltinFn::kDistance: {
auto* sem = builder_.Sem().GetVal(expr->args[0]);
if (sem->Type()->UnwrapRef()->Is<core::type::Scalar>()) {
// Emulate scalar overload using fabs(x - y);
@@ -762,7 +762,7 @@
break;
}
- case core::Function::kSubgroupBroadcast: {
+ case core::BuiltinFn::kSubgroupBroadcast: {
// The lane argument is ushort.
out << "simd_broadcast(";
if (!EmitExpression(out, expr->args[0])) {
@@ -876,7 +876,7 @@
bool ASTPrinter::EmitAtomicCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
auto call = [&](const std::string& name, bool append_memory_order_relaxed) {
out << name;
{
@@ -897,38 +897,38 @@
return true;
};
- switch (builtin->Type()) {
- case core::Function::kAtomicLoad:
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kAtomicLoad:
return call("atomic_load_explicit", true);
- case core::Function::kAtomicStore:
+ case core::BuiltinFn::kAtomicStore:
return call("atomic_store_explicit", true);
- case core::Function::kAtomicAdd:
+ case core::BuiltinFn::kAtomicAdd:
return call("atomic_fetch_add_explicit", true);
- case core::Function::kAtomicSub:
+ case core::BuiltinFn::kAtomicSub:
return call("atomic_fetch_sub_explicit", true);
- case core::Function::kAtomicMax:
+ case core::BuiltinFn::kAtomicMax:
return call("atomic_fetch_max_explicit", true);
- case core::Function::kAtomicMin:
+ case core::BuiltinFn::kAtomicMin:
return call("atomic_fetch_min_explicit", true);
- case core::Function::kAtomicAnd:
+ case core::BuiltinFn::kAtomicAnd:
return call("atomic_fetch_and_explicit", true);
- case core::Function::kAtomicOr:
+ case core::BuiltinFn::kAtomicOr:
return call("atomic_fetch_or_explicit", true);
- case core::Function::kAtomicXor:
+ case core::BuiltinFn::kAtomicXor:
return call("atomic_fetch_xor_explicit", true);
- case core::Function::kAtomicExchange:
+ case core::BuiltinFn::kAtomicExchange:
return call("atomic_exchange_explicit", true);
- case core::Function::kAtomicCompareExchangeWeak: {
+ case core::BuiltinFn::kAtomicCompareExchangeWeak: {
auto* ptr_ty = TypeOf(expr->args[0])->UnwrapRef()->As<core::type::Pointer>();
auto sc = ptr_ty->AddressSpace();
auto* str = builtin->ReturnType()->As<core::type::Struct>();
@@ -995,13 +995,13 @@
break;
}
- TINT_UNREACHABLE() << "unsupported atomic builtin: " << builtin->Type();
+ TINT_UNREACHABLE() << "unsupported atomic builtin: " << builtin->Fn();
return false;
}
bool ASTPrinter::EmitTextureCall(StringStream& out,
const sem::Call* call,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
using Usage = core::ParameterUsage;
auto& signature = builtin->Signature();
@@ -1043,8 +1043,8 @@
// MSL requires that `lod` is a constant 0 for 1D textures.
bool level_is_constant_zero = texture_type->dim() == core::type::TextureDimension::k1d;
- switch (builtin->Type()) {
- case core::Function::kTextureDimensions: {
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kTextureDimensions: {
std::vector<const char*> dims;
switch (texture_type->dim()) {
case core::type::TextureDimension::kNone:
@@ -1097,21 +1097,21 @@
}
return true;
}
- case core::Function::kTextureNumLayers: {
+ case core::BuiltinFn::kTextureNumLayers: {
if (!texture_expr()) {
return false;
}
out << ".get_array_size()";
return true;
}
- case core::Function::kTextureNumLevels: {
+ case core::BuiltinFn::kTextureNumLevels: {
if (!texture_expr()) {
return false;
}
out << ".get_num_mip_levels()";
return true;
}
- case core::Function::kTextureNumSamples: {
+ case core::BuiltinFn::kTextureNumSamples: {
if (!texture_expr()) {
return false;
}
@@ -1128,28 +1128,28 @@
bool lod_param_is_named = true;
- switch (builtin->Type()) {
- case core::Function::kTextureSample:
- case core::Function::kTextureSampleBias:
- case core::Function::kTextureSampleLevel:
- case core::Function::kTextureSampleGrad:
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kTextureSample:
+ case core::BuiltinFn::kTextureSampleBias:
+ case core::BuiltinFn::kTextureSampleLevel:
+ case core::BuiltinFn::kTextureSampleGrad:
out << ".sample(";
break;
- case core::Function::kTextureSampleCompare:
- case core::Function::kTextureSampleCompareLevel:
+ case core::BuiltinFn::kTextureSampleCompare:
+ case core::BuiltinFn::kTextureSampleCompareLevel:
out << ".sample_compare(";
break;
- case core::Function::kTextureGather:
+ case core::BuiltinFn::kTextureGather:
out << ".gather(";
break;
- case core::Function::kTextureGatherCompare:
+ case core::BuiltinFn::kTextureGatherCompare:
out << ".gather_compare(";
break;
- case core::Function::kTextureLoad:
+ case core::BuiltinFn::kTextureLoad:
out << ".read(";
lod_param_is_named = false;
break;
- case core::Function::kTextureStore:
+ case core::BuiltinFn::kTextureStore:
out << ".write(";
break;
default:
@@ -1225,7 +1225,7 @@
out << ")";
}
}
- if (builtin->Type() == core::Function::kTextureSampleCompareLevel) {
+ if (builtin->Fn() == core::BuiltinFn::kTextureSampleCompareLevel) {
maybe_write_comma();
out << "level(0)";
}
@@ -1310,7 +1310,7 @@
// If this is a `textureStore()` for a read-write texture, add a fence to ensure that the
// written values are visible to subsequent reads from the same thread.
if (auto* storage = texture_type->As<core::type::StorageTexture>();
- builtin->Type() == core::Function::kTextureStore &&
+ builtin->Fn() == core::BuiltinFn::kTextureStore &&
storage->access() == core::Access::kReadWrite) {
out << "; ";
texture_expr();
@@ -1322,7 +1322,7 @@
bool ASTPrinter::EmitDotCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
auto* vec_ty = builtin->Parameters()[0]->Type()->As<core::type::Vector>();
std::string fn = "dot";
if (vec_ty->type()->is_integer_scalar()) {
@@ -1367,7 +1367,7 @@
bool ASTPrinter::EmitDot4I8PackedCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
return CallBuiltinHelper(
out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
Line(b) << "packed_char4 vec1 = as_type<packed_char4>(" << params[0] << ");";
@@ -1380,7 +1380,7 @@
bool ASTPrinter::EmitDot4U8PackedCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
return CallBuiltinHelper(
out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
Line(b) << "packed_uchar4 vec1 = as_type<packed_uchar4>(" << params[0] << ");";
@@ -1393,7 +1393,7 @@
bool ASTPrinter::EmitModfCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
return CallBuiltinHelper(
out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
auto* ty = builtin->Parameters()[0]->Type();
@@ -1419,7 +1419,7 @@
bool ASTPrinter::EmitFrexpCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
return CallBuiltinHelper(
out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
auto* ty = builtin->Parameters()[0]->Type();
@@ -1445,7 +1445,7 @@
bool ASTPrinter::EmitDegreesCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
return CallBuiltinHelper(out, expr, builtin,
[&](TextBuffer* b, const std::vector<std::string>& params) {
Line(b) << "return " << params[0] << " * " << std::setprecision(20)
@@ -1456,7 +1456,7 @@
bool ASTPrinter::EmitRadiansCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin) {
+ const sem::BuiltinFn* builtin) {
return CallBuiltinHelper(out, expr, builtin,
[&](TextBuffer* b, const std::vector<std::string>& params) {
Line(b) << "return " << params[0] << " * " << std::setprecision(20)
@@ -1465,146 +1465,146 @@
});
}
-std::string ASTPrinter::generate_builtin_name(const sem::Builtin* builtin) {
+std::string ASTPrinter::generate_builtin_name(const sem::BuiltinFn* builtin) {
std::string out = "";
- switch (builtin->Type()) {
- case core::Function::kAcos:
- case core::Function::kAcosh:
- case core::Function::kAll:
- case core::Function::kAny:
- case core::Function::kAsin:
- case core::Function::kAsinh:
- case core::Function::kAtanh:
- case core::Function::kAtan:
- case core::Function::kAtan2:
- case core::Function::kCeil:
- case core::Function::kCos:
- case core::Function::kCosh:
- case core::Function::kCross:
- case core::Function::kDeterminant:
- case core::Function::kDistance:
- case core::Function::kDot:
- case core::Function::kExp:
- case core::Function::kExp2:
- case core::Function::kFloor:
- case core::Function::kFma:
- case core::Function::kFract:
- case core::Function::kFrexp:
- case core::Function::kLength:
- case core::Function::kLdexp:
- case core::Function::kLog:
- case core::Function::kLog2:
- case core::Function::kMix:
- case core::Function::kModf:
- case core::Function::kNormalize:
- case core::Function::kPow:
- case core::Function::kReflect:
- case core::Function::kRefract:
- case core::Function::kSaturate:
- case core::Function::kSelect:
- case core::Function::kSin:
- case core::Function::kSinh:
- case core::Function::kSqrt:
- case core::Function::kStep:
- case core::Function::kTan:
- case core::Function::kTanh:
- case core::Function::kTranspose:
- case core::Function::kTrunc:
- case core::Function::kSign:
- case core::Function::kClamp:
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kAcos:
+ case core::BuiltinFn::kAcosh:
+ case core::BuiltinFn::kAll:
+ case core::BuiltinFn::kAny:
+ case core::BuiltinFn::kAsin:
+ case core::BuiltinFn::kAsinh:
+ case core::BuiltinFn::kAtanh:
+ case core::BuiltinFn::kAtan:
+ case core::BuiltinFn::kAtan2:
+ case core::BuiltinFn::kCeil:
+ case core::BuiltinFn::kCos:
+ case core::BuiltinFn::kCosh:
+ case core::BuiltinFn::kCross:
+ case core::BuiltinFn::kDeterminant:
+ case core::BuiltinFn::kDistance:
+ case core::BuiltinFn::kDot:
+ case core::BuiltinFn::kExp:
+ case core::BuiltinFn::kExp2:
+ case core::BuiltinFn::kFloor:
+ case core::BuiltinFn::kFma:
+ case core::BuiltinFn::kFract:
+ case core::BuiltinFn::kFrexp:
+ case core::BuiltinFn::kLength:
+ case core::BuiltinFn::kLdexp:
+ case core::BuiltinFn::kLog:
+ case core::BuiltinFn::kLog2:
+ case core::BuiltinFn::kMix:
+ case core::BuiltinFn::kModf:
+ case core::BuiltinFn::kNormalize:
+ case core::BuiltinFn::kPow:
+ case core::BuiltinFn::kReflect:
+ case core::BuiltinFn::kRefract:
+ case core::BuiltinFn::kSaturate:
+ case core::BuiltinFn::kSelect:
+ case core::BuiltinFn::kSin:
+ case core::BuiltinFn::kSinh:
+ case core::BuiltinFn::kSqrt:
+ case core::BuiltinFn::kStep:
+ case core::BuiltinFn::kTan:
+ case core::BuiltinFn::kTanh:
+ case core::BuiltinFn::kTranspose:
+ case core::BuiltinFn::kTrunc:
+ case core::BuiltinFn::kSign:
+ case core::BuiltinFn::kClamp:
out += builtin->str();
break;
- case core::Function::kAbs:
+ case core::BuiltinFn::kAbs:
if (builtin->ReturnType()->is_float_scalar_or_vector()) {
out += "fabs";
} else {
out += "abs";
}
break;
- case core::Function::kCountLeadingZeros:
+ case core::BuiltinFn::kCountLeadingZeros:
out += "clz";
break;
- case core::Function::kCountOneBits:
+ case core::BuiltinFn::kCountOneBits:
out += "popcount";
break;
- case core::Function::kCountTrailingZeros:
+ case core::BuiltinFn::kCountTrailingZeros:
out += "ctz";
break;
- case core::Function::kDpdx:
- case core::Function::kDpdxCoarse:
- case core::Function::kDpdxFine:
+ case core::BuiltinFn::kDpdx:
+ case core::BuiltinFn::kDpdxCoarse:
+ case core::BuiltinFn::kDpdxFine:
out += "dfdx";
break;
- case core::Function::kDpdy:
- case core::Function::kDpdyCoarse:
- case core::Function::kDpdyFine:
+ case core::BuiltinFn::kDpdy:
+ case core::BuiltinFn::kDpdyCoarse:
+ case core::BuiltinFn::kDpdyFine:
out += "dfdy";
break;
- case core::Function::kExtractBits:
+ case core::BuiltinFn::kExtractBits:
out += "extract_bits";
break;
- case core::Function::kInsertBits:
+ case core::BuiltinFn::kInsertBits:
out += "insert_bits";
break;
- case core::Function::kFwidth:
- case core::Function::kFwidthCoarse:
- case core::Function::kFwidthFine:
+ case core::BuiltinFn::kFwidth:
+ case core::BuiltinFn::kFwidthCoarse:
+ case core::BuiltinFn::kFwidthFine:
out += "fwidth";
break;
- case core::Function::kMax:
+ case core::BuiltinFn::kMax:
if (builtin->ReturnType()->is_float_scalar_or_vector()) {
out += "fmax";
} else {
out += "max";
}
break;
- case core::Function::kMin:
+ case core::BuiltinFn::kMin:
if (builtin->ReturnType()->is_float_scalar_or_vector()) {
out += "fmin";
} else {
out += "min";
}
break;
- case core::Function::kFaceForward:
+ case core::BuiltinFn::kFaceForward:
out += "faceforward";
break;
- case core::Function::kPack4X8Snorm:
+ case core::BuiltinFn::kPack4X8Snorm:
out += "pack_float_to_snorm4x8";
break;
- case core::Function::kPack4X8Unorm:
+ case core::BuiltinFn::kPack4X8Unorm:
out += "pack_float_to_unorm4x8";
break;
- case core::Function::kPack2X16Snorm:
+ case core::BuiltinFn::kPack2X16Snorm:
out += "pack_float_to_snorm2x16";
break;
- case core::Function::kPack2X16Unorm:
+ case core::BuiltinFn::kPack2X16Unorm:
out += "pack_float_to_unorm2x16";
break;
- case core::Function::kReverseBits:
+ case core::BuiltinFn::kReverseBits:
out += "reverse_bits";
break;
- case core::Function::kRound:
+ case core::BuiltinFn::kRound:
out += "rint";
break;
- case core::Function::kSmoothstep:
+ case core::BuiltinFn::kSmoothstep:
out += "smoothstep";
break;
- case core::Function::kInverseSqrt:
+ case core::BuiltinFn::kInverseSqrt:
out += "rsqrt";
break;
- case core::Function::kUnpack4X8Snorm:
+ case core::BuiltinFn::kUnpack4X8Snorm:
out += "unpack_snorm4x8_to_float";
break;
- case core::Function::kUnpack4X8Unorm:
+ case core::BuiltinFn::kUnpack4X8Unorm:
out += "unpack_unorm4x8_to_float";
break;
- case core::Function::kUnpack2X16Snorm:
+ case core::BuiltinFn::kUnpack2X16Snorm:
out += "unpack_snorm2x16_to_float";
break;
- case core::Function::kUnpack2X16Unorm:
+ case core::BuiltinFn::kUnpack2X16Unorm:
out += "unpack_unorm2x16_to_float";
break;
- case core::Function::kArrayLength:
+ case core::BuiltinFn::kArrayLength:
diagnostics_.add_error(
diag::System::Writer,
"Unable to translate builtin: " + std::string(builtin->str()) +
@@ -3063,14 +3063,14 @@
template <typename F>
bool ASTPrinter::CallBuiltinHelper(StringStream& out,
const ast::CallExpression* call,
- const sem::Builtin* builtin,
+ const sem::BuiltinFn* builtin,
F&& build) {
// Generate the helper function if it hasn't been created already
auto fn = tint::GetOrCreate(builtins_, builtin, [&]() -> std::string {
TextBuffer b;
TINT_DEFER(helpers_.Append(b));
- auto fn_name = UniqueIdentifier(std::string("tint_") + core::str(builtin->Type()));
+ auto fn_name = UniqueIdentifier(std::string("tint_") + core::str(builtin->Fn()));
std::vector<std::string> parameter_names;
{
auto decl = Line(&b);
diff --git a/src/tint/lang/msl/writer/ast_printer/ast_printer.h b/src/tint/lang/msl/writer/ast_printer/ast_printer.h
index 47f1ef7..b4796b0 100644
--- a/src/tint/lang/msl/writer/ast_printer/ast_printer.h
+++ b/src/tint/lang/msl/writer/ast_printer/ast_printer.h
@@ -47,7 +47,7 @@
#include "src/tint/utils/text/string_stream.h"
namespace tint::sem {
-class Builtin;
+class BuiltinFn;
class Call;
class ValueConstructor;
class ValueConversion;
@@ -144,7 +144,7 @@
/// @param call the call expression
/// @param builtin the builtin being called
/// @returns true if the call expression is emitted
- bool EmitBuiltinCall(StringStream& out, const sem::Call* call, const sem::Builtin* builtin);
+ bool EmitBuiltinCall(StringStream& out, const sem::Call* call, const sem::BuiltinFn* builtin);
/// Handles generating a value conversion expression
/// @param out the output of the expression stream
/// @param call the call expression
@@ -175,14 +175,14 @@
/// @returns true if the call expression is emitted
bool EmitAtomicCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to a texture function (`textureSample`,
/// `textureSampleGrad`, etc)
/// @param out the output of the expression stream
/// @param call the call expression
/// @param builtin the semantic information for the texture builtin
/// @returns true if the call expression is emitted
- bool EmitTextureCall(StringStream& out, const sem::Call* call, const sem::Builtin* builtin);
+ bool EmitTextureCall(StringStream& out, const sem::Call* call, const sem::BuiltinFn* builtin);
/// Handles generating a call to the `dot()` builtin
/// @param out the output of the expression stream
/// @param expr the call expression
@@ -190,7 +190,7 @@
/// @returns true if the call expression is emitted
bool EmitDotCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `modf()` builtin
/// @param out the output of the expression stream
/// @param expr the call expression
@@ -198,7 +198,7 @@
/// @returns true if the call expression is emitted
bool EmitModfCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `frexp()` builtin
/// @param out the output of the expression stream
/// @param expr the call expression
@@ -206,7 +206,7 @@
/// @returns true if the call expression is emitted
bool EmitFrexpCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `degrees()` builtin
/// @param out the output of the expression stream
/// @param expr the call expression
@@ -214,7 +214,7 @@
/// @returns true if the call expression is emitted
bool EmitDegreesCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `radians()` builtin
/// @param out the output of the expression stream
/// @param expr the call expression
@@ -222,7 +222,7 @@
/// @returns true if the call expression is emitted
bool EmitRadiansCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles a case statement
/// @param stmt the statement
/// @returns true if the statement was emitted successfully
@@ -355,7 +355,7 @@
/// @returns true if the call expression is emitted
bool EmitDot4I8PackedCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a call to the `dot4U8Packed()` builtin
/// @param out the output of the expression stream
/// @param expr the call expression
@@ -363,12 +363,12 @@
/// @returns true if the call expression is emitted
bool EmitDot4U8PackedCall(StringStream& out,
const ast::CallExpression* expr,
- const sem::Builtin* builtin);
+ const sem::BuiltinFn* builtin);
/// Handles generating a builtin name
/// @param builtin the semantic info for the builtin
/// @returns the name or "" if not valid
- std::string generate_builtin_name(const sem::Builtin* builtin);
+ std::string generate_builtin_name(const sem::BuiltinFn* builtin);
private:
/// CallBuiltinHelper will call the builtin helper function, creating it
@@ -387,7 +387,7 @@
template <typename F>
bool CallBuiltinHelper(StringStream& out,
const ast::CallExpression* call,
- const sem::Builtin* builtin,
+ const sem::BuiltinFn* builtin,
F&& build);
/// @returns the name of the templated tint_array helper type, generating it if this is the
@@ -442,7 +442,7 @@
/// should be created for that index.
std::unordered_map<std::string, std::vector<uint32_t>> workgroup_allocations_;
- std::unordered_map<const sem::Builtin*, std::string> builtins_;
+ std::unordered_map<const sem::BuiltinFn*, std::string> builtins_;
std::unordered_map<const core::type::Type*, std::string> unary_minus_funcs_;
std::unordered_map<uint32_t, std::string> int_dot_funcs_;
std::unordered_set<const core::type::Struct*> emitted_structs_;
diff --git a/src/tint/lang/msl/writer/ast_printer/builtin_test.cc b/src/tint/lang/msl/writer/ast_printer/builtin_test.cc
index f596fd5..a137075 100644
--- a/src/tint/lang/msl/writer/ast_printer/builtin_test.cc
+++ b/src/tint/lang/msl/writer/ast_printer/builtin_test.cc
@@ -33,7 +33,7 @@
};
struct BuiltinData {
- core::Function builtin;
+ core::BuiltinFn builtin;
CallParamType type;
const char* msl_name;
};
@@ -57,88 +57,88 @@
return out;
}
-const ast::CallExpression* GenerateCall(core::Function builtin,
+const ast::CallExpression* GenerateCall(core::BuiltinFn builtin,
CallParamType type,
ProgramBuilder* builder) {
std::string name;
StringStream str;
str << name << builtin;
switch (builtin) {
- case core::Function::kAcos:
- case core::Function::kAsin:
- case core::Function::kAtan:
- case core::Function::kCeil:
- case core::Function::kCos:
- case core::Function::kCosh:
- case core::Function::kDpdx:
- case core::Function::kDpdxCoarse:
- case core::Function::kDpdxFine:
- case core::Function::kDpdy:
- case core::Function::kDpdyCoarse:
- case core::Function::kDpdyFine:
- case core::Function::kExp:
- case core::Function::kExp2:
- case core::Function::kFloor:
- case core::Function::kFract:
- case core::Function::kFwidth:
- case core::Function::kFwidthCoarse:
- case core::Function::kFwidthFine:
- case core::Function::kInverseSqrt:
- case core::Function::kLength:
- case core::Function::kLog:
- case core::Function::kLog2:
- case core::Function::kNormalize:
- case core::Function::kRound:
- case core::Function::kSin:
- case core::Function::kSinh:
- case core::Function::kSqrt:
- case core::Function::kTan:
- case core::Function::kTanh:
- case core::Function::kTrunc:
- case core::Function::kSign:
+ case core::BuiltinFn::kAcos:
+ case core::BuiltinFn::kAsin:
+ case core::BuiltinFn::kAtan:
+ case core::BuiltinFn::kCeil:
+ case core::BuiltinFn::kCos:
+ case core::BuiltinFn::kCosh:
+ case core::BuiltinFn::kDpdx:
+ case core::BuiltinFn::kDpdxCoarse:
+ case core::BuiltinFn::kDpdxFine:
+ case core::BuiltinFn::kDpdy:
+ case core::BuiltinFn::kDpdyCoarse:
+ case core::BuiltinFn::kDpdyFine:
+ case core::BuiltinFn::kExp:
+ case core::BuiltinFn::kExp2:
+ case core::BuiltinFn::kFloor:
+ case core::BuiltinFn::kFract:
+ case core::BuiltinFn::kFwidth:
+ case core::BuiltinFn::kFwidthCoarse:
+ case core::BuiltinFn::kFwidthFine:
+ case core::BuiltinFn::kInverseSqrt:
+ case core::BuiltinFn::kLength:
+ case core::BuiltinFn::kLog:
+ case core::BuiltinFn::kLog2:
+ case core::BuiltinFn::kNormalize:
+ case core::BuiltinFn::kRound:
+ case core::BuiltinFn::kSin:
+ case core::BuiltinFn::kSinh:
+ case core::BuiltinFn::kSqrt:
+ case core::BuiltinFn::kTan:
+ case core::BuiltinFn::kTanh:
+ case core::BuiltinFn::kTrunc:
+ case core::BuiltinFn::kSign:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2");
} else {
return builder->Call(str.str(), "f2");
}
- case core::Function::kLdexp:
+ case core::BuiltinFn::kLdexp:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "i2");
} else {
return builder->Call(str.str(), "f2", "i2");
}
- case core::Function::kAtan2:
- case core::Function::kDot:
- case core::Function::kDistance:
- case core::Function::kPow:
- case core::Function::kReflect:
- case core::Function::kStep:
+ case core::BuiltinFn::kAtan2:
+ case core::BuiltinFn::kDot:
+ case core::BuiltinFn::kDistance:
+ case core::BuiltinFn::kPow:
+ case core::BuiltinFn::kReflect:
+ case core::BuiltinFn::kStep:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2");
} else {
return builder->Call(str.str(), "f2", "f2");
}
- case core::Function::kStorageBarrier:
+ case core::BuiltinFn::kStorageBarrier:
return builder->Call(str.str());
- case core::Function::kCross:
+ case core::BuiltinFn::kCross:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h3", "h3");
} else {
return builder->Call(str.str(), "f3", "f3");
}
- case core::Function::kFma:
- case core::Function::kMix:
- case core::Function::kFaceForward:
- case core::Function::kSmoothstep:
+ case core::BuiltinFn::kFma:
+ case core::BuiltinFn::kMix:
+ case core::BuiltinFn::kFaceForward:
+ case core::BuiltinFn::kSmoothstep:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2", "h2");
} else {
return builder->Call(str.str(), "f2", "f2", "f2");
}
- case core::Function::kAll:
- case core::Function::kAny:
+ case core::BuiltinFn::kAll:
+ case core::BuiltinFn::kAny:
return builder->Call(str.str(), "b2");
- case core::Function::kAbs:
+ case core::BuiltinFn::kAbs:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2");
} else if (type == CallParamType::kF16) {
@@ -146,17 +146,17 @@
} else {
return builder->Call(str.str(), "u2");
}
- case core::Function::kCountLeadingZeros:
- case core::Function::kCountOneBits:
- case core::Function::kCountTrailingZeros:
- case core::Function::kReverseBits:
+ case core::BuiltinFn::kCountLeadingZeros:
+ case core::BuiltinFn::kCountOneBits:
+ case core::BuiltinFn::kCountTrailingZeros:
+ case core::BuiltinFn::kReverseBits:
return builder->Call(str.str(), "u2");
- case core::Function::kExtractBits:
+ case core::BuiltinFn::kExtractBits:
return builder->Call(str.str(), "u2", "u1", "u1");
- case core::Function::kInsertBits:
+ case core::BuiltinFn::kInsertBits:
return builder->Call(str.str(), "u2", "u2", "u1", "u1");
- case core::Function::kMax:
- case core::Function::kMin:
+ case core::BuiltinFn::kMax:
+ case core::BuiltinFn::kMin:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2", "f2");
} else if (type == CallParamType::kF16) {
@@ -164,7 +164,7 @@
} else {
return builder->Call(str.str(), "u2", "u2");
}
- case core::Function::kClamp:
+ case core::BuiltinFn::kClamp:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2", "f2", "f2");
} else if (type == CallParamType::kF16) {
@@ -172,32 +172,32 @@
} else {
return builder->Call(str.str(), "u2", "u2", "u2");
}
- case core::Function::kSelect:
+ case core::BuiltinFn::kSelect:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2", "b2");
} else {
return builder->Call(str.str(), "f2", "f2", "b2");
}
- case core::Function::kDeterminant:
+ case core::BuiltinFn::kDeterminant:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "hm2x2");
} else {
return builder->Call(str.str(), "m2x2");
}
- case core::Function::kPack2X16Snorm:
- case core::Function::kPack2X16Unorm:
+ case core::BuiltinFn::kPack2X16Snorm:
+ case core::BuiltinFn::kPack2X16Unorm:
return builder->Call(str.str(), "f2");
- case core::Function::kPack4X8Snorm:
- case core::Function::kPack4X8Unorm:
+ case core::BuiltinFn::kPack4X8Snorm:
+ case core::BuiltinFn::kPack4X8Unorm:
return builder->Call(str.str(), "f4");
- case core::Function::kUnpack4X8Snorm:
- case core::Function::kUnpack4X8Unorm:
- case core::Function::kUnpack2X16Snorm:
- case core::Function::kUnpack2X16Unorm:
+ case core::BuiltinFn::kUnpack4X8Snorm:
+ case core::BuiltinFn::kUnpack4X8Unorm:
+ case core::BuiltinFn::kUnpack2X16Snorm:
+ case core::BuiltinFn::kUnpack2X16Unorm:
return builder->Call(str.str(), "u1");
- case core::Function::kWorkgroupBarrier:
+ case core::BuiltinFn::kWorkgroupBarrier:
return builder->Call(str.str());
- case core::Function::kTranspose:
+ case core::BuiltinFn::kTranspose:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "hm3x2");
} else {
@@ -243,7 +243,7 @@
ASSERT_NE(sem, nullptr);
auto* target = sem->Target();
ASSERT_NE(target, nullptr);
- auto* builtin = target->As<sem::Builtin>();
+ auto* builtin = target->As<sem::BuiltinFn>();
ASSERT_NE(builtin, nullptr);
EXPECT_EQ(gen.generate_builtin_name(builtin), param.msl_name);
@@ -253,122 +253,124 @@
MslBuiltinTest,
testing::Values(
/* Logical built-in */
- BuiltinData{core::Function::kAll, CallParamType::kBool, "all"},
- BuiltinData{core::Function::kAny, CallParamType::kBool, "any"},
- BuiltinData{core::Function::kSelect, CallParamType::kF32, "select"},
+ BuiltinData{core::BuiltinFn::kAll, CallParamType::kBool, "all"},
+ BuiltinData{core::BuiltinFn::kAny, CallParamType::kBool, "any"},
+ BuiltinData{core::BuiltinFn::kSelect, CallParamType::kF32, "select"},
/* Float built-in */
- BuiltinData{core::Function::kAbs, CallParamType::kF32, "fabs"},
- BuiltinData{core::Function::kAbs, CallParamType::kF16, "fabs"},
- BuiltinData{core::Function::kAcos, CallParamType::kF32, "acos"},
- BuiltinData{core::Function::kAcos, CallParamType::kF16, "acos"},
- BuiltinData{core::Function::kAsin, CallParamType::kF32, "asin"},
- BuiltinData{core::Function::kAsin, CallParamType::kF16, "asin"},
- BuiltinData{core::Function::kAtan, CallParamType::kF32, "atan"},
- BuiltinData{core::Function::kAtan, CallParamType::kF16, "atan"},
- BuiltinData{core::Function::kAtan2, CallParamType::kF32, "atan2"},
- BuiltinData{core::Function::kAtan2, CallParamType::kF16, "atan2"},
- BuiltinData{core::Function::kCeil, CallParamType::kF32, "ceil"},
- BuiltinData{core::Function::kCeil, CallParamType::kF16, "ceil"},
- BuiltinData{core::Function::kClamp, CallParamType::kF32, "clamp"},
- BuiltinData{core::Function::kClamp, CallParamType::kF16, "clamp"},
- BuiltinData{core::Function::kCos, CallParamType::kF32, "cos"},
- BuiltinData{core::Function::kCos, CallParamType::kF16, "cos"},
- BuiltinData{core::Function::kCosh, CallParamType::kF32, "cosh"},
- BuiltinData{core::Function::kCosh, CallParamType::kF16, "cosh"},
- BuiltinData{core::Function::kCross, CallParamType::kF32, "cross"},
- BuiltinData{core::Function::kCross, CallParamType::kF16, "cross"},
- BuiltinData{core::Function::kDistance, CallParamType::kF32, "distance"},
- BuiltinData{core::Function::kDistance, CallParamType::kF16, "distance"},
- BuiltinData{core::Function::kExp, CallParamType::kF32, "exp"},
- BuiltinData{core::Function::kExp, CallParamType::kF16, "exp"},
- BuiltinData{core::Function::kExp2, CallParamType::kF32, "exp2"},
- BuiltinData{core::Function::kExp2, CallParamType::kF16, "exp2"},
- BuiltinData{core::Function::kFaceForward, CallParamType::kF32, "faceforward"},
- BuiltinData{core::Function::kFaceForward, CallParamType::kF16, "faceforward"},
- BuiltinData{core::Function::kFloor, CallParamType::kF32, "floor"},
- BuiltinData{core::Function::kFloor, CallParamType::kF16, "floor"},
- BuiltinData{core::Function::kFma, CallParamType::kF32, "fma"},
- BuiltinData{core::Function::kFma, CallParamType::kF16, "fma"},
- BuiltinData{core::Function::kFract, CallParamType::kF32, "fract"},
- BuiltinData{core::Function::kFract, CallParamType::kF16, "fract"},
- BuiltinData{core::Function::kInverseSqrt, CallParamType::kF32, "rsqrt"},
- BuiltinData{core::Function::kInverseSqrt, CallParamType::kF16, "rsqrt"},
- BuiltinData{core::Function::kLdexp, CallParamType::kF32, "ldexp"},
- BuiltinData{core::Function::kLdexp, CallParamType::kF16, "ldexp"},
- BuiltinData{core::Function::kLength, CallParamType::kF32, "length"},
- BuiltinData{core::Function::kLength, CallParamType::kF16, "length"},
- BuiltinData{core::Function::kLog, CallParamType::kF32, "log"},
- BuiltinData{core::Function::kLog, CallParamType::kF16, "log"},
- BuiltinData{core::Function::kLog2, CallParamType::kF32, "log2"},
- BuiltinData{core::Function::kLog2, CallParamType::kF16, "log2"},
- BuiltinData{core::Function::kMax, CallParamType::kF32, "fmax"},
- BuiltinData{core::Function::kMax, CallParamType::kF16, "fmax"},
- BuiltinData{core::Function::kMin, CallParamType::kF32, "fmin"},
- BuiltinData{core::Function::kMin, CallParamType::kF16, "fmin"},
- BuiltinData{core::Function::kNormalize, CallParamType::kF32, "normalize"},
- BuiltinData{core::Function::kNormalize, CallParamType::kF16, "normalize"},
- BuiltinData{core::Function::kPow, CallParamType::kF32, "pow"},
- BuiltinData{core::Function::kPow, CallParamType::kF16, "pow"},
- BuiltinData{core::Function::kReflect, CallParamType::kF32, "reflect"},
- BuiltinData{core::Function::kReflect, CallParamType::kF16, "reflect"},
- BuiltinData{core::Function::kSign, CallParamType::kF32, "sign"},
- BuiltinData{core::Function::kSign, CallParamType::kF16, "sign"},
- BuiltinData{core::Function::kSin, CallParamType::kF32, "sin"},
- BuiltinData{core::Function::kSin, CallParamType::kF16, "sin"},
- BuiltinData{core::Function::kSinh, CallParamType::kF32, "sinh"},
- BuiltinData{core::Function::kSinh, CallParamType::kF16, "sinh"},
- BuiltinData{core::Function::kSmoothstep, CallParamType::kF32, "smoothstep"},
- BuiltinData{core::Function::kSmoothstep, CallParamType::kF16, "smoothstep"},
- BuiltinData{core::Function::kSqrt, CallParamType::kF32, "sqrt"},
- BuiltinData{core::Function::kSqrt, CallParamType::kF16, "sqrt"},
- BuiltinData{core::Function::kStep, CallParamType::kF32, "step"},
- BuiltinData{core::Function::kStep, CallParamType::kF16, "step"},
- BuiltinData{core::Function::kTan, CallParamType::kF32, "tan"},
- BuiltinData{core::Function::kTan, CallParamType::kF16, "tan"},
- BuiltinData{core::Function::kTanh, CallParamType::kF32, "tanh"},
- BuiltinData{core::Function::kTanh, CallParamType::kF16, "tanh"},
- BuiltinData{core::Function::kTrunc, CallParamType::kF32, "trunc"},
- BuiltinData{core::Function::kTrunc, CallParamType::kF16, "trunc"},
+ BuiltinData{core::BuiltinFn::kAbs, CallParamType::kF32, "fabs"},
+ BuiltinData{core::BuiltinFn::kAbs, CallParamType::kF16, "fabs"},
+ BuiltinData{core::BuiltinFn::kAcos, CallParamType::kF32, "acos"},
+ BuiltinData{core::BuiltinFn::kAcos, CallParamType::kF16, "acos"},
+ BuiltinData{core::BuiltinFn::kAsin, CallParamType::kF32, "asin"},
+ BuiltinData{core::BuiltinFn::kAsin, CallParamType::kF16, "asin"},
+ BuiltinData{core::BuiltinFn::kAtan, CallParamType::kF32, "atan"},
+ BuiltinData{core::BuiltinFn::kAtan, CallParamType::kF16, "atan"},
+ BuiltinData{core::BuiltinFn::kAtan2, CallParamType::kF32, "atan2"},
+ BuiltinData{core::BuiltinFn::kAtan2, CallParamType::kF16, "atan2"},
+ BuiltinData{core::BuiltinFn::kCeil, CallParamType::kF32, "ceil"},
+ BuiltinData{core::BuiltinFn::kCeil, CallParamType::kF16, "ceil"},
+ BuiltinData{core::BuiltinFn::kClamp, CallParamType::kF32, "clamp"},
+ BuiltinData{core::BuiltinFn::kClamp, CallParamType::kF16, "clamp"},
+ BuiltinData{core::BuiltinFn::kCos, CallParamType::kF32, "cos"},
+ BuiltinData{core::BuiltinFn::kCos, CallParamType::kF16, "cos"},
+ BuiltinData{core::BuiltinFn::kCosh, CallParamType::kF32, "cosh"},
+ BuiltinData{core::BuiltinFn::kCosh, CallParamType::kF16, "cosh"},
+ BuiltinData{core::BuiltinFn::kCross, CallParamType::kF32, "cross"},
+ BuiltinData{core::BuiltinFn::kCross, CallParamType::kF16, "cross"},
+ BuiltinData{core::BuiltinFn::kDistance, CallParamType::kF32, "distance"},
+ BuiltinData{core::BuiltinFn::kDistance, CallParamType::kF16, "distance"},
+ BuiltinData{core::BuiltinFn::kExp, CallParamType::kF32, "exp"},
+ BuiltinData{core::BuiltinFn::kExp, CallParamType::kF16, "exp"},
+ BuiltinData{core::BuiltinFn::kExp2, CallParamType::kF32, "exp2"},
+ BuiltinData{core::BuiltinFn::kExp2, CallParamType::kF16, "exp2"},
+ BuiltinData{core::BuiltinFn::kFaceForward, CallParamType::kF32, "faceforward"},
+ BuiltinData{core::BuiltinFn::kFaceForward, CallParamType::kF16, "faceforward"},
+ BuiltinData{core::BuiltinFn::kFloor, CallParamType::kF32, "floor"},
+ BuiltinData{core::BuiltinFn::kFloor, CallParamType::kF16, "floor"},
+ BuiltinData{core::BuiltinFn::kFma, CallParamType::kF32, "fma"},
+ BuiltinData{core::BuiltinFn::kFma, CallParamType::kF16, "fma"},
+ BuiltinData{core::BuiltinFn::kFract, CallParamType::kF32, "fract"},
+ BuiltinData{core::BuiltinFn::kFract, CallParamType::kF16, "fract"},
+ BuiltinData{core::BuiltinFn::kInverseSqrt, CallParamType::kF32, "rsqrt"},
+ BuiltinData{core::BuiltinFn::kInverseSqrt, CallParamType::kF16, "rsqrt"},
+ BuiltinData{core::BuiltinFn::kLdexp, CallParamType::kF32, "ldexp"},
+ BuiltinData{core::BuiltinFn::kLdexp, CallParamType::kF16, "ldexp"},
+ BuiltinData{core::BuiltinFn::kLength, CallParamType::kF32, "length"},
+ BuiltinData{core::BuiltinFn::kLength, CallParamType::kF16, "length"},
+ BuiltinData{core::BuiltinFn::kLog, CallParamType::kF32, "log"},
+ BuiltinData{core::BuiltinFn::kLog, CallParamType::kF16, "log"},
+ BuiltinData{core::BuiltinFn::kLog2, CallParamType::kF32, "log2"},
+ BuiltinData{core::BuiltinFn::kLog2, CallParamType::kF16, "log2"},
+ BuiltinData{core::BuiltinFn::kMax, CallParamType::kF32, "fmax"},
+ BuiltinData{core::BuiltinFn::kMax, CallParamType::kF16, "fmax"},
+ BuiltinData{core::BuiltinFn::kMin, CallParamType::kF32, "fmin"},
+ BuiltinData{core::BuiltinFn::kMin, CallParamType::kF16, "fmin"},
+ BuiltinData{core::BuiltinFn::kNormalize, CallParamType::kF32, "normalize"},
+ BuiltinData{core::BuiltinFn::kNormalize, CallParamType::kF16, "normalize"},
+ BuiltinData{core::BuiltinFn::kPow, CallParamType::kF32, "pow"},
+ BuiltinData{core::BuiltinFn::kPow, CallParamType::kF16, "pow"},
+ BuiltinData{core::BuiltinFn::kReflect, CallParamType::kF32, "reflect"},
+ BuiltinData{core::BuiltinFn::kReflect, CallParamType::kF16, "reflect"},
+ BuiltinData{core::BuiltinFn::kSign, CallParamType::kF32, "sign"},
+ BuiltinData{core::BuiltinFn::kSign, CallParamType::kF16, "sign"},
+ BuiltinData{core::BuiltinFn::kSin, CallParamType::kF32, "sin"},
+ BuiltinData{core::BuiltinFn::kSin, CallParamType::kF16, "sin"},
+ BuiltinData{core::BuiltinFn::kSinh, CallParamType::kF32, "sinh"},
+ BuiltinData{core::BuiltinFn::kSinh, CallParamType::kF16, "sinh"},
+ BuiltinData{core::BuiltinFn::kSmoothstep, CallParamType::kF32, "smoothstep"},
+ BuiltinData{core::BuiltinFn::kSmoothstep, CallParamType::kF16, "smoothstep"},
+ BuiltinData{core::BuiltinFn::kSqrt, CallParamType::kF32, "sqrt"},
+ BuiltinData{core::BuiltinFn::kSqrt, CallParamType::kF16, "sqrt"},
+ BuiltinData{core::BuiltinFn::kStep, CallParamType::kF32, "step"},
+ BuiltinData{core::BuiltinFn::kStep, CallParamType::kF16, "step"},
+ BuiltinData{core::BuiltinFn::kTan, CallParamType::kF32, "tan"},
+ BuiltinData{core::BuiltinFn::kTan, CallParamType::kF16, "tan"},
+ BuiltinData{core::BuiltinFn::kTanh, CallParamType::kF32, "tanh"},
+ BuiltinData{core::BuiltinFn::kTanh, CallParamType::kF16, "tanh"},
+ BuiltinData{core::BuiltinFn::kTrunc, CallParamType::kF32, "trunc"},
+ BuiltinData{core::BuiltinFn::kTrunc, CallParamType::kF16, "trunc"},
/* Integer built-in */
- BuiltinData{core::Function::kAbs, CallParamType::kU32, "abs"},
- BuiltinData{core::Function::kClamp, CallParamType::kU32, "clamp"},
- BuiltinData{core::Function::kCountLeadingZeros, CallParamType::kU32, "clz"},
- BuiltinData{core::Function::kCountOneBits, CallParamType::kU32, "popcount"},
- BuiltinData{core::Function::kCountTrailingZeros, CallParamType::kU32, "ctz"},
- BuiltinData{core::Function::kExtractBits, CallParamType::kU32, "extract_bits"},
- BuiltinData{core::Function::kInsertBits, CallParamType::kU32, "insert_bits"},
- BuiltinData{core::Function::kMax, CallParamType::kU32, "max"},
- BuiltinData{core::Function::kMin, CallParamType::kU32, "min"},
- BuiltinData{core::Function::kReverseBits, CallParamType::kU32, "reverse_bits"},
- BuiltinData{core::Function::kRound, CallParamType::kU32, "rint"},
+ BuiltinData{core::BuiltinFn::kAbs, CallParamType::kU32, "abs"},
+ BuiltinData{core::BuiltinFn::kClamp, CallParamType::kU32, "clamp"},
+ BuiltinData{core::BuiltinFn::kCountLeadingZeros, CallParamType::kU32, "clz"},
+ BuiltinData{core::BuiltinFn::kCountOneBits, CallParamType::kU32, "popcount"},
+ BuiltinData{core::BuiltinFn::kCountTrailingZeros, CallParamType::kU32, "ctz"},
+ BuiltinData{core::BuiltinFn::kExtractBits, CallParamType::kU32, "extract_bits"},
+ BuiltinData{core::BuiltinFn::kInsertBits, CallParamType::kU32, "insert_bits"},
+ BuiltinData{core::BuiltinFn::kMax, CallParamType::kU32, "max"},
+ BuiltinData{core::BuiltinFn::kMin, CallParamType::kU32, "min"},
+ BuiltinData{core::BuiltinFn::kReverseBits, CallParamType::kU32, "reverse_bits"},
+ BuiltinData{core::BuiltinFn::kRound, CallParamType::kU32, "rint"},
/* Matrix built-in */
- BuiltinData{core::Function::kDeterminant, CallParamType::kF32, "determinant"},
- BuiltinData{core::Function::kTranspose, CallParamType::kF32, "transpose"},
+ BuiltinData{core::BuiltinFn::kDeterminant, CallParamType::kF32, "determinant"},
+ BuiltinData{core::BuiltinFn::kTranspose, CallParamType::kF32, "transpose"},
/* Vector built-in */
- BuiltinData{core::Function::kDot, CallParamType::kF32, "dot"},
+ BuiltinData{core::BuiltinFn::kDot, CallParamType::kF32, "dot"},
/* Derivate built-in */
- BuiltinData{core::Function::kDpdx, CallParamType::kF32, "dfdx"},
- BuiltinData{core::Function::kDpdxCoarse, CallParamType::kF32, "dfdx"},
- BuiltinData{core::Function::kDpdxFine, CallParamType::kF32, "dfdx"},
- BuiltinData{core::Function::kDpdy, CallParamType::kF32, "dfdy"},
- BuiltinData{core::Function::kDpdyCoarse, CallParamType::kF32, "dfdy"},
- BuiltinData{core::Function::kDpdyFine, CallParamType::kF32, "dfdy"},
- BuiltinData{core::Function::kFwidth, CallParamType::kF32, "fwidth"},
- BuiltinData{core::Function::kFwidthCoarse, CallParamType::kF32, "fwidth"},
- BuiltinData{core::Function::kFwidthFine, CallParamType::kF32, "fwidth"},
+ BuiltinData{core::BuiltinFn::kDpdx, CallParamType::kF32, "dfdx"},
+ BuiltinData{core::BuiltinFn::kDpdxCoarse, CallParamType::kF32, "dfdx"},
+ BuiltinData{core::BuiltinFn::kDpdxFine, CallParamType::kF32, "dfdx"},
+ BuiltinData{core::BuiltinFn::kDpdy, CallParamType::kF32, "dfdy"},
+ BuiltinData{core::BuiltinFn::kDpdyCoarse, CallParamType::kF32, "dfdy"},
+ BuiltinData{core::BuiltinFn::kDpdyFine, CallParamType::kF32, "dfdy"},
+ BuiltinData{core::BuiltinFn::kFwidth, CallParamType::kF32, "fwidth"},
+ BuiltinData{core::BuiltinFn::kFwidthCoarse, CallParamType::kF32, "fwidth"},
+ BuiltinData{core::BuiltinFn::kFwidthFine, CallParamType::kF32, "fwidth"},
/* Data packing builtin */
- BuiltinData{core::Function::kPack4X8Snorm, CallParamType::kF32, "pack_float_to_snorm4x8"},
- BuiltinData{core::Function::kPack4X8Unorm, CallParamType::kF32, "pack_float_to_unorm4x8"},
- BuiltinData{core::Function::kPack2X16Snorm, CallParamType::kF32, "pack_float_to_snorm2x16"},
- BuiltinData{core::Function::kPack2X16Unorm, CallParamType::kF32, "pack_float_to_unorm2x16"},
+ BuiltinData{core::BuiltinFn::kPack4X8Snorm, CallParamType::kF32, "pack_float_to_snorm4x8"},
+ BuiltinData{core::BuiltinFn::kPack4X8Unorm, CallParamType::kF32, "pack_float_to_unorm4x8"},
+ BuiltinData{core::BuiltinFn::kPack2X16Snorm, CallParamType::kF32,
+ "pack_float_to_snorm2x16"},
+ BuiltinData{core::BuiltinFn::kPack2X16Unorm, CallParamType::kF32,
+ "pack_float_to_unorm2x16"},
/* Data unpacking builtin */
- BuiltinData{core::Function::kUnpack4X8Snorm, CallParamType::kU32,
+ BuiltinData{core::BuiltinFn::kUnpack4X8Snorm, CallParamType::kU32,
"unpack_snorm4x8_to_float"},
- BuiltinData{core::Function::kUnpack4X8Unorm, CallParamType::kU32,
+ BuiltinData{core::BuiltinFn::kUnpack4X8Unorm, CallParamType::kU32,
"unpack_unorm4x8_to_float"},
- BuiltinData{core::Function::kUnpack2X16Snorm, CallParamType::kU32,
+ BuiltinData{core::BuiltinFn::kUnpack2X16Snorm, CallParamType::kU32,
"unpack_snorm2x16_to_float"},
- BuiltinData{core::Function::kUnpack2X16Unorm, CallParamType::kU32,
+ BuiltinData{core::BuiltinFn::kUnpack2X16Unorm, CallParamType::kU32,
"unpack_unorm2x16_to_float"}));
TEST_F(MslASTPrinterTest, Builtin_Call) {
diff --git a/src/tint/lang/msl/writer/ast_printer/import_test.cc b/src/tint/lang/msl/writer/ast_printer/import_test.cc
index f77ddec..a3f501d 100644
--- a/src/tint/lang/msl/writer/ast_printer/import_test.cc
+++ b/src/tint/lang/msl/writer/ast_printer/import_test.cc
@@ -46,7 +46,7 @@
ASSERT_NE(sem, nullptr);
auto* target = sem->Target();
ASSERT_NE(target, nullptr);
- auto* builtin = target->As<sem::Builtin>();
+ auto* builtin = target->As<sem::BuiltinFn>();
ASSERT_NE(builtin, nullptr);
ASSERT_EQ(gen.generate_builtin_name(builtin), param.msl_name);
diff --git a/src/tint/lang/msl/writer/ast_raise/subgroup_ballot.cc b/src/tint/lang/msl/writer/ast_raise/subgroup_ballot.cc
index e15bf24..3ed8cba 100644
--- a/src/tint/lang/msl/writer/ast_raise/subgroup_ballot.cc
+++ b/src/tint/lang/msl/writer/ast_raise/subgroup_ballot.cc
@@ -65,8 +65,8 @@
if (call) {
// If this is a call to a `subgroupBallot()` builtin, replace it with a call to the
// helper function and make a note of the function that we are in.
- auto* builtin = call->Target()->As<sem::Builtin>();
- if (builtin && builtin->Type() == core::Function::kSubgroupBallot) {
+ auto* builtin = call->Target()->As<sem::BuiltinFn>();
+ if (builtin && builtin->Fn() == core::BuiltinFn::kSubgroupBallot) {
ctx.Replace(call->Declaration(), b.Call(GetHelper()));
ballot_callers.Add(call->Stmt()->Function());
made_changes = true;
diff --git a/src/tint/lang/spirv/reader/ast_lower/atomics.cc b/src/tint/lang/spirv/reader/ast_lower/atomics.cc
index bd2aee4..c62df89 100644
--- a/src/tint/lang/spirv/reader/ast_lower/atomics.cc
+++ b/src/tint/lang/spirv/reader/ast_lower/atomics.cc
@@ -87,7 +87,7 @@
out_args[0] = b.AddressOf(out_args[0]);
// Replace all callsites of this stub to a call to the real builtin
- if (stub->builtin == core::Function::kAtomicCompareExchangeWeak) {
+ if (stub->builtin == core::BuiltinFn::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.
@@ -255,7 +255,7 @@
if (is_ref_to_atomic_var(load->Reference())) {
ctx.Replace(load->Reference()->Declaration(), [=] {
auto* expr = ctx.CloneWithoutTransform(load->Reference()->Declaration());
- return b.Call(core::str(core::Function::kAtomicLoad), b.AddressOf(expr));
+ return b.Call(core::str(core::BuiltinFn::kAtomicLoad), b.AddressOf(expr));
});
}
} else if (auto* assign = node->As<ast::AssignmentStatement>()) {
@@ -265,7 +265,7 @@
auto* lhs = ctx.CloneWithoutTransform(assign->lhs);
auto* rhs = ctx.CloneWithoutTransform(assign->rhs);
auto* call =
- b.Call(core::str(core::Function::kAtomicStore), b.AddressOf(lhs), rhs);
+ b.Call(core::str(core::BuiltinFn::kAtomicStore), b.AddressOf(lhs), rhs);
return b.CallStmt(call);
});
}
@@ -277,7 +277,7 @@
Atomics::Atomics() = default;
Atomics::~Atomics() = default;
-Atomics::Stub::Stub(GenerationID pid, ast::NodeID nid, core::Function b)
+Atomics::Stub::Stub(GenerationID pid, ast::NodeID nid, core::BuiltinFn b)
: Base(pid, nid, tint::Empty), builtin(b) {}
Atomics::Stub::~Stub() = default;
std::string Atomics::Stub::InternalName() const {
diff --git a/src/tint/lang/spirv/reader/ast_lower/atomics.h b/src/tint/lang/spirv/reader/ast_lower/atomics.h
index e349095..d1902f6 100644
--- a/src/tint/lang/spirv/reader/ast_lower/atomics.h
+++ b/src/tint/lang/spirv/reader/ast_lower/atomics.h
@@ -17,7 +17,7 @@
#include <string>
-#include "src/tint/lang/core/function.h"
+#include "src/tint/lang/core/builtin_fn.h"
#include "src/tint/lang/wgsl/ast/internal_attribute.h"
#include "src/tint/lang/wgsl/ast/transform/transform.h"
@@ -41,7 +41,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(GenerationID pid, ast::NodeID nid, core::Function builtin);
+ Stub(GenerationID pid, ast::NodeID nid, core::BuiltinFn builtin);
/// Destructor
~Stub() override;
@@ -55,7 +55,7 @@
const Stub* Clone(ast::CloneContext& ctx) const override;
/// The type of the intrinsic
- const core::Function builtin;
+ const core::BuiltinFn builtin;
};
/// @copydoc ast::transform::Transform::Apply
diff --git a/src/tint/lang/spirv/reader/ast_lower/atomics_test.cc b/src/tint/lang/spirv/reader/ast_lower/atomics_test.cc
index 8898c52..6f67a21 100644
--- a/src/tint/lang/spirv/reader/ast_lower/atomics_test.cc
+++ b/src/tint/lang/spirv/reader/ast_lower/atomics_test.cc
@@ -37,10 +37,11 @@
auto& b = parser.builder();
- core::Function two_params[] = {
- core::Function::kAtomicExchange, core::Function::kAtomicAdd, core::Function::kAtomicSub,
- core::Function::kAtomicMin, core::Function::kAtomicMax, core::Function::kAtomicAnd,
- core::Function::kAtomicOr, core::Function::kAtomicXor,
+ core::BuiltinFn two_params[] = {
+ core::BuiltinFn::kAtomicExchange, core::BuiltinFn::kAtomicAdd,
+ core::BuiltinFn::kAtomicSub, core::BuiltinFn::kAtomicMin,
+ core::BuiltinFn::kAtomicMax, core::BuiltinFn::kAtomicAnd,
+ core::BuiltinFn::kAtomicOr, core::BuiltinFn::kAtomicXor,
};
for (auto& a : two_params) {
b.Func(std::string{"stub_"} + core::str(a) + "_u32",
@@ -79,7 +80,7 @@
},
tint::Vector{
b.ASTNodes().Create<Atomics::Stub>(b.ID(), b.AllocateNodeID(),
- core::Function::kAtomicLoad),
+ core::BuiltinFn::kAtomicLoad),
});
b.Func("stub_atomicLoad_i32",
tint::Vector{
@@ -91,7 +92,7 @@
},
tint::Vector{
b.ASTNodes().Create<Atomics::Stub>(b.ID(), b.AllocateNodeID(),
- core::Function::kAtomicLoad),
+ core::BuiltinFn::kAtomicLoad),
});
b.Func("stub_atomicStore_u32",
@@ -102,7 +103,7 @@
b.ty.void_(), tint::Empty,
tint::Vector{
b.ASTNodes().Create<Atomics::Stub>(b.ID(), b.AllocateNodeID(),
- core::Function::kAtomicStore),
+ core::BuiltinFn::kAtomicStore),
});
b.Func("stub_atomicStore_i32",
tint::Vector{
@@ -112,7 +113,7 @@
b.ty.void_(), tint::Empty,
tint::Vector{
b.ASTNodes().Create<Atomics::Stub>(b.ID(), b.AllocateNodeID(),
- core::Function::kAtomicStore),
+ core::BuiltinFn::kAtomicStore),
});
b.Func("stub_atomic_compare_exchange_weak_u32",
@@ -127,7 +128,7 @@
},
tint::Vector{
b.ASTNodes().Create<Atomics::Stub>(b.ID(), b.AllocateNodeID(),
- core::Function::kAtomicCompareExchangeWeak),
+ core::BuiltinFn::kAtomicCompareExchangeWeak),
});
b.Func("stub_atomic_compare_exchange_weak_i32",
tint::Vector{b.Param("p0", b.ty.i32()), b.Param("p1", b.ty.i32()),
@@ -138,7 +139,7 @@
},
tint::Vector{
b.ASTNodes().Create<Atomics::Stub>(b.ID(), b.AllocateNodeID(),
- core::Function::kAtomicCompareExchangeWeak),
+ core::BuiltinFn::kAtomicCompareExchangeWeak),
});
// Keep this pointer alive after Transform() returns
diff --git a/src/tint/lang/spirv/reader/ast_parser/barrier_test.cc b/src/tint/lang/spirv/reader/ast_parser/barrier_test.cc
index 66247db..ff4191c 100644
--- a/src/tint/lang/spirv/reader/ast_parser/barrier_test.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/barrier_test.cc
@@ -71,9 +71,9 @@
EXPECT_EQ(call->expr->args.Length(), 0u);
auto* sem_call = program.Sem().Get<sem::Call>(call->expr);
ASSERT_NE(sem_call, nullptr);
- auto* builtin = sem_call->Target()->As<sem::Builtin>();
+ auto* builtin = sem_call->Target()->As<sem::BuiltinFn>();
ASSERT_NE(builtin, nullptr);
- EXPECT_EQ(builtin->Type(), core::Function::kWorkgroupBarrier);
+ EXPECT_EQ(builtin->Fn(), core::BuiltinFn::kWorkgroupBarrier);
}
TEST_F(SpirvASTParserTest, StorageBarrier) {
@@ -104,9 +104,9 @@
EXPECT_EQ(call->expr->args.Length(), 0u);
auto* sem_call = program.Sem().Get<sem::Call>(call->expr);
ASSERT_NE(sem_call, nullptr);
- auto* builtin = sem_call->Target()->As<sem::Builtin>();
+ auto* builtin = sem_call->Target()->As<sem::BuiltinFn>();
ASSERT_NE(builtin, nullptr);
- EXPECT_EQ(builtin->Type(), core::Function::kStorageBarrier);
+ EXPECT_EQ(builtin->Fn(), core::BuiltinFn::kStorageBarrier);
}
TEST_F(SpirvASTParserTest, TextureBarrier) {
@@ -137,9 +137,9 @@
EXPECT_EQ(call->expr->args.Length(), 0u);
auto* sem_call = program.Sem().Get<sem::Call>(call->expr);
ASSERT_NE(sem_call, nullptr);
- auto* builtin = sem_call->Target()->As<sem::Builtin>();
+ auto* builtin = sem_call->Target()->As<sem::BuiltinFn>();
ASSERT_NE(builtin, nullptr);
- EXPECT_EQ(builtin->Type(), core::Function::kTextureBarrier);
+ EXPECT_EQ(builtin->Fn(), core::BuiltinFn::kTextureBarrier);
}
TEST_F(SpirvASTParserTest, WorkgroupAndTextureAndStorageBarrier) {
@@ -173,9 +173,9 @@
EXPECT_EQ(call->expr->args.Length(), 0u);
auto* sem_call = program.Sem().Get<sem::Call>(call->expr);
ASSERT_NE(sem_call, nullptr);
- auto* builtin = sem_call->Target()->As<sem::Builtin>();
+ auto* builtin = sem_call->Target()->As<sem::BuiltinFn>();
ASSERT_NE(builtin, nullptr);
- EXPECT_EQ(builtin->Type(), core::Function::kWorkgroupBarrier);
+ EXPECT_EQ(builtin->Fn(), core::BuiltinFn::kWorkgroupBarrier);
}
{
auto* call = helper->body->statements[1]->As<ast::CallStatement>();
@@ -183,9 +183,9 @@
EXPECT_EQ(call->expr->args.Length(), 0u);
auto* sem_call = program.Sem().Get<sem::Call>(call->expr);
ASSERT_NE(sem_call, nullptr);
- auto* builtin = sem_call->Target()->As<sem::Builtin>();
+ auto* builtin = sem_call->Target()->As<sem::BuiltinFn>();
ASSERT_NE(builtin, nullptr);
- EXPECT_EQ(builtin->Type(), core::Function::kStorageBarrier);
+ EXPECT_EQ(builtin->Fn(), core::BuiltinFn::kStorageBarrier);
}
{
auto* call = helper->body->statements[2]->As<ast::CallStatement>();
@@ -193,9 +193,9 @@
EXPECT_EQ(call->expr->args.Length(), 0u);
auto* sem_call = program.Sem().Get<sem::Call>(call->expr);
ASSERT_NE(sem_call, nullptr);
- auto* builtin = sem_call->Target()->As<sem::Builtin>();
+ auto* builtin = sem_call->Target()->As<sem::BuiltinFn>();
ASSERT_NE(builtin, nullptr);
- EXPECT_EQ(builtin->Type(), core::Function::kTextureBarrier);
+ EXPECT_EQ(builtin->Fn(), core::BuiltinFn::kTextureBarrier);
}
}
diff --git a/src/tint/lang/spirv/reader/ast_parser/function.cc b/src/tint/lang/spirv/reader/ast_parser/function.cc
index 754fff5..311f9b24 100644
--- a/src/tint/lang/spirv/reader/ast_parser/function.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/function.cc
@@ -17,9 +17,9 @@
#include <algorithm>
#include <array>
+#include "src/tint/lang/core/builtin_fn.h"
#include "src/tint/lang/core/builtin_value.h"
#include "src/tint/lang/core/fluent_types.h"
-#include "src/tint/lang/core/function.h"
#include "src/tint/lang/core/type/depth_texture.h"
#include "src/tint/lang/core/type/sampled_texture.h"
#include "src/tint/lang/core/type/texture_dimension.h"
@@ -456,42 +456,42 @@
}
// Returns the WGSL standard library function builtin for the
-// given instruction, or core::Function::kNone
-core::Function GetBuiltin(spv::Op opcode) {
+// given instruction, or core::BuiltinFn::kNone
+core::BuiltinFn GetBuiltin(spv::Op opcode) {
switch (opcode) {
case spv::Op::OpBitCount:
- return core::Function::kCountOneBits;
+ return core::BuiltinFn::kCountOneBits;
case spv::Op::OpBitFieldInsert:
- return core::Function::kInsertBits;
+ return core::BuiltinFn::kInsertBits;
case spv::Op::OpBitFieldSExtract:
case spv::Op::OpBitFieldUExtract:
- return core::Function::kExtractBits;
+ return core::BuiltinFn::kExtractBits;
case spv::Op::OpBitReverse:
- return core::Function::kReverseBits;
+ return core::BuiltinFn::kReverseBits;
case spv::Op::OpDot:
- return core::Function::kDot;
+ return core::BuiltinFn::kDot;
case spv::Op::OpDPdx:
- return core::Function::kDpdx;
+ return core::BuiltinFn::kDpdx;
case spv::Op::OpDPdy:
- return core::Function::kDpdy;
+ return core::BuiltinFn::kDpdy;
case spv::Op::OpFwidth:
- return core::Function::kFwidth;
+ return core::BuiltinFn::kFwidth;
case spv::Op::OpDPdxFine:
- return core::Function::kDpdxFine;
+ return core::BuiltinFn::kDpdxFine;
case spv::Op::OpDPdyFine:
- return core::Function::kDpdyFine;
+ return core::BuiltinFn::kDpdyFine;
case spv::Op::OpFwidthFine:
- return core::Function::kFwidthFine;
+ return core::BuiltinFn::kFwidthFine;
case spv::Op::OpDPdxCoarse:
- return core::Function::kDpdxCoarse;
+ return core::BuiltinFn::kDpdxCoarse;
case spv::Op::OpDPdyCoarse:
- return core::Function::kDpdyCoarse;
+ return core::BuiltinFn::kDpdyCoarse;
case spv::Op::OpFwidthCoarse:
- return core::Function::kFwidthCoarse;
+ return core::BuiltinFn::kFwidthCoarse;
default:
break;
}
- return core::Function::kNone;
+ return core::BuiltinFn::kNone;
}
// @param opcode a SPIR-V opcode
@@ -3819,11 +3819,11 @@
}
const auto builtin = GetBuiltin(op);
- if (builtin != core::Function::kNone) {
+ if (builtin != core::BuiltinFn::kNone) {
switch (builtin) {
- case core::Function::kExtractBits:
+ case core::BuiltinFn::kExtractBits:
return MakeExtractBitsCall(inst);
- case core::Function::kInsertBits:
+ case core::BuiltinFn::kInsertBits:
return MakeInsertBitsCall(inst);
default:
return MakeBuiltinCall(inst);
@@ -5852,7 +5852,7 @@
}
bool FunctionEmitter::EmitAtomicOp(const spvtools::opt::Instruction& inst) {
- auto emit_atomic = [&](core::Function builtin, std::initializer_list<TypedExpression> args) {
+ auto emit_atomic = [&](core::BuiltinFn builtin, std::initializer_list<TypedExpression> args) {
// Split args into params and expressions
ParameterList params;
params.Reserve(args.size());
@@ -5911,38 +5911,38 @@
switch (opcode(inst)) {
case spv::Op::OpAtomicLoad:
- return emit_atomic(core::Function::kAtomicLoad, {oper(/*ptr*/ 0)});
+ return emit_atomic(core::BuiltinFn::kAtomicLoad, {oper(/*ptr*/ 0)});
case spv::Op::OpAtomicStore:
- return emit_atomic(core::Function::kAtomicStore, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(core::BuiltinFn::kAtomicStore, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicExchange:
- return emit_atomic(core::Function::kAtomicExchange,
+ return emit_atomic(core::BuiltinFn::kAtomicExchange,
{oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicCompareExchange:
case spv::Op::OpAtomicCompareExchangeWeak:
- return emit_atomic(core::Function::kAtomicCompareExchangeWeak,
+ return emit_atomic(core::BuiltinFn::kAtomicCompareExchangeWeak,
{oper(/*ptr*/ 0), /*value*/ oper(5), /*comparator*/ oper(4)});
case spv::Op::OpAtomicIIncrement:
- return emit_atomic(core::Function::kAtomicAdd, {oper(/*ptr*/ 0), lit(1)});
+ return emit_atomic(core::BuiltinFn::kAtomicAdd, {oper(/*ptr*/ 0), lit(1)});
case spv::Op::OpAtomicIDecrement:
- return emit_atomic(core::Function::kAtomicSub, {oper(/*ptr*/ 0), lit(1)});
+ return emit_atomic(core::BuiltinFn::kAtomicSub, {oper(/*ptr*/ 0), lit(1)});
case spv::Op::OpAtomicIAdd:
- return emit_atomic(core::Function::kAtomicAdd, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(core::BuiltinFn::kAtomicAdd, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicISub:
- return emit_atomic(core::Function::kAtomicSub, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(core::BuiltinFn::kAtomicSub, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicSMin:
- return emit_atomic(core::Function::kAtomicMin, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(core::BuiltinFn::kAtomicMin, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicUMin:
- return emit_atomic(core::Function::kAtomicMin, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(core::BuiltinFn::kAtomicMin, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicSMax:
- return emit_atomic(core::Function::kAtomicMax, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(core::BuiltinFn::kAtomicMax, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicUMax:
- return emit_atomic(core::Function::kAtomicMax, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(core::BuiltinFn::kAtomicMax, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicAnd:
- return emit_atomic(core::Function::kAtomicAnd, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(core::BuiltinFn::kAtomicAnd, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicOr:
- return emit_atomic(core::Function::kAtomicOr, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(core::BuiltinFn::kAtomicOr, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicXor:
- return emit_atomic(core::Function::kAtomicXor, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(core::BuiltinFn::kAtomicXor, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicFlagTestAndSet:
case spv::Op::OpAtomicFlagClear:
case spv::Op::OpAtomicFMinEXT:
diff --git a/src/tint/lang/spirv/reader/ast_parser/namer.cc b/src/tint/lang/spirv/reader/ast_parser/namer.cc
index aaa1ba6..6039a55 100644
--- a/src/tint/lang/spirv/reader/ast_parser/namer.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/namer.cc
@@ -17,7 +17,7 @@
#include <algorithm>
#include <unordered_set>
-#include "src/tint/lang/core/function.h"
+#include "src/tint/lang/core/builtin_fn.h"
#include "src/tint/utils/ice/ice.h"
#include "src/tint/utils/text/string_stream.h"
@@ -176,7 +176,7 @@
for (const auto* reserved : kWGSLReservedWords) {
name_to_id_[std::string(reserved)] = 0;
}
- for (const auto* builtin_function : core::kFunctionStrings) {
+ for (const auto* builtin_function : core::kBuiltinFnStrings) {
name_to_id_[std::string(builtin_function)] = 0;
}
}
diff --git a/src/tint/lang/spirv/reader/ast_parser/namer_test.cc b/src/tint/lang/spirv/reader/ast_parser/namer_test.cc
index f6af2c7..14ff1dc 100644
--- a/src/tint/lang/spirv/reader/ast_parser/namer_test.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/namer_test.cc
@@ -15,7 +15,7 @@
#include "src/tint/lang/spirv/reader/ast_parser/namer.h"
#include "gmock/gmock.h"
-#include "src/tint/lang/core/function.h"
+#include "src/tint/lang/core/builtin_fn.h"
#include "src/tint/utils/text/string_stream.h"
namespace tint::spirv::reader::ast_parser {
@@ -408,7 +408,7 @@
INSTANTIATE_TEST_SUITE_P(SpirvASTParserTest_BuiltinFunctions,
SpvNamerBuiltinFunctionTest,
- ::testing::ValuesIn(core::kFunctionStrings));
+ ::testing::ValuesIn(core::kBuiltinFnStrings));
} // namespace
} // namespace tint::spirv::reader::ast_parser
diff --git a/src/tint/lang/spirv/writer/ast_printer/builder.cc b/src/tint/lang/spirv/writer/ast_printer/builder.cc
index 9756664..beb9b39 100644
--- a/src/tint/lang/spirv/writer/ast_printer/builder.cc
+++ b/src/tint/lang/spirv/writer/ast_printer/builder.cc
@@ -36,7 +36,7 @@
#include "src/tint/lang/wgsl/ast/traverse_expressions.h"
#include "src/tint/lang/wgsl/helpers/append_vector.h"
#include "src/tint/lang/wgsl/helpers/check_supported_extensions.h"
-#include "src/tint/lang/wgsl/sem/builtin.h"
+#include "src/tint/lang/wgsl/sem/builtin_fn.h"
#include "src/tint/lang/wgsl/sem/call.h"
#include "src/tint/lang/wgsl/sem/function.h"
#include "src/tint/lang/wgsl/sem/load.h"
@@ -92,25 +92,25 @@
return type->As<core::type::Matrix>();
}
-uint32_t builtin_to_glsl_method(const sem::Builtin* builtin) {
- switch (builtin->Type()) {
- case core::Function::kAcos:
+uint32_t builtin_to_glsl_method(const sem::BuiltinFn* builtin) {
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kAcos:
return GLSLstd450Acos;
- case core::Function::kAcosh:
+ case core::BuiltinFn::kAcosh:
return GLSLstd450Acosh;
- case core::Function::kAsin:
+ case core::BuiltinFn::kAsin:
return GLSLstd450Asin;
- case core::Function::kAsinh:
+ case core::BuiltinFn::kAsinh:
return GLSLstd450Asinh;
- case core::Function::kAtan:
+ case core::BuiltinFn::kAtan:
return GLSLstd450Atan;
- case core::Function::kAtan2:
+ case core::BuiltinFn::kAtan2:
return GLSLstd450Atan2;
- case core::Function::kAtanh:
+ case core::BuiltinFn::kAtanh:
return GLSLstd450Atanh;
- case core::Function::kCeil:
+ case core::BuiltinFn::kCeil:
return GLSLstd450Ceil;
- case core::Function::kClamp:
+ case core::BuiltinFn::kClamp:
if (builtin->ReturnType()->is_float_scalar_or_vector()) {
return GLSLstd450NClamp;
} else if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
@@ -118,43 +118,43 @@
} else {
return GLSLstd450SClamp;
}
- case core::Function::kCos:
+ case core::BuiltinFn::kCos:
return GLSLstd450Cos;
- case core::Function::kCosh:
+ case core::BuiltinFn::kCosh:
return GLSLstd450Cosh;
- case core::Function::kCross:
+ case core::BuiltinFn::kCross:
return GLSLstd450Cross;
- case core::Function::kDegrees:
+ case core::BuiltinFn::kDegrees:
return GLSLstd450Degrees;
- case core::Function::kDeterminant:
+ case core::BuiltinFn::kDeterminant:
return GLSLstd450Determinant;
- case core::Function::kDistance:
+ case core::BuiltinFn::kDistance:
return GLSLstd450Distance;
- case core::Function::kExp:
+ case core::BuiltinFn::kExp:
return GLSLstd450Exp;
- case core::Function::kExp2:
+ case core::BuiltinFn::kExp2:
return GLSLstd450Exp2;
- case core::Function::kFaceForward:
+ case core::BuiltinFn::kFaceForward:
return GLSLstd450FaceForward;
- case core::Function::kFloor:
+ case core::BuiltinFn::kFloor:
return GLSLstd450Floor;
- case core::Function::kFma:
+ case core::BuiltinFn::kFma:
return GLSLstd450Fma;
- case core::Function::kFract:
+ case core::BuiltinFn::kFract:
return GLSLstd450Fract;
- case core::Function::kFrexp:
+ case core::BuiltinFn::kFrexp:
return GLSLstd450FrexpStruct;
- case core::Function::kInverseSqrt:
+ case core::BuiltinFn::kInverseSqrt:
return GLSLstd450InverseSqrt;
- case core::Function::kLdexp:
+ case core::BuiltinFn::kLdexp:
return GLSLstd450Ldexp;
- case core::Function::kLength:
+ case core::BuiltinFn::kLength:
return GLSLstd450Length;
- case core::Function::kLog:
+ case core::BuiltinFn::kLog:
return GLSLstd450Log;
- case core::Function::kLog2:
+ case core::BuiltinFn::kLog2:
return GLSLstd450Log2;
- case core::Function::kMax:
+ case core::BuiltinFn::kMax:
if (builtin->ReturnType()->is_float_scalar_or_vector()) {
return GLSLstd450NMax;
} else if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
@@ -162,7 +162,7 @@
} else {
return GLSLstd450SMax;
}
- case core::Function::kMin:
+ case core::BuiltinFn::kMin:
if (builtin->ReturnType()->is_float_scalar_or_vector()) {
return GLSLstd450NMin;
} else if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
@@ -170,63 +170,63 @@
} else {
return GLSLstd450SMin;
}
- case core::Function::kMix:
+ case core::BuiltinFn::kMix:
return GLSLstd450FMix;
- case core::Function::kModf:
+ case core::BuiltinFn::kModf:
return GLSLstd450ModfStruct;
- case core::Function::kNormalize:
+ case core::BuiltinFn::kNormalize:
return GLSLstd450Normalize;
- case core::Function::kPack4X8Snorm:
+ case core::BuiltinFn::kPack4X8Snorm:
return GLSLstd450PackSnorm4x8;
- case core::Function::kPack4X8Unorm:
+ case core::BuiltinFn::kPack4X8Unorm:
return GLSLstd450PackUnorm4x8;
- case core::Function::kPack2X16Snorm:
+ case core::BuiltinFn::kPack2X16Snorm:
return GLSLstd450PackSnorm2x16;
- case core::Function::kPack2X16Unorm:
+ case core::BuiltinFn::kPack2X16Unorm:
return GLSLstd450PackUnorm2x16;
- case core::Function::kPack2X16Float:
+ case core::BuiltinFn::kPack2X16Float:
return GLSLstd450PackHalf2x16;
- case core::Function::kPow:
+ case core::BuiltinFn::kPow:
return GLSLstd450Pow;
- case core::Function::kRadians:
+ case core::BuiltinFn::kRadians:
return GLSLstd450Radians;
- case core::Function::kReflect:
+ case core::BuiltinFn::kReflect:
return GLSLstd450Reflect;
- case core::Function::kRefract:
+ case core::BuiltinFn::kRefract:
return GLSLstd450Refract;
- case core::Function::kRound:
+ case core::BuiltinFn::kRound:
return GLSLstd450RoundEven;
- case core::Function::kSign:
+ case core::BuiltinFn::kSign:
if (builtin->ReturnType()->is_signed_integer_scalar_or_vector()) {
return GLSLstd450SSign;
} else {
return GLSLstd450FSign;
}
- case core::Function::kSin:
+ case core::BuiltinFn::kSin:
return GLSLstd450Sin;
- case core::Function::kSinh:
+ case core::BuiltinFn::kSinh:
return GLSLstd450Sinh;
- case core::Function::kSmoothstep:
+ case core::BuiltinFn::kSmoothstep:
return GLSLstd450SmoothStep;
- case core::Function::kSqrt:
+ case core::BuiltinFn::kSqrt:
return GLSLstd450Sqrt;
- case core::Function::kStep:
+ case core::BuiltinFn::kStep:
return GLSLstd450Step;
- case core::Function::kTan:
+ case core::BuiltinFn::kTan:
return GLSLstd450Tan;
- case core::Function::kTanh:
+ case core::BuiltinFn::kTanh:
return GLSLstd450Tanh;
- case core::Function::kTrunc:
+ case core::BuiltinFn::kTrunc:
return GLSLstd450Trunc;
- case core::Function::kUnpack4X8Snorm:
+ case core::BuiltinFn::kUnpack4X8Snorm:
return GLSLstd450UnpackSnorm4x8;
- case core::Function::kUnpack4X8Unorm:
+ case core::BuiltinFn::kUnpack4X8Unorm:
return GLSLstd450UnpackUnorm4x8;
- case core::Function::kUnpack2X16Snorm:
+ case core::BuiltinFn::kUnpack2X16Snorm:
return GLSLstd450UnpackSnorm2x16;
- case core::Function::kUnpack2X16Unorm:
+ case core::BuiltinFn::kUnpack2X16Unorm:
return GLSLstd450UnpackUnorm2x16;
- case core::Function::kUnpack2X16Float:
+ case core::BuiltinFn::kUnpack2X16Float:
return GLSLstd450UnpackHalf2x16;
default:
break;
@@ -2213,7 +2213,7 @@
return Switch(
target, //
[&](const sem::Function* func) { return GenerateFunctionCall(call, func); },
- [&](const sem::Builtin* builtin) { return GenerateBuiltinCall(call, builtin); },
+ [&](const sem::BuiltinFn* builtin) { return GenerateBuiltinCall(call, builtin); },
[&](const sem::ValueConversion*) {
return GenerateValueConstructorOrConversion(call, nullptr);
},
@@ -2262,7 +2262,7 @@
return result_id;
}
-uint32_t Builder::GenerateBuiltinCall(const sem::Call* call, const sem::Builtin* builtin) {
+uint32_t Builder::GenerateBuiltinCall(const sem::Call* call, const sem::BuiltinFn* builtin) {
auto result = result_op();
auto result_id = std::get<uint32_t>(result);
@@ -2328,22 +2328,22 @@
op = spv::Op::OpExtInst;
};
- switch (builtin->Type()) {
- case core::Function::kAny:
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kAny:
if (builtin->Parameters()[0]->Type()->Is<core::type::Bool>()) {
// any(v: bool) just resolves to v.
return get_arg_as_value_id(0);
}
op = spv::Op::OpAny;
break;
- case core::Function::kAll:
+ case core::BuiltinFn::kAll:
if (builtin->Parameters()[0]->Type()->Is<core::type::Bool>()) {
// all(v: bool) just resolves to v.
return get_arg_as_value_id(0);
}
op = spv::Op::OpAll;
break;
- case core::Function::kArrayLength: {
+ case core::BuiltinFn::kArrayLength: {
auto* address_of = call->Arguments()[0]->Declaration()->As<ast::UnaryOpExpression>();
if (!address_of || address_of->op != core::UnaryOp::kAddressOf) {
TINT_ICE() << "arrayLength() expected pointer to member access, got " +
@@ -2380,10 +2380,10 @@
}
return result_id;
}
- case core::Function::kCountOneBits:
+ case core::BuiltinFn::kCountOneBits:
op = spv::Op::OpBitCount;
break;
- case core::Function::kDot: {
+ case core::BuiltinFn::kDot: {
op = spv::Op::OpDot;
auto* vec_ty = builtin->Parameters()[0]->Type()->As<core::type::Vector>();
if (vec_ty->type()->is_integer_scalar()) {
@@ -2424,42 +2424,42 @@
}
break;
}
- case core::Function::kDpdx:
+ case core::BuiltinFn::kDpdx:
op = spv::Op::OpDPdx;
break;
- case core::Function::kDpdxCoarse:
+ case core::BuiltinFn::kDpdxCoarse:
op = spv::Op::OpDPdxCoarse;
break;
- case core::Function::kDpdxFine:
+ case core::BuiltinFn::kDpdxFine:
op = spv::Op::OpDPdxFine;
break;
- case core::Function::kDpdy:
+ case core::BuiltinFn::kDpdy:
op = spv::Op::OpDPdy;
break;
- case core::Function::kDpdyCoarse:
+ case core::BuiltinFn::kDpdyCoarse:
op = spv::Op::OpDPdyCoarse;
break;
- case core::Function::kDpdyFine:
+ case core::BuiltinFn::kDpdyFine:
op = spv::Op::OpDPdyFine;
break;
- case core::Function::kExtractBits:
+ case core::BuiltinFn::kExtractBits:
op = builtin->Parameters()[0]->Type()->is_unsigned_integer_scalar_or_vector()
? spv::Op::OpBitFieldUExtract
: spv::Op::OpBitFieldSExtract;
break;
- case core::Function::kFwidth:
+ case core::BuiltinFn::kFwidth:
op = spv::Op::OpFwidth;
break;
- case core::Function::kFwidthCoarse:
+ case core::BuiltinFn::kFwidthCoarse:
op = spv::Op::OpFwidthCoarse;
break;
- case core::Function::kFwidthFine:
+ case core::BuiltinFn::kFwidthFine:
op = spv::Op::OpFwidthFine;
break;
- case core::Function::kInsertBits:
+ case core::BuiltinFn::kInsertBits:
op = spv::Op::OpBitFieldInsert;
break;
- case core::Function::kMix: {
+ case core::BuiltinFn::kMix: {
auto std450 = Operand(GetGLSLstd450Import());
auto a_id = get_arg_as_value_id(0);
@@ -2486,13 +2486,13 @@
}
return result_id;
}
- case core::Function::kQuantizeToF16:
+ case core::BuiltinFn::kQuantizeToF16:
op = spv::Op::OpQuantizeToF16;
break;
- case core::Function::kReverseBits:
+ case core::BuiltinFn::kReverseBits:
op = spv::Op::OpBitReverse;
break;
- case core::Function::kSelect: {
+ case core::BuiltinFn::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);
@@ -2524,10 +2524,10 @@
}
return result_id;
}
- case core::Function::kTranspose:
+ case core::BuiltinFn::kTranspose:
op = spv::Op::OpTranspose;
break;
- case core::Function::kAbs:
+ case core::BuiltinFn::kAbs:
if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
// abs() only operates on *signed* integers.
// This is a no-op for unsigned integers.
@@ -2539,7 +2539,7 @@
glsl_std450(GLSLstd450SAbs);
}
break;
- case core::Function::kDot4I8Packed: {
+ case core::BuiltinFn::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,
@@ -2551,7 +2551,7 @@
}
return result_id;
}
- case core::Function::kDot4U8Packed: {
+ case core::BuiltinFn::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,
@@ -2563,7 +2563,7 @@
}
return result_id;
}
- case core::Function::kSubgroupBallot: {
+ case core::BuiltinFn::kSubgroupBallot: {
module_.PushCapability(SpvCapabilityGroupNonUniformBallot);
if (!push_function_inst(
spv::Op::OpGroupNonUniformBallot,
@@ -2574,7 +2574,7 @@
}
return result_id;
}
- case core::Function::kSubgroupBroadcast: {
+ case core::BuiltinFn::kSubgroupBroadcast: {
module_.PushCapability(SpvCapabilityGroupNonUniformBallot);
auto first_param_id = get_arg_as_value_id(0);
auto second_param_id = get_arg_as_value_id(1);
@@ -2619,7 +2619,7 @@
}
bool Builder::GenerateTextureBuiltin(const sem::Call* call,
- const sem::Builtin* builtin,
+ const sem::BuiltinFn* builtin,
Operand result_type,
Operand result_id) {
using Usage = core::ParameterUsage;
@@ -2777,8 +2777,8 @@
return append_coords_to_spirv_params();
};
- switch (builtin->Type()) {
- case core::Function::kTextureDimensions: {
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::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
@@ -2823,7 +2823,7 @@
}
break;
}
- case core::Function::kTextureNumLayers: {
+ case core::BuiltinFn::kTextureNumLayers: {
uint32_t spirv_dims = 0;
switch (texture_type->dim()) {
default:
@@ -2853,19 +2853,19 @@
}
break;
}
- case core::Function::kTextureNumLevels: {
+ case core::BuiltinFn::kTextureNumLevels: {
op = spv::Op::OpImageQueryLevels;
append_result_type_and_id_to_spirv_params();
spirv_params.emplace_back(gen_arg(Usage::kTexture));
break;
}
- case core::Function::kTextureNumSamples: {
+ case core::BuiltinFn::kTextureNumSamples: {
op = spv::Op::OpImageQuerySamples;
append_result_type_and_id_to_spirv_params();
spirv_params.emplace_back(gen_arg(Usage::kTexture));
break;
}
- case core::Function::kTextureLoad: {
+ case core::BuiltinFn::kTextureLoad: {
op = texture_type->Is<core::type::StorageTexture>() ? spv::Op::OpImageRead
: spv::Op::OpImageFetch;
append_result_type_and_id_to_spirv_params_for_read();
@@ -2885,7 +2885,7 @@
break;
}
- case core::Function::kTextureStore: {
+ case core::BuiltinFn::kTextureStore: {
op = spv::Op::OpImageWrite;
spirv_params.emplace_back(gen_arg(Usage::kTexture));
if (!append_coords_to_spirv_params()) {
@@ -2894,7 +2894,7 @@
spirv_params.emplace_back(gen_arg(Usage::kValue));
break;
}
- case core::Function::kTextureGather: {
+ case core::BuiltinFn::kTextureGather: {
op = spv::Op::OpImageGather;
append_result_type_and_id_to_spirv_params();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2908,7 +2908,7 @@
}
break;
}
- case core::Function::kTextureGatherCompare: {
+ case core::BuiltinFn::kTextureGatherCompare: {
op = spv::Op::OpImageDrefGather;
append_result_type_and_id_to_spirv_params();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2917,7 +2917,7 @@
spirv_params.emplace_back(gen_arg(Usage::kDepthRef));
break;
}
- case core::Function::kTextureSample: {
+ case core::BuiltinFn::kTextureSample: {
op = spv::Op::OpImageSampleImplicitLod;
append_result_type_and_id_to_spirv_params_for_read();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2925,7 +2925,7 @@
}
break;
}
- case core::Function::kTextureSampleBias: {
+ case core::BuiltinFn::kTextureSampleBias: {
op = spv::Op::OpImageSampleImplicitLod;
append_result_type_and_id_to_spirv_params_for_read();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2935,7 +2935,7 @@
ImageOperand{SpvImageOperandsBiasMask, gen_arg(Usage::kBias)});
break;
}
- case core::Function::kTextureSampleLevel: {
+ case core::BuiltinFn::kTextureSampleLevel: {
op = spv::Op::OpImageSampleExplicitLod;
append_result_type_and_id_to_spirv_params_for_read();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2963,7 +2963,7 @@
image_operands.emplace_back(ImageOperand{SpvImageOperandsLodMask, level});
break;
}
- case core::Function::kTextureSampleGrad: {
+ case core::BuiltinFn::kTextureSampleGrad: {
op = spv::Op::OpImageSampleExplicitLod;
append_result_type_and_id_to_spirv_params_for_read();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2975,7 +2975,7 @@
ImageOperand{SpvImageOperandsGradMask, gen_arg(Usage::kDdy)});
break;
}
- case core::Function::kTextureSampleCompare: {
+ case core::BuiltinFn::kTextureSampleCompare: {
op = spv::Op::OpImageSampleDrefImplicitLod;
append_result_type_and_id_to_spirv_params();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2984,7 +2984,7 @@
spirv_params.emplace_back(gen_arg(Usage::kDepthRef));
break;
}
- case core::Function::kTextureSampleCompareLevel: {
+ case core::BuiltinFn::kTextureSampleCompareLevel: {
op = spv::Op::OpImageSampleDrefExplicitLod;
append_result_type_and_id_to_spirv_params();
if (!append_image_and_coords_to_spirv_params()) {
@@ -3031,7 +3031,7 @@
return post_emission();
}
-bool Builder::GenerateControlBarrierBuiltin(const sem::Builtin* builtin) {
+bool Builder::GenerateControlBarrierBuiltin(const sem::BuiltinFn* builtin) {
auto const op = spv::Op::OpControlBarrier;
uint32_t execution = 0;
uint32_t memory = 0;
@@ -3039,23 +3039,23 @@
// TODO(crbug.com/tint/661): Combine sequential barriers to a single
// instruction.
- if (builtin->Type() == core::Function::kWorkgroupBarrier) {
+ if (builtin->Fn() == core::BuiltinFn::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() == core::Function::kStorageBarrier) {
+ } else if (builtin->Fn() == core::BuiltinFn::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 if (builtin->Type() == core::Function::kTextureBarrier) {
+ } else if (builtin->Fn() == core::BuiltinFn::kTextureBarrier) {
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::ImageMemory);
} else {
- TINT_ICE() << "unexpected barrier builtin type " << core::str(builtin->Type());
+ TINT_ICE() << "unexpected barrier builtin type " << core::str(builtin->Fn());
return false;
}
@@ -3074,7 +3074,7 @@
}
bool Builder::GenerateAtomicBuiltin(const sem::Call* call,
- const sem::Builtin* builtin,
+ const sem::BuiltinFn* builtin,
Operand result_type,
Operand result_id) {
auto is_value_signed = [&] { return builtin->Parameters()[1]->Type()->Is<core::type::I32>(); };
@@ -3124,8 +3124,8 @@
Operand memory = Operand(memory_id);
Operand semantics = Operand(semantics_id);
- switch (builtin->Type()) {
- case core::Function::kAtomicLoad:
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kAtomicLoad:
return push_function_inst(spv::Op::OpAtomicLoad, {
result_type,
result_id,
@@ -3133,14 +3133,14 @@
memory,
semantics,
});
- case core::Function::kAtomicStore:
+ case core::BuiltinFn::kAtomicStore:
return push_function_inst(spv::Op::OpAtomicStore, {
pointer,
memory,
semantics,
value,
});
- case core::Function::kAtomicAdd:
+ case core::BuiltinFn::kAtomicAdd:
return push_function_inst(spv::Op::OpAtomicIAdd, {
result_type,
result_id,
@@ -3149,7 +3149,7 @@
semantics,
value,
});
- case core::Function::kAtomicSub:
+ case core::BuiltinFn::kAtomicSub:
return push_function_inst(spv::Op::OpAtomicISub, {
result_type,
result_id,
@@ -3158,7 +3158,7 @@
semantics,
value,
});
- case core::Function::kAtomicMax:
+ case core::BuiltinFn::kAtomicMax:
return push_function_inst(
is_value_signed() ? spv::Op::OpAtomicSMax : spv::Op::OpAtomicUMax, {
result_type,
@@ -3168,7 +3168,7 @@
semantics,
value,
});
- case core::Function::kAtomicMin:
+ case core::BuiltinFn::kAtomicMin:
return push_function_inst(
is_value_signed() ? spv::Op::OpAtomicSMin : spv::Op::OpAtomicUMin, {
result_type,
@@ -3178,7 +3178,7 @@
semantics,
value,
});
- case core::Function::kAtomicAnd:
+ case core::BuiltinFn::kAtomicAnd:
return push_function_inst(spv::Op::OpAtomicAnd, {
result_type,
result_id,
@@ -3187,7 +3187,7 @@
semantics,
value,
});
- case core::Function::kAtomicOr:
+ case core::BuiltinFn::kAtomicOr:
return push_function_inst(spv::Op::OpAtomicOr, {
result_type,
result_id,
@@ -3196,7 +3196,7 @@
semantics,
value,
});
- case core::Function::kAtomicXor:
+ case core::BuiltinFn::kAtomicXor:
return push_function_inst(spv::Op::OpAtomicXor, {
result_type,
result_id,
@@ -3205,7 +3205,7 @@
semantics,
value,
});
- case core::Function::kAtomicExchange:
+ case core::BuiltinFn::kAtomicExchange:
return push_function_inst(spv::Op::OpAtomicExchange, {
result_type,
result_id,
@@ -3214,7 +3214,7 @@
semantics,
value,
});
- case core::Function::kAtomicCompareExchangeWeak: {
+ case core::BuiltinFn::kAtomicCompareExchangeWeak: {
auto comparator = GenerateExpression(call->Arguments()[1]);
if (comparator == 0) {
return false;
@@ -3275,7 +3275,7 @@
});
}
default:
- TINT_UNREACHABLE() << "unhandled atomic builtin " << builtin->Type();
+ TINT_UNREACHABLE() << "unhandled atomic builtin " << builtin->Fn();
return false;
}
}
diff --git a/src/tint/lang/spirv/writer/ast_printer/builder.h b/src/tint/lang/spirv/writer/ast_printer/builder.h
index c736697..ec5066e 100644
--- a/src/tint/lang/spirv/writer/ast_printer/builder.h
+++ b/src/tint/lang/spirv/writer/ast_printer/builder.h
@@ -40,7 +40,7 @@
#include "src/tint/lang/wgsl/ast/unary_op_expression.h"
#include "src/tint/lang/wgsl/ast/variable_decl_statement.h"
#include "src/tint/lang/wgsl/program/program_builder.h"
-#include "src/tint/lang/wgsl/sem/builtin.h"
+#include "src/tint/lang/wgsl/sem/builtin_fn.h"
#include "src/tint/utils/containers/scope_stack.h"
// Forward declarations
@@ -296,7 +296,7 @@
/// @param call the call expression
/// @param builtin the builtin being called
/// @returns the expression ID on success or 0 otherwise
- uint32_t GenerateBuiltinCall(const sem::Call* call, const sem::Builtin* builtin);
+ uint32_t GenerateBuiltinCall(const sem::Call* call, const sem::BuiltinFn* builtin);
/// Handles generating a value constructor or value conversion expression
/// @param call the call expression
/// @param var the variable that is being initialized. May be null.
@@ -311,13 +311,13 @@
/// parameters
/// @returns true on success
bool GenerateTextureBuiltin(const sem::Call* call,
- const sem::Builtin* builtin,
+ const sem::BuiltinFn* builtin,
Operand result_type,
Operand result_id);
/// Generates a control barrier statement.
/// @param builtin the semantic information for the barrier builtin call
/// @returns true on success
- bool GenerateControlBarrierBuiltin(const sem::Builtin* builtin);
+ bool GenerateControlBarrierBuiltin(const sem::BuiltinFn* builtin);
/// Generates an atomic builtin call.
/// @param call the call expression
/// @param builtin the semantic information for the atomic builtin call
@@ -325,7 +325,7 @@
/// @param result_id result identifier operand of the texture instruction
/// @returns true on success
bool GenerateAtomicBuiltin(const sem::Call* call,
- const sem::Builtin* builtin,
+ const sem::BuiltinFn* builtin,
Operand result_type,
Operand result_id);
/// Generates a sampled image
diff --git a/src/tint/lang/spirv/writer/atomic_builtin_test.cc b/src/tint/lang/spirv/writer/atomic_builtin_test.cc
index 5352fd1..2cbc65f 100644
--- a/src/tint/lang/spirv/writer/atomic_builtin_test.cc
+++ b/src/tint/lang/spirv/writer/atomic_builtin_test.cc
@@ -15,7 +15,7 @@
#include "src/tint/lang/core/type/builtin_structs.h"
#include "src/tint/lang/spirv/writer/common/helper_test.h"
-#include "src/tint/lang/core/function.h"
+#include "src/tint/lang/core/builtin_fn.h"
using namespace tint::core::fluent_types; // NOLINT
using namespace tint::core::number_suffixes; // NOLINT
@@ -34,7 +34,7 @@
b.Append(func->Block(), [&] {
auto* ptr = b.Let("ptr", var);
- auto* result = b.Call(ty.i32(), core::Function::kAtomicAdd, ptr, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicAdd, ptr, arg1);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -51,7 +51,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicAdd, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicAdd, var, arg1);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -68,7 +68,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicAnd, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicAnd, var, arg1);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -87,7 +87,8 @@
b.Append(func->Block(), [&] {
auto* result_ty = core::type::CreateAtomicCompareExchangeResult(ty, mod.symbols, ty.i32());
- auto* result = b.Call(result_ty, core::Function::kAtomicCompareExchangeWeak, var, cmp, val);
+ auto* result =
+ b.Call(result_ty, core::BuiltinFn::kAtomicCompareExchangeWeak, var, cmp, val);
auto* original = b.Access(ty.i32(), result, 0_u);
b.Return(func, original);
mod.SetName(result, "result");
@@ -109,7 +110,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicExchange, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicExchange, var, arg1);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -124,7 +125,7 @@
auto* func = b.Function("foo", ty.i32());
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicLoad, var);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicLoad, var);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -141,7 +142,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicMax, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicMax, var, arg1);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -158,7 +159,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kAtomicMax, var, arg1);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kAtomicMax, var, arg1);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -175,7 +176,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicMin, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicMin, var, arg1);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -192,7 +193,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kAtomicMin, var, arg1);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kAtomicMin, var, arg1);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -209,7 +210,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicOr, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicOr, var, arg1);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -226,7 +227,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- b.Call(ty.void_(), core::Function::kAtomicStore, var, arg1);
+ b.Call(ty.void_(), core::BuiltinFn::kAtomicStore, var, arg1);
b.Return(func);
});
@@ -242,7 +243,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicSub, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicSub, var, arg1);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -259,7 +260,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicXor, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicXor, var, arg1);
b.Return(func, result);
mod.SetName(result, "result");
});
diff --git a/src/tint/lang/spirv/writer/builtin_test.cc b/src/tint/lang/spirv/writer/builtin_test.cc
index 7e51a65..3b84143 100644
--- a/src/tint/lang/spirv/writer/builtin_test.cc
+++ b/src/tint/lang/spirv/writer/builtin_test.cc
@@ -14,7 +14,7 @@
#include "src/tint/lang/spirv/writer/common/helper_test.h"
-#include "src/tint/lang/core/function.h"
+#include "src/tint/lang/core/builtin_fn.h"
#include "src/tint/lang/core/type/builtin_structs.h"
using namespace tint::core::number_suffixes; // NOLINT
@@ -28,7 +28,7 @@
/// The element type to test.
TestElementType type;
/// The builtin function.
- enum core::Function function;
+ enum core::BuiltinFn function;
/// The expected SPIR-V instruction string.
std::string spirv_inst;
};
@@ -62,83 +62,83 @@
INSTANTIATE_TEST_SUITE_P(
SpirvWriterTest,
Builtin_1arg,
- testing::Values(BuiltinTestCase{kI32, core::Function::kAbs, "SAbs"},
- BuiltinTestCase{kF32, core::Function::kAbs, "FAbs"},
- BuiltinTestCase{kF16, core::Function::kAbs, "FAbs"},
- BuiltinTestCase{kF32, core::Function::kAcos, "Acos"},
- BuiltinTestCase{kF16, core::Function::kAcos, "Acos"},
- BuiltinTestCase{kF32, core::Function::kAsinh, "Asinh"},
- BuiltinTestCase{kF16, core::Function::kAsinh, "Asinh"},
- BuiltinTestCase{kF32, core::Function::kAcos, "Acos"},
- BuiltinTestCase{kF16, core::Function::kAcos, "Acos"},
- BuiltinTestCase{kF32, core::Function::kAsinh, "Asinh"},
- BuiltinTestCase{kF16, core::Function::kAsinh, "Asinh"},
- BuiltinTestCase{kF32, core::Function::kAtan, "Atan"},
- BuiltinTestCase{kF16, core::Function::kAtan, "Atan"},
- BuiltinTestCase{kF32, core::Function::kAtanh, "Atanh"},
- BuiltinTestCase{kF16, core::Function::kAtanh, "Atanh"},
- BuiltinTestCase{kF32, core::Function::kCeil, "Ceil"},
- BuiltinTestCase{kF16, core::Function::kCeil, "Ceil"},
- BuiltinTestCase{kF32, core::Function::kCos, "Cos"},
- BuiltinTestCase{kF16, core::Function::kCos, "Cos"},
- BuiltinTestCase{kI32, core::Function::kCountOneBits, "OpBitCount"},
- BuiltinTestCase{kU32, core::Function::kCountOneBits, "OpBitCount"},
- BuiltinTestCase{kF32, core::Function::kDpdx, "OpDPdx"},
- BuiltinTestCase{kF32, core::Function::kDpdxCoarse, "OpDPdxCoarse"},
- BuiltinTestCase{kF32, core::Function::kDpdxFine, "OpDPdxFine"},
- BuiltinTestCase{kF32, core::Function::kDpdy, "OpDPdy"},
- BuiltinTestCase{kF32, core::Function::kDpdyCoarse, "OpDPdyCoarse"},
- BuiltinTestCase{kF32, core::Function::kDpdyFine, "OpDPdyFine"},
- BuiltinTestCase{kF32, core::Function::kDegrees, "Degrees"},
- BuiltinTestCase{kF16, core::Function::kDegrees, "Degrees"},
- BuiltinTestCase{kF32, core::Function::kExp, "Exp"},
- BuiltinTestCase{kF16, core::Function::kExp, "Exp"},
- BuiltinTestCase{kF32, core::Function::kExp2, "Exp2"},
- BuiltinTestCase{kF16, core::Function::kExp2, "Exp2"},
- BuiltinTestCase{kF32, core::Function::kFloor, "Floor"},
- BuiltinTestCase{kF16, core::Function::kFloor, "Floor"},
- BuiltinTestCase{kF32, core::Function::kFract, "Fract"},
- BuiltinTestCase{kF16, core::Function::kFract, "Fract"},
- BuiltinTestCase{kF32, core::Function::kFwidth, "OpFwidth"},
- BuiltinTestCase{kF32, core::Function::kFwidthCoarse, "OpFwidthCoarse"},
- BuiltinTestCase{kF32, core::Function::kFwidthFine, "OpFwidthFine"},
- BuiltinTestCase{kF32, core::Function::kInverseSqrt, "InverseSqrt"},
- BuiltinTestCase{kF16, core::Function::kInverseSqrt, "InverseSqrt"},
- BuiltinTestCase{kF32, core::Function::kLog, "Log"},
- BuiltinTestCase{kF16, core::Function::kLog, "Log"},
- BuiltinTestCase{kF32, core::Function::kLog2, "Log2"},
- BuiltinTestCase{kF16, core::Function::kLog2, "Log2"},
- BuiltinTestCase{kF32, core::Function::kQuantizeToF16, "OpQuantizeToF16"},
- BuiltinTestCase{kF32, core::Function::kRadians, "Radians"},
- BuiltinTestCase{kF16, core::Function::kRadians, "Radians"},
- BuiltinTestCase{kI32, core::Function::kReverseBits, "OpBitReverse"},
- BuiltinTestCase{kU32, core::Function::kReverseBits, "OpBitReverse"},
- BuiltinTestCase{kF32, core::Function::kRound, "RoundEven"},
- BuiltinTestCase{kF16, core::Function::kRound, "RoundEven"},
- BuiltinTestCase{kF32, core::Function::kSign, "FSign"},
- BuiltinTestCase{kF16, core::Function::kSign, "FSign"},
- BuiltinTestCase{kI32, core::Function::kSign, "SSign"},
- BuiltinTestCase{kF32, core::Function::kSin, "Sin"},
- BuiltinTestCase{kF16, core::Function::kSin, "Sin"},
- BuiltinTestCase{kF32, core::Function::kSqrt, "Sqrt"},
- BuiltinTestCase{kF16, core::Function::kSqrt, "Sqrt"},
- BuiltinTestCase{kF32, core::Function::kTan, "Tan"},
- BuiltinTestCase{kF16, core::Function::kTan, "Tan"},
- BuiltinTestCase{kF32, core::Function::kTrunc, "Trunc"},
- BuiltinTestCase{kF16, core::Function::kTrunc, "Trunc"},
- BuiltinTestCase{kF32, core::Function::kCosh, "Cosh"},
- BuiltinTestCase{kF16, core::Function::kCosh, "Cosh"},
- BuiltinTestCase{kF32, core::Function::kSinh, "Sinh"},
- BuiltinTestCase{kF16, core::Function::kSinh, "Sinh"},
- BuiltinTestCase{kF32, core::Function::kTanh, "Tanh"},
- BuiltinTestCase{kF16, core::Function::kTanh, "Tanh"}));
+ testing::Values(BuiltinTestCase{kI32, core::BuiltinFn::kAbs, "SAbs"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kAbs, "FAbs"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kAbs, "FAbs"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kAcos, "Acos"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kAcos, "Acos"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kAsinh, "Asinh"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kAsinh, "Asinh"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kAcos, "Acos"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kAcos, "Acos"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kAsinh, "Asinh"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kAsinh, "Asinh"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kAtan, "Atan"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kAtan, "Atan"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kAtanh, "Atanh"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kAtanh, "Atanh"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kCeil, "Ceil"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kCeil, "Ceil"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kCos, "Cos"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kCos, "Cos"},
+ BuiltinTestCase{kI32, core::BuiltinFn::kCountOneBits, "OpBitCount"},
+ BuiltinTestCase{kU32, core::BuiltinFn::kCountOneBits, "OpBitCount"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kDpdx, "OpDPdx"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kDpdxCoarse, "OpDPdxCoarse"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kDpdxFine, "OpDPdxFine"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kDpdy, "OpDPdy"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kDpdyCoarse, "OpDPdyCoarse"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kDpdyFine, "OpDPdyFine"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kDegrees, "Degrees"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kDegrees, "Degrees"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kExp, "Exp"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kExp, "Exp"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kExp2, "Exp2"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kExp2, "Exp2"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kFloor, "Floor"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kFloor, "Floor"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kFract, "Fract"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kFract, "Fract"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kFwidth, "OpFwidth"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kFwidthCoarse, "OpFwidthCoarse"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kFwidthFine, "OpFwidthFine"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kInverseSqrt, "InverseSqrt"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kInverseSqrt, "InverseSqrt"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kLog, "Log"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kLog, "Log"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kLog2, "Log2"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kLog2, "Log2"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kQuantizeToF16, "OpQuantizeToF16"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kRadians, "Radians"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kRadians, "Radians"},
+ BuiltinTestCase{kI32, core::BuiltinFn::kReverseBits, "OpBitReverse"},
+ BuiltinTestCase{kU32, core::BuiltinFn::kReverseBits, "OpBitReverse"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kRound, "RoundEven"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kRound, "RoundEven"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kSign, "FSign"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kSign, "FSign"},
+ BuiltinTestCase{kI32, core::BuiltinFn::kSign, "SSign"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kSin, "Sin"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kSin, "Sin"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kSqrt, "Sqrt"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kSqrt, "Sqrt"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kTan, "Tan"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kTan, "Tan"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kTrunc, "Trunc"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kTrunc, "Trunc"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kCosh, "Cosh"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kCosh, "Cosh"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kSinh, "Sinh"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kSinh, "Sinh"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kTanh, "Tanh"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kTanh, "Tanh"}));
// Test that abs of an unsigned value just folds away.
TEST_F(SpirvWriterTest, Builtin_Abs_u32) {
auto* func = b.Function("foo", MakeScalarType(kU32));
b.Append(func->Block(), [&] {
auto* arg = MakeScalarValue(kU32);
- auto* result = b.Call(MakeScalarType(kU32), core::Function::kAbs, arg);
+ auto* result = b.Call(MakeScalarType(kU32), core::BuiltinFn::kAbs, arg);
b.Return(func, result);
mod.SetName(arg, "arg");
});
@@ -156,7 +156,7 @@
auto* func = b.Function("foo", MakeVectorType(kU32));
b.Append(func->Block(), [&] {
auto* arg = MakeVectorValue(kU32);
- auto* result = b.Call(MakeVectorType(kU32), core::Function::kAbs, arg);
+ auto* result = b.Call(MakeVectorType(kU32), core::BuiltinFn::kAbs, arg);
b.Return(func, result);
mod.SetName(arg, "arg");
});
@@ -176,7 +176,7 @@
auto* func = b.Function("foo", ty.bool_());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.bool_(), core::Function::kAll, arg);
+ auto* result = b.Call(ty.bool_(), core::BuiltinFn::kAll, arg);
b.Return(func, result);
});
@@ -189,7 +189,7 @@
auto* func = b.Function("foo", ty.bool_());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.bool_(), core::Function::kAll, arg);
+ auto* result = b.Call(ty.bool_(), core::BuiltinFn::kAll, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -204,7 +204,7 @@
auto* func = b.Function("foo", ty.bool_());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.bool_(), core::Function::kAny, arg);
+ auto* result = b.Call(ty.bool_(), core::BuiltinFn::kAny, arg);
b.Return(func, result);
});
@@ -217,7 +217,7 @@
auto* func = b.Function("foo", ty.bool_());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.bool_(), core::Function::kAny, arg);
+ auto* result = b.Call(ty.bool_(), core::BuiltinFn::kAny, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -231,7 +231,7 @@
auto* func = b.Function("foo", ty.f32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kDeterminant, arg);
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kDeterminant, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -245,7 +245,7 @@
auto* func = b.Function("foo", ty.f16());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f16(), core::Function::kDeterminant, arg);
+ auto* result = b.Call(ty.f16(), core::BuiltinFn::kDeterminant, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -260,7 +260,7 @@
auto* func = b.Function("foo", str);
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(str, core::Function::kFrexp, arg);
+ auto* result = b.Call(str, core::BuiltinFn::kFrexp, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -275,7 +275,7 @@
auto* func = b.Function("foo", str);
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(str, core::Function::kFrexp, arg);
+ auto* result = b.Call(str, core::BuiltinFn::kFrexp, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -290,7 +290,7 @@
auto* func = b.Function("foo", str);
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(str, core::Function::kFrexp, arg);
+ auto* result = b.Call(str, core::BuiltinFn::kFrexp, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -305,7 +305,7 @@
auto* func = b.Function("foo", str);
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(str, core::Function::kFrexp, arg);
+ auto* result = b.Call(str, core::BuiltinFn::kFrexp, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -319,7 +319,7 @@
auto* func = b.Function("foo", ty.f32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kLength, arg);
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kLength, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -334,7 +334,7 @@
auto* func = b.Function("foo", str);
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(str, core::Function::kModf, arg);
+ auto* result = b.Call(str, core::BuiltinFn::kModf, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -349,7 +349,7 @@
auto* func = b.Function("foo", str);
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(str, core::Function::kModf, arg);
+ auto* result = b.Call(str, core::BuiltinFn::kModf, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -364,7 +364,7 @@
auto* func = b.Function("foo", str);
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(str, core::Function::kModf, arg);
+ auto* result = b.Call(str, core::BuiltinFn::kModf, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -379,7 +379,7 @@
auto* func = b.Function("foo", str);
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(str, core::Function::kModf, arg);
+ auto* result = b.Call(str, core::BuiltinFn::kModf, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -393,7 +393,7 @@
auto* func = b.Function("foo", ty.vec4<f32>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kNormalize, arg);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kNormalize, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -407,7 +407,7 @@
auto* func = b.Function("foo", ty.mat3x2<f32>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.mat3x2<f32>(), core::Function::kTranspose, arg);
+ auto* result = b.Call(ty.mat3x2<f32>(), core::BuiltinFn::kTranspose, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -421,7 +421,7 @@
auto* func = b.Function("foo", ty.mat4x4<f32>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.mat4x4<f32>(), core::Function::kTranspose, arg);
+ auto* result = b.Call(ty.mat4x4<f32>(), core::BuiltinFn::kTranspose, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -435,7 +435,7 @@
auto* func = b.Function("foo", ty.mat3x4<f16>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.mat3x4<f16>(), core::Function::kTranspose, arg);
+ auto* result = b.Call(ty.mat3x4<f16>(), core::BuiltinFn::kTranspose, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -449,7 +449,7 @@
auto* func = b.Function("foo", ty.mat2x2<f16>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.mat2x2<f16>(), core::Function::kTranspose, arg);
+ auto* result = b.Call(ty.mat2x2<f16>(), core::BuiltinFn::kTranspose, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -463,7 +463,7 @@
auto* func = b.Function("foo", ty.u32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kPack2X16Float, arg);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kPack2X16Float, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -477,7 +477,7 @@
auto* func = b.Function("foo", ty.u32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kPack2X16Snorm, arg);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kPack2X16Snorm, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -491,7 +491,7 @@
auto* func = b.Function("foo", ty.u32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kPack2X16Unorm, arg);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kPack2X16Unorm, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -505,7 +505,7 @@
auto* func = b.Function("foo", ty.u32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kPack4X8Snorm, arg);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kPack4X8Snorm, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -519,7 +519,7 @@
auto* func = b.Function("foo", ty.u32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kPack4X8Unorm, arg);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kPack4X8Unorm, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -533,7 +533,7 @@
auto* func = b.Function("foo", ty.vec2<f32>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec2<f32>(), core::Function::kUnpack2X16Float, arg);
+ auto* result = b.Call(ty.vec2<f32>(), core::BuiltinFn::kUnpack2X16Float, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -547,7 +547,7 @@
auto* func = b.Function("foo", ty.vec2<f32>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec2<f32>(), core::Function::kUnpack2X16Snorm, arg);
+ auto* result = b.Call(ty.vec2<f32>(), core::BuiltinFn::kUnpack2X16Snorm, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -561,7 +561,7 @@
auto* func = b.Function("foo", ty.vec2<f32>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec2<f32>(), core::Function::kUnpack2X16Unorm, arg);
+ auto* result = b.Call(ty.vec2<f32>(), core::BuiltinFn::kUnpack2X16Unorm, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -575,7 +575,7 @@
auto* func = b.Function("foo", ty.vec4<f32>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kUnpack4X8Snorm, arg);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kUnpack4X8Snorm, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -589,7 +589,7 @@
auto* func = b.Function("foo", ty.vec4<f32>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kUnpack4X8Unorm, arg);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kUnpack4X8Unorm, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -603,7 +603,7 @@
auto* func = b.Function("foo", ty.u32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kCountLeadingZeros, arg);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kCountLeadingZeros, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -640,7 +640,7 @@
auto* func = b.Function("foo", ty.i32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kCountLeadingZeros, arg);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kCountLeadingZeros, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -679,7 +679,7 @@
auto* func = b.Function("foo", ty.vec2<u32>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec2<u32>(), core::Function::kCountLeadingZeros, arg);
+ auto* result = b.Call(ty.vec2<u32>(), core::BuiltinFn::kCountLeadingZeros, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -727,7 +727,7 @@
auto* func = b.Function("foo", ty.u32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kCountTrailingZeros, arg);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kCountTrailingZeros, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -768,7 +768,7 @@
auto* func = b.Function("foo", ty.i32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kCountTrailingZeros, arg);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kCountTrailingZeros, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -811,7 +811,7 @@
auto* func = b.Function("foo", ty.vec2<u32>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec2<u32>(), core::Function::kCountTrailingZeros, arg);
+ auto* result = b.Call(ty.vec2<u32>(), core::BuiltinFn::kCountTrailingZeros, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -862,7 +862,7 @@
auto* func = b.Function("foo", ty.u32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kFirstLeadingBit, arg);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kFirstLeadingBit, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -902,7 +902,7 @@
auto* func = b.Function("foo", ty.i32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kFirstLeadingBit, arg);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kFirstLeadingBit, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -947,7 +947,7 @@
auto* func = b.Function("foo", ty.vec2<u32>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec2<u32>(), core::Function::kFirstLeadingBit, arg);
+ auto* result = b.Call(ty.vec2<u32>(), core::BuiltinFn::kFirstLeadingBit, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -998,7 +998,7 @@
auto* func = b.Function("foo", ty.u32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kFirstTrailingBit, arg);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kFirstTrailingBit, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1038,7 +1038,7 @@
auto* func = b.Function("foo", ty.i32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kFirstTrailingBit, arg);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kFirstTrailingBit, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1080,7 +1080,7 @@
auto* func = b.Function("foo", ty.vec2<u32>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec2<u32>(), core::Function::kFirstTrailingBit, arg);
+ auto* result = b.Call(ty.vec2<u32>(), core::BuiltinFn::kFirstTrailingBit, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1131,7 +1131,7 @@
auto* func = b.Function("foo", ty.f32());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kSaturate, arg);
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kSaturate, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1145,7 +1145,7 @@
auto* func = b.Function("foo", ty.vec4<f16>());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f16>(), core::Function::kSaturate, arg);
+ auto* result = b.Call(ty.vec4<f16>(), core::BuiltinFn::kSaturate, arg);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1188,17 +1188,17 @@
}
INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
Builtin_2arg,
- testing::Values(BuiltinTestCase{kF32, core::Function::kAtan2, "Atan2"},
- BuiltinTestCase{kF32, core::Function::kMax, "FMax"},
- BuiltinTestCase{kI32, core::Function::kMax, "SMax"},
- BuiltinTestCase{kU32, core::Function::kMax, "UMax"},
- BuiltinTestCase{kF32, core::Function::kMin, "FMin"},
- BuiltinTestCase{kI32, core::Function::kMin, "SMin"},
- BuiltinTestCase{kU32, core::Function::kMin, "UMin"},
- BuiltinTestCase{kF32, core::Function::kPow, "Pow"},
- BuiltinTestCase{kF16, core::Function::kPow, "Pow"},
- BuiltinTestCase{kF32, core::Function::kStep, "Step"},
- BuiltinTestCase{kF16, core::Function::kStep, "Step"}));
+ testing::Values(BuiltinTestCase{kF32, core::BuiltinFn::kAtan2, "Atan2"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kMax, "FMax"},
+ BuiltinTestCase{kI32, core::BuiltinFn::kMax, "SMax"},
+ BuiltinTestCase{kU32, core::BuiltinFn::kMax, "UMax"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kMin, "FMin"},
+ BuiltinTestCase{kI32, core::BuiltinFn::kMin, "SMin"},
+ BuiltinTestCase{kU32, core::BuiltinFn::kMin, "UMin"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kPow, "Pow"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kPow, "Pow"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kStep, "Step"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kStep, "Step"}));
TEST_F(SpirvWriterTest, Builtin_Cross_vec3f) {
auto* arg1 = b.FunctionParam("arg1", ty.vec3<f32>());
@@ -1206,7 +1206,7 @@
auto* func = b.Function("foo", ty.vec3<f32>());
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec3<f32>(), core::Function::kCross, arg1, arg2);
+ auto* result = b.Call(ty.vec3<f32>(), core::BuiltinFn::kCross, arg1, arg2);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1221,7 +1221,7 @@
auto* func = b.Function("foo", MakeScalarType(kF32));
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(MakeScalarType(kF32), core::Function::kDistance, arg1, arg2);
+ auto* result = b.Call(MakeScalarType(kF32), core::BuiltinFn::kDistance, arg1, arg2);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1236,7 +1236,7 @@
auto* func = b.Function("foo", MakeScalarType(kF16));
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(MakeScalarType(kF16), core::Function::kDistance, arg1, arg2);
+ auto* result = b.Call(MakeScalarType(kF16), core::BuiltinFn::kDistance, arg1, arg2);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1251,7 +1251,7 @@
auto* func = b.Function("foo", ty.f32());
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kDot, arg1, arg2);
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kDot, arg1, arg2);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1266,7 +1266,7 @@
auto* func = b.Function("foo", ty.i32());
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kDot, arg1, arg2);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kDot, arg1, arg2);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1289,7 +1289,7 @@
auto* func = b.Function("foo", ty.u32());
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kDot, arg1, arg2);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kDot, arg1, arg2);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1320,7 +1320,7 @@
auto* func = b.Function("foo", ty.f32());
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kLdexp, arg1, arg2);
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kLdexp, arg1, arg2);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1335,7 +1335,7 @@
auto* func = b.Function("foo", ty.f16());
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f16(), core::Function::kLdexp, arg1, arg2);
+ auto* result = b.Call(ty.f16(), core::BuiltinFn::kLdexp, arg1, arg2);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1350,7 +1350,7 @@
auto* func = b.Function("foo", ty.vec2<f32>());
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec2<f32>(), core::Function::kLdexp, arg1, arg2);
+ auto* result = b.Call(ty.vec2<f32>(), core::BuiltinFn::kLdexp, arg1, arg2);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1365,7 +1365,7 @@
auto* func = b.Function("foo", ty.vec3<f16>());
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec3<f16>(), core::Function::kLdexp, arg1, arg2);
+ auto* result = b.Call(ty.vec3<f16>(), core::BuiltinFn::kLdexp, arg1, arg2);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1380,7 +1380,7 @@
auto* func = b.Function("foo", ty.vec3<f32>());
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec3<f32>(), core::Function::kReflect, arg1, arg2);
+ auto* result = b.Call(ty.vec3<f32>(), core::BuiltinFn::kReflect, arg1, arg2);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1395,7 +1395,7 @@
auto* func = b.Function("foo", ty.vec4<f16>());
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f16>(), core::Function::kReflect, arg1, arg2);
+ auto* result = b.Call(ty.vec4<f16>(), core::BuiltinFn::kReflect, arg1, arg2);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1435,15 +1435,15 @@
INSTANTIATE_TEST_SUITE_P(
SpirvWriterTest,
Builtin_3arg,
- testing::Values(BuiltinTestCase{kF32, core::Function::kClamp, "NClamp"},
- BuiltinTestCase{kI32, core::Function::kClamp, "SClamp"},
- BuiltinTestCase{kU32, core::Function::kClamp, "UClamp"},
- BuiltinTestCase{kF32, core::Function::kFma, "Fma"},
- BuiltinTestCase{kF16, core::Function::kFma, "Fma"},
- BuiltinTestCase{kF32, core::Function::kMix, "Mix"},
- BuiltinTestCase{kF16, core::Function::kMix, "Mix"},
- BuiltinTestCase{kF32, core::Function::kSmoothstep, "SmoothStep"},
- BuiltinTestCase{kF16, core::Function::kSmoothstep, "SmoothStep"}));
+ testing::Values(BuiltinTestCase{kF32, core::BuiltinFn::kClamp, "NClamp"},
+ BuiltinTestCase{kI32, core::BuiltinFn::kClamp, "SClamp"},
+ BuiltinTestCase{kU32, core::BuiltinFn::kClamp, "UClamp"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kFma, "Fma"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kFma, "Fma"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kMix, "Mix"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kMix, "Mix"},
+ BuiltinTestCase{kF32, core::BuiltinFn::kSmoothstep, "SmoothStep"},
+ BuiltinTestCase{kF16, core::BuiltinFn::kSmoothstep, "SmoothStep"}));
TEST_F(SpirvWriterTest, Builtin_ExtractBits_Scalar_I32) {
auto* arg = b.FunctionParam("arg", ty.i32());
@@ -1453,7 +1453,7 @@
func->SetParams({arg, offset, count});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kExtractBits, arg, offset, count);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kExtractBits, arg, offset, count);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1470,7 +1470,7 @@
func->SetParams({arg, offset, count});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kExtractBits, arg, offset, count);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kExtractBits, arg, offset, count);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1487,7 +1487,7 @@
func->SetParams({arg, offset, count});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<i32>(), core::Function::kExtractBits, arg, offset, count);
+ auto* result = b.Call(ty.vec4<i32>(), core::BuiltinFn::kExtractBits, arg, offset, count);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1504,7 +1504,7 @@
func->SetParams({arg, offset, count});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec2<u32>(), core::Function::kExtractBits, arg, offset, count);
+ auto* result = b.Call(ty.vec2<u32>(), core::BuiltinFn::kExtractBits, arg, offset, count);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1522,7 +1522,7 @@
func->SetParams({arg, newbits, offset, count});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kInsertBits, arg, newbits, offset, count);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kInsertBits, arg, newbits, offset, count);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1540,7 +1540,7 @@
func->SetParams({arg, newbits, offset, count});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kInsertBits, arg, newbits, offset, count);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kInsertBits, arg, newbits, offset, count);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1559,7 +1559,7 @@
b.Append(func->Block(), [&] {
auto* result =
- b.Call(ty.vec4<i32>(), core::Function::kInsertBits, arg, newbits, offset, count);
+ b.Call(ty.vec4<i32>(), core::BuiltinFn::kInsertBits, arg, newbits, offset, count);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1578,7 +1578,7 @@
b.Append(func->Block(), [&] {
auto* result =
- b.Call(ty.vec2<u32>(), core::Function::kInsertBits, arg, newbits, offset, count);
+ b.Call(ty.vec2<u32>(), core::BuiltinFn::kInsertBits, arg, newbits, offset, count);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1594,7 +1594,7 @@
auto* func = b.Function("foo", ty.vec3<f32>());
func->SetParams({arg1, arg2, arg3});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec3<f32>(), core::Function::kFaceForward, arg1, arg2, arg3);
+ auto* result = b.Call(ty.vec3<f32>(), core::BuiltinFn::kFaceForward, arg1, arg2, arg3);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1610,7 +1610,7 @@
auto* func = b.Function("foo", ty.vec4<f16>());
func->SetParams({arg1, arg2, arg3});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f16>(), core::Function::kFaceForward, arg1, arg2, arg3);
+ auto* result = b.Call(ty.vec4<f16>(), core::BuiltinFn::kFaceForward, arg1, arg2, arg3);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1627,7 +1627,7 @@
func->SetParams({arg1, arg2, factor});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kMix, arg1, arg2, factor);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kMix, arg1, arg2, factor);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1645,7 +1645,7 @@
func->SetParams({arg1, arg2, factor});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kMix, arg1, arg2, factor);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kMix, arg1, arg2, factor);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1662,7 +1662,7 @@
func->SetParams({arg1, arg2, i});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kRefract, arg1, arg2, i);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kRefract, arg1, arg2, i);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1679,7 +1679,7 @@
func->SetParams({arg1, arg2, i});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f16>(), core::Function::kRefract, arg1, arg2, i);
+ auto* result = b.Call(ty.vec4<f16>(), core::BuiltinFn::kRefract, arg1, arg2, i);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1696,7 +1696,7 @@
func->SetParams({argf, argt, cond});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kSelect, argf, argt, cond);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kSelect, argf, argt, cond);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1713,7 +1713,7 @@
func->SetParams({argf, argt, cond});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<i32>(), core::Function::kSelect, argf, argt, cond);
+ auto* result = b.Call(ty.vec4<i32>(), core::BuiltinFn::kSelect, argf, argt, cond);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1730,7 +1730,7 @@
func->SetParams({argf, argt, cond});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<i32>(), core::Function::kSelect, argf, argt, cond);
+ auto* result = b.Call(ty.vec4<i32>(), core::BuiltinFn::kSelect, argf, argt, cond);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1743,7 +1743,7 @@
TEST_F(SpirvWriterTest, Builtin_StorageBarrier) {
auto* func = b.Function("foo", ty.void_());
b.Append(func->Block(), [&] {
- b.Call(ty.void_(), core::Function::kStorageBarrier);
+ b.Call(ty.void_(), core::BuiltinFn::kStorageBarrier);
b.Return(func);
});
@@ -1754,7 +1754,7 @@
TEST_F(SpirvWriterTest, Builtin_TextureBarrier) {
auto* func = b.Function("foo", ty.void_());
b.Append(func->Block(), [&] {
- b.Call(ty.void_(), core::Function::kTextureBarrier);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureBarrier);
b.Return(func);
});
@@ -1765,7 +1765,7 @@
TEST_F(SpirvWriterTest, Builtin_WorkgroupBarrier) {
auto* func = b.Function("foo", ty.void_());
b.Append(func->Block(), [&] {
- b.Call(ty.void_(), core::Function::kWorkgroupBarrier);
+ b.Call(ty.void_(), core::BuiltinFn::kWorkgroupBarrier);
b.Return(func);
});
@@ -1776,7 +1776,7 @@
TEST_F(SpirvWriterTest, Builtin_SubgroupBallot) {
auto* func = b.Function("foo", ty.vec4<u32>());
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<u32>(), core::Function::kSubgroupBallot);
+ auto* result = b.Call(ty.vec4<u32>(), core::BuiltinFn::kSubgroupBallot);
mod.SetName(result, "result");
b.Return(func, result);
});
@@ -1789,7 +1789,7 @@
TEST_F(SpirvWriterTest, Builtin_SubgroupBroadcastValueF32) {
auto* func = b.Function("foo", ty.f32());
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kSubgroupBroadcast, 1_f, 0_u);
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kSubgroupBroadcast, 1_f, 0_u);
mod.SetName(result, "result");
b.Return(func, result);
});
@@ -1802,7 +1802,7 @@
TEST_F(SpirvWriterTest, Builtin_SubgroupBroadcastValueI32) {
auto* func = b.Function("foo", ty.i32());
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kSubgroupBroadcast, 1_i, 0_u);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kSubgroupBroadcast, 1_i, 0_u);
mod.SetName(result, "result");
b.Return(func, result);
});
@@ -1815,7 +1815,7 @@
TEST_F(SpirvWriterTest, Builtin_SubgroupBroadcastValueU32) {
auto* func = b.Function("foo", ty.u32());
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kSubgroupBroadcast, 1_u, 0_u);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kSubgroupBroadcast, 1_u, 0_u);
mod.SetName(result, "result");
b.Return(func, result);
});
@@ -1833,7 +1833,7 @@
auto* func = b.Function("foo", ty.u32());
b.Append(func->Block(), [&] {
auto* ptr = b.Let("ptr", var);
- auto* result = b.Call(ty.u32(), core::Function::kArrayLength, ptr);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kArrayLength, ptr);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1857,7 +1857,7 @@
auto* func = b.Function("foo", ty.u32());
b.Append(func->Block(), [&] {
auto* ptr = b.Let("ptr", b.Access(ty.ptr(storage, arr), var, 2_u));
- auto* result = b.Call(ty.u32(), core::Function::kArrayLength, ptr);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kArrayLength, ptr);
b.Return(func, result);
mod.SetName(result, "result");
});
diff --git a/src/tint/lang/spirv/writer/printer/printer.cc b/src/tint/lang/spirv/writer/printer/printer.cc
index d5b2d92..33da5de 100644
--- a/src/tint/lang/spirv/writer/printer/printer.cc
+++ b/src/tint/lang/spirv/writer/printer/printer.cc
@@ -1140,13 +1140,13 @@
void Printer::EmitCoreBuiltinCall(core::ir::CoreBuiltinCall* builtin) {
auto* result_ty = builtin->Result()->Type();
- if (builtin->Func() == core::Function::kAbs &&
+ if (builtin->Func() == core::BuiltinFn::kAbs &&
result_ty->is_unsigned_integer_scalar_or_vector()) {
// abs() is a no-op for unsigned integers.
values_.Add(builtin->Result(), Value(builtin->Args()[0]));
return;
}
- if ((builtin->Func() == core::Function::kAll || builtin->Func() == core::Function::kAny) &&
+ if ((builtin->Func() == core::BuiltinFn::kAll || builtin->Func() == core::BuiltinFn::kAny) &&
builtin->Args()[0]->Type()->Is<core::type::Bool>()) {
// all() and any() are passthroughs for scalar arguments.
values_.Add(builtin->Result(), Value(builtin->Args()[0]));
@@ -1173,41 +1173,41 @@
// Determine the opcode.
switch (builtin->Func()) {
- case core::Function::kAbs:
+ case core::BuiltinFn::kAbs:
if (result_ty->is_float_scalar_or_vector()) {
glsl_ext_inst(GLSLstd450FAbs);
} else if (result_ty->is_signed_integer_scalar_or_vector()) {
glsl_ext_inst(GLSLstd450SAbs);
}
break;
- case core::Function::kAll:
+ case core::BuiltinFn::kAll:
op = spv::Op::OpAll;
break;
- case core::Function::kAny:
+ case core::BuiltinFn::kAny:
op = spv::Op::OpAny;
break;
- case core::Function::kAcos:
+ case core::BuiltinFn::kAcos:
glsl_ext_inst(GLSLstd450Acos);
break;
- case core::Function::kAcosh:
+ case core::BuiltinFn::kAcosh:
glsl_ext_inst(GLSLstd450Acosh);
break;
- case core::Function::kAsin:
+ case core::BuiltinFn::kAsin:
glsl_ext_inst(GLSLstd450Asin);
break;
- case core::Function::kAsinh:
+ case core::BuiltinFn::kAsinh:
glsl_ext_inst(GLSLstd450Asinh);
break;
- case core::Function::kAtan:
+ case core::BuiltinFn::kAtan:
glsl_ext_inst(GLSLstd450Atan);
break;
- case core::Function::kAtan2:
+ case core::BuiltinFn::kAtan2:
glsl_ext_inst(GLSLstd450Atan2);
break;
- case core::Function::kAtanh:
+ case core::BuiltinFn::kAtanh:
glsl_ext_inst(GLSLstd450Atanh);
break;
- case core::Function::kClamp:
+ case core::BuiltinFn::kClamp:
if (result_ty->is_float_scalar_or_vector()) {
glsl_ext_inst(GLSLstd450NClamp);
} else if (result_ty->is_unsigned_integer_scalar_or_vector()) {
@@ -1216,107 +1216,107 @@
glsl_ext_inst(GLSLstd450SClamp);
}
break;
- case core::Function::kCeil:
+ case core::BuiltinFn::kCeil:
glsl_ext_inst(GLSLstd450Ceil);
break;
- case core::Function::kCos:
+ case core::BuiltinFn::kCos:
glsl_ext_inst(GLSLstd450Cos);
break;
- case core::Function::kCosh:
+ case core::BuiltinFn::kCosh:
glsl_ext_inst(GLSLstd450Cosh);
break;
- case core::Function::kCountOneBits:
+ case core::BuiltinFn::kCountOneBits:
op = spv::Op::OpBitCount;
break;
- case core::Function::kCross:
+ case core::BuiltinFn::kCross:
glsl_ext_inst(GLSLstd450Cross);
break;
- case core::Function::kDegrees:
+ case core::BuiltinFn::kDegrees:
glsl_ext_inst(GLSLstd450Degrees);
break;
- case core::Function::kDeterminant:
+ case core::BuiltinFn::kDeterminant:
glsl_ext_inst(GLSLstd450Determinant);
break;
- case core::Function::kDistance:
+ case core::BuiltinFn::kDistance:
glsl_ext_inst(GLSLstd450Distance);
break;
- case core::Function::kDpdx:
+ case core::BuiltinFn::kDpdx:
op = spv::Op::OpDPdx;
break;
- case core::Function::kDpdxCoarse:
+ case core::BuiltinFn::kDpdxCoarse:
module_.PushCapability(SpvCapabilityDerivativeControl);
op = spv::Op::OpDPdxCoarse;
break;
- case core::Function::kDpdxFine:
+ case core::BuiltinFn::kDpdxFine:
module_.PushCapability(SpvCapabilityDerivativeControl);
op = spv::Op::OpDPdxFine;
break;
- case core::Function::kDpdy:
+ case core::BuiltinFn::kDpdy:
op = spv::Op::OpDPdy;
break;
- case core::Function::kDpdyCoarse:
+ case core::BuiltinFn::kDpdyCoarse:
module_.PushCapability(SpvCapabilityDerivativeControl);
op = spv::Op::OpDPdyCoarse;
break;
- case core::Function::kDpdyFine:
+ case core::BuiltinFn::kDpdyFine:
module_.PushCapability(SpvCapabilityDerivativeControl);
op = spv::Op::OpDPdyFine;
break;
- case core::Function::kExp:
+ case core::BuiltinFn::kExp:
glsl_ext_inst(GLSLstd450Exp);
break;
- case core::Function::kExp2:
+ case core::BuiltinFn::kExp2:
glsl_ext_inst(GLSLstd450Exp2);
break;
- case core::Function::kExtractBits:
+ case core::BuiltinFn::kExtractBits:
op = result_ty->is_signed_integer_scalar_or_vector() ? spv::Op::OpBitFieldSExtract
: spv::Op::OpBitFieldUExtract;
break;
- case core::Function::kFaceForward:
+ case core::BuiltinFn::kFaceForward:
glsl_ext_inst(GLSLstd450FaceForward);
break;
- case core::Function::kFloor:
+ case core::BuiltinFn::kFloor:
glsl_ext_inst(GLSLstd450Floor);
break;
- case core::Function::kFma:
+ case core::BuiltinFn::kFma:
glsl_ext_inst(GLSLstd450Fma);
break;
- case core::Function::kFract:
+ case core::BuiltinFn::kFract:
glsl_ext_inst(GLSLstd450Fract);
break;
- case core::Function::kFrexp:
+ case core::BuiltinFn::kFrexp:
glsl_ext_inst(GLSLstd450FrexpStruct);
break;
- case core::Function::kFwidth:
+ case core::BuiltinFn::kFwidth:
op = spv::Op::OpFwidth;
break;
- case core::Function::kFwidthCoarse:
+ case core::BuiltinFn::kFwidthCoarse:
module_.PushCapability(SpvCapabilityDerivativeControl);
op = spv::Op::OpFwidthCoarse;
break;
- case core::Function::kFwidthFine:
+ case core::BuiltinFn::kFwidthFine:
module_.PushCapability(SpvCapabilityDerivativeControl);
op = spv::Op::OpFwidthFine;
break;
- case core::Function::kInsertBits:
+ case core::BuiltinFn::kInsertBits:
op = spv::Op::OpBitFieldInsert;
break;
- case core::Function::kInverseSqrt:
+ case core::BuiltinFn::kInverseSqrt:
glsl_ext_inst(GLSLstd450InverseSqrt);
break;
- case core::Function::kLdexp:
+ case core::BuiltinFn::kLdexp:
glsl_ext_inst(GLSLstd450Ldexp);
break;
- case core::Function::kLength:
+ case core::BuiltinFn::kLength:
glsl_ext_inst(GLSLstd450Length);
break;
- case core::Function::kLog:
+ case core::BuiltinFn::kLog:
glsl_ext_inst(GLSLstd450Log);
break;
- case core::Function::kLog2:
+ case core::BuiltinFn::kLog2:
glsl_ext_inst(GLSLstd450Log2);
break;
- case core::Function::kMax:
+ case core::BuiltinFn::kMax:
if (result_ty->is_float_scalar_or_vector()) {
glsl_ext_inst(GLSLstd450FMax);
} else if (result_ty->is_signed_integer_scalar_or_vector()) {
@@ -1325,7 +1325,7 @@
glsl_ext_inst(GLSLstd450UMax);
}
break;
- case core::Function::kMin:
+ case core::BuiltinFn::kMin:
if (result_ty->is_float_scalar_or_vector()) {
glsl_ext_inst(GLSLstd450FMin);
} else if (result_ty->is_signed_integer_scalar_or_vector()) {
@@ -1334,74 +1334,74 @@
glsl_ext_inst(GLSLstd450UMin);
}
break;
- case core::Function::kMix:
+ case core::BuiltinFn::kMix:
glsl_ext_inst(GLSLstd450FMix);
break;
- case core::Function::kModf:
+ case core::BuiltinFn::kModf:
glsl_ext_inst(GLSLstd450ModfStruct);
break;
- case core::Function::kNormalize:
+ case core::BuiltinFn::kNormalize:
glsl_ext_inst(GLSLstd450Normalize);
break;
- case core::Function::kPack2X16Float:
+ case core::BuiltinFn::kPack2X16Float:
glsl_ext_inst(GLSLstd450PackHalf2x16);
break;
- case core::Function::kPack2X16Snorm:
+ case core::BuiltinFn::kPack2X16Snorm:
glsl_ext_inst(GLSLstd450PackSnorm2x16);
break;
- case core::Function::kPack2X16Unorm:
+ case core::BuiltinFn::kPack2X16Unorm:
glsl_ext_inst(GLSLstd450PackUnorm2x16);
break;
- case core::Function::kPack4X8Snorm:
+ case core::BuiltinFn::kPack4X8Snorm:
glsl_ext_inst(GLSLstd450PackSnorm4x8);
break;
- case core::Function::kPack4X8Unorm:
+ case core::BuiltinFn::kPack4X8Unorm:
glsl_ext_inst(GLSLstd450PackUnorm4x8);
break;
- case core::Function::kPow:
+ case core::BuiltinFn::kPow:
glsl_ext_inst(GLSLstd450Pow);
break;
- case core::Function::kQuantizeToF16:
+ case core::BuiltinFn::kQuantizeToF16:
op = spv::Op::OpQuantizeToF16;
break;
- case core::Function::kRadians:
+ case core::BuiltinFn::kRadians:
glsl_ext_inst(GLSLstd450Radians);
break;
- case core::Function::kReflect:
+ case core::BuiltinFn::kReflect:
glsl_ext_inst(GLSLstd450Reflect);
break;
- case core::Function::kRefract:
+ case core::BuiltinFn::kRefract:
glsl_ext_inst(GLSLstd450Refract);
break;
- case core::Function::kReverseBits:
+ case core::BuiltinFn::kReverseBits:
op = spv::Op::OpBitReverse;
break;
- case core::Function::kRound:
+ case core::BuiltinFn::kRound:
glsl_ext_inst(GLSLstd450RoundEven);
break;
- case core::Function::kSign:
+ case core::BuiltinFn::kSign:
if (result_ty->is_float_scalar_or_vector()) {
glsl_ext_inst(GLSLstd450FSign);
} else if (result_ty->is_signed_integer_scalar_or_vector()) {
glsl_ext_inst(GLSLstd450SSign);
}
break;
- case core::Function::kSin:
+ case core::BuiltinFn::kSin:
glsl_ext_inst(GLSLstd450Sin);
break;
- case core::Function::kSinh:
+ case core::BuiltinFn::kSinh:
glsl_ext_inst(GLSLstd450Sinh);
break;
- case core::Function::kSmoothstep:
+ case core::BuiltinFn::kSmoothstep:
glsl_ext_inst(GLSLstd450SmoothStep);
break;
- case core::Function::kSqrt:
+ case core::BuiltinFn::kSqrt:
glsl_ext_inst(GLSLstd450Sqrt);
break;
- case core::Function::kStep:
+ case core::BuiltinFn::kStep:
glsl_ext_inst(GLSLstd450Step);
break;
- case core::Function::kStorageBarrier:
+ case core::BuiltinFn::kStorageBarrier:
op = spv::Op::OpControlBarrier;
operands.clear();
operands.push_back(Constant(b_.ConstantValue(u32(spv::Scope::Workgroup))));
@@ -1410,24 +1410,24 @@
Constant(b_.ConstantValue(u32(spv::MemorySemanticsMask::UniformMemory |
spv::MemorySemanticsMask::AcquireRelease))));
break;
- case core::Function::kSubgroupBallot:
+ case core::BuiltinFn::kSubgroupBallot:
module_.PushCapability(SpvCapabilityGroupNonUniformBallot);
op = spv::Op::OpGroupNonUniformBallot;
operands.push_back(Constant(ir_->constant_values.Get(u32(spv::Scope::Subgroup))));
operands.push_back(Constant(ir_->constant_values.Get(true)));
break;
- case core::Function::kSubgroupBroadcast:
+ case core::BuiltinFn::kSubgroupBroadcast:
module_.PushCapability(SpvCapabilityGroupNonUniformBallot);
op = spv::Op::OpGroupNonUniformBroadcast;
operands.push_back(Constant(ir_->constant_values.Get(u32(spv::Scope::Subgroup))));
break;
- case core::Function::kTan:
+ case core::BuiltinFn::kTan:
glsl_ext_inst(GLSLstd450Tan);
break;
- case core::Function::kTanh:
+ case core::BuiltinFn::kTanh:
glsl_ext_inst(GLSLstd450Tanh);
break;
- case core::Function::kTextureBarrier:
+ case core::BuiltinFn::kTextureBarrier:
op = spv::Op::OpControlBarrier;
operands.clear();
operands.push_back(Constant(b_.ConstantValue(u32(spv::Scope::Workgroup))));
@@ -1436,36 +1436,36 @@
Constant(b_.ConstantValue(u32(spv::MemorySemanticsMask::ImageMemory |
spv::MemorySemanticsMask::AcquireRelease))));
break;
- case core::Function::kTextureNumLevels:
+ case core::BuiltinFn::kTextureNumLevels:
module_.PushCapability(SpvCapabilityImageQuery);
op = spv::Op::OpImageQueryLevels;
break;
- case core::Function::kTextureNumSamples:
+ case core::BuiltinFn::kTextureNumSamples:
module_.PushCapability(SpvCapabilityImageQuery);
op = spv::Op::OpImageQuerySamples;
break;
- case core::Function::kTranspose:
+ case core::BuiltinFn::kTranspose:
op = spv::Op::OpTranspose;
break;
- case core::Function::kTrunc:
+ case core::BuiltinFn::kTrunc:
glsl_ext_inst(GLSLstd450Trunc);
break;
- case core::Function::kUnpack2X16Float:
+ case core::BuiltinFn::kUnpack2X16Float:
glsl_ext_inst(GLSLstd450UnpackHalf2x16);
break;
- case core::Function::kUnpack2X16Snorm:
+ case core::BuiltinFn::kUnpack2X16Snorm:
glsl_ext_inst(GLSLstd450UnpackSnorm2x16);
break;
- case core::Function::kUnpack2X16Unorm:
+ case core::BuiltinFn::kUnpack2X16Unorm:
glsl_ext_inst(GLSLstd450UnpackUnorm2x16);
break;
- case core::Function::kUnpack4X8Snorm:
+ case core::BuiltinFn::kUnpack4X8Snorm:
glsl_ext_inst(GLSLstd450UnpackSnorm4x8);
break;
- case core::Function::kUnpack4X8Unorm:
+ case core::BuiltinFn::kUnpack4X8Unorm:
glsl_ext_inst(GLSLstd450UnpackUnorm4x8);
break;
- case core::Function::kWorkgroupBarrier:
+ case core::BuiltinFn::kWorkgroupBarrier:
op = spv::Op::OpControlBarrier;
operands.clear();
operands.push_back(Constant(b_.ConstantValue(u32(spv::Scope::Workgroup))));
diff --git a/src/tint/lang/spirv/writer/raise/builtin_polyfill.cc b/src/tint/lang/spirv/writer/raise/builtin_polyfill.cc
index 5b06c9d..c42146e 100644
--- a/src/tint/lang/spirv/writer/raise/builtin_polyfill.cc
+++ b/src/tint/lang/spirv/writer/raise/builtin_polyfill.cc
@@ -63,35 +63,35 @@
}
if (auto* builtin = inst->As<core::ir::CoreBuiltinCall>()) {
switch (builtin->Func()) {
- case core::Function::kArrayLength:
- case core::Function::kAtomicAdd:
- case core::Function::kAtomicAnd:
- case core::Function::kAtomicCompareExchangeWeak:
- case core::Function::kAtomicExchange:
- case core::Function::kAtomicLoad:
- case core::Function::kAtomicMax:
- case core::Function::kAtomicMin:
- case core::Function::kAtomicOr:
- case core::Function::kAtomicStore:
- case core::Function::kAtomicSub:
- case core::Function::kAtomicXor:
- case core::Function::kDot:
- case core::Function::kSelect:
- case core::Function::kTextureDimensions:
- case core::Function::kTextureGather:
- case core::Function::kTextureGatherCompare:
- case core::Function::kTextureLoad:
- case core::Function::kTextureNumLayers:
- case core::Function::kTextureSample:
- case core::Function::kTextureSampleBias:
- case core::Function::kTextureSampleCompare:
- case core::Function::kTextureSampleCompareLevel:
- case core::Function::kTextureSampleGrad:
- case core::Function::kTextureSampleLevel:
- case core::Function::kTextureStore:
+ case core::BuiltinFn::kArrayLength:
+ case core::BuiltinFn::kAtomicAdd:
+ case core::BuiltinFn::kAtomicAnd:
+ case core::BuiltinFn::kAtomicCompareExchangeWeak:
+ case core::BuiltinFn::kAtomicExchange:
+ case core::BuiltinFn::kAtomicLoad:
+ case core::BuiltinFn::kAtomicMax:
+ case core::BuiltinFn::kAtomicMin:
+ case core::BuiltinFn::kAtomicOr:
+ case core::BuiltinFn::kAtomicStore:
+ case core::BuiltinFn::kAtomicSub:
+ case core::BuiltinFn::kAtomicXor:
+ case core::BuiltinFn::kDot:
+ case core::BuiltinFn::kSelect:
+ case core::BuiltinFn::kTextureDimensions:
+ case core::BuiltinFn::kTextureGather:
+ case core::BuiltinFn::kTextureGatherCompare:
+ case core::BuiltinFn::kTextureLoad:
+ case core::BuiltinFn::kTextureNumLayers:
+ case core::BuiltinFn::kTextureSample:
+ case core::BuiltinFn::kTextureSampleBias:
+ case core::BuiltinFn::kTextureSampleCompare:
+ case core::BuiltinFn::kTextureSampleCompareLevel:
+ case core::BuiltinFn::kTextureSampleGrad:
+ case core::BuiltinFn::kTextureSampleLevel:
+ case core::BuiltinFn::kTextureStore:
worklist.Push(builtin);
break;
- case core::Function::kQuantizeToF16:
+ case core::BuiltinFn::kQuantizeToF16:
if (builtin->Result()->Type()->Is<core::type::Vector>()) {
worklist.Push(builtin);
}
@@ -106,53 +106,53 @@
for (auto* builtin : worklist) {
core::ir::Value* replacement = nullptr;
switch (builtin->Func()) {
- case core::Function::kArrayLength:
+ case core::BuiltinFn::kArrayLength:
replacement = ArrayLength(builtin);
break;
- case core::Function::kAtomicAdd:
- case core::Function::kAtomicAnd:
- case core::Function::kAtomicCompareExchangeWeak:
- case core::Function::kAtomicExchange:
- case core::Function::kAtomicLoad:
- case core::Function::kAtomicMax:
- case core::Function::kAtomicMin:
- case core::Function::kAtomicOr:
- case core::Function::kAtomicStore:
- case core::Function::kAtomicSub:
- case core::Function::kAtomicXor:
+ case core::BuiltinFn::kAtomicAdd:
+ case core::BuiltinFn::kAtomicAnd:
+ case core::BuiltinFn::kAtomicCompareExchangeWeak:
+ case core::BuiltinFn::kAtomicExchange:
+ case core::BuiltinFn::kAtomicLoad:
+ case core::BuiltinFn::kAtomicMax:
+ case core::BuiltinFn::kAtomicMin:
+ case core::BuiltinFn::kAtomicOr:
+ case core::BuiltinFn::kAtomicStore:
+ case core::BuiltinFn::kAtomicSub:
+ case core::BuiltinFn::kAtomicXor:
replacement = Atomic(builtin);
break;
- case core::Function::kDot:
+ case core::BuiltinFn::kDot:
replacement = Dot(builtin);
break;
- case core::Function::kSelect:
+ case core::BuiltinFn::kSelect:
replacement = Select(builtin);
break;
- case core::Function::kTextureDimensions:
+ case core::BuiltinFn::kTextureDimensions:
replacement = TextureDimensions(builtin);
break;
- case core::Function::kTextureGather:
- case core::Function::kTextureGatherCompare:
+ case core::BuiltinFn::kTextureGather:
+ case core::BuiltinFn::kTextureGatherCompare:
replacement = TextureGather(builtin);
break;
- case core::Function::kTextureLoad:
+ case core::BuiltinFn::kTextureLoad:
replacement = TextureLoad(builtin);
break;
- case core::Function::kTextureNumLayers:
+ case core::BuiltinFn::kTextureNumLayers:
replacement = TextureNumLayers(builtin);
break;
- case core::Function::kTextureSample:
- case core::Function::kTextureSampleBias:
- case core::Function::kTextureSampleCompare:
- case core::Function::kTextureSampleCompareLevel:
- case core::Function::kTextureSampleGrad:
- case core::Function::kTextureSampleLevel:
+ case core::BuiltinFn::kTextureSample:
+ case core::BuiltinFn::kTextureSampleBias:
+ case core::BuiltinFn::kTextureSampleCompare:
+ case core::BuiltinFn::kTextureSampleCompareLevel:
+ case core::BuiltinFn::kTextureSampleGrad:
+ case core::BuiltinFn::kTextureSampleLevel:
replacement = TextureSample(builtin);
break;
- case core::Function::kTextureStore:
+ case core::BuiltinFn::kTextureStore:
replacement = TextureStore(builtin);
break;
- case core::Function::kQuantizeToF16:
+ case core::BuiltinFn::kQuantizeToF16:
replacement = QuantizeToF16Vec(builtin);
break;
default:
@@ -231,15 +231,15 @@
// Create the replacement call instruction.
core::ir::Call* call = nullptr;
switch (builtin->Func()) {
- case core::Function::kAtomicAdd:
+ case core::BuiltinFn::kAtomicAdd:
call = build(result_ty, spirv::ir::Function::kAtomicIadd);
call->AppendArg(builtin->Args()[1]);
break;
- case core::Function::kAtomicAnd:
+ case core::BuiltinFn::kAtomicAnd:
call = build(result_ty, spirv::ir::Function::kAtomicAnd);
call->AppendArg(builtin->Args()[1]);
break;
- case core::Function::kAtomicCompareExchangeWeak: {
+ case core::BuiltinFn::kAtomicCompareExchangeWeak: {
auto* cmp = builtin->Args()[1];
auto* value = builtin->Args()[2];
auto* int_ty = value->Type();
@@ -260,18 +260,18 @@
Vector{original, compare->Result()});
break;
}
- case core::Function::kAtomicExchange:
+ case core::BuiltinFn::kAtomicExchange:
call = build(result_ty, spirv::ir::Function::kAtomicExchange);
call->AppendArg(builtin->Args()[1]);
break;
- case core::Function::kAtomicLoad:
+ case core::BuiltinFn::kAtomicLoad:
call = build(result_ty, spirv::ir::Function::kAtomicLoad);
break;
- case core::Function::kAtomicOr:
+ case core::BuiltinFn::kAtomicOr:
call = build(result_ty, spirv::ir::Function::kAtomicOr);
call->AppendArg(builtin->Args()[1]);
break;
- case core::Function::kAtomicMax:
+ case core::BuiltinFn::kAtomicMax:
if (result_ty->is_signed_integer_scalar()) {
call = build(result_ty, spirv::ir::Function::kAtomicSmax);
} else {
@@ -279,7 +279,7 @@
}
call->AppendArg(builtin->Args()[1]);
break;
- case core::Function::kAtomicMin:
+ case core::BuiltinFn::kAtomicMin:
if (result_ty->is_signed_integer_scalar()) {
call = build(result_ty, spirv::ir::Function::kAtomicSmin);
} else {
@@ -287,15 +287,15 @@
}
call->AppendArg(builtin->Args()[1]);
break;
- case core::Function::kAtomicStore:
+ case core::BuiltinFn::kAtomicStore:
call = build(result_ty, spirv::ir::Function::kAtomicStore);
call->AppendArg(builtin->Args()[1]);
break;
- case core::Function::kAtomicSub:
+ case core::BuiltinFn::kAtomicSub:
call = build(result_ty, spirv::ir::Function::kAtomicIsub);
call->AppendArg(builtin->Args()[1]);
break;
- case core::Function::kAtomicXor:
+ case core::BuiltinFn::kAtomicXor:
call = build(result_ty, spirv::ir::Function::kAtomicXor);
call->AppendArg(builtin->Args()[1]);
break;
@@ -495,33 +495,33 @@
core::ir::Value* depth = nullptr;
ImageOperands operands;
switch (builtin->Func()) {
- case core::Function::kTextureSample:
+ case core::BuiltinFn::kTextureSample:
intrinsic = spirv::ir::Intrinsic::kImageSampleImplicitLod;
operands.offset = next_arg();
break;
- case core::Function::kTextureSampleBias:
+ case core::BuiltinFn::kTextureSampleBias:
intrinsic = spirv::ir::Intrinsic::kImageSampleImplicitLod;
operands.bias = next_arg();
operands.offset = next_arg();
break;
- case core::Function::kTextureSampleCompare:
+ case core::BuiltinFn::kTextureSampleCompare:
intrinsic = spirv::ir::Intrinsic::kImageSampleDrefImplicitLod;
depth = next_arg();
operands.offset = next_arg();
break;
- case core::Function::kTextureSampleCompareLevel:
+ case core::BuiltinFn::kTextureSampleCompareLevel:
intrinsic = spirv::ir::Intrinsic::kImageSampleDrefExplicitLod;
depth = next_arg();
operands.lod = b.Constant(0_f);
operands.offset = next_arg();
break;
- case core::Function::kTextureSampleGrad:
+ case core::BuiltinFn::kTextureSampleGrad:
intrinsic = spirv::ir::Intrinsic::kImageSampleExplicitLod;
operands.ddx = next_arg();
operands.ddy = next_arg();
operands.offset = next_arg();
break;
- case core::Function::kTextureSampleLevel:
+ case core::BuiltinFn::kTextureSampleLevel:
intrinsic = spirv::ir::Intrinsic::kImageSampleExplicitLod;
operands.lod = next_arg();
operands.offset = next_arg();
@@ -603,11 +603,11 @@
core::ir::Value* depth = nullptr;
ImageOperands operands;
switch (builtin->Func()) {
- case core::Function::kTextureGather:
+ case core::BuiltinFn::kTextureGather:
function = spirv::ir::Function::kImageGather;
operands.offset = next_arg();
break;
- case core::Function::kTextureGatherCompare:
+ case core::BuiltinFn::kTextureGatherCompare:
function = spirv::ir::Function::kImageDrefGather;
depth = next_arg();
operands.offset = next_arg();
@@ -839,7 +839,7 @@
Vector<core::ir::Value*, 4> args;
for (uint32_t i = 0; i < vec->Width(); i++) {
auto* el = b.Access(ty.f32(), arg, u32(i));
- auto* scalar_call = b.Call(ty.f32(), core::Function::kQuantizeToF16, el);
+ auto* scalar_call = b.Call(ty.f32(), core::BuiltinFn::kQuantizeToF16, el);
args.Push(scalar_call->Result());
el->InsertBefore(builtin);
scalar_call->InsertBefore(builtin);
diff --git a/src/tint/lang/spirv/writer/raise/builtin_polyfill_test.cc b/src/tint/lang/spirv/writer/raise/builtin_polyfill_test.cc
index d20393f..5bd292a 100644
--- a/src/tint/lang/spirv/writer/raise/builtin_polyfill_test.cc
+++ b/src/tint/lang/spirv/writer/raise/builtin_polyfill_test.cc
@@ -47,7 +47,7 @@
auto* func = b.Function("foo", ty.u32());
b.Append(func->Block(), [&] {
auto* access = b.Access(ty.ptr(storage, arr), var, 2_u);
- auto* result = b.Call(ty.u32(), core::Function::kArrayLength, access);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kArrayLength, access);
b.Return(func, result);
});
@@ -113,7 +113,7 @@
auto* let_a = b.Let("a", var);
auto* let_b = b.Let("b", let_a);
auto* access = b.Access(ty.ptr(storage, arr), let_b, 2_u);
- auto* result = b.Call(ty.u32(), core::Function::kArrayLength, access);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kArrayLength, access);
b.Return(func, result);
});
@@ -183,7 +183,7 @@
auto* access = b.Access(ty.ptr(storage, arr), var, 2_u);
auto* let_a = b.Let("a", access);
auto* let_b = b.Let("b", let_a);
- auto* result = b.Call(ty.u32(), core::Function::kArrayLength, let_b);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kArrayLength, let_b);
b.Return(func, result);
});
@@ -247,7 +247,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicAdd, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicAdd, var, arg1);
b.Return(func, result);
});
@@ -291,7 +291,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicAdd, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicAdd, var, arg1);
b.Return(func, result);
});
@@ -335,7 +335,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicAnd, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicAnd, var, arg1);
b.Return(func, result);
});
@@ -381,7 +381,8 @@
b.Append(func->Block(), [&] {
auto* result_ty = core::type::CreateAtomicCompareExchangeResult(ty, mod.symbols, ty.i32());
- auto* result = b.Call(result_ty, core::Function::kAtomicCompareExchangeWeak, var, cmp, val);
+ auto* result =
+ b.Call(result_ty, core::BuiltinFn::kAtomicCompareExchangeWeak, var, cmp, val);
b.Return(func, b.Access(ty.i32(), result, 0_u));
});
@@ -439,7 +440,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicExchange, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicExchange, var, arg1);
b.Return(func, result);
});
@@ -481,7 +482,7 @@
auto* func = b.Function("foo", ty.i32());
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicLoad, var);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicLoad, var);
b.Return(func, result);
});
@@ -525,7 +526,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicMax, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicMax, var, arg1);
b.Return(func, result);
});
@@ -569,7 +570,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kAtomicMax, var, arg1);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kAtomicMax, var, arg1);
b.Return(func, result);
});
@@ -613,7 +614,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicMin, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicMin, var, arg1);
b.Return(func, result);
});
@@ -657,7 +658,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kAtomicMin, var, arg1);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kAtomicMin, var, arg1);
b.Return(func, result);
});
@@ -701,7 +702,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicOr, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicOr, var, arg1);
b.Return(func, result);
});
@@ -745,7 +746,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- b.Call(ty.void_(), core::Function::kAtomicStore, var, arg1);
+ b.Call(ty.void_(), core::BuiltinFn::kAtomicStore, var, arg1);
b.Return(func);
});
@@ -789,7 +790,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicSub, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicSub, var, arg1);
b.Return(func, result);
});
@@ -833,7 +834,7 @@
func->SetParams({arg1});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kAtomicXor, var, arg1);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kAtomicXor, var, arg1);
b.Return(func, result);
});
@@ -876,7 +877,7 @@
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kDot, arg1, arg2);
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kDot, arg1, arg2);
b.Return(func, result);
});
@@ -911,7 +912,7 @@
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kDot, arg1, arg2);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kDot, arg1, arg2);
b.Return(func, result);
});
@@ -952,7 +953,7 @@
func->SetParams({arg1, arg2});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kDot, arg1, arg2);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kDot, arg1, arg2);
b.Return(func, result);
});
@@ -1002,7 +1003,7 @@
func->SetParams({argf, argt, cond});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.i32(), core::Function::kSelect, argf, argt, cond);
+ auto* result = b.Call(ty.i32(), core::BuiltinFn::kSelect, argf, argt, cond);
b.Return(func, result);
});
@@ -1038,7 +1039,7 @@
func->SetParams({argf, argt, cond});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<i32>(), core::Function::kSelect, argf, argt, cond);
+ auto* result = b.Call(ty.vec4<i32>(), core::BuiltinFn::kSelect, argf, argt, cond);
b.Return(func, result);
});
@@ -1074,7 +1075,7 @@
func->SetParams({argf, argt, cond});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<i32>(), core::Function::kSelect, argf, argt, cond);
+ auto* result = b.Call(ty.vec4<i32>(), core::BuiltinFn::kSelect, argf, argt, cond);
b.Return(func, result);
});
@@ -1112,7 +1113,7 @@
func->SetParams({t, coords, lod});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, t, coords, lod);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, t, coords, lod);
b.Return(func, result);
});
@@ -1151,7 +1152,7 @@
b.Append(func->Block(), [&] {
auto* result =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, t, coords, array_idx, lod);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, t, coords, array_idx, lod);
b.Return(func, result);
});
@@ -1191,7 +1192,7 @@
b.Append(func->Block(), [&] {
auto* result =
- b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, t, coords, array_idx, lod);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, t, coords, array_idx, lod);
b.Return(func, result);
});
@@ -1230,7 +1231,7 @@
func->SetParams({t, coords, sample_idx});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, t, coords, sample_idx);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, t, coords, sample_idx);
b.Return(func, result);
});
@@ -1267,7 +1268,7 @@
func->SetParams({t, coords, lod});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kTextureLoad, t, coords, lod);
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kTextureLoad, t, coords, lod);
b.Return(func, result);
});
@@ -1305,7 +1306,7 @@
func->SetParams({t, s, coords});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSample, t, s, coords);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSample, t, s, coords);
b.Return(func, result);
});
@@ -1343,7 +1344,7 @@
func->SetParams({t, s, coords});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSample, t, s, coords);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSample, t, s, coords);
b.Return(func, result);
});
@@ -1381,7 +1382,7 @@
func->SetParams({t, s, coords});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSample, t, s, coords,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSample, t, s, coords,
b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -1421,7 +1422,7 @@
func->SetParams({t, s, coords, array_idx});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSample, t, s, coords,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSample, t, s, coords,
array_idx, b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -1464,7 +1465,7 @@
b.Append(func->Block(), [&] {
auto* result =
- b.Call(ty.vec4<f32>(), core::Function::kTextureSampleBias, t, s, coords, bias);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleBias, t, s, coords, bias);
b.Return(func, result);
});
@@ -1503,7 +1504,7 @@
func->SetParams({t, s, coords, bias});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSampleBias, t, s, coords,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleBias, t, s, coords,
bias, b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -1544,7 +1545,7 @@
func->SetParams({t, s, coords, array_idx, bias});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSampleBias, t, s, coords,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleBias, t, s, coords,
array_idx, bias, b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -1586,7 +1587,7 @@
func->SetParams({t, s, coords, dref});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kTextureSampleCompare, t, s, coords, dref);
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kTextureSampleCompare, t, s, coords, dref);
b.Return(func, result);
});
@@ -1625,7 +1626,7 @@
func->SetParams({t, s, coords, dref});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kTextureSampleCompare, t, s, coords, dref,
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kTextureSampleCompare, t, s, coords, dref,
b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -1666,7 +1667,7 @@
func->SetParams({t, s, coords, array_idx, bias});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kTextureSampleCompare, t, s, coords,
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kTextureSampleCompare, t, s, coords,
array_idx, bias, b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -1709,7 +1710,7 @@
b.Append(func->Block(), [&] {
auto* result =
- b.Call(ty.f32(), core::Function::kTextureSampleCompareLevel, t, s, coords, dref);
+ b.Call(ty.f32(), core::BuiltinFn::kTextureSampleCompareLevel, t, s, coords, dref);
b.Return(func, result);
});
@@ -1748,7 +1749,7 @@
func->SetParams({t, s, coords, dref});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kTextureSampleCompareLevel, t, s, coords,
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kTextureSampleCompareLevel, t, s, coords,
dref, b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -1789,7 +1790,7 @@
func->SetParams({t, s, coords, array_idx, bias});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kTextureSampleCompareLevel, t, s, coords,
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kTextureSampleCompareLevel, t, s, coords,
array_idx, bias, b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -1833,7 +1834,7 @@
b.Append(func->Block(), [&] {
auto* result =
- b.Call(ty.vec4<f32>(), core::Function::kTextureSampleGrad, t, s, coords, ddx, ddy);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleGrad, t, s, coords, ddx, ddy);
b.Return(func, result);
});
@@ -1873,8 +1874,8 @@
func->SetParams({t, s, coords, ddx, ddy});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSampleGrad, t, s, coords, ddx,
- ddy, b.Splat(ty.vec2<i32>(), 1_i, 2));
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleGrad, t, s, coords,
+ ddx, ddy, b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -1915,7 +1916,7 @@
func->SetParams({t, s, coords, array_idx, ddx, ddy});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSampleGrad, t, s, coords,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleGrad, t, s, coords,
array_idx, ddx, ddy, b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -1958,7 +1959,7 @@
b.Append(func->Block(), [&] {
auto* result =
- b.Call(ty.vec4<f32>(), core::Function::kTextureSampleLevel, t, s, coords, lod);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleLevel, t, s, coords, lod);
b.Return(func, result);
});
@@ -1997,7 +1998,7 @@
func->SetParams({t, s, coords, lod});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSampleLevel, t, s, coords,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleLevel, t, s, coords,
lod, b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -2038,7 +2039,7 @@
func->SetParams({t, s, coords, array_idx, lod});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSampleLevel, t, s, coords,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleLevel, t, s, coords,
array_idx, lod, b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -2081,7 +2082,7 @@
b.Append(func->Block(), [&] {
auto* result =
- b.Call(ty.vec4<f32>(), core::Function::kTextureGather, component, t, s, coords);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureGather, component, t, s, coords);
b.Return(func, result);
});
@@ -2120,7 +2121,7 @@
func->SetParams({t, s, component, coords});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureGather, component, t, s,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureGather, component, t, s,
coords, b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -2161,7 +2162,7 @@
func->SetParams({t, s, component, coords, array_idx});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureGather, component, t, s,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureGather, component, t, s,
coords, array_idx, b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -2202,7 +2203,7 @@
func->SetParams({t, s, coords});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureGather, t, s, coords);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureGather, t, s, coords);
b.Return(func, result);
});
@@ -2242,7 +2243,7 @@
b.Append(func->Block(), [&] {
auto* result =
- b.Call(ty.vec4<f32>(), core::Function::kTextureGatherCompare, t, s, coords, depth);
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureGatherCompare, t, s, coords, depth);
b.Return(func, result);
});
@@ -2281,7 +2282,7 @@
func->SetParams({t, s, coords, depth});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureGatherCompare, t, s, coords,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureGatherCompare, t, s, coords,
depth, b.Splat(ty.vec2<i32>(), 1_i, 2));
b.Return(func, result);
});
@@ -2322,7 +2323,7 @@
func->SetParams({t, s, coords, array_idx, depth});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureGatherCompare, t, s, coords,
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureGatherCompare, t, s, coords,
array_idx, depth);
b.Return(func, result);
});
@@ -2366,7 +2367,7 @@
func->SetParams({t, coords, texel});
b.Append(func->Block(), [&] {
- b.Call(ty.void_(), core::Function::kTextureStore, t, coords, texel);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, t, coords, texel);
b.Return(func);
});
@@ -2407,7 +2408,7 @@
func->SetParams({t, coords, array_idx, texel});
b.Append(func->Block(), [&] {
- b.Call(ty.void_(), core::Function::kTextureStore, t, coords, array_idx, texel);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, t, coords, array_idx, texel);
b.Return(func);
});
@@ -2449,7 +2450,7 @@
func->SetParams({t, coords, array_idx, texel});
b.Append(func->Block(), [&] {
- b.Call(ty.void_(), core::Function::kTextureStore, t, coords, array_idx, texel);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, t, coords, array_idx, texel);
b.Return(func);
});
@@ -2486,7 +2487,7 @@
func->SetParams({t});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec2<u32>(), core::Function::kTextureDimensions, t);
+ auto* result = b.Call(ty.vec2<u32>(), core::BuiltinFn::kTextureDimensions, t);
b.Return(func, result);
});
@@ -2522,7 +2523,7 @@
func->SetParams({t, lod});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec2<u32>(), core::Function::kTextureDimensions, t, lod);
+ auto* result = b.Call(ty.vec2<u32>(), core::BuiltinFn::kTextureDimensions, t, lod);
b.Return(func, result);
});
@@ -2557,7 +2558,7 @@
func->SetParams({t});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec2<u32>(), core::Function::kTextureDimensions, t);
+ auto* result = b.Call(ty.vec2<u32>(), core::BuiltinFn::kTextureDimensions, t);
b.Return(func, result);
});
@@ -2593,7 +2594,7 @@
func->SetParams({t});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec2<u32>(), core::Function::kTextureDimensions, t);
+ auto* result = b.Call(ty.vec2<u32>(), core::BuiltinFn::kTextureDimensions, t);
b.Return(func, result);
});
@@ -2628,7 +2629,7 @@
func->SetParams({t});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kTextureNumLayers, t);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kTextureNumLayers, t);
b.Return(func, result);
});
@@ -2664,7 +2665,7 @@
func->SetParams({t});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kTextureNumLayers, t);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kTextureNumLayers, t);
b.Return(func, result);
});
@@ -2700,7 +2701,7 @@
func->SetParams({t});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kTextureNumLayers, t);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kTextureNumLayers, t);
b.Return(func, result);
});
@@ -2736,7 +2737,7 @@
func->SetParams({t});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kTextureNumLayers, t);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kTextureNumLayers, t);
b.Return(func, result);
});
@@ -2775,7 +2776,7 @@
func->SetParams({t});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.u32(), core::Function::kTextureNumLayers, t);
+ auto* result = b.Call(ty.u32(), core::BuiltinFn::kTextureNumLayers, t);
b.Return(func, result);
});
@@ -2810,7 +2811,7 @@
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.f32(), core::Function::kQuantizeToF16, arg);
+ auto* result = b.Call(ty.f32(), core::BuiltinFn::kQuantizeToF16, arg);
b.Return(func, result);
});
@@ -2837,7 +2838,7 @@
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kQuantizeToF16, arg);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kQuantizeToF16, arg);
b.Return(func, result);
});
diff --git a/src/tint/lang/spirv/writer/raise/expand_implicit_splats.cc b/src/tint/lang/spirv/writer/raise/expand_implicit_splats.cc
index c222b71..cedf944 100644
--- a/src/tint/lang/spirv/writer/raise/expand_implicit_splats.cc
+++ b/src/tint/lang/spirv/writer/raise/expand_implicit_splats.cc
@@ -62,7 +62,7 @@
} else if (auto* builtin = inst->As<core::ir::CoreBuiltinCall>()) {
// A mix builtin call that mixes vector and scalar operands needs to have the scalar
// operand replaced with an explicit vector constructor.
- if (builtin->Func() == core::Function::kMix) {
+ if (builtin->Func() == core::BuiltinFn::kMix) {
if (builtin->Result()->Type()->Is<core::type::Vector>()) {
if (builtin->Args()[2]->Type()->Is<core::type::Scalar>()) {
builtin_worklist.Push(builtin);
@@ -118,7 +118,7 @@
// Replace scalar arguments to builtin calls that produce vectors.
for (auto* builtin : builtin_worklist) {
switch (builtin->Func()) {
- case core::Function::kMix:
+ case core::BuiltinFn::kMix:
// Expand the scalar argument into an explicitly constructed vector.
expand_operand(builtin, core::ir::CoreBuiltinCall::kArgsOperandOffset + 2);
break;
diff --git a/src/tint/lang/spirv/writer/raise/expand_implicit_splats_test.cc b/src/tint/lang/spirv/writer/raise/expand_implicit_splats_test.cc
index 9111271..79b83aa 100644
--- a/src/tint/lang/spirv/writer/raise/expand_implicit_splats_test.cc
+++ b/src/tint/lang/spirv/writer/raise/expand_implicit_splats_test.cc
@@ -639,7 +639,7 @@
func->SetParams({arg1, arg2, factor});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kMix, arg1, arg2, factor);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kMix, arg1, arg2, factor);
b.Return(func, result);
});
diff --git a/src/tint/lang/spirv/writer/raise/shader_io.cc b/src/tint/lang/spirv/writer/raise/shader_io.cc
index 0c7a3b2..d4c60ed 100644
--- a/src/tint/lang/spirv/writer/raise/shader_io.cc
+++ b/src/tint/lang/spirv/writer/raise/shader_io.cc
@@ -186,7 +186,7 @@
auto* frag_depth_min = builder.Access(ty.f32(), args, 0_u);
auto* frag_depth_max = builder.Access(ty.f32(), args, 1_u);
return builder
- .Call(ty.f32(), core::Function::kClamp, frag_depth, frag_depth_min, frag_depth_max)
+ .Call(ty.f32(), core::BuiltinFn::kClamp, frag_depth, frag_depth_min, frag_depth_max)
->Result();
}
diff --git a/src/tint/lang/spirv/writer/texture_builtin_test.cc b/src/tint/lang/spirv/writer/texture_builtin_test.cc
index c77274b..db4f44f 100644
--- a/src/tint/lang/spirv/writer/texture_builtin_test.cc
+++ b/src/tint/lang/spirv/writer/texture_builtin_test.cc
@@ -12,8 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+#include "src/tint/lang/core/builtin_fn.h"
#include "src/tint/lang/core/fluent_types.h"
-#include "src/tint/lang/core/function.h"
#include "src/tint/lang/core/type/depth_multisampled_texture.h"
#include "src/tint/lang/spirv/writer/common/helper_test.h"
@@ -130,11 +130,11 @@
return nullptr;
}
- void Run(enum core::Function function, SamplerUsage sampler) {
+ void Run(enum core::BuiltinFn function, SamplerUsage sampler) {
auto params = GetParam();
auto* result_ty = MakeScalarType(params.result.type);
- if (function == core::Function::kTextureStore) {
+ if (function == core::BuiltinFn::kTextureStore) {
result_ty = ty.void_();
}
if (params.result.width > 1) {
@@ -162,7 +162,7 @@
uint32_t arg_value = 1;
Vector<core::ir::Value*, 4> args;
- if (function == core::Function::kTextureGather &&
+ if (function == core::BuiltinFn::kTextureGather &&
params.texture_type != kDepthTexture) {
// Special case for textureGather, which has a component argument first.
auto* component = MakeScalarValue(kU32, arg_value++);
@@ -205,7 +205,7 @@
////////////////////////////////////////////////////////////////
using TextureSample = TextureBuiltinTest;
TEST_P(TextureSample, Emit) {
- Run(core::Function::kTextureSample, kSampler);
+ Run(core::BuiltinFn::kTextureSample, kSampler);
}
INSTANTIATE_TEST_SUITE_P(
SpirvWriterTest,
@@ -400,7 +400,7 @@
////////////////////////////////////////////////////////////////
using TextureSampleBias = TextureBuiltinTest;
TEST_P(TextureSampleBias, Emit) {
- Run(core::Function::kTextureSampleBias, kSampler);
+ Run(core::BuiltinFn::kTextureSampleBias, kSampler);
}
INSTANTIATE_TEST_SUITE_P(
SpirvWriterTest,
@@ -507,7 +507,7 @@
////////////////////////////////////////////////////////////////
using TextureSampleGrad = TextureBuiltinTest;
TEST_P(TextureSampleGrad, Emit) {
- Run(core::Function::kTextureSampleGrad, kSampler);
+ Run(core::BuiltinFn::kTextureSampleGrad, kSampler);
}
INSTANTIATE_TEST_SUITE_P(
SpirvWriterTest,
@@ -618,7 +618,7 @@
////////////////////////////////////////////////////////////////
using TextureSampleLevel = TextureBuiltinTest;
TEST_P(TextureSampleLevel, Emit) {
- Run(core::Function::kTextureSampleLevel, kSampler);
+ Run(core::BuiltinFn::kTextureSampleLevel, kSampler);
}
INSTANTIATE_TEST_SUITE_P(
SpirvWriterTest,
@@ -808,7 +808,7 @@
////////////////////////////////////////////////////////////////
using TextureSampleCompare = TextureBuiltinTest;
TEST_P(TextureSampleCompare, Emit) {
- Run(core::Function::kTextureSampleCompare, kComparisonSampler);
+ Run(core::BuiltinFn::kTextureSampleCompare, kComparisonSampler);
}
INSTANTIATE_TEST_SUITE_P(
SpirvWriterTest,
@@ -893,7 +893,7 @@
////////////////////////////////////////////////////////////////
using TextureSampleCompareLevel = TextureBuiltinTest;
TEST_P(TextureSampleCompareLevel, Emit) {
- Run(core::Function::kTextureSampleCompareLevel, kComparisonSampler);
+ Run(core::BuiltinFn::kTextureSampleCompareLevel, kComparisonSampler);
}
INSTANTIATE_TEST_SUITE_P(
SpirvWriterTest,
@@ -983,7 +983,7 @@
////////////////////////////////////////////////////////////////
using TextureGather = TextureBuiltinTest;
TEST_P(TextureGather, Emit) {
- Run(core::Function::kTextureGather, kSampler);
+ Run(core::BuiltinFn::kTextureGather, kSampler);
}
INSTANTIATE_TEST_SUITE_P(
SpirvWriterTest,
@@ -1164,7 +1164,7 @@
////////////////////////////////////////////////////////////////
using TextureGatherCompare = TextureBuiltinTest;
TEST_P(TextureGatherCompare, Emit) {
- Run(core::Function::kTextureGatherCompare, kComparisonSampler);
+ Run(core::BuiltinFn::kTextureGatherCompare, kComparisonSampler);
}
INSTANTIATE_TEST_SUITE_P(
SpirvWriterTest,
@@ -1249,7 +1249,7 @@
////////////////////////////////////////////////////////////////
using TextureLoad = TextureBuiltinTest;
TEST_P(TextureLoad, Emit) {
- Run(core::Function::kTextureLoad, kNoSampler);
+ Run(core::BuiltinFn::kTextureLoad, kNoSampler);
}
INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
TextureLoad,
@@ -1368,7 +1368,7 @@
////////////////////////////////////////////////////////////////
using TextureStore = TextureBuiltinTest;
TEST_P(TextureStore, Emit) {
- Run(core::Function::kTextureStore, kNoSampler);
+ Run(core::BuiltinFn::kTextureStore, kNoSampler);
}
INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
TextureStore,
@@ -1443,7 +1443,7 @@
////////////////////////////////////////////////////////////////
using TextureDimensions = TextureBuiltinTest;
TEST_P(TextureDimensions, Emit) {
- Run(core::Function::kTextureDimensions, kNoSampler);
+ Run(core::BuiltinFn::kTextureDimensions, kNoSampler);
}
INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
TextureDimensions,
@@ -1693,7 +1693,7 @@
////////////////////////////////////////////////////////////////
using TextureNumLayers = TextureBuiltinTest;
TEST_P(TextureNumLayers, Emit) {
- Run(core::Function::kTextureNumLayers, kNoSampler);
+ Run(core::BuiltinFn::kTextureNumLayers, kNoSampler);
}
INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
TextureNumLayers,
@@ -1760,7 +1760,7 @@
////////////////////////////////////////////////////////////////
using TextureNumLevels = TextureBuiltinTest;
TEST_P(TextureNumLevels, Emit) {
- Run(core::Function::kTextureNumLevels, kNoSampler);
+ Run(core::BuiltinFn::kTextureNumLevels, kNoSampler);
}
INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
TextureNumLevels,
@@ -1852,7 +1852,7 @@
////////////////////////////////////////////////////////////////
using TextureNumSamples = TextureBuiltinTest;
TEST_P(TextureNumSamples, Emit) {
- Run(core::Function::kTextureNumSamples, kNoSampler);
+ Run(core::BuiltinFn::kTextureNumSamples, kNoSampler);
}
INSTANTIATE_TEST_SUITE_P(SpirvWriterTest,
TextureNumSamples,
@@ -1891,7 +1891,7 @@
auto* func = b.Function("foo", ty.vec4<f32>());
func->SetParams(args);
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureSampleBaseClampToEdge, args);
+ auto* result = b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureSampleBaseClampToEdge, args);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -1926,7 +1926,7 @@
auto* func = b.Function("foo", ty.void_());
func->SetParams({texture, coords, value});
b.Append(func->Block(), [&] {
- b.Call(ty.void_(), core::Function::kTextureStore, texture, coords, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, texture, coords, value);
b.Return(func);
});
@@ -1952,7 +1952,7 @@
auto* func = b.Function("foo", ty.vec2<u32>());
func->SetParams({texture, level});
b.Append(func->Block(), [&] {
- auto* dims = b.Call(ty.vec2<u32>(), core::Function::kTextureDimensions, texture, level);
+ auto* dims = b.Call(ty.vec2<u32>(), core::BuiltinFn::kTextureDimensions, texture, level);
b.Return(func, dims);
mod.SetName(dims, "dims");
});
@@ -1977,7 +1977,8 @@
auto* func = b.Function("foo", ty.vec4<f32>());
func->SetParams({texture, coords, level});
b.Append(func->Block(), [&] {
- auto* result = b.Call(ty.vec4<f32>(), core::Function::kTextureLoad, texture, coords, level);
+ auto* result =
+ b.Call(ty.vec4<f32>(), core::BuiltinFn::kTextureLoad, texture, coords, level);
b.Return(func, result);
mod.SetName(result, "result");
});
@@ -2008,7 +2009,7 @@
auto* func = b.Function("foo", ty.void_());
func->SetParams({texture, coords, layer, value});
b.Append(func->Block(), [&] {
- b.Call(ty.void_(), core::Function::kTextureStore, texture, coords, layer, value);
+ b.Call(ty.void_(), core::BuiltinFn::kTextureStore, texture, coords, layer, value);
b.Return(func);
});
diff --git a/src/tint/lang/wgsl/ast/call_expression.h b/src/tint/lang/wgsl/ast/call_expression.h
index 07a3e5a..a26eeac 100644
--- a/src/tint/lang/wgsl/ast/call_expression.h
+++ b/src/tint/lang/wgsl/ast/call_expression.h
@@ -27,7 +27,7 @@
/// A call expression - represents either a:
/// * sem::Function
-/// * sem::Builtin
+/// * sem::BuiltinFn
/// * sem::ValueConstructor
/// * sem::ValueConversion
class CallExpression final : public Castable<CallExpression, Expression> {
diff --git a/src/tint/lang/wgsl/ast/transform/array_length_from_uniform.cc b/src/tint/lang/wgsl/ast/transform/array_length_from_uniform.cc
index d9e1c60c..49cc35c 100644
--- a/src/tint/lang/wgsl/ast/transform/array_length_from_uniform.cc
+++ b/src/tint/lang/wgsl/ast/transform/array_length_from_uniform.cc
@@ -41,7 +41,7 @@
for (auto* fn : program->AST().Functions()) {
if (auto* sem_fn = program->Sem().Get(fn)) {
for (auto* builtin : sem_fn->DirectlyCalledBuiltins()) {
- if (builtin->Type() == core::Function::kArrayLength) {
+ if (builtin->Fn() == core::BuiltinFn::kArrayLength) {
return true;
}
}
@@ -206,8 +206,8 @@
}
auto* call = sem.Get(call_expr)->UnwrapMaterialize()->As<sem::Call>();
- auto* builtin = call->Target()->As<sem::Builtin>();
- if (!builtin || builtin->Type() != core::Function::kArrayLength) {
+ auto* builtin = call->Target()->As<sem::BuiltinFn>();
+ if (!builtin || builtin->Fn() != core::BuiltinFn::kArrayLength) {
continue;
}
diff --git a/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc b/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
index dc4ba14..c49d83b 100644
--- a/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
+++ b/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
@@ -24,7 +24,7 @@
#include "src/tint/lang/wgsl/program/clone_context.h"
#include "src/tint/lang/wgsl/program/program_builder.h"
#include "src/tint/lang/wgsl/resolver/resolve.h"
-#include "src/tint/lang/wgsl/sem/builtin.h"
+#include "src/tint/lang/wgsl/sem/builtin_fn.h"
#include "src/tint/lang/wgsl/sem/call.h"
#include "src/tint/lang/wgsl/sem/type_expression.h"
#include "src/tint/lang/wgsl/sem/value_conversion.h"
@@ -155,7 +155,7 @@
/// Polyfill functions for binary operators.
Hashmap<BinaryOpSignature, Symbol, 8> binary_op_polyfills;
/// Polyfill builtins.
- Hashmap<const sem::Builtin*, Symbol, 8> builtin_polyfills;
+ Hashmap<const sem::BuiltinFn*, Symbol, 8> builtin_polyfills;
/// Polyfill f32 conversion to i32 or u32 (or vectors of)
Hashmap<const core::type::Type*, Symbol, 2> f32_conv_polyfills;
// Tracks whether the chromium_experimental_full_ptr_parameters extension has been enabled.
@@ -858,13 +858,13 @@
const uint32_t width = WidthOf(target);
// select(target(v), low_limit, v < low_condition)
- auto* select_low = b.Call(core::Function::kSelect, //
+ auto* select_low = b.Call(core::BuiltinFn::kSelect, //
b.Call(T(target), "v"), //
ScalarOrVector(width, limits.low_limit), //
b.LessThan("v", ScalarOrVector(width, limits.low_condition)));
// select(high_limit, select_low, v < high_condition)
- auto* select_high = b.Call(core::Function::kSelect, //
+ auto* select_high = b.Call(core::BuiltinFn::kSelect, //
ScalarOrVector(width, limits.high_limit), //
select_low, //
b.LessThan("v", ScalarOrVector(width, limits.high_condition)));
@@ -1078,30 +1078,30 @@
}
Symbol fn = Switch(
call->Target(), //
- [&](const sem::Builtin* builtin) {
- switch (builtin->Type()) {
- case core::Function::kAcosh:
+ [&](const sem::BuiltinFn* builtin) {
+ switch (builtin->Fn()) {
+ case core::BuiltinFn::kAcosh:
if (cfg.builtins.acosh != Level::kNone) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return acosh(builtin->ReturnType()); });
}
return Symbol{};
- case core::Function::kAsinh:
+ case core::BuiltinFn::kAsinh:
if (cfg.builtins.asinh) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return asinh(builtin->ReturnType()); });
}
return Symbol{};
- case core::Function::kAtanh:
+ case core::BuiltinFn::kAtanh:
if (cfg.builtins.atanh != Level::kNone) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return atanh(builtin->ReturnType()); });
}
return Symbol{};
- case core::Function::kClamp:
+ case core::BuiltinFn::kClamp:
if (cfg.builtins.clamp_int) {
auto& sig = builtin->Signature();
if (sig.parameters[0]->Type()->is_integer_scalar_or_vector()) {
@@ -1111,49 +1111,49 @@
}
return Symbol{};
- case core::Function::kCountLeadingZeros:
+ case core::BuiltinFn::kCountLeadingZeros:
if (cfg.builtins.count_leading_zeros) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return countLeadingZeros(builtin->ReturnType()); });
}
return Symbol{};
- case core::Function::kCountTrailingZeros:
+ case core::BuiltinFn::kCountTrailingZeros:
if (cfg.builtins.count_trailing_zeros) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return countTrailingZeros(builtin->ReturnType()); });
}
return Symbol{};
- case core::Function::kExtractBits:
+ case core::BuiltinFn::kExtractBits:
if (cfg.builtins.extract_bits != Level::kNone) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return extractBits(builtin->ReturnType()); });
}
return Symbol{};
- case core::Function::kFirstLeadingBit:
+ case core::BuiltinFn::kFirstLeadingBit:
if (cfg.builtins.first_leading_bit) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return firstLeadingBit(builtin->ReturnType()); });
}
return Symbol{};
- case core::Function::kFirstTrailingBit:
+ case core::BuiltinFn::kFirstTrailingBit:
if (cfg.builtins.first_trailing_bit) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return firstTrailingBit(builtin->ReturnType()); });
}
return Symbol{};
- case core::Function::kInsertBits:
+ case core::BuiltinFn::kInsertBits:
if (cfg.builtins.insert_bits != Level::kNone) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return insertBits(builtin->ReturnType()); });
}
return Symbol{};
- case core::Function::kReflect:
+ case core::BuiltinFn::kReflect:
// Only polyfill for vec2<f32>. See https://crbug.com/tint/1798 for
// more details.
if (cfg.builtins.reflect_vec2_f32) {
@@ -1166,14 +1166,14 @@
}
return Symbol{};
- case core::Function::kSaturate:
+ case core::BuiltinFn::kSaturate:
if (cfg.builtins.saturate) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return saturate(builtin->ReturnType()); });
}
return Symbol{};
- case core::Function::kSign:
+ case core::BuiltinFn::kSign:
if (cfg.builtins.sign_int) {
auto* ty = builtin->ReturnType();
if (ty->is_signed_integer_scalar_or_vector()) {
@@ -1183,7 +1183,7 @@
}
return Symbol{};
- case core::Function::kTextureLoad:
+ case core::BuiltinFn::kTextureLoad:
if (cfg.builtins.bgra8unorm) {
auto& sig = builtin->Signature();
auto* tex = sig.Parameter(core::ParameterUsage::kTexture);
@@ -1199,7 +1199,7 @@
}
return Symbol{};
- case core::Function::kTextureSampleBaseClampToEdge:
+ case core::BuiltinFn::kTextureSampleBaseClampToEdge:
if (cfg.builtins.texture_sample_base_clamp_to_edge_2d_f32) {
auto& sig = builtin->Signature();
auto* tex = sig.Parameter(core::ParameterUsage::kTexture);
@@ -1213,7 +1213,7 @@
}
return Symbol{};
- case core::Function::kTextureStore:
+ case core::BuiltinFn::kTextureStore:
if (cfg.builtins.bgra8unorm) {
auto& sig = builtin->Signature();
auto* tex = sig.Parameter(core::ParameterUsage::kTexture);
@@ -1231,7 +1231,7 @@
args.Push(arg);
}
return ctx.dst->Call(
- tint::ToString(core::Function::kTextureStore),
+ tint::ToString(core::BuiltinFn::kTextureStore),
std::move(args));
});
made_changes = true;
@@ -1240,7 +1240,7 @@
}
return Symbol{};
- case core::Function::kQuantizeToF16:
+ case core::BuiltinFn::kQuantizeToF16:
if (cfg.builtins.quantize_to_vec_f16) {
if (auto* vec = builtin->ReturnType()->As<core::type::Vector>()) {
return builtin_polyfills.GetOrCreate(
@@ -1249,7 +1249,7 @@
}
return Symbol{};
- 