[WHLSL] Ensure structs/arrays with pointers as fields are disallowed
authorsbarati@apple.com <sbarati@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 11 Sep 2019 07:17:17 +0000 (07:17 +0000)
committersbarati@apple.com <sbarati@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 11 Sep 2019 07:17:17 +0000 (07:17 +0000)
https://bugs.webkit.org/show_bug.cgi?id=201525

Reviewed by Robin Morisset.

Source/WebCore:

This patch adds a pass which both ensures that references are always initialized with
concrete values and that we support logical mode validation by disallowing nested references.

Specifically, the pass:

1. Disallows structs to have fields which are references. This prevents us from having to
figure out how to default initialize such a struct. We could relax this in the future if we
did an analysis on which structs contain reference fields, and ensure such struct variables
always have initializers. This would also require us to create constructors for structs which
initialize each field.
2. We also do the same for arrays.
3. References can only be one level deep. So no pointers to pointers. No references to
references, etc. This is to support logical mode validation rules.

Test: webgpu/whlsl/ensure-proper-pointer-usage.html

* Modules/webgpu/WHLSL/WHLSLCheckReferenceTypes.cpp: Added.
(WebCore::WHLSL::checkReferenceTypes):
* Modules/webgpu/WHLSL/WHLSLCheckReferenceTypes.h: Added.
* Modules/webgpu/WHLSL/WHLSLChecker.cpp:
(WebCore::WHLSL::Checker::visit):
* Modules/webgpu/WHLSL/WHLSLPrepare.cpp:
(WebCore::WHLSL::prepareShared):
* Sources.txt:
* WebCore.xcodeproj/project.pbxproj:

LayoutTests:

This patch fixes a bug in our test harness where we forgot to wait for the gpu
device to load before running test harness tests. This patch fixes this oversight
and asserts that we have always finished loading before running a test.

* webgpu/whlsl/array-spec-tests.html:
* webgpu/whlsl/ensure-proper-pointer-usage-expected.txt: Added.
* webgpu/whlsl/ensure-proper-pointer-usage.html: Added.
* webgpu/whlsl/js/test-harness.js:
(Harness):
(Harness.prototype.async.requestDevice):
(Harness.prototype.async.callTypedFunction):
(Harness.prototype.async.checkCompileFail):
* webgpu/whlsl/pointer-spec-tests.html:
* webgpu/whlsl/test-harness-test.html:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@249758 268f45cc-cd09-0410-ab3c-d52691b4dbfc

14 files changed:
LayoutTests/ChangeLog
LayoutTests/webgpu/whlsl/array-spec-tests.html
LayoutTests/webgpu/whlsl/ensure-proper-pointer-usage-expected.txt [new file with mode: 0644]
LayoutTests/webgpu/whlsl/ensure-proper-pointer-usage.html [new file with mode: 0644]
LayoutTests/webgpu/whlsl/js/test-harness.js
LayoutTests/webgpu/whlsl/pointer-spec-tests.html
LayoutTests/webgpu/whlsl/test-harness-test.html
Source/WebCore/ChangeLog
Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckReferenceTypes.cpp [new file with mode: 0644]
Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckReferenceTypes.h [new file with mode: 0644]
Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp
Source/WebCore/Sources.txt
Source/WebCore/WebCore.xcodeproj/project.pbxproj

index 3517c12..379e24f 100644 (file)
@@ -1,3 +1,25 @@
+2019-09-11  Saam Barati  <sbarati@apple.com>
+
+        [WHLSL] Ensure structs/arrays with pointers as fields are disallowed
+        https://bugs.webkit.org/show_bug.cgi?id=201525
+
+        Reviewed by Robin Morisset.
+
+        This patch fixes a bug in our test harness where we forgot to wait for the gpu
+        device to load before running test harness tests. This patch fixes this oversight
+        and asserts that we have always finished loading before running a test.
+
+        * webgpu/whlsl/array-spec-tests.html:
+        * webgpu/whlsl/ensure-proper-pointer-usage-expected.txt: Added.
+        * webgpu/whlsl/ensure-proper-pointer-usage.html: Added.
+        * webgpu/whlsl/js/test-harness.js:
+        (Harness):
+        (Harness.prototype.async.requestDevice):
+        (Harness.prototype.async.callTypedFunction):
+        (Harness.prototype.async.checkCompileFail):
+        * webgpu/whlsl/pointer-spec-tests.html:
+        * webgpu/whlsl/test-harness-test.html:
+
 2019-09-10  Devin Rousso  <drousso@apple.com>
 
         Web Inspector: Canvas: instrument WebGPUDevice instead of GPUCanvasContext
