tint/test-runner: Split expectations for FXC and DXC

Change tint's `--fxc` flag to take the path of the FXC compiler DLL.
Have tint attempt to validate with both FXC and DXC if `--validate` is
passed.

Fix the 'dirsWithNoPassExpectations' logic which looks like it got
broken with the tint -> dawn merge. It also incorrectly applied
filepath.FromSlash() on windows.

Change-Id: I0f46aa5c21bc48a2abc48402c41f846aff4a8633
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/96800
Reviewed-by: Antonio Maiorano <amaiorano@google.com>
Commit-Queue: Ben Clayton <bclayton@chromium.org>

test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_body.wgsl.expected.fxc.hlsl

@@ -0,0 +1,26 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    [loop] for(int i = 0; (i < 4); i = (i + 1)) {
+      {
+        InnerS tint_symbol_1[8] = s1.a1;
+        tint_symbol_1[uniforms[0].x] = v;
+        s1.a1 = tint_symbol_1;
+      }
+    }
+  }
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_continuing.wgsl.expected.fxc.hlsl

@@ -0,0 +1,29 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    int i = 0;
+    [loop] while (true) {
+      if (!((i < 4))) { break; }
+      i = (i + 1);
+      {
+        InnerS tint_symbol_1[8] = s1.a1;
+        tint_symbol_1[uniforms[0].x] = v;
+        s1.a1 = tint_symbol_1;
+      }
+    }
+  }
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/in_for_loop_init.wgsl.expected.fxc.hlsl

@@ -0,0 +1,27 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  int i = 0;
+  {
+    {
+      InnerS tint_symbol_1[8] = s1.a1;
+      tint_symbol_1[uniforms[0].x] = v;
+      s1.a1 = tint_symbol_1;
+    }
+    [loop] for(; (i < 4); i = (i + 1)) {
+    }
+  }
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/indexing_with_side_effect_func.wgsl.expected.fxc.hlsl

@@ -0,0 +1,36 @@
+struct InnerS {
+  int v;
+};
+struct S1 {
+  InnerS a2[8];
+};
+struct OuterS {
+  S1 a1[8];
+};
+
+static uint nextIndex = 0u;
+
+uint getNextIndex() {
+  nextIndex = (nextIndex + 1u);
+  return nextIndex;
+}
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s = (OuterS)0;
+  {
+    S1 tint_symbol_1[8] = s.a1;
+    const uint tint_symbol_4 = getNextIndex();
+    const uint tint_symbol_2_save = tint_symbol_4;
+    InnerS tint_symbol_3[8] = tint_symbol_1[tint_symbol_2_save].a2;
+    tint_symbol_3[uniforms[0].y] = v;
+    tint_symbol_1[tint_symbol_2_save].a2 = tint_symbol_3;
+    s.a1 = tint_symbol_1;
+  }
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array.wgsl.expected.fxc.hlsl

@@ -0,0 +1,22 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    InnerS tint_symbol_1[8] = s1.a1;
+    tint_symbol_1[uniforms[0].x] = v;
+    s1.a1 = tint_symbol_1;
+  }
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_array.wgsl.expected.fxc.hlsl

@@ -0,0 +1,22 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8][8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    InnerS tint_symbol_1[8][8] = s1.a1;
+    tint_symbol_1[uniforms[0].x][uniforms[0].y] = v;
+    s1.a1 = tint_symbol_1;
+  }
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct.wgsl.expected.fxc.hlsl

@@ -0,0 +1,25 @@
+struct InnerS {
+  int v;
+};
+struct S1 {
+  InnerS s2;
+};
+struct OuterS {
+  S1 a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    S1 tint_symbol_1[8] = s1.a1;
+    tint_symbol_1[uniforms[0].x].s2 = v;
+    s1.a1 = tint_symbol_1;
+  }
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_array_struct_array.wgsl.expected.fxc.hlsl

