diff --git a/src/tint/lang/hlsl/writer/access_test.cc b/src/tint/lang/hlsl/writer/access_test.cc
index 194041c672f..7ac2e74d124 100644
--- a/src/tint/lang/hlsl/writer/access_test.cc
+++ b/src/tint/lang/hlsl/writer/access_test.cc
@@ -979,7 +979,7 @@ void foo() {
   uint x = 1u;
   vector<float16_t, 4> a = tint_bitcast_to_f16(v[0u]);
   float16_t b = float16_t(f16tof32(v[0u].x));
-  uint v_4 = (min(x, 3u) * 2u);
+  uint v_4 = (uint(min(x, 3u)) * 2u);
   uint v_5 = v[(v_4 / 16u)][((v_4 % 16u) / 4u)];
   float16_t c = float16_t(f16tof32((v_5 >> ((((v_4 % 4u) == 0u)) ? (0u) : (16u)))));
   float16_t d = float16_t(f16tof32(v[0u].y));
diff --git a/src/tint/lang/hlsl/writer/raise/decompose_uniform_access.cc b/src/tint/lang/hlsl/writer/raise/decompose_uniform_access.cc
index 0c9460a4a5a..fdbe18cc7f1 100644
--- a/src/tint/lang/hlsl/writer/raise/decompose_uniform_access.cc
+++ b/src/tint/lang/hlsl/writer/raise/decompose_uniform_access.cc
@@ -279,7 +279,8 @@ struct State {
                 offset.byte_offset += (cnst->Value()->ValueAs<uint32_t>() * elem_byte_size);
             } else {
                 offset.byte_offset_expr.Push(
-                    b.Multiply(ty.u32(), lve->Index(), u32(elem_byte_size))->Result(0));
+                    b.Multiply(ty.u32(), b.Convert(ty.u32(), lve->Index()), u32(elem_byte_size))
+                        ->Result(0));
             }
 
             auto* byte_idx = OffsetToValue(offset);
diff --git a/src/tint/lang/hlsl/writer/raise/decompose_uniform_access_test.cc b/src/tint/lang/hlsl/writer/raise/decompose_uniform_access_test.cc
index d2be685575a..57df7336b32 100644
--- a/src/tint/lang/hlsl/writer/raise/decompose_uniform_access_test.cc
+++ b/src/tint/lang/hlsl/writer/raise/decompose_uniform_access_test.cc
@@ -406,30 +406,31 @@ TEST_F(HlslWriterDecomposeUniformAccessTest, UniformAccessVectorF16) {
     %10:f32 = hlsl.f16tof32 %9
     %11:f16 = convert %10
     %b:f16 = let %11
-    %13:u32 = mul %x, 2u
-    %14:u32 = div %13, 16u
-    %15:ptr<uniform, vec4<u32>, read> = access %v, %14
-    %16:u32 = mod %13, 16u
-    %17:u32 = div %16, 4u
-    %18:u32 = load_vector_element %15, %17
-    %19:u32 = mod %13, 4u
-    %20:bool = eq %19, 0u
-    %21:u32 = hlsl.ternary 16u, 0u, %20
-    %22:u32 = shr %18, %21
-    %23:f32 = hlsl.f16tof32 %22
-    %24:f16 = convert %23
-    %c:f16 = let %24
-    %26:ptr<uniform, vec4<u32>, read> = access %v, 0u
-    %27:u32 = load_vector_element %26, 1u
-    %28:f32 = hlsl.f16tof32 %27
-    %29:f16 = convert %28
-    %d:f16 = let %29
-    %31:ptr<uniform, vec4<u32>, read> = access %v, 0u
-    %32:u32 = load_vector_element %31, 1u
-    %33:u32 = shr %32, 16u
-    %34:f32 = hlsl.f16tof32 %33
-    %35:f16 = convert %34
-    %e:f16 = let %35
+    %13:u32 = convert %x
+    %14:u32 = mul %13, 2u
+    %15:u32 = div %14, 16u
+    %16:ptr<uniform, vec4<u32>, read> = access %v, %15
+    %17:u32 = mod %14, 16u
+    %18:u32 = div %17, 4u
+    %19:u32 = load_vector_element %16, %18
+    %20:u32 = mod %14, 4u
+    %21:bool = eq %20, 0u
+    %22:u32 = hlsl.ternary 16u, 0u, %21
+    %23:u32 = shr %19, %22
+    %24:f32 = hlsl.f16tof32 %23
+    %25:f16 = convert %24
+    %c:f16 = let %25
+    %27:ptr<uniform, vec4<u32>, read> = access %v, 0u
+    %28:u32 = load_vector_element %27, 1u
+    %29:f32 = hlsl.f16tof32 %28
+    %30:f16 = convert %29
+    %d:f16 = let %30
+    %32:ptr<uniform, vec4<u32>, read> = access %v, 0u
+    %33:u32 = load_vector_element %32, 1u
+    %34:u32 = shr %33, 16u
+    %35:f32 = hlsl.f16tof32 %34
+    %36:f16 = convert %35
+    %e:f16 = let %36
     ret
   }
 }
diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat2x2_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index dc1ee6458f7..578f0380e49 100644
--- a/test/tint/buffer/uniform/std140/struct/mat2x2_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat2x2_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,250 +1,107 @@
-SKIP: FAILED
-
-
-enable f16;
-
 struct Inner {
-  @size(64)
-  m : mat2x2<f16>,
-}
+  matrix<float16_t, 2, 2> m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
+  Inner a[4];
+};
 