index d6e77ef..ad1531b 100644 (file)
@@ -29,7 +29,7 @@ whlslTests.arrayRefToArrayRef = async () => {
             return result;
         }
     `;
-    assert_equals(await callIntFunction(program, "foo", []), 76 + 39 + 83);
+    await checkFail(program);
 }
 
 whlslTests.assignLength = async () => {
diff --git a/LayoutTests/webgpu/whlsl/ensure-proper-pointer-usage-expected.txt b/LayoutTests/webgpu/whlsl/ensure-proper-pointer-usage-expected.txt
new file mode 100644 (file)
index 0000000..a4f09bd
--- /dev/null
@@ -0,0 +1,3 @@
+
+PASS noPointersInStructOrArray 
+
diff --git a/LayoutTests/webgpu/whlsl/ensure-proper-pointer-usage.html b/LayoutTests/webgpu/whlsl/ensure-proper-pointer-usage.html
new file mode 100644 (file)
index 0000000..0272d1c
--- /dev/null
@@ -0,0 +1,111 @@
+<!DOCTYPE html>
+<html>
+<meta charset=utf-8>
+<meta name="timeout" content="long">
+<title>correct pointer usage.</title>
+<script src="js/test-harness.js"></script>
+<script src="../js/webgpu-functions.js"></script>
+<script src="../../resources/testharness.js"></script>
+<script src="../../resources/testharnessreport.js"></script>
+<script>
+const whlslTests = {};
+
+whlslTests.noPointersInStructOrArray = async () => {
+    await checkFail(`
+        struct S { int x; thread int* ptr; }
+        void foo() { }
+    `);
+
+    await checkFail(`
+        typedef T = thread int*;
+        struct S { int x; T ptr; }
+        void foo() { }
+    `);
+
+    await checkFail(`
+        struct S { thread int*[42] arr; }
+        void foo() { }
+    `);
+
+
+    await checkFail(`
+        void foo() {
+            thread int*[42] arr;
+        }
+    `);
+
+    await checkFail(`
+        typedef T = thread int*;
+        void foo() {
+            T[42] arr;
+        }
+    `);
+
+    await checkFail(`
+        typedef T = thread int*[42];
+        void foo() { }
+    `);
+
+    await checkFail(`
+        void foo() {
+            int x;
+            thread int* ptr = &x;
+            (&ptr);
+        }
+    `);
+
+    await checkFail(`
+        typedef T = thread int*[];
+        void foo() { }
+    `);
+
+    await checkFail(`
+        typedef I = int;
+        typedef T = thread I*[];
+        void foo() { }
+    `);
+
+    await checkFail(`
+        typedef I = thread int*;
+        typedef T = thread I[];
+        void foo() { }
+    `);
+
+    await checkFail(`
+        typedef I = thread int[];
+        typedef T = thread I[];
+        void foo() { }
+    `);
+
+    await checkFail(`
+        typedef I = thread int*;
+        typedef T = thread I*;
+        void foo() { }
+    `);
+
+    await checkFail(`
+        void foo() {
+            int x;
+            thread int[] arr = @x;
+            (@arr);
+        }
+    `);
+
+    await checkFail(`
+        void foo() {
+            int x;
+            thread int[] arr = @x;
+            (&arr);
+        }
+    `);
+
+    await checkFail(`
+        typedef I = thread int[];
+        typedef T = thread I*;
+        void foo() { }
+    `);
+};
+
+runTests(whlslTests);
+</script>
+</html>
index 67bfb1a..2d56c96 100644 (file)
@@ -158,6 +158,7 @@ class Data {
 class Harness {
     constructor ()
     {
+        this._loaded = false;
     }
 
     async requestDevice()
@@ -169,6 +170,8 @@ class Harness {
             // WebGPU is not supported.
             // FIXME: Add support for GPUAdapterRequestOptions and GPUDeviceDescriptor,
             // and differentiate between descriptor validation errors and no WebGPU support.
+        } finally {
+            this._loaded = true;
         }
     }
 
@@ -182,6 +185,9 @@ class Harness {
      */
     async callTypedFunction(type, functions, name, args)
     {   
+        if (!this._loaded)
+            throw new Error("GPU device not loaded.");
+
         if (this._device === undefined)
             throw new WebGPUUnsupportedError();
 
@@ -263,8 +269,11 @@ compute void _compute_main(${argsDeclarations.join(", ")})
      */
     async checkCompileFail(source)
     {
+        if (!this._loaded)
+            throw new Error("GPU device not loaded.");
+
         if (this._device === undefined)
-            return;
+            throw new WebGPUUnsupportedError();
         
         let entryPointCode = `
 [numthreads(1, 1, 1)]
