tint: Add support for workgroupUniformLoad

Accept any type in the intrinsics definition, and then manually
validate that there are no atomics in the type. Add manual E2E tests
for composite types.

Use the BuiltinPolyfill transform to implement it for all backends.

Update the uniformity analysis with special-case tags for the builtin.

Fixed: tint:1780
Change-Id: I95786dff4df70a0b16ed1c53b853b5d0ec6bc501
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/114862
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: James Price <jrprice@google.com>
Kokoro: James Price <jrprice@google.com>

test/tint/builtins/workgroupUniformLoad/array.wgsl

@@ -0,0 +1,5 @@
+var<workgroup> v : array<i32, 4>;
+
+fn foo() -> array<i32, 4> {
+  return workgroupUniformLoad(&v);
+}

test/tint/builtins/workgroupUniformLoad/array.wgsl.expected.dxc.hlsl

@@ -0,0 +1,19 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared int v[4];
+
+typedef int tint_workgroupUniformLoad_v_ret[4];
+tint_workgroupUniformLoad_v_ret tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const int result[4] = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+typedef int foo_ret[4];
+foo_ret foo() {
+  return tint_workgroupUniformLoad_v();
+}

test/tint/builtins/workgroupUniformLoad/array.wgsl.expected.fxc.hlsl

@@ -0,0 +1,19 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared int v[4];
+
+typedef int tint_workgroupUniformLoad_v_ret[4];
+tint_workgroupUniformLoad_v_ret tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const int result[4] = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+typedef int foo_ret[4];
+foo_ret foo() {
+  return tint_workgroupUniformLoad_v();
+}

test/tint/builtins/workgroupUniformLoad/array.wgsl.expected.glsl

@@ -0,0 +1,18 @@
+#version 310 es
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void unused_entry_point() {
+  return;
+}
+shared int v[4];
+int[4] tint_workgroupUniformLoad_v() {
+  barrier();
+  int result[4] = v;
+  barrier();
+  return result;
+}
+
+int[4] foo() {
+  return tint_workgroupUniformLoad_v();
+}
+

test/tint/builtins/workgroupUniformLoad/array.wgsl.expected.msl

@@ -0,0 +1,27 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+tint_array<int, 4> tint_workgroupUniformLoad(threadgroup tint_array<int, 4>* const p) {
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  tint_array<int, 4> const result = *(p);
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  return result;
+}
+
+tint_array<int, 4> foo(threadgroup tint_array<int, 4>* const tint_symbol) {
+  return tint_workgroupUniformLoad(tint_symbol);
+}
+

test/tint/builtins/workgroupUniformLoad/array.wgsl.expected.spvasm

@@ -0,0 +1,41 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 22
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %unused_entry_point "unused_entry_point"
+               OpExecutionMode %unused_entry_point LocalSize 1 1 1
+               OpName %v "v"
+               OpName %unused_entry_point "unused_entry_point"
+               OpName %tint_workgroupUniformLoad_v "tint_workgroupUniformLoad_v"
+               OpName %foo "foo"
+               OpDecorate %_arr_int_uint_4 ArrayStride 4
+        %int = OpTypeInt 32 1
+       %uint = OpTypeInt 32 0
+     %uint_4 = OpConstant %uint 4
+%_arr_int_uint_4 = OpTypeArray %int %uint_4
+%_ptr_Workgroup__arr_int_uint_4 = OpTypePointer Workgroup %_arr_int_uint_4
+          %v = OpVariable %_ptr_Workgroup__arr_int_uint_4 Workgroup
+       %void = OpTypeVoid
+          %7 = OpTypeFunction %void
+         %11 = OpTypeFunction %_arr_int_uint_4
+     %uint_2 = OpConstant %uint 2
+   %uint_264 = OpConstant %uint 264
+%unused_entry_point = OpFunction %void None %7
+         %10 = OpLabel
+               OpReturn
+               OpFunctionEnd
+%tint_workgroupUniformLoad_v = OpFunction %_arr_int_uint_4 None %11
+         %13 = OpLabel
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+         %17 = OpLoad %_arr_int_uint_4 %v
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+               OpReturnValue %17
+               OpFunctionEnd
+        %foo = OpFunction %_arr_int_uint_4 None %11
+         %20 = OpLabel
+         %21 = OpFunctionCall %_arr_int_uint_4 %tint_workgroupUniformLoad_v
+               OpReturnValue %21
+               OpFunctionEnd

test/tint/builtins/workgroupUniformLoad/array.wgsl.expected.wgsl

@@ -0,0 +1,5 @@
+var<workgroup> v : array<i32, 4>;
+
+fn foo() -> array<i32, 4> {
+  return workgroupUniformLoad(&(v));
+}

test/tint/builtins/workgroupUniformLoad/array_overridable_count.wgsl

@@ -0,0 +1,7 @@
+// flags: --overrides wgsize=64
+override wgsize : i32;
+var<workgroup> v : array<i32, wgsize * 2>;
+
+fn foo() -> i32 {
+  return workgroupUniformLoad(&v)[0];
+}

test/tint/builtins/workgroupUniformLoad/array_overridable_count.wgsl.expected.dxc.hlsl

@@ -0,0 +1,19 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared int v[128];
+
+typedef int tint_workgroupUniformLoad_v_ret[128];
+tint_workgroupUniformLoad_v_ret tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const int result[128] = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+int foo() {
+  const int tint_symbol[128] = tint_workgroupUniformLoad_v();
+  return tint_symbol[0];
+}

test/tint/builtins/workgroupUniformLoad/array_overridable_count.wgsl.expected.fxc.hlsl

@@ -0,0 +1,19 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared int v[128];
+
+typedef int tint_workgroupUniformLoad_v_ret[128];
+tint_workgroupUniformLoad_v_ret tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const int result[128] = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+int foo() {
+  const int tint_symbol[128] = tint_workgroupUniformLoad_v();
+  return tint_symbol[0];
+}

test/tint/builtins/workgroupUniformLoad/array_overridable_count.wgsl.expected.glsl

@@ -0,0 +1,19 @@
+#version 310 es
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void unused_entry_point() {
+  return;
+}
+shared int v[128];
+int[128] tint_workgroupUniformLoad_v() {
+  barrier();
+  int result[128] = v;
+  barrier();
+  return result;
+}
+
+int foo() {
+  int tint_symbol[128] = tint_workgroupUniformLoad_v();
+  return tint_symbol[0];
+}
+

