tint->dawn: Shuffle source tree in preperation of merging repos

docs/    -> docs/tint/
fuzzers/ -> src/tint/fuzzers/
samples/ -> src/tint/cmd/
src/     -> src/tint/
test/    -> test/tint/

BUG=tint:1418,tint:1433

Change-Id: Id2aa79f989aef3245b80ef4aa37a27ff16cd700b
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/80482
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: Ryan Harrison <rharrison@chromium.org>

test/tint/expressions/binary/mul/mat2x4-mat4x2/f32.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+    let a = mat2x4<f32>(vec4<f32>(1., 2., 3., 4.), vec4<f32>(5., 6., 7., 8.));
+    let b = mat4x2<f32>(vec2<f32>(-1., -2.), vec2<f32>(-3., -4.), vec2<f32>(-5., -6.), vec2<f32>(-7., -8.));
+    let r : mat4x4<f32> = a * b;
+}

test/tint/expressions/binary/mul/mat2x4-mat4x2/f32.wgsl.expected.glsl

@@ -0,0 +1,13 @@
+#version 310 es
+
+void f() {
+  mat2x4 a = mat2x4(vec4(1.0f, 2.0f, 3.0f, 4.0f), vec4(5.0f, 6.0f, 7.0f, 8.0f));
+  mat4x2 b = mat4x2(vec2(-1.0f, -2.0f), vec2(-3.0f, -4.0f), vec2(-5.0f, -6.0f), vec2(-7.0f, -8.0f));
+  mat4 r = (a * b);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  f();
+  return;
+}

test/tint/expressions/binary/mul/mat2x4-mat4x2/f32.wgsl.expected.hlsl

@@ -0,0 +1,7 @@
+[numthreads(1, 1, 1)]
+void f() {
+  const float2x4 a = float2x4(float4(1.0f, 2.0f, 3.0f, 4.0f), float4(5.0f, 6.0f, 7.0f, 8.0f));
+  const float4x2 b = float4x2(float2(-1.0f, -2.0f), float2(-3.0f, -4.0f), float2(-5.0f, -6.0f), float2(-7.0f, -8.0f));
+  const float4x4 r = mul(b, a);
+  return;
+}

test/tint/expressions/binary/mul/mat2x4-mat4x2/f32.wgsl.expected.msl

@@ -0,0 +1,10 @@
+#include <metal_stdlib>
+
+using namespace metal;
+kernel void f() {
+  float2x4 const a = float2x4(float4(1.0f, 2.0f, 3.0f, 4.0f), float4(5.0f, 6.0f, 7.0f, 8.0f));
+  float4x2 const b = float4x2(float2(-1.0f, -2.0f), float2(-3.0f, -4.0f), float2(-5.0f, -6.0f), float2(-7.0f, -8.0f));
+  float4x4 const r = (a * b);
+  return;
+}
+

test/tint/expressions/binary/mul/mat2x4-mat4x2/f32.wgsl.expected.spvasm

@@ -0,0 +1,47 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 36
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %f "f"
+               OpExecutionMode %f LocalSize 1 1 1
+               OpName %f "f"
+       %void = OpTypeVoid
+          %1 = OpTypeFunction %void
+      %float = OpTypeFloat 32
+    %v4float = OpTypeVector %float 4
+%mat2v4float = OpTypeMatrix %v4float 2
+    %float_1 = OpConstant %float 1
+    %float_2 = OpConstant %float 2
+    %float_3 = OpConstant %float 3
+    %float_4 = OpConstant %float 4
+         %12 = OpConstantComposite %v4float %float_1 %float_2 %float_3 %float_4
+    %float_5 = OpConstant %float 5
+    %float_6 = OpConstant %float 6
+    %float_7 = OpConstant %float 7
+    %float_8 = OpConstant %float 8
+         %17 = OpConstantComposite %v4float %float_5 %float_6 %float_7 %float_8
+         %18 = OpConstantComposite %mat2v4float %12 %17
+    %v2float = OpTypeVector %float 2
+%mat4v2float = OpTypeMatrix %v2float 4
+   %float_n1 = OpConstant %float -1
+   %float_n2 = OpConstant %float -2
+         %23 = OpConstantComposite %v2float %float_n1 %float_n2
+   %float_n3 = OpConstant %float -3
+   %float_n4 = OpConstant %float -4
+         %26 = OpConstantComposite %v2float %float_n3 %float_n4
+   %float_n5 = OpConstant %float -5
+   %float_n6 = OpConstant %float -6
+         %29 = OpConstantComposite %v2float %float_n5 %float_n6
+   %float_n7 = OpConstant %float -7
+   %float_n8 = OpConstant %float -8
+         %32 = OpConstantComposite %v2float %float_n7 %float_n8
+         %33 = OpConstantComposite %mat4v2float %23 %26 %29 %32
+%mat4v4float = OpTypeMatrix %v4float 4
+          %f = OpFunction %void None %1
+          %4 = OpLabel
+         %34 = OpMatrixTimesMatrix %mat4v4float %18 %33
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/mat2x4-mat4x2/f32.wgsl.expected.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+  let a = mat2x4<f32>(vec4<f32>(1.0, 2.0, 3.0, 4.0), vec4<f32>(5.0, 6.0, 7.0, 8.0));
+  let b = mat4x2<f32>(vec2<f32>(-1.0, -2.0), vec2<f32>(-3.0, -4.0), vec2<f32>(-5.0, -6.0), vec2<f32>(-7.0, -8.0));
+  let r : mat4x4<f32> = (a * b);
+}

test/tint/expressions/binary/mul/mat3x2-vec3/f32.wgsl

@@ -0,0 +1,10 @@
+struct S {
+    matrix : mat3x2<f32>;
+    vector : vec3<f32>;
+};
+@group(0) @binding(0) var<uniform> data: S;
+
+@stage(fragment)
+fn main() {
+  let x = data.matrix * data.vector;
+}

test/tint/expressions/binary/mul/mat3x2-vec3/f32.wgsl.expected.glsl

@@ -0,0 +1,21 @@
+#version 310 es
+precision mediump float;
+
+struct S {
+  mat3x2 matrix;
+  vec3 vector;
+};
+
+layout(binding = 0) uniform S_1 {
+  mat3x2 matrix;
+  vec3 vector;
+} data;
+
+void tint_symbol() {
+  vec2 x = (data.matrix * data.vector);
+}
+
+void main() {
+  tint_symbol();
+  return;
+}

test/tint/expressions/binary/mul/mat3x2-vec3/f32.wgsl.expected.hlsl