@@ -0,0 +1,28 @@
+struct InnerS {
+  int v;
+};
+struct S1 {
+  InnerS a2[8];
+};
+struct OuterS {
+  S1 a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s = (OuterS)0;
+  {
+    S1 tint_symbol_1[8] = s.a1;
+    const uint tint_symbol_2_save = uniforms[0].x;
+    InnerS tint_symbol_3[8] = tint_symbol_1[tint_symbol_2_save].a2;
+    tint_symbol_3[uniforms[0].y] = v;
+    tint_symbol_1[tint_symbol_2_save].a2 = tint_symbol_3;
+    s.a1 = tint_symbol_1;
+  }
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array.wgsl.expected.fxc.hlsl

@@ -0,0 +1,19 @@
+struct InnerS {
+  int v;
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+RWByteAddressBuffer s1 : register(u0, space0);
+
+void tint_symbol_1(RWByteAddressBuffer buffer, uint offset, InnerS value) {
+  buffer.Store((offset + 0u), asuint(value.v));
+}
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  tint_symbol_1(s1, (4u * uniforms[0].x), v);
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_dynamic_array_struct_array.wgsl.expected.fxc.hlsl

@@ -0,0 +1,19 @@
+struct InnerS {
+  int v;
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+RWByteAddressBuffer s : register(u0, space0);
+
+void tint_symbol_1(RWByteAddressBuffer buffer, uint offset, InnerS value) {
+  buffer.Store((offset + 0u), asuint(value.v));
+}
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  tint_symbol_1(s, ((32u * uniforms[0].x) + (4u * uniforms[0].y)), v);
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_matrix.wgsl.expected.fxc.hlsl

@@ -0,0 +1,33 @@
+void set_vector_float2x4(inout float2x4 mat, int col, float4 val) {
+  switch (col) {
+    case 0: mat[0] = val; break;
+    case 1: mat[1] = val; break;
+  }
+}
+
+void set_scalar_float2x4(inout float2x4 mat, int col, int row, float val) {
+  switch (col) {
+    case 0:
+      mat[0] = (row.xxxx == int4(0, 1, 2, 3)) ? val.xxxx : mat[0];
+      break;
+    case 1:
+      mat[1] = (row.xxxx == int4(0, 1, 2, 3)) ? val.xxxx : mat[1];
+      break;
+  }
+}
+
+struct OuterS {
+  float2x4 m1;
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  OuterS s1 = (OuterS)0;
+  set_vector_float2x4(s1.m1, uniforms[0].x, (1.0f).xxxx);
+  set_scalar_float2x4(s1.m1, uniforms[0].x, uniforms[0].x, 1.0f);
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_multiple_arrays.wgsl.expected.fxc.hlsl

@@ -0,0 +1,28 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+  InnerS a2[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    InnerS tint_symbol_1[8] = s1.a1;
+    tint_symbol_1[uniforms[0].x] = v;
+    s1.a1 = tint_symbol_1;
+  }
+  {
+    InnerS tint_symbol_3[8] = s1.a2;
+    tint_symbol_3[uniforms[0].x] = v;
+    s1.a2 = tint_symbol_3;
+  }
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_struct_array.wgsl.expected.fxc.hlsl

@@ -0,0 +1,25 @@
+struct InnerS {
+  int v;
+};
+struct S1 {
+  InnerS a[8];
+};
+struct OuterS {
+  S1 s2;
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  {
+    InnerS tint_symbol_1[8] = s1.s2.a;
+    tint_symbol_1[uniforms[0].x] = v;
+    s1.s2.a = tint_symbol_1;
+  }
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/struct_vector.wgsl.expected.fxc.hlsl

@@ -0,0 +1,18 @@
+void set_float3(inout float3 vec, int idx, float val) {
+  vec = (idx.xxx == int3(0, 1, 2)) ? val.xxx : vec;
+}
+
+struct OuterS {
+  float3 v1;
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  OuterS s1 = (OuterS)0;
+  set_float3(s1.v1, uniforms[0].x, 1.0f);
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/vector_assign.wgsl.expected.fxc.hlsl

@@ -0,0 +1,25 @@
+void set_float3(inout float3 vec, int idx, float val) {
+  vec = (idx.xxx == int3(0, 1, 2)) ? val.xxx : vec;
+}
+
+struct OuterS {
+  uint a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+uint f(uint i) {
+  return (i + 1u);
+}
+
+[numthreads(1, 1, 1)]
+void main() {
+  OuterS s1 = (OuterS)0;
+  float3 v = float3(0.0f, 0.0f, 0.0f);
+  set_float3(v, s1.a1[uniforms[0].x], 1.0f);
+  const uint tint_symbol = f(s1.a1[uniforms[0].x]);
+  set_float3(v, tint_symbol, 1.0f);
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/via_pointer.wgsl.expected.fxc.hlsl

@@ -0,0 +1,23 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  InnerS v = (InnerS)0;
+  OuterS s1 = (OuterS)0;
+  const uint p_save = uniforms[0].x;
+  {
+    InnerS tint_symbol_1[8] = s1.a1;
+    tint_symbol_1[p_save] = v;
+    s1.a1 = tint_symbol_1;
+  }
+  return;
+}

test/tint/statements/assign/indexed_assign_to_array_in_struct/via_pointer_arg.wgsl.expected.fxc.hlsl

@@ -0,0 +1,26 @@
+struct InnerS {
+  int v;
+};
+struct OuterS {
+  InnerS a1[8];
+};
+
+cbuffer cbuffer_uniforms : register(b4, space1) {
+  uint4 uniforms[1];
+};
+
+void f(inout OuterS p) {
+  InnerS v = (InnerS)0;
+  {
+    InnerS tint_symbol_1[8] = p.a1;
+    tint_symbol_1[uniforms[0].x] = v;
+    p.a1 = tint_symbol_1;
+  }
+}
+
+[numthreads(1, 1, 1)]
+void main() {
+  OuterS s1 = (OuterS)0;
+  f(s1);
+  return;
+}

test/tint/statements/assign/phony/addr_of_runtime_array.wgsl.expected.fxc.hlsl

@@ -0,0 +1,6 @@
+RWByteAddressBuffer s : register(u0, space0);
+
+[numthreads(1, 1, 1)]
+void main() {
+  return;
+}

test/tint/statements/assign/phony/call.wgsl.expected.fxc.hlsl

@@ -0,0 +1,9 @@
+int f(int a, int b, int c) {
+  return ((a * b) + c);
+}
+
+[numthreads(1, 1, 1)]
+void main() {
+  f(1, 2, 3);
+  return;
+}

test/tint/statements/assign/phony/multiple_side_effects.wgsl.expected.fxc.hlsl

@@ -0,0 +1,12 @@
+int f(int a, int b, int c) {
+  return ((a * b) + c);
+}
+
+[numthreads(1, 1, 1)]
+void main() {
+  const int tint_symbol = f(1, 2, 3);
+  const int tint_symbol_1 = f(4, 5, 6);
+  const int tint_symbol_2 = f(8, 9, 10);
+  const int tint_symbol_3 = f(7, tint_symbol_2, 11);
+  return;
+}

test/tint/statements/assign/phony/storage_buffer.wgsl.expected.dxc.hlsl

@@ -0,0 +1,6 @@
+RWByteAddressBuffer s : register(u0, space0);
+
+[numthreads(1, 1, 1)]
+void main() {
+  return;
+}

test/tint/statements/assign/phony/storage_buffer.wgsl.expected.fxc.hlsl

@@ -0,0 +1,6 @@
+RWByteAddressBuffer s : register(u0, space0);
+
+[numthreads(1, 1, 1)]
+void main() {
+  return;
+}

test/tint/statements/assign/phony/uniform_buffer.wgsl.expected.fxc.hlsl

@@ -0,0 +1,8 @@
+cbuffer cbuffer_u : register(b0, space0) {
+  uint4 u[1];
+};
+
+[numthreads(1, 1, 1)]
+void main() {
+  return;
+}

test/tint/statements/compound_assign/complex_lhs.wgsl.expected.fxc.hlsl

@@ -0,0 +1,32 @@
+void set_int4(inout int4 vec, int idx, int val) {
+  vec = (idx.xxxx == int4(0, 1, 2, 3)) ? val.xxxx : vec;
+}
+
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+struct S {
+  int4 a[4];
+};
+
+static int counter = 0;
+
+int foo() {
+  counter = (counter + 1);
+  return counter;
+}
+
+int bar() {
+  counter = (counter + 2);
+  return counter;
+}
+
+void main() {
+  S x = (S)0;
+  const int tint_symbol_2 = foo();
+  const int tint_symbol_save = tint_symbol_2;
+  const int tint_symbol_1 = bar();
+  set_int4(x.a[tint_symbol_save], tint_symbol_1, (x.a[tint_symbol_save][tint_symbol_1] + 5));
+}

test/tint/statements/compound_assign/divide_by_zero.wgsl.expected.fxc.hlsl

@@ -0,0 +1,18 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+static int a = 0;
+static float b = 0.0f;
+
+void foo(int maybe_zero) {
+  a = (a / 1);
+  a = (a % 1);
+  a = (a / (maybe_zero == 0 ? 1 : maybe_zero));
+  a = (a % (maybe_zero == 0 ? 1 : maybe_zero));
+  b = (b / 0.0f);
+  b = (b % 0.0f);
+  b = (b / float(maybe_zero));
+  b = (b % float(maybe_zero));
+}

test/tint/statements/compound_assign/for_loop.wgsl.expected.fxc.hlsl

@@ -0,0 +1,44 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+static uint i = 0u;
+
+int idx1() {
+  i = (i + 1u);
+  return 1;
+}
+
+int idx2() {
+  i = (i + 2u);
+  return 1;
+}
+
+int idx3() {
+  i = (i + 3u);
+  return 1;
+}
+
+void foo() {
+  float a[4] = (float[4])0;
+  const int tint_symbol_2 = idx1();
+  const int tint_symbol_save = tint_symbol_2;
+  {
+    a[tint_symbol_save] = (a[tint_symbol_save] * 2.0f);
+    [loop] while (true) {
+      const int tint_symbol_3 = idx2();
+      if (!((a[tint_symbol_3] < 10.0f))) {
+        break;
+      }
+      {
+      }
+      {
+        const int tint_symbol_4 = idx3();
+        const int tint_symbol_1_save = tint_symbol_4;
+        a[tint_symbol_1_save] = (a[tint_symbol_1_save] + 1.0f);
+      }
+    }
+  }
+}

test/tint/statements/compound_assign/function.wgsl.expected.fxc.hlsl

@@ -0,0 +1,13 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+void foo() {
+  int a = 0;
+  float4 b = float4(0.0f, 0.0f, 0.0f, 0.0f);
+  float2x2 c = float2x2(0.0f, 0.0f, 0.0f, 0.0f);
+  a = (a / 2);
+  b = mul(float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx), b);
+  c = (c * 2.0f);
+}

test/tint/statements/compound_assign/matrix/minus.wgsl.expected.fxc.hlsl

@@ -0,0 +1,21 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void tint_symbol(RWByteAddressBuffer buffer, uint offset, float4x4 value) {
+  buffer.Store4((offset + 0u), asuint(value[0u]));
+  buffer.Store4((offset + 16u), asuint(value[1u]));
+  buffer.Store4((offset + 32u), asuint(value[2u]));
+  buffer.Store4((offset + 48u), asuint(value[3u]));
+}
+
+float4x4 tint_symbol_2(RWByteAddressBuffer buffer, uint offset) {
+  return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u))));
+}
+
+void foo() {
+  tint_symbol(v, 0u, (tint_symbol_2(v, 0u) - float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)));
+}

test/tint/statements/compound_assign/matrix/plus.wgsl.expected.fxc.hlsl

@@ -0,0 +1,21 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void tint_symbol(RWByteAddressBuffer buffer, uint offset, float4x4 value) {
+  buffer.Store4((offset + 0u), asuint(value[0u]));
+  buffer.Store4((offset + 16u), asuint(value[1u]));
+  buffer.Store4((offset + 32u), asuint(value[2u]));
+  buffer.Store4((offset + 48u), asuint(value[3u]));
+}
+
+float4x4 tint_symbol_2(RWByteAddressBuffer buffer, uint offset) {
+  return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u))));
+}
+
+void foo() {
+  tint_symbol(v, 0u, (tint_symbol_2(v, 0u) + float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx)));
+}