test/tint/builtins/workgroupUniformLoad/array_overridable_count.wgsl.expected.msl

@@ -0,0 +1,28 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+tint_array<int, 128> tint_workgroupUniformLoad(threadgroup tint_array<int, 128>* const p) {
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  tint_array<int, 128> const result = *(p);
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  return result;
+}
+
+int foo(threadgroup tint_array<int, 128>* const tint_symbol_1) {
+  tint_array<int, 128> const tint_symbol = tint_workgroupUniformLoad(tint_symbol_1);
+  return tint_symbol[0];
+}
+

test/tint/builtins/workgroupUniformLoad/array_overridable_count.wgsl.expected.spvasm

@@ -0,0 +1,44 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 25
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %unused_entry_point "unused_entry_point"
+               OpExecutionMode %unused_entry_point LocalSize 1 1 1
+               OpName %v "v"
+               OpName %unused_entry_point "unused_entry_point"
+               OpName %tint_workgroupUniformLoad_v "tint_workgroupUniformLoad_v"
+               OpName %foo "foo"
+               OpDecorate %_arr_int_uint_128 ArrayStride 4
+        %int = OpTypeInt 32 1
+       %uint = OpTypeInt 32 0
+   %uint_128 = OpConstant %uint 128
+%_arr_int_uint_128 = OpTypeArray %int %uint_128
+%_ptr_Workgroup__arr_int_uint_128 = OpTypePointer Workgroup %_arr_int_uint_128
+          %v = OpVariable %_ptr_Workgroup__arr_int_uint_128 Workgroup
+       %void = OpTypeVoid
+          %7 = OpTypeFunction %void
+         %11 = OpTypeFunction %_arr_int_uint_128
+     %uint_2 = OpConstant %uint 2
+   %uint_264 = OpConstant %uint 264
+         %19 = OpTypeFunction %int
+         %23 = OpConstantNull %int
+%unused_entry_point = OpFunction %void None %7
+         %10 = OpLabel
+               OpReturn
+               OpFunctionEnd
+%tint_workgroupUniformLoad_v = OpFunction %_arr_int_uint_128 None %11
+         %13 = OpLabel
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+         %17 = OpLoad %_arr_int_uint_128 %v
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+               OpReturnValue %17
+               OpFunctionEnd
+        %foo = OpFunction %int None %19
+         %21 = OpLabel
+         %22 = OpFunctionCall %_arr_int_uint_128 %tint_workgroupUniformLoad_v
+         %24 = OpCompositeExtract %int %22 0
+               OpReturnValue %24
+               OpFunctionEnd

test/tint/builtins/workgroupUniformLoad/array_overridable_count.wgsl.expected.wgsl

@@ -0,0 +1,7 @@
+const wgsize : i32 = 64i;
+
+var<workgroup> v : array<i32, (wgsize * 2)>;
+
+fn foo() -> i32 {
+  return workgroupUniformLoad(&(v))[0];
+}

test/tint/builtins/workgroupUniformLoad/array_overridable_count_aliased.wgsl

@@ -0,0 +1,8 @@
+// flags: --overrides wgsize=64
+override wgsize : i32;
+type Array = array<i32, wgsize * 2>;
+var<workgroup> v : Array;
+
+fn foo() -> i32 {
+  return workgroupUniformLoad(&v)[0];
+}

test/tint/builtins/workgroupUniformLoad/array_overridable_count_aliased.wgsl.expected.dxc.hlsl

@@ -0,0 +1,19 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared int v[128];
+
+typedef int tint_workgroupUniformLoad_v_ret[128];
+tint_workgroupUniformLoad_v_ret tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const int result[128] = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+int foo() {
+  const int tint_symbol[128] = tint_workgroupUniformLoad_v();
+  return tint_symbol[0];
+}

test/tint/builtins/workgroupUniformLoad/array_overridable_count_aliased.wgsl.expected.fxc.hlsl

@@ -0,0 +1,19 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared int v[128];
+
+typedef int tint_workgroupUniformLoad_v_ret[128];
+tint_workgroupUniformLoad_v_ret tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const int result[128] = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+int foo() {
+  const int tint_symbol[128] = tint_workgroupUniformLoad_v();
+  return tint_symbol[0];
+}

test/tint/builtins/workgroupUniformLoad/array_overridable_count_aliased.wgsl.expected.glsl

@@ -0,0 +1,19 @@
+#version 310 es
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void unused_entry_point() {
+  return;
+}
+shared int v[128];
+int[128] tint_workgroupUniformLoad_v() {
+  barrier();
+  int result[128] = v;
+  barrier();
+  return result;
+}
+
+int foo() {
+  int tint_symbol[128] = tint_workgroupUniformLoad_v();
+  return tint_symbol[0];
+}
+

test/tint/builtins/workgroupUniformLoad/array_overridable_count_aliased.wgsl.expected.msl

@@ -0,0 +1,28 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+tint_array<int, 128> tint_workgroupUniformLoad(threadgroup tint_array<int, 128>* const p) {
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  tint_array<int, 128> const result = *(p);
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  return result;
+}
+
+int foo(threadgroup tint_array<int, 128>* const tint_symbol_1) {
+  tint_array<int, 128> const tint_symbol = tint_workgroupUniformLoad(tint_symbol_1);
+  return tint_symbol[0];
+}
+

test/tint/builtins/workgroupUniformLoad/array_overridable_count_aliased.wgsl.expected.spvasm

@@ -0,0 +1,44 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 25
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %unused_entry_point "unused_entry_point"
+               OpExecutionMode %unused_entry_point LocalSize 1 1 1
+               OpName %v "v"
+               OpName %unused_entry_point "unused_entry_point"
+               OpName %tint_workgroupUniformLoad_v "tint_workgroupUniformLoad_v"
+               OpName %foo "foo"
+               OpDecorate %_arr_int_uint_128 ArrayStride 4
+        %int = OpTypeInt 32 1
+       %uint = OpTypeInt 32 0
+   %uint_128 = OpConstant %uint 128
+%_arr_int_uint_128 = OpTypeArray %int %uint_128
+%_ptr_Workgroup__arr_int_uint_128 = OpTypePointer Workgroup %_arr_int_uint_128
+          %v = OpVariable %_ptr_Workgroup__arr_int_uint_128 Workgroup
+       %void = OpTypeVoid
+          %7 = OpTypeFunction %void
+         %11 = OpTypeFunction %_arr_int_uint_128
+     %uint_2 = OpConstant %uint 2
+   %uint_264 = OpConstant %uint 264
+         %19 = OpTypeFunction %int
+         %23 = OpConstantNull %int
+%unused_entry_point = OpFunction %void None %7
+         %10 = OpLabel
+               OpReturn
+               OpFunctionEnd
+%tint_workgroupUniformLoad_v = OpFunction %_arr_int_uint_128 None %11
+         %13 = OpLabel
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+         %17 = OpLoad %_arr_int_uint_128 %v
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+               OpReturnValue %17
+               OpFunctionEnd
+        %foo = OpFunction %int None %19
+         %21 = OpLabel
+         %22 = OpFunctionCall %_arr_int_uint_128 %tint_workgroupUniformLoad_v
+         %24 = OpCompositeExtract %int %22 0
+               OpReturnValue %24
+               OpFunctionEnd