@@ -0,0 +1,18 @@
+cbuffer cbuffer_data : register(b0, space0) {
+  uint4 data[3];
+};
+
+float3x2 tint_symbol_2(uint4 buffer[3], uint offset) {
+  const uint scalar_offset = ((offset + 0u)) / 4;
+  uint4 ubo_load = buffer[scalar_offset / 4];
+  const uint scalar_offset_1 = ((offset + 8u)) / 4;
+  uint4 ubo_load_1 = buffer[scalar_offset_1 / 4];
+  const uint scalar_offset_2 = ((offset + 16u)) / 4;
+  uint4 ubo_load_2 = buffer[scalar_offset_2 / 4];
+  return float3x2(asfloat(((scalar_offset & 2) ? ubo_load.zw : ubo_load.xy)), asfloat(((scalar_offset_1 & 2) ? ubo_load_1.zw : ubo_load_1.xy)), asfloat(((scalar_offset_2 & 2) ? ubo_load_2.zw : ubo_load_2.xy)));
+}
+
+void main() {
+  const float2 x = mul(asfloat(data[2].xyz), tint_symbol_2(data, 0u));
+  return;
+}

test/tint/expressions/binary/mul/mat3x2-vec3/f32.wgsl.expected.msl

@@ -0,0 +1,26 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, int N, int M>
+inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
+  return lhs * vec<T, N>(rhs);
+}
+
+template<typename T, int N, int M>
+inline vec<T, N> operator*(packed_vec<T, M> lhs, matrix<T, N, M> rhs) {
+  return vec<T, M>(lhs) * rhs;
+}
+
+struct S {
+  /* 0x0000 */ float3x2 tint_symbol;
+  /* 0x0018 */ int8_t tint_pad[8];
+  /* 0x0020 */ packed_float3 vector;
+  /* 0x002c */ int8_t tint_pad_1[4];
+};
+
+fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
+  float2 const x = ((*(tint_symbol_2)).tint_symbol * (*(tint_symbol_2)).vector);
+  return;
+}
+

test/tint/expressions/binary/mul/mat3x2-vec3/f32.wgsl.expected.spvasm

@@ -0,0 +1,45 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 22
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main"
+               OpExecutionMode %main OriginUpperLeft
+               OpName %S "S"
+               OpMemberName %S 0 "matrix"
+               OpMemberName %S 1 "vector"
+               OpName %data "data"
+               OpName %main "main"
+               OpDecorate %S Block
+               OpMemberDecorate %S 0 Offset 0
+               OpMemberDecorate %S 0 ColMajor
+               OpMemberDecorate %S 0 MatrixStride 8
+               OpMemberDecorate %S 1 Offset 32
+               OpDecorate %data NonWritable
+               OpDecorate %data DescriptorSet 0
+               OpDecorate %data Binding 0
+      %float = OpTypeFloat 32
+    %v2float = OpTypeVector %float 2
+%mat3v2float = OpTypeMatrix %v2float 3
+    %v3float = OpTypeVector %float 3
+          %S = OpTypeStruct %mat3v2float %v3float
+%_ptr_Uniform_S = OpTypePointer Uniform %S
+       %data = OpVariable %_ptr_Uniform_S Uniform
+       %void = OpTypeVoid
+          %8 = OpTypeFunction %void
+       %uint = OpTypeInt 32 0
+     %uint_0 = OpConstant %uint 0
+%_ptr_Uniform_mat3v2float = OpTypePointer Uniform %mat3v2float
+     %uint_1 = OpConstant %uint 1
+%_ptr_Uniform_v3float = OpTypePointer Uniform %v3float
+       %main = OpFunction %void None %8
+         %11 = OpLabel
+         %15 = OpAccessChain %_ptr_Uniform_mat3v2float %data %uint_0
+         %16 = OpLoad %mat3v2float %15
+         %19 = OpAccessChain %_ptr_Uniform_v3float %data %uint_1
+         %20 = OpLoad %v3float %19
+         %21 = OpMatrixTimesVector %v2float %16 %20
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/mat3x2-vec3/f32.wgsl.expected.wgsl

@@ -0,0 +1,11 @@
+struct S {
+  matrix : mat3x2<f32>;
+  vector : vec3<f32>;
+}
+
+@group(0) @binding(0) var<uniform> data : S;
+
+@stage(fragment)
+fn main() {
+  let x = (data.matrix * data.vector);
+}

test/tint/expressions/binary/mul/mat3x3-mat3x3/f32.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+    let a = mat3x3<f32>(vec3<f32>( 1.,  2.,  3.), vec3<f32>( 4.,  5.,  6.), vec3<f32>( 7.,  8.,  9.));
+    let b = mat3x3<f32>(vec3<f32>(-1., -2., -3.), vec3<f32>(-4., -5., -6.), vec3<f32>(-7., -8., -9.));
+    let r : mat3x3<f32> = a * b;
+}

test/tint/expressions/binary/mul/mat3x3-mat3x3/f32.wgsl.expected.glsl

@@ -0,0 +1,13 @@
+#version 310 es
+
+void f() {
+  mat3 a = mat3(vec3(1.0f, 2.0f, 3.0f), vec3(4.0f, 5.0f, 6.0f), vec3(7.0f, 8.0f, 9.0f));
+  mat3 b = mat3(vec3(-1.0f, -2.0f, -3.0f), vec3(-4.0f, -5.0f, -6.0f), vec3(-7.0f, -8.0f, -9.0f));
+  mat3 r = (a * b);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  f();
+  return;
+}

test/tint/expressions/binary/mul/mat3x3-mat3x3/f32.wgsl.expected.hlsl

@@ -0,0 +1,7 @@
+[numthreads(1, 1, 1)]
+void f() {
+  const float3x3 a = float3x3(float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f));
+  const float3x3 b = float3x3(float3(-1.0f, -2.0f, -3.0f), float3(-4.0f, -5.0f, -6.0f), float3(-7.0f, -8.0f, -9.0f));
+  const float3x3 r = mul(b, a);
+  return;
+}

test/tint/expressions/binary/mul/mat3x3-mat3x3/f32.wgsl.expected.msl

@@ -0,0 +1,10 @@
+#include <metal_stdlib>
+
+using namespace metal;
+kernel void f() {
+  float3x3 const a = float3x3(float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f));
+  float3x3 const b = float3x3(float3(-1.0f, -2.0f, -3.0f), float3(-4.0f, -5.0f, -6.0f), float3(-7.0f, -8.0f, -9.0f));
+  float3x3 const r = (a * b);
+  return;
+}
+

test/tint/expressions/binary/mul/mat3x3-mat3x3/f32.wgsl.expected.spvasm

