<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[247067] trunk</title>
</head>
<body>

<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt;  }
#msg dl a { font-weight: bold}
#msg dl a:link    { color:#fc3; }
#msg dl a:active  { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff  {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/247067">247067</a></dd>
<dt>Author</dt> <dd>sbarati@apple.com</dd>
<dt>Date</dt> <dd>2019-07-02 12:06:44 -0700 (Tue, 02 Jul 2019)</dd>
</dl>

<h3>Log Message</h3>
<pre>[WHLSL] Import bitwise bool tests
https://bugs.webkit.org/show_bug.cgi?id=199093

Reviewed by Myles C. Maxfield.

Source/WebCore:

Add standard library functions for:
- bool bit ops
- converting from bool to number
- converting from number to bool

Test: webgpu/whlsl-bitwise-bool-ops.html

* Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt:

LayoutTests:

This patch makes it so that we can mark bools as input and output types in the
WHLSL harness. Since bool is not something WHLSL itself allows as an entrypoint
input/output type (because we don't specify its bit pattern), we convert between
bool and int in the input and output of the function. For now,  we don't support
a buffer of bools for the input type as a simplification, so we don't have to worry
about dynamically converting an int buffer to a bool buffer. We could add this
in the future if we found it helpful, but we don't have a strong reason for supporting
it right now.

This patch also starts the process of importing the WHLSL test suite by importing bool
bit op tests.

* webgpu/js/whlsl-test-harness.js:
(convertTypeToArrayType):
(whlslArgumentType):
(convertToWHLSLOutputType):
(convertToWHLSLInputType):
(Data):
(Harness.prototype.get isWHLSL):
(Harness.prototype.async.callTypedFunction):
(Harness.prototype._setUpArguments):
(callVoidFunction):
* webgpu/whlsl-bitwise-bool-ops-expected.txt: Added.
* webgpu/whlsl-bitwise-bool-ops.html: Added.
* webgpu/whlsl-test-harness-test-expected.txt:
* webgpu/whlsl-test-harness-test.html:</pre>

<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsChangeLog">trunk/LayoutTests/ChangeLog</a></li>
<li><a href="#trunkLayoutTestswebgpujswhlsltestharnessjs">trunk/LayoutTests/webgpu/js/whlsl-test-harness.js</a></li>
<li><a href="#trunkLayoutTestswebgpuwhlsltestharnesstestexpectedtxt">trunk/LayoutTests/webgpu/whlsl-test-harness-test-expected.txt</a></li>
<li><a href="#trunkLayoutTestswebgpuwhlsltestharnesstesthtml">trunk/LayoutTests/webgpu/whlsl-test-harness-test.html</a></li>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCoreModuleswebgpuWHLSLWHLSLStandardLibrarytxt">trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt</a></li>
</ul>

<h3>Added Paths</h3>
<ul>
<li><a href="#trunkLayoutTestswebgpuwhlslbitwiseboolopsexpectedtxt">trunk/LayoutTests/webgpu/whlsl-bitwise-bool-ops-expected.txt</a></li>
<li><a href="#trunkLayoutTestswebgpuwhlslbitwiseboolopshtml">trunk/LayoutTests/webgpu/whlsl-bitwise-bool-ops.html</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkLayoutTestsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/ChangeLog (247066 => 247067)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/ChangeLog      2019-07-02 18:55:18 UTC (rev 247066)
+++ trunk/LayoutTests/ChangeLog 2019-07-02 19:06:44 UTC (rev 247067)
</span><span class="lines">@@ -1,3 +1,37 @@
</span><ins>+2019-07-02  Saam Barati  <sbarati@apple.com>
+
+        [WHLSL] Import bitwise bool tests
+        https://bugs.webkit.org/show_bug.cgi?id=199093
+
+        Reviewed by Myles C. Maxfield.
+
+        This patch makes it so that we can mark bools as input and output types in the
+        WHLSL harness. Since bool is not something WHLSL itself allows as an entrypoint
+        input/output type (because we don't specify its bit pattern), we convert between
+        bool and int in the input and output of the function. For now,  we don't support
+        a buffer of bools for the input type as a simplification, so we don't have to worry
+        about dynamically converting an int buffer to a bool buffer. We could add this
+        in the future if we found it helpful, but we don't have a strong reason for supporting
+        it right now.
+        
+        This patch also starts the process of importing the WHLSL test suite by importing bool
+        bit op tests.
+
+        * webgpu/js/whlsl-test-harness.js:
+        (convertTypeToArrayType):
+        (whlslArgumentType):
+        (convertToWHLSLOutputType):
+        (convertToWHLSLInputType):
+        (Data):
+        (Harness.prototype.get isWHLSL):
+        (Harness.prototype.async.callTypedFunction):
+        (Harness.prototype._setUpArguments):
+        (callVoidFunction):
+        * webgpu/whlsl-bitwise-bool-ops-expected.txt: Added.
+        * webgpu/whlsl-bitwise-bool-ops.html: Added.
+        * webgpu/whlsl-test-harness-test-expected.txt:
+        * webgpu/whlsl-test-harness-test.html:
+
</ins><span class="cx"> 2019-07-02  Takashi Komori  <Takashi.Komori@sony.com>
</span><span class="cx"> 
</span><span class="cx">         [Curl] Fix CookieJarCurl::getRawCookie.
</span></span></pre></div>
<a id="trunkLayoutTestswebgpujswhlsltestharnessjs"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/webgpu/js/whlsl-test-harness.js (247066 => 247067)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/webgpu/js/whlsl-test-harness.js        2019-07-02 18:55:18 UTC (rev 247066)
+++ trunk/LayoutTests/webgpu/js/whlsl-test-harness.js   2019-07-02 19:06:44 UTC (rev 247067)
</span><span class="lines">@@ -22,10 +22,12 @@
</span><span class="cx">     }
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-function convertTypeToArrayType(type)
</del><ins>+function convertTypeToArrayType(isWHLSL, type)
</ins><span class="cx"> {
</span><span class="cx">     switch(type) {
</span><span class="cx">         case Types.BOOL:
</span><ins>+            if (isWHLSL)
+                return Int32Array;
</ins><span class="cx">             return Uint8Array;
</span><span class="cx">         case Types.INT:
</span><span class="cx">             return Int32Array;
</span><span class="lines">@@ -61,6 +63,27 @@
</span><span class="cx">     }
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+function whlslArgumentType(type)
+{
+    if (type === Types.BOOL)
+        return "int";
+    return convertTypeToWHLSLType(type);
+}
+
+function convertToWHLSLOutputType(code, type)
+{
+    if (type !== Types.BOOL)
+        return code;
+    return `int(${code})`;
+}
+
+function convertToWHLSLInputType(code, type)
+{
+    if (type !== Types.BOOL)
+        return code;
+    return `bool(${code})`;
+}
+
</ins><span class="cx"> /* Harness Classes */
</span><span class="cx"> 
</span><span class="cx"> class WebGPUUnsupportedError extends Error {
</span><span class="lines">@@ -91,7 +114,7 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         this._type = type;
</span><del>-        this._byteLength = (convertTypeToArrayType(type)).BYTES_PER_ELEMENT * values.length;
</del><ins>+        this._byteLength = (convertTypeToArrayType(harness.isWHLSL, type)).BYTES_PER_ELEMENT * values.length;
</ins><span class="cx"> 
</span><span class="cx">         const [buffer, arrayBuffer] = harness.device.createBufferMapped({
</span><span class="cx">             size: this._byteLength,
</span><span class="lines">@@ -98,7 +121,7 @@
</span><span class="cx">             usage: GPUBufferUsage.STORAGE | GPUBufferUsage.MAP_READ
</span><span class="cx">         });
</span><span class="cx"> 
</span><del>-        const typedArray = new (convertTypeToArrayType(type))(arrayBuffer);
</del><ins>+        const typedArray = new (convertTypeToArrayType(harness.isWHLSL, type))(arrayBuffer);
</ins><span class="cx">         typedArray.set(values);
</span><span class="cx">         buffer.unmap();
</span><span class="cx"> 
</span><span class="lines">@@ -157,6 +180,11 @@
</span><span class="cx">         `;
</span><span class="cx">     }
</span><span class="cx"> 
</span><ins>+    get isWHLSL()
+    {
+        return this._isWHLSL;
+    }
+
</ins><span class="cx">     /**
</span><span class="cx">      * Return the return value of a WHLSL function.
</span><span class="cx">      * @param {Types} type - The return type of the WHLSL function.
</span><span class="lines">@@ -196,12 +224,14 @@
</span><span class="cx"> 
</span><span class="cx">         let entryPointCode;
</span><span class="cx">         if (this._isWHLSL) {
</span><del>-            argsDeclarations.unshift(`device ${convertTypeToWHLSLType(type)}[] result : register(u0)`);
</del><ins>+            argsDeclarations.unshift(`device ${whlslArgumentType(type)}[] result : register(u0)`);
+            let callCode = `${name}(${functionCallArgs.join(", ")})`;
+            callCode = convertToWHLSLOutputType(callCode, type);
</ins><span class="cx">             entryPointCode = `
</span><span class="cx"> [numthreads(1, 1, 1)]
</span><span class="cx"> compute void _compute_main(${argsDeclarations.join(", ")})
</span><span class="cx"> {
</span><del>-    result[0] = ${name}(${functionCallArgs.join(", ")});
</del><ins>+    result[0] = ${callCode};
</ins><span class="cx"> }
</span><span class="cx"> `;
</span><span class="cx">         } else {
</span><span class="lines">@@ -225,7 +255,7 @@
</span><span class="cx">         } catch {
</span><span class="cx">             throw new Error("Harness error: Unable to read results!");
</span><span class="cx">         }
</span><del>-        const array = new (convertTypeToArrayType(type))(result);
</del><ins>+        const array = new (convertTypeToArrayType(this._isWHLSL, type))(result);
</ins><span class="cx">         this._resultBuffer.unmap();
</span><span class="cx"> 
</span><span class="cx">         return array;
</span><span class="lines">@@ -301,8 +331,8 @@
</span><span class="cx">         for (let i = 1; i <= args.length; ++i) {
</span><span class="cx">             const arg = args[i - 1];
</span><span class="cx">             if (this._isWHLSL) {
</span><del>-                argsDeclarations.push(`device ${convertTypeToWHLSLType(arg.type)}[] arg${i} : register(u${i})`);
-                functionCallArgs.push(`arg${i}` + (arg.isBuffer ? "" : "[0]"));
</del><ins>+                argsDeclarations.push(`device ${whlslArgumentType(arg.type)}[] arg${i} : register(u${i})`);
+                functionCallArgs.push(convertToWHLSLInputType(`arg${i}` + (arg.isBuffer ? "" : "[0]"), arg.type));
</ins><span class="cx">             } else {
</span><span class="cx">                 argsDeclarations.push(`device ${convertTypeToWHLSLType(arg.type)}* arg${i} [[id(${i})]];`);
</span><span class="cx">                 functionCallArgs.push((arg.isBuffer ? "" : "*") + `args.arg${i}`);
</span><span class="lines">@@ -456,4 +486,4 @@
</span><span class="cx"> function callVoidFunction(functions, name, args)
</span><span class="cx"> {
</span><span class="cx">     harness.callVoidFunction(functions, name, args);
</span><del>-}
</del><span class="cx">\ No newline at end of file
</span><ins>+}
</ins></span></pre></div>
<a id="trunkLayoutTestswebgpuwhlslbitwiseboolopsexpectedtxt"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/webgpu/whlsl-bitwise-bool-ops-expected.txt (0 => 247067)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/webgpu/whlsl-bitwise-bool-ops-expected.txt                             (rev 0)
+++ trunk/LayoutTests/webgpu/whlsl-bitwise-bool-ops-expected.txt        2019-07-02 19:06:44 UTC (rev 247067)
</span><span class="lines">@@ -0,0 +1,6 @@
</span><ins>+
+PASS Bool bit and 
+PASS Bool bit or 
+PASS Bool bit or 
+PASS Bool bit not 
+
</ins></span></pre></div>
<a id="trunkLayoutTestswebgpuwhlslbitwiseboolopshtml"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/webgpu/whlsl-bitwise-bool-ops.html (0 => 247067)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/webgpu/whlsl-bitwise-bool-ops.html                             (rev 0)
+++ trunk/LayoutTests/webgpu/whlsl-bitwise-bool-ops.html        2019-07-02 19:06:44 UTC (rev 247067)
</span><span class="lines">@@ -0,0 +1,175 @@
</span><ins>+<!DOCTYPE html><!-- webkit-test-runner [ experimental:WebGPUEnabled=true ] -->
+<html>
+<meta charset=utf-8>
+<meta name="timeout" content="long">
+<title>Test the WHLSL test harness.</title>
+<script src="js/whlsl-test-harness.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script>
+const epsilon = 0.0001;
+
+const whlslTests = {};
+
+whlslTests.boolBitAnd = () => {
+    const source = `
+        bool foo(bool a, bool b)
+        {
+            return a & b;
+        }
+    `;
+
+    webGPUPromiseTest(async () => {
+        try {
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(true), makeBool(true)]);
+                assert_equals(result, true, "Test returned expected value.");
+            }
+
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(false), makeBool(false)]);
+                assert_equals(result, false, "Test returned expected value.");
+            }
+
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(true), makeBool(false)]);
+                assert_equals(result, false, "Test returned expected value.");
+            }
+
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(false), makeBool(true)]);
+                assert_equals(result, false, "Test returned expected value.");
+            }
+        } catch(e) {
+            if (!(e instanceof WebGPUUnsupportedError))
+                throw e;
+        }
+    }, "Bool bit and");
+};
+
+whlslTests.boolBitOr = () => {
+    const source = `
+        bool foo(bool a, bool b)
+        {
+            return a | b;
+        }
+    `;
+
+    webGPUPromiseTest(async () => {
+        try {
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(true), makeBool(true)]);
+                assert_equals(result, true, "Test returned expected value.");
+            }
+
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(false), makeBool(false)]);
+                assert_equals(result, false, "Test returned expected value.");
+            }
+
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(true), makeBool(false)]);
+                assert_equals(result, true, "Test returned expected value.");
+            }
+
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(false), makeBool(true)]);
+                assert_equals(result, true, "Test returned expected value.");
+            }
+        } catch(e) {
+            if (!(e instanceof WebGPUUnsupportedError))
+                throw e;
+        }
+    }, "Bool bit or");
+};
+
+whlslTests.boolBitXor = () => {
+    const source = `
+        bool foo(bool a, bool b)
+        {
+            return a ^ b;
+        }
+    `;
+
+    webGPUPromiseTest(async () => {
+        try {
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(true), makeBool(true)]);
+                assert_equals(result, false, "Test returned expected value.");
+            }
+
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(false), makeBool(false)]);
+                assert_equals(result, false, "Test returned expected value.");
+            }
+
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(true), makeBool(false)]);
+                assert_equals(result, true, "Test returned expected value.");
+            }
+
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(false), makeBool(true)]);
+                assert_equals(result, true, "Test returned expected value.");
+            }
+        } catch(e) {
+            if (!(e instanceof WebGPUUnsupportedError))
+                throw e;
+        }
+    }, "Bool bit or");
+};
+
+whlslTests.boolBitNot = () => {
+    const source = `
+        bool foo(bool a)
+        {
+            return ~a;
+        }
+    `;
+
+    webGPUPromiseTest(async () => {
+        try {
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(true)]);
+                assert_equals(result, false, "Test returned expected value.");
+            }
+
+            {
+                let result = await callBoolFunction(source, "foo", [makeBool(false)]);
+                assert_equals(result, true, "Test returned expected value.");
+            }
+        } catch(e) {
+            if (!(e instanceof WebGPUUnsupportedError))
+                throw e;
+        }
+    }, "Bool bit not");
+};
+
+function runTests(obj) {
+    window.addEventListener("load", () => {
+        try {
+            for (const name in obj) {
+                if (!name.startsWith("_"))
+                    obj[name]();
+            }
+        } catch (e) {
+            if (window.testRunner)
+                testRunner.notifyDone();
+            
+            throw e;
+        }
+    });
+}
+
+runTests(whlslTests);
+
+const webGPUPromiseTest = (testFunc, msg) => {
+    promise_test(async () => { 
+        return testFunc().catch(e => {
+        if (!(e instanceof WebGPUUnsupportedError))
+            throw e;
+        });
+    }, msg);
+}
+</script>
+</html>
</ins></span></pre></div>
<a id="trunkLayoutTestswebgpuwhlsltestharnesstestexpectedtxt"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/webgpu/whlsl-test-harness-test-expected.txt (247066 => 247067)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/webgpu/whlsl-test-harness-test-expected.txt    2019-07-02 18:55:18 UTC (rev 247066)
+++ trunk/LayoutTests/webgpu/whlsl-test-harness-test-expected.txt       2019-07-02 19:06:44 UTC (rev 247067)
</span><span class="lines">@@ -1,12 +1,15 @@
</span><span class="cx"> 
</span><ins>+PASS Return a literal of type bool. 
</ins><span class="cx"> PASS Return an expected float4 value. 
</span><span class="cx"> PASS Return an expected int value. 
</span><span class="cx"> PASS Return an expected uint value. 
</span><span class="cx"> PASS Return an expected float value. 
</span><ins>+PASS Upload and return a bool value. 
</ins><span class="cx"> PASS Return an expected float4 value. 
</span><span class="cx"> PASS Return an expected int value. 
</span><span class="cx"> PASS Return an expected uint value. 
</span><span class="cx"> PASS Return an expected float value. 
</span><ins>+PASS Upload many bool values and return a calculated result. 
</ins><span class="cx"> PASS Return an expected float4 value. 
</span><span class="cx"> PASS Return an expected int value. 
</span><span class="cx"> PASS Return an expected uint value. 
</span></span></pre></div>
<a id="trunkLayoutTestswebgpuwhlsltestharnesstesthtml"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/webgpu/whlsl-test-harness-test.html (247066 => 247067)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/webgpu/whlsl-test-harness-test.html    2019-07-02 18:55:18 UTC (rev 247066)
+++ trunk/LayoutTests/webgpu/whlsl-test-harness-test.html       2019-07-02 19:06:44 UTC (rev 247067)
</span><span class="lines">@@ -58,16 +58,11 @@
</span><span class="cx"> 
</span><span class="cx"> whlslTests.buffersWithOneValue = () => {
</span><span class="cx">     const body = `return in0[0];`
</span><del>-    checkBools("Access and return a single bool through a bool[].", body, [[true]]);
</del><span class="cx">     checkFloat4s(body, [[[0, 1, 2, 3]]]);
</span><span class="cx">     checkNumericScalars(body, [[42]], 42);
</span><span class="cx"> };
</span><span class="cx"> 
</span><span class="cx"> whlslTests.multipleBufferArguments = () => {
</span><del>-    checkBools("Access multiple bools through various buffers and return a bool.", 
-        "return in0[0] & in0[1] & in0[2] & in1 & in2[0];", 
-        [[true, true, true], true, [true]]);
-
</del><span class="cx">     let body = `
</span><span class="cx">     float x = in0[0].x + in0[1].x + in0[2].x + in1.x + in2[0].x;
</span><span class="cx">     float y = in0[0].y + in0[1].y + in0[2].y + in1.y + in2[0].y;
</span><span class="lines">@@ -168,9 +163,6 @@
</span><span class="cx"> };
</span><span class="cx"> 
</span><span class="cx"> const checkBools = (msg = "Return an expected bool value.", body, argValues = [], expected = true) => {
</span><del>-    // FIXME (https://webkit.org/b/199093): Bool[] functions don't compile, so no-op for now.
-    return;
-
</del><span class="cx">     const [src, name, values] = appendScalarFunctionToSource("", "bool", body, argValues); 
</span><span class="cx"> 
</span><span class="cx">     webGPUPromiseTest(async () => {
</span><span class="lines">@@ -231,4 +223,4 @@
</span><span class="cx">     }, msg);
</span><span class="cx"> }
</span><span class="cx"> </script>
</span><del>-</html>
</del><span class="cx">\ No newline at end of file
</span><ins>+</html>
</ins></span></pre></div>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (247066 => 247067)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog   2019-07-02 18:55:18 UTC (rev 247066)
+++ trunk/Source/WebCore/ChangeLog      2019-07-02 19:06:44 UTC (rev 247067)
</span><span class="lines">@@ -1,3 +1,19 @@
</span><ins>+2019-07-02  Saam Barati  <sbarati@apple.com>
+
+        [WHLSL] Import bitwise bool tests
+        https://bugs.webkit.org/show_bug.cgi?id=199093
+
+        Reviewed by Myles C. Maxfield.
+
+        Add standard library functions for:
+        - bool bit ops
+        - converting from bool to number
+        - converting from number to bool
+
+        Test: webgpu/whlsl-bitwise-bool-ops.html
+
+        * Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt:
+
</ins><span class="cx"> 2019-07-02  Takashi Komori  <Takashi.Komori@sony.com>
</span><span class="cx"> 
</span><span class="cx">         [Curl] Fix CookieJarCurl::getRawCookie.
</span></span></pre></div>
<a id="trunkSourceWebCoreModuleswebgpuWHLSLWHLSLStandardLibrarytxt"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt (247066 => 247067)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt       2019-07-02 18:55:18 UTC (rev 247066)
+++ trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt  2019-07-02 19:06:44 UTC (rev 247067)
</span><span class="lines">@@ -744,6 +744,12 @@
</span><span class="cx">     return result;
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+native bool operator==(uchar, uchar);
+native bool operator==(ushort, ushort);
+native bool operator==(char, char);
+native bool operator==(short, short);
+native bool operator==(half, half);
+
</ins><span class="cx"> native int operator+(int, int);
</span><span class="cx"> native int operator-(int, int);
</span><span class="cx"> native int operator*(int, int);
</span><span class="lines">@@ -1172,4 +1178,52 @@
</span><span class="cx"> native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
</span><span class="cx"> native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
</span><span class="cx"> 
</span><ins>+
+native bool operator==(bool, bool);
+native bool operator&&(bool, bool);
+native bool operator||(bool, bool);
+bool operator&(bool a, bool b) {
+    return a && b;
+}
+bool operator|(bool a, bool b) {
+    return a || b;
+}
+bool operator^(bool a, bool b) {
+    if (a)
+        return !b;
+    return b;
+}
+bool operator~(bool value) {
+    return !value;
+}
+
+operator bool(uchar x) {
+    return x != 0;
+}
+operator bool(ushort x) {
+    return x != 0;
+}
+operator bool(uint x) {
+    return x != 0;
+}
+operator bool(char x) {
+    return x != 0;
+}
+operator bool(short x) {
+    return x != 0;
+}
+operator bool(int x) {
+    return x != 0;
+}
+operator bool(half x) {
+    return x != 0;
+}
+operator bool(float x) {
+    return x != 0;
+}
+
+operator int(bool x) {
+    return x ? 1 : 0;
+}
+
</ins><span class="cx"> // FIXME: https://bugs.webkit.org/show_bug.cgi?id=192890 Insert the rest of the standard library once the parser is fast enough
</span></span></pre>
</div>
</div>

</body>
</html>