test/tint/statements/compound_assign/matrix/times-scalar.wgsl.expected.fxc.hlsl

@@ -0,0 +1,21 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void tint_symbol(RWByteAddressBuffer buffer, uint offset, float4x4 value) {
+  buffer.Store4((offset + 0u), asuint(value[0u]));
+  buffer.Store4((offset + 16u), asuint(value[1u]));
+  buffer.Store4((offset + 32u), asuint(value[2u]));
+  buffer.Store4((offset + 48u), asuint(value[3u]));
+}
+
+float4x4 tint_symbol_2(RWByteAddressBuffer buffer, uint offset) {
+  return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u))));
+}
+
+void foo() {
+  tint_symbol(v, 0u, (tint_symbol_2(v, 0u) * 2.0f));
+}

test/tint/statements/compound_assign/matrix/times.wgsl.expected.fxc.hlsl

@@ -0,0 +1,21 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void tint_symbol(RWByteAddressBuffer buffer, uint offset, float4x4 value) {
+  buffer.Store4((offset + 0u), asuint(value[0u]));
+  buffer.Store4((offset + 16u), asuint(value[1u]));
+  buffer.Store4((offset + 32u), asuint(value[2u]));
+  buffer.Store4((offset + 48u), asuint(value[3u]));
+}
+
+float4x4 tint_symbol_2(RWByteAddressBuffer buffer, uint offset) {
+  return float4x4(asfloat(buffer.Load4((offset + 0u))), asfloat(buffer.Load4((offset + 16u))), asfloat(buffer.Load4((offset + 32u))), asfloat(buffer.Load4((offset + 48u))));
+}
+
+void foo() {
+  tint_symbol(v, 0u, mul(float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx), tint_symbol_2(v, 0u)));
+}