@@ -0,0 +1,46 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 35
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %f "f"
+               OpExecutionMode %f LocalSize 1 1 1
+               OpName %f "f"
+       %void = OpTypeVoid
+          %1 = OpTypeFunction %void
+      %float = OpTypeFloat 32
+    %v3float = OpTypeVector %float 3
+%mat3v3float = OpTypeMatrix %v3float 3
+    %float_1 = OpConstant %float 1
+    %float_2 = OpConstant %float 2
+    %float_3 = OpConstant %float 3
+         %11 = OpConstantComposite %v3float %float_1 %float_2 %float_3
+    %float_4 = OpConstant %float 4
+    %float_5 = OpConstant %float 5
+    %float_6 = OpConstant %float 6
+         %15 = OpConstantComposite %v3float %float_4 %float_5 %float_6
+    %float_7 = OpConstant %float 7
+    %float_8 = OpConstant %float 8
+    %float_9 = OpConstant %float 9
+         %19 = OpConstantComposite %v3float %float_7 %float_8 %float_9
+         %20 = OpConstantComposite %mat3v3float %11 %15 %19
+   %float_n1 = OpConstant %float -1
+   %float_n2 = OpConstant %float -2
+   %float_n3 = OpConstant %float -3
+         %24 = OpConstantComposite %v3float %float_n1 %float_n2 %float_n3
+   %float_n4 = OpConstant %float -4
+   %float_n5 = OpConstant %float -5
+   %float_n6 = OpConstant %float -6
+         %28 = OpConstantComposite %v3float %float_n4 %float_n5 %float_n6
+   %float_n7 = OpConstant %float -7
+   %float_n8 = OpConstant %float -8
+   %float_n9 = OpConstant %float -9
+         %32 = OpConstantComposite %v3float %float_n7 %float_n8 %float_n9
+         %33 = OpConstantComposite %mat3v3float %24 %28 %32
+          %f = OpFunction %void None %1
+          %4 = OpLabel
+         %34 = OpMatrixTimesMatrix %mat3v3float %20 %33
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/mat3x3-mat3x3/f32.wgsl.expected.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+  let a = mat3x3<f32>(vec3<f32>(1.0, 2.0, 3.0), vec3<f32>(4.0, 5.0, 6.0), vec3<f32>(7.0, 8.0, 9.0));
+  let b = mat3x3<f32>(vec3<f32>(-1.0, -2.0, -3.0), vec3<f32>(-4.0, -5.0, -6.0), vec3<f32>(-7.0, -8.0, -9.0));
+  let r : mat3x3<f32> = (a * b);
+}

test/tint/expressions/binary/mul/mat3x3-vec3/f32.wgsl

@@ -0,0 +1,10 @@
+struct S {
+    matrix : mat3x3<f32>;
+    vector : vec3<f32>;
+};
+@group(0) @binding(0) var<uniform> data: S;
+
+@stage(fragment)
+fn main() {
+  let x = data.matrix * data.vector;
+}

test/tint/expressions/binary/mul/mat3x3-vec3/f32.wgsl.expected.glsl

@@ -0,0 +1,21 @@
+#version 310 es
+precision mediump float;
+
+struct S {
+  mat3 matrix;
+  vec3 vector;
+};
+
+layout(binding = 0) uniform S_1 {
+  mat3 matrix;
+  vec3 vector;
+} data;
+
+void tint_symbol() {
+  vec3 x = (data.matrix * data.vector);
+}
+
+void main() {
+  tint_symbol();
+  return;
+}

test/tint/expressions/binary/mul/mat3x3-vec3/f32.wgsl.expected.hlsl

@@ -0,0 +1,15 @@
+cbuffer cbuffer_data : register(b0, space0) {
+  uint4 data[4];
+};
+
+float3x3 tint_symbol_2(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;
+  return float3x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz), asfloat(buffer[scalar_offset_2 / 4].xyz));
+}
+
+void main() {
+  const float3 x = mul(asfloat(data[3].xyz), tint_symbol_2(data, 0u));
+  return;
+}

test/tint/expressions/binary/mul/mat3x3-vec3/f32.wgsl.expected.msl

@@ -0,0 +1,25 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, int N, int M>
+inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
+  return lhs * vec<T, N>(rhs);
+}
+
+template<typename T, int N, int M>
+inline vec<T, N> operator*(packed_vec<T, M> lhs, matrix<T, N, M> rhs) {
+  return vec<T, M>(lhs) * rhs;
+}
+
+struct S {
+  /* 0x0000 */ float3x3 tint_symbol;
+  /* 0x0030 */ packed_float3 vector;
+  /* 0x003c */ int8_t tint_pad[4];
+};
+
+fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
+  float3 const x = ((*(tint_symbol_2)).tint_symbol * (*(tint_symbol_2)).vector);
+  return;
+}
+

test/tint/expressions/binary/mul/mat3x3-vec3/f32.wgsl.expected.spvasm

@@ -0,0 +1,44 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 21
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main"
+               OpExecutionMode %main OriginUpperLeft
+               OpName %S "S"
+               OpMemberName %S 0 "matrix"
+               OpMemberName %S 1 "vector"
+               OpName %data "data"
+               OpName %main "main"
+               OpDecorate %S Block
+               OpMemberDecorate %S 0 Offset 0
+               OpMemberDecorate %S 0 ColMajor
+               OpMemberDecorate %S 0 MatrixStride 16
+               OpMemberDecorate %S 1 Offset 48
+               OpDecorate %data NonWritable
+               OpDecorate %data DescriptorSet 0
+               OpDecorate %data Binding 0
+      %float = OpTypeFloat 32
+    %v3float = OpTypeVector %float 3
+%mat3v3float = OpTypeMatrix %v3float 3
+          %S = OpTypeStruct %mat3v3float %v3float
+%_ptr_Uniform_S = OpTypePointer Uniform %S
+       %data = OpVariable %_ptr_Uniform_S Uniform
+       %void = OpTypeVoid
+          %7 = OpTypeFunction %void
+       %uint = OpTypeInt 32 0
+     %uint_0 = OpConstant %uint 0
+%_ptr_Uniform_mat3v3float = OpTypePointer Uniform %mat3v3float
+     %uint_1 = OpConstant %uint 1
+%_ptr_Uniform_v3float = OpTypePointer Uniform %v3float
+       %main = OpFunction %void None %7
+         %10 = OpLabel
+         %14 = OpAccessChain %_ptr_Uniform_mat3v3float %data %uint_0
+         %15 = OpLoad %mat3v3float %14
+         %18 = OpAccessChain %_ptr_Uniform_v3float %data %uint_1
+         %19 = OpLoad %v3float %18
+         %20 = OpMatrixTimesVector %v3float %15 %19
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/mat3x3-vec3/f32.wgsl.expected.wgsl

@@ -0,0 +1,11 @@
+struct S {
+  matrix : mat3x3<f32>;
+  vector : vec3<f32>;
+}
+
+@group(0) @binding(0) var<uniform> data : S;
+
+@stage(fragment)
+fn main() {
+  let x = (data.matrix * data.vector);
+}

test/tint/expressions/binary/mul/mat4x2-mat2x4/f32.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+    let a = mat4x2<f32>(vec2<f32>(-1., -2.), vec2<f32>(-3., -4.), vec2<f32>(-5., -6.), vec2<f32>(-7., -8.));
+    let b = mat2x4<f32>(vec4<f32>(1., 2., 3., 4.), vec4<f32>(5., 6., 7., 8.));
+    let r : mat2x2<f32> = a * b;
+}

test/tint/expressions/binary/mul/mat4x2-mat2x4/f32.wgsl.expected.glsl

@@ -0,0 +1,13 @@
+#version 310 es
+
+void f() {
+  mat4x2 a = mat4x2(vec2(-1.0f, -2.0f), vec2(-3.0f, -4.0f), vec2(-5.0f, -6.0f), vec2(-7.0f, -8.0f));
+  mat2x4 b = mat2x4(vec4(1.0f, 2.0f, 3.0f, 4.0f), vec4(5.0f, 6.0f, 7.0f, 8.0f));
+  mat2 r = (a * b);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  f();
+  return;
+}

