[WHLSL] Implement array references
https://bugs.webkit.org/show_bug.cgi?id=198163
Reviewed by Saam Barati.
Source/WebCore:
The compiler automatically generates anders for every array reference. Luckily, the infrastructure
to generate those anders and emit Metal code to represent them already exists in the compiler.
There are two pieces remaining (which this patch implements):
1. The JavaScript compiler has a behavior where anders that are called with an array reference
as an argument don't wrap the argument in a MakePointerExpression. This is because the array
reference is already a reference type, so it's silly to operate on a pointer to a reference.
This patch implements this by teaching the type checker about which types should be passed
to the ander call, and by actually constructing those types in the property resolver.
The property resolver does this by placing the logic to construct an ander argument in a
single function which also has logic to save the argument in a temporary if the thread ander
will be called. The semantics about which functions are called in which situations are not
changed; instead, we just simply don't wrap array references with MakePointerExpressions.
2. Creating a bind group from the WebGPU API has to retain information about buffer lengths for
each buffer so the shader can properly perform bounds checks. This can be broken down into a
few pieces:
- Creating a bind group layout has to assign extra id indexes for each buffer which will be
filled in to represent the buffer's length
- Creating the bind group itself needs to fill in the buffer length into the Metal argument
buffer
- The shader compiler needs to emit code at the beginning of entry point to find the buffer
lengths and pack them together into the array reference (array references correspond to
a Metal struct with two fields: a pointer and a length).
This patch doesn't actually implement bounds checks themselves; it just hooks up the buffer
lengths so https://bugs.webkit.org/show_bug.cgi?id=198600 can implement it.
The shader compiler's API is modified to allow for this extra buffer length information to be
passed in from the WebGPU implementation.
Unfortunately, I don't think I could split this patch up into two pieces because both are
required to test the compiler with buffers.
Tests: webgpu/whlsl-buffer-fragment.html
webgpu/whlsl-buffer-vertex.html
* Modules/webgpu/WHLSL/AST/WHLSLPropertyAccessExpression.h:
(WebCore::WHLSL::AST::PropertyAccessExpression::baseReference):
* Modules/webgpu/WHLSL/AST/WHLSLResourceSemantic.cpp:
(WebCore::WHLSL::AST::ResourceSemantic::isAcceptableType const): Arrays can't be resources
because the compiler has no way of guaranteeing if the resource is long enough to hold the
array at compile time.
* Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp:
(WebCore::WHLSL::Metal::EntryPointScaffolding::EntryPointScaffolding): Generate an extra
variable name to represent the buffer length. Only do it for resources which have lengths.
(WebCore::WHLSL::Metal::EntryPointScaffolding::resourceHelperTypes):
(WebCore::WHLSL::Metal::EntryPointScaffolding::unpackResourcesAndNamedBuiltIns): Perform
the appropriate math to turn byte lengths into element counts and store the element count
in the array reference.
* Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.h:
* Modules/webgpu/WHLSL/WHLSLChecker.cpp:
(WebCore::WHLSL::resolveWithOperatorAnderIndexer): Refactor.
(WebCore::WHLSL::resolveWithOperatorLength): Ditto.
(WebCore::WHLSL::resolveWithReferenceComparator): Ditto.
(WebCore::WHLSL::resolveByInstantiation): Ditto.
(WebCore::WHLSL::argumentTypeForAndOverload): Given an ander, what should the type of the
argument be?
(WebCore::WHLSL::Checker::finishVisiting): Call argumentTypeForAndOverload(). Also, if
we couldn't find an ander, try automatically generating it, the same way that function
calls do. (This is how array references get their anders.)
(WebCore::WHLSL::Checker::visit):
* Modules/webgpu/WHLSL/WHLSLPipelineDescriptor.h: New WHLSL API to provide the length
information.
* Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp:
(WebCore::WHLSL::PropertyResolver::visit): SimplifyRightValue() can't fail any more.
(WebCore::WHLSL::wrapAnderCallArgument): If the ander argument should be wrapped in a
MakePointer or a MakeArrayReference, do that. Also, if the ander is a thread ander, save
the argument in a local variable and use that.
(WebCore::WHLSL::anderCallArgument): The equivalent of argumentTypeForAndOverload().
(WebCore::WHLSL::setterCall): Call anderCallArgument().
(WebCore::WHLSL::getterCall): Ditto.
(WebCore::WHLSL::modify): We used to have special-case code for handling pointer-to-argument
values as distinct from just the argument values themselves. However, emitting
chains of &* operators is valid and won't even make it through the Metal code generator
after https://bugs.webkit.org/show_bug.cgi?id=198600 is fixed. So, in order to simplify
wrapAnderCallArgument(), don't special case these values and just create &* chains instead.
(WebCore::WHLSL::PropertyResolver::simplifyRightValue):
(WebCore::WHLSL::LeftValueSimplifier::finishVisiting): Call anderCallArgument().
* Modules/webgpu/WHLSL/WHLSLSemanticMatcher.cpp: Update to support the new compiler API.
(WebCore::WHLSL::matchMode):
(WebCore::WHLSL::matchResources):
* Modules/webgpu/WebGPUBindGroupDescriptor.cpp: Ditto.
(WebCore::WebGPUBindGroupDescriptor::tryCreateGPUBindGroupDescriptor const):
* platform/graphics/gpu/GPUBindGroupLayout.h: Add some internal implementation data inside
the bindings object. Use a Variant to differentiate between the various bindings types, and
put the extra length field on just those members of the variant that represent buffers.
* platform/graphics/gpu/cocoa/GPUBindGroupLayoutMetal.mm: Update to support the new compiler API.
(WebCore::argumentDescriptor):
(WebCore::GPUBindGroupLayout::tryCreate):
* platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm: Ditto.
(WebCore::setBufferOnEncoder):
(WebCore::GPUBindGroup::tryCreate):
* platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm: Ditto.
(WebCore::convertBindingType):
(WebCore::convertLayout):
LayoutTests:
* webgpu/buffer-resource-triangles-expected.html: Deleted. This test doens't make any sense and triggers
Metal to read out-of-bounds of a vertex buffer.
* webgpu/buffer-resource-triangles.html: Deleted.
* webgpu/whlsl-buffer-fragment-expected.html: Added.
* webgpu/whlsl-buffer-fragment.html: Added.
* webgpu/whlsl-buffer-vertex-expected.html: Added.
* webgpu/whlsl-buffer-vertex.html: Added.
* webgpu/whlsl-dont-crash-parsing-enum.html:
* webgpu/whlsl.html:
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@246394 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
index 1e5c720..dd60667 100644
--- a/LayoutTests/ChangeLog
+++ b/LayoutTests/ChangeLog
@@ -1,3 +1,20 @@
+2019-06-12 Myles C. Maxfield <mmaxfield@apple.com>
+
+ [WHLSL] Implement array references
+ https://bugs.webkit.org/show_bug.cgi?id=198163
+
+ Reviewed by Saam Barati.
+
+ * webgpu/buffer-resource-triangles-expected.html: Deleted. This test doens't make any sense and triggers
+ Metal to read out-of-bounds of a vertex buffer.
+ * webgpu/buffer-resource-triangles.html: Deleted.
+ * webgpu/whlsl-buffer-fragment-expected.html: Added.
+ * webgpu/whlsl-buffer-fragment.html: Added.
+ * webgpu/whlsl-buffer-vertex-expected.html: Added.
+ * webgpu/whlsl-buffer-vertex.html: Added.
+ * webgpu/whlsl-dont-crash-parsing-enum.html:
+ * webgpu/whlsl.html:
+
2019-06-12 Justin Fan <justin_fan@apple.com>
[WebGL] ANGLE Extension directive location incorrectly enforced for webgl 1.0
diff --git a/LayoutTests/webgpu/buffer-resource-triangles-expected.html b/LayoutTests/webgpu/buffer-resource-triangles-expected.html
deleted file mode 100644
index 886f13e..0000000
--- a/LayoutTests/webgpu/buffer-resource-triangles-expected.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<meta charset="utf-8">
-<title>HTML Reference File</title>
-<p>Pass if square canvas below is completely green.</p>
-<canvas width="400" height="400"></canvas>
-<script>
-const canvas = document.querySelector("canvas");
-const context = canvas.getContext('2d');
-
-context.fillStyle = 'rgb(0, 255, 0)';
-context.fillRect(0, 0, canvas.width, canvas.height);
-</script>
\ No newline at end of file
diff --git a/LayoutTests/webgpu/buffer-resource-triangles.html b/LayoutTests/webgpu/buffer-resource-triangles.html
deleted file mode 100644
index 263626c..0000000
--- a/LayoutTests/webgpu/buffer-resource-triangles.html
+++ /dev/null
@@ -1,209 +0,0 @@
-<!DOCTYPE html>
-<meta charset="utf-8">
-<title>WebGPU Hello Triangles</title>
-<meta name="assert" content="WebGPU correctly renders a green canvas.">
-<link rel="match" href="buffer-resource-triangles-expected.html">
-<p>Pass if square canvas below is completely green.</p>
-<canvas width="400" height="400"></canvas>
-<script src="js/webgpu-functions.js"></script>
-<script>
-if (window.testRunner)
- testRunner.waitUntilDone();
-
-const shaderCode = `
-#include <metal_stdlib>
-
-using namespace metal;
-
-struct VertexInput {
- float4 position [[attribute(0)]];
-};
-
-struct Vertex {
- float4 position [[position]];
-};
-
-struct VertexArguments {
- device Vertex* v0;
- device Vertex* v1;
- device Vertex* v2;
-};
-
-vertex Vertex vertex_main(
- VertexInput input [[stage_in]],
- const device VertexArguments& args0 [[buffer(0)]],
- const device VertexArguments& args1 [[buffer(1)]],
- uint vid [[vertex_id]])
-{
- switch (vid)
- {
- case 0:
- case 1:
- case 2: {
- Vertex out;
- out.position = input.position;
- return out;
- }
- case 3: return *args0.v0;
- case 4: return *args0.v1;
- case 5: return *args0.v2;
- case 6: return *args1.v0;
- case 7: return *args1.v1;
- default: return *args1.v2;
- }
-}
-
-struct FragmentArguments {
- device float4* color;
-};
-
-fragment float4 fragment_main(const device FragmentArguments& args [[buffer(0)]])
-{
- return args.color[0];
-}
-`
-
-const bindingNums = {
- UL: 0,
- UM: 1,
- UR: 2,
- LL: 3,
- LR: 4,
- G: 5
-};
-
-function createUniformBufferBindGroupLayout(bindNum, stage = GPUShaderStageBit.VERTEX) {
- return {
- binding: bindNum,
- visibility: stage,
- type: "uniform-buffer"
- };
-}
-
-const vertexSize = 4 * 4;
-function createAndUploadVerticesBuffer(device) {
- const vertexArray = new Float32Array([
- 0, 1, 0, 1,
- -1, -1, 0, 1,
- 1, -1, 0, 1
- ]);
- return createBufferWithData(device, { size: vertexArray.byteLength, usage: GPUBufferUsage.VERTEX }, vertexArray.buffer);
-}
-
-function createFloat4Buffer(device, a, b, promises) {
- const buffer = device.createBuffer({ size: vertexSize, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.MAP_WRITE });
-
- const promise = buffer.mapWriteAsync().then(mapping => {
- const mappedArray = new Float32Array(mapping);
- mappedArray.set([a, b, 0, 1]);
- buffer.unmap();
- });
-
- promises.push(promise);
- return buffer;
-}
-
-function createBufferBinding(buffer) {
- return { buffer: buffer, size: vertexSize };
-}
-
-async function test() {
- const device = await getBasicDevice();
- const canvas = document.querySelector("canvas");
- const swapChain = createBasicSwapChain(canvas, device);
- // FIXME: Replace with non-MSL shaders.
- const shaderModule = device.createShaderModule({ code: shaderCode });
-
- // Create vertex data GPUBuffers.
- const verticesBuffer = createAndUploadVerticesBuffer(device);
-
- let bufferPromises = [];
- const upperLeft = createFloat4Buffer(device, -1, 1, bufferPromises);
- const upperMiddle = createFloat4Buffer(device, 0, 1, bufferPromises);
- const upperRight = createFloat4Buffer(device, 1, 1, bufferPromises);
- const lowerLeft = createFloat4Buffer(device, -1, -1, bufferPromises);
- const lowerRight = createFloat4Buffer(device, 1, -1, bufferPromises);
-
- // Color data buffer.
- const green = createFloat4Buffer(device, 0, 1, bufferPromises);
-
- // Create vertex input state.
- const vertexInput = {
- indexFormat: "uint32",
- vertexBuffers: [{
- stride: vertexSize,
- attributeSet: [{
- format: "float4",
- shaderLocation: 0
- }]
- }]
- };
-
- // Create buffer GPUBindGroupLayoutBindings.
- const layoutUL = createUniformBufferBindGroupLayout(bindingNums.UL);
- const layoutUM = createUniformBufferBindGroupLayout(bindingNums.UM);
- const layoutUR = createUniformBufferBindGroupLayout(bindingNums.UR);
- const layoutLL = createUniformBufferBindGroupLayout(bindingNums.LL);
- const layoutLR = createUniformBufferBindGroupLayout(bindingNums.LR);
- const layoutG = createUniformBufferBindGroupLayout(bindingNums.G, GPUShaderStageBit.FRAGMENT);
-
- // GPUBindGroupLayouts
- const leftTriangleBGLayout = device.createBindGroupLayout({ bindings: [layoutUL, layoutUM, layoutLL, layoutG] });
- const rightTriangleBGLayout = device.createBindGroupLayout({ bindings: [layoutUR, layoutUM, layoutLR] });
-
- // GPUPipelineLayout and GPURenderPipeline
- const pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: [leftTriangleBGLayout, rightTriangleBGLayout] });
- const pipeline = createBasicPipeline(shaderModule, device, null, pipelineLayout, vertexInput, null, "triangle-list");
-
- // GPUBufferBindings
- const bindingUL = createBufferBinding(upperLeft);
- const bindingUM = createBufferBinding(upperMiddle);
- const bindingUR = createBufferBinding(upperRight);
- const bindingLL = createBufferBinding(lowerLeft);
- const bindingLR = createBufferBinding(lowerRight);
- const bindingG = createBufferBinding(green);
-
- // GPUBindGroupBindings
- const bgBindingUL = { binding: bindingNums.UL, resource: bindingUL };
- const bgBindingUM = { binding: bindingNums.UM, resource: bindingUM };
- const bgBindingUR = { binding: bindingNums.UR, resource: bindingUR };
- const bgBindingLL = { binding: bindingNums.LL, resource: bindingLL };
- const bgBindingLR = { binding: bindingNums.LR, resource: bindingLR };
- const bgBindingG = { binding: bindingNums.G, resource: bindingG };
-
- // GPUBindGroups
- const leftTriangleBG = device.createBindGroup({
- layout: leftTriangleBGLayout,
- bindings: [bgBindingUL, bgBindingUM, bgBindingLL, bgBindingG]
- });
- const rightTriangleBG = device.createBindGroup({
- layout: rightTriangleBGLayout,
- bindings: [bgBindingUR, bgBindingUM, bgBindingLR]
- });
-
- Promise.all(bufferPromises).then(() => {
- const commandEncoder = device.createCommandEncoder();
- const passEncoder = beginBasicRenderPass(swapChain, commandEncoder);
- passEncoder.setPipeline(pipeline);
-
- // Vertex data for upper triangles.
- passEncoder.setBindGroup(0, leftTriangleBG);
- passEncoder.setBindGroup(1, rightTriangleBG);
- // Lower triangle.
- passEncoder.setVertexBuffers(0, [verticesBuffer], [0]);
- passEncoder.draw(9, 1, 0, 0);
-
- passEncoder.endPass();
- const queue = device.getQueue();
- queue.submit([commandEncoder.finish()]);
- });
-}
-
-test().then(function() {
- if (window.testRunner)
- testRunner.notifyDone();
-}, function() {
- if (window.testRunner)
- testRunner.notifyDone();
-});
-</script>
diff --git a/LayoutTests/webgpu/whlsl-buffer-fragment-expected.html b/LayoutTests/webgpu/whlsl-buffer-fragment-expected.html
new file mode 100644
index 0000000..f417050
--- /dev/null
+++ b/LayoutTests/webgpu/whlsl-buffer-fragment-expected.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html>
+<head>
+</head>
+<body>
+<canvas id="canvas" width="400" height="400"></canvas>
+<script>
+async function start() {
+ const canvas = document.getElementById("canvas");
+ const context = canvas.getContext("2d");
+ context.fillStyle = "blue";
+ context.fillRect(0, 0, 400, 400);
+ context.fillStyle = "white";
+ context.fillRect(100, 100, 200, 200);
+}
+window.addEventListener("load", start);
+</script>
+</body>
+</html>
diff --git a/LayoutTests/webgpu/whlsl-buffer-fragment.html b/LayoutTests/webgpu/whlsl-buffer-fragment.html
new file mode 100644
index 0000000..9bb788f
--- /dev/null
+++ b/LayoutTests/webgpu/whlsl-buffer-fragment.html
@@ -0,0 +1,124 @@
+<!DOCTYPE html>
+<html>
+<head>
+</head>
+<body>
+<canvas id="canvas" width="400" height="400"></canvas>
+<script>
+const shaderSource = `
+vertex float4 vertexShader(float4 position : attribute(0), float i : attribute(1)) : SV_Position {
+ return position;
+}
+
+fragment float4 fragmentShader(float4 position : SV_Position, constant float[] theBuffer : register(b0)) : SV_Target 0 {
+ return float4(theBuffer[0], theBuffer[0], theBuffer[0], 1.0);
+}
+`;
+async function start() {
+ const adapter = await navigator.gpu.requestAdapter();
+ const device = await adapter.requestDevice();
+
+ const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
+ const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
+ const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
+ const primitiveTopology = "triangle-strip";
+ const rasterizationState = {frontFace: "cw", cullMode: "none"};
+ const alphaBlend = {};
+ const colorBlend = {};
+ const colorStates = [{format: "rgba8unorm", alphaBlend, colorBlend, writeMask: 15}]; // GPUColorWriteBits.ALL
+ const depthStencilState = null;
+
+ const attribute0 = {shaderLocation: 0, format: "float4"};
+ const attribute1 = {shaderLocation: 1, format: "float"};
+ const input0 = {stride: 16, attributeSet: [attribute0]};
+ const input1 = {stride: 4, attributeSet: [attribute1]};
+ const inputs = [input0, input1];
+ const vertexInput = {vertexBuffers: inputs};
+
+ const bindGroupLayoutDescriptor = {bindings: [{binding: 0, visibility: 7, type: "uniform-buffer"}]};
+ const bindGroupLayout = device.createBindGroupLayout(bindGroupLayoutDescriptor);
+ const pipelineLayoutDescriptor = {bindGroupLayouts: [bindGroupLayout]};
+ const pipelineLayout = device.createPipelineLayout(pipelineLayoutDescriptor);
+
+ const renderPipelineDescriptor = {vertexStage, fragmentStage, primitiveTopology, rasterizationState, colorStates, depthStencilState, vertexInput, sampleCount: 1, layout: pipelineLayout};
+ const renderPipeline = device.createRenderPipeline(renderPipelineDescriptor);
+
+ const vertexBuffer0Descriptor = {size: Float32Array.BYTES_PER_ELEMENT * 4 * 4, usage: GPUBufferUsage.VERTEX | GPUBufferUsage.MAP_WRITE};
+ const vertexBuffer0 = device.createBuffer(vertexBuffer0Descriptor);
+ const vertexBuffer0ArrayBuffer = await vertexBuffer0.mapWriteAsync();
+ const vertexBuffer0Float32Array = new Float32Array(vertexBuffer0ArrayBuffer);
+ vertexBuffer0Float32Array[0] = -0.5;
+ vertexBuffer0Float32Array[1] = -0.5;
+ vertexBuffer0Float32Array[2] = 1.0;
+ vertexBuffer0Float32Array[3] = 1;
+ vertexBuffer0Float32Array[4] = -0.5;
+ vertexBuffer0Float32Array[5] = 0.5;
+ vertexBuffer0Float32Array[6] = 1.0;
+ vertexBuffer0Float32Array[7] = 1;
+ vertexBuffer0Float32Array[8] = 0.5;
+ vertexBuffer0Float32Array[9] = -0.5;
+ vertexBuffer0Float32Array[10] = 1.0;
+ vertexBuffer0Float32Array[11] = 1;
+ vertexBuffer0Float32Array[12] = 0.5;
+ vertexBuffer0Float32Array[13] = 0.5;
+ vertexBuffer0Float32Array[14] = 1.0;
+ vertexBuffer0Float32Array[15] = 1;
+ vertexBuffer0.unmap();
+
+ const vertexBuffer1Descriptor = {size: Float32Array.BYTES_PER_ELEMENT * 4, usage: GPUBufferUsage.VERTEX | GPUBufferUsage.MAP_WRITE};
+ const vertexBuffer1 = device.createBuffer(vertexBuffer1Descriptor);
+ const vertexBuffer1ArrayBuffer = await vertexBuffer1.mapWriteAsync();
+ const vertexBuffer1Float32Array = new Float32Array(vertexBuffer1ArrayBuffer);
+ vertexBuffer1Float32Array[0] = 1;
+ vertexBuffer1Float32Array[1] = 1;
+ vertexBuffer1Float32Array[2] = 1;
+ vertexBuffer1Float32Array[3] = 1;
+ vertexBuffer1.unmap();
+
+ const resourceBufferDescriptor = {size: Float32Array.BYTES_PER_ELEMENT, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.MAP_WRITE};
+ const resourceBuffer = device.createBuffer(resourceBufferDescriptor);
+ const resourceBufferArrayBuffer = await resourceBuffer.mapWriteAsync();
+ const resourceBufferFloat32Array = new Float32Array(resourceBufferArrayBuffer);
+ resourceBufferFloat32Array[0] = 1;
+ resourceBuffer.unmap();
+
+ const bufferBinding = {buffer: resourceBuffer, size: 4};
+ const bindGroupBinding = {binding: 0, resource: bufferBinding};
+ const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
+ const bindGroup = device.createBindGroup(bindGroupDescriptor);
+
+ const canvas = document.getElementById("canvas");
+ const context = canvas.getContext("gpu");
+ const swapChainDescriptor = {device, format: "bgra8unorm"};
+ const swapChain = context.configureSwapChain(swapChainDescriptor);
+ const outputTexture = swapChain.getCurrentTexture();
+ const outputTextureView = outputTexture.createDefaultView();
+
+ const commandEncoder = device.createCommandEncoder(); // {}
+ const red = {r: 0, g: 0, b: 1, a: 1};
+ const colorAttachments = [{attachment: outputTextureView, resolveTarget: null, loadOp: "clear", storeOp: "store", clearColor: red}];
+ const depthStencilAttachment = null;
+ const renderPassDescriptor = {colorAttachments, depthStencilAttachment};
+ const renderPassEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
+ renderPassEncoder.setPipeline(renderPipeline);
+ renderPassEncoder.setBindGroup(0, bindGroup);
+ renderPassEncoder.setVertexBuffers(0, [vertexBuffer0, vertexBuffer1], [0, 0]);
+ renderPassEncoder.draw(4, 1, 0, 0);
+ renderPassEncoder.endPass();
+ const commandBuffer = commandEncoder.finish();
+ device.getQueue().submit([commandBuffer]);
+}
+if (window.testRunner)
+ testRunner.waitUntilDone();
+window.addEventListener("load", function() {
+ start().then(function() {
+ if (window.testRunner)
+ testRunner.notifyDone();
+ }, function() {
+ if (window.testRunner)
+ testRunner.notifyDone();
+ });
+});
+</script>
+</body>
+</html>
diff --git a/LayoutTests/webgpu/whlsl-buffer-vertex-expected.html b/LayoutTests/webgpu/whlsl-buffer-vertex-expected.html
new file mode 100644
index 0000000..f417050
--- /dev/null
+++ b/LayoutTests/webgpu/whlsl-buffer-vertex-expected.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html>
+<head>
+</head>
+<body>
+<canvas id="canvas" width="400" height="400"></canvas>
+<script>
+async function start() {
+ const canvas = document.getElementById("canvas");
+ const context = canvas.getContext("2d");
+ context.fillStyle = "blue";
+ context.fillRect(0, 0, 400, 400);
+ context.fillStyle = "white";
+ context.fillRect(100, 100, 200, 200);
+}
+window.addEventListener("load", start);
+</script>
+</body>
+</html>
diff --git a/LayoutTests/webgpu/whlsl-buffer-vertex.html b/LayoutTests/webgpu/whlsl-buffer-vertex.html
new file mode 100644
index 0000000..71d4e35
--- /dev/null
+++ b/LayoutTests/webgpu/whlsl-buffer-vertex.html
@@ -0,0 +1,101 @@
+<!DOCTYPE html>
+<html>
+<head>
+</head>
+<body>
+<canvas id="canvas" width="400" height="400"></canvas>
+<script>
+const shaderSource = `
+vertex float4 vertexShader(constant float4[] buffer : register(b0), uint id : SV_VertexID) : SV_Position {
+ return buffer[id];
+}
+
+fragment float4 fragmentShader(float4 position : SV_Position) : SV_Target 0 {
+ return float4(1.0, 1.0, 1.0, 1.0);
+}
+`;
+async function start() {
+ const adapter = await navigator.gpu.requestAdapter();
+ const device = await adapter.requestDevice();
+
+ const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
+ const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
+ const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
+ const primitiveTopology = "triangle-strip";
+ const rasterizationState = {frontFace: "cw", cullMode: "none"};
+ const alphaBlend = {};
+ const colorBlend = {};
+ const colorStates = [{format: "rgba8unorm", alphaBlend, colorBlend, writeMask: 15}]; // GPUColorWriteBits.ALL
+ const depthStencilState = null;
+
+ const vertexInput = {vertexBuffers: []};
+
+ const bindGroupLayoutDescriptor = {bindings: [{binding: 0, visibility: 7, type: "uniform-buffer"}]};
+ const bindGroupLayout = device.createBindGroupLayout(bindGroupLayoutDescriptor);
+ const pipelineLayoutDescriptor = {bindGroupLayouts: [bindGroupLayout]};
+ const pipelineLayout = device.createPipelineLayout(pipelineLayoutDescriptor);
+
+ const renderPipelineDescriptor = {vertexStage, fragmentStage, primitiveTopology, rasterizationState, colorStates, depthStencilState, vertexInput, sampleCount: 1, layout: pipelineLayout};
+ const renderPipeline = device.createRenderPipeline(renderPipelineDescriptor);
+
+ const resourceBufferDescriptor = {size: 4 * 4 * Float32Array.BYTES_PER_ELEMENT, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.MAP_WRITE};
+ const resourceBuffer = device.createBuffer(resourceBufferDescriptor);
+ const resourceBufferArrayBuffer = await resourceBuffer.mapWriteAsync();
+ const resourceBufferFloat32Array = new Float32Array(resourceBufferArrayBuffer);
+ resourceBufferFloat32Array[0] = -0.5;
+ resourceBufferFloat32Array[1] = -0.5;
+ resourceBufferFloat32Array[2] = 1.0;
+ resourceBufferFloat32Array[3] = 1;
+ resourceBufferFloat32Array[4] = -0.5;
+ resourceBufferFloat32Array[5] = 0.5;
+ resourceBufferFloat32Array[6] = 1.0;
+ resourceBufferFloat32Array[7] = 1;
+ resourceBufferFloat32Array[8] = 0.5;
+ resourceBufferFloat32Array[9] = -0.5;
+ resourceBufferFloat32Array[10] = 1.0;
+ resourceBufferFloat32Array[11] = 1;
+ resourceBufferFloat32Array[12] = 0.5;
+ resourceBufferFloat32Array[13] = 0.5;
+ resourceBufferFloat32Array[14] = 1.0;
+ resourceBufferFloat32Array[15] = 1;
+ resourceBuffer.unmap();
+
+ const bufferBinding = {buffer: resourceBuffer, size: 4};
+ const bindGroupBinding = {binding: 0, resource: bufferBinding};
+ const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
+ const bindGroup = device.createBindGroup(bindGroupDescriptor);
+
+ const canvas = document.getElementById("canvas");
+ const context = canvas.getContext("gpu");
+ const swapChainDescriptor = {device, format: "bgra8unorm"};
+ const swapChain = context.configureSwapChain(swapChainDescriptor);
+ const outputTexture = swapChain.getCurrentTexture();
+ const outputTextureView = outputTexture.createDefaultView();
+
+ const commandEncoder = device.createCommandEncoder(); // {}
+ const red = {r: 0, g: 0, b: 1, a: 1};
+ const colorAttachments = [{attachment: outputTextureView, resolveTarget: null, loadOp: "clear", storeOp: "store", clearColor: red}];
+ const depthStencilAttachment = null;
+ const renderPassDescriptor = {colorAttachments, depthStencilAttachment};
+ const renderPassEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
+ renderPassEncoder.setPipeline(renderPipeline);
+ renderPassEncoder.setBindGroup(0, bindGroup);
+ renderPassEncoder.draw(4, 1, 0, 0);
+ renderPassEncoder.endPass();
+ const commandBuffer = commandEncoder.finish();
+ device.getQueue().submit([commandBuffer]);
+}
+if (window.testRunner)
+ testRunner.waitUntilDone();
+window.addEventListener("load", function() {
+ start().then(function() {
+ if (window.testRunner)
+ testRunner.notifyDone();
+ }, function() {
+ if (window.testRunner)
+ testRunner.notifyDone();
+ });
+});
+</script>
+</body>
+</html>
diff --git a/LayoutTests/webgpu/whlsl-dont-crash-parsing-enum.html b/LayoutTests/webgpu/whlsl-dont-crash-parsing-enum.html
index 4a2252f..8986f7f 100644
--- a/LayoutTests/webgpu/whlsl-dont-crash-parsing-enum.html
+++ b/LayoutTests/webgpu/whlsl-dont-crash-parsing-enum.html
@@ -74,10 +74,10 @@
const vertexBuffer1 = device.createBuffer(vertexBuffer1Descriptor);
const vertexBuffer1ArrayBuffer = await vertexBuffer1.mapWriteAsync();
const vertexBuffer1Float32Array = new Float32Array(vertexBuffer1ArrayBuffer);
- vertexBuffer1Descriptor[0] = 1;
- vertexBuffer1Descriptor[1] = 1;
- vertexBuffer1Descriptor[2] = 1;
- vertexBuffer1Descriptor[3] = 1;
+ vertexBuffer1Float32Array[0] = 1;
+ vertexBuffer1Float32Array[1] = 1;
+ vertexBuffer1Float32Array[2] = 1;
+ vertexBuffer1Float32Array[3] = 1;
vertexBuffer1.unmap();
const resourceBufferDescriptor = {size: Float32Array.BYTES_PER_ELEMENT, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.MAP_WRITE};
diff --git a/LayoutTests/webgpu/whlsl.html b/LayoutTests/webgpu/whlsl.html
index 9f79433..676bd06 100644
--- a/LayoutTests/webgpu/whlsl.html
+++ b/LayoutTests/webgpu/whlsl.html
@@ -69,10 +69,10 @@
const vertexBuffer1 = device.createBuffer(vertexBuffer1Descriptor);
const vertexBuffer1ArrayBuffer = await vertexBuffer1.mapWriteAsync();
const vertexBuffer1Float32Array = new Float32Array(vertexBuffer1ArrayBuffer);
- vertexBuffer1Descriptor[0] = 1;
- vertexBuffer1Descriptor[1] = 1;
- vertexBuffer1Descriptor[2] = 1;
- vertexBuffer1Descriptor[3] = 1;
+ vertexBuffer1Float32Array[0] = 1;
+ vertexBuffer1Float32Array[1] = 1;
+ vertexBuffer1Float32Array[2] = 1;
+ vertexBuffer1Float32Array[3] = 1;
vertexBuffer1.unmap();
const resourceBufferDescriptor = {size: Float32Array.BYTES_PER_ELEMENT, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.MAP_WRITE};
diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
index 50bbaa7..06ae4ed 100644
--- a/Source/WebCore/ChangeLog
+++ b/Source/WebCore/ChangeLog
@@ -1,3 +1,107 @@
+2019-06-12 Myles C. Maxfield <mmaxfield@apple.com>
+
+ [WHLSL] Implement array references
+ https://bugs.webkit.org/show_bug.cgi?id=198163
+
+ Reviewed by Saam Barati.
+
+ The compiler automatically generates anders for every array reference. Luckily, the infrastructure
+ to generate those anders and emit Metal code to represent them already exists in the compiler.
+ There are two pieces remaining (which this patch implements):
+
+ 1. The JavaScript compiler has a behavior where anders that are called with an array reference
+ as an argument don't wrap the argument in a MakePointerExpression. This is because the array
+ reference is already a reference type, so it's silly to operate on a pointer to a reference.
+ This patch implements this by teaching the type checker about which types should be passed
+ to the ander call, and by actually constructing those types in the property resolver.
+ The property resolver does this by placing the logic to construct an ander argument in a
+ single function which also has logic to save the argument in a temporary if the thread ander
+ will be called. The semantics about which functions are called in which situations are not
+ changed; instead, we just simply don't wrap array references with MakePointerExpressions.
+
+ 2. Creating a bind group from the WebGPU API has to retain information about buffer lengths for
+ each buffer so the shader can properly perform bounds checks. This can be broken down into a
+ few pieces:
+ - Creating a bind group layout has to assign extra id indexes for each buffer which will be
+ filled in to represent the buffer's length
+ - Creating the bind group itself needs to fill in the buffer length into the Metal argument
+ buffer
+ - The shader compiler needs to emit code at the beginning of entry point to find the buffer
+ lengths and pack them together into the array reference (array references correspond to
+ a Metal struct with two fields: a pointer and a length).
+
+ This patch doesn't actually implement bounds checks themselves; it just hooks up the buffer
+ lengths so https://bugs.webkit.org/show_bug.cgi?id=198600 can implement it.
+
+ The shader compiler's API is modified to allow for this extra buffer length information to be
+ passed in from the WebGPU implementation.
+
+ Unfortunately, I don't think I could split this patch up into two pieces because both are
+ required to test the compiler with buffers.
+
+ Tests: webgpu/whlsl-buffer-fragment.html
+ webgpu/whlsl-buffer-vertex.html
+
+ * Modules/webgpu/WHLSL/AST/WHLSLPropertyAccessExpression.h:
+ (WebCore::WHLSL::AST::PropertyAccessExpression::baseReference):
+ * Modules/webgpu/WHLSL/AST/WHLSLResourceSemantic.cpp:
+ (WebCore::WHLSL::AST::ResourceSemantic::isAcceptableType const): Arrays can't be resources
+ because the compiler has no way of guaranteeing if the resource is long enough to hold the
+ array at compile time.
+ * Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp:
+ (WebCore::WHLSL::Metal::EntryPointScaffolding::EntryPointScaffolding): Generate an extra
+ variable name to represent the buffer length. Only do it for resources which have lengths.
+ (WebCore::WHLSL::Metal::EntryPointScaffolding::resourceHelperTypes):
+ (WebCore::WHLSL::Metal::EntryPointScaffolding::unpackResourcesAndNamedBuiltIns): Perform
+ the appropriate math to turn byte lengths into element counts and store the element count
+ in the array reference.
+ * Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.h:
+ * Modules/webgpu/WHLSL/WHLSLChecker.cpp:
+ (WebCore::WHLSL::resolveWithOperatorAnderIndexer): Refactor.
+ (WebCore::WHLSL::resolveWithOperatorLength): Ditto.
+ (WebCore::WHLSL::resolveWithReferenceComparator): Ditto.
+ (WebCore::WHLSL::resolveByInstantiation): Ditto.
+ (WebCore::WHLSL::argumentTypeForAndOverload): Given an ander, what should the type of the
+ argument be?
+ (WebCore::WHLSL::Checker::finishVisiting): Call argumentTypeForAndOverload(). Also, if
+ we couldn't find an ander, try automatically generating it, the same way that function
+ calls do. (This is how array references get their anders.)
+ (WebCore::WHLSL::Checker::visit):
+ * Modules/webgpu/WHLSL/WHLSLPipelineDescriptor.h: New WHLSL API to provide the length
+ information.
+ * Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp:
+ (WebCore::WHLSL::PropertyResolver::visit): SimplifyRightValue() can't fail any more.
+ (WebCore::WHLSL::wrapAnderCallArgument): If the ander argument should be wrapped in a
+ MakePointer or a MakeArrayReference, do that. Also, if the ander is a thread ander, save
+ the argument in a local variable and use that.
+ (WebCore::WHLSL::anderCallArgument): The equivalent of argumentTypeForAndOverload().
+ (WebCore::WHLSL::setterCall): Call anderCallArgument().
+ (WebCore::WHLSL::getterCall): Ditto.
+ (WebCore::WHLSL::modify): We used to have special-case code for handling pointer-to-argument
+ values as distinct from just the argument values themselves. However, emitting
+ chains of &* operators is valid and won't even make it through the Metal code generator
+ after https://bugs.webkit.org/show_bug.cgi?id=198600 is fixed. So, in order to simplify
+ wrapAnderCallArgument(), don't special case these values and just create &* chains instead.
+ (WebCore::WHLSL::PropertyResolver::simplifyRightValue):
+ (WebCore::WHLSL::LeftValueSimplifier::finishVisiting): Call anderCallArgument().
+ * Modules/webgpu/WHLSL/WHLSLSemanticMatcher.cpp: Update to support the new compiler API.
+ (WebCore::WHLSL::matchMode):
+ (WebCore::WHLSL::matchResources):
+ * Modules/webgpu/WebGPUBindGroupDescriptor.cpp: Ditto.
+ (WebCore::WebGPUBindGroupDescriptor::tryCreateGPUBindGroupDescriptor const):
+ * platform/graphics/gpu/GPUBindGroupLayout.h: Add some internal implementation data inside
+ the bindings object. Use a Variant to differentiate between the various bindings types, and
+ put the extra length field on just those members of the variant that represent buffers.
+ * platform/graphics/gpu/cocoa/GPUBindGroupLayoutMetal.mm: Update to support the new compiler API.
+ (WebCore::argumentDescriptor):
+ (WebCore::GPUBindGroupLayout::tryCreate):
+ * platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm: Ditto.
+ (WebCore::setBufferOnEncoder):
+ (WebCore::GPUBindGroup::tryCreate):
+ * platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm: Ditto.
+ (WebCore::convertBindingType):
+ (WebCore::convertLayout):
+
2019-06-12 Carlos Garcia Campos <cgarcia@igalia.com>
[cairo][SVG] If clipPath has multiple elements, clip-path doesn't work with transform
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLPropertyAccessExpression.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLPropertyAccessExpression.h
index 8f4aa0e..bb0c301 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLPropertyAccessExpression.h
+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLPropertyAccessExpression.h
@@ -99,6 +99,7 @@
}
Expression& base() { return m_base; }
+ UniqueRef<Expression>& baseReference() { return m_base; }
UniqueRef<Expression> takeBase() { return WTFMove(m_base); }
private:
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLResourceSemantic.cpp b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLResourceSemantic.cpp
index 3b58c3d..e56287e 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLResourceSemantic.cpp
+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLResourceSemantic.cpp
@@ -49,8 +49,6 @@
auto& referenceType = downcast<ReferenceType>(unnamedType);
return referenceType.addressSpace() == AddressSpace::Constant || referenceType.addressSpace() == AddressSpace::Device;
}
- if (is<ArrayType>(unnamedType))
- return true;
if (is<TypeReference>(unnamedType)) {
auto& typeReference = downcast<TypeReference>(unnamedType);
if (is<NativeTypeDeclaration>(typeReference.resolvedType()))
@@ -71,7 +69,7 @@
case Mode::Buffer:
if (is<ReferenceType>(unnamedType))
return downcast<ReferenceType>(unnamedType).addressSpace() == AddressSpace::Constant;
- return is<ArrayType>(unnamedType);
+ return false;
case Mode::Sampler:
return matches(unnamedType, intrinsics.samplerType());
}
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp
index 21974eb..da8c057 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp
+++ b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp
@@ -32,6 +32,7 @@
#include "WHLSLFunctionDefinition.h"
#include "WHLSLGatherEntryPointItems.h"
#include "WHLSLPipelineDescriptor.h"
+#include "WHLSLReferenceType.h"
#include "WHLSLResourceSemantic.h"
#include "WHLSLStageInOutSemantic.h"
#include "WHLSLStructureDefinition.h"
@@ -108,7 +109,16 @@
for (size_t j = 0; j < m_layout[i].bindings.size(); ++j) {
NamedBinding namedBinding;
namedBinding.elementName = m_typeNamer.generateNextStructureElementName();
- namedBinding.index = m_layout[i].bindings[j].name; // GPUBindGroupLayout::tryCreate() makes sure these don't collide.
+ namedBinding.index = m_layout[i].bindings[j].internalName;
+ WTF::visit(WTF::makeVisitor([&](UniformBufferBinding& uniformBufferBinding) {
+ LengthInformation lengthInformation { m_typeNamer.generateNextStructureElementName(), m_generateNextVariableName(), uniformBufferBinding.lengthName };
+ namedBinding.lengthInformation = lengthInformation;
+ }, [&](SamplerBinding&) {
+ }, [&](TextureBinding&) {
+ }, [&](StorageBufferBinding& storageBufferBinding) {
+ LengthInformation lengthInformation { m_typeNamer.generateNextStructureElementName(), m_generateNextVariableName(), storageBufferBinding.lengthName };
+ namedBinding.lengthInformation = lengthInformation;
+ }), m_layout[i].bindings[j].binding);
namedBindGroup.namedBindings.uncheckedAppend(WTFMove(namedBinding));
}
m_namedBindGroups.uncheckedAppend(WTFMove(namedBindGroup));
@@ -137,10 +147,16 @@
auto iterator = m_resourceMap.find(&m_layout[i].bindings[j]);
if (iterator == m_resourceMap.end())
continue;
- auto mangledTypeName = m_typeNamer.mangledNameForType(*m_entryPointItems.inputs[iterator->value].unnamedType);
+ auto& unnamedType = *m_entryPointItems.inputs[iterator->value].unnamedType;
+ ASSERT(is<AST::ReferenceType>(unnamedType));
+ auto& referenceType = downcast<AST::ReferenceType>(unnamedType);
+ auto mangledTypeName = m_typeNamer.mangledNameForType(referenceType.elementType());
+ auto addressSpace = toString(referenceType.addressSpace());
auto elementName = m_namedBindGroups[i].namedBindings[j].elementName;
auto index = m_namedBindGroups[i].namedBindings[j].index;
- stringBuilder.append(makeString(" ", mangledTypeName, ' ', elementName, " [[id(", index, ")]];\n"));
+ stringBuilder.append(makeString(" ", addressSpace, " ", mangledTypeName, "* ", elementName, " [[id(", index, ")]];\n"));
+ if (auto lengthInformation = m_namedBindGroups[i].namedBindings[j].lengthInformation)
+ stringBuilder.append(makeString(" uint2 ", lengthInformation->elementName, " [[id(", lengthInformation->index, ")]];\n"));
}
stringBuilder.append("};\n\n");
}
@@ -257,9 +273,28 @@
auto iterator = m_resourceMap.find(&m_layout[i].bindings[j]);
if (iterator == m_resourceMap.end())
continue;
- auto& path = m_entryPointItems.inputs[iterator->value].path;
- auto elementName = m_namedBindGroups[i].namedBindings[j].elementName;
- stringBuilder.append(makeString(mangledInputPath(path), " = ", variableName, '.', elementName, ";\n"));
+ if (m_namedBindGroups[i].namedBindings[j].lengthInformation) {
+ auto& path = m_entryPointItems.inputs[iterator->value].path;
+ auto elementName = m_namedBindGroups[i].namedBindings[j].elementName;
+ auto lengthElementName = m_namedBindGroups[i].namedBindings[j].lengthInformation->elementName;
+ auto lengthTemporaryName = m_namedBindGroups[i].namedBindings[j].lengthInformation->temporaryName;
+
+ auto& unnamedType = *m_entryPointItems.inputs[iterator->value].unnamedType;
+ ASSERT(is<AST::ReferenceType>(unnamedType));
+ auto& referenceType = downcast<AST::ReferenceType>(unnamedType);
+ auto mangledTypeName = m_typeNamer.mangledNameForType(referenceType.elementType());
+
+ stringBuilder.append(makeString("size_t ", lengthTemporaryName, " = ", variableName, '.', lengthElementName, ".x;\n"));
+ stringBuilder.append(makeString(lengthTemporaryName, " = ", lengthTemporaryName, " << 32;\n"));
+ stringBuilder.append(makeString(lengthTemporaryName, " = ", lengthTemporaryName, " | ", variableName, '.', lengthElementName, ".y;\n"));
+ stringBuilder.append(makeString(lengthTemporaryName, " = ", lengthTemporaryName, " / sizeof(", mangledTypeName, ");\n"));
+ stringBuilder.append(makeString("if (", lengthTemporaryName, " > 0xFFFFFFFF) ", lengthTemporaryName, " = 0xFFFFFFFF;\n"));
+ stringBuilder.append(makeString(mangledInputPath(path), " = { ", variableName, '.', elementName, ", static_cast<uint32_t>(", lengthTemporaryName, ") };\n"));
+ } else {
+ auto& path = m_entryPointItems.inputs[iterator->value].path;
+ auto elementName = m_namedBindGroups[i].namedBindings[j].elementName;
+ stringBuilder.append(makeString(mangledInputPath(path), " = ", variableName, '.', elementName, ";\n"));
+ }
}
}
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.h b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.h
index 2467e86..664f7fb 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.h
+++ b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.h
@@ -77,9 +77,15 @@
Layout& m_layout;
std::function<String()> m_generateNextVariableName;
+ struct LengthInformation {
+ String elementName;
+ String temporaryName;
+ unsigned index;
+ };
struct NamedBinding {
String elementName;
unsigned index;
+ Optional<LengthInformation> lengthInformation;
};
struct NamedBindGroup {
String structName;
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
index fd282a1..1561a4f 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
@@ -117,29 +117,29 @@
}
};
-static AST::NativeFunctionDeclaration resolveWithOperatorAnderIndexer(AST::CallExpression& callExpression, AST::ArrayReferenceType& firstArgument, const Intrinsics& intrinsics)
+static AST::NativeFunctionDeclaration resolveWithOperatorAnderIndexer(Lexer::Token origin, AST::ArrayReferenceType& firstArgument, const Intrinsics& intrinsics)
{
const bool isOperator = true;
- auto returnType = makeUniqueRef<AST::PointerType>(Lexer::Token(callExpression.origin()), firstArgument.addressSpace(), firstArgument.elementType().clone());
+ auto returnType = makeUniqueRef<AST::PointerType>(Lexer::Token(origin), firstArgument.addressSpace(), firstArgument.elementType().clone());
AST::VariableDeclarations parameters;
- parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(callExpression.origin()), AST::Qualifiers(), firstArgument.clone(), String(), WTF::nullopt, WTF::nullopt));
- parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(callExpression.origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(callExpression.origin()), intrinsics.uintType())), String(), WTF::nullopt, WTF::nullopt));
- return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(callExpression.origin()), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator&[]", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, isOperator));
+ parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), firstArgument.clone(), String(), WTF::nullopt, WTF::nullopt));
+ parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(origin), intrinsics.uintType())), String(), WTF::nullopt, WTF::nullopt));
+ return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator&[]", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, isOperator));
}
-static AST::NativeFunctionDeclaration resolveWithOperatorLength(AST::CallExpression& callExpression, AST::UnnamedType& firstArgument, const Intrinsics& intrinsics)
+static AST::NativeFunctionDeclaration resolveWithOperatorLength(Lexer::Token origin, AST::UnnamedType& firstArgument, const Intrinsics& intrinsics)
{
const bool isOperator = true;
- auto returnType = AST::TypeReference::wrap(Lexer::Token(callExpression.origin()), intrinsics.uintType());
+ auto returnType = AST::TypeReference::wrap(Lexer::Token(origin), intrinsics.uintType());
AST::VariableDeclarations parameters;
- parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(callExpression.origin()), AST::Qualifiers(), firstArgument.clone(), String(), WTF::nullopt, WTF::nullopt));
- return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(callExpression.origin()), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator.length", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, isOperator));
+ parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), firstArgument.clone(), String(), WTF::nullopt, WTF::nullopt));
+ return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator.length", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, isOperator));
}
-static AST::NativeFunctionDeclaration resolveWithReferenceComparator(AST::CallExpression& callExpression, ResolvingType& firstArgument, ResolvingType& secondArgument, const Intrinsics& intrinsics)
+static AST::NativeFunctionDeclaration resolveWithReferenceComparator(Lexer::Token origin, ResolvingType& firstArgument, ResolvingType& secondArgument, const Intrinsics& intrinsics)
{
const bool isOperator = true;
- auto returnType = AST::TypeReference::wrap(Lexer::Token(callExpression.origin()), intrinsics.boolType());
+ auto returnType = AST::TypeReference::wrap(Lexer::Token(origin), intrinsics.boolType());
auto argumentType = firstArgument.visit(WTF::makeVisitor([](UniqueRef<AST::UnnamedType>& unnamedType) -> UniqueRef<AST::UnnamedType> {
return unnamedType->clone();
}, [&](RefPtr<ResolvableTypeReference>&) -> UniqueRef<AST::UnnamedType> {
@@ -149,13 +149,13 @@
// We encountered "null == null".
// FIXME: https://bugs.webkit.org/show_bug.cgi?id=198162 This can probably be generalized, using the "preferred type" infrastructure used by generic literals
ASSERT_NOT_REACHED();
- return AST::TypeReference::wrap(Lexer::Token(callExpression.origin()), intrinsics.intType());
+ return AST::TypeReference::wrap(Lexer::Token(origin), intrinsics.intType());
}));
}));
AST::VariableDeclarations parameters;
- parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(callExpression.origin()), AST::Qualifiers(), argumentType->clone(), String(), WTF::nullopt, WTF::nullopt));
- parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(callExpression.origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(WTFMove(argumentType)), String(), WTF::nullopt, WTF::nullopt));
- return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(callExpression.origin()), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator==", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, isOperator));
+ parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), argumentType->clone(), String(), WTF::nullopt, WTF::nullopt));
+ parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(WTFMove(argumentType)), String(), WTF::nullopt, WTF::nullopt));
+ return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator==", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, isOperator));
}
enum class Acceptability {
@@ -164,9 +164,9 @@
No
};
-static Optional<AST::NativeFunctionDeclaration> resolveByInstantiation(AST::CallExpression& callExpression, const Vector<std::reference_wrapper<ResolvingType>>& types, const Intrinsics& intrinsics)
+static Optional<AST::NativeFunctionDeclaration> resolveByInstantiation(const String& name, Lexer::Token origin, const Vector<std::reference_wrapper<ResolvingType>>& types, const Intrinsics& intrinsics)
{
- if (callExpression.name() == "operator&[]" && types.size() == 2) {
+ if (name == "operator&[]" && types.size() == 2) {
auto* firstArgumentArrayRef = types[0].get().visit(WTF::makeVisitor([](UniqueRef<AST::UnnamedType>& unnamedType) -> AST::ArrayReferenceType* {
if (is<AST::ArrayReferenceType>(static_cast<AST::UnnamedType&>(unnamedType)))
return &downcast<AST::ArrayReferenceType>(static_cast<AST::UnnamedType&>(unnamedType));
@@ -180,8 +180,8 @@
return resolvableTypeReference->resolvableType().canResolve(intrinsics.uintType());
}));
if (firstArgumentArrayRef && secondArgumentIsUint)
- return resolveWithOperatorAnderIndexer(callExpression, *firstArgumentArrayRef, intrinsics);
- } else if (callExpression.name() == "operator.length" && types.size() == 1) {
+ return resolveWithOperatorAnderIndexer(origin, *firstArgumentArrayRef, intrinsics);
+ } else if (name == "operator.length" && types.size() == 1) {
auto* firstArgumentReference = types[0].get().visit(WTF::makeVisitor([](UniqueRef<AST::UnnamedType>& unnamedType) -> AST::UnnamedType* {
if (is<AST::ArrayReferenceType>(static_cast<AST::UnnamedType&>(unnamedType)))
return &unnamedType;
@@ -190,8 +190,8 @@
return nullptr;
}));
if (firstArgumentReference)
- return resolveWithOperatorLength(callExpression, *firstArgumentReference, intrinsics);
- } else if (callExpression.name() == "operator==" && types.size() == 2) {
+ return resolveWithOperatorLength(origin, *firstArgumentReference, intrinsics);
+ } else if (name == "operator==" && types.size() == 2) {
auto acceptability = [](ResolvingType& resolvingType) -> Acceptability {
return resolvingType.visit(WTF::makeVisitor([](UniqueRef<AST::UnnamedType>& unnamedType) -> Acceptability {
return is<AST::ReferenceType>(static_cast<AST::UnnamedType&>(unnamedType)) ? Acceptability::Yes : Acceptability::No;
@@ -210,7 +210,7 @@
|| (leftAcceptability == Acceptability::Yes && rightAcceptability == Acceptability::Maybe))
success = true;
if (success)
- return resolveWithReferenceComparator(callExpression, types[0].get(), types[1].get(), intrinsics);
+ return resolveWithReferenceComparator(origin, types[0].get(), types[1].get(), intrinsics);
}
return WTF::nullopt;
}
@@ -969,6 +969,29 @@
assignType(makeArrayReferenceExpression, makeUniqueRef<AST::ArrayReferenceType>(Lexer::Token(makeArrayReferenceExpression.origin()), *leftAddressSpace, leftValueType->clone()));
}
+static Optional<UniqueRef<AST::UnnamedType>> argumentTypeForAndOverload(AST::UnnamedType& baseType, AST::AddressSpace addressSpace)
+{
+ auto& unifyNode = baseType.unifyNode();
+ if (is<AST::NamedType>(unifyNode)) {
+ auto& namedType = downcast<AST::NamedType>(unifyNode);
+ return { makeUniqueRef<AST::PointerType>(Lexer::Token(namedType.origin()), addressSpace, AST::TypeReference::wrap(Lexer::Token(namedType.origin()), namedType)) };
+ }
+
+ ASSERT(is<AST::UnnamedType>(unifyNode));
+ auto& unnamedType = downcast<AST::UnnamedType>(unifyNode);
+
+ if (is<AST::ArrayReferenceType>(unnamedType))
+ return unnamedType.clone();
+
+ if (is<AST::ArrayType>(unnamedType))
+ return { makeUniqueRef<AST::ArrayReferenceType>(Lexer::Token(unnamedType.origin()), addressSpace, downcast<AST::ArrayType>(unnamedType).type().clone()) };
+
+ if (is<AST::PointerType>(unnamedType))
+ return WTF::nullopt;
+
+ return { makeUniqueRef<AST::PointerType>(Lexer::Token(unnamedType.origin()), addressSpace, unnamedType.clone()) };
+}
+
void Checker::finishVisiting(AST::PropertyAccessExpression& propertyAccessExpression, ResolvingType* additionalArgumentType)
{
auto baseInfo = recurseAndGetInfo(propertyAccessExpression.base());
@@ -992,23 +1015,35 @@
AST::UnnamedType* anderReturnType = nullptr;
auto leftAddressSpace = baseInfo->typeAnnotation.leftAddressSpace();
if (leftAddressSpace) {
- ResolvingType argumentType = { makeUniqueRef<AST::PointerType>(Lexer::Token(propertyAccessExpression.origin()), *leftAddressSpace, baseUnnamedType->get().clone()) };
- Vector<std::reference_wrapper<ResolvingType>> anderArgumentTypes { argumentType };
- if (additionalArgumentType)
- anderArgumentTypes.append(*additionalArgumentType);
- if ((anderFunction = resolveFunctionOverload(propertyAccessExpression.possibleAnderOverloads(), anderArgumentTypes)))
- anderReturnType = &downcast<AST::PointerType>(anderFunction->type()).elementType(); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198164 Enforce the return of anders will always be a pointer
+ if (auto argumentTypeForAndOverload = WHLSL::argumentTypeForAndOverload(*baseUnnamedType, *leftAddressSpace)) {
+ ResolvingType argumentType = { WTFMove(*argumentTypeForAndOverload) };
+ Vector<std::reference_wrapper<ResolvingType>> anderArgumentTypes { argumentType };
+ if (additionalArgumentType)
+ anderArgumentTypes.append(*additionalArgumentType);
+ if ((anderFunction = resolveFunctionOverload(propertyAccessExpression.possibleAnderOverloads(), anderArgumentTypes)))
+ anderReturnType = &downcast<AST::PointerType>(anderFunction->type()).elementType(); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198164 Enforce the return of anders will always be a pointer
+ else if (auto newFunction = resolveByInstantiation(propertyAccessExpression.anderFunctionName(), propertyAccessExpression.origin(), anderArgumentTypes, m_intrinsics)) {
+ m_program.append(WTFMove(*newFunction));
+ anderFunction = &m_program.nativeFunctionDeclarations().last();
+ anderReturnType = &downcast<AST::PointerType>(anderFunction->type()).elementType(); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198164 Enforce the return of anders will always be a pointer
+ }
+ }
}
AST::FunctionDeclaration* threadAnderFunction = nullptr;
AST::UnnamedType* threadAnderReturnType = nullptr;
- {
+ if (auto argumentTypeForAndOverload = WHLSL::argumentTypeForAndOverload(*baseUnnamedType, AST::AddressSpace::Thread)) {
ResolvingType argumentType = { makeUniqueRef<AST::PointerType>(Lexer::Token(propertyAccessExpression.origin()), AST::AddressSpace::Thread, baseUnnamedType->get().clone()) };
Vector<std::reference_wrapper<ResolvingType>> threadAnderArgumentTypes { argumentType };
if (additionalArgumentType)
threadAnderArgumentTypes.append(*additionalArgumentType);
if ((threadAnderFunction = resolveFunctionOverload(propertyAccessExpression.possibleAnderOverloads(), threadAnderArgumentTypes)))
threadAnderReturnType = &downcast<AST::PointerType>(threadAnderFunction->type()).elementType(); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198164 Enforce the return of anders will always be a pointer
+ else if (auto newFunction = resolveByInstantiation(propertyAccessExpression.anderFunctionName(), propertyAccessExpression.origin(), threadAnderArgumentTypes, m_intrinsics)) {
+ m_program.append(WTFMove(*newFunction));
+ threadAnderFunction = &m_program.nativeFunctionDeclarations().last();
+ threadAnderReturnType = &downcast<AST::PointerType>(anderFunction->type()).elementType(); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198164 Enforce the return of anders will always be a pointer
+ }
}
if (leftAddressSpace && !anderFunction && !getterFunction) {
@@ -1434,7 +1469,7 @@
ASSERT(callExpression.hasOverloads());
auto* function = resolveFunctionOverload(*callExpression.overloads(), types, callExpression.castReturnType());
if (!function) {
- if (auto newFunction = resolveByInstantiation(callExpression, types, m_intrinsics)) {
+ if (auto newFunction = resolveByInstantiation(callExpression.name(), callExpression.origin(), types, m_intrinsics)) {
m_program.append(WTFMove(*newFunction));
function = &m_program.nativeFunctionDeclarations().last();
}
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPipelineDescriptor.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPipelineDescriptor.h
index f8f1745..5b37e3f 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPipelineDescriptor.h
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPipelineDescriptor.h
@@ -114,18 +114,28 @@
Compute = 1 << 2
};
-enum class BindingType : uint8_t {
- UniformBuffer,
- Sampler,
- Texture,
- StorageBuffer,
- // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198168 Add the dynamic types
+struct UniformBufferBinding {
+ unsigned lengthName;
};
+struct SamplerBinding {
+};
+
+struct TextureBinding {
+};
+
+struct StorageBufferBinding {
+ unsigned lengthName;
+};
+
+// FIXME: https://bugs.webkit.org/show_bug.cgi?id=198168 Add the dynamic types
+
struct Binding {
+ using BindingDetails = Variant<UniformBufferBinding, SamplerBinding, TextureBinding, StorageBufferBinding>;
OptionSet<ShaderStage> visibility;
- BindingType bindingType;
- unsigned name;
+ BindingDetails binding;
+ unsigned internalName;
+ unsigned externalName;
};
struct BindGroup {
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp
index 8a5a8b3..a93e037 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp
@@ -35,6 +35,7 @@
#include "WHLSLDotExpression.h"
#include "WHLSLFunctionDeclaration.h"
#include "WHLSLFunctionDefinition.h"
+#include "WHLSLMakeArrayReferenceExpression.h"
#include "WHLSLMakePointerExpression.h"
#include "WHLSLPointerType.h"
#include "WHLSLReadModifyWriteExpression.h"
@@ -55,7 +56,7 @@
void visit(AST::AssignmentExpression&) override;
void visit(AST::ReadModifyWriteExpression&) override;
- bool simplifyRightValue(AST::PropertyAccessExpression&);
+ void simplifyRightValue(AST::PropertyAccessExpression&);
bool simplifyAbstractLeftValue(AST::AssignmentExpression&, AST::DotExpression&, UniqueRef<AST::Expression>&& right);
void simplifyLeftValue(AST::Expression&);
@@ -65,16 +66,14 @@
void PropertyResolver::visit(AST::DotExpression& dotExpression)
{
// Unless we're inside an AssignmentExpression or a ReadModifyWriteExpression, we're a right value.
- if (!simplifyRightValue(dotExpression))
- setError();
+ simplifyRightValue(dotExpression);
}
void PropertyResolver::visit(AST::IndexExpression& indexExpression)
{
checkErrorAndVisit(indexExpression.indexExpression());
// Unless we're inside an AssignmentExpression or a ReadModifyWriteExpression, we're a right value.
- if (!simplifyRightValue(indexExpression))
- setError();
+ simplifyRightValue(indexExpression);
}
void PropertyResolver::visit(AST::FunctionDefinition& functionDefinition)
@@ -84,7 +83,78 @@
functionDefinition.block().statements().insert(0, makeUniqueRef<AST::VariableDeclarationsStatement>(Lexer::Token(m_variableDeclarations[0]->origin()), WTFMove(m_variableDeclarations)));
}
-static Optional<UniqueRef<AST::Expression>> setterCall(AST::PropertyAccessExpression& propertyAccessExpression, AST::FunctionDeclaration* relevantAnder, UniqueRef<AST::Expression>&& newValue, const std::function<UniqueRef<AST::Expression>()>& leftValueFactory, const std::function<UniqueRef<AST::Expression>()>& pointerToLeftValueFactory, AST::VariableDeclaration* indexVariable)
+enum class WhichAnder {
+ ThreadAnder,
+ Ander
+};
+
+struct AnderCallArgumentResult {
+ UniqueRef<AST::Expression> expression;
+ Optional<UniqueRef<AST::VariableDeclaration>> variableDeclaration;
+ WhichAnder whichAnder;
+};
+
+template <typename ExpressionConstructor, typename TypeConstructor>
+static Optional<AnderCallArgumentResult> wrapAnderCallArgument(UniqueRef<AST::Expression>& expression, bool anderFunction, bool threadAnderFunction)
+{
+ if (auto addressSpace = expression->typeAnnotation().leftAddressSpace()) {
+ if (!anderFunction)
+ return WTF::nullopt;
+ auto origin = expression->origin();
+ auto baseType = expression->resolvedType().clone();
+ auto makeArrayReference = makeUniqueRef<ExpressionConstructor>(Lexer::Token(origin), WTFMove(expression));
+ makeArrayReference->setType(makeUniqueRef<TypeConstructor>(WTFMove(origin), *addressSpace, WTFMove(baseType)));
+ makeArrayReference->setTypeAnnotation(AST::RightValue());
+ return {{ WTFMove(makeArrayReference), WTF::nullopt, WhichAnder::Ander }};
+ }
+ if (threadAnderFunction) {
+ auto origin = expression->origin();
+ auto baseType = expression->resolvedType().clone();
+ auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), baseType->clone(), String(), WTF::nullopt, WTF::nullopt);
+
+ auto variableReference1 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
+ variableReference1->setType(baseType->clone());
+ variableReference1->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
+
+ auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(origin), WTFMove(variableReference1), WTFMove(expression));
+ assignmentExpression->setType(baseType->clone());
+ assignmentExpression->setTypeAnnotation(AST::RightValue());
+
+ auto variableReference2 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
+ variableReference2->setType(baseType->clone());
+ variableReference2->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
+
+ auto expression = makeUniqueRef<ExpressionConstructor>(Lexer::Token(origin), WTFMove(variableReference2));
+ auto resultType = makeUniqueRef<TypeConstructor>(Lexer::Token(origin), AST::AddressSpace::Thread, WTFMove(baseType));
+ expression->setType(resultType->clone());
+ expression->setTypeAnnotation(AST::RightValue());
+
+ Vector<UniqueRef<AST::Expression>> expressions;
+ expressions.append(WTFMove(assignmentExpression));
+ expressions.append(WTFMove(expression));
+ auto commaExpression = makeUniqueRef<AST::CommaExpression>(WTFMove(origin), WTFMove(expressions));
+ commaExpression->setType(WTFMove(resultType));
+ commaExpression->setTypeAnnotation(AST::RightValue());
+ return {{ WTFMove(commaExpression), { WTFMove(variableDeclaration) }, WhichAnder::ThreadAnder}};
+ }
+ return WTF::nullopt;
+}
+
+static Optional<AnderCallArgumentResult> anderCallArgument(UniqueRef<AST::Expression>& expression, bool anderFunction, bool threadAnderFunction)
+{
+ auto& unifyNode = expression->resolvedType().unifyNode();
+ if (is<AST::UnnamedType>(unifyNode)) {
+ auto& unnamedType = downcast<AST::UnnamedType>(unifyNode);
+ ASSERT(!is<AST::PointerType>(unnamedType));
+ if (is<AST::ArrayReferenceType>(unnamedType))
+ return {{ WTFMove(expression), WTF::nullopt, WhichAnder::Ander }};
+ if (is<AST::ArrayType>(unnamedType))
+ return wrapAnderCallArgument<AST::MakeArrayReferenceExpression, AST::ArrayReferenceType>(expression, anderFunction, threadAnderFunction);
+ }
+ return wrapAnderCallArgument<AST::MakePointerExpression, AST::PointerType>(expression, anderFunction, threadAnderFunction);
+}
+
+static Optional<UniqueRef<AST::Expression>> setterCall(AST::PropertyAccessExpression& propertyAccessExpression, AST::FunctionDeclaration* relevantAnder, UniqueRef<AST::Expression>&& newValue, const std::function<UniqueRef<AST::Expression>()>& leftValueFactory, AST::VariableDeclaration* indexVariable)
{
auto maybeAddIndexArgument = [&](Vector<UniqueRef<AST::Expression>>& arguments) {
if (!indexVariable)
@@ -98,8 +168,13 @@
if (relevantAnder) {
// *operator&.foo(&v) = newValue
+ auto leftValue = leftValueFactory();
+ auto argument = anderCallArgument(leftValue, true, true);
+ ASSERT(argument);
+ ASSERT(!argument->variableDeclaration);
+ ASSERT(argument->whichAnder == WhichAnder::Ander);
Vector<UniqueRef<AST::Expression>> arguments;
- arguments.append(pointerToLeftValueFactory());
+ arguments.append(WTFMove(argument->expression));
maybeAddIndexArgument(arguments);
auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(propertyAccessExpression.origin()), String(relevantAnder->name()), WTFMove(arguments));
@@ -138,7 +213,7 @@
return UniqueRef<AST::Expression>(WTFMove(assignmentExpression));
}
-static Optional<UniqueRef<AST::Expression>> getterCall(AST::PropertyAccessExpression& propertyAccessExpression, AST::FunctionDeclaration* relevantAnder, const std::function<UniqueRef<AST::Expression>()>& leftValueFactory, const std::function<UniqueRef<AST::Expression>()>& pointerToLeftValueFactory, AST::VariableDeclaration* indexVariable)
+static Optional<UniqueRef<AST::Expression>> getterCall(AST::PropertyAccessExpression& propertyAccessExpression, AST::FunctionDeclaration* relevantAnder, const std::function<UniqueRef<AST::Expression>()>& leftValueFactory, AST::VariableDeclaration* indexVariable)
{
auto maybeAddIndexArgument = [&](Vector<UniqueRef<AST::Expression>>& arguments) {
if (!indexVariable)
@@ -152,8 +227,13 @@
if (relevantAnder) {
// *operator&.foo(&v)
+ auto leftValue = leftValueFactory();
+ auto argument = anderCallArgument(leftValue, true, true);
+ ASSERT(argument);
+ ASSERT(!argument->variableDeclaration);
+ ASSERT(argument->whichAnder == WhichAnder::Ander);
Vector<UniqueRef<AST::Expression>> arguments;
- arguments.append(pointerToLeftValueFactory());
+ arguments.append(WTFMove(argument->expression));
maybeAddIndexArgument(arguments);
auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(propertyAccessExpression.origin()), String(relevantAnder->name()), WTFMove(arguments));
@@ -170,7 +250,7 @@
// operator.foo(v)
ASSERT(propertyAccessExpression.getterFunction());
-
+
Vector<UniqueRef<AST::Expression>> arguments;
arguments.append(leftValueFactory());
maybeAddIndexArgument(arguments);
@@ -304,7 +384,7 @@
variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
return variableReference;
}
-
+
auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(pointerVariable));
ASSERT(pointerVariable->type());
variableReference->setType(pointerVariable->type()->clone());
@@ -316,26 +396,6 @@
dereferenceExpression->setTypeAnnotation(AST::LeftValue { downcast<AST::PointerType>(*pointerVariable->type()).addressSpace() });
return dereferenceExpression;
};
- auto pointerToPreviousLeftValue = [&]() -> UniqueRef<AST::Expression> {
- if (previous) {
- auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(*previous));
- ASSERT(previous->type());
- variableReference->setType(previous->type()->clone());
- variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
-
- auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference));
- ASSERT(previous->type());
- makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(propertyAccessExpression.origin()), AST::AddressSpace::Thread, previous->type()->clone()));
- makePointerExpression->setTypeAnnotation(AST::RightValue());
- return makePointerExpression;
- }
-
- auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(pointerVariable));
- ASSERT(pointerVariable->type());
- variableReference->setType(pointerVariable->type()->clone());
- variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
- return variableReference;
- };
auto appendIndexAssignment = [&](AST::PropertyAccessExpression& propertyAccessExpression, Optional<UniqueRef<AST::VariableDeclaration>>& indexVariable) {
if (!indexVariable)
return;
@@ -361,7 +421,7 @@
appendIndexAssignment(propertyAccessExpression, indexVariable);
AST::FunctionDeclaration* relevantAnder = i == chain.size() - 1 ? propertyAccessExpression.anderFunction() : propertyAccessExpression.threadAnderFunction();
- auto callExpression = getterCall(propertyAccessExpression, relevantAnder, previousLeftValue, pointerToPreviousLeftValue, indexVariable ? &*indexVariable : nullptr);
+ auto callExpression = getterCall(propertyAccessExpression, relevantAnder, previousLeftValue, indexVariable ? &*indexVariable : nullptr);
if (!callExpression)
return WTF::nullopt;
@@ -376,12 +436,12 @@
assignmentExpression->setTypeAnnotation(AST::RightValue());
expressions.append(WTFMove(assignmentExpression));
-
+
previous = &variableDeclaration;
}
appendIndexAssignment(chain[0], indexVariables[0]);
AST::FunctionDeclaration* relevantAnder = chain.size() == 1 ? propertyAccessExpression.anderFunction() : propertyAccessExpression.threadAnderFunction();
- auto lastGetterCallExpression = getterCall(chain[0], relevantAnder, previousLeftValue, pointerToPreviousLeftValue, indexVariables[0] ? &*(indexVariables[0]) : nullptr);
+ auto lastGetterCallExpression = getterCall(chain[0], relevantAnder, previousLeftValue, indexVariables[0] ? &*(indexVariables[0]) : nullptr);
// Step 3:
auto modificationResult = modification(WTFMove(lastGetterCallExpression));
@@ -404,17 +464,6 @@
variableReference->setType(variableDeclaration.type()->clone());
variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
return variableReference;
- }, [&]() -> UniqueRef<AST::Expression> {
- auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
- ASSERT(variableDeclaration.type());
- variableReference->setType(variableDeclaration.type()->clone());
- variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
-
- auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(propertyAccessExpression.origin()), WTFMove(variableReference));
- ASSERT(variableDeclaration.type());
- makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(propertyAccessExpression.origin()), AST::AddressSpace::Thread, variableDeclaration.type()->clone()));
- makePointerExpression->setTypeAnnotation(AST::RightValue());
- return makePointerExpression;
}, indexVariable ? &*indexVariable : nullptr);
if (!assignmentExpression)
@@ -442,12 +491,6 @@
dereferenceExpression->setType(downcast<AST::PointerType>(*pointerVariable->type()).elementType().clone());
dereferenceExpression->setTypeAnnotation(AST::LeftValue { downcast<AST::PointerType>(*pointerVariable->type()).addressSpace() });
return dereferenceExpression;
- }, [&]() -> UniqueRef<AST::Expression> {
- auto variableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(pointerVariable));
- ASSERT(pointerVariable->type());
- variableReference->setType(pointerVariable->type()->clone());
- variableReference->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread }); // FIXME: https://bugs.webkit.org/show_bug.cgi?id=198169 Is this right?
- return variableReference;
}, indexVariables[indexVariables.size() - 1] ? &*(indexVariables[indexVariables.size() - 1]) : nullptr);
if (!assignmentExpression)
@@ -671,94 +714,50 @@
m_variableDeclarations.append(WTFMove(newVariableDeclaration));
}
-bool PropertyResolver::simplifyRightValue(AST::PropertyAccessExpression& propertyAccessExpression)
+static Optional<AnderCallArgumentResult> anderCallArgument(AST::PropertyAccessExpression& propertyAccessExpression)
+{
+ return anderCallArgument(propertyAccessExpression.baseReference(), propertyAccessExpression.anderFunction(), propertyAccessExpression.threadAnderFunction());
+}
+
+void PropertyResolver::simplifyRightValue(AST::PropertyAccessExpression& propertyAccessExpression)
{
Lexer::Token origin = propertyAccessExpression.origin();
checkErrorAndVisit(propertyAccessExpression.base());
- auto& base = propertyAccessExpression.base();
- if (auto leftAddressSpace = base.typeAnnotation().leftAddressSpace()) {
- if (auto* anderFunction = propertyAccessExpression.anderFunction()) {
- auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), propertyAccessExpression.takeBase());
- makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(origin), *leftAddressSpace, base.resolvedType().clone()));
- makePointerExpression->setTypeAnnotation(AST::RightValue());
-
- Vector<UniqueRef<AST::Expression>> arguments;
- arguments.append(WTFMove(makePointerExpression));
- if (is<AST::IndexExpression>(propertyAccessExpression))
- arguments.append(downcast<AST::IndexExpression>(propertyAccessExpression).takeIndex());
- auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(origin), String(anderFunction->name()), WTFMove(arguments));
- callExpression->setType(anderFunction->type().clone());
- callExpression->setTypeAnnotation(AST::RightValue());
- callExpression->setFunction(*anderFunction);
-
- auto* dereferenceExpression = AST::replaceWith<AST::DereferenceExpression>(propertyAccessExpression, WTFMove(origin), WTFMove(callExpression));
- dereferenceExpression->setType(downcast<AST::PointerType>(anderFunction->type()).elementType().clone());
- dereferenceExpression->setTypeAnnotation(AST::LeftValue { downcast<AST::PointerType>(anderFunction->type()).addressSpace() });
- return true;
- }
- }
-
- if (propertyAccessExpression.getterFunction()) {
- auto& getterFunction = *propertyAccessExpression.getterFunction();
+ if (auto argument = anderCallArgument(propertyAccessExpression)) {
+ auto* anderFunction = argument->whichAnder == WhichAnder::ThreadAnder ? propertyAccessExpression.threadAnderFunction() : propertyAccessExpression.anderFunction();
+ ASSERT(anderFunction);
+ auto origin = propertyAccessExpression.origin();
Vector<UniqueRef<AST::Expression>> arguments;
- arguments.append(propertyAccessExpression.takeBase());
+ arguments.append(WTFMove(argument->expression));
if (is<AST::IndexExpression>(propertyAccessExpression))
arguments.append(downcast<AST::IndexExpression>(propertyAccessExpression).takeIndex());
- auto* callExpression = AST::replaceWith<AST::CallExpression>(propertyAccessExpression, WTFMove(origin), String(getterFunction.name()), WTFMove(arguments));
- callExpression->setFunction(getterFunction);
- callExpression->setType(getterFunction.type().clone());
+ auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(origin), String(anderFunction->name()), WTFMove(arguments));
+ callExpression->setType(anderFunction->type().clone());
callExpression->setTypeAnnotation(AST::RightValue());
- return true;
+ callExpression->setFunction(*anderFunction);
+
+ auto* dereferenceExpression = AST::replaceWith<AST::DereferenceExpression>(propertyAccessExpression, WTFMove(origin), WTFMove(callExpression));
+ dereferenceExpression->setType(downcast<AST::PointerType>(anderFunction->type()).elementType().clone());
+ dereferenceExpression->setTypeAnnotation(AST::LeftValue { downcast<AST::PointerType>(anderFunction->type()).addressSpace() });
+
+ if (auto& variableDeclaration = argument->variableDeclaration)
+ m_variableDeclarations.append(WTFMove(*variableDeclaration));
+
+ return;
}
- // We have an ander, but no left value to call it on. Let's save the value into a temporary variable to create a left value.
- // This is effectively inlining the functions the spec says are generated.
- ASSERT(propertyAccessExpression.threadAnderFunction());
- auto* threadAnderFunction = propertyAccessExpression.threadAnderFunction();
-
- auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), base.resolvedType().clone(), String(), WTF::nullopt, WTF::nullopt);
-
- auto variableReference1 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
- variableReference1->setType(base.resolvedType().clone());
- variableReference1->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
-
- auto assignmentExpression = makeUniqueRef<AST::AssignmentExpression>(Lexer::Token(origin), WTFMove(variableReference1), propertyAccessExpression.takeBase());
- assignmentExpression->setType(base.resolvedType().clone());
- assignmentExpression->setTypeAnnotation(AST::RightValue());
-
- auto variableReference2 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
- variableReference2->setType(base.resolvedType().clone());
- variableReference2->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
-
- auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), WTFMove(variableReference2));
- makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(origin), AST::AddressSpace::Thread, base.resolvedType().clone()));
- makePointerExpression->setTypeAnnotation(AST::RightValue());
-
+ ASSERT(propertyAccessExpression.getterFunction());
+ auto& getterFunction = *propertyAccessExpression.getterFunction();
Vector<UniqueRef<AST::Expression>> arguments;
- arguments.append(WTFMove(makePointerExpression));
+ arguments.append(propertyAccessExpression.takeBase());
if (is<AST::IndexExpression>(propertyAccessExpression))
arguments.append(downcast<AST::IndexExpression>(propertyAccessExpression).takeIndex());
- auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(origin), String(threadAnderFunction->name()), WTFMove(arguments));
- callExpression->setType(threadAnderFunction->type().clone());
+ auto* callExpression = AST::replaceWith<AST::CallExpression>(propertyAccessExpression, WTFMove(origin), String(getterFunction.name()), WTFMove(arguments));
+ callExpression->setFunction(getterFunction);
+ callExpression->setType(getterFunction.type().clone());
callExpression->setTypeAnnotation(AST::RightValue());
- callExpression->setFunction(*threadAnderFunction);
-
- auto dereferenceExpression = makeUniqueRef<AST::DereferenceExpression>(WTFMove(origin), WTFMove(callExpression));
- dereferenceExpression->setType(downcast<AST::PointerType>(threadAnderFunction->type()).elementType().clone());
- dereferenceExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
-
- Vector<UniqueRef<AST::Expression>> expressions;
- expressions.append(WTFMove(assignmentExpression));
- expressions.append(WTFMove(dereferenceExpression));
- auto* commaExpression = AST::replaceWith<AST::CommaExpression>(propertyAccessExpression, WTFMove(origin), WTFMove(expressions));
- commaExpression->setType(downcast<AST::PointerType>(threadAnderFunction->type()).elementType().clone());
- commaExpression->setTypeAnnotation(AST::LeftValue { AST::AddressSpace::Thread });
-
- m_variableDeclarations.append(WTFMove(variableDeclaration));
- return true;
-
}
class LeftValueSimplifier : public Visitor {
@@ -777,14 +776,14 @@
Lexer::Token origin = propertyAccessExpression.origin();
auto* anderFunction = propertyAccessExpression.anderFunction();
- auto& base = propertyAccessExpression.base();
- auto leftAddressSpace = *propertyAccessExpression.base().typeAnnotation().leftAddressSpace();
- auto makePointerExpression = makeUniqueRef<AST::MakePointerExpression>(Lexer::Token(origin), propertyAccessExpression.takeBase());
- makePointerExpression->setType(makeUniqueRef<AST::PointerType>(Lexer::Token(origin), leftAddressSpace, base.resolvedType().clone()));
- makePointerExpression->setTypeAnnotation(AST::RightValue());
+
+ auto argument = anderCallArgument(propertyAccessExpression);
+ ASSERT(argument);
+ ASSERT(!argument->variableDeclaration);
+ ASSERT(argument->whichAnder == WhichAnder::Ander);
Vector<UniqueRef<AST::Expression>> arguments;
- arguments.append(WTFMove(makePointerExpression));
+ arguments.append(WTFMove(argument->expression));
if (is<AST::IndexExpression>(propertyAccessExpression))
arguments.append(downcast<AST::IndexExpression>(propertyAccessExpression).takeIndex());
auto callExpression = makeUniqueRef<AST::CallExpression>(Lexer::Token(origin), String(anderFunction->name()), WTFMove(arguments));
diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSemanticMatcher.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSemanticMatcher.cpp
index 7a551bf..5002ee5 100644
--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSemanticMatcher.cpp
+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSemanticMatcher.cpp
@@ -55,19 +55,17 @@
return &*iterator;
};
-static bool matchMode(BindingType bindingType, AST::ResourceSemantic::Mode mode)
+static bool matchMode(Binding::BindingDetails bindingType, AST::ResourceSemantic::Mode mode)
{
- switch (bindingType) {
- case BindingType::UniformBuffer:
+ return WTF::visit(WTF::makeVisitor([&](UniformBufferBinding) -> bool {
return mode == AST::ResourceSemantic::Mode::Buffer;
- case BindingType::Sampler:
+ }, [&](SamplerBinding) -> bool {
return mode == AST::ResourceSemantic::Mode::Sampler;
- case BindingType::Texture:
+ }, [&](TextureBinding) -> bool {
return mode == AST::ResourceSemantic::Mode::Texture;
- default:
- ASSERT(bindingType == BindingType::StorageBuffer);
+ }, [&](StorageBufferBinding) -> bool {
return mode == AST::ResourceSemantic::Mode::UnorderedAccessView;
- }
+ }), bindingType);
}
static Optional<HashMap<Binding*, size_t>> matchResources(Vector<EntryPointItem>& entryPointItems, Layout& layout, ShaderStage shaderStage)
@@ -87,9 +85,9 @@
if (!WTF::holds_alternative<AST::ResourceSemantic>(semantic))
continue;
auto& resourceSemantic = WTF::get<AST::ResourceSemantic>(semantic);
- if (!matchMode(binding.bindingType, resourceSemantic.mode()))
+ if (!matchMode(binding.binding, resourceSemantic.mode()))
continue;
- if (binding.name != resourceSemantic.index())
+ if (binding.externalName != resourceSemantic.index())
continue;
if (space != resourceSemantic.space())
continue;
diff --git a/Source/WebCore/Modules/webgpu/WebGPUBindGroupDescriptor.cpp b/Source/WebCore/Modules/webgpu/WebGPUBindGroupDescriptor.cpp
index 9851567..3e510c5 100644
--- a/Source/WebCore/Modules/webgpu/WebGPUBindGroupDescriptor.cpp
+++ b/Source/WebCore/Modules/webgpu/WebGPUBindGroupDescriptor.cpp
@@ -111,7 +111,7 @@
if (!buffer)
return WTF::nullopt;
- if (!validateBufferBindingType(buffer, layoutBinding, functionName))
+ if (!validateBufferBindingType(buffer, layoutBinding.externalBinding, functionName))
return WTF::nullopt;
return static_cast<GPUBindingResource>(GPUBufferBinding { makeRef(*buffer), bufferBinding.offset, bufferBinding.size });
@@ -119,7 +119,7 @@
auto bindingResource = WTF::visit(bindingResourceVisitor, binding.resource);
if (!bindingResource) {
- LOG(WebGPU, "%s: Invalid resource for binding %u!", functionName, layoutBinding.binding);
+ LOG(WebGPU, "%s: Invalid resource for binding %u!", functionName, layoutBinding.externalBinding.binding);
return WTF::nullopt;
}
diff --git a/Source/WebCore/platform/graphics/gpu/GPUBindGroupLayout.h b/Source/WebCore/platform/graphics/gpu/GPUBindGroupLayout.h
index a55b1c9..f7762c3 100644
--- a/Source/WebCore/platform/graphics/gpu/GPUBindGroupLayout.h
+++ b/Source/WebCore/platform/graphics/gpu/GPUBindGroupLayout.h
@@ -33,6 +33,7 @@
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>
#include <wtf/RetainPtr.h>
+#include <wtf/Variant.h>
#if USE(METAL)
OBJC_PROTOCOL(MTLArgumentEncoder);
@@ -47,7 +48,37 @@
public:
static RefPtr<GPUBindGroupLayout> tryCreate(const GPUDevice&, const GPUBindGroupLayoutDescriptor&);
- using BindingsMapType = HashMap<uint64_t, GPUBindGroupLayoutBinding, WTF::IntHash<uint64_t>, WTF::UnsignedWithZeroKeyHashTraits<uint64_t>>;
+ struct UniformBuffer {
+ unsigned internalLengthName;
+ };
+
+ struct DynamicUniformBuffer {
+ unsigned internalLengthName;
+ };
+
+ struct Sampler {
+ };
+
+ struct SampledTexture {
+ };
+
+ struct StorageBuffer {
+ unsigned internalLengthName;
+ };
+
+ struct DynamicStorageBuffer {
+ unsigned internalLengthName;
+ };
+
+ using InternalBindingDetails = Variant<UniformBuffer, DynamicUniformBuffer, Sampler, SampledTexture, StorageBuffer, DynamicStorageBuffer>;
+
+ struct Binding {
+ GPUBindGroupLayoutBinding externalBinding;
+ unsigned internalName;
+ InternalBindingDetails internalBindingDetails;
+ };
+
+ using BindingsMapType = HashMap<uint64_t, Binding, WTF::IntHash<uint64_t>, WTF::UnsignedWithZeroKeyHashTraits<uint64_t>>;
const BindingsMapType& bindingsMap() const { return m_bindingsMap; }
#if USE(METAL)
MTLArgumentEncoder *vertexEncoder() const { return m_vertexEncoder.get(); }
diff --git a/Source/WebCore/platform/graphics/gpu/cocoa/GPUBindGroupLayoutMetal.mm b/Source/WebCore/platform/graphics/gpu/cocoa/GPUBindGroupLayoutMetal.mm
index e2ed11a..35ae3c9 100644
--- a/Source/WebCore/platform/graphics/gpu/cocoa/GPUBindGroupLayoutMetal.mm
+++ b/Source/WebCore/platform/graphics/gpu/cocoa/GPUBindGroupLayoutMetal.mm
@@ -77,6 +77,18 @@
return encoder;
};
+static RetainPtr<MTLArgumentDescriptor> argumentDescriptor(MTLDataType dataType, NSUInteger index)
+{
+ RetainPtr<MTLArgumentDescriptor> mtlArgument;
+ BEGIN_BLOCK_OBJC_EXCEPTIONS;
+ mtlArgument = adoptNS([MTLArgumentDescriptor new]);
+ END_BLOCK_OBJC_EXCEPTIONS;
+
+ [mtlArgument setDataType:dataType];
+ [mtlArgument setIndex:index];
+ return mtlArgument;
+}
+
RefPtr<GPUBindGroupLayout> GPUBindGroupLayout::tryCreate(const GPUDevice& device, const GPUBindGroupLayoutDescriptor& descriptor)
{
if (!device.platformDevice()) {
@@ -87,47 +99,72 @@
ArgumentArray vertexArgsArray, fragmentArgsArray, computeArgsArray;
BindingsMapType bindingsMap;
+ unsigned internalName = 0;
+ unsigned internalLengthBase = descriptor.bindings.size();
for (const auto& binding : descriptor.bindings) {
- if (!bindingsMap.add(binding.binding, binding)) {
+ Optional<unsigned> extraIndex;
+ auto internalDetails = ([&]() -> GPUBindGroupLayout::InternalBindingDetails {
+ switch (binding.type) {
+ case GPUBindingType::UniformBuffer:
+ extraIndex = internalLengthBase++;
+ return GPUBindGroupLayout::UniformBuffer { *extraIndex };
+ case GPUBindingType::DynamicUniformBuffer:
+ extraIndex = internalLengthBase++;
+ return GPUBindGroupLayout::DynamicUniformBuffer { *extraIndex };
+ case GPUBindingType::Sampler:
+ return GPUBindGroupLayout::Sampler { };
+ case GPUBindingType::SampledTexture:
+ return GPUBindGroupLayout::SampledTexture { };
+ case GPUBindingType::StorageBuffer:
+ extraIndex = internalLengthBase++;
+ return GPUBindGroupLayout::StorageBuffer { *extraIndex };
+ default:
+ ASSERT(binding.type == GPUBindingType::DynamicStorageBuffer);
+ extraIndex = internalLengthBase++;
+ return GPUBindGroupLayout::DynamicStorageBuffer { *extraIndex };
+ }
+ })();
+ Binding bindingDetails = { binding, internalName++, WTFMove(internalDetails) };
+ if (!bindingsMap.add(binding.binding, bindingDetails)) {
LOG(WebGPU, "GPUBindGroupLayout::tryCreate(): Duplicate binding %u found in GPUBindGroupLayoutDescriptor!", binding.binding);
return nullptr;
}
- RetainPtr<MTLArgumentDescriptor> mtlArgument;
+ RetainPtr<MTLArgumentDescriptor> mtlArgument = argumentDescriptor(MTLDataTypeForBindingType(binding.type), bindingDetails.internalName);
- BEGIN_BLOCK_OBJC_EXCEPTIONS;
- mtlArgument = adoptNS([MTLArgumentDescriptor new]);
- END_BLOCK_OBJC_EXCEPTIONS;
if (!mtlArgument) {
LOG(WebGPU, "GPUBindGroupLayout::tryCreate(): Unable to create MTLArgumentDescriptor for binding %u!", binding.binding);
return nullptr;
}
- [mtlArgument setDataType:MTLDataTypeForBindingType(binding.type)];
- [mtlArgument setIndex:binding.binding];
-
- if (binding.visibility & GPUShaderStageBit::Flags::Vertex)
- appendArgumentToArray(vertexArgsArray, mtlArgument);
- if (binding.visibility & GPUShaderStageBit::Flags::Fragment)
- appendArgumentToArray(fragmentArgsArray, mtlArgument);
- if (binding.visibility & GPUShaderStageBit::Flags::Compute)
- appendArgumentToArray(computeArgsArray, mtlArgument);
+ auto addIndices = [&](ArgumentArray& array) -> bool {
+ appendArgumentToArray(array, mtlArgument);
+ if (extraIndex) {
+ RetainPtr<MTLArgumentDescriptor> mtlArgument = argumentDescriptor(MTLDataTypeUInt2, *extraIndex);
+ if (!mtlArgument) {
+ LOG(WebGPU, "GPUBindGroupLayout::tryCreate(): Unable to create MTLArgumentDescriptor for binding %u!", binding.binding);
+ return false;
+ }
+ appendArgumentToArray(array, mtlArgument);
+ }
+ return true;
+ };
+ if ((binding.visibility & GPUShaderStageBit::Flags::Vertex) && !addIndices(vertexArgsArray))
+ return nullptr;
+ if ((binding.visibility & GPUShaderStageBit::Flags::Fragment) && !addIndices(fragmentArgsArray))
+ return nullptr;
+ if ((binding.visibility & GPUShaderStageBit::Flags::Compute) && !addIndices(computeArgsArray))
+ return nullptr;
}
RetainPtr<MTLArgumentEncoder> vertex, fragment, compute;
- if (vertexArgsArray) {
- if (!(vertex = tryCreateMtlArgumentEncoder(device, vertexArgsArray)))
- return nullptr;
- }
- if (fragmentArgsArray) {
- if (!(fragment = tryCreateMtlArgumentEncoder(device, fragmentArgsArray)))
- return nullptr;
- }
- if (computeArgsArray) {
- if (!(compute = tryCreateMtlArgumentEncoder(device, computeArgsArray)))
- return nullptr;
- }
+ if (vertexArgsArray && !(vertex = tryCreateMtlArgumentEncoder(device, vertexArgsArray)))
+ return nullptr;
+ if (fragmentArgsArray && !(fragment = tryCreateMtlArgumentEncoder(device, fragmentArgsArray)))
+ return nullptr;
+ if (computeArgsArray && !(compute = tryCreateMtlArgumentEncoder(device, computeArgsArray)))
+ return nullptr;
return adoptRef(new GPUBindGroupLayout(WTFMove(bindingsMap), WTFMove(vertex), WTFMove(fragment), WTFMove(compute)));
}
diff --git a/Source/WebCore/platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm b/Source/WebCore/platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm
index da2c20d..6262e5f 100644
--- a/Source/WebCore/platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm
+++ b/Source/WebCore/platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm
@@ -72,13 +72,15 @@
return GPUBufferBinding { bufferBinding.buffer.copyRef(), bufferBinding.offset, bufferBinding.size };
}
-static void setBufferOnEncoder(MTLArgumentEncoder *argumentEncoder, const GPUBufferBinding& bufferBinding, unsigned index)
+static void setBufferOnEncoder(MTLArgumentEncoder *argumentEncoder, const GPUBufferBinding& bufferBinding, unsigned name, unsigned lengthName)
{
ASSERT(argumentEncoder && bufferBinding.buffer->platformBuffer());
BEGIN_BLOCK_OBJC_EXCEPTIONS;
// Bounds check when converting GPUBufferBinding ensures that NSUInteger cast of uint64_t offset is safe.
- [argumentEncoder setBuffer:bufferBinding.buffer->platformBuffer() offset:static_cast<NSUInteger>(bufferBinding.offset) atIndex:index];
+ [argumentEncoder setBuffer:bufferBinding.buffer->platformBuffer() offset:static_cast<NSUInteger>(bufferBinding.offset) atIndex:name];
+ void* lengthPointer = [argumentEncoder constantDataAtIndex:lengthName];
+ memcpy(lengthPointer, &bufferBinding.size, sizeof(uint64_t));
END_BLOCK_OBJC_EXCEPTIONS;
}
@@ -171,12 +173,12 @@
return nullptr;
}
auto layoutBinding = layoutIterator->value;
- if (layoutBinding.visibility == GPUShaderStageBit::Flags::None)
+ if (layoutBinding.externalBinding.visibility == GPUShaderStageBit::Flags::None)
continue;
- bool isForVertex = layoutBinding.visibility & GPUShaderStageBit::Flags::Vertex;
- bool isForFragment = layoutBinding.visibility & GPUShaderStageBit::Flags::Fragment;
- bool isForCompute = layoutBinding.visibility & GPUShaderStageBit::Flags::Compute;
+ bool isForVertex = layoutBinding.externalBinding.visibility & GPUShaderStageBit::Flags::Vertex;
+ bool isForFragment = layoutBinding.externalBinding.visibility & GPUShaderStageBit::Flags::Fragment;
+ bool isForCompute = layoutBinding.externalBinding.visibility & GPUShaderStageBit::Flags::Compute;
if (isForVertex && !vertexEncoder) {
LOG(WebGPU, "%s: No vertex argument encoder found for binding %u!", functionName, index);
@@ -191,39 +193,39 @@
return nullptr;
}
- switch (layoutBinding.type) {
- // FIXME: Support more resource types.
- // FIXME: We could avoid this ugly switch-on-type using virtual functions if GPUBindingResource is refactored as a base class rather than a Variant.
- case GPUBindingType::UniformBuffer:
- case GPUBindingType::StorageBuffer: {
+ auto handleBuffer = [&](unsigned internalLengthName) -> bool {
auto bufferResource = tryGetResourceAsBufferBinding(resourceBinding.resource, functionName);
if (!bufferResource)
- return nullptr;
+ return false;
if (isForVertex)
- setBufferOnEncoder(vertexEncoder, *bufferResource, index);
+ setBufferOnEncoder(vertexEncoder, *bufferResource, layoutBinding.internalName, internalLengthName);
if (isForFragment)
- setBufferOnEncoder(fragmentEncoder, *bufferResource, index);
+ setBufferOnEncoder(fragmentEncoder, *bufferResource, layoutBinding.internalName, internalLengthName);
if (isForCompute)
- setBufferOnEncoder(computeEncoder, *bufferResource, index);
+ setBufferOnEncoder(computeEncoder, *bufferResource, layoutBinding.internalName, internalLengthName);
boundBuffers.append(bufferResource->buffer.copyRef());
- break;
- }
- case GPUBindingType::Sampler: {
+ return true;
+ };
+
+ auto success = WTF::visit(WTF::makeVisitor([&](GPUBindGroupLayout::UniformBuffer& uniformBuffer) -> bool {
+ return handleBuffer(uniformBuffer.internalLengthName);
+ }, [&](GPUBindGroupLayout::DynamicUniformBuffer& dynamicUniformBuffer) -> bool {
+ return handleBuffer(dynamicUniformBuffer.internalLengthName);
+ }, [&](GPUBindGroupLayout::Sampler&) -> bool {
auto samplerState = tryGetResourceAsMtlSampler(resourceBinding.resource, functionName);
if (!samplerState)
- return nullptr;
+ return false;
if (isForVertex)
setSamplerOnEncoder(vertexEncoder, samplerState, index);
if (isForFragment)
setSamplerOnEncoder(fragmentEncoder, samplerState, index);
if (isForCompute)
setSamplerOnEncoder(computeEncoder, samplerState, index);
- break;
- }
- case GPUBindingType::SampledTexture: {
+ return true;
+ }, [&](GPUBindGroupLayout::SampledTexture&) -> bool {
auto textureResource = tryGetResourceAsTexture(resourceBinding.resource, functionName);
if (!textureResource)
- return nullptr;
+ return false;
if (isForVertex)
setTextureOnEncoder(vertexEncoder, textureResource->platformTexture(), index);
if (isForFragment)
@@ -231,12 +233,14 @@
if (isForCompute)
setTextureOnEncoder(computeEncoder, textureResource->platformTexture(), index);
boundTextures.append(textureResource.releaseNonNull());
- break;
- }
- default:
- LOG(WebGPU, "%s: Resource type not yet implemented.", functionName);
+ return true;
+ }, [&](GPUBindGroupLayout::StorageBuffer& storageBuffer) -> bool {
+ return handleBuffer(storageBuffer.internalLengthName);
+ }, [&](GPUBindGroupLayout::DynamicStorageBuffer& dynamicStorageBuffer) -> bool {
+ return handleBuffer(dynamicStorageBuffer.internalLengthName);
+ }), layoutBinding.internalBindingDetails);
+ if (!success)
return nullptr;
- }
}
return adoptRef(new GPUBindGroup(WTFMove(vertexArgsBuffer), WTFMove(fragmentArgsBuffer), WTFMove(computeArgsBuffer), WTFMove(boundBuffers), WTFMove(boundTextures)));
diff --git a/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm b/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm
index 2bb6204..4a9eebb 100644
--- a/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm
+++ b/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm
@@ -110,20 +110,21 @@
return result;
}
-static Optional<WHLSL::BindingType> convertBindingType(GPUBindingType type)
+static Optional<WHLSL::Binding::BindingDetails> convertBindingType(GPUBindGroupLayout::InternalBindingDetails internalBindingDetails)
{
- switch (type) {
- case GPUBindingType::UniformBuffer:
- return WHLSL::BindingType::UniformBuffer;
- case GPUBindingType::Sampler:
- return WHLSL::BindingType::Sampler;
- case GPUBindingType::SampledTexture:
- return WHLSL::BindingType::Texture;
- case GPUBindingType::StorageBuffer:
- return WHLSL::BindingType::StorageBuffer;
- default:
+ return WTF::visit(WTF::makeVisitor([&](GPUBindGroupLayout::UniformBuffer uniformBuffer) -> Optional<WHLSL::Binding::BindingDetails> {
+ return { WHLSL::UniformBufferBinding { uniformBuffer.internalLengthName } };
+ }, [&](GPUBindGroupLayout::DynamicUniformBuffer) -> Optional<WHLSL::Binding::BindingDetails> {
return WTF::nullopt;
- }
+ }, [&](GPUBindGroupLayout::Sampler) -> Optional<WHLSL::Binding::BindingDetails> {
+ return { WHLSL::SamplerBinding { } };
+ }, [&](GPUBindGroupLayout::SampledTexture) -> Optional<WHLSL::Binding::BindingDetails> {
+ return { WHLSL::TextureBinding { } };
+ }, [&](GPUBindGroupLayout::StorageBuffer storageBuffer) -> Optional<WHLSL::Binding::BindingDetails> {
+ return { WHLSL::StorageBufferBinding { storageBuffer.internalLengthName } };
+ }, [&](GPUBindGroupLayout::DynamicStorageBuffer) -> Optional<WHLSL::Binding::BindingDetails> {
+ return WTF::nullopt;
+ }), internalBindingDetails);
}
static Optional<WHLSL::TextureFormat> convertTextureFormat(GPUTextureFormat format)
@@ -377,16 +378,17 @@
WHLSL::BindGroup bindGroup;
bindGroup.name = static_cast<unsigned>(i);
for (const auto& keyValuePair : bindGroupLayout->bindingsMap()) {
- const auto& gpuBindGroupLayoutBinding = keyValuePair.value;
+ const auto& bindingDetails = keyValuePair.value;
WHLSL::Binding binding;
- binding.visibility = convertShaderStageFlags(gpuBindGroupLayoutBinding.visibility);
- if (auto bindingType = convertBindingType(gpuBindGroupLayoutBinding.type))
- binding.bindingType = *bindingType;
+ binding.visibility = convertShaderStageFlags(bindingDetails.externalBinding.visibility);
+ if (auto bindingType = convertBindingType(bindingDetails.internalBindingDetails))
+ binding.binding = *bindingType;
else
return WTF::nullopt;
- if (gpuBindGroupLayoutBinding.binding > std::numeric_limits<unsigned>::max())
+ if (bindingDetails.externalBinding.binding > std::numeric_limits<unsigned>::max())
return WTF::nullopt;
- binding.name = static_cast<unsigned>(gpuBindGroupLayoutBinding.binding);
+ binding.externalName = bindingDetails.externalBinding.binding;
+ binding.internalName = bindingDetails.internalName;
bindGroup.bindings.append(WTFMove(binding));
}
result.append(WTFMove(bindGroup));