test/tint/statements/compound_assign/private.wgsl.expected.fxc.hlsl

@@ -0,0 +1,14 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+static int a = 0;
+static float4 b = float4(0.0f, 0.0f, 0.0f, 0.0f);
+static float2x2 c = float2x2(0.0f, 0.0f, 0.0f, 0.0f);
+
+void foo() {
+  a = (a / 2);
+  b = mul(float4x4((0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx, (0.0f).xxxx), b);
+  c = (c * 2.0f);
+}

test/tint/statements/compound_assign/scalar/and.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store(0u, asuint((asint(v.Load(0u)) & 2)));
+}

test/tint/statements/compound_assign/scalar/divide.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store(0u, asuint((asint(v.Load(0u)) / 2)));
+}

test/tint/statements/compound_assign/scalar/minus.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store(0u, asuint((asint(v.Load(0u)) - 2)));
+}

test/tint/statements/compound_assign/scalar/modulo.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store(0u, asuint((asint(v.Load(0u)) % 2)));
+}

test/tint/statements/compound_assign/scalar/or.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store(0u, asuint((asint(v.Load(0u)) | 2)));
+}

test/tint/statements/compound_assign/scalar/plus.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store(0u, asuint((asint(v.Load(0u)) + 2)));
+}

test/tint/statements/compound_assign/scalar/times.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store(0u, asuint((asint(v.Load(0u)) * 2)));
+}