test/tint/expressions/binary/mul/mat4x2-mat2x4/f32.wgsl.expected.hlsl

@@ -0,0 +1,7 @@
+[numthreads(1, 1, 1)]
+void f() {
+  const float4x2 a = float4x2(float2(-1.0f, -2.0f), float2(-3.0f, -4.0f), float2(-5.0f, -6.0f), float2(-7.0f, -8.0f));
+  const float2x4 b = float2x4(float4(1.0f, 2.0f, 3.0f, 4.0f), float4(5.0f, 6.0f, 7.0f, 8.0f));
+  const float2x2 r = mul(b, a);
+  return;
+}

test/tint/expressions/binary/mul/mat4x2-mat2x4/f32.wgsl.expected.msl

@@ -0,0 +1,10 @@
+#include <metal_stdlib>
+
+using namespace metal;
+kernel void f() {
+  float4x2 const a = float4x2(float2(-1.0f, -2.0f), float2(-3.0f, -4.0f), float2(-5.0f, -6.0f), float2(-7.0f, -8.0f));
+  float2x4 const b = float2x4(float4(1.0f, 2.0f, 3.0f, 4.0f), float4(5.0f, 6.0f, 7.0f, 8.0f));
+  float2x2 const r = (a * b);
+  return;
+}
+

test/tint/expressions/binary/mul/mat4x2-mat2x4/f32.wgsl.expected.spvasm

@@ -0,0 +1,47 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 36
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %f "f"
+               OpExecutionMode %f LocalSize 1 1 1
+               OpName %f "f"
+       %void = OpTypeVoid
+          %1 = OpTypeFunction %void
+      %float = OpTypeFloat 32
+    %v2float = OpTypeVector %float 2
+%mat4v2float = OpTypeMatrix %v2float 4
+   %float_n1 = OpConstant %float -1
+   %float_n2 = OpConstant %float -2
+         %10 = OpConstantComposite %v2float %float_n1 %float_n2
+   %float_n3 = OpConstant %float -3
+   %float_n4 = OpConstant %float -4
+         %13 = OpConstantComposite %v2float %float_n3 %float_n4
+   %float_n5 = OpConstant %float -5
+   %float_n6 = OpConstant %float -6
+         %16 = OpConstantComposite %v2float %float_n5 %float_n6
+   %float_n7 = OpConstant %float -7
+   %float_n8 = OpConstant %float -8
+         %19 = OpConstantComposite %v2float %float_n7 %float_n8
+         %20 = OpConstantComposite %mat4v2float %10 %13 %16 %19
+    %v4float = OpTypeVector %float 4
+%mat2v4float = OpTypeMatrix %v4float 2
+    %float_1 = OpConstant %float 1
+    %float_2 = OpConstant %float 2
+    %float_3 = OpConstant %float 3
+    %float_4 = OpConstant %float 4
+         %27 = OpConstantComposite %v4float %float_1 %float_2 %float_3 %float_4
+    %float_5 = OpConstant %float 5
+    %float_6 = OpConstant %float 6
+    %float_7 = OpConstant %float 7
+    %float_8 = OpConstant %float 8
+         %32 = OpConstantComposite %v4float %float_5 %float_6 %float_7 %float_8
+         %33 = OpConstantComposite %mat2v4float %27 %32
+%mat2v2float = OpTypeMatrix %v2float 2
+          %f = OpFunction %void None %1
+          %4 = OpLabel
+         %34 = OpMatrixTimesMatrix %mat2v2float %20 %33
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/mat4x2-mat2x4/f32.wgsl.expected.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+  let a = mat4x2<f32>(vec2<f32>(-1.0, -2.0), vec2<f32>(-3.0, -4.0), vec2<f32>(-5.0, -6.0), vec2<f32>(-7.0, -8.0));
+  let b = mat2x4<f32>(vec4<f32>(1.0, 2.0, 3.0, 4.0), vec4<f32>(5.0, 6.0, 7.0, 8.0));
+  let r : mat2x2<f32> = (a * b);
+}

test/tint/expressions/binary/mul/scalar-scalar/f32.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+    let a = 1.;
+    let b = 2.;
+    let r : f32 = a * b;
+}

test/tint/expressions/binary/mul/scalar-scalar/f32.wgsl.expected.glsl

@@ -0,0 +1,11 @@
+#version 310 es
+
+void f() {
+  float r = (1.0f * 2.0f);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  f();
+  return;
+}

test/tint/expressions/binary/mul/scalar-scalar/f32.wgsl.expected.hlsl

@@ -0,0 +1,5 @@
+[numthreads(1, 1, 1)]
+void f() {
+  const float r = (1.0f * 2.0f);
+  return;
+}

test/tint/expressions/binary/mul/scalar-scalar/f32.wgsl.expected.msl

@@ -0,0 +1,10 @@
+#include <metal_stdlib>
+
+using namespace metal;
+kernel void f() {
+  float const a = 1.0f;
+  float const b = 2.0f;
+  float const r = (a * b);
+  return;
+}
+

test/tint/expressions/binary/mul/scalar-scalar/f32.wgsl.expected.spvasm

@@ -0,0 +1,20 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 9
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %f "f"
+               OpExecutionMode %f LocalSize 1 1 1
+               OpName %f "f"
+       %void = OpTypeVoid
+          %1 = OpTypeFunction %void
+      %float = OpTypeFloat 32
+    %float_1 = OpConstant %float 1
+    %float_2 = OpConstant %float 2
+          %f = OpFunction %void None %1
+          %4 = OpLabel
+          %8 = OpFMul %float %float_1 %float_2
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/scalar-scalar/f32.wgsl.expected.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+  let a = 1.0;
+  let b = 2.0;
+  let r : f32 = (a * b);
+}

test/tint/expressions/binary/mul/scalar-scalar/i32.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+    let a = 1;
+    let b = 2;
+    let r : i32 = a * b;
+}

test/tint/expressions/binary/mul/scalar-scalar/i32.wgsl.expected.glsl

@@ -0,0 +1,11 @@
+#version 310 es
+
+void f() {
+  int r = (1 * 2);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  f();
+  return;
+}

test/tint/expressions/binary/mul/scalar-scalar/i32.wgsl.expected.hlsl

@@ -0,0 +1,5 @@
+[numthreads(1, 1, 1)]
+void f() {
+  const int r = (1 * 2);
+  return;
+}

test/tint/expressions/binary/mul/scalar-scalar/i32.wgsl.expected.msl

@@ -0,0 +1,10 @@
+#include <metal_stdlib>
+
+using namespace metal;
+kernel void f() {
+  int const a = 1;
+  int const b = 2;
+  int const r = as_type<int>((as_type<uint>(a) * as_type<uint>(b)));
+  return;
+}
+

test/tint/expressions/binary/mul/scalar-scalar/i32.wgsl.expected.spvasm