@@ -519,6 +528,7 @@ const webGPUPromiseTest = (testFunc, msg) => {
 
 function runTests(obj) {
     window.addEventListener("load", async () => {
+        await harness.requestDevice();
         try {
             for (const name in obj) {
                 if (!name.startsWith("_")) 
index 5404a44..6b8550b 100644 (file)
@@ -29,8 +29,8 @@ whlslTests.pointerToPointer = async () =>
             result += x;
             return result;
         }
-    `;;
-    assert_equals(await callIntFunction(program, "foo", []), 76 + 39 + 83);
+    `;
+    await checkFail(program);
 }
 
 whlslTests.pointerToMember = async () =>
index e51db36..8083987 100644 (file)
@@ -186,8 +186,9 @@ whlslTests.checkFailTests = () => {
     }, "Successfully compiling code in checkFail is an error.")
 };
 
-window.addEventListener("load", () => {
+window.addEventListener("load", async () => {
     try {
+        await harness.requestDevice();
         for (const name in whlslTests) {
             if (!name.startsWith("_"))
                 whlslTests[name]();
index e746214..94576ef 100644 (file)
@@ -1,3 +1,36 @@
+2019-09-11  Saam Barati  <sbarati@apple.com>
+
+        [WHLSL] Ensure structs/arrays with pointers as fields are disallowed
+        https://bugs.webkit.org/show_bug.cgi?id=201525
+
+        Reviewed by Robin Morisset.
+
+        This patch adds a pass which both ensures that references are always initialized with
+        concrete values and that we support logical mode validation by disallowing nested references.
+        
+        Specifically, the pass:
+        
+        1. Disallows structs to have fields which are references. This prevents us from having to
+        figure out how to default initialize such a struct. We could relax this in the future if we
+        did an analysis on which structs contain reference fields, and ensure such struct variables
+        always have initializers. This would also require us to create constructors for structs which
+        initialize each field.
+        2. We also do the same for arrays.
+        3. References can only be one level deep. So no pointers to pointers. No references to
+        references, etc. This is to support logical mode validation rules.
+
+        Test: webgpu/whlsl/ensure-proper-pointer-usage.html
+
+        * Modules/webgpu/WHLSL/WHLSLCheckReferenceTypes.cpp: Added.
+        (WebCore::WHLSL::checkReferenceTypes):
+        * Modules/webgpu/WHLSL/WHLSLCheckReferenceTypes.h: Added.
+        * Modules/webgpu/WHLSL/WHLSLChecker.cpp:
+        (WebCore::WHLSL::Checker::visit):
+        * Modules/webgpu/WHLSL/WHLSLPrepare.cpp:
+        (WebCore::WHLSL::prepareShared):
+        * Sources.txt:
+        * WebCore.xcodeproj/project.pbxproj:
+
 2019-09-10  Devin Rousso  <drousso@apple.com>
 
         Web Inspector: Canvas: instrument WebGPUDevice instead of GPUCanvasContext
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckReferenceTypes.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckReferenceTypes.cpp
new file mode 100644 (file)
index 0000000..f7be93c
--- /dev/null
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2019 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "WHLSLCheckReferenceTypes.h"
+
+#if ENABLE(WEBGPU)
+
+#include "WHLSLAST.h"
+#include "WHLSLVisitor.h"
+
+namespace WebCore {
+
+namespace WHLSL {
+
+class ReferenceTypeChecker final : public Visitor {
+public:
+    ReferenceTypeChecker() = default;
+    virtual ~ReferenceTypeChecker() = default;
+
+private:
+    ALWAYS_INLINE void checkType(AST::UnnamedType& type, CodeLocation codeLocation, const char* error)
+    {
+        auto& unifiedType = type.unifyNode();
+        if (is<AST::ReferenceType>(unifiedType)) {
+            setError(Error(error, codeLocation));
+            return;
+        }
+
+        if (is<AST::UnnamedType>(unifiedType))
+            checkErrorAndVisit(downcast<AST::UnnamedType>(unifiedType));
+    }
+
+    void visit(AST::ReferenceType& referenceType) override
+    {
+        checkType(referenceType.elementType(), referenceType.codeLocation(), "reference type cannot have another reference type as an inner type");
+    }
+
+    void visit(AST::ArrayType& arrayType) override
+    {
+        checkType(arrayType.type(), arrayType.codeLocation(), "array type cannot have a reference type as its inner type");
+    }
+
+    void visit(AST::StructureElement& structureElement) override
+    {
+        checkType(structureElement.type(), structureElement.codeLocation(), "cannot have a structure field which is a reference type");
+    }
+
+    void visit(AST::Expression& expression) override
+    {
+        Visitor::visit(expression);
+        checkErrorAndVisit(expression.resolvedType());
+    }
+};
+
+Expected<void, Error> checkReferenceTypes(Program& program)
+{
+    // This pass does these things:
+    // 1. Disallow structs to have fields which are references. This prevents us from having to
+    // figure out how to default initialize such a struct. We could relax this in the future if we
+    // did an analysis on which structs contain reference fields, and ensure such struct variables
+    // always have initializers. This would also require us to create constructors for structs which
+    // initialize each field.
+    // 2. We also do the same for arrays.
+    // 3. References can only be one level deep. So no pointers to pointers. No references to
+    // references, etc. This is to support logical mode.
+    ReferenceTypeChecker referenceTypeChecker;
+    referenceTypeChecker.checkErrorAndVisit(program);
+    return referenceTypeChecker.result();
+}
+
+} // namespace WHLSL
+
+} // namespace WebCore
+
+#endif // ENABLE(WEBGPU)
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckReferenceTypes.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckReferenceTypes.h
new file mode 100644 (file)
index 0000000..427fda2
--- /dev/null
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2019 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#if ENABLE(WEBGPU)
+
+#include "WHLSLError.h"
+#include <wtf/Expected.h>
+
+namespace WebCore {
+
+namespace WHLSL {
+
+class Program;
+
+Expected<void, Error> checkReferenceTypes(Program&);
+
+}
+
+}
+
+#endif
index fb44780..90a0a45 100644 (file)
@@ -936,7 +936,6 @@ void Checker::visit(AST::MakeArrayReferenceExpression& makeArrayReferenceExpress
         auto& unnamedType = downcast<AST::UnnamedType>(unifyNode);
         if (is<AST::PointerType>(unnamedType)) {
             auto& pointerType = downcast<AST::PointerType>(unnamedType);
-            // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198163 Save the fact that we're not targetting the item; we're targetting the item's inner element.
             assignConcreteType(makeArrayReferenceExpression, AST::ArrayReferenceType::create(makeArrayReferenceExpression.codeLocation(), pointerType.addressSpace(), pointerType.elementType()));
             return;
         }
index b56798b..2b72fe9 100644 (file)
@@ -31,6 +31,7 @@
 #include "WHLSLASTDumper.h"
 #include "WHLSLCheckDuplicateFunctions.h"
 #include "WHLSLCheckTextureReferences.h"
+#include "WHLSLCheckReferenceTypes.h"
 #include "WHLSLChecker.h"
 #include "WHLSLComputeDimensions.h"
 #include "WHLSLFunctionStageChecker.h"
@@ -231,6 +232,7 @@ static Expected<Program, String> prepareShared(PhaseTimes& phaseTimes, const Str
 
     RUN_PASS(checkLiteralTypes, program);
     CHECK_PASS(checkTextureReferences, program);
+    CHECK_PASS(checkReferenceTypes, program);
     RUN_PASS(resolveProperties, program);
     RUN_PASS(findHighZombies, program);
     CHECK_PASS(checkStatementBehavior, program);
index c9accc0..57e750e 100644 (file)
@@ -313,6 +313,7 @@ Modules/webgpu/WHLSL/WHLSLLexer.cpp
 Modules/webgpu/WHLSL/WHLSLParser.cpp
 Modules/webgpu/WHLSL/WHLSLPruneUnreachableStandardLibraryFunctions.cpp
 Modules/webgpu/WHLSL/WHLSLCheckTextureReferences.cpp
+Modules/webgpu/WHLSL/WHLSLCheckReferenceTypes.cpp
 Modules/webgpu/WHLSL/WHLSLChecker.cpp
 Modules/webgpu/WHLSL/WHLSLGatherEntryPointItems.cpp
 Modules/webgpu/WHLSL/WHLSLCheckDuplicateFunctions.cpp
index b8d27fc..f874214 100644 (file)
                522DA3D3229E1D390042D151 /* WHLSLGlobalVariableReference.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLGlobalVariableReference.h; sourceTree = "<group>"; };
                522E1A172297D6D400E5D36A /* WHLSLPreserveVariableLifetimes.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLPreserveVariableLifetimes.cpp; sourceTree = "<group>"; };
                522E1A192297D6D400E5D36A /* WHLSLPreserveVariableLifetimes.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLPreserveVariableLifetimes.h; sourceTree = "<group>"; };
+               524BD47E23277E15008F56C1 /* WHLSLCheckReferenceTypes.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLCheckReferenceTypes.cpp; sourceTree = "<group>"; };
+               524BD48023277E16008F56C1 /* WHLSLCheckReferenceTypes.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLCheckReferenceTypes.h; sourceTree = "<group>"; };
                526724F11CB2FDF60075974D /* TextTrackRepresentationCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = TextTrackRepresentationCocoa.mm; sourceTree = "<group>"; };
                526724F21CB2FDF60075974D /* TextTrackRepresentationCocoa.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TextTrackRepresentationCocoa.h; sourceTree = "<group>"; };
                526B3F0122FB7BDD0076D37D /* WHLSLPruneUnreachableStandardLibraryFunctions.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLPruneUnreachableStandardLibraryFunctions.cpp; sourceTree = "<group>"; };
                                1C840B9721EC400700D0500D /* WHLSLChecker.h */,
                                1C281C6D22B87B9800691C00 /* WHLSLCheckTextureReferences.cpp */,
                                1C281C6E22B87B9800691C00 /* WHLSLCheckTextureReferences.h */,
+                               524BD47E23277E15008F56C1 /* WHLSLCheckReferenceTypes.cpp */,
+                               524BD48023277E16008F56C1 /* WHLSLCheckReferenceTypes.h */,
                                522BAB9622E6A36200C54CE9 /* WHLSLCodeLocation.h */,
                                1C86CA4B22AA19FF001BF961 /* WHLSLComputeDimensions.cpp */,
                                1C86CA4C22AA19FF001BF961 /* WHLSLComputeDimensions.h */,