-var<private> counter = 0;
 
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat2x2<f16> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec2<f16> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f16 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :60:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %48:u32 = mul %47, 2u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(4) {
-  m:mat2x2<f16> @offset(0)
+vector<float16_t, 2> tint_bitcast_to_f16(uint src) {
+  uint v = src;
+  float t_low = f16tof32((v & 65535u));
+  float t_high = f16tof32(((v >> 16u) & 65535u));
+  float16_t v_1 = float16_t(t_low);
+  return vector<float16_t, 2>(v_1, float16_t(t_high));
 }
 
-Outer = struct @align(4) {
-  a:array<Inner, 4> @offset(0)
+matrix<float16_t, 2, 2> v_2(uint start_byte_offset) {
+  uint4 v_3 = a[(start_byte_offset / 16u)];
+  vector<float16_t, 2> v_4 = tint_bitcast_to_f16((((((start_byte_offset % 16u) / 4u) == 2u)) ? (v_3.z) : (v_3.x)));
+  uint4 v_5 = a[((4u + start_byte_offset) / 16u)];
+  return matrix<float16_t, 2, 2>(v_4, tint_bitcast_to_f16(((((((4u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_5.z) : (v_5.x))));
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
+Inner v_6(uint start_byte_offset) {
+  Inner v_7 = {v_2(start_byte_offset)};
+  return v_7;
 }
 
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 4u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat2x2<f16> = call %32, %30
-    %l_a_i_a_i_m:mat2x2<f16> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:u32 = mod %35, 16u
-    %39:u32 = div %38, 4u
-    %40:vec4<u32> = load %37
-    %41:u32 = swizzle %40, z
-    %42:u32 = swizzle %40, x
-    %43:bool = eq %39, 2u
-    %44:u32 = hlsl.ternary %42, %41, %43
-    %45:vec2<f16> = bitcast %44
-    %l_a_i_a_i_m_i:vec2<f16> = let %45
-    %47:i32 = call %i
-    %48:u32 = mul %47, 2u
-    %49:u32 = add %10, %13
-    %50:u32 = add %49, %16
-    %51:u32 = add %50, %48
-    %52:u32 = div %51, 16u
-    %53:ptr<uniform, vec4<u32>, read> = access %a, %52
-    %54:u32 = mod %51, 16u
-    %55:u32 = div %54, 4u
-    %56:u32 = load_vector_element %53, %55
-    %57:u32 = mod %51, 4u
-    %58:bool = eq %57, 0u
-    %59:u32 = hlsl.ternary 16u, 0u, %58
-    %60:u32 = shr %56, %59
-    %61:f32 = hlsl.f16tof32 %60
-    %62:f16 = convert %61
-    %l_a_i_a_i_m_i_i:f16 = let %62
-    ret
-  }
-}
-%24 = func(%start_byte_offset:u32):array<Inner, 4> {
-  $B4: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat2x2<f16>(vec2<f16>(0.0h))))  # %a_1: 'a'
-    loop [i: $B5, b: $B6, c: $B7] {  # loop_1
-      $B5: {  # initializer
-        next_iteration 0u  # -> $B6
+typedef Inner ary_ret[4];
+ary_ret v_8(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_9 = 0u;
+    v_9 = 0u;
+    while(true) {
+      uint v_10 = v_9;
+      if ((v_10 >= 4u)) {
+        break;
       }
-      $B6 (%idx:u32): {  # body
-        %67:bool = gte %idx, 4u
-        if %67 [t: $B8] {  # if_1
-          $B8: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %68:u32 = mul %idx, 64u
-        %69:u32 = add %start_byte_offset, %68
-        %70:ptr<function, Inner, read_write> = access %a_1, %idx
-        %71:Inner = call %28, %69
-        store %70, %71
-        continue  # -> $B7
-      }
-      $B7: {  # continuing
-        %72:u32 = add %idx, 1u
-        next_iteration %72  # -> $B6
+      Inner v_11 = v_6((start_byte_offset + (v_10 * 64u)));
+      a[v_10] = v_11;
+      {
+        v_9 = (v_10 + 1u);
       }
+      continue;
     }
-    %73:array<Inner, 4> = load %a_1
-    ret %73
-  }
-}
-%28 = func(%start_byte_offset_1:u32):Inner {  # %start_byte_offset_1: 'start_byte_offset'
-  $B9: {
-    %75:mat2x2<f16> = call %32, %start_byte_offset_1
-    %76:Inner = construct %75
-    ret %76
-  }
-}
-%32 = func(%start_byte_offset_2:u32):mat2x2<f16> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %78:u32 = div %start_byte_offset_2, 16u
-    %79:ptr<uniform, vec4<u32>, read> = access %a, %78
-    %80:u32 = mod %start_byte_offset_2, 16u
-    %81:u32 = div %80, 4u
-    %82:vec4<u32> = load %79
-    %83:u32 = swizzle %82, z
-    %84:u32 = swizzle %82, x
-    %85:bool = eq %81, 2u
-    %86:u32 = hlsl.ternary %84, %83, %85
-    %87:vec2<f16> = bitcast %86
-    %88:u32 = add 4u, %start_byte_offset_2
-    %89:u32 = div %88, 16u
-    %90:ptr<uniform, vec4<u32>, read> = access %a, %89
-    %91:u32 = mod %88, 16u
-    %92:u32 = div %91, 4u
-    %93:vec4<u32> = load %90
-    %94:u32 = swizzle %93, z
-    %95:u32 = swizzle %93, x
-    %96:bool = eq %92, 2u
-    %97:u32 = hlsl.ternary %95, %94, %96
-    %98:vec2<f16> = bitcast %97
-    %99:mat2x2<f16> = construct %87, %98
-    ret %99
   }
+  Inner v_12[4] = a;
+  return v_12;
 }
-%21 = func(%start_byte_offset_3:u32):Outer {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %101:array<Inner, 4> = call %24, %start_byte_offset_3
-    %102:Outer = construct %101
-    ret %102
-  }
+
+Outer v_13(uint start_byte_offset) {
+  Inner v_14[4] = v_8(start_byte_offset);
+  Outer v_15 = {v_14};
+  return v_15;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat2x2<f16>(vec2<f16>(0.0h))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %106:bool = gte %idx_1, 4u
-        if %106 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %107:u32 = mul %idx_1, 256u
-        %108:u32 = add %start_byte_offset_4, %107
-        %109:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %110:Outer = call %21, %108
-        store %109, %110
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_16(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_17 = 0u;
+    v_17 = 0u;
+    while(true) {
+      uint v_18 = v_17;
+      if ((v_18 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %111:u32 = add %idx_1, 1u
-        next_iteration %111  # -> $B14
+      Outer v_19 = v_13((start_byte_offset + (v_18 * 256u)));
+      a[v_18] = v_19;
+      {
+        v_17 = (v_18 + 1u);
       }
+      continue;
     }
-    %112:array<Outer, 4> = load %a_2
-    ret %112
   }
+  Outer v_20[4] = a;
+  return v_20;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_21 = (256u * uint(i()));
+  uint v_22 = (64u * uint(i()));
+  uint v_23 = (4u * uint(i()));
+  Outer l_a[4] = v_16(0u);
+  Outer l_a_i = v_13(v_21);
+  Inner l_a_i_a[4] = v_8(v_21);
+  Inner l_a_i_a_i = v_6((v_21 + v_22));
+  matrix<float16_t, 2, 2> l_a_i_a_i_m = v_2((v_21 + v_22));
+  uint4 v_24 = a[(((v_21 + v_22) + v_23) / 16u)];
+  vector<float16_t, 2> l_a_i_a_i_m_i = tint_bitcast_to_f16((((((((v_21 + v_22) + v_23) % 16u) / 4u) == 2u)) ? (v_24.z) : (v_24.x)));
+  uint v_25 = (((v_21 + v_22) + v_23) + (uint(i()) * 2u));
+  uint v_26 = a[(v_25 / 16u)][((v_25 % 16u) / 4u)];
+  float16_t l_a_i_a_i_m_i_i = float16_t(f16tof32((v_26 >> ((((v_25 % 4u) == 0u)) ? (0u) : (16u)))));
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat2x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index d579f46e3d5..3a71197aaea 100644
--- a/test/tint/buffer/uniform/std140/struct/mat2x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat2x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,243 +1,98 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat2x2<f32>,
-}
+  float2x2 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat2x2<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec2<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :60:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %48:u32 = mul %47, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(8) {
-  m:mat2x2<f32> @offset(0)
+float2x2 v(uint start_byte_offset) {
+  uint4 v_1 = a[(start_byte_offset / 16u)];
+  float2 v_2 = asfloat((((((start_byte_offset % 16u) / 4u) == 2u)) ? (v_1.zw) : (v_1.xy)));
+  uint4 v_3 = a[((8u + start_byte_offset) / 16u)];
+  return float2x2(v_2, asfloat(((((((8u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_3.zw) : (v_3.xy))));
 }
 
-Outer = struct @align(8) {
-  a:array<Inner, 4> @offset(0)
+Inner v_4(uint start_byte_offset) {
+  Inner v_5 = {v(start_byte_offset)};
+  return v_5;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 8u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat2x2<f32> = call %32, %30
-    %l_a_i_a_i_m:mat2x2<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:u32 = mod %35, 16u
-    %39:u32 = div %38, 4u
-    %40:vec4<u32> = load %37
-    %41:vec2<u32> = swizzle %40, zw
-    %42:vec2<u32> = swizzle %40, xy
-    %43:bool = eq %39, 2u
-    %44:vec2<u32> = hlsl.ternary %42, %41, %43
-    %45:vec2<f32> = bitcast %44
-    %l_a_i_a_i_m_i:vec2<f32> = let %45
-    %47:i32 = call %i
-    %48:u32 = mul %47, 4u
-    %49:u32 = add %10, %13
-    %50:u32 = add %49, %16
-    %51:u32 = add %50, %48
-    %52:u32 = div %51, 16u
-    %53:ptr<uniform, vec4<u32>, read> = access %a, %52
-    %54:u32 = mod %51, 16u
-    %55:u32 = div %54, 4u
-    %56:u32 = load_vector_element %53, %55
-    %57:f32 = bitcast %56
-    %l_a_i_a_i_m_i_i:f32 = let %57
-    ret
-  }
-}
-%21 = func(%start_byte_offset:u32):Outer {
-  $B4: {
-    %60:array<Inner, 4> = call %24, %start_byte_offset
-    %61:Outer = construct %60
-    ret %61
-  }
-}
-%24 = func(%start_byte_offset_1:u32):array<Inner, 4> {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat2x2<f32>(vec2<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B6, b: $B7, c: $B8] {  # loop_1
-      $B6: {  # initializer
-        next_iteration 0u  # -> $B7
-      }
-      $B7 (%idx:u32): {  # body
-        %65:bool = gte %idx, 4u
-        if %65 [t: $B9] {  # if_1
-          $B9: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %66:u32 = mul %idx, 64u
-        %67:u32 = add %start_byte_offset_1, %66
-        %68:ptr<function, Inner, read_write> = access %a_1, %idx
-        %69:Inner = call %28, %67
-        store %68, %69
-        continue  # -> $B8
+typedef Inner ary_ret[4];
+ary_ret v_6(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_7 = 0u;
+    v_7 = 0u;
+    while(true) {
+      uint v_8 = v_7;
+      if ((v_8 >= 4u)) {
+        break;
       }
-      $B8: {  # continuing
-        %70:u32 = add %idx, 1u
-        next_iteration %70  # -> $B7
+      Inner v_9 = v_4((start_byte_offset + (v_8 * 64u)));
+      a[v_8] = v_9;
+      {
+        v_7 = (v_8 + 1u);
       }
+      continue;
     }
-    %71:array<Inner, 4> = load %a_1
-    ret %71
-  }
-}
-%28 = func(%start_byte_offset_2:u32):Inner {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %73:mat2x2<f32> = call %32, %start_byte_offset_2
-    %74:Inner = construct %73
-    ret %74
   }
+  Inner v_10[4] = a;
+  return v_10;
 }
-%32 = func(%start_byte_offset_3:u32):mat2x2<f32> {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %76:u32 = div %start_byte_offset_3, 16u
-    %77:ptr<uniform, vec4<u32>, read> = access %a, %76
-    %78:u32 = mod %start_byte_offset_3, 16u
-    %79:u32 = div %78, 4u
-    %80:vec4<u32> = load %77
-    %81:vec2<u32> = swizzle %80, zw
-    %82:vec2<u32> = swizzle %80, xy
-    %83:bool = eq %79, 2u
-    %84:vec2<u32> = hlsl.ternary %82, %81, %83
-    %85:vec2<f32> = bitcast %84
-    %86:u32 = add 8u, %start_byte_offset_3
-    %87:u32 = div %86, 16u
-    %88:ptr<uniform, vec4<u32>, read> = access %a, %87
-    %89:u32 = mod %86, 16u
-    %90:u32 = div %89, 4u
-    %91:vec4<u32> = load %88
-    %92:vec2<u32> = swizzle %91, zw
-    %93:vec2<u32> = swizzle %91, xy
-    %94:bool = eq %90, 2u
-    %95:vec2<u32> = hlsl.ternary %93, %92, %94
-    %96:vec2<f32> = bitcast %95
-    %97:mat2x2<f32> = construct %85, %96
-    ret %97
-  }
+
+Outer v_11(uint start_byte_offset) {
+  Inner v_12[4] = v_6(start_byte_offset);
+  Outer v_13 = {v_12};
+  return v_13;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat2x2<f32>(vec2<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %101:bool = gte %idx_1, 4u
-        if %101 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %102:u32 = mul %idx_1, 256u
-        %103:u32 = add %start_byte_offset_4, %102
-        %104:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %105:Outer = call %21, %103
-        store %104, %105
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_14(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_15 = 0u;
+    v_15 = 0u;
+    while(true) {
+      uint v_16 = v_15;
+      if ((v_16 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %106:u32 = add %idx_1, 1u
-        next_iteration %106  # -> $B14
+      Outer v_17 = v_11((start_byte_offset + (v_16 * 256u)));
+      a[v_16] = v_17;
+      {
+        v_15 = (v_16 + 1u);
       }
+      continue;
     }
-    %107:array<Outer, 4> = load %a_2
-    ret %107
   }
+  Outer v_18[4] = a;
+  return v_18;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_19 = (256u * uint(i()));
+  uint v_20 = (64u * uint(i()));
+  uint v_21 = (8u * uint(i()));
+  Outer l_a[4] = v_14(0u);
+  Outer l_a_i = v_11(v_19);
+  Inner l_a_i_a[4] = v_6(v_19);
+  Inner l_a_i_a_i = v_4((v_19 + v_20));
+  float2x2 l_a_i_a_i_m = v((v_19 + v_20));
+  uint4 v_22 = a[(((v_19 + v_20) + v_21) / 16u)];
+  float2 l_a_i_a_i_m_i = asfloat((((((((v_19 + v_20) + v_21) % 16u) / 4u) == 2u)) ? (v_22.zw) : (v_22.xy)));
+  uint v_23 = (((v_19 + v_20) + v_21) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_23 / 16u)][((v_23 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat2x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat2x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
index 278dc9fce3d..3a71197aaea 100644
--- a/test/tint/buffer/uniform/std140/struct/mat2x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat2x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
@@ -1,243 +1,98 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat2x2<f32>,
-}
+  float2x2 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat2x2<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec2<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :60:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %48:u32 = mul %47, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(8) {
-  m:mat2x2<f32> @offset(0)
+float2x2 v(uint start_byte_offset) {
+  uint4 v_1 = a[(start_byte_offset / 16u)];
+  float2 v_2 = asfloat((((((start_byte_offset % 16u) / 4u) == 2u)) ? (v_1.zw) : (v_1.xy)));
+  uint4 v_3 = a[((8u + start_byte_offset) / 16u)];
+  return float2x2(v_2, asfloat(((((((8u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_3.zw) : (v_3.xy))));
 }
 
-Outer = struct @align(8) {
-  a:array<Inner, 4> @offset(0)
+Inner v_4(uint start_byte_offset) {
+  Inner v_5 = {v(start_byte_offset)};
+  return v_5;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 8u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat2x2<f32> = call %32, %30
-    %l_a_i_a_i_m:mat2x2<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:u32 = mod %35, 16u
-    %39:u32 = div %38, 4u
-    %40:vec4<u32> = load %37
-    %41:vec2<u32> = swizzle %40, zw
-    %42:vec2<u32> = swizzle %40, xy
-    %43:bool = eq %39, 2u
-    %44:vec2<u32> = hlsl.ternary %42, %41, %43
-    %45:vec2<f32> = bitcast %44
-    %l_a_i_a_i_m_i:vec2<f32> = let %45
-    %47:i32 = call %i
-    %48:u32 = mul %47, 4u
-    %49:u32 = add %10, %13
-    %50:u32 = add %49, %16
-    %51:u32 = add %50, %48
-    %52:u32 = div %51, 16u
-    %53:ptr<uniform, vec4<u32>, read> = access %a, %52
-    %54:u32 = mod %51, 16u
-    %55:u32 = div %54, 4u
-    %56:u32 = load_vector_element %53, %55
-    %57:f32 = bitcast %56
-    %l_a_i_a_i_m_i_i:f32 = let %57
-    ret
-  }
-}
-%24 = func(%start_byte_offset:u32):array<Inner, 4> {
-  $B4: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat2x2<f32>(vec2<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B5, b: $B6, c: $B7] {  # loop_1
-      $B5: {  # initializer
-        next_iteration 0u  # -> $B6
-      }
-      $B6 (%idx:u32): {  # body
-        %62:bool = gte %idx, 4u
-        if %62 [t: $B8] {  # if_1
-          $B8: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %63:u32 = mul %idx, 64u
-        %64:u32 = add %start_byte_offset, %63
-        %65:ptr<function, Inner, read_write> = access %a_1, %idx
-        %66:Inner = call %28, %64
-        store %65, %66
-        continue  # -> $B7
+typedef Inner ary_ret[4];
+ary_ret v_6(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_7 = 0u;
+    v_7 = 0u;
+    while(true) {
+      uint v_8 = v_7;
+      if ((v_8 >= 4u)) {
+        break;
       }
-      $B7: {  # continuing
-        %67:u32 = add %idx, 1u
-        next_iteration %67  # -> $B6
+      Inner v_9 = v_4((start_byte_offset + (v_8 * 64u)));
+      a[v_8] = v_9;
+      {
+        v_7 = (v_8 + 1u);
       }
+      continue;
     }
-    %68:array<Inner, 4> = load %a_1
-    ret %68
-  }
-}
-%28 = func(%start_byte_offset_1:u32):Inner {  # %start_byte_offset_1: 'start_byte_offset'
-  $B9: {
-    %70:mat2x2<f32> = call %32, %start_byte_offset_1
-    %71:Inner = construct %70
-    ret %71
-  }
-}
-%32 = func(%start_byte_offset_2:u32):mat2x2<f32> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %73:u32 = div %start_byte_offset_2, 16u
-    %74:ptr<uniform, vec4<u32>, read> = access %a, %73
-    %75:u32 = mod %start_byte_offset_2, 16u
-    %76:u32 = div %75, 4u
-    %77:vec4<u32> = load %74
-    %78:vec2<u32> = swizzle %77, zw
-    %79:vec2<u32> = swizzle %77, xy
-    %80:bool = eq %76, 2u
-    %81:vec2<u32> = hlsl.ternary %79, %78, %80
-    %82:vec2<f32> = bitcast %81
-    %83:u32 = add 8u, %start_byte_offset_2
-    %84:u32 = div %83, 16u
-    %85:ptr<uniform, vec4<u32>, read> = access %a, %84
-    %86:u32 = mod %83, 16u
-    %87:u32 = div %86, 4u
-    %88:vec4<u32> = load %85
-    %89:vec2<u32> = swizzle %88, zw
-    %90:vec2<u32> = swizzle %88, xy
-    %91:bool = eq %87, 2u
-    %92:vec2<u32> = hlsl.ternary %90, %89, %91
-    %93:vec2<f32> = bitcast %92
-    %94:mat2x2<f32> = construct %82, %93
-    ret %94
   }
+  Inner v_10[4] = a;
+  return v_10;
 }
-%21 = func(%start_byte_offset_3:u32):Outer {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %96:array<Inner, 4> = call %24, %start_byte_offset_3
-    %97:Outer = construct %96
-    ret %97
-  }
+
+Outer v_11(uint start_byte_offset) {
+  Inner v_12[4] = v_6(start_byte_offset);
+  Outer v_13 = {v_12};
+  return v_13;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat2x2<f32>(vec2<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %101:bool = gte %idx_1, 4u
-        if %101 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %102:u32 = mul %idx_1, 256u
-        %103:u32 = add %start_byte_offset_4, %102
-        %104:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %105:Outer = call %21, %103
-        store %104, %105
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_14(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_15 = 0u;
+    v_15 = 0u;
+    while(true) {
+      uint v_16 = v_15;
+      if ((v_16 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %106:u32 = add %idx_1, 1u
-        next_iteration %106  # -> $B14
+      Outer v_17 = v_11((start_byte_offset + (v_16 * 256u)));
+      a[v_16] = v_17;
+      {
+        v_15 = (v_16 + 1u);
       }
+      continue;
     }
-    %107:array<Outer, 4> = load %a_2
-    ret %107
   }
+  Outer v_18[4] = a;
+  return v_18;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_19 = (256u * uint(i()));
+  uint v_20 = (64u * uint(i()));
+  uint v_21 = (8u * uint(i()));
+  Outer l_a[4] = v_14(0u);
+  Outer l_a_i = v_11(v_19);
+  Inner l_a_i_a[4] = v_6(v_19);
+  Inner l_a_i_a_i = v_4((v_19 + v_20));
+  float2x2 l_a_i_a_i_m = v((v_19 + v_20));
+  uint4 v_22 = a[(((v_19 + v_20) + v_21) / 16u)];
+  float2 l_a_i_a_i_m_i = asfloat((((((((v_19 + v_20) + v_21) % 16u) / 4u) == 2u)) ? (v_22.zw) : (v_22.xy)));
+  uint v_23 = (((v_19 + v_20) + v_21) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_23 / 16u)][((v_23 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat2x3_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat2x3_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index 99306bce8c2..e6c32e37c11 100644
--- a/test/tint/buffer/uniform/std140/struct/mat2x3_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat2x3_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,235 +1,108 @@
-SKIP: FAILED
-
-
-enable f16;
-
 struct Inner {
-  @size(64)
-  m : mat2x3<f16>,
-}
+  matrix<float16_t, 2, 3> m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
+  Inner a[4];
+};
 
-var<private> counter = 0;
 
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat2x3<f16> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec3<f16> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f16 = (*(p_a_i_a_i_m_i))[i()];
+vector<float16_t, 4> tint_bitcast_to_f16(uint4 src) {
+  uint4 v = src;
+  uint4 mask = (65535u).xxxx;
+  uint4 shift = (16u).xxxx;
+  float4 t_low = f16tof32((v & mask));
+  float4 t_high = f16tof32(((v >> shift) & mask));
+  float16_t v_1 = float16_t(t_low.x);
+  float16_t v_2 = float16_t(t_high.x);
+  float16_t v_3 = float16_t(t_low.y);
+  return vector<float16_t, 4>(v_1, v_2, v_3, float16_t(t_high.y));
 }
 
-Failed to generate: :55:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %43:u32 = mul %42, 2u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(8) {
-  m:mat2x3<f16> @offset(0)
+matrix<float16_t, 2, 3> v_4(uint start_byte_offset) {
+  vector<float16_t, 3> v_5 = tint_bitcast_to_f16(a[(start_byte_offset / 16u)]).xyz;
+  return matrix<float16_t, 2, 3>(v_5, tint_bitcast_to_f16(a[((8u + start_byte_offset) / 16u)]).xyz);
 }
 
-Outer = struct @align(8) {
-  a:array<Inner, 4> @offset(0)
+Inner v_6(uint start_byte_offset) {
+  Inner v_7 = {v_4(start_byte_offset)};
+  return v_7;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 8u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat2x3<f16> = call %32, %30
-    %l_a_i_a_i_m:mat2x3<f16> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec4<f16> = bitcast %38
-    %40:vec3<f16> = swizzle %39, xyz
-    %l_a_i_a_i_m_i:vec3<f16> = let %40
-    %42:i32 = call %i
-    %43:u32 = mul %42, 2u
-    %44:u32 = add %10, %13
-    %45:u32 = add %44, %16
-    %46:u32 = add %45, %43
-    %47:u32 = div %46, 16u
-    %48:ptr<uniform, vec4<u32>, read> = access %a, %47
-    %49:u32 = mod %46, 16u
-    %50:u32 = div %49, 4u
-    %51:u32 = load_vector_element %48, %50
-    %52:u32 = mod %46, 4u
-    %53:bool = eq %52, 0u
-    %54:u32 = hlsl.ternary 16u, 0u, %53
-    %55:u32 = shr %51, %54
-    %56:f32 = hlsl.f16tof32 %55
-    %57:f16 = convert %56
-    %l_a_i_a_i_m_i_i:f16 = let %57
-    ret
-  }
-}
-%18 = func(%start_byte_offset:u32):array<Outer, 4> {
-  $B4: {
-    %a_1:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat2x3<f16>(vec3<f16>(0.0h))))))  # %a_1: 'a'
-    loop [i: $B5, b: $B6, c: $B7] {  # loop_1
-      $B5: {  # initializer
-        next_iteration 0u  # -> $B6
+typedef Inner ary_ret[4];
+ary_ret v_8(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_9 = 0u;
+    v_9 = 0u;
+    while(true) {
+      uint v_10 = v_9;
+      if ((v_10 >= 4u)) {
+        break;
       }
-      $B6 (%idx:u32): {  # body
-        %62:bool = gte %idx, 4u
-        if %62 [t: $B8] {  # if_1
-          $B8: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %63:u32 = mul %idx, 256u
-        %64:u32 = add %start_byte_offset, %63
-        %65:ptr<function, Outer, read_write> = access %a_1, %idx
-        %66:Outer = call %21, %64
-        store %65, %66
-        continue  # -> $B7
-      }
-      $B7: {  # continuing
-        %67:u32 = add %idx, 1u
-        next_iteration %67  # -> $B6
+      Inner v_11 = v_6((start_byte_offset + (v_10 * 64u)));
+      a[v_10] = v_11;
+      {
+        v_9 = (v_10 + 1u);
       }
+      continue;
     }
-    %68:array<Outer, 4> = load %a_1
-    ret %68
   }
+  Inner v_12[4] = a;
+  return v_12;
 }
-%21 = func(%start_byte_offset_1:u32):Outer {  # %start_byte_offset_1: 'start_byte_offset'
-  $B9: {
-    %70:array<Inner, 4> = call %24, %start_byte_offset_1
-    %71:Outer = construct %70
-    ret %71
-  }
+
+Outer v_13(uint start_byte_offset) {
+  Inner v_14[4] = v_8(start_byte_offset);
+  Outer v_15 = {v_14};
+  return v_15;
 }
-%24 = func(%start_byte_offset_2:u32):array<Inner, 4> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %a_2:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat2x3<f16>(vec3<f16>(0.0h))))  # %a_2: 'a'
-    loop [i: $B11, b: $B12, c: $B13] {  # loop_2
-      $B11: {  # initializer
-        next_iteration 0u  # -> $B12
-      }
-      $B12 (%idx_1:u32): {  # body
-        %75:bool = gte %idx_1, 4u
-        if %75 [t: $B14] {  # if_2
-          $B14: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %76:u32 = mul %idx_1, 64u
-        %77:u32 = add %start_byte_offset_2, %76
-        %78:ptr<function, Inner, read_write> = access %a_2, %idx_1
-        %79:Inner = call %28, %77
-        store %78, %79
-        continue  # -> $B13
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_16(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_17 = 0u;
+    v_17 = 0u;
+    while(true) {
+      uint v_18 = v_17;
+      if ((v_18 >= 4u)) {
+        break;
       }
-      $B13: {  # continuing
-        %80:u32 = add %idx_1, 1u
-        next_iteration %80  # -> $B12
+      Outer v_19 = v_13((start_byte_offset + (v_18 * 256u)));
+      a[v_18] = v_19;
+      {
+        v_17 = (v_18 + 1u);
       }
+      continue;
     }
-    %81:array<Inner, 4> = load %a_2
-    ret %81
-  }
-}
-%28 = func(%start_byte_offset_3:u32):Inner {  # %start_byte_offset_3: 'start_byte_offset'
-  $B15: {
-    %83:mat2x3<f16> = call %32, %start_byte_offset_3
-    %84:Inner = construct %83
-    ret %84
   }
+  Outer v_20[4] = a;
+  return v_20;
 }
-%32 = func(%start_byte_offset_4:u32):mat2x3<f16> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B16: {
-    %86:u32 = div %start_byte_offset_4, 16u
-    %87:ptr<uniform, vec4<u32>, read> = access %a, %86
-    %88:vec4<u32> = load %87
-    %89:vec4<f16> = bitcast %88
-    %90:vec3<f16> = swizzle %89, xyz
-    %91:u32 = add 8u, %start_byte_offset_4
-    %92:u32 = div %91, 16u
-    %93:ptr<uniform, vec4<u32>, read> = access %a, %92
-    %94:vec4<u32> = load %93
-    %95:vec4<f16> = bitcast %94
-    %96:vec3<f16> = swizzle %95, xyz
-    %97:mat2x3<f16> = construct %90, %96
-    ret %97
-  }
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_21 = (256u * uint(i()));
+  uint v_22 = (64u * uint(i()));
+  uint v_23 = (8u * uint(i()));
+  Outer l_a[4] = v_16(0u);
+  Outer l_a_i = v_13(v_21);
+  Inner l_a_i_a[4] = v_8(v_21);
+  Inner l_a_i_a_i = v_6((v_21 + v_22));
+  matrix<float16_t, 2, 3> l_a_i_a_i_m = v_4((v_21 + v_22));
+  vector<float16_t, 3> l_a_i_a_i_m_i = tint_bitcast_to_f16(a[(((v_21 + v_22) + v_23) / 16u)]).xyz;
+  uint v_24 = (((v_21 + v_22) + v_23) + (uint(i()) * 2u));
+  uint v_25 = a[(v_24 / 16u)][((v_24 % 16u) / 4u)];
+  float16_t l_a_i_a_i_m_i_i = float16_t(f16tof32((v_25 >> ((((v_24 % 4u) == 0u)) ? (0u) : (16u)))));
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat2x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat2x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index 9b875a547df..b54e9b61ffc 100644
--- a/test/tint/buffer/uniform/std140/struct/mat2x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat2x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,228 +1,95 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat2x3<f32>,
-}
+  float2x3 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat2x3<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec3<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :55:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %43:u32 = mul %42, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(16) {
-  m:mat2x3<f32> @offset(0)
+float2x3 v(uint start_byte_offset) {
+  float3 v_1 = asfloat(a[(start_byte_offset / 16u)].xyz);
+  return float2x3(v_1, asfloat(a[((16u + start_byte_offset) / 16u)].xyz));
 }
 
-Outer = struct @align(16) {
-  a:array<Inner, 4> @offset(0)
+Inner v_2(uint start_byte_offset) {
+  Inner v_3 = {v(start_byte_offset)};
+  return v_3;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 16u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat2x3<f32> = call %32, %30
-    %l_a_i_a_i_m:mat2x3<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec3<u32> = swizzle %38, xyz
-    %40:vec3<f32> = bitcast %39
-    %l_a_i_a_i_m_i:vec3<f32> = let %40
-    %42:i32 = call %i
-    %43:u32 = mul %42, 4u
-    %44:u32 = add %10, %13
-    %45:u32 = add %44, %16
-    %46:u32 = add %45, %43
-    %47:u32 = div %46, 16u
-    %48:ptr<uniform, vec4<u32>, read> = access %a, %47
-    %49:u32 = mod %46, 16u
-    %50:u32 = div %49, 4u
-    %51:u32 = load_vector_element %48, %50
-    %52:f32 = bitcast %51
-    %l_a_i_a_i_m_i_i:f32 = let %52
-    ret
-  }
-}
-%21 = func(%start_byte_offset:u32):Outer {
-  $B4: {
-    %55:array<Inner, 4> = call %24, %start_byte_offset
-    %56:Outer = construct %55
-    ret %56
-  }
-}
-%24 = func(%start_byte_offset_1:u32):array<Inner, 4> {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat2x3<f32>(vec3<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B6, b: $B7, c: $B8] {  # loop_1
-      $B6: {  # initializer
-        next_iteration 0u  # -> $B7
-      }
-      $B7 (%idx:u32): {  # body
-        %60:bool = gte %idx, 4u
-        if %60 [t: $B9] {  # if_1
-          $B9: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %61:u32 = mul %idx, 64u
-        %62:u32 = add %start_byte_offset_1, %61
-        %63:ptr<function, Inner, read_write> = access %a_1, %idx
-        %64:Inner = call %28, %62
-        store %63, %64
-        continue  # -> $B8
+typedef Inner ary_ret[4];
+ary_ret v_4(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_5 = 0u;
+    v_5 = 0u;
+    while(true) {
+      uint v_6 = v_5;
+      if ((v_6 >= 4u)) {
+        break;
       }
-      $B8: {  # continuing
-        %65:u32 = add %idx, 1u
-        next_iteration %65  # -> $B7
+      Inner v_7 = v_2((start_byte_offset + (v_6 * 64u)));
+      a[v_6] = v_7;
+      {
+        v_5 = (v_6 + 1u);
       }
+      continue;
     }
-    %66:array<Inner, 4> = load %a_1
-    ret %66
-  }
-}
-%28 = func(%start_byte_offset_2:u32):Inner {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %68:mat2x3<f32> = call %32, %start_byte_offset_2
-    %69:Inner = construct %68
-    ret %69
   }
+  Inner v_8[4] = a;
+  return v_8;
 }
-%32 = func(%start_byte_offset_3:u32):mat2x3<f32> {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %71:u32 = div %start_byte_offset_3, 16u
-    %72:ptr<uniform, vec4<u32>, read> = access %a, %71
-    %73:vec4<u32> = load %72
-    %74:vec3<u32> = swizzle %73, xyz
-    %75:vec3<f32> = bitcast %74
-    %76:u32 = add 16u, %start_byte_offset_3
-    %77:u32 = div %76, 16u
-    %78:ptr<uniform, vec4<u32>, read> = access %a, %77
-    %79:vec4<u32> = load %78
-    %80:vec3<u32> = swizzle %79, xyz
-    %81:vec3<f32> = bitcast %80
-    %82:mat2x3<f32> = construct %75, %81
-    ret %82
-  }
+
+Outer v_9(uint start_byte_offset) {
+  Inner v_10[4] = v_4(start_byte_offset);
+  Outer v_11 = {v_10};
+  return v_11;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat2x3<f32>(vec3<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %86:bool = gte %idx_1, 4u
-        if %86 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %87:u32 = mul %idx_1, 256u
-        %88:u32 = add %start_byte_offset_4, %87
-        %89:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %90:Outer = call %21, %88
-        store %89, %90
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_12(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_13 = 0u;
+    v_13 = 0u;
+    while(true) {
+      uint v_14 = v_13;
+      if ((v_14 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %91:u32 = add %idx_1, 1u
-        next_iteration %91  # -> $B14
+      Outer v_15 = v_9((start_byte_offset + (v_14 * 256u)));
+      a[v_14] = v_15;
+      {
+        v_13 = (v_14 + 1u);
       }
+      continue;
     }
-    %92:array<Outer, 4> = load %a_2
-    ret %92
   }
+  Outer v_16[4] = a;
+  return v_16;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_17 = (256u * uint(i()));
+  uint v_18 = (64u * uint(i()));
+  uint v_19 = (16u * uint(i()));
+  Outer l_a[4] = v_12(0u);
+  Outer l_a_i = v_9(v_17);
+  Inner l_a_i_a[4] = v_4(v_17);
+  Inner l_a_i_a_i = v_2((v_17 + v_18));
+  float2x3 l_a_i_a_i_m = v((v_17 + v_18));
+  float3 l_a_i_a_i_m_i = asfloat(a[(((v_17 + v_18) + v_19) / 16u)].xyz);
+  uint v_20 = (((v_17 + v_18) + v_19) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_20 / 16u)][((v_20 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat2x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat2x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
index 8e556b1c1b3..b54e9b61ffc 100644
--- a/test/tint/buffer/uniform/std140/struct/mat2x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat2x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
@@ -1,228 +1,95 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat2x3<f32>,
-}
+  float2x3 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat2x3<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec3<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :55:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %43:u32 = mul %42, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(16) {
-  m:mat2x3<f32> @offset(0)
+float2x3 v(uint start_byte_offset) {
+  float3 v_1 = asfloat(a[(start_byte_offset / 16u)].xyz);
+  return float2x3(v_1, asfloat(a[((16u + start_byte_offset) / 16u)].xyz));
 }
 
-Outer = struct @align(16) {
-  a:array<Inner, 4> @offset(0)
+Inner v_2(uint start_byte_offset) {
+  Inner v_3 = {v(start_byte_offset)};
+  return v_3;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 16u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat2x3<f32> = call %32, %30
-    %l_a_i_a_i_m:mat2x3<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec3<u32> = swizzle %38, xyz
-    %40:vec3<f32> = bitcast %39
-    %l_a_i_a_i_m_i:vec3<f32> = let %40
-    %42:i32 = call %i
-    %43:u32 = mul %42, 4u
-    %44:u32 = add %10, %13
-    %45:u32 = add %44, %16
-    %46:u32 = add %45, %43
-    %47:u32 = div %46, 16u
-    %48:ptr<uniform, vec4<u32>, read> = access %a, %47
-    %49:u32 = mod %46, 16u
-    %50:u32 = div %49, 4u
-    %51:u32 = load_vector_element %48, %50
-    %52:f32 = bitcast %51
-    %l_a_i_a_i_m_i_i:f32 = let %52
-    ret
-  }
-}
-%32 = func(%start_byte_offset:u32):mat2x3<f32> {
-  $B4: {
-    %55:u32 = div %start_byte_offset, 16u
-    %56:ptr<uniform, vec4<u32>, read> = access %a, %55
-    %57:vec4<u32> = load %56
-    %58:vec3<u32> = swizzle %57, xyz
-    %59:vec3<f32> = bitcast %58
-    %60:u32 = add 16u, %start_byte_offset
-    %61:u32 = div %60, 16u
-    %62:ptr<uniform, vec4<u32>, read> = access %a, %61
-    %63:vec4<u32> = load %62
-    %64:vec3<u32> = swizzle %63, xyz
-    %65:vec3<f32> = bitcast %64
-    %66:mat2x3<f32> = construct %59, %65
-    ret %66
-  }
-}
-%28 = func(%start_byte_offset_1:u32):Inner {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %68:mat2x3<f32> = call %32, %start_byte_offset_1
-    %69:Inner = construct %68
-    ret %69
-  }
-}
-%24 = func(%start_byte_offset_2:u32):array<Inner, 4> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B6: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat2x3<f32>(vec3<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B7, b: $B8, c: $B9] {  # loop_1
-      $B7: {  # initializer
-        next_iteration 0u  # -> $B8
+typedef Inner ary_ret[4];
+ary_ret v_4(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_5 = 0u;
+    v_5 = 0u;
+    while(true) {
+      uint v_6 = v_5;
+      if ((v_6 >= 4u)) {
+        break;
       }
-      $B8 (%idx:u32): {  # body
-        %73:bool = gte %idx, 4u
-        if %73 [t: $B10] {  # if_1
-          $B10: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %74:u32 = mul %idx, 64u
-        %75:u32 = add %start_byte_offset_2, %74
-        %76:ptr<function, Inner, read_write> = access %a_1, %idx
-        %77:Inner = call %28, %75
-        store %76, %77
-        continue  # -> $B9
-      }
-      $B9: {  # continuing
-        %78:u32 = add %idx, 1u
-        next_iteration %78  # -> $B8
+      Inner v_7 = v_2((start_byte_offset + (v_6 * 64u)));
+      a[v_6] = v_7;
+      {
+        v_5 = (v_6 + 1u);
       }
+      continue;
     }
-    %79:array<Inner, 4> = load %a_1
-    ret %79
   }
+  Inner v_8[4] = a;
+  return v_8;
 }
-%21 = func(%start_byte_offset_3:u32):Outer {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %81:array<Inner, 4> = call %24, %start_byte_offset_3
-    %82:Outer = construct %81
-    ret %82
-  }
+
+Outer v_9(uint start_byte_offset) {
+  Inner v_10[4] = v_4(start_byte_offset);
+  Outer v_11 = {v_10};
+  return v_11;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat2x3<f32>(vec3<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %86:bool = gte %idx_1, 4u
-        if %86 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %87:u32 = mul %idx_1, 256u
-        %88:u32 = add %start_byte_offset_4, %87
-        %89:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %90:Outer = call %21, %88
-        store %89, %90
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_12(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_13 = 0u;
+    v_13 = 0u;
+    while(true) {
+      uint v_14 = v_13;
+      if ((v_14 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %91:u32 = add %idx_1, 1u
-        next_iteration %91  # -> $B14
+      Outer v_15 = v_9((start_byte_offset + (v_14 * 256u)));
+      a[v_14] = v_15;
+      {
+        v_13 = (v_14 + 1u);
       }
+      continue;
     }
-    %92:array<Outer, 4> = load %a_2
-    ret %92
   }
+  Outer v_16[4] = a;
+  return v_16;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_17 = (256u * uint(i()));
+  uint v_18 = (64u * uint(i()));
+  uint v_19 = (16u * uint(i()));
+  Outer l_a[4] = v_12(0u);
+  Outer l_a_i = v_9(v_17);
+  Inner l_a_i_a[4] = v_4(v_17);
+  Inner l_a_i_a_i = v_2((v_17 + v_18));
+  float2x3 l_a_i_a_i_m = v((v_17 + v_18));
+  float3 l_a_i_a_i_m_i = asfloat(a[(((v_17 + v_18) + v_19) / 16u)].xyz);
+  uint v_20 = (((v_17 + v_18) + v_19) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_20 / 16u)][((v_20 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat2x4_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat2x4_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index 421f139d9e3..aab8cc6884a 100644
--- a/test/tint/buffer/uniform/std140/struct/mat2x4_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat2x4_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,232 +1,108 @@
-SKIP: FAILED
-
-
-enable f16;
-
 struct Inner {
-  @size(64)
-  m : mat2x4<f16>,
-}
+  matrix<float16_t, 2, 4> m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
+  Inner a[4];
+};
 
-var<private> counter = 0;
 
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat2x4<f16> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec4<f16> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f16 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :54:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %42:u32 = mul %41, 2u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(8) {
-  m:mat2x4<f16> @offset(0)
+vector<float16_t, 4> tint_bitcast_to_f16(uint4 src) {
+  uint4 v = src;
+  uint4 mask = (65535u).xxxx;
+  uint4 shift = (16u).xxxx;
+  float4 t_low = f16tof32((v & mask));
+  float4 t_high = f16tof32(((v >> shift) & mask));
+  float16_t v_1 = float16_t(t_low.x);
+  float16_t v_2 = float16_t(t_high.x);
+  float16_t v_3 = float16_t(t_low.y);
+  return vector<float16_t, 4>(v_1, v_2, v_3, float16_t(t_high.y));
 }
 
-Outer = struct @align(8) {
-  a:array<Inner, 4> @offset(0)
+matrix<float16_t, 2, 4> v_4(uint start_byte_offset) {
+  vector<float16_t, 4> v_5 = tint_bitcast_to_f16(a[(start_byte_offset / 16u)]);
+  return matrix<float16_t, 2, 4>(v_5, tint_bitcast_to_f16(a[((8u + start_byte_offset) / 16u)]));
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
+Inner v_6(uint start_byte_offset) {
+  Inner v_7 = {v_4(start_byte_offset)};
+  return v_7;
 }
 
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 8u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat2x4<f16> = call %32, %30
-    %l_a_i_a_i_m:mat2x4<f16> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec4<f16> = bitcast %38
-    %l_a_i_a_i_m_i:vec4<f16> = let %39
-    %41:i32 = call %i
-    %42:u32 = mul %41, 2u
-    %43:u32 = add %10, %13
-    %44:u32 = add %43, %16
-    %45:u32 = add %44, %42
-    %46:u32 = div %45, 16u
-    %47:ptr<uniform, vec4<u32>, read> = access %a, %46
-    %48:u32 = mod %45, 16u
-    %49:u32 = div %48, 4u
-    %50:u32 = load_vector_element %47, %49
-    %51:u32 = mod %45, 4u
-    %52:bool = eq %51, 0u
-    %53:u32 = hlsl.ternary 16u, 0u, %52
-    %54:u32 = shr %50, %53
-    %55:f32 = hlsl.f16tof32 %54
-    %56:f16 = convert %55
-    %l_a_i_a_i_m_i_i:f16 = let %56
-    ret
-  }
-}
-%21 = func(%start_byte_offset:u32):Outer {
-  $B4: {
-    %59:array<Inner, 4> = call %24, %start_byte_offset
-    %60:Outer = construct %59
-    ret %60
-  }
-}
-%24 = func(%start_byte_offset_1:u32):array<Inner, 4> {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat2x4<f16>(vec4<f16>(0.0h))))  # %a_1: 'a'
-    loop [i: $B6, b: $B7, c: $B8] {  # loop_1
-      $B6: {  # initializer
-        next_iteration 0u  # -> $B7
+typedef Inner ary_ret[4];
+ary_ret v_8(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_9 = 0u;
+    v_9 = 0u;
+    while(true) {
+      uint v_10 = v_9;
+      if ((v_10 >= 4u)) {
+        break;
       }
-      $B7 (%idx:u32): {  # body
-        %64:bool = gte %idx, 4u
-        if %64 [t: $B9] {  # if_1
-          $B9: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %65:u32 = mul %idx, 64u
-        %66:u32 = add %start_byte_offset_1, %65
-        %67:ptr<function, Inner, read_write> = access %a_1, %idx
-        %68:Inner = call %28, %66
-        store %67, %68
-        continue  # -> $B8
-      }
-      $B8: {  # continuing
-        %69:u32 = add %idx, 1u
-        next_iteration %69  # -> $B7
+      Inner v_11 = v_6((start_byte_offset + (v_10 * 64u)));
+      a[v_10] = v_11;
+      {
+        v_9 = (v_10 + 1u);
       }
+      continue;
     }
-    %70:array<Inner, 4> = load %a_1
-    ret %70
-  }
-}
-%28 = func(%start_byte_offset_2:u32):Inner {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %72:mat2x4<f16> = call %32, %start_byte_offset_2
-    %73:Inner = construct %72
-    ret %73
   }
+  Inner v_12[4] = a;
+  return v_12;
 }
-%32 = func(%start_byte_offset_3:u32):mat2x4<f16> {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %75:u32 = div %start_byte_offset_3, 16u
-    %76:ptr<uniform, vec4<u32>, read> = access %a, %75
-    %77:vec4<u32> = load %76
-    %78:vec4<f16> = bitcast %77
-    %79:u32 = add 8u, %start_byte_offset_3
-    %80:u32 = div %79, 16u
-    %81:ptr<uniform, vec4<u32>, read> = access %a, %80
-    %82:vec4<u32> = load %81
-    %83:vec4<f16> = bitcast %82
-    %84:mat2x4<f16> = construct %78, %83
-    ret %84
-  }
+
+Outer v_13(uint start_byte_offset) {
+  Inner v_14[4] = v_8(start_byte_offset);
+  Outer v_15 = {v_14};
+  return v_15;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat2x4<f16>(vec4<f16>(0.0h))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %88:bool = gte %idx_1, 4u
-        if %88 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %89:u32 = mul %idx_1, 256u
-        %90:u32 = add %start_byte_offset_4, %89
-        %91:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %92:Outer = call %21, %90
-        store %91, %92
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_16(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_17 = 0u;
+    v_17 = 0u;
+    while(true) {
+      uint v_18 = v_17;
+      if ((v_18 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %93:u32 = add %idx_1, 1u
-        next_iteration %93  # -> $B14
+      Outer v_19 = v_13((start_byte_offset + (v_18 * 256u)));
+      a[v_18] = v_19;
+      {
+        v_17 = (v_18 + 1u);
       }
+      continue;
     }
-    %94:array<Outer, 4> = load %a_2
-    ret %94
   }
+  Outer v_20[4] = a;
+  return v_20;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_21 = (256u * uint(i()));
+  uint v_22 = (64u * uint(i()));
+  uint v_23 = (8u * uint(i()));
+  Outer l_a[4] = v_16(0u);
+  Outer l_a_i = v_13(v_21);
+  Inner l_a_i_a[4] = v_8(v_21);
+  Inner l_a_i_a_i = v_6((v_21 + v_22));
+  matrix<float16_t, 2, 4> l_a_i_a_i_m = v_4((v_21 + v_22));
+  vector<float16_t, 4> l_a_i_a_i_m_i = tint_bitcast_to_f16(a[(((v_21 + v_22) + v_23) / 16u)]);
+  uint v_24 = (((v_21 + v_22) + v_23) + (uint(i()) * 2u));
+  uint v_25 = a[(v_24 / 16u)][((v_24 % 16u) / 4u)];
+  float16_t l_a_i_a_i_m_i_i = float16_t(f16tof32((v_25 >> ((((v_24 % 4u) == 0u)) ? (0u) : (16u)))));
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat2x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat2x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index ee58aee6863..a7a8d5f7984 100644
--- a/test/tint/buffer/uniform/std140/struct/mat2x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat2x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,225 +1,95 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat2x4<f32>,
-}
+  float2x4 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat2x4<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec4<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :54:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %42:u32 = mul %41, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(16) {
-  m:mat2x4<f32> @offset(0)
+float2x4 v(uint start_byte_offset) {
+  float4 v_1 = asfloat(a[(start_byte_offset / 16u)]);
+  return float2x4(v_1, asfloat(a[((16u + start_byte_offset) / 16u)]));
 }
 
-Outer = struct @align(16) {
-  a:array<Inner, 4> @offset(0)
+Inner v_2(uint start_byte_offset) {
+  Inner v_3 = {v(start_byte_offset)};
+  return v_3;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 16u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat2x4<f32> = call %32, %30
-    %l_a_i_a_i_m:mat2x4<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec4<f32> = bitcast %38
-    %l_a_i_a_i_m_i:vec4<f32> = let %39
-    %41:i32 = call %i
-    %42:u32 = mul %41, 4u
-    %43:u32 = add %10, %13
-    %44:u32 = add %43, %16
-    %45:u32 = add %44, %42
-    %46:u32 = div %45, 16u
-    %47:ptr<uniform, vec4<u32>, read> = access %a, %46
-    %48:u32 = mod %45, 16u
-    %49:u32 = div %48, 4u
-    %50:u32 = load_vector_element %47, %49
-    %51:f32 = bitcast %50
-    %l_a_i_a_i_m_i_i:f32 = let %51
-    ret
-  }
-}
-%24 = func(%start_byte_offset:u32):array<Inner, 4> {
-  $B4: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat2x4<f32>(vec4<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B5, b: $B6, c: $B7] {  # loop_1
-      $B5: {  # initializer
-        next_iteration 0u  # -> $B6
-      }
-      $B6 (%idx:u32): {  # body
-        %56:bool = gte %idx, 4u
-        if %56 [t: $B8] {  # if_1
-          $B8: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %57:u32 = mul %idx, 64u
-        %58:u32 = add %start_byte_offset, %57
-        %59:ptr<function, Inner, read_write> = access %a_1, %idx
-        %60:Inner = call %28, %58
-        store %59, %60
-        continue  # -> $B7
+typedef Inner ary_ret[4];
+ary_ret v_4(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_5 = 0u;
+    v_5 = 0u;
+    while(true) {
+      uint v_6 = v_5;
+      if ((v_6 >= 4u)) {
+        break;
       }
-      $B7: {  # continuing
-        %61:u32 = add %idx, 1u
-        next_iteration %61  # -> $B6
+      Inner v_7 = v_2((start_byte_offset + (v_6 * 64u)));
+      a[v_6] = v_7;
+      {
+        v_5 = (v_6 + 1u);
       }
+      continue;
     }
-    %62:array<Inner, 4> = load %a_1
-    ret %62
-  }
-}
-%28 = func(%start_byte_offset_1:u32):Inner {  # %start_byte_offset_1: 'start_byte_offset'
-  $B9: {
-    %64:mat2x4<f32> = call %32, %start_byte_offset_1
-    %65:Inner = construct %64
-    ret %65
-  }
-}
-%32 = func(%start_byte_offset_2:u32):mat2x4<f32> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %67:u32 = div %start_byte_offset_2, 16u
-    %68:ptr<uniform, vec4<u32>, read> = access %a, %67
-    %69:vec4<u32> = load %68
-    %70:vec4<f32> = bitcast %69
-    %71:u32 = add 16u, %start_byte_offset_2
-    %72:u32 = div %71, 16u
-    %73:ptr<uniform, vec4<u32>, read> = access %a, %72
-    %74:vec4<u32> = load %73
-    %75:vec4<f32> = bitcast %74
-    %76:mat2x4<f32> = construct %70, %75
-    ret %76
   }
+  Inner v_8[4] = a;
+  return v_8;
 }
-%21 = func(%start_byte_offset_3:u32):Outer {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %78:array<Inner, 4> = call %24, %start_byte_offset_3
-    %79:Outer = construct %78
-    ret %79
-  }
+
+Outer v_9(uint start_byte_offset) {
+  Inner v_10[4] = v_4(start_byte_offset);
+  Outer v_11 = {v_10};
+  return v_11;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat2x4<f32>(vec4<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %83:bool = gte %idx_1, 4u
-        if %83 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %84:u32 = mul %idx_1, 256u
-        %85:u32 = add %start_byte_offset_4, %84
-        %86:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %87:Outer = call %21, %85
-        store %86, %87
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_12(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_13 = 0u;
+    v_13 = 0u;
+    while(true) {
+      uint v_14 = v_13;
+      if ((v_14 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %88:u32 = add %idx_1, 1u
-        next_iteration %88  # -> $B14
+      Outer v_15 = v_9((start_byte_offset + (v_14 * 256u)));
+      a[v_14] = v_15;
+      {
+        v_13 = (v_14 + 1u);
       }
+      continue;
     }
-    %89:array<Outer, 4> = load %a_2
-    ret %89
   }
+  Outer v_16[4] = a;
+  return v_16;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_17 = (256u * uint(i()));
+  uint v_18 = (64u * uint(i()));
+  uint v_19 = (16u * uint(i()));
+  Outer l_a[4] = v_12(0u);
+  Outer l_a_i = v_9(v_17);
+  Inner l_a_i_a[4] = v_4(v_17);
+  Inner l_a_i_a_i = v_2((v_17 + v_18));
+  float2x4 l_a_i_a_i_m = v((v_17 + v_18));
+  float4 l_a_i_a_i_m_i = asfloat(a[(((v_17 + v_18) + v_19) / 16u)]);
+  uint v_20 = (((v_17 + v_18) + v_19) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_20 / 16u)][((v_20 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat2x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat2x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
index d4a0e76bacd..a7a8d5f7984 100644
--- a/test/tint/buffer/uniform/std140/struct/mat2x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat2x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
@@ -1,225 +1,95 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat2x4<f32>,
-}
+  float2x4 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat2x4<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec4<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :54:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %42:u32 = mul %41, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(16) {
-  m:mat2x4<f32> @offset(0)
+float2x4 v(uint start_byte_offset) {
+  float4 v_1 = asfloat(a[(start_byte_offset / 16u)]);
+  return float2x4(v_1, asfloat(a[((16u + start_byte_offset) / 16u)]));
 }
 
-Outer = struct @align(16) {
-  a:array<Inner, 4> @offset(0)
+Inner v_2(uint start_byte_offset) {
+  Inner v_3 = {v(start_byte_offset)};
+  return v_3;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 16u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat2x4<f32> = call %32, %30
-    %l_a_i_a_i_m:mat2x4<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec4<f32> = bitcast %38
-    %l_a_i_a_i_m_i:vec4<f32> = let %39
-    %41:i32 = call %i
-    %42:u32 = mul %41, 4u
-    %43:u32 = add %10, %13
-    %44:u32 = add %43, %16
-    %45:u32 = add %44, %42
-    %46:u32 = div %45, 16u
-    %47:ptr<uniform, vec4<u32>, read> = access %a, %46
-    %48:u32 = mod %45, 16u
-    %49:u32 = div %48, 4u
-    %50:u32 = load_vector_element %47, %49
-    %51:f32 = bitcast %50
-    %l_a_i_a_i_m_i_i:f32 = let %51
-    ret
-  }
-}
-%21 = func(%start_byte_offset:u32):Outer {
-  $B4: {
-    %54:array<Inner, 4> = call %24, %start_byte_offset
-    %55:Outer = construct %54
-    ret %55
-  }
-}
-%24 = func(%start_byte_offset_1:u32):array<Inner, 4> {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat2x4<f32>(vec4<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B6, b: $B7, c: $B8] {  # loop_1
-      $B6: {  # initializer
-        next_iteration 0u  # -> $B7
-      }
-      $B7 (%idx:u32): {  # body
-        %59:bool = gte %idx, 4u
-        if %59 [t: $B9] {  # if_1
-          $B9: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %60:u32 = mul %idx, 64u
-        %61:u32 = add %start_byte_offset_1, %60
-        %62:ptr<function, Inner, read_write> = access %a_1, %idx
-        %63:Inner = call %28, %61
-        store %62, %63
-        continue  # -> $B8
+typedef Inner ary_ret[4];
+ary_ret v_4(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_5 = 0u;
+    v_5 = 0u;
+    while(true) {
+      uint v_6 = v_5;
+      if ((v_6 >= 4u)) {
+        break;
       }
-      $B8: {  # continuing
-        %64:u32 = add %idx, 1u
-        next_iteration %64  # -> $B7
+      Inner v_7 = v_2((start_byte_offset + (v_6 * 64u)));
+      a[v_6] = v_7;
+      {
+        v_5 = (v_6 + 1u);
       }
+      continue;
     }
-    %65:array<Inner, 4> = load %a_1
-    ret %65
-  }
-}
-%28 = func(%start_byte_offset_2:u32):Inner {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %67:mat2x4<f32> = call %32, %start_byte_offset_2
-    %68:Inner = construct %67
-    ret %68
   }
+  Inner v_8[4] = a;
+  return v_8;
 }
-%32 = func(%start_byte_offset_3:u32):mat2x4<f32> {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %70:u32 = div %start_byte_offset_3, 16u
-    %71:ptr<uniform, vec4<u32>, read> = access %a, %70
-    %72:vec4<u32> = load %71
-    %73:vec4<f32> = bitcast %72
-    %74:u32 = add 16u, %start_byte_offset_3
-    %75:u32 = div %74, 16u
-    %76:ptr<uniform, vec4<u32>, read> = access %a, %75
-    %77:vec4<u32> = load %76
-    %78:vec4<f32> = bitcast %77
-    %79:mat2x4<f32> = construct %73, %78
-    ret %79
-  }
+
+Outer v_9(uint start_byte_offset) {
+  Inner v_10[4] = v_4(start_byte_offset);
+  Outer v_11 = {v_10};
+  return v_11;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat2x4<f32>(vec4<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %83:bool = gte %idx_1, 4u
-        if %83 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %84:u32 = mul %idx_1, 256u
-        %85:u32 = add %start_byte_offset_4, %84
-        %86:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %87:Outer = call %21, %85
-        store %86, %87
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_12(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_13 = 0u;
+    v_13 = 0u;
+    while(true) {
+      uint v_14 = v_13;
+      if ((v_14 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %88:u32 = add %idx_1, 1u
-        next_iteration %88  # -> $B14
+      Outer v_15 = v_9((start_byte_offset + (v_14 * 256u)));
+      a[v_14] = v_15;
+      {
+        v_13 = (v_14 + 1u);
       }
+      continue;
     }
-    %89:array<Outer, 4> = load %a_2
-    ret %89
   }
+  Outer v_16[4] = a;
+  return v_16;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_17 = (256u * uint(i()));
+  uint v_18 = (64u * uint(i()));
+  uint v_19 = (16u * uint(i()));
+  Outer l_a[4] = v_12(0u);
+  Outer l_a_i = v_9(v_17);
+  Inner l_a_i_a[4] = v_4(v_17);
+  Inner l_a_i_a_i = v_2((v_17 + v_18));
+  float2x4 l_a_i_a_i_m = v((v_17 + v_18));
+  float4 l_a_i_a_i_m_i = asfloat(a[(((v_17 + v_18) + v_19) / 16u)]);
+  uint v_20 = (((v_17 + v_18) + v_19) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_20 / 16u)][((v_20 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat3x2_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index 3dbc5f6d311..32d68cf9d9a 100644
--- a/test/tint/buffer/uniform/std140/struct/mat3x2_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat3x2_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,261 +1,109 @@
-SKIP: FAILED
-
-
-enable f16;
-
 struct Inner {
-  @size(64)
-  m : mat3x2<f16>,
-}
+  matrix<float16_t, 3, 2> m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
+  Inner a[4];
+};
 
-var<private> counter = 0;
 
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat3x2<f16> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec2<f16> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f16 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :60:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %48:u32 = mul %47, 2u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(4) {
-  m:mat3x2<f16> @offset(0)
+vector<float16_t, 2> tint_bitcast_to_f16(uint src) {
+  uint v = src;
+  float t_low = f16tof32((v & 65535u));
+  float t_high = f16tof32(((v >> 16u) & 65535u));
+  float16_t v_1 = float16_t(t_low);
+  return vector<float16_t, 2>(v_1, float16_t(t_high));
 }
 
-Outer = struct @align(4) {
-  a:array<Inner, 4> @offset(0)
+matrix<float16_t, 3, 2> v_2(uint start_byte_offset) {
+  uint4 v_3 = a[(start_byte_offset / 16u)];
+  vector<float16_t, 2> v_4 = tint_bitcast_to_f16((((((start_byte_offset % 16u) / 4u) == 2u)) ? (v_3.z) : (v_3.x)));
+  uint4 v_5 = a[((4u + start_byte_offset) / 16u)];
+  vector<float16_t, 2> v_6 = tint_bitcast_to_f16(((((((4u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_5.z) : (v_5.x)));
+  uint4 v_7 = a[((8u + start_byte_offset) / 16u)];
+  return matrix<float16_t, 3, 2>(v_4, v_6, tint_bitcast_to_f16(((((((8u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_7.z) : (v_7.x))));
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
+Inner v_8(uint start_byte_offset) {
+  Inner v_9 = {v_2(start_byte_offset)};
+  return v_9;
 }
 
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 4u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat3x2<f16> = call %32, %30
-    %l_a_i_a_i_m:mat3x2<f16> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:u32 = mod %35, 16u
-    %39:u32 = div %38, 4u
-    %40:vec4<u32> = load %37
-    %41:u32 = swizzle %40, z
-    %42:u32 = swizzle %40, x
-    %43:bool = eq %39, 2u
-    %44:u32 = hlsl.ternary %42, %41, %43
-    %45:vec2<f16> = bitcast %44
-    %l_a_i_a_i_m_i:vec2<f16> = let %45
-    %47:i32 = call %i
-    %48:u32 = mul %47, 2u
-    %49:u32 = add %10, %13
-    %50:u32 = add %49, %16
-    %51:u32 = add %50, %48
-    %52:u32 = div %51, 16u
-    %53:ptr<uniform, vec4<u32>, read> = access %a, %52
-    %54:u32 = mod %51, 16u
-    %55:u32 = div %54, 4u
-    %56:u32 = load_vector_element %53, %55
-    %57:u32 = mod %51, 4u
-    %58:bool = eq %57, 0u
-    %59:u32 = hlsl.ternary 16u, 0u, %58
-    %60:u32 = shr %56, %59
-    %61:f32 = hlsl.f16tof32 %60
-    %62:f16 = convert %61
-    %l_a_i_a_i_m_i_i:f16 = let %62
-    ret
-  }
-}
-%24 = func(%start_byte_offset:u32):array<Inner, 4> {
-  $B4: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat3x2<f16>(vec2<f16>(0.0h))))  # %a_1: 'a'
-    loop [i: $B5, b: $B6, c: $B7] {  # loop_1
-      $B5: {  # initializer
-        next_iteration 0u  # -> $B6
+typedef Inner ary_ret[4];
+ary_ret v_10(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_11 = 0u;
+    v_11 = 0u;
+    while(true) {
+      uint v_12 = v_11;
+      if ((v_12 >= 4u)) {
+        break;
       }
-      $B6 (%idx:u32): {  # body
-        %67:bool = gte %idx, 4u
-        if %67 [t: $B8] {  # if_1
-          $B8: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %68:u32 = mul %idx, 64u
-        %69:u32 = add %start_byte_offset, %68
-        %70:ptr<function, Inner, read_write> = access %a_1, %idx
-        %71:Inner = call %28, %69
-        store %70, %71
-        continue  # -> $B7
-      }
-      $B7: {  # continuing
-        %72:u32 = add %idx, 1u
-        next_iteration %72  # -> $B6
+      Inner v_13 = v_8((start_byte_offset + (v_12 * 64u)));
+      a[v_12] = v_13;
+      {
+        v_11 = (v_12 + 1u);
       }
+      continue;
     }
-    %73:array<Inner, 4> = load %a_1
-    ret %73
-  }
-}
-%28 = func(%start_byte_offset_1:u32):Inner {  # %start_byte_offset_1: 'start_byte_offset'
-  $B9: {
-    %75:mat3x2<f16> = call %32, %start_byte_offset_1
-    %76:Inner = construct %75
-    ret %76
-  }
-}
-%32 = func(%start_byte_offset_2:u32):mat3x2<f16> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %78:u32 = div %start_byte_offset_2, 16u
-    %79:ptr<uniform, vec4<u32>, read> = access %a, %78
-    %80:u32 = mod %start_byte_offset_2, 16u
-    %81:u32 = div %80, 4u
-    %82:vec4<u32> = load %79
-    %83:u32 = swizzle %82, z
-    %84:u32 = swizzle %82, x
-    %85:bool = eq %81, 2u
-    %86:u32 = hlsl.ternary %84, %83, %85
-    %87:vec2<f16> = bitcast %86
-    %88:u32 = add 4u, %start_byte_offset_2
-    %89:u32 = div %88, 16u
-    %90:ptr<uniform, vec4<u32>, read> = access %a, %89
-    %91:u32 = mod %88, 16u
-    %92:u32 = div %91, 4u
-    %93:vec4<u32> = load %90
-    %94:u32 = swizzle %93, z
-    %95:u32 = swizzle %93, x
-    %96:bool = eq %92, 2u
-    %97:u32 = hlsl.ternary %95, %94, %96
-    %98:vec2<f16> = bitcast %97
-    %99:u32 = add 8u, %start_byte_offset_2
-    %100:u32 = div %99, 16u
-    %101:ptr<uniform, vec4<u32>, read> = access %a, %100
-    %102:u32 = mod %99, 16u
-    %103:u32 = div %102, 4u
-    %104:vec4<u32> = load %101
-    %105:u32 = swizzle %104, z
-    %106:u32 = swizzle %104, x
-    %107:bool = eq %103, 2u
-    %108:u32 = hlsl.ternary %106, %105, %107
-    %109:vec2<f16> = bitcast %108
-    %110:mat3x2<f16> = construct %87, %98, %109
-    ret %110
   }
+  Inner v_14[4] = a;
+  return v_14;
 }
-%21 = func(%start_byte_offset_3:u32):Outer {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %112:array<Inner, 4> = call %24, %start_byte_offset_3
-    %113:Outer = construct %112
-    ret %113
-  }
+
+Outer v_15(uint start_byte_offset) {
+  Inner v_16[4] = v_10(start_byte_offset);
+  Outer v_17 = {v_16};
+  return v_17;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat3x2<f16>(vec2<f16>(0.0h))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %117:bool = gte %idx_1, 4u
-        if %117 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %118:u32 = mul %idx_1, 256u
-        %119:u32 = add %start_byte_offset_4, %118
-        %120:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %121:Outer = call %21, %119
-        store %120, %121
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_18(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_19 = 0u;
+    v_19 = 0u;
+    while(true) {
+      uint v_20 = v_19;
+      if ((v_20 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %122:u32 = add %idx_1, 1u
-        next_iteration %122  # -> $B14
+      Outer v_21 = v_15((start_byte_offset + (v_20 * 256u)));
+      a[v_20] = v_21;
+      {
+        v_19 = (v_20 + 1u);
       }
+      continue;
     }
-    %123:array<Outer, 4> = load %a_2
-    ret %123
   }
+  Outer v_22[4] = a;
+  return v_22;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_23 = (256u * uint(i()));
+  uint v_24 = (64u * uint(i()));
+  uint v_25 = (4u * uint(i()));
+  Outer l_a[4] = v_18(0u);
+  Outer l_a_i = v_15(v_23);
+  Inner l_a_i_a[4] = v_10(v_23);
+  Inner l_a_i_a_i = v_8((v_23 + v_24));
+  matrix<float16_t, 3, 2> l_a_i_a_i_m = v_2((v_23 + v_24));
+  uint4 v_26 = a[(((v_23 + v_24) + v_25) / 16u)];
+  vector<float16_t, 2> l_a_i_a_i_m_i = tint_bitcast_to_f16((((((((v_23 + v_24) + v_25) % 16u) / 4u) == 2u)) ? (v_26.z) : (v_26.x)));
+  uint v_27 = (((v_23 + v_24) + v_25) + (uint(i()) * 2u));
+  uint v_28 = a[(v_27 / 16u)][((v_27 % 16u) / 4u)];
+  float16_t l_a_i_a_i_m_i_i = float16_t(f16tof32((v_28 >> ((((v_27 % 4u) == 0u)) ? (0u) : (16u)))));
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat3x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index ce65b77a393..e90b7843860 100644
--- a/test/tint/buffer/uniform/std140/struct/mat3x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat3x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,254 +1,100 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat3x2<f32>,
-}
+  float3x2 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat3x2<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec2<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :60:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %48:u32 = mul %47, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(8) {
-  m:mat3x2<f32> @offset(0)
+float3x2 v(uint start_byte_offset) {
+  uint4 v_1 = a[(start_byte_offset / 16u)];
+  float2 v_2 = asfloat((((((start_byte_offset % 16u) / 4u) == 2u)) ? (v_1.zw) : (v_1.xy)));
+  uint4 v_3 = a[((8u + start_byte_offset) / 16u)];
+  float2 v_4 = asfloat(((((((8u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_3.zw) : (v_3.xy)));
+  uint4 v_5 = a[((16u + start_byte_offset) / 16u)];
+  return float3x2(v_2, v_4, asfloat(((((((16u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_5.zw) : (v_5.xy))));
 }
 
-Outer = struct @align(8) {
-  a:array<Inner, 4> @offset(0)
+Inner v_6(uint start_byte_offset) {
+  Inner v_7 = {v(start_byte_offset)};
+  return v_7;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 8u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat3x2<f32> = call %32, %30
-    %l_a_i_a_i_m:mat3x2<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:u32 = mod %35, 16u
-    %39:u32 = div %38, 4u
-    %40:vec4<u32> = load %37
-    %41:vec2<u32> = swizzle %40, zw
-    %42:vec2<u32> = swizzle %40, xy
-    %43:bool = eq %39, 2u
-    %44:vec2<u32> = hlsl.ternary %42, %41, %43
-    %45:vec2<f32> = bitcast %44
-    %l_a_i_a_i_m_i:vec2<f32> = let %45
-    %47:i32 = call %i
-    %48:u32 = mul %47, 4u
-    %49:u32 = add %10, %13
-    %50:u32 = add %49, %16
-    %51:u32 = add %50, %48
-    %52:u32 = div %51, 16u
-    %53:ptr<uniform, vec4<u32>, read> = access %a, %52
-    %54:u32 = mod %51, 16u
-    %55:u32 = div %54, 4u
-    %56:u32 = load_vector_element %53, %55
-    %57:f32 = bitcast %56
-    %l_a_i_a_i_m_i_i:f32 = let %57
-    ret
-  }
-}
-%24 = func(%start_byte_offset:u32):array<Inner, 4> {
-  $B4: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat3x2<f32>(vec2<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B5, b: $B6, c: $B7] {  # loop_1
-      $B5: {  # initializer
-        next_iteration 0u  # -> $B6
-      }
-      $B6 (%idx:u32): {  # body
-        %62:bool = gte %idx, 4u
-        if %62 [t: $B8] {  # if_1
-          $B8: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %63:u32 = mul %idx, 64u
-        %64:u32 = add %start_byte_offset, %63
-        %65:ptr<function, Inner, read_write> = access %a_1, %idx
-        %66:Inner = call %28, %64
-        store %65, %66
-        continue  # -> $B7
+typedef Inner ary_ret[4];
+ary_ret v_8(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_9 = 0u;
+    v_9 = 0u;
+    while(true) {
+      uint v_10 = v_9;
+      if ((v_10 >= 4u)) {
+        break;
       }
-      $B7: {  # continuing
-        %67:u32 = add %idx, 1u
-        next_iteration %67  # -> $B6
+      Inner v_11 = v_6((start_byte_offset + (v_10 * 64u)));
+      a[v_10] = v_11;
+      {
+        v_9 = (v_10 + 1u);
       }
+      continue;
     }
-    %68:array<Inner, 4> = load %a_1
-    ret %68
-  }
-}
-%28 = func(%start_byte_offset_1:u32):Inner {  # %start_byte_offset_1: 'start_byte_offset'
-  $B9: {
-    %70:mat3x2<f32> = call %32, %start_byte_offset_1
-    %71:Inner = construct %70
-    ret %71
-  }
-}
-%32 = func(%start_byte_offset_2:u32):mat3x2<f32> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %73:u32 = div %start_byte_offset_2, 16u
-    %74:ptr<uniform, vec4<u32>, read> = access %a, %73
-    %75:u32 = mod %start_byte_offset_2, 16u
-    %76:u32 = div %75, 4u
-    %77:vec4<u32> = load %74
-    %78:vec2<u32> = swizzle %77, zw
-    %79:vec2<u32> = swizzle %77, xy
-    %80:bool = eq %76, 2u
-    %81:vec2<u32> = hlsl.ternary %79, %78, %80
-    %82:vec2<f32> = bitcast %81
-    %83:u32 = add 8u, %start_byte_offset_2
-    %84:u32 = div %83, 16u
-    %85:ptr<uniform, vec4<u32>, read> = access %a, %84
-    %86:u32 = mod %83, 16u
-    %87:u32 = div %86, 4u
-    %88:vec4<u32> = load %85
-    %89:vec2<u32> = swizzle %88, zw
-    %90:vec2<u32> = swizzle %88, xy
-    %91:bool = eq %87, 2u
-    %92:vec2<u32> = hlsl.ternary %90, %89, %91
-    %93:vec2<f32> = bitcast %92
-    %94:u32 = add 16u, %start_byte_offset_2
-    %95:u32 = div %94, 16u
-    %96:ptr<uniform, vec4<u32>, read> = access %a, %95
-    %97:u32 = mod %94, 16u
-    %98:u32 = div %97, 4u
-    %99:vec4<u32> = load %96
-    %100:vec2<u32> = swizzle %99, zw
-    %101:vec2<u32> = swizzle %99, xy
-    %102:bool = eq %98, 2u
-    %103:vec2<u32> = hlsl.ternary %101, %100, %102
-    %104:vec2<f32> = bitcast %103
-    %105:mat3x2<f32> = construct %82, %93, %104
-    ret %105
   }
+  Inner v_12[4] = a;
+  return v_12;
 }
-%21 = func(%start_byte_offset_3:u32):Outer {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %107:array<Inner, 4> = call %24, %start_byte_offset_3
-    %108:Outer = construct %107
-    ret %108
-  }
+
+Outer v_13(uint start_byte_offset) {
+  Inner v_14[4] = v_8(start_byte_offset);
+  Outer v_15 = {v_14};
+  return v_15;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat3x2<f32>(vec2<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %112:bool = gte %idx_1, 4u
-        if %112 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %113:u32 = mul %idx_1, 256u
-        %114:u32 = add %start_byte_offset_4, %113
-        %115:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %116:Outer = call %21, %114
-        store %115, %116
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_16(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_17 = 0u;
+    v_17 = 0u;
+    while(true) {
+      uint v_18 = v_17;
+      if ((v_18 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %117:u32 = add %idx_1, 1u
-        next_iteration %117  # -> $B14
+      Outer v_19 = v_13((start_byte_offset + (v_18 * 256u)));
+      a[v_18] = v_19;
+      {
+        v_17 = (v_18 + 1u);
       }
+      continue;
     }
-    %118:array<Outer, 4> = load %a_2
-    ret %118
   }
+  Outer v_20[4] = a;
+  return v_20;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_21 = (256u * uint(i()));
+  uint v_22 = (64u * uint(i()));
+  uint v_23 = (8u * uint(i()));
+  Outer l_a[4] = v_16(0u);
+  Outer l_a_i = v_13(v_21);
+  Inner l_a_i_a[4] = v_8(v_21);
+  Inner l_a_i_a_i = v_6((v_21 + v_22));
+  float3x2 l_a_i_a_i_m = v((v_21 + v_22));
+  uint4 v_24 = a[(((v_21 + v_22) + v_23) / 16u)];
+  float2 l_a_i_a_i_m_i = asfloat((((((((v_21 + v_22) + v_23) % 16u) / 4u) == 2u)) ? (v_24.zw) : (v_24.xy)));
+  uint v_25 = (((v_21 + v_22) + v_23) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_25 / 16u)][((v_25 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat3x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat3x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
index 6dd002387a9..e90b7843860 100644
--- a/test/tint/buffer/uniform/std140/struct/mat3x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat3x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
@@ -1,254 +1,100 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat3x2<f32>,
-}
+  float3x2 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat3x2<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec2<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :60:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %48:u32 = mul %47, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(8) {
-  m:mat3x2<f32> @offset(0)
+float3x2 v(uint start_byte_offset) {
+  uint4 v_1 = a[(start_byte_offset / 16u)];
+  float2 v_2 = asfloat((((((start_byte_offset % 16u) / 4u) == 2u)) ? (v_1.zw) : (v_1.xy)));
+  uint4 v_3 = a[((8u + start_byte_offset) / 16u)];
+  float2 v_4 = asfloat(((((((8u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_3.zw) : (v_3.xy)));
+  uint4 v_5 = a[((16u + start_byte_offset) / 16u)];
+  return float3x2(v_2, v_4, asfloat(((((((16u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_5.zw) : (v_5.xy))));
 }
 
-Outer = struct @align(8) {
-  a:array<Inner, 4> @offset(0)
+Inner v_6(uint start_byte_offset) {
+  Inner v_7 = {v(start_byte_offset)};
+  return v_7;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 8u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat3x2<f32> = call %32, %30
-    %l_a_i_a_i_m:mat3x2<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:u32 = mod %35, 16u
-    %39:u32 = div %38, 4u
-    %40:vec4<u32> = load %37
-    %41:vec2<u32> = swizzle %40, zw
-    %42:vec2<u32> = swizzle %40, xy
-    %43:bool = eq %39, 2u
-    %44:vec2<u32> = hlsl.ternary %42, %41, %43
-    %45:vec2<f32> = bitcast %44
-    %l_a_i_a_i_m_i:vec2<f32> = let %45
-    %47:i32 = call %i
-    %48:u32 = mul %47, 4u
-    %49:u32 = add %10, %13
-    %50:u32 = add %49, %16
-    %51:u32 = add %50, %48
-    %52:u32 = div %51, 16u
-    %53:ptr<uniform, vec4<u32>, read> = access %a, %52
-    %54:u32 = mod %51, 16u
-    %55:u32 = div %54, 4u
-    %56:u32 = load_vector_element %53, %55
-    %57:f32 = bitcast %56
-    %l_a_i_a_i_m_i_i:f32 = let %57
-    ret
-  }
-}
-%32 = func(%start_byte_offset:u32):mat3x2<f32> {
-  $B4: {
-    %60:u32 = div %start_byte_offset, 16u
-    %61:ptr<uniform, vec4<u32>, read> = access %a, %60
-    %62:u32 = mod %start_byte_offset, 16u
-    %63:u32 = div %62, 4u
-    %64:vec4<u32> = load %61
-    %65:vec2<u32> = swizzle %64, zw
-    %66:vec2<u32> = swizzle %64, xy
-    %67:bool = eq %63, 2u
-    %68:vec2<u32> = hlsl.ternary %66, %65, %67
-    %69:vec2<f32> = bitcast %68
-    %70:u32 = add 8u, %start_byte_offset
-    %71:u32 = div %70, 16u
-    %72:ptr<uniform, vec4<u32>, read> = access %a, %71
-    %73:u32 = mod %70, 16u
-    %74:u32 = div %73, 4u
-    %75:vec4<u32> = load %72
-    %76:vec2<u32> = swizzle %75, zw
-    %77:vec2<u32> = swizzle %75, xy
-    %78:bool = eq %74, 2u
-    %79:vec2<u32> = hlsl.ternary %77, %76, %78
-    %80:vec2<f32> = bitcast %79
-    %81:u32 = add 16u, %start_byte_offset
-    %82:u32 = div %81, 16u
-    %83:ptr<uniform, vec4<u32>, read> = access %a, %82
-    %84:u32 = mod %81, 16u
-    %85:u32 = div %84, 4u
-    %86:vec4<u32> = load %83
-    %87:vec2<u32> = swizzle %86, zw
-    %88:vec2<u32> = swizzle %86, xy
-    %89:bool = eq %85, 2u
-    %90:vec2<u32> = hlsl.ternary %88, %87, %89
-    %91:vec2<f32> = bitcast %90
-    %92:mat3x2<f32> = construct %69, %80, %91
-    ret %92
-  }
-}
-%28 = func(%start_byte_offset_1:u32):Inner {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %94:mat3x2<f32> = call %32, %start_byte_offset_1
-    %95:Inner = construct %94
-    ret %95
-  }
-}
-%24 = func(%start_byte_offset_2:u32):array<Inner, 4> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B6: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat3x2<f32>(vec2<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B7, b: $B8, c: $B9] {  # loop_1
-      $B7: {  # initializer
-        next_iteration 0u  # -> $B8
+typedef Inner ary_ret[4];
+ary_ret v_8(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_9 = 0u;
+    v_9 = 0u;
+    while(true) {
+      uint v_10 = v_9;
+      if ((v_10 >= 4u)) {
+        break;
       }
-      $B8 (%idx:u32): {  # body
-        %99:bool = gte %idx, 4u
-        if %99 [t: $B10] {  # if_1
-          $B10: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %100:u32 = mul %idx, 64u
-        %101:u32 = add %start_byte_offset_2, %100
-        %102:ptr<function, Inner, read_write> = access %a_1, %idx
-        %103:Inner = call %28, %101
-        store %102, %103
-        continue  # -> $B9
-      }
-      $B9: {  # continuing
-        %104:u32 = add %idx, 1u
-        next_iteration %104  # -> $B8
+      Inner v_11 = v_6((start_byte_offset + (v_10 * 64u)));
+      a[v_10] = v_11;
+      {
+        v_9 = (v_10 + 1u);
       }
+      continue;
     }
-    %105:array<Inner, 4> = load %a_1
-    ret %105
   }
+  Inner v_12[4] = a;
+  return v_12;
 }
-%21 = func(%start_byte_offset_3:u32):Outer {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %107:array<Inner, 4> = call %24, %start_byte_offset_3
-    %108:Outer = construct %107
-    ret %108
-  }
+
+Outer v_13(uint start_byte_offset) {
+  Inner v_14[4] = v_8(start_byte_offset);
+  Outer v_15 = {v_14};
+  return v_15;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat3x2<f32>(vec2<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %112:bool = gte %idx_1, 4u
-        if %112 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %113:u32 = mul %idx_1, 256u
-        %114:u32 = add %start_byte_offset_4, %113
-        %115:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %116:Outer = call %21, %114
-        store %115, %116
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_16(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_17 = 0u;
+    v_17 = 0u;
+    while(true) {
+      uint v_18 = v_17;
+      if ((v_18 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %117:u32 = add %idx_1, 1u
-        next_iteration %117  # -> $B14
+      Outer v_19 = v_13((start_byte_offset + (v_18 * 256u)));
+      a[v_18] = v_19;
+      {
+        v_17 = (v_18 + 1u);
       }
+      continue;
     }
-    %118:array<Outer, 4> = load %a_2
-    ret %118
   }
+  Outer v_20[4] = a;
+  return v_20;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_21 = (256u * uint(i()));
+  uint v_22 = (64u * uint(i()));
+  uint v_23 = (8u * uint(i()));
+  Outer l_a[4] = v_16(0u);
+  Outer l_a_i = v_13(v_21);
+  Inner l_a_i_a[4] = v_8(v_21);
+  Inner l_a_i_a_i = v_6((v_21 + v_22));
+  float3x2 l_a_i_a_i_m = v((v_21 + v_22));
+  uint4 v_24 = a[(((v_21 + v_22) + v_23) / 16u)];
+  float2 l_a_i_a_i_m_i = asfloat((((((((v_21 + v_22) + v_23) % 16u) / 4u) == 2u)) ? (v_24.zw) : (v_24.xy)));
+  uint v_25 = (((v_21 + v_22) + v_23) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_25 / 16u)][((v_25 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat3x3_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat3x3_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index b7fdeb22aa4..e0cc2647140 100644
--- a/test/tint/buffer/uniform/std140/struct/mat3x3_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat3x3_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,241 +1,109 @@
-SKIP: FAILED
-
-
-enable f16;
-
 struct Inner {
-  @size(64)
-  m : mat3x3<f16>,
-}
+  matrix<float16_t, 3, 3> m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
+  Inner a[4];
+};
 
-var<private> counter = 0;
 
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat3x3<f16> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec3<f16> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f16 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :55:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %43:u32 = mul %42, 2u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(8) {
-  m:mat3x3<f16> @offset(0)
+vector<float16_t, 4> tint_bitcast_to_f16(uint4 src) {
+  uint4 v = src;
+  uint4 mask = (65535u).xxxx;
+  uint4 shift = (16u).xxxx;
+  float4 t_low = f16tof32((v & mask));
+  float4 t_high = f16tof32(((v >> shift) & mask));
+  float16_t v_1 = float16_t(t_low.x);
+  float16_t v_2 = float16_t(t_high.x);
+  float16_t v_3 = float16_t(t_low.y);
+  return vector<float16_t, 4>(v_1, v_2, v_3, float16_t(t_high.y));
 }
 
-Outer = struct @align(8) {
-  a:array<Inner, 4> @offset(0)
+matrix<float16_t, 3, 3> v_4(uint start_byte_offset) {
+  vector<float16_t, 3> v_5 = tint_bitcast_to_f16(a[(start_byte_offset / 16u)]).xyz;
+  vector<float16_t, 3> v_6 = tint_bitcast_to_f16(a[((8u + start_byte_offset) / 16u)]).xyz;
+  return matrix<float16_t, 3, 3>(v_5, v_6, tint_bitcast_to_f16(a[((16u + start_byte_offset) / 16u)]).xyz);
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
+Inner v_7(uint start_byte_offset) {
+  Inner v_8 = {v_4(start_byte_offset)};
+  return v_8;
 }
 
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 8u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat3x3<f16> = call %32, %30
-    %l_a_i_a_i_m:mat3x3<f16> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec4<f16> = bitcast %38
-    %40:vec3<f16> = swizzle %39, xyz
-    %l_a_i_a_i_m_i:vec3<f16> = let %40
-    %42:i32 = call %i
-    %43:u32 = mul %42, 2u
-    %44:u32 = add %10, %13
-    %45:u32 = add %44, %16
-    %46:u32 = add %45, %43
-    %47:u32 = div %46, 16u
-    %48:ptr<uniform, vec4<u32>, read> = access %a, %47
-    %49:u32 = mod %46, 16u
-    %50:u32 = div %49, 4u
-    %51:u32 = load_vector_element %48, %50
-    %52:u32 = mod %46, 4u
-    %53:bool = eq %52, 0u
-    %54:u32 = hlsl.ternary 16u, 0u, %53
-    %55:u32 = shr %51, %54
-    %56:f32 = hlsl.f16tof32 %55
-    %57:f16 = convert %56
-    %l_a_i_a_i_m_i_i:f16 = let %57
-    ret
-  }
-}
-%21 = func(%start_byte_offset:u32):Outer {
-  $B4: {
-    %60:array<Inner, 4> = call %24, %start_byte_offset
-    %61:Outer = construct %60
-    ret %61
-  }
-}
-%24 = func(%start_byte_offset_1:u32):array<Inner, 4> {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat3x3<f16>(vec3<f16>(0.0h))))  # %a_1: 'a'
-    loop [i: $B6, b: $B7, c: $B8] {  # loop_1
-      $B6: {  # initializer
-        next_iteration 0u  # -> $B7
+typedef Inner ary_ret[4];
+ary_ret v_9(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_10 = 0u;
+    v_10 = 0u;
+    while(true) {
+      uint v_11 = v_10;
+      if ((v_11 >= 4u)) {
+        break;
       }
-      $B7 (%idx:u32): {  # body
-        %65:bool = gte %idx, 4u
-        if %65 [t: $B9] {  # if_1
-          $B9: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %66:u32 = mul %idx, 64u
-        %67:u32 = add %start_byte_offset_1, %66
-        %68:ptr<function, Inner, read_write> = access %a_1, %idx
-        %69:Inner = call %28, %67
-        store %68, %69
-        continue  # -> $B8
-      }
-      $B8: {  # continuing
-        %70:u32 = add %idx, 1u
-        next_iteration %70  # -> $B7
+      Inner v_12 = v_7((start_byte_offset + (v_11 * 64u)));
+      a[v_11] = v_12;
+      {
+        v_10 = (v_11 + 1u);
       }
+      continue;
     }
-    %71:array<Inner, 4> = load %a_1
-    ret %71
-  }
-}
-%28 = func(%start_byte_offset_2:u32):Inner {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %73:mat3x3<f16> = call %32, %start_byte_offset_2
-    %74:Inner = construct %73
-    ret %74
   }
+  Inner v_13[4] = a;
+  return v_13;
 }
-%32 = func(%start_byte_offset_3:u32):mat3x3<f16> {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %76:u32 = div %start_byte_offset_3, 16u
-    %77:ptr<uniform, vec4<u32>, read> = access %a, %76
-    %78:vec4<u32> = load %77
-    %79:vec4<f16> = bitcast %78
-    %80:vec3<f16> = swizzle %79, xyz
-    %81:u32 = add 8u, %start_byte_offset_3
-    %82:u32 = div %81, 16u
-    %83:ptr<uniform, vec4<u32>, read> = access %a, %82
-    %84:vec4<u32> = load %83
-    %85:vec4<f16> = bitcast %84
-    %86:vec3<f16> = swizzle %85, xyz
-    %87:u32 = add 16u, %start_byte_offset_3
-    %88:u32 = div %87, 16u
-    %89:ptr<uniform, vec4<u32>, read> = access %a, %88
-    %90:vec4<u32> = load %89
-    %91:vec4<f16> = bitcast %90
-    %92:vec3<f16> = swizzle %91, xyz
-    %93:mat3x3<f16> = construct %80, %86, %92
-    ret %93
-  }
+
+Outer v_14(uint start_byte_offset) {
+  Inner v_15[4] = v_9(start_byte_offset);
+  Outer v_16 = {v_15};
+  return v_16;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat3x3<f16>(vec3<f16>(0.0h))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %97:bool = gte %idx_1, 4u
-        if %97 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %98:u32 = mul %idx_1, 256u
-        %99:u32 = add %start_byte_offset_4, %98
-        %100:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %101:Outer = call %21, %99
-        store %100, %101
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_17(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_18 = 0u;
+    v_18 = 0u;
+    while(true) {
+      uint v_19 = v_18;
+      if ((v_19 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %102:u32 = add %idx_1, 1u
-        next_iteration %102  # -> $B14
+      Outer v_20 = v_14((start_byte_offset + (v_19 * 256u)));
+      a[v_19] = v_20;
+      {
+        v_18 = (v_19 + 1u);
       }
+      continue;
     }
-    %103:array<Outer, 4> = load %a_2
-    ret %103
   }
+  Outer v_21[4] = a;
+  return v_21;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_22 = (256u * uint(i()));
+  uint v_23 = (64u * uint(i()));
+  uint v_24 = (8u * uint(i()));
+  Outer l_a[4] = v_17(0u);
+  Outer l_a_i = v_14(v_22);
+  Inner l_a_i_a[4] = v_9(v_22);
+  Inner l_a_i_a_i = v_7((v_22 + v_23));
+  matrix<float16_t, 3, 3> l_a_i_a_i_m = v_4((v_22 + v_23));
+  vector<float16_t, 3> l_a_i_a_i_m_i = tint_bitcast_to_f16(a[(((v_22 + v_23) + v_24) / 16u)]).xyz;
+  uint v_25 = (((v_22 + v_23) + v_24) + (uint(i()) * 2u));
+  uint v_26 = a[(v_25 / 16u)][((v_25 % 16u) / 4u)];
+  float16_t l_a_i_a_i_m_i_i = float16_t(f16tof32((v_26 >> ((((v_25 % 4u) == 0u)) ? (0u) : (16u)))));
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat3x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat3x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index d40d68c2be6..1d05e5d1408 100644
--- a/test/tint/buffer/uniform/std140/struct/mat3x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat3x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,234 +1,96 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat3x3<f32>,
-}
+  float3x3 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat3x3<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec3<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :55:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %43:u32 = mul %42, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(16) {
-  m:mat3x3<f32> @offset(0)
+float3x3 v(uint start_byte_offset) {
+  float3 v_1 = asfloat(a[(start_byte_offset / 16u)].xyz);
+  float3 v_2 = asfloat(a[((16u + start_byte_offset) / 16u)].xyz);
+  return float3x3(v_1, v_2, asfloat(a[((32u + start_byte_offset) / 16u)].xyz));
 }
 
-Outer = struct @align(16) {
-  a:array<Inner, 4> @offset(0)
+Inner v_3(uint start_byte_offset) {
+  Inner v_4 = {v(start_byte_offset)};
+  return v_4;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 16u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat3x3<f32> = call %32, %30
-    %l_a_i_a_i_m:mat3x3<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec3<u32> = swizzle %38, xyz
-    %40:vec3<f32> = bitcast %39
-    %l_a_i_a_i_m_i:vec3<f32> = let %40
-    %42:i32 = call %i
-    %43:u32 = mul %42, 4u
-    %44:u32 = add %10, %13
-    %45:u32 = add %44, %16
-    %46:u32 = add %45, %43
-    %47:u32 = div %46, 16u
-    %48:ptr<uniform, vec4<u32>, read> = access %a, %47
-    %49:u32 = mod %46, 16u
-    %50:u32 = div %49, 4u
-    %51:u32 = load_vector_element %48, %50
-    %52:f32 = bitcast %51
-    %l_a_i_a_i_m_i_i:f32 = let %52
-    ret
-  }
-}
-%24 = func(%start_byte_offset:u32):array<Inner, 4> {
-  $B4: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat3x3<f32>(vec3<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B5, b: $B6, c: $B7] {  # loop_1
-      $B5: {  # initializer
-        next_iteration 0u  # -> $B6
-      }
-      $B6 (%idx:u32): {  # body
-        %57:bool = gte %idx, 4u
-        if %57 [t: $B8] {  # if_1
-          $B8: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %58:u32 = mul %idx, 64u
-        %59:u32 = add %start_byte_offset, %58
-        %60:ptr<function, Inner, read_write> = access %a_1, %idx
-        %61:Inner = call %28, %59
-        store %60, %61
-        continue  # -> $B7
+typedef Inner ary_ret[4];
+ary_ret v_5(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_6 = 0u;
+    v_6 = 0u;
+    while(true) {
+      uint v_7 = v_6;
+      if ((v_7 >= 4u)) {
+        break;
       }
-      $B7: {  # continuing
-        %62:u32 = add %idx, 1u
-        next_iteration %62  # -> $B6
+      Inner v_8 = v_3((start_byte_offset + (v_7 * 64u)));
+      a[v_7] = v_8;
+      {
+        v_6 = (v_7 + 1u);
       }
+      continue;
     }
-    %63:array<Inner, 4> = load %a_1
-    ret %63
-  }
-}
-%28 = func(%start_byte_offset_1:u32):Inner {  # %start_byte_offset_1: 'start_byte_offset'
-  $B9: {
-    %65:mat3x3<f32> = call %32, %start_byte_offset_1
-    %66:Inner = construct %65
-    ret %66
-  }
-}
-%32 = func(%start_byte_offset_2:u32):mat3x3<f32> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %68:u32 = div %start_byte_offset_2, 16u
-    %69:ptr<uniform, vec4<u32>, read> = access %a, %68
-    %70:vec4<u32> = load %69
-    %71:vec3<u32> = swizzle %70, xyz
-    %72:vec3<f32> = bitcast %71
-    %73:u32 = add 16u, %start_byte_offset_2
-    %74:u32 = div %73, 16u
-    %75:ptr<uniform, vec4<u32>, read> = access %a, %74
-    %76:vec4<u32> = load %75
-    %77:vec3<u32> = swizzle %76, xyz
-    %78:vec3<f32> = bitcast %77
-    %79:u32 = add 32u, %start_byte_offset_2
-    %80:u32 = div %79, 16u
-    %81:ptr<uniform, vec4<u32>, read> = access %a, %80
-    %82:vec4<u32> = load %81
-    %83:vec3<u32> = swizzle %82, xyz
-    %84:vec3<f32> = bitcast %83
-    %85:mat3x3<f32> = construct %72, %78, %84
-    ret %85
   }
+  Inner v_9[4] = a;
+  return v_9;
 }
-%21 = func(%start_byte_offset_3:u32):Outer {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %87:array<Inner, 4> = call %24, %start_byte_offset_3
-    %88:Outer = construct %87
-    ret %88
-  }
+
+Outer v_10(uint start_byte_offset) {
+  Inner v_11[4] = v_5(start_byte_offset);
+  Outer v_12 = {v_11};
+  return v_12;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat3x3<f32>(vec3<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %92:bool = gte %idx_1, 4u
-        if %92 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %93:u32 = mul %idx_1, 256u
-        %94:u32 = add %start_byte_offset_4, %93
-        %95:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %96:Outer = call %21, %94
-        store %95, %96
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_13(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_14 = 0u;
+    v_14 = 0u;
+    while(true) {
+      uint v_15 = v_14;
+      if ((v_15 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %97:u32 = add %idx_1, 1u
-        next_iteration %97  # -> $B14
+      Outer v_16 = v_10((start_byte_offset + (v_15 * 256u)));
+      a[v_15] = v_16;
+      {
+        v_14 = (v_15 + 1u);
       }
+      continue;
     }
-    %98:array<Outer, 4> = load %a_2
-    ret %98
   }
+  Outer v_17[4] = a;
+  return v_17;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_18 = (256u * uint(i()));
+  uint v_19 = (64u * uint(i()));
+  uint v_20 = (16u * uint(i()));
+  Outer l_a[4] = v_13(0u);
+  Outer l_a_i = v_10(v_18);
+  Inner l_a_i_a[4] = v_5(v_18);
+  Inner l_a_i_a_i = v_3((v_18 + v_19));
+  float3x3 l_a_i_a_i_m = v((v_18 + v_19));
+  float3 l_a_i_a_i_m_i = asfloat(a[(((v_18 + v_19) + v_20) / 16u)].xyz);
+  uint v_21 = (((v_18 + v_19) + v_20) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_21 / 16u)][((v_21 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat3x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat3x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
index 9c466719ac3..1d05e5d1408 100644
--- a/test/tint/buffer/uniform/std140/struct/mat3x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat3x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
@@ -1,234 +1,96 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat3x3<f32>,
-}
+  float3x3 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat3x3<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec3<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :55:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %43:u32 = mul %42, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(16) {
-  m:mat3x3<f32> @offset(0)
-}
-
-Outer = struct @align(16) {
-  a:array<Inner, 4> @offset(0)
+float3x3 v(uint start_byte_offset) {
+  float3 v_1 = asfloat(a[(start_byte_offset / 16u)].xyz);
+  float3 v_2 = asfloat(a[((16u + start_byte_offset) / 16u)].xyz);
+  return float3x3(v_1, v_2, asfloat(a[((32u + start_byte_offset) / 16u)].xyz));
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
+Inner v_3(uint start_byte_offset) {
+  Inner v_4 = {v(start_byte_offset)};
+  return v_4;
 }
 
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 16u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat3x3<f32> = call %32, %30
-    %l_a_i_a_i_m:mat3x3<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec3<u32> = swizzle %38, xyz
-    %40:vec3<f32> = bitcast %39
-    %l_a_i_a_i_m_i:vec3<f32> = let %40
-    %42:i32 = call %i
-    %43:u32 = mul %42, 4u
-    %44:u32 = add %10, %13
-    %45:u32 = add %44, %16
-    %46:u32 = add %45, %43
-    %47:u32 = div %46, 16u
-    %48:ptr<uniform, vec4<u32>, read> = access %a, %47
-    %49:u32 = mod %46, 16u
-    %50:u32 = div %49, 4u
-    %51:u32 = load_vector_element %48, %50
-    %52:f32 = bitcast %51
-    %l_a_i_a_i_m_i_i:f32 = let %52
-    ret
-  }
-}
-%18 = func(%start_byte_offset:u32):array<Outer, 4> {
-  $B4: {
-    %a_1:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat3x3<f32>(vec3<f32>(0.0f))))))  # %a_1: 'a'
-    loop [i: $B5, b: $B6, c: $B7] {  # loop_1
-      $B5: {  # initializer
-        next_iteration 0u  # -> $B6
+typedef Inner ary_ret[4];
+ary_ret v_5(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_6 = 0u;
+    v_6 = 0u;
+    while(true) {
+      uint v_7 = v_6;
+      if ((v_7 >= 4u)) {
+        break;
       }
-      $B6 (%idx:u32): {  # body
-        %57:bool = gte %idx, 4u
-        if %57 [t: $B8] {  # if_1
-          $B8: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %58:u32 = mul %idx, 256u
-        %59:u32 = add %start_byte_offset, %58
-        %60:ptr<function, Outer, read_write> = access %a_1, %idx
-        %61:Outer = call %21, %59
-        store %60, %61
-        continue  # -> $B7
-      }
-      $B7: {  # continuing
-        %62:u32 = add %idx, 1u
-        next_iteration %62  # -> $B6
+      Inner v_8 = v_3((start_byte_offset + (v_7 * 64u)));
+      a[v_7] = v_8;
+      {
+        v_6 = (v_7 + 1u);
       }
+      continue;
     }
-    %63:array<Outer, 4> = load %a_1
-    ret %63
   }
+  Inner v_9[4] = a;
+  return v_9;
 }
-%21 = func(%start_byte_offset_1:u32):Outer {  # %start_byte_offset_1: 'start_byte_offset'
-  $B9: {
-    %65:array<Inner, 4> = call %24, %start_byte_offset_1
-    %66:Outer = construct %65
-    ret %66
-  }
+
+Outer v_10(uint start_byte_offset) {
+  Inner v_11[4] = v_5(start_byte_offset);
+  Outer v_12 = {v_11};
+  return v_12;
 }
-%24 = func(%start_byte_offset_2:u32):array<Inner, 4> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %a_2:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat3x3<f32>(vec3<f32>(0.0f))))  # %a_2: 'a'
-    loop [i: $B11, b: $B12, c: $B13] {  # loop_2
-      $B11: {  # initializer
-        next_iteration 0u  # -> $B12
-      }
-      $B12 (%idx_1:u32): {  # body
-        %70:bool = gte %idx_1, 4u
-        if %70 [t: $B14] {  # if_2
-          $B14: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %71:u32 = mul %idx_1, 64u
-        %72:u32 = add %start_byte_offset_2, %71
-        %73:ptr<function, Inner, read_write> = access %a_2, %idx_1
-        %74:Inner = call %28, %72
-        store %73, %74
-        continue  # -> $B13
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_13(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_14 = 0u;
+    v_14 = 0u;
+    while(true) {
+      uint v_15 = v_14;
+      if ((v_15 >= 4u)) {
+        break;
       }
-      $B13: {  # continuing
-        %75:u32 = add %idx_1, 1u
-        next_iteration %75  # -> $B12
+      Outer v_16 = v_10((start_byte_offset + (v_15 * 256u)));
+      a[v_15] = v_16;
+      {
+        v_14 = (v_15 + 1u);
       }
+      continue;
     }
-    %76:array<Inner, 4> = load %a_2
-    ret %76
-  }
-}
-%28 = func(%start_byte_offset_3:u32):Inner {  # %start_byte_offset_3: 'start_byte_offset'
-  $B15: {
-    %78:mat3x3<f32> = call %32, %start_byte_offset_3
-    %79:Inner = construct %78
-    ret %79
   }
+  Outer v_17[4] = a;
+  return v_17;
 }
-%32 = func(%start_byte_offset_4:u32):mat3x3<f32> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B16: {
-    %81:u32 = div %start_byte_offset_4, 16u
-    %82:ptr<uniform, vec4<u32>, read> = access %a, %81
-    %83:vec4<u32> = load %82
-    %84:vec3<u32> = swizzle %83, xyz
-    %85:vec3<f32> = bitcast %84
-    %86:u32 = add 16u, %start_byte_offset_4
-    %87:u32 = div %86, 16u
-    %88:ptr<uniform, vec4<u32>, read> = access %a, %87
-    %89:vec4<u32> = load %88
-    %90:vec3<u32> = swizzle %89, xyz
-    %91:vec3<f32> = bitcast %90
-    %92:u32 = add 32u, %start_byte_offset_4
-    %93:u32 = div %92, 16u
-    %94:ptr<uniform, vec4<u32>, read> = access %a, %93
-    %95:vec4<u32> = load %94
-    %96:vec3<u32> = swizzle %95, xyz
-    %97:vec3<f32> = bitcast %96
-    %98:mat3x3<f32> = construct %85, %91, %97
-    ret %98
-  }
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_18 = (256u * uint(i()));
+  uint v_19 = (64u * uint(i()));
+  uint v_20 = (16u * uint(i()));
+  Outer l_a[4] = v_13(0u);
+  Outer l_a_i = v_10(v_18);
+  Inner l_a_i_a[4] = v_5(v_18);
+  Inner l_a_i_a_i = v_3((v_18 + v_19));
+  float3x3 l_a_i_a_i_m = v((v_18 + v_19));
+  float3 l_a_i_a_i_m_i = asfloat(a[(((v_18 + v_19) + v_20) / 16u)].xyz);
+  uint v_21 = (((v_18 + v_19) + v_20) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_21 / 16u)][((v_21 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat3x4_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat3x4_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index f23eccc094a..2766ada9d28 100644
--- a/test/tint/buffer/uniform/std140/struct/mat3x4_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat3x4_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,237 +1,109 @@
-SKIP: FAILED
-
-
-enable f16;
-
 struct Inner {
-  @size(64)
-  m : mat3x4<f16>,
-}
+  matrix<float16_t, 3, 4> m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
+  Inner a[4];
+};
 
-var<private> counter = 0;
 
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat3x4<f16> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec4<f16> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f16 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :54:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %42:u32 = mul %41, 2u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(8) {
-  m:mat3x4<f16> @offset(0)
+vector<float16_t, 4> tint_bitcast_to_f16(uint4 src) {
+  uint4 v = src;
+  uint4 mask = (65535u).xxxx;
+  uint4 shift = (16u).xxxx;
+  float4 t_low = f16tof32((v & mask));
+  float4 t_high = f16tof32(((v >> shift) & mask));
+  float16_t v_1 = float16_t(t_low.x);
+  float16_t v_2 = float16_t(t_high.x);
+  float16_t v_3 = float16_t(t_low.y);
+  return vector<float16_t, 4>(v_1, v_2, v_3, float16_t(t_high.y));
 }
 
-Outer = struct @align(8) {
-  a:array<Inner, 4> @offset(0)
+matrix<float16_t, 3, 4> v_4(uint start_byte_offset) {
+  vector<float16_t, 4> v_5 = tint_bitcast_to_f16(a[(start_byte_offset / 16u)]);
+  vector<float16_t, 4> v_6 = tint_bitcast_to_f16(a[((8u + start_byte_offset) / 16u)]);
+  return matrix<float16_t, 3, 4>(v_5, v_6, tint_bitcast_to_f16(a[((16u + start_byte_offset) / 16u)]));
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
+Inner v_7(uint start_byte_offset) {
+  Inner v_8 = {v_4(start_byte_offset)};
+  return v_8;
 }
 
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 8u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat3x4<f16> = call %32, %30
-    %l_a_i_a_i_m:mat3x4<f16> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec4<f16> = bitcast %38
-    %l_a_i_a_i_m_i:vec4<f16> = let %39
-    %41:i32 = call %i
-    %42:u32 = mul %41, 2u
-    %43:u32 = add %10, %13
-    %44:u32 = add %43, %16
-    %45:u32 = add %44, %42
-    %46:u32 = div %45, 16u
-    %47:ptr<uniform, vec4<u32>, read> = access %a, %46
-    %48:u32 = mod %45, 16u
-    %49:u32 = div %48, 4u
-    %50:u32 = load_vector_element %47, %49
-    %51:u32 = mod %45, 4u
-    %52:bool = eq %51, 0u
-    %53:u32 = hlsl.ternary 16u, 0u, %52
-    %54:u32 = shr %50, %53
-    %55:f32 = hlsl.f16tof32 %54
-    %56:f16 = convert %55
-    %l_a_i_a_i_m_i_i:f16 = let %56
-    ret
-  }
-}
-%21 = func(%start_byte_offset:u32):Outer {
-  $B4: {
-    %59:array<Inner, 4> = call %24, %start_byte_offset
-    %60:Outer = construct %59
-    ret %60
-  }
-}
-%24 = func(%start_byte_offset_1:u32):array<Inner, 4> {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat3x4<f16>(vec4<f16>(0.0h))))  # %a_1: 'a'
-    loop [i: $B6, b: $B7, c: $B8] {  # loop_1
-      $B6: {  # initializer
-        next_iteration 0u  # -> $B7
+typedef Inner ary_ret[4];
+ary_ret v_9(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_10 = 0u;
+    v_10 = 0u;
+    while(true) {
+      uint v_11 = v_10;
+      if ((v_11 >= 4u)) {
+        break;
       }
-      $B7 (%idx:u32): {  # body
-        %64:bool = gte %idx, 4u
-        if %64 [t: $B9] {  # if_1
-          $B9: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %65:u32 = mul %idx, 64u
-        %66:u32 = add %start_byte_offset_1, %65
-        %67:ptr<function, Inner, read_write> = access %a_1, %idx
-        %68:Inner = call %28, %66
-        store %67, %68
-        continue  # -> $B8
-      }
-      $B8: {  # continuing
-        %69:u32 = add %idx, 1u
-        next_iteration %69  # -> $B7
+      Inner v_12 = v_7((start_byte_offset + (v_11 * 64u)));
+      a[v_11] = v_12;
+      {
+        v_10 = (v_11 + 1u);
       }
+      continue;
     }
-    %70:array<Inner, 4> = load %a_1
-    ret %70
-  }
-}
-%28 = func(%start_byte_offset_2:u32):Inner {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %72:mat3x4<f16> = call %32, %start_byte_offset_2
-    %73:Inner = construct %72
-    ret %73
   }
+  Inner v_13[4] = a;
+  return v_13;
 }
-%32 = func(%start_byte_offset_3:u32):mat3x4<f16> {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %75:u32 = div %start_byte_offset_3, 16u
-    %76:ptr<uniform, vec4<u32>, read> = access %a, %75
-    %77:vec4<u32> = load %76
-    %78:vec4<f16> = bitcast %77
-    %79:u32 = add 8u, %start_byte_offset_3
-    %80:u32 = div %79, 16u
-    %81:ptr<uniform, vec4<u32>, read> = access %a, %80
-    %82:vec4<u32> = load %81
-    %83:vec4<f16> = bitcast %82
-    %84:u32 = add 16u, %start_byte_offset_3
-    %85:u32 = div %84, 16u
-    %86:ptr<uniform, vec4<u32>, read> = access %a, %85
-    %87:vec4<u32> = load %86
-    %88:vec4<f16> = bitcast %87
-    %89:mat3x4<f16> = construct %78, %83, %88
-    ret %89
-  }
+
+Outer v_14(uint start_byte_offset) {
+  Inner v_15[4] = v_9(start_byte_offset);
+  Outer v_16 = {v_15};
+  return v_16;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat3x4<f16>(vec4<f16>(0.0h))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %93:bool = gte %idx_1, 4u
-        if %93 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %94:u32 = mul %idx_1, 256u
-        %95:u32 = add %start_byte_offset_4, %94
-        %96:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %97:Outer = call %21, %95
-        store %96, %97
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_17(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_18 = 0u;
+    v_18 = 0u;
+    while(true) {
+      uint v_19 = v_18;
+      if ((v_19 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %98:u32 = add %idx_1, 1u
-        next_iteration %98  # -> $B14
+      Outer v_20 = v_14((start_byte_offset + (v_19 * 256u)));
+      a[v_19] = v_20;
+      {
+        v_18 = (v_19 + 1u);
       }
+      continue;
     }
-    %99:array<Outer, 4> = load %a_2
-    ret %99
   }
+  Outer v_21[4] = a;
+  return v_21;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_22 = (256u * uint(i()));
+  uint v_23 = (64u * uint(i()));
+  uint v_24 = (8u * uint(i()));
+  Outer l_a[4] = v_17(0u);
+  Outer l_a_i = v_14(v_22);
+  Inner l_a_i_a[4] = v_9(v_22);
+  Inner l_a_i_a_i = v_7((v_22 + v_23));
+  matrix<float16_t, 3, 4> l_a_i_a_i_m = v_4((v_22 + v_23));
+  vector<float16_t, 4> l_a_i_a_i_m_i = tint_bitcast_to_f16(a[(((v_22 + v_23) + v_24) / 16u)]);
+  uint v_25 = (((v_22 + v_23) + v_24) + (uint(i()) * 2u));
+  uint v_26 = a[(v_25 / 16u)][((v_25 % 16u) / 4u)];
+  float16_t l_a_i_a_i_m_i_i = float16_t(f16tof32((v_26 >> ((((v_25 % 4u) == 0u)) ? (0u) : (16u)))));
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat3x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat3x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index 631a20b7453..9a27854403b 100644
--- a/test/tint/buffer/uniform/std140/struct/mat3x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat3x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,230 +1,96 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat3x4<f32>,
-}
+  float3x4 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat3x4<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec4<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :54:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %42:u32 = mul %41, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(16) {
-  m:mat3x4<f32> @offset(0)
+float3x4 v(uint start_byte_offset) {
+  float4 v_1 = asfloat(a[(start_byte_offset / 16u)]);
+  float4 v_2 = asfloat(a[((16u + start_byte_offset) / 16u)]);
+  return float3x4(v_1, v_2, asfloat(a[((32u + start_byte_offset) / 16u)]));
 }
 
-Outer = struct @align(16) {
-  a:array<Inner, 4> @offset(0)
+Inner v_3(uint start_byte_offset) {
+  Inner v_4 = {v(start_byte_offset)};
+  return v_4;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 16u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat3x4<f32> = call %32, %30
-    %l_a_i_a_i_m:mat3x4<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec4<f32> = bitcast %38
-    %l_a_i_a_i_m_i:vec4<f32> = let %39
-    %41:i32 = call %i
-    %42:u32 = mul %41, 4u
-    %43:u32 = add %10, %13
-    %44:u32 = add %43, %16
-    %45:u32 = add %44, %42
-    %46:u32 = div %45, 16u
-    %47:ptr<uniform, vec4<u32>, read> = access %a, %46
-    %48:u32 = mod %45, 16u
-    %49:u32 = div %48, 4u
-    %50:u32 = load_vector_element %47, %49
-    %51:f32 = bitcast %50
-    %l_a_i_a_i_m_i_i:f32 = let %51
-    ret
-  }
-}
-%21 = func(%start_byte_offset:u32):Outer {
-  $B4: {
-    %54:array<Inner, 4> = call %24, %start_byte_offset
-    %55:Outer = construct %54
-    ret %55
-  }
-}
-%24 = func(%start_byte_offset_1:u32):array<Inner, 4> {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat3x4<f32>(vec4<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B6, b: $B7, c: $B8] {  # loop_1
-      $B6: {  # initializer
-        next_iteration 0u  # -> $B7
-      }
-      $B7 (%idx:u32): {  # body
-        %59:bool = gte %idx, 4u
-        if %59 [t: $B9] {  # if_1
-          $B9: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %60:u32 = mul %idx, 64u
-        %61:u32 = add %start_byte_offset_1, %60
-        %62:ptr<function, Inner, read_write> = access %a_1, %idx
-        %63:Inner = call %28, %61
-        store %62, %63
-        continue  # -> $B8
+typedef Inner ary_ret[4];
+ary_ret v_5(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_6 = 0u;
+    v_6 = 0u;
+    while(true) {
+      uint v_7 = v_6;
+      if ((v_7 >= 4u)) {
+        break;
       }
-      $B8: {  # continuing
-        %64:u32 = add %idx, 1u
-        next_iteration %64  # -> $B7
+      Inner v_8 = v_3((start_byte_offset + (v_7 * 64u)));
+      a[v_7] = v_8;
+      {
+        v_6 = (v_7 + 1u);
       }
+      continue;
     }
-    %65:array<Inner, 4> = load %a_1
-    ret %65
-  }
-}
-%28 = func(%start_byte_offset_2:u32):Inner {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %67:mat3x4<f32> = call %32, %start_byte_offset_2
-    %68:Inner = construct %67
-    ret %68
   }
+  Inner v_9[4] = a;
+  return v_9;
 }
-%32 = func(%start_byte_offset_3:u32):mat3x4<f32> {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %70:u32 = div %start_byte_offset_3, 16u
-    %71:ptr<uniform, vec4<u32>, read> = access %a, %70
-    %72:vec4<u32> = load %71
-    %73:vec4<f32> = bitcast %72
-    %74:u32 = add 16u, %start_byte_offset_3
-    %75:u32 = div %74, 16u
-    %76:ptr<uniform, vec4<u32>, read> = access %a, %75
-    %77:vec4<u32> = load %76
-    %78:vec4<f32> = bitcast %77
-    %79:u32 = add 32u, %start_byte_offset_3
-    %80:u32 = div %79, 16u
-    %81:ptr<uniform, vec4<u32>, read> = access %a, %80
-    %82:vec4<u32> = load %81
-    %83:vec4<f32> = bitcast %82
-    %84:mat3x4<f32> = construct %73, %78, %83
-    ret %84
-  }
+
+Outer v_10(uint start_byte_offset) {
+  Inner v_11[4] = v_5(start_byte_offset);
+  Outer v_12 = {v_11};
+  return v_12;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat3x4<f32>(vec4<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %88:bool = gte %idx_1, 4u
-        if %88 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %89:u32 = mul %idx_1, 256u
-        %90:u32 = add %start_byte_offset_4, %89
-        %91:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %92:Outer = call %21, %90
-        store %91, %92
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_13(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_14 = 0u;
+    v_14 = 0u;
+    while(true) {
+      uint v_15 = v_14;
+      if ((v_15 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %93:u32 = add %idx_1, 1u
-        next_iteration %93  # -> $B14
+      Outer v_16 = v_10((start_byte_offset + (v_15 * 256u)));
+      a[v_15] = v_16;
+      {
+        v_14 = (v_15 + 1u);
       }
+      continue;
     }
-    %94:array<Outer, 4> = load %a_2
-    ret %94
   }
+  Outer v_17[4] = a;
+  return v_17;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_18 = (256u * uint(i()));
+  uint v_19 = (64u * uint(i()));
+  uint v_20 = (16u * uint(i()));
+  Outer l_a[4] = v_13(0u);
+  Outer l_a_i = v_10(v_18);
+  Inner l_a_i_a[4] = v_5(v_18);
+  Inner l_a_i_a_i = v_3((v_18 + v_19));
+  float3x4 l_a_i_a_i_m = v((v_18 + v_19));
+  float4 l_a_i_a_i_m_i = asfloat(a[(((v_18 + v_19) + v_20) / 16u)]);
+  uint v_21 = (((v_18 + v_19) + v_20) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_21 / 16u)][((v_21 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat3x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat3x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
index 631a20b7453..9a27854403b 100644
--- a/test/tint/buffer/uniform/std140/struct/mat3x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat3x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
@@ -1,230 +1,96 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat3x4<f32>,
-}
+  float3x4 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat3x4<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec4<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :54:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %42:u32 = mul %41, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(16) {
-  m:mat3x4<f32> @offset(0)
+float3x4 v(uint start_byte_offset) {
+  float4 v_1 = asfloat(a[(start_byte_offset / 16u)]);
+  float4 v_2 = asfloat(a[((16u + start_byte_offset) / 16u)]);
+  return float3x4(v_1, v_2, asfloat(a[((32u + start_byte_offset) / 16u)]));
 }
 
-Outer = struct @align(16) {
-  a:array<Inner, 4> @offset(0)
+Inner v_3(uint start_byte_offset) {
+  Inner v_4 = {v(start_byte_offset)};
+  return v_4;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 16u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat3x4<f32> = call %32, %30
-    %l_a_i_a_i_m:mat3x4<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec4<f32> = bitcast %38
-    %l_a_i_a_i_m_i:vec4<f32> = let %39
-    %41:i32 = call %i
-    %42:u32 = mul %41, 4u
-    %43:u32 = add %10, %13
-    %44:u32 = add %43, %16
-    %45:u32 = add %44, %42
-    %46:u32 = div %45, 16u
-    %47:ptr<uniform, vec4<u32>, read> = access %a, %46
-    %48:u32 = mod %45, 16u
-    %49:u32 = div %48, 4u
-    %50:u32 = load_vector_element %47, %49
-    %51:f32 = bitcast %50
-    %l_a_i_a_i_m_i_i:f32 = let %51
-    ret
-  }
-}
-%21 = func(%start_byte_offset:u32):Outer {
-  $B4: {
-    %54:array<Inner, 4> = call %24, %start_byte_offset
-    %55:Outer = construct %54
-    ret %55
-  }
-}
-%24 = func(%start_byte_offset_1:u32):array<Inner, 4> {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat3x4<f32>(vec4<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B6, b: $B7, c: $B8] {  # loop_1
-      $B6: {  # initializer
-        next_iteration 0u  # -> $B7
-      }
-      $B7 (%idx:u32): {  # body
-        %59:bool = gte %idx, 4u
-        if %59 [t: $B9] {  # if_1
-          $B9: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %60:u32 = mul %idx, 64u
-        %61:u32 = add %start_byte_offset_1, %60
-        %62:ptr<function, Inner, read_write> = access %a_1, %idx
-        %63:Inner = call %28, %61
-        store %62, %63
-        continue  # -> $B8
+typedef Inner ary_ret[4];
+ary_ret v_5(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_6 = 0u;
+    v_6 = 0u;
+    while(true) {
+      uint v_7 = v_6;
+      if ((v_7 >= 4u)) {
+        break;
       }
-      $B8: {  # continuing
-        %64:u32 = add %idx, 1u
-        next_iteration %64  # -> $B7
+      Inner v_8 = v_3((start_byte_offset + (v_7 * 64u)));
+      a[v_7] = v_8;
+      {
+        v_6 = (v_7 + 1u);
       }
+      continue;
     }
-    %65:array<Inner, 4> = load %a_1
-    ret %65
-  }
-}
-%28 = func(%start_byte_offset_2:u32):Inner {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %67:mat3x4<f32> = call %32, %start_byte_offset_2
-    %68:Inner = construct %67
-    ret %68
   }
+  Inner v_9[4] = a;
+  return v_9;
 }
-%32 = func(%start_byte_offset_3:u32):mat3x4<f32> {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %70:u32 = div %start_byte_offset_3, 16u
-    %71:ptr<uniform, vec4<u32>, read> = access %a, %70
-    %72:vec4<u32> = load %71
-    %73:vec4<f32> = bitcast %72
-    %74:u32 = add 16u, %start_byte_offset_3
-    %75:u32 = div %74, 16u
-    %76:ptr<uniform, vec4<u32>, read> = access %a, %75
-    %77:vec4<u32> = load %76
-    %78:vec4<f32> = bitcast %77
-    %79:u32 = add 32u, %start_byte_offset_3
-    %80:u32 = div %79, 16u
-    %81:ptr<uniform, vec4<u32>, read> = access %a, %80
-    %82:vec4<u32> = load %81
-    %83:vec4<f32> = bitcast %82
-    %84:mat3x4<f32> = construct %73, %78, %83
-    ret %84
-  }
+
+Outer v_10(uint start_byte_offset) {
+  Inner v_11[4] = v_5(start_byte_offset);
+  Outer v_12 = {v_11};
+  return v_12;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat3x4<f32>(vec4<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %88:bool = gte %idx_1, 4u
-        if %88 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %89:u32 = mul %idx_1, 256u
-        %90:u32 = add %start_byte_offset_4, %89
-        %91:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %92:Outer = call %21, %90
-        store %91, %92
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_13(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_14 = 0u;
+    v_14 = 0u;
+    while(true) {
+      uint v_15 = v_14;
+      if ((v_15 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %93:u32 = add %idx_1, 1u
-        next_iteration %93  # -> $B14
+      Outer v_16 = v_10((start_byte_offset + (v_15 * 256u)));
+      a[v_15] = v_16;
+      {
+        v_14 = (v_15 + 1u);
       }
+      continue;
     }
-    %94:array<Outer, 4> = load %a_2
-    ret %94
   }
+  Outer v_17[4] = a;
+  return v_17;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_18 = (256u * uint(i()));
+  uint v_19 = (64u * uint(i()));
+  uint v_20 = (16u * uint(i()));
+  Outer l_a[4] = v_13(0u);
+  Outer l_a_i = v_10(v_18);
+  Inner l_a_i_a[4] = v_5(v_18);
+  Inner l_a_i_a_i = v_3((v_18 + v_19));
+  float3x4 l_a_i_a_i_m = v((v_18 + v_19));
+  float4 l_a_i_a_i_m_i = asfloat(a[(((v_18 + v_19) + v_20) / 16u)]);
+  uint v_21 = (((v_18 + v_19) + v_20) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_21 / 16u)][((v_21 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat4x2_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index 074becf5e79..5cbe187b592 100644
--- a/test/tint/buffer/uniform/std140/struct/mat4x2_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat4x2_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,272 +1,111 @@
-SKIP: FAILED
-
-
-enable f16;
-
 struct Inner {
-  @size(64)
-  m : mat4x2<f16>,
-}
+  matrix<float16_t, 4, 2> m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
+  Inner a[4];
+};
 
-var<private> counter = 0;
 
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat4x2<f16> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec2<f16> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f16 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :60:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %48:u32 = mul %47, 2u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(4) {
-  m:mat4x2<f16> @offset(0)
+vector<float16_t, 2> tint_bitcast_to_f16(uint src) {
+  uint v = src;
+  float t_low = f16tof32((v & 65535u));
+  float t_high = f16tof32(((v >> 16u) & 65535u));
+  float16_t v_1 = float16_t(t_low);
+  return vector<float16_t, 2>(v_1, float16_t(t_high));
 }
 
-Outer = struct @align(4) {
-  a:array<Inner, 4> @offset(0)
+matrix<float16_t, 4, 2> v_2(uint start_byte_offset) {
+  uint4 v_3 = a[(start_byte_offset / 16u)];
+  vector<float16_t, 2> v_4 = tint_bitcast_to_f16((((((start_byte_offset % 16u) / 4u) == 2u)) ? (v_3.z) : (v_3.x)));
+  uint4 v_5 = a[((4u + start_byte_offset) / 16u)];
+  vector<float16_t, 2> v_6 = tint_bitcast_to_f16(((((((4u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_5.z) : (v_5.x)));
+  uint4 v_7 = a[((8u + start_byte_offset) / 16u)];
+  vector<float16_t, 2> v_8 = tint_bitcast_to_f16(((((((8u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_7.z) : (v_7.x)));
+  uint4 v_9 = a[((12u + start_byte_offset) / 16u)];
+  return matrix<float16_t, 4, 2>(v_4, v_6, v_8, tint_bitcast_to_f16(((((((12u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_9.z) : (v_9.x))));
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
+Inner v_10(uint start_byte_offset) {
+  Inner v_11 = {v_2(start_byte_offset)};
+  return v_11;
 }
 
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 4u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat4x2<f16> = call %32, %30
-    %l_a_i_a_i_m:mat4x2<f16> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:u32 = mod %35, 16u
-    %39:u32 = div %38, 4u
-    %40:vec4<u32> = load %37
-    %41:u32 = swizzle %40, z
-    %42:u32 = swizzle %40, x
-    %43:bool = eq %39, 2u
-    %44:u32 = hlsl.ternary %42, %41, %43
-    %45:vec2<f16> = bitcast %44
-    %l_a_i_a_i_m_i:vec2<f16> = let %45
-    %47:i32 = call %i
-    %48:u32 = mul %47, 2u
-    %49:u32 = add %10, %13
-    %50:u32 = add %49, %16
-    %51:u32 = add %50, %48
-    %52:u32 = div %51, 16u
-    %53:ptr<uniform, vec4<u32>, read> = access %a, %52
-    %54:u32 = mod %51, 16u
-    %55:u32 = div %54, 4u
-    %56:u32 = load_vector_element %53, %55
-    %57:u32 = mod %51, 4u
-    %58:bool = eq %57, 0u
-    %59:u32 = hlsl.ternary 16u, 0u, %58
-    %60:u32 = shr %56, %59
-    %61:f32 = hlsl.f16tof32 %60
-    %62:f16 = convert %61
-    %l_a_i_a_i_m_i_i:f16 = let %62
-    ret
-  }
-}
-%24 = func(%start_byte_offset:u32):array<Inner, 4> {
-  $B4: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat4x2<f16>(vec2<f16>(0.0h))))  # %a_1: 'a'
-    loop [i: $B5, b: $B6, c: $B7] {  # loop_1
-      $B5: {  # initializer
-        next_iteration 0u  # -> $B6
+typedef Inner ary_ret[4];
+ary_ret v_12(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_13 = 0u;
+    v_13 = 0u;
+    while(true) {
+      uint v_14 = v_13;
+      if ((v_14 >= 4u)) {
+        break;
       }
-      $B6 (%idx:u32): {  # body
-        %67:bool = gte %idx, 4u
-        if %67 [t: $B8] {  # if_1
-          $B8: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %68:u32 = mul %idx, 64u
-        %69:u32 = add %start_byte_offset, %68
-        %70:ptr<function, Inner, read_write> = access %a_1, %idx
-        %71:Inner = call %28, %69
-        store %70, %71
-        continue  # -> $B7
-      }
-      $B7: {  # continuing
-        %72:u32 = add %idx, 1u
-        next_iteration %72  # -> $B6
+      Inner v_15 = v_10((start_byte_offset + (v_14 * 64u)));
+      a[v_14] = v_15;
+      {
+        v_13 = (v_14 + 1u);
       }
+      continue;
     }
-    %73:array<Inner, 4> = load %a_1
-    ret %73
-  }
-}
-%28 = func(%start_byte_offset_1:u32):Inner {  # %start_byte_offset_1: 'start_byte_offset'
-  $B9: {
-    %75:mat4x2<f16> = call %32, %start_byte_offset_1
-    %76:Inner = construct %75
-    ret %76
-  }
-}
-%32 = func(%start_byte_offset_2:u32):mat4x2<f16> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %78:u32 = div %start_byte_offset_2, 16u
-    %79:ptr<uniform, vec4<u32>, read> = access %a, %78
-    %80:u32 = mod %start_byte_offset_2, 16u
-    %81:u32 = div %80, 4u
-    %82:vec4<u32> = load %79
-    %83:u32 = swizzle %82, z
-    %84:u32 = swizzle %82, x
-    %85:bool = eq %81, 2u
-    %86:u32 = hlsl.ternary %84, %83, %85
-    %87:vec2<f16> = bitcast %86
-    %88:u32 = add 4u, %start_byte_offset_2
-    %89:u32 = div %88, 16u
-    %90:ptr<uniform, vec4<u32>, read> = access %a, %89
-    %91:u32 = mod %88, 16u
-    %92:u32 = div %91, 4u
-    %93:vec4<u32> = load %90
-    %94:u32 = swizzle %93, z
-    %95:u32 = swizzle %93, x
-    %96:bool = eq %92, 2u
-    %97:u32 = hlsl.ternary %95, %94, %96
-    %98:vec2<f16> = bitcast %97
-    %99:u32 = add 8u, %start_byte_offset_2
-    %100:u32 = div %99, 16u
-    %101:ptr<uniform, vec4<u32>, read> = access %a, %100
-    %102:u32 = mod %99, 16u
-    %103:u32 = div %102, 4u
-    %104:vec4<u32> = load %101
-    %105:u32 = swizzle %104, z
-    %106:u32 = swizzle %104, x
-    %107:bool = eq %103, 2u
-    %108:u32 = hlsl.ternary %106, %105, %107
-    %109:vec2<f16> = bitcast %108
-    %110:u32 = add 12u, %start_byte_offset_2
-    %111:u32 = div %110, 16u
-    %112:ptr<uniform, vec4<u32>, read> = access %a, %111
-    %113:u32 = mod %110, 16u
-    %114:u32 = div %113, 4u
-    %115:vec4<u32> = load %112
-    %116:u32 = swizzle %115, z
-    %117:u32 = swizzle %115, x
-    %118:bool = eq %114, 2u
-    %119:u32 = hlsl.ternary %117, %116, %118
-    %120:vec2<f16> = bitcast %119
-    %121:mat4x2<f16> = construct %87, %98, %109, %120
-    ret %121
   }
+  Inner v_16[4] = a;
+  return v_16;
 }
-%21 = func(%start_byte_offset_3:u32):Outer {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %123:array<Inner, 4> = call %24, %start_byte_offset_3
-    %124:Outer = construct %123
-    ret %124
-  }
+
+Outer v_17(uint start_byte_offset) {
+  Inner v_18[4] = v_12(start_byte_offset);
+  Outer v_19 = {v_18};
+  return v_19;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat4x2<f16>(vec2<f16>(0.0h))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %128:bool = gte %idx_1, 4u
-        if %128 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %129:u32 = mul %idx_1, 256u
-        %130:u32 = add %start_byte_offset_4, %129
-        %131:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %132:Outer = call %21, %130
-        store %131, %132
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_20(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_21 = 0u;
+    v_21 = 0u;
+    while(true) {
+      uint v_22 = v_21;
+      if ((v_22 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %133:u32 = add %idx_1, 1u
-        next_iteration %133  # -> $B14
+      Outer v_23 = v_17((start_byte_offset + (v_22 * 256u)));
+      a[v_22] = v_23;
+      {
+        v_21 = (v_22 + 1u);
       }
+      continue;
     }
-    %134:array<Outer, 4> = load %a_2
-    ret %134
   }
+  Outer v_24[4] = a;
+  return v_24;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_25 = (256u * uint(i()));
+  uint v_26 = (64u * uint(i()));
+  uint v_27 = (4u * uint(i()));
+  Outer l_a[4] = v_20(0u);
+  Outer l_a_i = v_17(v_25);
+  Inner l_a_i_a[4] = v_12(v_25);
+  Inner l_a_i_a_i = v_10((v_25 + v_26));
+  matrix<float16_t, 4, 2> l_a_i_a_i_m = v_2((v_25 + v_26));
+  uint4 v_28 = a[(((v_25 + v_26) + v_27) / 16u)];
+  vector<float16_t, 2> l_a_i_a_i_m_i = tint_bitcast_to_f16((((((((v_25 + v_26) + v_27) % 16u) / 4u) == 2u)) ? (v_28.z) : (v_28.x)));
+  uint v_29 = (((v_25 + v_26) + v_27) + (uint(i()) * 2u));
+  uint v_30 = a[(v_29 / 16u)][((v_29 % 16u) / 4u)];
+  float16_t l_a_i_a_i_m_i_i = float16_t(f16tof32((v_30 >> ((((v_29 % 4u) == 0u)) ? (0u) : (16u)))));
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat4x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index fba081a8d4d..533ddd0f5ac 100644
--- a/test/tint/buffer/uniform/std140/struct/mat4x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat4x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,265 +1,102 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat4x2<f32>,
-}
+  float4x2 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat4x2<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec2<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :60:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %48:u32 = mul %47, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(8) {
-  m:mat4x2<f32> @offset(0)
+float4x2 v(uint start_byte_offset) {
+  uint4 v_1 = a[(start_byte_offset / 16u)];
+  float2 v_2 = asfloat((((((start_byte_offset % 16u) / 4u) == 2u)) ? (v_1.zw) : (v_1.xy)));
+  uint4 v_3 = a[((8u + start_byte_offset) / 16u)];
+  float2 v_4 = asfloat(((((((8u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_3.zw) : (v_3.xy)));
+  uint4 v_5 = a[((16u + start_byte_offset) / 16u)];
+  float2 v_6 = asfloat(((((((16u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_5.zw) : (v_5.xy)));
+  uint4 v_7 = a[((24u + start_byte_offset) / 16u)];
+  return float4x2(v_2, v_4, v_6, asfloat(((((((24u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_7.zw) : (v_7.xy))));
 }
 
-Outer = struct @align(8) {
-  a:array<Inner, 4> @offset(0)
+Inner v_8(uint start_byte_offset) {
+  Inner v_9 = {v(start_byte_offset)};
+  return v_9;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 8u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat4x2<f32> = call %32, %30
-    %l_a_i_a_i_m:mat4x2<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:u32 = mod %35, 16u
-    %39:u32 = div %38, 4u
-    %40:vec4<u32> = load %37
-    %41:vec2<u32> = swizzle %40, zw
-    %42:vec2<u32> = swizzle %40, xy
-    %43:bool = eq %39, 2u
-    %44:vec2<u32> = hlsl.ternary %42, %41, %43
-    %45:vec2<f32> = bitcast %44
-    %l_a_i_a_i_m_i:vec2<f32> = let %45
-    %47:i32 = call %i
-    %48:u32 = mul %47, 4u
-    %49:u32 = add %10, %13
-    %50:u32 = add %49, %16
-    %51:u32 = add %50, %48
-    %52:u32 = div %51, 16u
-    %53:ptr<uniform, vec4<u32>, read> = access %a, %52
-    %54:u32 = mod %51, 16u
-    %55:u32 = div %54, 4u
-    %56:u32 = load_vector_element %53, %55
-    %57:f32 = bitcast %56
-    %l_a_i_a_i_m_i_i:f32 = let %57
-    ret
-  }
-}
-%28 = func(%start_byte_offset:u32):Inner {
-  $B4: {
-    %60:mat4x2<f32> = call %32, %start_byte_offset
-    %61:Inner = construct %60
-    ret %61
-  }
-}
-%32 = func(%start_byte_offset_1:u32):mat4x2<f32> {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %63:u32 = div %start_byte_offset_1, 16u
-    %64:ptr<uniform, vec4<u32>, read> = access %a, %63
-    %65:u32 = mod %start_byte_offset_1, 16u
-    %66:u32 = div %65, 4u
-    %67:vec4<u32> = load %64
-    %68:vec2<u32> = swizzle %67, zw
-    %69:vec2<u32> = swizzle %67, xy
-    %70:bool = eq %66, 2u
-    %71:vec2<u32> = hlsl.ternary %69, %68, %70
-    %72:vec2<f32> = bitcast %71
-    %73:u32 = add 8u, %start_byte_offset_1
-    %74:u32 = div %73, 16u
-    %75:ptr<uniform, vec4<u32>, read> = access %a, %74
-    %76:u32 = mod %73, 16u
-    %77:u32 = div %76, 4u
-    %78:vec4<u32> = load %75
-    %79:vec2<u32> = swizzle %78, zw
-    %80:vec2<u32> = swizzle %78, xy
-    %81:bool = eq %77, 2u
-    %82:vec2<u32> = hlsl.ternary %80, %79, %81
-    %83:vec2<f32> = bitcast %82
-    %84:u32 = add 16u, %start_byte_offset_1
-    %85:u32 = div %84, 16u
-    %86:ptr<uniform, vec4<u32>, read> = access %a, %85
-    %87:u32 = mod %84, 16u
-    %88:u32 = div %87, 4u
-    %89:vec4<u32> = load %86
-    %90:vec2<u32> = swizzle %89, zw
-    %91:vec2<u32> = swizzle %89, xy
-    %92:bool = eq %88, 2u
-    %93:vec2<u32> = hlsl.ternary %91, %90, %92
-    %94:vec2<f32> = bitcast %93
-    %95:u32 = add 24u, %start_byte_offset_1
-    %96:u32 = div %95, 16u
-    %97:ptr<uniform, vec4<u32>, read> = access %a, %96
-    %98:u32 = mod %95, 16u
-    %99:u32 = div %98, 4u
-    %100:vec4<u32> = load %97
-    %101:vec2<u32> = swizzle %100, zw
-    %102:vec2<u32> = swizzle %100, xy
-    %103:bool = eq %99, 2u
-    %104:vec2<u32> = hlsl.ternary %102, %101, %103
-    %105:vec2<f32> = bitcast %104
-    %106:mat4x2<f32> = construct %72, %83, %94, %105
-    ret %106
-  }
-}
-%24 = func(%start_byte_offset_2:u32):array<Inner, 4> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B6: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat4x2<f32>(vec2<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B7, b: $B8, c: $B9] {  # loop_1
-      $B7: {  # initializer
-        next_iteration 0u  # -> $B8
+typedef Inner ary_ret[4];
+ary_ret v_10(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_11 = 0u;
+    v_11 = 0u;
+    while(true) {
+      uint v_12 = v_11;
+      if ((v_12 >= 4u)) {
+        break;
       }
-      $B8 (%idx:u32): {  # body
-        %110:bool = gte %idx, 4u
-        if %110 [t: $B10] {  # if_1
-          $B10: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %111:u32 = mul %idx, 64u
-        %112:u32 = add %start_byte_offset_2, %111
-        %113:ptr<function, Inner, read_write> = access %a_1, %idx
-        %114:Inner = call %28, %112
-        store %113, %114
-        continue  # -> $B9
-      }
-      $B9: {  # continuing
-        %115:u32 = add %idx, 1u
-        next_iteration %115  # -> $B8
+      Inner v_13 = v_8((start_byte_offset + (v_12 * 64u)));
+      a[v_12] = v_13;
+      {
+        v_11 = (v_12 + 1u);
       }
+      continue;
     }
-    %116:array<Inner, 4> = load %a_1
-    ret %116
   }
+  Inner v_14[4] = a;
+  return v_14;
 }
-%21 = func(%start_byte_offset_3:u32):Outer {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %118:array<Inner, 4> = call %24, %start_byte_offset_3
-    %119:Outer = construct %118
-    ret %119
-  }
+
+Outer v_15(uint start_byte_offset) {
+  Inner v_16[4] = v_10(start_byte_offset);
+  Outer v_17 = {v_16};
+  return v_17;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat4x2<f32>(vec2<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %123:bool = gte %idx_1, 4u
-        if %123 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %124:u32 = mul %idx_1, 256u
-        %125:u32 = add %start_byte_offset_4, %124
-        %126:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %127:Outer = call %21, %125
-        store %126, %127
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_18(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_19 = 0u;
+    v_19 = 0u;
+    while(true) {
+      uint v_20 = v_19;
+      if ((v_20 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %128:u32 = add %idx_1, 1u
-        next_iteration %128  # -> $B14
+      Outer v_21 = v_15((start_byte_offset + (v_20 * 256u)));
+      a[v_20] = v_21;
+      {
+        v_19 = (v_20 + 1u);
       }
+      continue;
     }
-    %129:array<Outer, 4> = load %a_2
-    ret %129
   }
+  Outer v_22[4] = a;
+  return v_22;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_23 = (256u * uint(i()));
+  uint v_24 = (64u * uint(i()));
+  uint v_25 = (8u * uint(i()));
+  Outer l_a[4] = v_18(0u);
+  Outer l_a_i = v_15(v_23);
+  Inner l_a_i_a[4] = v_10(v_23);
+  Inner l_a_i_a_i = v_8((v_23 + v_24));
+  float4x2 l_a_i_a_i_m = v((v_23 + v_24));
+  uint4 v_26 = a[(((v_23 + v_24) + v_25) / 16u)];
+  float2 l_a_i_a_i_m_i = asfloat((((((((v_23 + v_24) + v_25) % 16u) / 4u) == 2u)) ? (v_26.zw) : (v_26.xy)));
+  uint v_27 = (((v_23 + v_24) + v_25) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_27 / 16u)][((v_27 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat4x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat4x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
index fa3d49feea2..533ddd0f5ac 100644
--- a/test/tint/buffer/uniform/std140/struct/mat4x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat4x2_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
@@ -1,265 +1,102 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat4x2<f32>,
-}
+  float4x2 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat4x2<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec2<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :60:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %48:u32 = mul %47, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(8) {
-  m:mat4x2<f32> @offset(0)
+float4x2 v(uint start_byte_offset) {
+  uint4 v_1 = a[(start_byte_offset / 16u)];
+  float2 v_2 = asfloat((((((start_byte_offset % 16u) / 4u) == 2u)) ? (v_1.zw) : (v_1.xy)));
+  uint4 v_3 = a[((8u + start_byte_offset) / 16u)];
+  float2 v_4 = asfloat(((((((8u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_3.zw) : (v_3.xy)));
+  uint4 v_5 = a[((16u + start_byte_offset) / 16u)];
+  float2 v_6 = asfloat(((((((16u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_5.zw) : (v_5.xy)));
+  uint4 v_7 = a[((24u + start_byte_offset) / 16u)];
+  return float4x2(v_2, v_4, v_6, asfloat(((((((24u + start_byte_offset) % 16u) / 4u) == 2u)) ? (v_7.zw) : (v_7.xy))));
 }
 
-Outer = struct @align(8) {
-  a:array<Inner, 4> @offset(0)
+Inner v_8(uint start_byte_offset) {
+  Inner v_9 = {v(start_byte_offset)};
+  return v_9;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 8u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat4x2<f32> = call %32, %30
-    %l_a_i_a_i_m:mat4x2<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:u32 = mod %35, 16u
-    %39:u32 = div %38, 4u
-    %40:vec4<u32> = load %37
-    %41:vec2<u32> = swizzle %40, zw
-    %42:vec2<u32> = swizzle %40, xy
-    %43:bool = eq %39, 2u
-    %44:vec2<u32> = hlsl.ternary %42, %41, %43
-    %45:vec2<f32> = bitcast %44
-    %l_a_i_a_i_m_i:vec2<f32> = let %45
-    %47:i32 = call %i
-    %48:u32 = mul %47, 4u
-    %49:u32 = add %10, %13
-    %50:u32 = add %49, %16
-    %51:u32 = add %50, %48
-    %52:u32 = div %51, 16u
-    %53:ptr<uniform, vec4<u32>, read> = access %a, %52
-    %54:u32 = mod %51, 16u
-    %55:u32 = div %54, 4u
-    %56:u32 = load_vector_element %53, %55
-    %57:f32 = bitcast %56
-    %l_a_i_a_i_m_i_i:f32 = let %57
-    ret
-  }
-}
-%32 = func(%start_byte_offset:u32):mat4x2<f32> {
-  $B4: {
-    %60:u32 = div %start_byte_offset, 16u
-    %61:ptr<uniform, vec4<u32>, read> = access %a, %60
-    %62:u32 = mod %start_byte_offset, 16u
-    %63:u32 = div %62, 4u
-    %64:vec4<u32> = load %61
-    %65:vec2<u32> = swizzle %64, zw
-    %66:vec2<u32> = swizzle %64, xy
-    %67:bool = eq %63, 2u
-    %68:vec2<u32> = hlsl.ternary %66, %65, %67
-    %69:vec2<f32> = bitcast %68
-    %70:u32 = add 8u, %start_byte_offset
-    %71:u32 = div %70, 16u
-    %72:ptr<uniform, vec4<u32>, read> = access %a, %71
-    %73:u32 = mod %70, 16u
-    %74:u32 = div %73, 4u
-    %75:vec4<u32> = load %72
-    %76:vec2<u32> = swizzle %75, zw
-    %77:vec2<u32> = swizzle %75, xy
-    %78:bool = eq %74, 2u
-    %79:vec2<u32> = hlsl.ternary %77, %76, %78
-    %80:vec2<f32> = bitcast %79
-    %81:u32 = add 16u, %start_byte_offset
-    %82:u32 = div %81, 16u
-    %83:ptr<uniform, vec4<u32>, read> = access %a, %82
-    %84:u32 = mod %81, 16u
-    %85:u32 = div %84, 4u
-    %86:vec4<u32> = load %83
-    %87:vec2<u32> = swizzle %86, zw
-    %88:vec2<u32> = swizzle %86, xy
-    %89:bool = eq %85, 2u
-    %90:vec2<u32> = hlsl.ternary %88, %87, %89
-    %91:vec2<f32> = bitcast %90
-    %92:u32 = add 24u, %start_byte_offset
-    %93:u32 = div %92, 16u
-    %94:ptr<uniform, vec4<u32>, read> = access %a, %93
-    %95:u32 = mod %92, 16u
-    %96:u32 = div %95, 4u
-    %97:vec4<u32> = load %94
-    %98:vec2<u32> = swizzle %97, zw
-    %99:vec2<u32> = swizzle %97, xy
-    %100:bool = eq %96, 2u
-    %101:vec2<u32> = hlsl.ternary %99, %98, %100
-    %102:vec2<f32> = bitcast %101
-    %103:mat4x2<f32> = construct %69, %80, %91, %102
-    ret %103
-  }
-}
-%28 = func(%start_byte_offset_1:u32):Inner {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %105:mat4x2<f32> = call %32, %start_byte_offset_1
-    %106:Inner = construct %105
-    ret %106
-  }
-}
-%24 = func(%start_byte_offset_2:u32):array<Inner, 4> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B6: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat4x2<f32>(vec2<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B7, b: $B8, c: $B9] {  # loop_1
-      $B7: {  # initializer
-        next_iteration 0u  # -> $B8
+typedef Inner ary_ret[4];
+ary_ret v_10(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_11 = 0u;
+    v_11 = 0u;
+    while(true) {
+      uint v_12 = v_11;
+      if ((v_12 >= 4u)) {
+        break;
       }
-      $B8 (%idx:u32): {  # body
-        %110:bool = gte %idx, 4u
-        if %110 [t: $B10] {  # if_1
-          $B10: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %111:u32 = mul %idx, 64u
-        %112:u32 = add %start_byte_offset_2, %111
-        %113:ptr<function, Inner, read_write> = access %a_1, %idx
-        %114:Inner = call %28, %112
-        store %113, %114
-        continue  # -> $B9
-      }
-      $B9: {  # continuing
-        %115:u32 = add %idx, 1u
-        next_iteration %115  # -> $B8
+      Inner v_13 = v_8((start_byte_offset + (v_12 * 64u)));
+      a[v_12] = v_13;
+      {
+        v_11 = (v_12 + 1u);
       }
+      continue;
     }
-    %116:array<Inner, 4> = load %a_1
-    ret %116
   }
+  Inner v_14[4] = a;
+  return v_14;
 }
-%21 = func(%start_byte_offset_3:u32):Outer {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %118:array<Inner, 4> = call %24, %start_byte_offset_3
-    %119:Outer = construct %118
-    ret %119
-  }
+
+Outer v_15(uint start_byte_offset) {
+  Inner v_16[4] = v_10(start_byte_offset);
+  Outer v_17 = {v_16};
+  return v_17;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat4x2<f32>(vec2<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %123:bool = gte %idx_1, 4u
-        if %123 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %124:u32 = mul %idx_1, 256u
-        %125:u32 = add %start_byte_offset_4, %124
-        %126:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %127:Outer = call %21, %125
-        store %126, %127
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_18(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_19 = 0u;
+    v_19 = 0u;
+    while(true) {
+      uint v_20 = v_19;
+      if ((v_20 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %128:u32 = add %idx_1, 1u
-        next_iteration %128  # -> $B14
+      Outer v_21 = v_15((start_byte_offset + (v_20 * 256u)));
+      a[v_20] = v_21;
+      {
+        v_19 = (v_20 + 1u);
       }
+      continue;
     }
-    %129:array<Outer, 4> = load %a_2
-    ret %129
   }
+  Outer v_22[4] = a;
+  return v_22;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_23 = (256u * uint(i()));
+  uint v_24 = (64u * uint(i()));
+  uint v_25 = (8u * uint(i()));
+  Outer l_a[4] = v_18(0u);
+  Outer l_a_i = v_15(v_23);
+  Inner l_a_i_a[4] = v_10(v_23);
+  Inner l_a_i_a_i = v_8((v_23 + v_24));
+  float4x2 l_a_i_a_i_m = v((v_23 + v_24));
+  uint4 v_26 = a[(((v_23 + v_24) + v_25) / 16u)];
+  float2 l_a_i_a_i_m_i = asfloat((((((((v_23 + v_24) + v_25) % 16u) / 4u) == 2u)) ? (v_26.zw) : (v_26.xy)));
+  uint v_27 = (((v_23 + v_24) + v_25) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_27 / 16u)][((v_27 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat4x3_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat4x3_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index a40d7b7a17e..500da46016c 100644
--- a/test/tint/buffer/uniform/std140/struct/mat4x3_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat4x3_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,247 +1,110 @@
-SKIP: FAILED
-
-
-enable f16;
-
 struct Inner {
-  @size(64)
-  m : mat4x3<f16>,
-}
+  matrix<float16_t, 4, 3> m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
+  Inner a[4];
+};
 
-var<private> counter = 0;
 
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat4x3<f16> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec3<f16> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f16 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :55:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %43:u32 = mul %42, 2u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(8) {
-  m:mat4x3<f16> @offset(0)
+vector<float16_t, 4> tint_bitcast_to_f16(uint4 src) {
+  uint4 v = src;
+  uint4 mask = (65535u).xxxx;
+  uint4 shift = (16u).xxxx;
+  float4 t_low = f16tof32((v & mask));
+  float4 t_high = f16tof32(((v >> shift) & mask));
+  float16_t v_1 = float16_t(t_low.x);
+  float16_t v_2 = float16_t(t_high.x);
+  float16_t v_3 = float16_t(t_low.y);
+  return vector<float16_t, 4>(v_1, v_2, v_3, float16_t(t_high.y));
 }
 
-Outer = struct @align(8) {
-  a:array<Inner, 4> @offset(0)
+matrix<float16_t, 4, 3> v_4(uint start_byte_offset) {
+  vector<float16_t, 3> v_5 = tint_bitcast_to_f16(a[(start_byte_offset / 16u)]).xyz;
+  vector<float16_t, 3> v_6 = tint_bitcast_to_f16(a[((8u + start_byte_offset) / 16u)]).xyz;
+  vector<float16_t, 3> v_7 = tint_bitcast_to_f16(a[((16u + start_byte_offset) / 16u)]).xyz;
+  return matrix<float16_t, 4, 3>(v_5, v_6, v_7, tint_bitcast_to_f16(a[((24u + start_byte_offset) / 16u)]).xyz);
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
+Inner v_8(uint start_byte_offset) {
+  Inner v_9 = {v_4(start_byte_offset)};
+  return v_9;
 }
 
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 8u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat4x3<f16> = call %32, %30
-    %l_a_i_a_i_m:mat4x3<f16> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec4<f16> = bitcast %38
-    %40:vec3<f16> = swizzle %39, xyz
-    %l_a_i_a_i_m_i:vec3<f16> = let %40
-    %42:i32 = call %i
-    %43:u32 = mul %42, 2u
-    %44:u32 = add %10, %13
-    %45:u32 = add %44, %16
-    %46:u32 = add %45, %43
-    %47:u32 = div %46, 16u
-    %48:ptr<uniform, vec4<u32>, read> = access %a, %47
-    %49:u32 = mod %46, 16u
-    %50:u32 = div %49, 4u
-    %51:u32 = load_vector_element %48, %50
-    %52:u32 = mod %46, 4u
-    %53:bool = eq %52, 0u
-    %54:u32 = hlsl.ternary 16u, 0u, %53
-    %55:u32 = shr %51, %54
-    %56:f32 = hlsl.f16tof32 %55
-    %57:f16 = convert %56
-    %l_a_i_a_i_m_i_i:f16 = let %57
-    ret
-  }
-}
-%24 = func(%start_byte_offset:u32):array<Inner, 4> {
-  $B4: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat4x3<f16>(vec3<f16>(0.0h))))  # %a_1: 'a'
-    loop [i: $B5, b: $B6, c: $B7] {  # loop_1
-      $B5: {  # initializer
-        next_iteration 0u  # -> $B6
+typedef Inner ary_ret[4];
+ary_ret v_10(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_11 = 0u;
+    v_11 = 0u;
+    while(true) {
+      uint v_12 = v_11;
+      if ((v_12 >= 4u)) {
+        break;
       }
-      $B6 (%idx:u32): {  # body
-        %62:bool = gte %idx, 4u
-        if %62 [t: $B8] {  # if_1
-          $B8: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %63:u32 = mul %idx, 64u
-        %64:u32 = add %start_byte_offset, %63
-        %65:ptr<function, Inner, read_write> = access %a_1, %idx
-        %66:Inner = call %28, %64
-        store %65, %66
-        continue  # -> $B7
-      }
-      $B7: {  # continuing
-        %67:u32 = add %idx, 1u
-        next_iteration %67  # -> $B6
+      Inner v_13 = v_8((start_byte_offset + (v_12 * 64u)));
+      a[v_12] = v_13;
+      {
+        v_11 = (v_12 + 1u);
       }
+      continue;
     }
-    %68:array<Inner, 4> = load %a_1
-    ret %68
-  }
-}
-%28 = func(%start_byte_offset_1:u32):Inner {  # %start_byte_offset_1: 'start_byte_offset'
-  $B9: {
-    %70:mat4x3<f16> = call %32, %start_byte_offset_1
-    %71:Inner = construct %70
-    ret %71
-  }
-}
-%32 = func(%start_byte_offset_2:u32):mat4x3<f16> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %73:u32 = div %start_byte_offset_2, 16u
-    %74:ptr<uniform, vec4<u32>, read> = access %a, %73
-    %75:vec4<u32> = load %74
-    %76:vec4<f16> = bitcast %75
-    %77:vec3<f16> = swizzle %76, xyz
-    %78:u32 = add 8u, %start_byte_offset_2
-    %79:u32 = div %78, 16u
-    %80:ptr<uniform, vec4<u32>, read> = access %a, %79
-    %81:vec4<u32> = load %80
-    %82:vec4<f16> = bitcast %81
-    %83:vec3<f16> = swizzle %82, xyz
-    %84:u32 = add 16u, %start_byte_offset_2
-    %85:u32 = div %84, 16u
-    %86:ptr<uniform, vec4<u32>, read> = access %a, %85
-    %87:vec4<u32> = load %86
-    %88:vec4<f16> = bitcast %87
-    %89:vec3<f16> = swizzle %88, xyz
-    %90:u32 = add 24u, %start_byte_offset_2
-    %91:u32 = div %90, 16u
-    %92:ptr<uniform, vec4<u32>, read> = access %a, %91
-    %93:vec4<u32> = load %92
-    %94:vec4<f16> = bitcast %93
-    %95:vec3<f16> = swizzle %94, xyz
-    %96:mat4x3<f16> = construct %77, %83, %89, %95
-    ret %96
   }
+  Inner v_14[4] = a;
+  return v_14;
 }
-%21 = func(%start_byte_offset_3:u32):Outer {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %98:array<Inner, 4> = call %24, %start_byte_offset_3
-    %99:Outer = construct %98
-    ret %99
-  }
+
+Outer v_15(uint start_byte_offset) {
+  Inner v_16[4] = v_10(start_byte_offset);
+  Outer v_17 = {v_16};
+  return v_17;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat4x3<f16>(vec3<f16>(0.0h))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %103:bool = gte %idx_1, 4u
-        if %103 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %104:u32 = mul %idx_1, 256u
-        %105:u32 = add %start_byte_offset_4, %104
-        %106:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %107:Outer = call %21, %105
-        store %106, %107
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_18(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_19 = 0u;
+    v_19 = 0u;
+    while(true) {
+      uint v_20 = v_19;
+      if ((v_20 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %108:u32 = add %idx_1, 1u
-        next_iteration %108  # -> $B14
+      Outer v_21 = v_15((start_byte_offset + (v_20 * 256u)));
+      a[v_20] = v_21;
+      {
+        v_19 = (v_20 + 1u);
       }
+      continue;
     }
-    %109:array<Outer, 4> = load %a_2
-    ret %109
   }
+  Outer v_22[4] = a;
+  return v_22;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_23 = (256u * uint(i()));
+  uint v_24 = (64u * uint(i()));
+  uint v_25 = (8u * uint(i()));
+  Outer l_a[4] = v_18(0u);
+  Outer l_a_i = v_15(v_23);
+  Inner l_a_i_a[4] = v_10(v_23);
+  Inner l_a_i_a_i = v_8((v_23 + v_24));
+  matrix<float16_t, 4, 3> l_a_i_a_i_m = v_4((v_23 + v_24));
+  vector<float16_t, 3> l_a_i_a_i_m_i = tint_bitcast_to_f16(a[(((v_23 + v_24) + v_25) / 16u)]).xyz;
+  uint v_26 = (((v_23 + v_24) + v_25) + (uint(i()) * 2u));
+  uint v_27 = a[(v_26 / 16u)][((v_26 % 16u) / 4u)];
+  float16_t l_a_i_a_i_m_i_i = float16_t(f16tof32((v_27 >> ((((v_26 % 4u) == 0u)) ? (0u) : (16u)))));
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat4x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat4x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index f4f3c622062..62767c77248 100644
--- a/test/tint/buffer/uniform/std140/struct/mat4x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat4x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,240 +1,97 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat4x3<f32>,
-}
+  float4x3 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat4x3<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec3<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :55:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %43:u32 = mul %42, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(16) {
-  m:mat4x3<f32> @offset(0)
+float4x3 v(uint start_byte_offset) {
+  float3 v_1 = asfloat(a[(start_byte_offset / 16u)].xyz);
+  float3 v_2 = asfloat(a[((16u + start_byte_offset) / 16u)].xyz);
+  float3 v_3 = asfloat(a[((32u + start_byte_offset) / 16u)].xyz);
+  return float4x3(v_1, v_2, v_3, asfloat(a[((48u + start_byte_offset) / 16u)].xyz));
 }
 
-Outer = struct @align(16) {
-  a:array<Inner, 4> @offset(0)
+Inner v_4(uint start_byte_offset) {
+  Inner v_5 = {v(start_byte_offset)};
+  return v_5;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 16u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat4x3<f32> = call %32, %30
-    %l_a_i_a_i_m:mat4x3<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec3<u32> = swizzle %38, xyz
-    %40:vec3<f32> = bitcast %39
-    %l_a_i_a_i_m_i:vec3<f32> = let %40
-    %42:i32 = call %i
-    %43:u32 = mul %42, 4u
-    %44:u32 = add %10, %13
-    %45:u32 = add %44, %16
-    %46:u32 = add %45, %43
-    %47:u32 = div %46, 16u
-    %48:ptr<uniform, vec4<u32>, read> = access %a, %47
-    %49:u32 = mod %46, 16u
-    %50:u32 = div %49, 4u
-    %51:u32 = load_vector_element %48, %50
-    %52:f32 = bitcast %51
-    %l_a_i_a_i_m_i_i:f32 = let %52
-    ret
-  }
-}
-%21 = func(%start_byte_offset:u32):Outer {
-  $B4: {
-    %55:array<Inner, 4> = call %24, %start_byte_offset
-    %56:Outer = construct %55
-    ret %56
-  }
-}
-%24 = func(%start_byte_offset_1:u32):array<Inner, 4> {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat4x3<f32>(vec3<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B6, b: $B7, c: $B8] {  # loop_1
-      $B6: {  # initializer
-        next_iteration 0u  # -> $B7
-      }
-      $B7 (%idx:u32): {  # body
-        %60:bool = gte %idx, 4u
-        if %60 [t: $B9] {  # if_1
-          $B9: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %61:u32 = mul %idx, 64u
-        %62:u32 = add %start_byte_offset_1, %61
-        %63:ptr<function, Inner, read_write> = access %a_1, %idx
-        %64:Inner = call %28, %62
-        store %63, %64
-        continue  # -> $B8
+typedef Inner ary_ret[4];
+ary_ret v_6(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_7 = 0u;
+    v_7 = 0u;
+    while(true) {
+      uint v_8 = v_7;
+      if ((v_8 >= 4u)) {
+        break;
       }
-      $B8: {  # continuing
-        %65:u32 = add %idx, 1u
-        next_iteration %65  # -> $B7
+      Inner v_9 = v_4((start_byte_offset + (v_8 * 64u)));
+      a[v_8] = v_9;
+      {
+        v_7 = (v_8 + 1u);
       }
+      continue;
     }
-    %66:array<Inner, 4> = load %a_1
-    ret %66
-  }
-}
-%28 = func(%start_byte_offset_2:u32):Inner {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %68:mat4x3<f32> = call %32, %start_byte_offset_2
-    %69:Inner = construct %68
-    ret %69
   }
+  Inner v_10[4] = a;
+  return v_10;
 }
-%32 = func(%start_byte_offset_3:u32):mat4x3<f32> {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %71:u32 = div %start_byte_offset_3, 16u
-    %72:ptr<uniform, vec4<u32>, read> = access %a, %71
-    %73:vec4<u32> = load %72
-    %74:vec3<u32> = swizzle %73, xyz
-    %75:vec3<f32> = bitcast %74
-    %76:u32 = add 16u, %start_byte_offset_3
-    %77:u32 = div %76, 16u
-    %78:ptr<uniform, vec4<u32>, read> = access %a, %77
-    %79:vec4<u32> = load %78
-    %80:vec3<u32> = swizzle %79, xyz
-    %81:vec3<f32> = bitcast %80
-    %82:u32 = add 32u, %start_byte_offset_3
-    %83:u32 = div %82, 16u
-    %84:ptr<uniform, vec4<u32>, read> = access %a, %83
-    %85:vec4<u32> = load %84
-    %86:vec3<u32> = swizzle %85, xyz
-    %87:vec3<f32> = bitcast %86
-    %88:u32 = add 48u, %start_byte_offset_3
-    %89:u32 = div %88, 16u
-    %90:ptr<uniform, vec4<u32>, read> = access %a, %89
-    %91:vec4<u32> = load %90
-    %92:vec3<u32> = swizzle %91, xyz
-    %93:vec3<f32> = bitcast %92
-    %94:mat4x3<f32> = construct %75, %81, %87, %93
-    ret %94
-  }
+
+Outer v_11(uint start_byte_offset) {
+  Inner v_12[4] = v_6(start_byte_offset);
+  Outer v_13 = {v_12};
+  return v_13;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat4x3<f32>(vec3<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %98:bool = gte %idx_1, 4u
-        if %98 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %99:u32 = mul %idx_1, 256u
-        %100:u32 = add %start_byte_offset_4, %99
-        %101:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %102:Outer = call %21, %100
-        store %101, %102
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_14(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_15 = 0u;
+    v_15 = 0u;
+    while(true) {
+      uint v_16 = v_15;
+      if ((v_16 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %103:u32 = add %idx_1, 1u
-        next_iteration %103  # -> $B14
+      Outer v_17 = v_11((start_byte_offset + (v_16 * 256u)));
+      a[v_16] = v_17;
+      {
+        v_15 = (v_16 + 1u);
       }
+      continue;
     }
-    %104:array<Outer, 4> = load %a_2
-    ret %104
   }
+  Outer v_18[4] = a;
+  return v_18;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_19 = (256u * uint(i()));
+  uint v_20 = (64u * uint(i()));
+  uint v_21 = (16u * uint(i()));
+  Outer l_a[4] = v_14(0u);
+  Outer l_a_i = v_11(v_19);
+  Inner l_a_i_a[4] = v_6(v_19);
+  Inner l_a_i_a_i = v_4((v_19 + v_20));
+  float4x3 l_a_i_a_i_m = v((v_19 + v_20));
+  float3 l_a_i_a_i_m_i = asfloat(a[(((v_19 + v_20) + v_21) / 16u)].xyz);
+  uint v_22 = (((v_19 + v_20) + v_21) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_22 / 16u)][((v_22 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat4x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat4x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
index f4f3c622062..62767c77248 100644
--- a/test/tint/buffer/uniform/std140/struct/mat4x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat4x3_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
@@ -1,240 +1,97 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat4x3<f32>,
-}
+  float4x3 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat4x3<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec3<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :55:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %43:u32 = mul %42, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(16) {
-  m:mat4x3<f32> @offset(0)
+float4x3 v(uint start_byte_offset) {
+  float3 v_1 = asfloat(a[(start_byte_offset / 16u)].xyz);
+  float3 v_2 = asfloat(a[((16u + start_byte_offset) / 16u)].xyz);
+  float3 v_3 = asfloat(a[((32u + start_byte_offset) / 16u)].xyz);
+  return float4x3(v_1, v_2, v_3, asfloat(a[((48u + start_byte_offset) / 16u)].xyz));
 }
 
-Outer = struct @align(16) {
-  a:array<Inner, 4> @offset(0)
+Inner v_4(uint start_byte_offset) {
+  Inner v_5 = {v(start_byte_offset)};
+  return v_5;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 16u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat4x3<f32> = call %32, %30
-    %l_a_i_a_i_m:mat4x3<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec3<u32> = swizzle %38, xyz
-    %40:vec3<f32> = bitcast %39
-    %l_a_i_a_i_m_i:vec3<f32> = let %40
-    %42:i32 = call %i
-    %43:u32 = mul %42, 4u
-    %44:u32 = add %10, %13
-    %45:u32 = add %44, %16
-    %46:u32 = add %45, %43
-    %47:u32 = div %46, 16u
-    %48:ptr<uniform, vec4<u32>, read> = access %a, %47
-    %49:u32 = mod %46, 16u
-    %50:u32 = div %49, 4u
-    %51:u32 = load_vector_element %48, %50
-    %52:f32 = bitcast %51
-    %l_a_i_a_i_m_i_i:f32 = let %52
-    ret
-  }
-}
-%21 = func(%start_byte_offset:u32):Outer {
-  $B4: {
-    %55:array<Inner, 4> = call %24, %start_byte_offset
-    %56:Outer = construct %55
-    ret %56
-  }
-}
-%24 = func(%start_byte_offset_1:u32):array<Inner, 4> {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat4x3<f32>(vec3<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B6, b: $B7, c: $B8] {  # loop_1
-      $B6: {  # initializer
-        next_iteration 0u  # -> $B7
-      }
-      $B7 (%idx:u32): {  # body
-        %60:bool = gte %idx, 4u
-        if %60 [t: $B9] {  # if_1
-          $B9: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %61:u32 = mul %idx, 64u
-        %62:u32 = add %start_byte_offset_1, %61
-        %63:ptr<function, Inner, read_write> = access %a_1, %idx
-        %64:Inner = call %28, %62
-        store %63, %64
-        continue  # -> $B8
+typedef Inner ary_ret[4];
+ary_ret v_6(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_7 = 0u;
+    v_7 = 0u;
+    while(true) {
+      uint v_8 = v_7;
+      if ((v_8 >= 4u)) {
+        break;
       }
-      $B8: {  # continuing
-        %65:u32 = add %idx, 1u
-        next_iteration %65  # -> $B7
+      Inner v_9 = v_4((start_byte_offset + (v_8 * 64u)));
+      a[v_8] = v_9;
+      {
+        v_7 = (v_8 + 1u);
       }
+      continue;
     }
-    %66:array<Inner, 4> = load %a_1
-    ret %66
-  }
-}
-%28 = func(%start_byte_offset_2:u32):Inner {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %68:mat4x3<f32> = call %32, %start_byte_offset_2
-    %69:Inner = construct %68
-    ret %69
   }
+  Inner v_10[4] = a;
+  return v_10;
 }
-%32 = func(%start_byte_offset_3:u32):mat4x3<f32> {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %71:u32 = div %start_byte_offset_3, 16u
-    %72:ptr<uniform, vec4<u32>, read> = access %a, %71
-    %73:vec4<u32> = load %72
-    %74:vec3<u32> = swizzle %73, xyz
-    %75:vec3<f32> = bitcast %74
-    %76:u32 = add 16u, %start_byte_offset_3
-    %77:u32 = div %76, 16u
-    %78:ptr<uniform, vec4<u32>, read> = access %a, %77
-    %79:vec4<u32> = load %78
-    %80:vec3<u32> = swizzle %79, xyz
-    %81:vec3<f32> = bitcast %80
-    %82:u32 = add 32u, %start_byte_offset_3
-    %83:u32 = div %82, 16u
-    %84:ptr<uniform, vec4<u32>, read> = access %a, %83
-    %85:vec4<u32> = load %84
-    %86:vec3<u32> = swizzle %85, xyz
-    %87:vec3<f32> = bitcast %86
-    %88:u32 = add 48u, %start_byte_offset_3
-    %89:u32 = div %88, 16u
-    %90:ptr<uniform, vec4<u32>, read> = access %a, %89
-    %91:vec4<u32> = load %90
-    %92:vec3<u32> = swizzle %91, xyz
-    %93:vec3<f32> = bitcast %92
-    %94:mat4x3<f32> = construct %75, %81, %87, %93
-    ret %94
-  }
+
+Outer v_11(uint start_byte_offset) {
+  Inner v_12[4] = v_6(start_byte_offset);
+  Outer v_13 = {v_12};
+  return v_13;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat4x3<f32>(vec3<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %98:bool = gte %idx_1, 4u
-        if %98 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %99:u32 = mul %idx_1, 256u
-        %100:u32 = add %start_byte_offset_4, %99
-        %101:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %102:Outer = call %21, %100
-        store %101, %102
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_14(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_15 = 0u;
+    v_15 = 0u;
+    while(true) {
+      uint v_16 = v_15;
+      if ((v_16 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %103:u32 = add %idx_1, 1u
-        next_iteration %103  # -> $B14
+      Outer v_17 = v_11((start_byte_offset + (v_16 * 256u)));
+      a[v_16] = v_17;
+      {
+        v_15 = (v_16 + 1u);
       }
+      continue;
     }
-    %104:array<Outer, 4> = load %a_2
-    ret %104
   }
+  Outer v_18[4] = a;
+  return v_18;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_19 = (256u * uint(i()));
+  uint v_20 = (64u * uint(i()));
+  uint v_21 = (16u * uint(i()));
+  Outer l_a[4] = v_14(0u);
+  Outer l_a_i = v_11(v_19);
+  Inner l_a_i_a[4] = v_6(v_19);
+  Inner l_a_i_a_i = v_4((v_19 + v_20));
+  float4x3 l_a_i_a_i_m = v((v_19 + v_20));
+  float3 l_a_i_a_i_m_i = asfloat(a[(((v_19 + v_20) + v_21) / 16u)].xyz);
+  uint v_22 = (((v_19 + v_20) + v_21) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_22 / 16u)][((v_22 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat4x4_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat4x4_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index 1800362de9a..16b40c5d2a5 100644
--- a/test/tint/buffer/uniform/std140/struct/mat4x4_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat4x4_f16/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,242 +1,110 @@
-SKIP: FAILED
-
-
-enable f16;
-
 struct Inner {
-  @size(64)
-  m : mat4x4<f16>,
-}
+  matrix<float16_t, 4, 4> m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
-
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
+  Inner a[4];
+};
 
-var<private> counter = 0;
 
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat4x4<f16> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec4<f16> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f16 = (*(p_a_i_a_i_m_i))[i()];
+vector<float16_t, 4> tint_bitcast_to_f16(uint4 src) {
+  uint4 v = src;
+  uint4 mask = (65535u).xxxx;
+  uint4 shift = (16u).xxxx;
+  float4 t_low = f16tof32((v & mask));
+  float4 t_high = f16tof32(((v >> shift) & mask));
+  float16_t v_1 = float16_t(t_low.x);
+  float16_t v_2 = float16_t(t_high.x);
+  float16_t v_3 = float16_t(t_low.y);
+  return vector<float16_t, 4>(v_1, v_2, v_3, float16_t(t_high.y));
 }
 
-Failed to generate: :54:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %42:u32 = mul %41, 2u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(8) {
-  m:mat4x4<f16> @offset(0)
+matrix<float16_t, 4, 4> v_4(uint start_byte_offset) {
+  vector<float16_t, 4> v_5 = tint_bitcast_to_f16(a[(start_byte_offset / 16u)]);
+  vector<float16_t, 4> v_6 = tint_bitcast_to_f16(a[((8u + start_byte_offset) / 16u)]);
+  vector<float16_t, 4> v_7 = tint_bitcast_to_f16(a[((16u + start_byte_offset) / 16u)]);
+  return matrix<float16_t, 4, 4>(v_5, v_6, v_7, tint_bitcast_to_f16(a[((24u + start_byte_offset) / 16u)]));
 }
 
-Outer = struct @align(8) {
-  a:array<Inner, 4> @offset(0)
+Inner v_8(uint start_byte_offset) {
+  Inner v_9 = {v_4(start_byte_offset)};
+  return v_9;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 8u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat4x4<f16> = call %32, %30
-    %l_a_i_a_i_m:mat4x4<f16> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec4<f16> = bitcast %38
-    %l_a_i_a_i_m_i:vec4<f16> = let %39
-    %41:i32 = call %i
-    %42:u32 = mul %41, 2u
-    %43:u32 = add %10, %13
-    %44:u32 = add %43, %16
-    %45:u32 = add %44, %42
-    %46:u32 = div %45, 16u
-    %47:ptr<uniform, vec4<u32>, read> = access %a, %46
-    %48:u32 = mod %45, 16u
-    %49:u32 = div %48, 4u
-    %50:u32 = load_vector_element %47, %49
-    %51:u32 = mod %45, 4u
-    %52:bool = eq %51, 0u
-    %53:u32 = hlsl.ternary 16u, 0u, %52
-    %54:u32 = shr %50, %53
-    %55:f32 = hlsl.f16tof32 %54
-    %56:f16 = convert %55
-    %l_a_i_a_i_m_i_i:f16 = let %56
-    ret
-  }
-}
-%18 = func(%start_byte_offset:u32):array<Outer, 4> {
-  $B4: {
-    %a_1:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat4x4<f16>(vec4<f16>(0.0h))))))  # %a_1: 'a'
-    loop [i: $B5, b: $B6, c: $B7] {  # loop_1
-      $B5: {  # initializer
-        next_iteration 0u  # -> $B6
+typedef Inner ary_ret[4];
+ary_ret v_10(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_11 = 0u;
+    v_11 = 0u;
+    while(true) {
+      uint v_12 = v_11;
+      if ((v_12 >= 4u)) {
+        break;
       }
-      $B6 (%idx:u32): {  # body
-        %61:bool = gte %idx, 4u
-        if %61 [t: $B8] {  # if_1
-          $B8: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %62:u32 = mul %idx, 256u
-        %63:u32 = add %start_byte_offset, %62
-        %64:ptr<function, Outer, read_write> = access %a_1, %idx
-        %65:Outer = call %21, %63
-        store %64, %65
-        continue  # -> $B7
-      }
-      $B7: {  # continuing
-        %66:u32 = add %idx, 1u
-        next_iteration %66  # -> $B6
+      Inner v_13 = v_8((start_byte_offset + (v_12 * 64u)));
+      a[v_12] = v_13;
+      {
+        v_11 = (v_12 + 1u);
       }
+      continue;
     }
-    %67:array<Outer, 4> = load %a_1
-    ret %67
   }
+  Inner v_14[4] = a;
+  return v_14;
 }
-%21 = func(%start_byte_offset_1:u32):Outer {  # %start_byte_offset_1: 'start_byte_offset'
-  $B9: {
-    %69:array<Inner, 4> = call %24, %start_byte_offset_1
-    %70:Outer = construct %69
-    ret %70
-  }
+
+Outer v_15(uint start_byte_offset) {
+  Inner v_16[4] = v_10(start_byte_offset);
+  Outer v_17 = {v_16};
+  return v_17;
 }
-%24 = func(%start_byte_offset_2:u32):array<Inner, 4> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %a_2:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat4x4<f16>(vec4<f16>(0.0h))))  # %a_2: 'a'
-    loop [i: $B11, b: $B12, c: $B13] {  # loop_2
-      $B11: {  # initializer
-        next_iteration 0u  # -> $B12
-      }
-      $B12 (%idx_1:u32): {  # body
-        %74:bool = gte %idx_1, 4u
-        if %74 [t: $B14] {  # if_2
-          $B14: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %75:u32 = mul %idx_1, 64u
-        %76:u32 = add %start_byte_offset_2, %75
-        %77:ptr<function, Inner, read_write> = access %a_2, %idx_1
-        %78:Inner = call %28, %76
-        store %77, %78
-        continue  # -> $B13
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_18(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_19 = 0u;
+    v_19 = 0u;
+    while(true) {
+      uint v_20 = v_19;
+      if ((v_20 >= 4u)) {
+        break;
       }
-      $B13: {  # continuing
-        %79:u32 = add %idx_1, 1u
-        next_iteration %79  # -> $B12
+      Outer v_21 = v_15((start_byte_offset + (v_20 * 256u)));
+      a[v_20] = v_21;
+      {
+        v_19 = (v_20 + 1u);
       }
+      continue;
     }
-    %80:array<Inner, 4> = load %a_2
-    ret %80
-  }
-}
-%28 = func(%start_byte_offset_3:u32):Inner {  # %start_byte_offset_3: 'start_byte_offset'
-  $B15: {
-    %82:mat4x4<f16> = call %32, %start_byte_offset_3
-    %83:Inner = construct %82
-    ret %83
   }
+  Outer v_22[4] = a;
+  return v_22;
 }
-%32 = func(%start_byte_offset_4:u32):mat4x4<f16> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B16: {
-    %85:u32 = div %start_byte_offset_4, 16u
-    %86:ptr<uniform, vec4<u32>, read> = access %a, %85
-    %87:vec4<u32> = load %86
-    %88:vec4<f16> = bitcast %87
-    %89:u32 = add 8u, %start_byte_offset_4
-    %90:u32 = div %89, 16u
-    %91:ptr<uniform, vec4<u32>, read> = access %a, %90
-    %92:vec4<u32> = load %91
-    %93:vec4<f16> = bitcast %92
-    %94:u32 = add 16u, %start_byte_offset_4
-    %95:u32 = div %94, 16u
-    %96:ptr<uniform, vec4<u32>, read> = access %a, %95
-    %97:vec4<u32> = load %96
-    %98:vec4<f16> = bitcast %97
-    %99:u32 = add 24u, %start_byte_offset_4
-    %100:u32 = div %99, 16u
-    %101:ptr<uniform, vec4<u32>, read> = access %a, %100
-    %102:vec4<u32> = load %101
-    %103:vec4<f16> = bitcast %102
-    %104:mat4x4<f16> = construct %88, %93, %98, %103
-    ret %104
-  }
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_23 = (256u * uint(i()));
+  uint v_24 = (64u * uint(i()));
+  uint v_25 = (8u * uint(i()));
+  Outer l_a[4] = v_18(0u);
+  Outer l_a_i = v_15(v_23);
+  Inner l_a_i_a[4] = v_10(v_23);
+  Inner l_a_i_a_i = v_8((v_23 + v_24));
+  matrix<float16_t, 4, 4> l_a_i_a_i_m = v_4((v_23 + v_24));
+  vector<float16_t, 4> l_a_i_a_i_m_i = tint_bitcast_to_f16(a[(((v_23 + v_24) + v_25) / 16u)]);
+  uint v_26 = (((v_23 + v_24) + v_25) + (uint(i()) * 2u));
+  uint v_27 = a[(v_26 / 16u)][((v_26 % 16u) / 4u)];
+  float16_t l_a_i_a_i_m_i_i = float16_t(f16tof32((v_27 >> ((((v_26 % 4u) == 0u)) ? (0u) : (16u)))));
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat4x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat4x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
index 6dd889b01b5..e5bd0af27bb 100644
--- a/test/tint/buffer/uniform/std140/struct/mat4x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat4x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.dxc.hlsl
@@ -1,235 +1,97 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat4x4<f32>,
-}
+  float4x4 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat4x4<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec4<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :54:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %42:u32 = mul %41, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(16) {
-  m:mat4x4<f32> @offset(0)
+float4x4 v(uint start_byte_offset) {
+  float4 v_1 = asfloat(a[(start_byte_offset / 16u)]);
+  float4 v_2 = asfloat(a[((16u + start_byte_offset) / 16u)]);
+  float4 v_3 = asfloat(a[((32u + start_byte_offset) / 16u)]);
+  return float4x4(v_1, v_2, v_3, asfloat(a[((48u + start_byte_offset) / 16u)]));
 }
 
-Outer = struct @align(16) {
-  a:array<Inner, 4> @offset(0)
+Inner v_4(uint start_byte_offset) {
+  Inner v_5 = {v(start_byte_offset)};
+  return v_5;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 16u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat4x4<f32> = call %32, %30
-    %l_a_i_a_i_m:mat4x4<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec4<f32> = bitcast %38
-    %l_a_i_a_i_m_i:vec4<f32> = let %39
-    %41:i32 = call %i
-    %42:u32 = mul %41, 4u
-    %43:u32 = add %10, %13
-    %44:u32 = add %43, %16
-    %45:u32 = add %44, %42
-    %46:u32 = div %45, 16u
-    %47:ptr<uniform, vec4<u32>, read> = access %a, %46
-    %48:u32 = mod %45, 16u
-    %49:u32 = div %48, 4u
-    %50:u32 = load_vector_element %47, %49
-    %51:f32 = bitcast %50
-    %l_a_i_a_i_m_i_i:f32 = let %51
-    ret
-  }
-}
-%24 = func(%start_byte_offset:u32):array<Inner, 4> {
-  $B4: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat4x4<f32>(vec4<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B5, b: $B6, c: $B7] {  # loop_1
-      $B5: {  # initializer
-        next_iteration 0u  # -> $B6
-      }
-      $B6 (%idx:u32): {  # body
-        %56:bool = gte %idx, 4u
-        if %56 [t: $B8] {  # if_1
-          $B8: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %57:u32 = mul %idx, 64u
-        %58:u32 = add %start_byte_offset, %57
-        %59:ptr<function, Inner, read_write> = access %a_1, %idx
-        %60:Inner = call %28, %58
-        store %59, %60
-        continue  # -> $B7
+typedef Inner ary_ret[4];
+ary_ret v_6(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_7 = 0u;
+    v_7 = 0u;
+    while(true) {
+      uint v_8 = v_7;
+      if ((v_8 >= 4u)) {
+        break;
       }
-      $B7: {  # continuing
-        %61:u32 = add %idx, 1u
-        next_iteration %61  # -> $B6
+      Inner v_9 = v_4((start_byte_offset + (v_8 * 64u)));
+      a[v_8] = v_9;
+      {
+        v_7 = (v_8 + 1u);
       }
+      continue;
     }
-    %62:array<Inner, 4> = load %a_1
-    ret %62
-  }
-}
-%28 = func(%start_byte_offset_1:u32):Inner {  # %start_byte_offset_1: 'start_byte_offset'
-  $B9: {
-    %64:mat4x4<f32> = call %32, %start_byte_offset_1
-    %65:Inner = construct %64
-    ret %65
-  }
-}
-%32 = func(%start_byte_offset_2:u32):mat4x4<f32> {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %67:u32 = div %start_byte_offset_2, 16u
-    %68:ptr<uniform, vec4<u32>, read> = access %a, %67
-    %69:vec4<u32> = load %68
-    %70:vec4<f32> = bitcast %69
-    %71:u32 = add 16u, %start_byte_offset_2
-    %72:u32 = div %71, 16u
-    %73:ptr<uniform, vec4<u32>, read> = access %a, %72
-    %74:vec4<u32> = load %73
-    %75:vec4<f32> = bitcast %74
-    %76:u32 = add 32u, %start_byte_offset_2
-    %77:u32 = div %76, 16u
-    %78:ptr<uniform, vec4<u32>, read> = access %a, %77
-    %79:vec4<u32> = load %78
-    %80:vec4<f32> = bitcast %79
-    %81:u32 = add 48u, %start_byte_offset_2
-    %82:u32 = div %81, 16u
-    %83:ptr<uniform, vec4<u32>, read> = access %a, %82
-    %84:vec4<u32> = load %83
-    %85:vec4<f32> = bitcast %84
-    %86:mat4x4<f32> = construct %70, %75, %80, %85
-    ret %86
   }
+  Inner v_10[4] = a;
+  return v_10;
 }
-%21 = func(%start_byte_offset_3:u32):Outer {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %88:array<Inner, 4> = call %24, %start_byte_offset_3
-    %89:Outer = construct %88
-    ret %89
-  }
+
+Outer v_11(uint start_byte_offset) {
+  Inner v_12[4] = v_6(start_byte_offset);
+  Outer v_13 = {v_12};
+  return v_13;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat4x4<f32>(vec4<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %93:bool = gte %idx_1, 4u
-        if %93 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %94:u32 = mul %idx_1, 256u
-        %95:u32 = add %start_byte_offset_4, %94
-        %96:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %97:Outer = call %21, %95
-        store %96, %97
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_14(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_15 = 0u;
+    v_15 = 0u;
+    while(true) {
+      uint v_16 = v_15;
+      if ((v_16 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %98:u32 = add %idx_1, 1u
-        next_iteration %98  # -> $B14
+      Outer v_17 = v_11((start_byte_offset + (v_16 * 256u)));
+      a[v_16] = v_17;
+      {
+        v_15 = (v_16 + 1u);
       }
+      continue;
     }
-    %99:array<Outer, 4> = load %a_2
-    ret %99
   }
+  Outer v_18[4] = a;
+  return v_18;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_19 = (256u * uint(i()));
+  uint v_20 = (64u * uint(i()));
+  uint v_21 = (16u * uint(i()));
+  Outer l_a[4] = v_14(0u);
+  Outer l_a_i = v_11(v_19);
+  Inner l_a_i_a[4] = v_6(v_19);
+  Inner l_a_i_a_i = v_4((v_19 + v_20));
+  float4x4 l_a_i_a_i_m = v((v_19 + v_20));
+  float4 l_a_i_a_i_m_i = asfloat(a[(((v_19 + v_20) + v_21) / 16u)]);
+  uint v_22 = (((v_19 + v_20) + v_21) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_22 / 16u)][((v_22 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/buffer/uniform/std140/struct/mat4x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl b/test/tint/buffer/uniform/std140/struct/mat4x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
index 484df98b19b..e5bd0af27bb 100644
--- a/test/tint/buffer/uniform/std140/struct/mat4x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
+++ b/test/tint/buffer/uniform/std140/struct/mat4x4_f32/dynamic_index_via_ptr.wgsl.expected.ir.fxc.hlsl
@@ -1,235 +1,97 @@
-SKIP: FAILED
-
-
 struct Inner {
-  @size(64)
-  m : mat4x4<f32>,
-}
+  float4x4 m;
+};
 
 struct Outer {
-  a : array<Inner, 4>,
-}
+  Inner a[4];
+};
 
-@group(0) @binding(0) var<uniform> a : array<Outer, 4>;
 
-var<private> counter = 0;
-
-fn i() -> i32 {
-  counter++;
+cbuffer cbuffer_a : register(b0) {
+  uint4 a[64];
+};
+static int counter = 0;
+int i() {
+  counter = (counter + 1);
   return counter;
 }
 
-@compute @workgroup_size(1)
-fn f() {
-  let p_a = &(a);
-  let p_a_i = &((*(p_a))[i()]);
-  let p_a_i_a = &((*(p_a_i)).a);
-  let p_a_i_a_i = &((*(p_a_i_a))[i()]);
-  let p_a_i_a_i_m = &((*(p_a_i_a_i)).m);
-  let p_a_i_a_i_m_i = &((*(p_a_i_a_i_m))[i()]);
-  let l_a : array<Outer, 4> = *(p_a);
-  let l_a_i : Outer = *(p_a_i);
-  let l_a_i_a : array<Inner, 4> = *(p_a_i_a);
-  let l_a_i_a_i : Inner = *(p_a_i_a_i);
-  let l_a_i_a_i_m : mat4x4<f32> = *(p_a_i_a_i_m);
-  let l_a_i_a_i_m_i : vec4<f32> = *(p_a_i_a_i_m_i);
-  let l_a_i_a_i_m_i_i : f32 = (*(p_a_i_a_i_m_i))[i()];
-}
-
-Failed to generate: :54:5 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-    %42:u32 = mul %41, 4u
-    ^^^^^^^^^^^^^^^^^^^^^
-
-:24:3 note: in block
-  $B3: {
-  ^^^
-
-note: # Disassembly
-Inner = struct @align(16) {
-  m:mat4x4<f32> @offset(0)
+float4x4 v(uint start_byte_offset) {
+  float4 v_1 = asfloat(a[(start_byte_offset / 16u)]);
+  float4 v_2 = asfloat(a[((16u + start_byte_offset) / 16u)]);
+  float4 v_3 = asfloat(a[((32u + start_byte_offset) / 16u)]);
+  return float4x4(v_1, v_2, v_3, asfloat(a[((48u + start_byte_offset) / 16u)]));
 }
 
-Outer = struct @align(16) {
-  a:array<Inner, 4> @offset(0)
+Inner v_4(uint start_byte_offset) {
+  Inner v_5 = {v(start_byte_offset)};
+  return v_5;
 }
 
-$B1: {  # root
-  %a:ptr<uniform, array<vec4<u32>, 64>, read> = var @binding_point(0, 0)
-  %counter:ptr<private, i32, read_write> = var, 0i
-}
-
-%i = func():i32 {
-  $B2: {
-    %4:i32 = load %counter
-    %5:i32 = add %4, 1i
-    store %counter, %5
-    %6:i32 = load %counter
-    ret %6
-  }
-}
-%f = @compute @workgroup_size(1, 1, 1) func():void {
-  $B3: {
-    %8:i32 = call %i
-    %9:u32 = convert %8
-    %10:u32 = mul 256u, %9
-    %11:i32 = call %i
-    %12:u32 = convert %11
-    %13:u32 = mul 64u, %12
-    %14:i32 = call %i
-    %15:u32 = convert %14
-    %16:u32 = mul 16u, %15
-    %17:array<Outer, 4> = call %18, 0u
-    %l_a:array<Outer, 4> = let %17
-    %20:Outer = call %21, %10
-    %l_a_i:Outer = let %20
-    %23:array<Inner, 4> = call %24, %10
-    %l_a_i_a:array<Inner, 4> = let %23
-    %26:u32 = add %10, %13
-    %27:Inner = call %28, %26
-    %l_a_i_a_i:Inner = let %27
-    %30:u32 = add %10, %13
-    %31:mat4x4<f32> = call %32, %30
-    %l_a_i_a_i_m:mat4x4<f32> = let %31
-    %34:u32 = add %10, %13
-    %35:u32 = add %34, %16
-    %36:u32 = div %35, 16u
-    %37:ptr<uniform, vec4<u32>, read> = access %a, %36
-    %38:vec4<u32> = load %37
-    %39:vec4<f32> = bitcast %38
-    %l_a_i_a_i_m_i:vec4<f32> = let %39
-    %41:i32 = call %i
-    %42:u32 = mul %41, 4u
-    %43:u32 = add %10, %13
-    %44:u32 = add %43, %16
-    %45:u32 = add %44, %42
-    %46:u32 = div %45, 16u
-    %47:ptr<uniform, vec4<u32>, read> = access %a, %46
-    %48:u32 = mod %45, 16u
-    %49:u32 = div %48, 4u
-    %50:u32 = load_vector_element %47, %49
-    %51:f32 = bitcast %50
-    %l_a_i_a_i_m_i_i:f32 = let %51
-    ret
-  }
-}
-%21 = func(%start_byte_offset:u32):Outer {
-  $B4: {
-    %54:array<Inner, 4> = call %24, %start_byte_offset
-    %55:Outer = construct %54
-    ret %55
-  }
-}
-%24 = func(%start_byte_offset_1:u32):array<Inner, 4> {  # %start_byte_offset_1: 'start_byte_offset'
-  $B5: {
-    %a_1:ptr<function, array<Inner, 4>, read_write> = var, array<Inner, 4>(Inner(mat4x4<f32>(vec4<f32>(0.0f))))  # %a_1: 'a'
-    loop [i: $B6, b: $B7, c: $B8] {  # loop_1
-      $B6: {  # initializer
-        next_iteration 0u  # -> $B7
-      }
-      $B7 (%idx:u32): {  # body
-        %59:bool = gte %idx, 4u
-        if %59 [t: $B9] {  # if_1
-          $B9: {  # true
-            exit_loop  # loop_1
-          }
-        }
-        %60:u32 = mul %idx, 64u
-        %61:u32 = add %start_byte_offset_1, %60
-        %62:ptr<function, Inner, read_write> = access %a_1, %idx
-        %63:Inner = call %28, %61
-        store %62, %63
-        continue  # -> $B8
+typedef Inner ary_ret[4];
+ary_ret v_6(uint start_byte_offset) {
+  Inner a[4] = (Inner[4])0;
+  {
+    uint v_7 = 0u;
+    v_7 = 0u;
+    while(true) {
+      uint v_8 = v_7;
+      if ((v_8 >= 4u)) {
+        break;
       }
-      $B8: {  # continuing
-        %64:u32 = add %idx, 1u
-        next_iteration %64  # -> $B7
+      Inner v_9 = v_4((start_byte_offset + (v_8 * 64u)));
+      a[v_8] = v_9;
+      {
+        v_7 = (v_8 + 1u);
       }
+      continue;
     }
-    %65:array<Inner, 4> = load %a_1
-    ret %65
-  }
-}
-%28 = func(%start_byte_offset_2:u32):Inner {  # %start_byte_offset_2: 'start_byte_offset'
-  $B10: {
-    %67:mat4x4<f32> = call %32, %start_byte_offset_2
-    %68:Inner = construct %67
-    ret %68
   }
+  Inner v_10[4] = a;
+  return v_10;
 }
-%32 = func(%start_byte_offset_3:u32):mat4x4<f32> {  # %start_byte_offset_3: 'start_byte_offset'
-  $B11: {
-    %70:u32 = div %start_byte_offset_3, 16u
-    %71:ptr<uniform, vec4<u32>, read> = access %a, %70
-    %72:vec4<u32> = load %71
-    %73:vec4<f32> = bitcast %72
-    %74:u32 = add 16u, %start_byte_offset_3
-    %75:u32 = div %74, 16u
-    %76:ptr<uniform, vec4<u32>, read> = access %a, %75
-    %77:vec4<u32> = load %76
-    %78:vec4<f32> = bitcast %77
-    %79:u32 = add 32u, %start_byte_offset_3
-    %80:u32 = div %79, 16u
-    %81:ptr<uniform, vec4<u32>, read> = access %a, %80
-    %82:vec4<u32> = load %81
-    %83:vec4<f32> = bitcast %82
-    %84:u32 = add 48u, %start_byte_offset_3
-    %85:u32 = div %84, 16u
-    %86:ptr<uniform, vec4<u32>, read> = access %a, %85
-    %87:vec4<u32> = load %86
-    %88:vec4<f32> = bitcast %87
-    %89:mat4x4<f32> = construct %73, %78, %83, %88
-    ret %89
-  }
+
+Outer v_11(uint start_byte_offset) {
+  Inner v_12[4] = v_6(start_byte_offset);
+  Outer v_13 = {v_12};
+  return v_13;
 }
-%18 = func(%start_byte_offset_4:u32):array<Outer, 4> {  # %start_byte_offset_4: 'start_byte_offset'
-  $B12: {
-    %a_2:ptr<function, array<Outer, 4>, read_write> = var, array<Outer, 4>(Outer(array<Inner, 4>(Inner(mat4x4<f32>(vec4<f32>(0.0f))))))  # %a_2: 'a'
-    loop [i: $B13, b: $B14, c: $B15] {  # loop_2
-      $B13: {  # initializer
-        next_iteration 0u  # -> $B14
-      }
-      $B14 (%idx_1:u32): {  # body
-        %93:bool = gte %idx_1, 4u
-        if %93 [t: $B16] {  # if_2
-          $B16: {  # true
-            exit_loop  # loop_2
-          }
-        }
-        %94:u32 = mul %idx_1, 256u
-        %95:u32 = add %start_byte_offset_4, %94
-        %96:ptr<function, Outer, read_write> = access %a_2, %idx_1
-        %97:Outer = call %21, %95
-        store %96, %97
-        continue  # -> $B15
+
+typedef Outer ary_ret_1[4];
+ary_ret_1 v_14(uint start_byte_offset) {
+  Outer a[4] = (Outer[4])0;
+  {
+    uint v_15 = 0u;
+    v_15 = 0u;
+    while(true) {
+      uint v_16 = v_15;
+      if ((v_16 >= 4u)) {
+        break;
       }
-      $B15: {  # continuing
-        %98:u32 = add %idx_1, 1u
-        next_iteration %98  # -> $B14
+      Outer v_17 = v_11((start_byte_offset + (v_16 * 256u)));
+      a[v_16] = v_17;
+      {
+        v_15 = (v_16 + 1u);
       }
+      continue;
     }
-    %99:array<Outer, 4> = load %a_2
-    ret %99
   }
+  Outer v_18[4] = a;
+  return v_18;
+}
+
+[numthreads(1, 1, 1)]
+void f() {
+  uint v_19 = (256u * uint(i()));
+  uint v_20 = (64u * uint(i()));
+  uint v_21 = (16u * uint(i()));
+  Outer l_a[4] = v_14(0u);
+  Outer l_a_i = v_11(v_19);
+  Inner l_a_i_a[4] = v_6(v_19);
+  Inner l_a_i_a_i = v_4((v_19 + v_20));
+  float4x4 l_a_i_a_i_m = v((v_19 + v_20));
+  float4 l_a_i_a_i_m_i = asfloat(a[(((v_19 + v_20) + v_21) / 16u)]);
+  uint v_22 = (((v_19 + v_20) + v_21) + (uint(i()) * 4u));
+  float l_a_i_a_i_m_i_i = asfloat(a[(v_22 / 16u)][((v_22 % 16u) / 4u)]);
 }
 
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-simplify-clamp-max-itself/0-opt.spvasm.expected.ir.dxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-simplify-clamp-max-itself/0-opt.spvasm.expected.ir.dxc.hlsl
deleted file mode 100644
index cb918d92023..00000000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-simplify-clamp-max-itself/0-opt.spvasm.expected.ir.dxc.hlsl
+++ /dev/null
@@ -1,192 +0,0 @@
-SKIP: FAILED
-
-
-struct buf0 {
-  /* @offset(0) */
-  sequence : vec4i,
-}
-
-@group(0) @binding(0) var<uniform> x_7 : buf0;
-
-var<private> x_GLF_color : vec4f;
-
-fn main_1() {
-  var a : vec4i;
-  var i : i32;
-  var sum : i32;
-  a = vec4i();
-  i = 0i;
-  loop {
-    if ((i < (x_7.sequence.w + 1i))) {
-    } else {
-      break;
-    }
-    if ((x_7.sequence[clamp(i, x_7.sequence.x, i)] == 1i)) {
-      let x_57 = i;
-      a[x_57] = 5i;
-    } else {
-      let x_59 = i;
-      a[x_59] = i;
-    }
-
-    continuing {
-      i = (i + 1i);
-    }
-  }
-  sum = (((a.x + a.y) + a.z) + a.w);
-  if ((sum == 10i)) {
-    x_GLF_color = vec4f(1.0f, 0.0f, 0.0f, 1.0f);
-  } else {
-    x_GLF_color = vec4f();
-  }
-  return;
-}
-
-struct main_out {
-  @location(0)
-  x_GLF_color_1 : vec4f,
-}
-
-@fragment
-fn main() -> main_out {
-  main_1();
-  return main_out(x_GLF_color);
-}
-
-Failed to generate: :44:9 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-        %20:u32 = mul %19, 4u
-        ^^^^^^^^^^^^^^^^^^^^^
-
-:22:7 note: in block
-      $B3: {  # body
-      ^^^
-
-note: # Disassembly
-buf0 = struct @align(16) {
-  sequence:vec4<i32> @offset(0)
-}
-
-main_out = struct @align(16) {
-  x_GLF_color_1:vec4<f32> @offset(0), @location(0)
-}
-
-$B1: {  # root
-  %x_7:ptr<uniform, array<vec4<u32>, 1>, read> = var @binding_point(0, 0)
-  %x_GLF_color:ptr<private, vec4<f32>, read_write> = var
-}
-
-%main_1 = func():void {
-  $B2: {
-    %a:ptr<function, vec4<i32>, read_write> = var
-    %i:ptr<function, i32, read_write> = var
-    %sum:ptr<function, i32, read_write> = var
-    store %a, vec4<i32>(0i)
-    store %i, 0i
-    loop [b: $B3, c: $B4] {  # loop_1
-      $B3: {  # body
-        %7:i32 = load %i
-        %8:ptr<uniform, vec4<u32>, read> = access %x_7, 0u
-        %9:u32 = load_vector_element %8, 3u
-        %10:i32 = bitcast %9
-        %11:i32 = add %10, 1i
-        %12:bool = lt %7, %11
-        if %12 [t: $B5, f: $B6] {  # if_1
-          $B5: {  # true
-            exit_if  # if_1
-          }
-          $B6: {  # false
-            exit_loop  # loop_1
-          }
-        }
-        %13:i32 = load %i
-        %14:ptr<uniform, vec4<u32>, read> = access %x_7, 0u
-        %15:u32 = load_vector_element %14, 0u
-        %16:i32 = bitcast %15
-        %17:i32 = load %i
-        %18:i32 = max %13, %16
-        %19:i32 = min %18, %17
-        %20:u32 = mul %19, 4u
-        %21:u32 = div %20, 16u
-        %22:ptr<uniform, vec4<u32>, read> = access %x_7, %21
-        %23:u32 = mod %20, 16u
-        %24:u32 = div %23, 4u
-        %25:u32 = load_vector_element %22, %24
-        %26:i32 = bitcast %25
-        %27:bool = eq %26, 1i
-        if %27 [t: $B7, f: $B8] {  # if_2
-          $B7: {  # true
-            %28:i32 = load %i
-            %x_57:i32 = let %28
-            store_vector_element %a, %x_57, 5i
-            exit_if  # if_2
-          }
-          $B8: {  # false
-            %30:i32 = load %i
-            %x_59:i32 = let %30
-            %32:i32 = load %i
-            store_vector_element %a, %x_59, %32
-            exit_if  # if_2
-          }
-        }
-        continue  # -> $B4
-      }
-      $B4: {  # continuing
-        %33:i32 = load %i
-        %34:i32 = add %33, 1i
-        store %i, %34
-        next_iteration  # -> $B3
-      }
-    }
-    %35:i32 = load_vector_element %a, 0u
-    %36:i32 = load_vector_element %a, 1u
-    %37:i32 = add %35, %36
-    %38:i32 = load_vector_element %a, 2u
-    %39:i32 = add %37, %38
-    %40:i32 = load_vector_element %a, 3u
-    %41:i32 = add %39, %40
-    store %sum, %41
-    %42:i32 = load %sum
-    %43:bool = eq %42, 10i
-    if %43 [t: $B9, f: $B10] {  # if_3
-      $B9: {  # true
-        store %x_GLF_color, vec4<f32>(1.0f, 0.0f, 0.0f, 1.0f)
-        exit_if  # if_3
-      }
-      $B10: {  # false
-        store %x_GLF_color, vec4<f32>(0.0f)
-        exit_if  # if_3
-      }
-    }
-    ret
-  }
-}
-%main = @fragment func():main_out {
-  $B11: {
-    %45:void = call %main_1
-    %46:vec4<f32> = load %x_GLF_color
-    %47:main_out = construct %46
-    ret %47
-  }
-}
-
diff --git a/test/tint/vk-gl-cts/graphicsfuzz/cov-simplify-clamp-max-itself/0-opt.wgsl.expected.ir.dxc.hlsl b/test/tint/vk-gl-cts/graphicsfuzz/cov-simplify-clamp-max-itself/0-opt.wgsl.expected.ir.dxc.hlsl
deleted file mode 100644
index 3f7ca96caca..00000000000
--- a/test/tint/vk-gl-cts/graphicsfuzz/cov-simplify-clamp-max-itself/0-opt.wgsl.expected.ir.dxc.hlsl
+++ /dev/null
@@ -1,217 +0,0 @@
-SKIP: FAILED
-
-
-struct buf0 {
-  sequence : vec4<i32>,
-}
-
-@group(0) @binding(0) var<uniform> x_7 : buf0;
-
-var<private> x_GLF_color : vec4<f32>;
-
-fn main_1() {
-  var a : vec4<i32>;
-  var i : i32;
-  var sum : i32;
-  a = vec4<i32>(0, 0, 0, 0);
-  i = 0;
-  loop {
-    let x_40 : i32 = i;
-    let x_42 : i32 = x_7.sequence.w;
-    if ((x_40 < (x_42 + 1))) {
-    } else {
-      break;
-    }
-    let x_46 : i32 = i;
-    let x_48 : i32 = x_7.sequence.x;
-    let x_49 : i32 = i;
-    let x_52 : i32 = x_7.sequence[clamp(x_46, x_48, x_49)];
-    if ((x_52 == 1)) {
-      let x_57 : i32 = i;
-      a[x_57] = 5;
-    } else {
-      let x_59 : i32 = i;
-      let x_60 : i32 = i;
-      a[x_59] = x_60;
-    }
-
-    continuing {
-      let x_62 : i32 = i;
-      i = (x_62 + 1);
-    }
-  }
-  let x_65 : i32 = a.x;
-  let x_67 : i32 = a.y;
-  let x_70 : i32 = a.z;
-  let x_73 : i32 = a.w;
-  sum = (((x_65 + x_67) + x_70) + x_73);
-  let x_75 : i32 = sum;
-  if ((x_75 == 10)) {
-    x_GLF_color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
-  } else {
-    x_GLF_color = vec4<f32>(0.0, 0.0, 0.0, 0.0);
-  }
-  return;
-}
-
-struct main_out {
-  @location(0)
-  x_GLF_color_1 : vec4<f32>,
-}
-
-@fragment
-fn main() -> main_out {
-  main_1();
-  return main_out(x_GLF_color);
-}
-
-Failed to generate: :49:9 error: binary: no matching overload for 'operator * (i32, u32)'
-
-9 candidate operators:
- • 'operator * (T  ✓ , T  ✗ ) -> T' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (vecN<T>  ✗ , T  ✓ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✓ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✓  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (T  ✗ , matNxM<T>  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matNxM<T>  ✗ , T  ✗ ) -> matNxM<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecN<T>  ✗ , vecN<T>  ✗ ) -> vecN<T>' where:
-      ✗  'T' is 'f32', 'i32', 'u32' or 'f16'
- • 'operator * (matCxR<T>  ✗ , vecC<T>  ✗ ) -> vecR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (vecR<T>  ✗ , matCxR<T>  ✗ ) -> vecC<T>' where:
-      ✗  'T' is 'f32' or 'f16'
- • 'operator * (matKxR<T>  ✗ , matCxK<T>  ✗ ) -> matCxR<T>' where:
-      ✗  'T' is 'f32' or 'f16'
-
-        %25:u32 = mul %24, 4u
-        ^^^^^^^^^^^^^^^^^^^^^
-
-:22:7 note: in block
-      $B3: {  # body
-      ^^^
-
-note: # Disassembly
-buf0 = struct @align(16) {
-  sequence:vec4<i32> @offset(0)
-}
-
-main_out = struct @align(16) {
-  x_GLF_color_1:vec4<f32> @offset(0), @location(0)
-}
-
-$B1: {  # root
-  %x_7:ptr<uniform, array<vec4<u32>, 1>, read> = var @binding_point(0, 0)
-  %x_GLF_color:ptr<private, vec4<f32>, read_write> = var
-}
-
-%main_1 = func():void {
-  $B2: {
-    %a:ptr<function, vec4<i32>, read_write> = var
-    %i:ptr<function, i32, read_write> = var
-    %sum:ptr<function, i32, read_write> = var
-    store %a, vec4<i32>(0i)
-    store %i, 0i
-    loop [b: $B3, c: $B4] {  # loop_1
-      $B3: {  # body
-        %7:i32 = load %i
-        %x_40:i32 = let %7
-        %9:ptr<uniform, vec4<u32>, read> = access %x_7, 0u
-        %10:u32 = load_vector_element %9, 3u
-        %11:i32 = bitcast %10
-        %x_42:i32 = let %11
-        %13:i32 = add %x_42, 1i
-        %14:bool = lt %x_40, %13
-        if %14 [t: $B5, f: $B6] {  # if_1
-          $B5: {  # true
-            exit_if  # if_1
-          }
-          $B6: {  # false
-            exit_loop  # loop_1
-          }
-        }
-        %15:i32 = load %i
-        %x_46:i32 = let %15
-        %17:ptr<uniform, vec4<u32>, read> = access %x_7, 0u
-        %18:u32 = load_vector_element %17, 0u
-        %19:i32 = bitcast %18
-        %x_48:i32 = let %19
-        %21:i32 = load %i
-        %x_49:i32 = let %21
-        %23:i32 = max %x_46, %x_48
-        %24:i32 = min %23, %x_49
-        %25:u32 = mul %24, 4u
-        %26:u32 = div %25, 16u
-        %27:ptr<uniform, vec4<u32>, read> = access %x_7, %26
-        %28:u32 = mod %25, 16u
-        %29:u32 = div %28, 4u
-        %30:u32 = load_vector_element %27, %29
-        %31:i32 = bitcast %30
-        %x_52:i32 = let %31
-        %33:bool = eq %x_52, 1i
-        if %33 [t: $B7, f: $B8] {  # if_2
-          $B7: {  # true
-            %34:i32 = load %i
-            %x_57:i32 = let %34
-            store_vector_element %a, %x_57, 5i
-            exit_if  # if_2
-          }
-          $B8: {  # false
-            %36:i32 = load %i
-            %x_59:i32 = let %36
-            %38:i32 = load %i
-            %x_60:i32 = let %38
-            store_vector_element %a, %x_59, %x_60
-            exit_if  # if_2
-          }
-        }
-        continue  # -> $B4
-      }
-      $B4: {  # continuing
-        %40:i32 = load %i
-        %x_62:i32 = let %40
-        %42:i32 = add %x_62, 1i
-        store %i, %42
-        next_iteration  # -> $B3
-      }
-    }
-    %43:i32 = load_vector_element %a, 0u
-    %x_65:i32 = let %43
-    %45:i32 = load_vector_element %a, 1u
-    %x_67:i32 = let %45
-    %47:i32 = load_vector_element %a, 2u
-    %x_70:i32 = let %47
-    %49:i32 = load_vector_element %a, 3u
-    %x_73:i32 = let %49
-    %51:i32 = add %x_65, %x_67
-    %52:i32 = add %51, %x_70
-    %53:i32 = add %52, %x_73
-    store %sum, %53
-    %54:i32 = load %sum
-    %x_75:i32 = let %54
-    %56:bool = eq %x_75, 10i
-    if %56 [t: $B9, f: $B10] {  # if_3
-      $B9: {  # true
-        store %x_GLF_color, vec4<f32>(1.0f, 0.0f, 0.0f, 1.0f)
-        exit_if  # if_3
-      }
-      $B10: {  # false
-        store %x_GLF_color, vec4<f32>(0.0f)
-        exit_if  # if_3
-      }
-    }
-    ret
-  }
-}
-%main = @fragment func():main_out {
-  $B11: {
-    %58:void = call %main_1
-    %59:vec4<f32> = load %x_GLF_color
-    %60:main_out = construct %59
-    ret %60
-  }
-}
-