@@ -0,0 +1,20 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 9
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %f "f"
+               OpExecutionMode %f LocalSize 1 1 1
+               OpName %f "f"
+       %void = OpTypeVoid
+          %1 = OpTypeFunction %void
+        %int = OpTypeInt 32 1
+      %int_1 = OpConstant %int 1
+      %int_2 = OpConstant %int 2
+          %f = OpFunction %void None %1
+          %4 = OpLabel
+          %8 = OpIMul %int %int_1 %int_2
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/scalar-scalar/i32.wgsl.expected.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+  let a = 1;
+  let b = 2;
+  let r : i32 = (a * b);
+}

test/tint/expressions/binary/mul/scalar-scalar/u32.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+    let a = 1u;
+    let b = 2u;
+    let r : u32 = a * b;
+}

test/tint/expressions/binary/mul/scalar-scalar/u32.wgsl.expected.glsl

@@ -0,0 +1,11 @@
+#version 310 es
+
+void f() {
+  uint r = (1u * 2u);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  f();
+  return;
+}

test/tint/expressions/binary/mul/scalar-scalar/u32.wgsl.expected.hlsl

@@ -0,0 +1,5 @@
+[numthreads(1, 1, 1)]
+void f() {
+  const uint r = (1u * 2u);
+  return;
+}

test/tint/expressions/binary/mul/scalar-scalar/u32.wgsl.expected.msl

@@ -0,0 +1,10 @@
+#include <metal_stdlib>
+
+using namespace metal;
+kernel void f() {
+  uint const a = 1u;
+  uint const b = 2u;
+  uint const r = (a * b);
+  return;
+}
+

test/tint/expressions/binary/mul/scalar-scalar/u32.wgsl.expected.spvasm

@@ -0,0 +1,20 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 9
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %f "f"
+               OpExecutionMode %f LocalSize 1 1 1
+               OpName %f "f"
+       %void = OpTypeVoid
+          %1 = OpTypeFunction %void
+       %uint = OpTypeInt 32 0
+     %uint_1 = OpConstant %uint 1
+     %uint_2 = OpConstant %uint 2
+          %f = OpFunction %void None %1
+          %4 = OpLabel
+          %8 = OpIMul %uint %uint_1 %uint_2
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/scalar-scalar/u32.wgsl.expected.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+  let a = 1u;
+  let b = 2u;
+  let r : u32 = (a * b);
+}

test/tint/expressions/binary/mul/scalar-vec3/f32.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+    let a = 4.;
+    let b = vec3<f32>(1., 2., 3.);
+    let r : vec3<f32> = a * b;
+}

test/tint/expressions/binary/mul/scalar-vec3/f32.wgsl.expected.glsl

@@ -0,0 +1,13 @@
+#version 310 es
+
+void f() {
+  float a = 4.0f;
+  vec3 b = vec3(1.0f, 2.0f, 3.0f);
+  vec3 r = (a * b);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  f();
+  return;
+}

test/tint/expressions/binary/mul/scalar-vec3/f32.wgsl.expected.hlsl

@@ -0,0 +1,7 @@
+[numthreads(1, 1, 1)]
+void f() {
+  const float a = 4.0f;
+  const float3 b = float3(1.0f, 2.0f, 3.0f);
+  const float3 r = (a * b);
+  return;
+}

test/tint/expressions/binary/mul/scalar-vec3/f32.wgsl.expected.msl

@@ -0,0 +1,10 @@
+#include <metal_stdlib>
+
+using namespace metal;
+kernel void f() {
+  float const a = 4.0f;
+  float3 const b = float3(1.0f, 2.0f, 3.0f);
+  float3 const r = (a * b);
+  return;
+}
+

test/tint/expressions/binary/mul/scalar-vec3/f32.wgsl.expected.spvasm

@@ -0,0 +1,24 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 13
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %f "f"
+               OpExecutionMode %f LocalSize 1 1 1
+               OpName %f "f"
+       %void = OpTypeVoid
+          %1 = OpTypeFunction %void
+      %float = OpTypeFloat 32
+    %float_4 = OpConstant %float 4
+    %v3float = OpTypeVector %float 3
+    %float_1 = OpConstant %float 1
+    %float_2 = OpConstant %float 2
+    %float_3 = OpConstant %float 3
+         %11 = OpConstantComposite %v3float %float_1 %float_2 %float_3
+          %f = OpFunction %void None %1
+          %4 = OpLabel
+         %12 = OpVectorTimesScalar %v3float %11 %float_4
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/scalar-vec3/f32.wgsl.expected.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+  let a = 4.0;
+  let b = vec3<f32>(1.0, 2.0, 3.0);
+  let r : vec3<f32> = (a * b);
+}

test/tint/expressions/binary/mul/scalar-vec3/i32.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+    let a = 4;
+    let b = vec3<i32>(1, 2, 3);
+    let r : vec3<i32> = a * b;
+}

test/tint/expressions/binary/mul/scalar-vec3/i32.wgsl.expected.glsl

@@ -0,0 +1,13 @@
+#version 310 es
+
+void f() {
+  int a = 4;
+  ivec3 b = ivec3(1, 2, 3);
+  ivec3 r = (a * b);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  f();
+  return;
+}

test/tint/expressions/binary/mul/scalar-vec3/i32.wgsl.expected.hlsl

@@ -0,0 +1,7 @@
+[numthreads(1, 1, 1)]
+void f() {
+  const int a = 4;
+  const int3 b = int3(1, 2, 3);
+  const int3 r = (a * b);
+  return;
+}

test/tint/expressions/binary/mul/scalar-vec3/i32.wgsl.expected.msl

@@ -0,0 +1,10 @@
+#include <metal_stdlib>
+
+using namespace metal;
+kernel void f() {
+  int const a = 4;
+  int3 const b = int3(1, 2, 3);
+  int3 const r = as_type<int3>((as_type<uint>(a) * as_type<uint3>(b)));
+  return;
+}
+

test/tint/expressions/binary/mul/scalar-vec3/i32.wgsl.expected.spvasm

@@ -0,0 +1,28 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 17
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %f "f"
+               OpExecutionMode %f LocalSize 1 1 1
+               OpName %f "f"
+       %void = OpTypeVoid
+          %1 = OpTypeFunction %void
+        %int = OpTypeInt 32 1
+      %int_4 = OpConstant %int 4
+      %v3int = OpTypeVector %int 3
+      %int_1 = OpConstant %int 1
+      %int_2 = OpConstant %int 2
+      %int_3 = OpConstant %int 3
+         %11 = OpConstantComposite %v3int %int_1 %int_2 %int_3
+%_ptr_Function_v3int = OpTypePointer Function %v3int
+         %15 = OpConstantNull %v3int
+          %f = OpFunction %void None %1
+          %4 = OpLabel
+         %13 = OpVariable %_ptr_Function_v3int Function %15
+         %16 = OpCompositeConstruct %v3int %int_4 %int_4 %int_4
+         %12 = OpIMul %v3int %16 %11
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/scalar-vec3/i32.wgsl.expected.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+  let a = 4;
+  let b = vec3<i32>(1, 2, 3);
+  let r : vec3<i32> = (a * b);
+}

