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/samples/compute_boids.wgsl.expected.fxc.hlsl

@@ -0,0 +1,111 @@
+struct tint_symbol_1 {
+  float2 a_particlePos : TEXCOORD0;
+  float2 a_particleVel : TEXCOORD1;
+  float2 a_pos : TEXCOORD2;
+};
+struct tint_symbol_2 {
+  float4 value : SV_Position;
+};
+
+float4 vert_main_inner(float2 a_particlePos, float2 a_particleVel, float2 a_pos) {
+  float angle = -(atan2(a_particleVel.x, a_particleVel.y));
+  float2 pos = float2(((a_pos.x * cos(angle)) - (a_pos.y * sin(angle))), ((a_pos.x * sin(angle)) + (a_pos.y * cos(angle))));
+  return float4((pos + a_particlePos), 0.0f, 1.0f);
+}
+
+tint_symbol_2 vert_main(tint_symbol_1 tint_symbol) {
+  const float4 inner_result = vert_main_inner(tint_symbol.a_particlePos, tint_symbol.a_particleVel, tint_symbol.a_pos);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+
+struct tint_symbol_3 {
+  float4 value : SV_Target0;
+};
+
+float4 frag_main_inner() {
+  return (1.0f).xxxx;
+}
+
+tint_symbol_3 frag_main() {
+  const float4 inner_result_1 = frag_main_inner();
+  tint_symbol_3 wrapper_result_1 = (tint_symbol_3)0;
+  wrapper_result_1.value = inner_result_1;
+  return wrapper_result_1;
+}
+
+cbuffer cbuffer_params : register(b0, space0) {
+  uint4 params[2];
+};
+RWByteAddressBuffer particlesA : register(u1, space0);
+RWByteAddressBuffer particlesB : register(u2, space0);
+
+struct tint_symbol_5 {
+  uint3 gl_GlobalInvocationID : SV_DispatchThreadID;
+};
+
+void comp_main_inner(uint3 gl_GlobalInvocationID) {
+  uint index = gl_GlobalInvocationID.x;
+  if ((index >= 5u)) {
+    return;
+  }
+  float2 vPos = asfloat(particlesA.Load2((16u * index)));
+  float2 vVel = asfloat(particlesA.Load2(((16u * index) + 8u)));
+  float2 cMass = (0.0f).xx;
+  float2 cVel = (0.0f).xx;
+  float2 colVel = (0.0f).xx;
+  int cMassCount = 0;
+  int cVelCount = 0;
+  float2 pos = float2(0.0f, 0.0f);
+  float2 vel = float2(0.0f, 0.0f);
+  {
+    [loop] for(uint i = 0u; (i < 5u); i = (i + 1u)) {
+      if ((i == index)) {
+        continue;
+      }
+      pos = asfloat(particlesA.Load2((16u * i))).xy;
+      vel = asfloat(particlesA.Load2(((16u * i) + 8u))).xy;
+      if ((distance(pos, vPos) < asfloat(params[0].y))) {
+        cMass = (cMass + pos);
+        cMassCount = (cMassCount + 1);
+      }
+      if ((distance(pos, vPos) < asfloat(params[0].z))) {
+        colVel = (colVel - (pos - vPos));
+      }
+      if ((distance(pos, vPos) < asfloat(params[0].w))) {
+        cVel = (cVel + vel);
+        cVelCount = (cVelCount + 1);
+      }
+    }
+  }
+  if ((cMassCount > 0)) {
+    cMass = ((cMass / float2(float(cMassCount), float(cMassCount))) - vPos);
+  }
+  if ((cVelCount > 0)) {
+    cVel = (cVel / float2(float(cVelCount), float(cVelCount)));
+  }
+  vVel = (((vVel + (cMass * asfloat(params[1].x))) + (colVel * asfloat(params[1].y))) + (cVel * asfloat(params[1].z)));
+  vVel = (normalize(vVel) * clamp(length(vVel), 0.0f, 0.100000001f));
+  vPos = (vPos + (vVel * asfloat(params[0].x)));
+  if ((vPos.x < -1.0f)) {
+    vPos.x = 1.0f;
+  }
+  if ((vPos.x > 1.0f)) {
+    vPos.x = -1.0f;
+  }
+  if ((vPos.y < -1.0f)) {
+    vPos.y = 1.0f;
+  }
+  if ((vPos.y > 1.0f)) {
+    vPos.y = -1.0f;
+  }
+  particlesB.Store2((16u * index), asuint(vPos));
+  particlesB.Store2(((16u * index) + 8u), asuint(vVel));
+}
+
+[numthreads(1, 1, 1)]
+void comp_main(tint_symbol_5 tint_symbol_4) {
+  comp_main_inner(tint_symbol_4.gl_GlobalInvocationID);
+  return;
+}

test/tint/samples/cube.wgsl.expected.fxc.hlsl

@@ -0,0 +1,62 @@
+cbuffer cbuffer_uniforms : register(b0, space0) {
+  uint4 uniforms[4];
+};
+
+struct VertexInput {
+  float4 cur_position;
+  float4 color;
+};
+struct VertexOutput {
+  float4 vtxFragColor;
+  float4 Position;
+};
+struct tint_symbol_1 {
+  float4 cur_position : TEXCOORD0;
+  float4 color : TEXCOORD1;
+};
+struct tint_symbol_2 {
+  float4 vtxFragColor : TEXCOORD0;
+  float4 Position : SV_Position;
+};
+
+float4x4 tint_symbol_6(uint4 buffer[4], uint offset) {
+  const uint scalar_offset = ((offset + 0u)) / 4;
+  const uint scalar_offset_1 = ((offset + 16u)) / 4;
+  const uint scalar_offset_2 = ((offset + 32u)) / 4;
+  const uint scalar_offset_3 = ((offset + 48u)) / 4;
+  return float4x4(asfloat(buffer[scalar_offset / 4]), asfloat(buffer[scalar_offset_1 / 4]), asfloat(buffer[scalar_offset_2 / 4]), asfloat(buffer[scalar_offset_3 / 4]));
+}
+
+VertexOutput vtx_main_inner(VertexInput input) {
+  VertexOutput output = (VertexOutput)0;
+  output.Position = mul(input.cur_position, tint_symbol_6(uniforms, 0u));
+  output.vtxFragColor = input.color;
+  return output;
+}
+
+tint_symbol_2 vtx_main(tint_symbol_1 tint_symbol) {
+  const VertexInput tint_symbol_8 = {tint_symbol.cur_position, tint_symbol.color};
+  const VertexOutput inner_result = vtx_main_inner(tint_symbol_8);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.vtxFragColor = inner_result.vtxFragColor;
+  wrapper_result.Position = inner_result.Position;
+  return wrapper_result;
+}
+
+struct tint_symbol_4 {
+  float4 fragColor : TEXCOORD0;
+};
+struct tint_symbol_5 {
+  float4 value : SV_Target0;
+};
+
+float4 frag_main_inner(float4 fragColor) {
+  return fragColor;
+}
+
+tint_symbol_5 frag_main(tint_symbol_4 tint_symbol_3) {
+  const float4 inner_result_1 = frag_main_inner(tint_symbol_3.fragColor);
+  tint_symbol_5 wrapper_result_1 = (tint_symbol_5)0;
+  wrapper_result_1.value = inner_result_1;
+  return wrapper_result_1;
+}

test/tint/samples/function.wgsl.expected.fxc.hlsl

@@ -0,0 +1,8 @@
+float main() {
+  return (((2.0f * 3.0f) - 4.0f) / 5.0f);
+}
+
+[numthreads(2, 1, 1)]
+void ep() {
+  return;
+}

test/tint/samples/simple.wgsl.expected.fxc.hlsl

@@ -0,0 +1,19 @@
+void bar() {
+}
+
+struct tint_symbol {
+  float4 value : SV_Target0;
+};
+
+float4 main_inner() {
+  float2 a = (0.0f).xx;
+  bar();
+  return float4(0.400000006f, 0.400000006f, 0.800000012f, 1.0f);
+}
+
+tint_symbol main() {
+  const float4 inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}

test/tint/samples/simple_vertex.spvasm.expected.fxc.hlsl

@@ -0,0 +1,26 @@
+static float4 gl_Position = float4(0.0f, 0.0f, 0.0f, 0.0f);
+
+void main_1() {
+  gl_Position = (0.0f).xxxx;
+  return;
+}
+
+struct main_out {
+  float4 gl_Position;
+};
+struct tint_symbol {
+  float4 gl_Position : SV_Position;
+};
+
+main_out main_inner() {
+  main_1();
+  const main_out tint_symbol_1 = {gl_Position};
+  return tint_symbol_1;
+}
+
+tint_symbol main() {
+  const main_out inner_result = main_inner();
+  tint_symbol wrapper_result = (tint_symbol)0;
+  wrapper_result.gl_Position = inner_result.gl_Position;
+  return wrapper_result;
+}

test/tint/samples/triangle.wgsl.expected.fxc.hlsl

@@ -0,0 +1,33 @@
+struct tint_symbol_1 {
+  uint VertexIndex : SV_VertexID;
+};
+struct tint_symbol_2 {
+  float4 value : SV_Position;
+};
+
+float4 vtx_main_inner(uint VertexIndex) {
+  const float2 tint_symbol_4[3] = {float2(0.0f, 0.5f), (-0.5f).xx, float2(0.5f, -0.5f)};
+  return float4(tint_symbol_4[VertexIndex], 0.0f, 1.0f);
+}
+
+tint_symbol_2 vtx_main(tint_symbol_1 tint_symbol) {
+  const float4 inner_result = vtx_main_inner(tint_symbol.VertexIndex);
+  tint_symbol_2 wrapper_result = (tint_symbol_2)0;
+  wrapper_result.value = inner_result;
+  return wrapper_result;
+}
+
+struct tint_symbol_3 {
+  float4 value : SV_Target0;
+};
+
+float4 frag_main_inner() {
+  return float4(1.0f, 0.0f, 0.0f, 1.0f);
+}
+
+tint_symbol_3 frag_main() {
+  const float4 inner_result_1 = frag_main_inner();
+  tint_symbol_3 wrapper_result_1 = (tint_symbol_3)0;
+  wrapper_result_1.value = inner_result_1;
+  return wrapper_result_1;
+}