test/tint/builtins/workgroupUniformLoad/array_overridable_count_aliased.wgsl.expected.wgsl

@@ -0,0 +1,9 @@
+const wgsize : i32 = 64i;
+
+type Array = array<i32, (wgsize * 2)>;
+
+var<workgroup> v : Array;
+
+fn foo() -> i32 {
+  return workgroupUniformLoad(&(v))[0];
+}

test/tint/builtins/workgroupUniformLoad/bool.wgsl

@@ -0,0 +1,5 @@
+var<workgroup> v : bool;
+
+fn foo() -> bool {
+  return workgroupUniformLoad(&v);
+}

test/tint/builtins/workgroupUniformLoad/bool.wgsl.expected.dxc.hlsl

@@ -0,0 +1,17 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared bool v;
+
+bool tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const bool result = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+bool foo() {
+  return tint_workgroupUniformLoad_v();
+}

test/tint/builtins/workgroupUniformLoad/bool.wgsl.expected.fxc.hlsl

@@ -0,0 +1,17 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared bool v;
+
+bool tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const bool result = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+bool foo() {
+  return tint_workgroupUniformLoad_v();
+}

test/tint/builtins/workgroupUniformLoad/bool.wgsl.expected.glsl

@@ -0,0 +1,18 @@
+#version 310 es
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void unused_entry_point() {
+  return;
+}
+shared bool v;
+bool tint_workgroupUniformLoad_v() {
+  barrier();
+  bool result = v;
+  barrier();
+  return result;
+}
+
+bool foo() {
+  return tint_workgroupUniformLoad_v();
+}
+

test/tint/builtins/workgroupUniformLoad/bool.wgsl.expected.msl

@@ -0,0 +1,14 @@
+#include <metal_stdlib>
+
+using namespace metal;
+bool tint_workgroupUniformLoad(threadgroup bool* const p) {
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  bool const result = *(p);
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  return result;
+}
+
+bool foo(threadgroup bool* const tint_symbol) {
+  return tint_workgroupUniformLoad(tint_symbol);
+}
+

test/tint/builtins/workgroupUniformLoad/bool.wgsl.expected.spvasm

@@ -0,0 +1,38 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 20
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %unused_entry_point "unused_entry_point"
+               OpExecutionMode %unused_entry_point LocalSize 1 1 1
+               OpName %v "v"
+               OpName %unused_entry_point "unused_entry_point"
+               OpName %tint_workgroupUniformLoad_v "tint_workgroupUniformLoad_v"
+               OpName %foo "foo"
+       %bool = OpTypeBool
+%_ptr_Workgroup_bool = OpTypePointer Workgroup %bool
+          %v = OpVariable %_ptr_Workgroup_bool Workgroup
+       %void = OpTypeVoid
+          %4 = OpTypeFunction %void
+          %8 = OpTypeFunction %bool
+       %uint = OpTypeInt 32 0
+     %uint_2 = OpConstant %uint 2
+   %uint_264 = OpConstant %uint 264
+%unused_entry_point = OpFunction %void None %4
+          %7 = OpLabel
+               OpReturn
+               OpFunctionEnd
+%tint_workgroupUniformLoad_v = OpFunction %bool None %8
+         %10 = OpLabel
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+         %15 = OpLoad %bool %v
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+               OpReturnValue %15
+               OpFunctionEnd
+        %foo = OpFunction %bool None %8
+         %18 = OpLabel
+         %19 = OpFunctionCall %bool %tint_workgroupUniformLoad_v
+               OpReturnValue %19
+               OpFunctionEnd

test/tint/builtins/workgroupUniformLoad/bool.wgsl.expected.wgsl

@@ -0,0 +1,5 @@
+var<workgroup> v : bool;
+
+fn foo() -> bool {
+  return workgroupUniformLoad(&(v));
+}

test/tint/builtins/workgroupUniformLoad/for_loop.wgsl

@@ -0,0 +1,7 @@
+var<workgroup> a : i32;
+var<workgroup> b : i32;
+
+fn foo() {
+  for (var i = 0; i < workgroupUniformLoad(&a); i += workgroupUniformLoad(&b)) {
+  }
+}

test/tint/builtins/workgroupUniformLoad/for_loop.wgsl.expected.dxc.hlsl