test/tint/expressions/binary/mul/scalar-vec3/u32.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+    let a = 4u;
+    let b = vec3<u32>(1u, 2u, 3u);
+    let r : vec3<u32> = a * b;
+}

test/tint/expressions/binary/mul/scalar-vec3/u32.wgsl.expected.glsl

@@ -0,0 +1,13 @@
+#version 310 es
+
+void f() {
+  uint a = 4u;
+  uvec3 b = uvec3(1u, 2u, 3u);
+  uvec3 r = (a * b);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  f();
+  return;
+}

test/tint/expressions/binary/mul/scalar-vec3/u32.wgsl.expected.hlsl

@@ -0,0 +1,7 @@
+[numthreads(1, 1, 1)]
+void f() {
+  const uint a = 4u;
+  const uint3 b = uint3(1u, 2u, 3u);
+  const uint3 r = (a * b);
+  return;
+}

test/tint/expressions/binary/mul/scalar-vec3/u32.wgsl.expected.msl

@@ -0,0 +1,10 @@
+#include <metal_stdlib>
+
+using namespace metal;
+kernel void f() {
+  uint const a = 4u;
+  uint3 const b = uint3(1u, 2u, 3u);
+  uint3 const r = (a * b);
+  return;
+}
+

test/tint/expressions/binary/mul/scalar-vec3/u32.wgsl.expected.spvasm

@@ -0,0 +1,28 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 17
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %f "f"
+               OpExecutionMode %f LocalSize 1 1 1
+               OpName %f "f"
+       %void = OpTypeVoid
+          %1 = OpTypeFunction %void
+       %uint = OpTypeInt 32 0
+     %uint_4 = OpConstant %uint 4
+     %v3uint = OpTypeVector %uint 3
+     %uint_1 = OpConstant %uint 1
+     %uint_2 = OpConstant %uint 2
+     %uint_3 = OpConstant %uint 3
+         %11 = OpConstantComposite %v3uint %uint_1 %uint_2 %uint_3
+%_ptr_Function_v3uint = OpTypePointer Function %v3uint
+         %15 = OpConstantNull %v3uint
+          %f = OpFunction %void None %1
+          %4 = OpLabel
+         %13 = OpVariable %_ptr_Function_v3uint Function %15
+         %16 = OpCompositeConstruct %v3uint %uint_4 %uint_4 %uint_4
+         %12 = OpIMul %v3uint %16 %11
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/scalar-vec3/u32.wgsl.expected.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+  let a = 4u;
+  let b = vec3<u32>(1u, 2u, 3u);
+  let r : vec3<u32> = (a * b);
+}

test/tint/expressions/binary/mul/vec3-mat3x3/f32.wgsl

@@ -0,0 +1,10 @@
+struct S {
+    matrix : mat3x3<f32>;
+    vector : vec3<f32>;
+};
+@group(0) @binding(0) var<uniform> data: S;
+
+@stage(fragment)
+fn main() {
+  let x = data.vector * data.matrix;
+}

test/tint/expressions/binary/mul/vec3-mat3x3/f32.wgsl.expected.glsl

@@ -0,0 +1,21 @@
+#version 310 es
+precision mediump float;
+
+struct S {
+  mat3 matrix;
+  vec3 vector;
+};
+
+layout(binding = 0) uniform S_1 {
+  mat3 matrix;
+  vec3 vector;
+} data;
+
+void tint_symbol() {
+  vec3 x = (data.vector * data.matrix);
+}
+
+void main() {
+  tint_symbol();
+  return;
+}

test/tint/expressions/binary/mul/vec3-mat3x3/f32.wgsl.expected.hlsl

@@ -0,0 +1,15 @@
+cbuffer cbuffer_data : register(b0, space0) {
+  uint4 data[4];
+};
+
+float3x3 tint_symbol_3(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;
+  return float3x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz), asfloat(buffer[scalar_offset_2 / 4].xyz));
+}
+
+void main() {
+  const float3 x = mul(tint_symbol_3(data, 0u), asfloat(data[3].xyz));
+  return;
+}

test/tint/expressions/binary/mul/vec3-mat3x3/f32.wgsl.expected.msl

@@ -0,0 +1,25 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, int N, int M>
+inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
+  return lhs * vec<T, N>(rhs);
+}
+
+template<typename T, int N, int M>
+inline vec<T, N> operator*(packed_vec<T, M> lhs, matrix<T, N, M> rhs) {
+  return vec<T, M>(lhs) * rhs;
+}
+
+struct S {
+  /* 0x0000 */ float3x3 tint_symbol;
+  /* 0x0030 */ packed_float3 vector;
+  /* 0x003c */ int8_t tint_pad[4];
+};
+
+fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
+  float3 const x = ((*(tint_symbol_2)).vector * (*(tint_symbol_2)).tint_symbol);
+  return;
+}
+

test/tint/expressions/binary/mul/vec3-mat3x3/f32.wgsl.expected.spvasm

@@ -0,0 +1,44 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 21
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main"
+               OpExecutionMode %main OriginUpperLeft
+               OpName %S "S"
+               OpMemberName %S 0 "matrix"
+               OpMemberName %S 1 "vector"
+               OpName %data "data"
+               OpName %main "main"
+               OpDecorate %S Block
+               OpMemberDecorate %S 0 Offset 0
+               OpMemberDecorate %S 0 ColMajor
+               OpMemberDecorate %S 0 MatrixStride 16
+               OpMemberDecorate %S 1 Offset 48
+               OpDecorate %data NonWritable
+               OpDecorate %data DescriptorSet 0
+               OpDecorate %data Binding 0
+      %float = OpTypeFloat 32
+    %v3float = OpTypeVector %float 3
+%mat3v3float = OpTypeMatrix %v3float 3
+          %S = OpTypeStruct %mat3v3float %v3float
+%_ptr_Uniform_S = OpTypePointer Uniform %S
+       %data = OpVariable %_ptr_Uniform_S Uniform
+       %void = OpTypeVoid
+          %7 = OpTypeFunction %void
+       %uint = OpTypeInt 32 0
+     %uint_1 = OpConstant %uint 1
+%_ptr_Uniform_v3float = OpTypePointer Uniform %v3float
+     %uint_0 = OpConstant %uint 0
+%_ptr_Uniform_mat3v3float = OpTypePointer Uniform %mat3v3float
+       %main = OpFunction %void None %7
+         %10 = OpLabel
+         %14 = OpAccessChain %_ptr_Uniform_v3float %data %uint_1
+         %15 = OpLoad %v3float %14
+         %18 = OpAccessChain %_ptr_Uniform_mat3v3float %data %uint_0
+         %19 = OpLoad %mat3v3float %18
+         %20 = OpVectorTimesMatrix %v3float %15 %19
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/vec3-mat3x3/f32.wgsl.expected.wgsl

@@ -0,0 +1,11 @@
+struct S {
+  matrix : mat3x3<f32>;
+  vector : vec3<f32>;
+}
+
+@group(0) @binding(0) var<uniform> data : S;
+
+@stage(fragment)
+fn main() {
+  let x = (data.vector * data.matrix);
+}