test/tint/statements/compound_assign/scalar/xor.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store(0u, asuint((asint(v.Load(0u)) ^ 2)));
+}

test/tint/statements/compound_assign/vector/and.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store4(0u, asuint((asint(v.Load4(0u)) & (2).xxxx)));
+}

test/tint/statements/compound_assign/vector/divide-scalar.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store4(0u, asuint((asfloat(v.Load4(0u)) / 2.0f)));
+}

test/tint/statements/compound_assign/vector/divide.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store4(0u, asuint((asint(v.Load4(0u)) / (2).xxxx)));
+}

test/tint/statements/compound_assign/vector/minus-scalar.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store4(0u, asuint((asfloat(v.Load4(0u)) - 2.0f)));
+}

test/tint/statements/compound_assign/vector/minus.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store4(0u, asuint((asint(v.Load4(0u)) - (2).xxxx)));
+}

test/tint/statements/compound_assign/vector/modulo-scalar.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store4(0u, asuint((asint(v.Load4(0u)) % 2)));
+}

test/tint/statements/compound_assign/vector/modulo.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store4(0u, asuint((asint(v.Load4(0u)) % (2).xxxx)));
+}

test/tint/statements/compound_assign/vector/or.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store4(0u, asuint((asint(v.Load4(0u)) | (2).xxxx)));
+}

test/tint/statements/compound_assign/vector/plus-scalar.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store4(0u, asuint((asfloat(v.Load4(0u)) + 2.0f)));
+}

test/tint/statements/compound_assign/vector/plus.wgsl.expected.fxc.hlsl

@@ -0,0 +1,10 @@
+[numthreads(1, 1, 1)]
+void unused_entry_point() {
+  return;
+}
+
+RWByteAddressBuffer v : register(u0, space0);
+
+void foo() {
+  v.Store4(0u, asuint((asint(v.Load4(0u)) + (2).xxxx)));
+}