@@ -0,0 +1,42 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared int a;
+
+int tint_workgroupUniformLoad_a() {
+  GroupMemoryBarrierWithGroupSync();
+  const int result = a;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+groupshared int b;
+
+int tint_workgroupUniformLoad_b() {
+  GroupMemoryBarrierWithGroupSync();
+  const int result = b;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+void foo() {
+  {
+    int i = 0;
+    while (true) {
+      const int tint_symbol = i;
+      const int tint_symbol_1 = tint_workgroupUniformLoad_a();
+      if (!((tint_symbol < tint_symbol_1))) {
+        break;
+      }
+      {
+      }
+      {
+        const int tint_symbol_2 = i;
+        const int tint_symbol_3 = tint_workgroupUniformLoad_b();
+        i = (tint_symbol_2 + tint_symbol_3);
+      }
+    }
+  }
+}

test/tint/builtins/workgroupUniformLoad/for_loop.wgsl.expected.fxc.hlsl

@@ -0,0 +1,42 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared int a;
+
+int tint_workgroupUniformLoad_a() {
+  GroupMemoryBarrierWithGroupSync();
+  const int result = a;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+groupshared int b;
+
+int tint_workgroupUniformLoad_b() {
+  GroupMemoryBarrierWithGroupSync();
+  const int result = b;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+void foo() {
+  {
+    int i = 0;
+    while (true) {
+      const int tint_symbol = i;
+      const int tint_symbol_1 = tint_workgroupUniformLoad_a();
+      if (!((tint_symbol < tint_symbol_1))) {
+        break;
+      }
+      {
+      }
+      {
+        const int tint_symbol_2 = i;
+        const int tint_symbol_3 = tint_workgroupUniformLoad_b();
+        i = (tint_symbol_2 + tint_symbol_3);
+      }
+    }
+  }
+}

test/tint/builtins/workgroupUniformLoad/for_loop.wgsl.expected.glsl

@@ -0,0 +1,42 @@
+#version 310 es
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void unused_entry_point() {
+  return;
+}
+shared int a;
+int tint_workgroupUniformLoad_a() {
+  barrier();
+  int result = a;
+  barrier();
+  return result;
+}
+
+shared int b;
+int tint_workgroupUniformLoad_b() {
+  barrier();
+  int result = b;
+  barrier();
+  return result;
+}
+
+void foo() {
+  {
+    int i = 0;
+    while (true) {
+      int tint_symbol = i;
+      int tint_symbol_1 = tint_workgroupUniformLoad_a();
+      if (!((tint_symbol < tint_symbol_1))) {
+        break;
+      }
+      {
+      }
+      {
+        int tint_symbol_2 = i;
+        int tint_symbol_3 = tint_workgroupUniformLoad_b();
+        i = (tint_symbol_2 + tint_symbol_3);
+      }
+    }
+  }
+}
+

test/tint/builtins/workgroupUniformLoad/for_loop.wgsl.expected.msl

@@ -0,0 +1,30 @@
+#include <metal_stdlib>
+
+using namespace metal;
+int tint_workgroupUniformLoad(threadgroup int* const p) {
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  int const result = *(p);
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  return result;
+}
+
+void foo(threadgroup int* const tint_symbol_4, threadgroup int* const tint_symbol_5) {
+  {
+    int i = 0;
+    while (true) {
+      int const tint_symbol = i;
+      int const tint_symbol_1 = tint_workgroupUniformLoad(tint_symbol_4);
+      if (!((tint_symbol < tint_symbol_1))) {
+        break;
+      }
+      {
+      }
+      {
+        int const tint_symbol_2 = i;
+        int const tint_symbol_3 = tint_workgroupUniformLoad(tint_symbol_5);
+        i = as_type<int>((as_type<uint>(tint_symbol_2) + as_type<uint>(tint_symbol_3)));
+      }
+    }
+  }
+}
+

test/tint/builtins/workgroupUniformLoad/for_loop.wgsl.expected.spvasm

@@ -0,0 +1,75 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 42
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %unused_entry_point "unused_entry_point"
+               OpExecutionMode %unused_entry_point LocalSize 1 1 1
+               OpName %a "a"
+               OpName %b "b"
+               OpName %unused_entry_point "unused_entry_point"
+               OpName %tint_workgroupUniformLoad_a "tint_workgroupUniformLoad_a"
+               OpName %tint_workgroupUniformLoad_b "tint_workgroupUniformLoad_b"
+               OpName %foo "foo"
+               OpName %i "i"
+        %int = OpTypeInt 32 1
+%_ptr_Workgroup_int = OpTypePointer Workgroup %int
+          %a = OpVariable %_ptr_Workgroup_int Workgroup
+          %b = OpVariable %_ptr_Workgroup_int Workgroup
+       %void = OpTypeVoid
+          %5 = OpTypeFunction %void
+          %9 = OpTypeFunction %int
+       %uint = OpTypeInt 32 0
+     %uint_2 = OpConstant %uint 2
+   %uint_264 = OpConstant %uint 264
+         %25 = OpConstantNull %int
+%_ptr_Function_int = OpTypePointer Function %int
+       %bool = OpTypeBool
+%unused_entry_point = OpFunction %void None %5
+          %8 = OpLabel
+               OpReturn
+               OpFunctionEnd
+%tint_workgroupUniformLoad_a = OpFunction %int None %9
+         %11 = OpLabel
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+         %16 = OpLoad %int %a
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+               OpReturnValue %16
+               OpFunctionEnd
+%tint_workgroupUniformLoad_b = OpFunction %int None %9
+         %19 = OpLabel
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+         %21 = OpLoad %int %b
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+               OpReturnValue %21
+               OpFunctionEnd
+        %foo = OpFunction %void None %5
+         %24 = OpLabel
+          %i = OpVariable %_ptr_Function_int Function %25
+               OpStore %i %25
+               OpBranch %28
+         %28 = OpLabel
+               OpLoopMerge %29 %30 None
+               OpBranch %31
+         %31 = OpLabel
+         %32 = OpLoad %int %i
+         %33 = OpFunctionCall %int %tint_workgroupUniformLoad_a
+         %35 = OpSLessThan %bool %32 %33
+         %34 = OpLogicalNot %bool %35
+               OpSelectionMerge %37 None
+               OpBranchConditional %34 %38 %37
+         %38 = OpLabel
+               OpBranch %29
+         %37 = OpLabel
+               OpBranch %30
+         %30 = OpLabel
+         %39 = OpLoad %int %i
+         %40 = OpFunctionCall %int %tint_workgroupUniformLoad_b
+         %41 = OpIAdd %int %39 %40
+               OpStore %i %41
+               OpBranch %28
+         %29 = OpLabel
+               OpReturn
+               OpFunctionEnd

test/tint/builtins/workgroupUniformLoad/for_loop.wgsl.expected.wgsl

@@ -0,0 +1,8 @@
+var<workgroup> a : i32;
+
+var<workgroup> b : i32;
+
+fn foo() {
+  for(var i = 0; (i < workgroupUniformLoad(&(a))); i += workgroupUniformLoad(&(b))) {
+  }
+}

test/tint/builtins/workgroupUniformLoad/for_loops.wgsl.expected.msl

@@ -0,0 +1,30 @@
+#include <metal_stdlib>
+
+using namespace metal;
+int tint_workgroupUniformLoad(threadgroup int* const p) {
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  int const result = *(p);
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  return result;
+}
+
+void foo(threadgroup int* const tint_symbol_4, threadgroup int* const tint_symbol_5) {
+  {
+    int i = 0;
+    while (true) {
+      int const tint_symbol = i;
+      int const tint_symbol_1 = tint_workgroupUniformLoad(tint_symbol_4);
+      if (!((tint_symbol < tint_symbol_1))) {
+        break;
+      }
+      {
+      }
+      {
+        int const tint_symbol_2 = i;
+        int const tint_symbol_3 = tint_workgroupUniformLoad(tint_symbol_5);
+        i = as_type<int>((as_type<uint>(tint_symbol_2) + as_type<uint>(tint_symbol_3)));
+      }
+    }
+  }
+}
+

test/tint/builtins/workgroupUniformLoad/if_condition.wgsl

@@ -0,0 +1,8 @@
+var<workgroup> v : bool;
+
+fn foo() -> i32 {
+  if (workgroupUniformLoad(&v)) {
+    return 42;
+  }
+  return 0;
+}

test/tint/builtins/workgroupUniformLoad/if_condition.wgsl.expected.dxc.hlsl

@@ -0,0 +1,20 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared bool v;
+
+bool tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const bool result = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+int foo() {
+  if (tint_workgroupUniformLoad_v()) {
+    return 42;
+  }
+  return 0;
+}

test/tint/builtins/workgroupUniformLoad/if_condition.wgsl.expected.fxc.hlsl

@@ -0,0 +1,20 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared bool v;
+
+bool tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const bool result = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+int foo() {
+  if (tint_workgroupUniformLoad_v()) {
+    return 42;
+  }
+  return 0;
+}

test/tint/builtins/workgroupUniformLoad/if_condition.wgsl.expected.glsl

@@ -0,0 +1,21 @@
+#version 310 es
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void unused_entry_point() {
+  return;
+}
+shared bool v;
+bool tint_workgroupUniformLoad_v() {
+  barrier();
+  bool result = v;
+  barrier();
+  return result;
+}
+
+int foo() {
+  if (tint_workgroupUniformLoad_v()) {
+    return 42;
+  }
+  return 0;
+}
+

test/tint/builtins/workgroupUniformLoad/if_condition.wgsl.expected.msl

@@ -0,0 +1,17 @@
+#include <metal_stdlib>
+
+using namespace metal;
+bool tint_workgroupUniformLoad(threadgroup bool* const p) {
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  bool const result = *(p);
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  return result;
+}
+
+int foo(threadgroup bool* const tint_symbol) {
+  if (tint_workgroupUniformLoad(tint_symbol)) {
+    return 42;
+  }
+  return 0;
+}
+

test/tint/builtins/workgroupUniformLoad/if_condition.wgsl.expected.spvasm

@@ -0,0 +1,67 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 37
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %unused_entry_point "unused_entry_point"
+               OpExecutionMode %unused_entry_point LocalSize 1 1 1
+               OpName %v "v"
+               OpName %unused_entry_point "unused_entry_point"
+               OpName %tint_workgroupUniformLoad_v "tint_workgroupUniformLoad_v"
+               OpName %foo "foo"
+               OpName %tint_return_flag "tint_return_flag"
+               OpName %tint_return_value "tint_return_value"
+       %bool = OpTypeBool
+%_ptr_Workgroup_bool = OpTypePointer Workgroup %bool
+          %v = OpVariable %_ptr_Workgroup_bool Workgroup
+       %void = OpTypeVoid
+          %4 = OpTypeFunction %void
+          %8 = OpTypeFunction %bool
+       %uint = OpTypeInt 32 0
+     %uint_2 = OpConstant %uint 2
+   %uint_264 = OpConstant %uint 264
+        %int = OpTypeInt 32 1
+         %17 = OpTypeFunction %int
+%_ptr_Function_bool = OpTypePointer Function %bool
+         %23 = OpConstantNull %bool
+%_ptr_Function_int = OpTypePointer Function %int
+         %26 = OpConstantNull %int
+       %true = OpConstantTrue %bool
+     %int_42 = OpConstant %int 42
+%unused_entry_point = OpFunction %void None %4
+          %7 = OpLabel
+               OpReturn
+               OpFunctionEnd
+%tint_workgroupUniformLoad_v = OpFunction %bool None %8
+         %10 = OpLabel
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+         %15 = OpLoad %bool %v
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+               OpReturnValue %15
+               OpFunctionEnd
+        %foo = OpFunction %int None %17
+         %20 = OpLabel
+%tint_return_flag = OpVariable %_ptr_Function_bool Function %23
+%tint_return_value = OpVariable %_ptr_Function_int Function %26
+         %27 = OpFunctionCall %bool %tint_workgroupUniformLoad_v
+               OpSelectionMerge %28 None
+               OpBranchConditional %27 %29 %28
+         %29 = OpLabel
+               OpStore %tint_return_flag %true
+               OpStore %tint_return_value %int_42
+               OpBranch %28
+         %28 = OpLabel
+         %33 = OpLoad %bool %tint_return_flag
+         %32 = OpLogicalNot %bool %33
+               OpSelectionMerge %34 None
+               OpBranchConditional %32 %35 %34
+         %35 = OpLabel
+               OpStore %tint_return_flag %true
+               OpStore %tint_return_value %26
+               OpBranch %34
+         %34 = OpLabel
+         %36 = OpLoad %int %tint_return_value
+               OpReturnValue %36
+               OpFunctionEnd

test/tint/builtins/workgroupUniformLoad/if_condition.wgsl.expected.wgsl

@@ -0,0 +1,8 @@
+var<workgroup> v : bool;
+
+fn foo() -> i32 {
+  if (workgroupUniformLoad(&(v))) {
+    return 42;
+  }
+  return 0;
+}

test/tint/builtins/workgroupUniformLoad/matrix.wgsl

@@ -0,0 +1,5 @@
+var<workgroup> v : mat3x3<f32>;
+
+fn foo() -> mat3x3<f32> {
+  return workgroupUniformLoad(&v);
+}

test/tint/builtins/workgroupUniformLoad/matrix.wgsl.expected.dxc.hlsl

@@ -0,0 +1,17 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared float3x3 v;
+
+float3x3 tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const float3x3 result = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+float3x3 foo() {
+  return tint_workgroupUniformLoad_v();
+}

test/tint/builtins/workgroupUniformLoad/matrix.wgsl.expected.fxc.hlsl

@@ -0,0 +1,17 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared float3x3 v;
+
+float3x3 tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const float3x3 result = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+float3x3 foo() {
+  return tint_workgroupUniformLoad_v();
+}

test/tint/builtins/workgroupUniformLoad/matrix.wgsl.expected.glsl

@@ -0,0 +1,18 @@
+#version 310 es
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void unused_entry_point() {
+  return;
+}
+shared mat3 v;
+mat3 tint_workgroupUniformLoad_v() {
+  barrier();
+  mat3 result = v;
+  barrier();
+  return result;
+}
+
+mat3 foo() {
+  return tint_workgroupUniformLoad_v();
+}
+

test/tint/builtins/workgroupUniformLoad/matrix.wgsl.expected.msl

@@ -0,0 +1,14 @@
+#include <metal_stdlib>
+
+using namespace metal;
+float3x3 tint_workgroupUniformLoad(threadgroup float3x3* const p) {
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  float3x3 const result = *(p);
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  return result;
+}
+
+float3x3 foo(threadgroup float3x3* const tint_symbol) {
+  return tint_workgroupUniformLoad(tint_symbol);
+}
+

test/tint/builtins/workgroupUniformLoad/matrix.wgsl.expected.spvasm

@@ -0,0 +1,40 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 22
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %unused_entry_point "unused_entry_point"
+               OpExecutionMode %unused_entry_point LocalSize 1 1 1
+               OpName %v "v"
+               OpName %unused_entry_point "unused_entry_point"
+               OpName %tint_workgroupUniformLoad_v "tint_workgroupUniformLoad_v"
+               OpName %foo "foo"
+      %float = OpTypeFloat 32
+    %v3float = OpTypeVector %float 3
+%mat3v3float = OpTypeMatrix %v3float 3
+%_ptr_Workgroup_mat3v3float = OpTypePointer Workgroup %mat3v3float
+          %v = OpVariable %_ptr_Workgroup_mat3v3float Workgroup
+       %void = OpTypeVoid
+          %6 = OpTypeFunction %void
+         %10 = OpTypeFunction %mat3v3float
+       %uint = OpTypeInt 32 0
+     %uint_2 = OpConstant %uint 2
+   %uint_264 = OpConstant %uint 264
+%unused_entry_point = OpFunction %void None %6
+          %9 = OpLabel
+               OpReturn
+               OpFunctionEnd
+%tint_workgroupUniformLoad_v = OpFunction %mat3v3float None %10
+         %12 = OpLabel
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+         %17 = OpLoad %mat3v3float %v
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+               OpReturnValue %17
+               OpFunctionEnd
+        %foo = OpFunction %mat3v3float None %10
+         %20 = OpLabel
+         %21 = OpFunctionCall %mat3v3float %tint_workgroupUniformLoad_v
+               OpReturnValue %21
+               OpFunctionEnd

test/tint/builtins/workgroupUniformLoad/matrix.wgsl.expected.wgsl

@@ -0,0 +1,5 @@
+var<workgroup> v : mat3x3<f32>;
+
+fn foo() -> mat3x3<f32> {
+  return workgroupUniformLoad(&(v));
+}

test/tint/builtins/workgroupUniformLoad/structures.wgsl

@@ -0,0 +1,15 @@
+struct Inner {
+  b : bool,
+  v : vec4<i32>,
+  m : mat3x3<f32>,
+}
+
+struct Outer {
+  a : array<Inner, 4>,
+}
+
+var<workgroup> v : Outer;
+
+fn foo() -> Outer {
+  return workgroupUniformLoad(&v);
+}

test/tint/builtins/workgroupUniformLoad/structures.wgsl.expected.dxc.hlsl

@@ -0,0 +1,26 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+struct Inner {
+  bool b;
+  int4 v;
+  float3x3 m;
+};
+struct Outer {
+  Inner a[4];
+};
+
+groupshared Outer v;
+
+Outer tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const Outer result = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+Outer foo() {
+  return tint_workgroupUniformLoad_v();
+}

test/tint/builtins/workgroupUniformLoad/structures.wgsl.expected.fxc.hlsl

@@ -0,0 +1,26 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+struct Inner {
+  bool b;
+  int4 v;
+  float3x3 m;
+};
+struct Outer {
+  Inner a[4];
+};
+
+groupshared Outer v;
+
+Outer tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const Outer result = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+Outer foo() {
+  return tint_workgroupUniformLoad_v();
+}

test/tint/builtins/workgroupUniformLoad/structures.wgsl.expected.glsl

@@ -0,0 +1,28 @@
+#version 310 es
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void unused_entry_point() {
+  return;
+}
+struct Inner {
+  bool b;
+  ivec4 v;
+  mat3 m;
+};
+
+struct Outer {
+  Inner a[4];
+};
+
+shared Outer v;
+Outer tint_workgroupUniformLoad_v() {
+  barrier();
+  Outer result = v;
+  barrier();
+  return result;
+}
+
+Outer foo() {
+  return tint_workgroupUniformLoad_v();
+}
+

test/tint/builtins/workgroupUniformLoad/structures.wgsl.expected.msl

@@ -0,0 +1,37 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+struct Inner {
+  bool b;
+  int4 v;
+  float3x3 m;
+};
+
+struct Outer {
+  tint_array<Inner, 4> a;
+};
+
+Outer tint_workgroupUniformLoad(threadgroup Outer* const p) {
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  Outer const result = *(p);
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  return result;
+}
+
+Outer foo(threadgroup Outer* const tint_symbol) {
+  return tint_workgroupUniformLoad(tint_symbol);
+}
+

test/tint/builtins/workgroupUniformLoad/structures.wgsl.expected.spvasm

@@ -0,0 +1,60 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 29
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %unused_entry_point "unused_entry_point"
+               OpExecutionMode %unused_entry_point LocalSize 1 1 1
+               OpName %Outer "Outer"
+               OpMemberName %Outer 0 "a"
+               OpName %Inner "Inner"
+               OpMemberName %Inner 0 "b"
+               OpMemberName %Inner 1 "v"
+               OpMemberName %Inner 2 "m"
+               OpName %v "v"
+               OpName %unused_entry_point "unused_entry_point"
+               OpName %tint_workgroupUniformLoad_v "tint_workgroupUniformLoad_v"
+               OpName %foo "foo"
+               OpMemberDecorate %Outer 0 Offset 0
+               OpMemberDecorate %Inner 0 Offset 0
+               OpMemberDecorate %Inner 1 Offset 16
+               OpMemberDecorate %Inner 2 Offset 32
+               OpMemberDecorate %Inner 2 ColMajor
+               OpMemberDecorate %Inner 2 MatrixStride 16
+               OpDecorate %_arr_Inner_uint_4 ArrayStride 80
+       %bool = OpTypeBool
+        %int = OpTypeInt 32 1
+      %v4int = OpTypeVector %int 4
+      %float = OpTypeFloat 32
+    %v3float = OpTypeVector %float 3
+%mat3v3float = OpTypeMatrix %v3float 3
+      %Inner = OpTypeStruct %bool %v4int %mat3v3float
+       %uint = OpTypeInt 32 0
+     %uint_4 = OpConstant %uint 4
+%_arr_Inner_uint_4 = OpTypeArray %Inner %uint_4
+      %Outer = OpTypeStruct %_arr_Inner_uint_4
+%_ptr_Workgroup_Outer = OpTypePointer Workgroup %Outer
+          %v = OpVariable %_ptr_Workgroup_Outer Workgroup
+       %void = OpTypeVoid
+         %14 = OpTypeFunction %void
+         %18 = OpTypeFunction %Outer
+     %uint_2 = OpConstant %uint 2
+   %uint_264 = OpConstant %uint 264
+%unused_entry_point = OpFunction %void None %14
+         %17 = OpLabel
+               OpReturn
+               OpFunctionEnd
+%tint_workgroupUniformLoad_v = OpFunction %Outer None %18
+         %20 = OpLabel
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+         %24 = OpLoad %Outer %v
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+               OpReturnValue %24
+               OpFunctionEnd
+        %foo = OpFunction %Outer None %18
+         %27 = OpLabel
+         %28 = OpFunctionCall %Outer %tint_workgroupUniformLoad_v
+               OpReturnValue %28
+               OpFunctionEnd

test/tint/builtins/workgroupUniformLoad/structures.wgsl.expected.wgsl

@@ -0,0 +1,15 @@
+struct Inner {
+  b : bool,
+  v : vec4<i32>,
+  m : mat3x3<f32>,
+}
+
+struct Outer {
+  a : array<Inner, 4>,
+}
+
+var<workgroup> v : Outer;
+
+fn foo() -> Outer {
+  return workgroupUniformLoad(&(v));
+}

test/tint/builtins/workgroupUniformLoad/vec.wgsl

@@ -0,0 +1,5 @@
+var<workgroup> v : vec4<f32>;
+
+fn foo() -> vec4<f32> {
+  return workgroupUniformLoad(&v);
+}

test/tint/builtins/workgroupUniformLoad/vec.wgsl.expected.dxc.hlsl

@@ -0,0 +1,17 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared float4 v;
+
+float4 tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const float4 result = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+float4 foo() {
+  return tint_workgroupUniformLoad_v();
+}

test/tint/builtins/workgroupUniformLoad/vec.wgsl.expected.fxc.hlsl

@@ -0,0 +1,17 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared float4 v;
+
+float4 tint_workgroupUniformLoad_v() {
+  GroupMemoryBarrierWithGroupSync();
+  const float4 result = v;
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+float4 foo() {
+  return tint_workgroupUniformLoad_v();
+}

test/tint/builtins/workgroupUniformLoad/vec.wgsl.expected.glsl

@@ -0,0 +1,18 @@
+#version 310 es
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void unused_entry_point() {
+  return;
+}
+shared vec4 v;
+vec4 tint_workgroupUniformLoad_v() {
+  barrier();
+  vec4 result = v;
+  barrier();
+  return result;
+}
+
+vec4 foo() {
+  return tint_workgroupUniformLoad_v();
+}
+

test/tint/builtins/workgroupUniformLoad/vec.wgsl.expected.msl

@@ -0,0 +1,14 @@
+#include <metal_stdlib>
+
+using namespace metal;
+float4 tint_workgroupUniformLoad(threadgroup float4* const p) {
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  float4 const result = *(p);
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  return result;
+}
+
+float4 foo(threadgroup float4* const tint_symbol) {
+  return tint_workgroupUniformLoad(tint_symbol);
+}
+

test/tint/builtins/workgroupUniformLoad/vec.wgsl.expected.spvasm

@@ -0,0 +1,39 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 21
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %unused_entry_point "unused_entry_point"
+               OpExecutionMode %unused_entry_point LocalSize 1 1 1
+               OpName %v "v"
+               OpName %unused_entry_point "unused_entry_point"
+               OpName %tint_workgroupUniformLoad_v "tint_workgroupUniformLoad_v"
+               OpName %foo "foo"
+      %float = OpTypeFloat 32
+    %v4float = OpTypeVector %float 4
+%_ptr_Workgroup_v4float = OpTypePointer Workgroup %v4float
+          %v = OpVariable %_ptr_Workgroup_v4float Workgroup
+       %void = OpTypeVoid
+          %5 = OpTypeFunction %void
+          %9 = OpTypeFunction %v4float
+       %uint = OpTypeInt 32 0
+     %uint_2 = OpConstant %uint 2
+   %uint_264 = OpConstant %uint 264
+%unused_entry_point = OpFunction %void None %5
+          %8 = OpLabel
+               OpReturn
+               OpFunctionEnd
+%tint_workgroupUniformLoad_v = OpFunction %v4float None %9
+         %11 = OpLabel
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+         %16 = OpLoad %v4float %v
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+               OpReturnValue %16
+               OpFunctionEnd
+        %foo = OpFunction %v4float None %9
+         %19 = OpLabel
+         %20 = OpFunctionCall %v4float %tint_workgroupUniformLoad_v
+               OpReturnValue %20
+               OpFunctionEnd

test/tint/builtins/workgroupUniformLoad/vec.wgsl.expected.wgsl

@@ -0,0 +1,5 @@
+var<workgroup> v : vec4<f32>;
+
+fn foo() -> vec4<f32> {
+  return workgroupUniformLoad(&(v));
+}

test/tint/builtins/workgroupUniformLoad/via_param.wgsl

@@ -0,0 +1,11 @@
+enable chromium_experimental_full_ptr_parameters;
+
+var<workgroup> v : array<i32, 4>;
+
+fn foo(p : ptr<workgroup, i32>) -> i32 {
+  return workgroupUniformLoad(p);
+}
+
+fn bar() -> i32 {
+  return foo(&(v[0]));
+}

test/tint/builtins/workgroupUniformLoad/via_param.wgsl.expected.dxc.hlsl

@@ -0,0 +1,23 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared int v[4];
+
+int tint_workgroupUniformLoad_v_X(uint p[1]) {
+  GroupMemoryBarrierWithGroupSync();
+  const int result = v[p[0]];
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+int foo_v_X(uint p[1]) {
+  const uint tint_symbol[1] = {p[0u]};
+  return tint_workgroupUniformLoad_v_X(tint_symbol);
+}
+
+int bar() {
+  const uint tint_symbol_1[1] = (uint[1])0;
+  return foo_v_X(tint_symbol_1);
+}

test/tint/builtins/workgroupUniformLoad/via_param.wgsl.expected.fxc.hlsl

@@ -0,0 +1,23 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+groupshared int v[4];
+
+int tint_workgroupUniformLoad_v_X(uint p[1]) {
+  GroupMemoryBarrierWithGroupSync();
+  const int result = v[p[0]];
+  GroupMemoryBarrierWithGroupSync();
+  return result;
+}
+
+int foo_v_X(uint p[1]) {
+  const uint tint_symbol[1] = {p[0u]};
+  return tint_workgroupUniformLoad_v_X(tint_symbol);
+}
+
+int bar() {
+  const uint tint_symbol_1[1] = (uint[1])0;
+  return foo_v_X(tint_symbol_1);
+}

test/tint/builtins/workgroupUniformLoad/via_param.wgsl.expected.glsl

@@ -0,0 +1,24 @@
+#version 310 es
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void unused_entry_point() {
+  return;
+}
+shared int v[4];
+int tint_workgroupUniformLoad_v_X(uint p[1]) {
+  barrier();
+  int result = v[p[0]];
+  barrier();
+  return result;
+}
+
+int foo_v_X(uint p[1]) {
+  uint tint_symbol[1] = uint[1](p[0u]);
+  return tint_workgroupUniformLoad_v_X(tint_symbol);
+}
+
+int bar() {
+  uint tint_symbol_1[1] = uint[1](0u);
+  return foo_v_X(tint_symbol_1);
+}
+

test/tint/builtins/workgroupUniformLoad/via_param.wgsl.expected.msl

@@ -0,0 +1,31 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, size_t N>
+struct tint_array {
+    const constant T& operator[](size_t i) const constant { return elements[i]; }
+    device T& operator[](size_t i) device { return elements[i]; }
+    const device T& operator[](size_t i) const device { return elements[i]; }
+    thread T& operator[](size_t i) thread { return elements[i]; }
+    const thread T& operator[](size_t i) const thread { return elements[i]; }
+    threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+    const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+    T elements[N];
+};
+
+int tint_workgroupUniformLoad(threadgroup int* const p) {
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  int const result = *(p);
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  return result;
+}
+
+int foo(threadgroup int* const p) {
+  return tint_workgroupUniformLoad(p);
+}
+
+int bar(threadgroup tint_array<int, 4>* const tint_symbol) {
+  return foo(&((*(tint_symbol))[0]));
+}
+

test/tint/builtins/workgroupUniformLoad/via_param.wgsl.expected.spvasm

@@ -0,0 +1,63 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 38
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %unused_entry_point "unused_entry_point"
+               OpExecutionMode %unused_entry_point LocalSize 1 1 1
+               OpName %v "v"
+               OpName %unused_entry_point "unused_entry_point"
+               OpName %tint_workgroupUniformLoad_v_X "tint_workgroupUniformLoad_v_X"
+               OpName %p "p"
+               OpName %foo_v_X "foo_v_X"
+               OpName %p_0 "p"
+               OpName %bar "bar"
+               OpDecorate %_arr_int_uint_4 ArrayStride 4
+               OpDecorate %_arr_uint_uint_1 ArrayStride 4
+        %int = OpTypeInt 32 1
+       %uint = OpTypeInt 32 0
+     %uint_4 = OpConstant %uint 4
+%_arr_int_uint_4 = OpTypeArray %int %uint_4
+%_ptr_Workgroup__arr_int_uint_4 = OpTypePointer Workgroup %_arr_int_uint_4
+          %v = OpVariable %_ptr_Workgroup__arr_int_uint_4 Workgroup
+       %void = OpTypeVoid
+          %7 = OpTypeFunction %void
+     %uint_1 = OpConstant %uint 1
+%_arr_uint_uint_1 = OpTypeArray %uint %uint_1
+         %11 = OpTypeFunction %int %_arr_uint_uint_1
+     %uint_2 = OpConstant %uint 2
+   %uint_264 = OpConstant %uint 264
+         %20 = OpConstantNull %int
+%_ptr_Workgroup_int = OpTypePointer Workgroup %int
+         %30 = OpConstantNull %uint
+         %33 = OpTypeFunction %int
+         %37 = OpConstantNull %_arr_uint_uint_1
+%unused_entry_point = OpFunction %void None %7
+         %10 = OpLabel
+               OpReturn
+               OpFunctionEnd
+%tint_workgroupUniformLoad_v_X = OpFunction %int None %11
+          %p = OpFunctionParameter %_arr_uint_uint_1
+         %16 = OpLabel
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+         %21 = OpCompositeExtract %uint %p 0
+         %23 = OpAccessChain %_ptr_Workgroup_int %v %21
+         %24 = OpLoad %int %23
+               OpControlBarrier %uint_2 %uint_2 %uint_264
+               OpReturnValue %24
+               OpFunctionEnd
+    %foo_v_X = OpFunction %int None %11
+        %p_0 = OpFunctionParameter %_arr_uint_uint_1
+         %28 = OpLabel
+         %31 = OpCompositeExtract %uint %p_0 0
+         %32 = OpCompositeConstruct %_arr_uint_uint_1 %31
+         %29 = OpFunctionCall %int %tint_workgroupUniformLoad_v_X %32
+               OpReturnValue %29
+               OpFunctionEnd
+        %bar = OpFunction %int None %33
+         %35 = OpLabel
+         %36 = OpFunctionCall %int %foo_v_X %37
+               OpReturnValue %36
+               OpFunctionEnd

test/tint/builtins/workgroupUniformLoad/via_param.wgsl.expected.wgsl

@@ -0,0 +1,11 @@
+enable chromium_experimental_full_ptr_parameters;
+
+var<workgroup> v : array<i32, 4>;
+
+fn foo(p : ptr<workgroup, i32>) -> i32 {
+  return workgroupUniformLoad(p);
+}
+
+fn bar() -> i32 {
+  return foo(&(v[0]));
+}