test/tint/expressions/binary/mul/vec3-mat4x3/f32.wgsl

@@ -0,0 +1,10 @@
+struct S {
+    matrix : mat4x3<f32>;
+    vector : vec3<f32>;
+};
+@group(0) @binding(0) var<uniform> data: S;
+
+@stage(fragment)
+fn main() {
+  let x = data.vector * data.matrix;
+}

test/tint/expressions/binary/mul/vec3-mat4x3/f32.wgsl.expected.glsl

@@ -0,0 +1,21 @@
+#version 310 es
+precision mediump float;
+
+struct S {
+  mat4x3 matrix;
+  vec3 vector;
+};
+
+layout(binding = 0) uniform S_1 {
+  mat4x3 matrix;
+  vec3 vector;
+} data;
+
+void tint_symbol() {
+  vec4 x = (data.vector * data.matrix);
+}
+
+void main() {
+  tint_symbol();
+  return;
+}

test/tint/expressions/binary/mul/vec3-mat4x3/f32.wgsl.expected.hlsl

@@ -0,0 +1,16 @@
+cbuffer cbuffer_data : register(b0, space0) {
+  uint4 data[5];
+};
+
+float4x3 tint_symbol_3(uint4 buffer[5], 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 float4x3(asfloat(buffer[scalar_offset / 4].xyz), asfloat(buffer[scalar_offset_1 / 4].xyz), asfloat(buffer[scalar_offset_2 / 4].xyz), asfloat(buffer[scalar_offset_3 / 4].xyz));
+}
+
+void main() {
+  const float4 x = mul(tint_symbol_3(data, 0u), asfloat(data[4].xyz));
+  return;
+}

test/tint/expressions/binary/mul/vec3-mat4x3/f32.wgsl.expected.msl

@@ -0,0 +1,25 @@
+#include <metal_stdlib>
+
+using namespace metal;
+
+template<typename T, int N, int M>
+inline vec<T, M> operator*(matrix<T, N, M> lhs, packed_vec<T, N> rhs) {
+  return lhs * vec<T, N>(rhs);
+}
+
+template<typename T, int N, int M>
+inline vec<T, N> operator*(packed_vec<T, M> lhs, matrix<T, N, M> rhs) {
+  return vec<T, M>(lhs) * rhs;
+}
+
+struct S {
+  /* 0x0000 */ float4x3 tint_symbol;
+  /* 0x0040 */ packed_float3 vector;
+  /* 0x004c */ int8_t tint_pad[4];
+};
+
+fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
+  float4 const x = ((*(tint_symbol_2)).vector * (*(tint_symbol_2)).tint_symbol);
+  return;
+}
+

test/tint/expressions/binary/mul/vec3-mat4x3/f32.wgsl.expected.spvasm

@@ -0,0 +1,45 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 22
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main"
+               OpExecutionMode %main OriginUpperLeft
+               OpName %S "S"
+               OpMemberName %S 0 "matrix"
+               OpMemberName %S 1 "vector"
+               OpName %data "data"
+               OpName %main "main"
+               OpDecorate %S Block
+               OpMemberDecorate %S 0 Offset 0
+               OpMemberDecorate %S 0 ColMajor
+               OpMemberDecorate %S 0 MatrixStride 16
+               OpMemberDecorate %S 1 Offset 64
+               OpDecorate %data NonWritable
+               OpDecorate %data DescriptorSet 0
+               OpDecorate %data Binding 0
+      %float = OpTypeFloat 32
+    %v3float = OpTypeVector %float 3
+%mat4v3float = OpTypeMatrix %v3float 4
+          %S = OpTypeStruct %mat4v3float %v3float
+%_ptr_Uniform_S = OpTypePointer Uniform %S
+       %data = OpVariable %_ptr_Uniform_S Uniform
+       %void = OpTypeVoid
+          %7 = OpTypeFunction %void
+       %uint = OpTypeInt 32 0
+     %uint_1 = OpConstant %uint 1
+%_ptr_Uniform_v3float = OpTypePointer Uniform %v3float
+     %uint_0 = OpConstant %uint 0
+%_ptr_Uniform_mat4v3float = OpTypePointer Uniform %mat4v3float
+    %v4float = OpTypeVector %float 4
+       %main = OpFunction %void None %7
+         %10 = OpLabel
+         %14 = OpAccessChain %_ptr_Uniform_v3float %data %uint_1
+         %15 = OpLoad %v3float %14
+         %18 = OpAccessChain %_ptr_Uniform_mat4v3float %data %uint_0
+         %19 = OpLoad %mat4v3float %18
+         %20 = OpVectorTimesMatrix %v4float %15 %19
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/vec3-mat4x3/f32.wgsl.expected.wgsl

@@ -0,0 +1,11 @@
+struct S {
+  matrix : mat4x3<f32>;
+  vector : vec3<f32>;
+}
+
+@group(0) @binding(0) var<uniform> data : S;
+
+@stage(fragment)
+fn main() {
+  let x = (data.vector * data.matrix);
+}

test/tint/expressions/binary/mul/vec3-scalar/f32.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+    let a = vec3<f32>(1., 2., 3.);
+    let b = 4.;
+    let r : vec3<f32> = a * b;
+}

test/tint/expressions/binary/mul/vec3-scalar/f32.wgsl.expected.glsl

@@ -0,0 +1,12 @@
+#version 310 es
+
+void f() {
+  vec3 a = vec3(1.0f, 2.0f, 3.0f);
+  vec3 r = (a * 4.0f);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  f();
+  return;
+}

test/tint/expressions/binary/mul/vec3-scalar/f32.wgsl.expected.hlsl

@@ -0,0 +1,6 @@
+[numthreads(1, 1, 1)]
+void f() {
+  const float3 a = float3(1.0f, 2.0f, 3.0f);
+  const float3 r = (a * 4.0f);
+  return;
+}

test/tint/expressions/binary/mul/vec3-scalar/f32.wgsl.expected.msl

@@ -0,0 +1,10 @@
+#include <metal_stdlib>
+
+using namespace metal;
+kernel void f() {
+  float3 const a = float3(1.0f, 2.0f, 3.0f);
+  float const b = 4.0f;
+  float3 const r = (a * b);
+  return;
+}
+

test/tint/expressions/binary/mul/vec3-scalar/f32.wgsl.expected.spvasm

@@ -0,0 +1,24 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 13
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %f "f"
+               OpExecutionMode %f LocalSize 1 1 1
+               OpName %f "f"
+       %void = OpTypeVoid
+          %1 = OpTypeFunction %void
+      %float = OpTypeFloat 32
+    %v3float = OpTypeVector %float 3
+    %float_1 = OpConstant %float 1
+    %float_2 = OpConstant %float 2
+    %float_3 = OpConstant %float 3
+         %10 = OpConstantComposite %v3float %float_1 %float_2 %float_3
+    %float_4 = OpConstant %float 4
+          %f = OpFunction %void None %1
+          %4 = OpLabel
+         %12 = OpVectorTimesScalar %v3float %10 %float_4
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/vec3-scalar/f32.wgsl.expected.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+  let a = vec3<f32>(1.0, 2.0, 3.0);
+  let b = 4.0;
+  let r : vec3<f32> = (a * b);
+}

test/tint/expressions/binary/mul/vec3-scalar/i32.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+    let a = vec3<i32>(1, 2, 3);
+    let b = 4;
+    let r : vec3<i32> = a * b;
+}

test/tint/expressions/binary/mul/vec3-scalar/i32.wgsl.expected.glsl

@@ -0,0 +1,12 @@
+#version 310 es
+
+void f() {
+  ivec3 a = ivec3(1, 2, 3);
+  ivec3 r = (a * 4);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  f();
+  return;
+}

test/tint/expressions/binary/mul/vec3-scalar/i32.wgsl.expected.hlsl

@@ -0,0 +1,6 @@
+[numthreads(1, 1, 1)]
+void f() {
+  const int3 a = int3(1, 2, 3);
+  const int3 r = (a * 4);
+  return;
+}

test/tint/expressions/binary/mul/vec3-scalar/i32.wgsl.expected.msl

@@ -0,0 +1,10 @@
+#include <metal_stdlib>
+
+using namespace metal;
+kernel void f() {
+  int3 const a = int3(1, 2, 3);
+  int const b = 4;
+  int3 const r = as_type<int3>((as_type<uint3>(a) * as_type<uint>(b)));
+  return;
+}
+

test/tint/expressions/binary/mul/vec3-scalar/i32.wgsl.expected.spvasm

@@ -0,0 +1,28 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 17
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %f "f"
+               OpExecutionMode %f LocalSize 1 1 1
+               OpName %f "f"
+       %void = OpTypeVoid
+          %1 = OpTypeFunction %void
+        %int = OpTypeInt 32 1
+      %v3int = OpTypeVector %int 3
+      %int_1 = OpConstant %int 1
+      %int_2 = OpConstant %int 2
+      %int_3 = OpConstant %int 3
+         %10 = OpConstantComposite %v3int %int_1 %int_2 %int_3
+      %int_4 = OpConstant %int 4
+%_ptr_Function_v3int = OpTypePointer Function %v3int
+         %15 = OpConstantNull %v3int
+          %f = OpFunction %void None %1
+          %4 = OpLabel
+         %13 = OpVariable %_ptr_Function_v3int Function %15
+         %16 = OpCompositeConstruct %v3int %int_4 %int_4 %int_4
+         %12 = OpIMul %v3int %10 %16
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/vec3-scalar/i32.wgsl.expected.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+  let a = vec3<i32>(1, 2, 3);
+  let b = 4;
+  let r : vec3<i32> = (a * b);
+}

test/tint/expressions/binary/mul/vec3-scalar/u32.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+    let a = vec3<u32>(1u, 2u, 3u);
+    let b = 4u;
+    let r : vec3<u32> = a * b;
+}

test/tint/expressions/binary/mul/vec3-scalar/u32.wgsl.expected.glsl

@@ -0,0 +1,12 @@
+#version 310 es
+
+void f() {
+  uvec3 a = uvec3(1u, 2u, 3u);
+  uvec3 r = (a * 4u);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  f();
+  return;
+}

test/tint/expressions/binary/mul/vec3-scalar/u32.wgsl.expected.hlsl

@@ -0,0 +1,6 @@
+[numthreads(1, 1, 1)]
+void f() {
+  const uint3 a = uint3(1u, 2u, 3u);
+  const uint3 r = (a * 4u);
+  return;
+}

test/tint/expressions/binary/mul/vec3-scalar/u32.wgsl.expected.msl

@@ -0,0 +1,10 @@
+#include <metal_stdlib>
+
+using namespace metal;
+kernel void f() {
+  uint3 const a = uint3(1u, 2u, 3u);
+  uint const b = 4u;
+  uint3 const r = (a * b);
+  return;
+}
+

test/tint/expressions/binary/mul/vec3-scalar/u32.wgsl.expected.spvasm

@@ -0,0 +1,28 @@
+; SPIR-V
+; Version: 1.3
+; Generator: Google Tint Compiler; 0
+; Bound: 17
+; Schema: 0
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %f "f"
+               OpExecutionMode %f LocalSize 1 1 1
+               OpName %f "f"
+       %void = OpTypeVoid
+          %1 = OpTypeFunction %void
+       %uint = OpTypeInt 32 0
+     %v3uint = OpTypeVector %uint 3
+     %uint_1 = OpConstant %uint 1
+     %uint_2 = OpConstant %uint 2
+     %uint_3 = OpConstant %uint 3
+         %10 = OpConstantComposite %v3uint %uint_1 %uint_2 %uint_3
+     %uint_4 = OpConstant %uint 4
+%_ptr_Function_v3uint = OpTypePointer Function %v3uint
+         %15 = OpConstantNull %v3uint
+          %f = OpFunction %void None %1
+          %4 = OpLabel
+         %13 = OpVariable %_ptr_Function_v3uint Function %15
+         %16 = OpCompositeConstruct %v3uint %uint_4 %uint_4 %uint_4
+         %12 = OpIMul %v3uint %10 %16
+               OpReturn
+               OpFunctionEnd

test/tint/expressions/binary/mul/vec3-scalar/u32.wgsl.expected.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+  let a = vec3<u32>(1u, 2u, 3u);
+  let b = 4u;
+  let r : vec3<u32> = (a * b);
+}

test/tint/expressions/binary/mul/vec3-vec3/f32.wgsl

@@ -0,0 +1,6 @@
+@stage(compute) @workgroup_size(1)
+fn f() {
+    let a = vec3<f32>(1., 2., 3.);
+    let b = vec3<f32>(4., 5., 6.);
+    let r : vec3<f32> = a * b;
+}

test/tint/expressions/binary/mul/vec3-vec3/f32.wgsl.expected.glsl

@@ -0,0 +1,13 @@
+#version 310 es
+
+void f() {
+  vec3 a = vec3(1.0f, 2.0f, 3.0f);
+  vec3 b = vec3(4.0f, 5.0f, 6.0f);
+  vec3 r = (a * b);
+}
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void main() {
+  f();
+  return;
+}

test/tint/expressions/binary/mul/vec3-vec3/f32.wgsl.expected.hlsl

@@ -0,0 +1,7 @@
+[numthreads(1, 1, 1)]
+void f() {
+  const float3 a = float3(1.0f, 2.0f, 3.0f);
+  const float3 b = float3(4.0f, 5.0f, 6.0f);
+  const float3 r = (a * b);
+  return;
+}

test/tint/expressions/binary/mul/vec3-vec3/f32.wgsl.expected.msl

@@ -0,0 +1,10 @@
+#include <metal_stdlib>
+
+using namespace metal;
+kernel void f() {
+  float3 const a = float3(1.0f, 2.0f, 3.0f);
+  float3 const b = float3(4.0f, 5.0f, 6.0f);
+  float3 const r = (a * b);
+  return;
+}
+