diff --git a/resources/sksl/intrinsics/BitCount.sksl b/resources/sksl/intrinsics/BitCount.sksl
index 5f85cdb..9ef0bfd 100644
--- a/resources/sksl/intrinsics/BitCount.sksl
+++ b/resources/sksl/intrinsics/BitCount.sksl
@@ -1,6 +1,10 @@
 uniform int a;
 uniform uint b;
 void main() {
-    sk_FragColor.x = half(bitCount(a));
-    sk_FragColor.y = half(bitCount(b));
+    int b1 = bitCount(a) + bitCount(b);
+    int2 b2 = bitCount(int2(a)) + bitCount(uint2(b));
+    int3 b3 = bitCount(int3(a)) + bitCount(uint3(b));
+    int4 b4 = bitCount(int4(a)) + bitCount(uint4(b));
+
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
 }
diff --git a/resources/sksl/intrinsics/FindLSB.sksl b/resources/sksl/intrinsics/FindLSB.sksl
index 8a8955a..b181e25 100644
--- a/resources/sksl/intrinsics/FindLSB.sksl
+++ b/resources/sksl/intrinsics/FindLSB.sksl
@@ -1,6 +1,10 @@
 uniform int a;
 uniform uint b;
 void main() {
-    sk_FragColor.x = half(findLSB(a));
-    sk_FragColor.y = half(findLSB(b));
+    int b1 = findLSB(a) + findLSB(b);
+    int2 b2 = findLSB(int2(a)) + findLSB(uint2(b));
+    int3 b3 = findLSB(int3(a)) + findLSB(uint3(b));
+    int4 b4 = findLSB(int4(a)) + findLSB(uint4(b));
+
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
 }
diff --git a/resources/sksl/intrinsics/FindMSB.sksl b/resources/sksl/intrinsics/FindMSB.sksl
index 66b2dd3..2eb183c 100644
--- a/resources/sksl/intrinsics/FindMSB.sksl
+++ b/resources/sksl/intrinsics/FindMSB.sksl
@@ -1,6 +1,10 @@
 uniform int a;
 uniform uint b;
 void main() {
-    sk_FragColor.x = half(findMSB(a));
-    sk_FragColor.y = half(findMSB(b));
+    int b1 = findMSB(a) + findMSB(b);
+    int2 b2 = findMSB(int2(a)) + findMSB(uint2(b));
+    int3 b3 = findMSB(int3(a)) + findMSB(uint3(b));
+    int4 b4 = findMSB(int4(a)) + findMSB(uint4(b));
+
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
 }
diff --git a/src/sksl/codegen/SkSLMetalCodeGenerator.cpp b/src/sksl/codegen/SkSLMetalCodeGenerator.cpp
index 686a547..069f630 100644
--- a/src/sksl/codegen/SkSLMetalCodeGenerator.cpp
+++ b/src/sksl/codegen/SkSLMetalCodeGenerator.cpp
@@ -1165,28 +1165,38 @@
             return true;
         }
         case k_bitCount_IntrinsicKind: {
-            this->write("popcount(");
+            // Cast to the signed return type required in SkSL
+            if (!c.arguments()[0]->type().componentType().isSigned()) {
+                this->write(this->typeName(c.type()));
+            }
+            this->write("(popcount(");
             this->writeExpression(*arguments[0], Precedence::kSequence);
-            this->write(")");
+            this->write("))");
             return true;
         }
         case k_findLSB_IntrinsicKind: {
             // Create a temp variable to store the expression, to avoid double-evaluating it.
             std::string skTemp = this->getTempVariable(arguments[0]->type());
+            std::string signedType = this->typeName(c.type()); // The return type is always signed
             std::string exprType = this->typeName(arguments[0]->type());
 
             // ctz returns numbits(type) on zero inputs; GLSL documents it as generating -1 instead.
-            // Use select to detect zero inputs and force a -1 result.
+            // - Use select to detect zero inputs and force a -1 result.
+            // - ctz returns an unsigned value for unsigned inputs, so we have to cast back to int
 
-            // (_skTemp1 = (.....), select(ctz(_skTemp1), int4(-1), _skTemp1 == int4(0)))
+            // (_skTemp1 = (.....), select(int4(ctz(_skTemp1)), int4(-1), _skTemp1 == int4(0)))
             this->write("(");
             this->write(skTemp);
             this->write(" = (");
             this->writeExpression(*arguments[0], Precedence::kSequence);
-            this->write("), select(ctz(");
+            this->write("), select(");
+            if (!c.arguments()[0]->type().componentType().isSigned()) {
+                this->write(signedType);
+            }
+            this->write("(ctz(");
             this->write(skTemp);
-            this->write("), ");
-            this->write(exprType);
+            this->write(")), ");
+            this->write(signedType);
             this->write("(-1), ");
             this->write(skTemp);
             this->write(" == ");
@@ -1197,11 +1207,14 @@
         case k_findMSB_IntrinsicKind: {
             // Create a temp variable to store the expression, to avoid double-evaluating it.
             std::string skTemp1 = this->getTempVariable(arguments[0]->type());
+            std::string signedType = this->typeName(c.type()); // The return type is always signed
             std::string exprType = this->typeName(arguments[0]->type());
 
             // GLSL findMSB is actually quite different from Metal's clz:
             // - For signed negative numbers, it returns the first zero bit, not the first one bit!
             // - For an empty input (0/~0 depending on sign), findMSB gives -1; clz is numbits(type)
+            // - clz is relative to the MSB whereas findMSB returns a 0-based bit number
+            // - clz returns an unsigned value for unsigned inputs, so we have to cast back to int
 
             // (_skTemp1 = (.....),
             this->write("(");
@@ -1228,13 +1241,15 @@
                 skTemp2 = skTemp1;
             }
 
-            // ... select(int4(clz(_skTemp2)), int4(-1), _skTemp2 == int4(0)))
-            this->write("select(");
-            this->write(this->typeName(c.type()));
+            // ... select(int4(31) - int4(clz(_skTemp2)), int4(-1), _skTemp2 == int4(0)))
+            this->write("select(31 - "); // Assuming 32-bit integer types
+            if (!c.arguments()[0]->type().componentType().isSigned()) {
+                this->write(signedType);
+            }
             this->write("(clz(");
             this->write(skTemp2);
             this->write(")), ");
-            this->write(this->typeName(c.type()));
+            this->write(signedType);
             this->write("(-1), ");
             this->write(skTemp2);
             this->write(" == ");
diff --git a/src/sksl/codegen/SkSLWGSLCodeGenerator.cpp b/src/sksl/codegen/SkSLWGSLCodeGenerator.cpp
index b9ca5b4..96973e4 100644
--- a/src/sksl/codegen/SkSLWGSLCodeGenerator.cpp
+++ b/src/sksl/codegen/SkSLWGSLCodeGenerator.cpp
@@ -168,6 +168,10 @@
                       PrettyPrint pp,
                       IncludeSyntheticCode isc)
             : CodeGenerator(context, caps, program, out)
+            , fWrittenInverse({false, false, false})
+            , fWrittenOuterProduct({std::array{false, false, false},
+                                    std::array{false, false, false},
+                                    std::array{false, false, false}})
             , fPrettyPrint(pp)
             , fGenSyntheticCode(isc) {}
 
@@ -294,6 +298,7 @@
                                                                   const Expression& sampler,
                                                                   const Expression& coords);
     std::string assembleInversePolyfill(const FunctionCall& call);
+    std::string assembleOuterProductPolyfill(const FunctionCall& call);
     std::string assembleComponentwiseMatrixBinary(const Type& leftType,
                                                   const Type& rightType,
                                                   const std::string& left,
@@ -392,10 +397,10 @@
     skia_private::TArray<const Variable*> fPipelineOutputs;
 
     // These fields track whether we have written the polyfill for `inverse()` for a given matrix
-    // type.
-    bool fWrittenInverse2 = false;
-    bool fWrittenInverse3 = false;
-    bool fWrittenInverse4 = false;
+    // type. Indexed by row or column count - 2, i.e. [2,3,4] -> idx [0,1,2]
+    std::array<bool, 3> fWrittenInverse;
+    std::array<std::array<bool, 3>, 3> fWrittenOuterProduct;
+
     PrettyPrint fPrettyPrint;
     IncludeSyntheticCode fGenSyntheticCode;
 
@@ -3188,6 +3193,9 @@
         case k_inverse_IntrinsicKind:
             return this->assembleInversePolyfill(call);
 
+        case k_outerProduct_IntrinsicKind:
+            return this->assembleOuterProductPolyfill(call);
+
         case k_inversesqrt_IntrinsicKind:
             return this->assembleSimpleIntrinsic("inverseSqrt", call);
 
@@ -3254,6 +3262,45 @@
         case k_packUnorm4x8_IntrinsicKind:
             return this->assembleSimpleIntrinsic("pack4x8unorm", call);
 
+        case k_findLSB_IntrinsicKind: {
+            // firstTrailingBit (and firstLeadingBit) return a type matching their input, but
+            // findLSB and findMSB in SkSL return signed types. Add a cast if needed.
+            std::string lsb = this->assembleSimpleIntrinsic("firstTrailingBit", call);
+            return arguments[0]->type().componentType().isSigned() ? lsb :
+                    (to_wgsl_type(fContext, call.type()) + "(" + lsb + ")");
+        }
+
+        case k_findMSB_IntrinsicKind: {
+            std::string msb = this->assembleSimpleIntrinsic("firstLeadingBit", call);
+            return arguments[0]->type().componentType().isSigned() ? msb :
+                    (to_wgsl_type(fContext, call.type()) + "(" + msb + ")");
+        }
+
+        case k_bitCount_IntrinsicKind: {
+            // countOneBits returns a type matching its input, but bitCount in SkSL returns a
+            // signed type. Add a cast if needed.
+            std::string bitCount = this->assembleSimpleIntrinsic("countOneBits", call);
+            return arguments[0]->type().componentType().isSigned() ? bitCount :
+                    (to_wgsl_type(fContext, call.type()) + "(" + bitCount + ")");
+        }
+
+        case k_floatBitsToInt_IntrinsicKind:
+        case k_floatBitsToUint_IntrinsicKind:
+        case k_intBitsToFloat_IntrinsicKind:
+        case k_uintBitsToFloat_IntrinsicKind: {
+            std::string outputType = to_wgsl_type(fContext, call.type());
+            return this->assembleSimpleIntrinsic("bitcast<" + outputType + ">", call);
+        }
+
+        case k_roundEven_IntrinsicKind:
+        case k_round_IntrinsicKind:
+            // WGSL has no built-in roundEven(), but its round() is defined as:
+            //     "When e lies halfway between integers k and k + 1, the result is k when k is
+            //      even, and k + 1 when k is odd."
+            // This is equivalent to GLSL's roundEven(). GLSL's round() is allowed to just match
+            // roundEven().
+            return this->assembleSimpleIntrinsic("round", call);
+
         case k_reflect_IntrinsicKind:
             if (arguments[0]->type().isScalar()) {
                 // I - 2 * N * I * N
@@ -3471,6 +3518,22 @@
 "\n" "}"
 "\n";
 
+// Generates outer_product_$Cx$R(vec$R<f32}>, vec$C<f32>) -> mat$Cx$R<f32>
+static std::string gen_outer_product_fn(int c, int r) {
+    return String::printf(
+            "fn outer_product%dx%d(a: vec%d<f32>, b: vec%d<f32>) -> mat%dx%d<f32> {\n"
+                "var m : mat%dx%d<f32>;\n"
+                "for (var c = 0; c < %d; c++) { m[c] = a * b[c]; }\n"
+                "return m;\n"
+            "}\n",
+            /* outer_product$Cx$R */ c, r,
+            /* vec$R */ r,
+            /* vec$C */ c,
+            /* mat$Cx$R */ c, r,
+            /* mat$Cx$R */ c, r,
+            /* c < $C */ c);
+}
+
 std::string WGSLCodeGenerator::assembleInversePolyfill(const FunctionCall& call) {
     const ExpressionArray& arguments = call.arguments();
     const Type& type = arguments.front()->type();
@@ -3482,32 +3545,37 @@
     SkASSERT(type.isMatrix());
     SkASSERT(type.rows() == type.columns());
 
-    switch (type.slotCount()) {
-        case 4:
-            if (!fWrittenInverse2) {
-                fWrittenInverse2 = true;
-                fHeader.writeText(kInverse2x2);
-            }
-            return this->assembleSimpleIntrinsic("mat2_inverse", call);
-
-        case 9:
-            if (!fWrittenInverse3) {
-                fWrittenInverse3 = true;
-                fHeader.writeText(kInverse3x3);
-            }
-            return this->assembleSimpleIntrinsic("mat3_inverse", call);
-
-        case 16:
-            if (!fWrittenInverse4) {
-                fWrittenInverse4 = true;
-                fHeader.writeText(kInverse4x4);
-            }
-            return this->assembleSimpleIntrinsic("mat4_inverse", call);
-
-        default:
-            // We only support square matrices.
-            SkUNREACHABLE;
+    const int idx = type.rows() - 2;
+    if (!fWrittenInverse[idx]) {
+        static constexpr std::array<const char*, 3> kTemplates{kInverse2x2,
+                                                               kInverse3x3,
+                                                               kInverse4x4};
+        fWrittenInverse[idx] = true;
+        fHeader.writeText(kTemplates[idx]);
     }
+    return this->assembleSimpleIntrinsic(String::printf("mat%d_inverse", type.rows()), call);
+}
+
+std::string WGSLCodeGenerator::assembleOuterProductPolyfill(const FunctionCall& call) {
+    // The outer product should take two vector arguments, with the first type's component count
+    // defining R and the second type's component count defining C.
+    const ExpressionArray& arguments = call.arguments();
+    SkASSERT(arguments.size() == 2);
+    SkASSERT(arguments[0]->type().isVector() && arguments[1]->type().isVector());
+    SkASSERT(call.type().isMatrix());
+
+    const int r = arguments[0]->type().columns();
+    const int c = arguments[1]->type().columns();
+    SkASSERT(r == call.type().rows() && c == call.type().columns());
+
+    const int cIdx = c - 2;
+    const int rIdx = r - 2;
+    if (!fWrittenOuterProduct[cIdx][rIdx]) {
+        fWrittenOuterProduct[cIdx][rIdx] = true;
+        fHeader.writeText(gen_outer_product_fn(c, r).c_str());
+    }
+
+    return this->assembleSimpleIntrinsic(String::printf("outer_product%dx%d", c, r), call);
 }
 
 std::string WGSLCodeGenerator::assembleFunctionCall(const FunctionCall& call,
diff --git a/tests/sksl/intrinsics/BitCount.asm.frag b/tests/sksl/intrinsics/BitCount.asm.frag
index 0e5f83e..dc551ac 100644
--- a/tests/sksl/intrinsics/BitCount.asm.frag
+++ b/tests/sksl/intrinsics/BitCount.asm.frag
@@ -10,6 +10,10 @@
                OpMemberName %_UniformBuffer 0 "a"
                OpMemberName %_UniformBuffer 1 "b"
                OpName %main "main"                  ; id %6
+               OpName %b1 "b1"                      ; id %18
+               OpName %b2 "b2"                      ; id %31
+               OpName %b3 "b3"                      ; id %44
+               OpName %b4 "b4"                      ; id %57
 
                ; Annotations
                OpDecorate %sk_FragColor RelaxedPrecision
@@ -20,8 +24,11 @@
                OpDecorate %_UniformBuffer Block
                OpDecorate %11 Binding 0
                OpDecorate %11 DescriptorSet 0
-               OpDecorate %23 RelaxedPrecision
-               OpDecorate %31 RelaxedPrecision
+               OpDecorate %80 RelaxedPrecision
+               OpDecorate %82 RelaxedPrecision
+               OpDecorate %84 RelaxedPrecision
+               OpDecorate %86 RelaxedPrecision
+               OpDecorate %87 RelaxedPrecision
 
                ; Types, variables and constants
         %int = OpTypeInt 32 1
@@ -36,28 +43,86 @@
          %11 = OpVariable %_ptr_Uniform__UniformBuffer Uniform  ; Binding 0, DescriptorSet 0
        %void = OpTypeVoid
          %16 = OpTypeFunction %void
+%_ptr_Function_int = OpTypePointer Function %int
 %_ptr_Uniform_int = OpTypePointer Uniform %int
       %int_0 = OpConstant %int 0
-%_ptr_Output_float = OpTypePointer Output %float
 %_ptr_Uniform_uint = OpTypePointer Uniform %uint
       %int_1 = OpConstant %int 1
+      %v2int = OpTypeVector %int 2
+%_ptr_Function_v2int = OpTypePointer Function %v2int
+     %v2uint = OpTypeVector %uint 2
+      %v3int = OpTypeVector %int 3
+%_ptr_Function_v3int = OpTypePointer Function %v3int
+     %v3uint = OpTypeVector %uint 3
+      %v4int = OpTypeVector %int 4
+%_ptr_Function_v4int = OpTypePointer Function %v4int
+     %v4uint = OpTypeVector %uint 4
 
 
                ; Function main
        %main = OpFunction %void None %16
 
          %17 = OpLabel
-         %19 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
-         %22 =   OpLoad %int %19
-         %18 =   OpBitCount %int %22
-         %23 =   OpConvertSToF %float %18           ; RelaxedPrecision
-         %24 =   OpAccessChain %_ptr_Output_float %sk_FragColor %int_0
-                 OpStore %24 %23
-         %27 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
-         %30 =   OpLoad %uint %27
-         %26 =   OpBitCount %int %30
-         %31 =   OpConvertSToF %float %26           ; RelaxedPrecision
-         %32 =   OpAccessChain %_ptr_Output_float %sk_FragColor %int_1
-                 OpStore %32 %31
+         %b1 =   OpVariable %_ptr_Function_int Function
+         %b2 =   OpVariable %_ptr_Function_v2int Function
+         %b3 =   OpVariable %_ptr_Function_v3int Function
+         %b4 =   OpVariable %_ptr_Function_v4int Function
+         %21 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
+         %24 =   OpLoad %int %21
+         %20 =   OpBitCount %int %24
+         %26 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
+         %29 =   OpLoad %uint %26
+         %25 =   OpBitCount %int %29
+         %30 =   OpIAdd %int %20 %25
+                 OpStore %b1 %30
+         %35 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
+         %36 =   OpLoad %int %35
+         %37 =   OpCompositeConstruct %v2int %36 %36
+         %34 =   OpBitCount %v2int %37
+         %39 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
+         %40 =   OpLoad %uint %39
+         %42 =   OpCompositeConstruct %v2uint %40 %40
+         %38 =   OpBitCount %v2int %42
+         %43 =   OpIAdd %v2int %34 %38
+                 OpStore %b2 %43
+         %48 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
+         %49 =   OpLoad %int %48
+         %50 =   OpCompositeConstruct %v3int %49 %49 %49
+         %47 =   OpBitCount %v3int %50
+         %52 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
+         %53 =   OpLoad %uint %52
+         %55 =   OpCompositeConstruct %v3uint %53 %53 %53
+         %51 =   OpBitCount %v3int %55
+         %56 =   OpIAdd %v3int %47 %51
+                 OpStore %b3 %56
+         %61 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
+         %62 =   OpLoad %int %61
+         %63 =   OpCompositeConstruct %v4int %62 %62 %62 %62
+         %60 =   OpBitCount %v4int %63
+         %65 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
+         %66 =   OpLoad %uint %65
+         %68 =   OpCompositeConstruct %v4uint %66 %66 %66 %66
+         %64 =   OpBitCount %v4int %68
+         %69 =   OpIAdd %v4int %60 %64
+                 OpStore %b4 %69
+         %70 =   OpCompositeConstruct %v4int %30 %30 %30 %30
+         %71 =   OpVectorShuffle %v4int %43 %43 0 1 0 1
+         %72 =   OpIAdd %v4int %70 %71
+         %73 =   OpCompositeExtract %int %56 0
+         %74 =   OpCompositeExtract %int %56 1
+         %75 =   OpCompositeExtract %int %56 2
+         %76 =   OpCompositeConstruct %v4int %73 %74 %75 %int_1
+         %77 =   OpIAdd %v4int %72 %76
+         %78 =   OpIAdd %v4int %77 %69
+         %79 =   OpCompositeExtract %int %78 0
+         %80 =   OpConvertSToF %float %79           ; RelaxedPrecision
+         %81 =   OpCompositeExtract %int %78 1
+         %82 =   OpConvertSToF %float %81           ; RelaxedPrecision
+         %83 =   OpCompositeExtract %int %78 2
+         %84 =   OpConvertSToF %float %83           ; RelaxedPrecision
+         %85 =   OpCompositeExtract %int %78 3
+         %86 =   OpConvertSToF %float %85           ; RelaxedPrecision
+         %87 =   OpCompositeConstruct %v4float %80 %82 %84 %86  ; RelaxedPrecision
+                 OpStore %sk_FragColor %87
                  OpReturn
                OpFunctionEnd
diff --git a/tests/sksl/intrinsics/BitCount.glsl b/tests/sksl/intrinsics/BitCount.glsl
index b2af45a..d83e8d4 100644
--- a/tests/sksl/intrinsics/BitCount.glsl
+++ b/tests/sksl/intrinsics/BitCount.glsl
@@ -3,6 +3,9 @@
 uniform int a;
 uniform uint b;
 void main() {
-    sk_FragColor.x = float(bitCount(a));
-    sk_FragColor.y = float(bitCount(b));
+    int b1 = bitCount(a) + bitCount(b);
+    ivec2 b2 = bitCount(ivec2(a)) + bitCount(uvec2(b));
+    ivec3 b3 = bitCount(ivec3(a)) + bitCount(uvec3(b));
+    ivec4 b4 = bitCount(ivec4(a)) + bitCount(uvec4(b));
+    sk_FragColor = vec4(((ivec4(b1) + b2.xyxy) + ivec4(b3, 1)) + b4);
 }
diff --git a/tests/sksl/intrinsics/BitCount.hlsl b/tests/sksl/intrinsics/BitCount.hlsl
index ff4813e..613a07a 100644
--- a/tests/sksl/intrinsics/BitCount.hlsl
+++ b/tests/sksl/intrinsics/BitCount.hlsl
@@ -14,8 +14,16 @@
 
 void frag_main()
 {
-    sk_FragColor.x = float(countbits(_11_a));
-    sk_FragColor.y = float(int(countbits(_11_b)));
+    int _30 = countbits(_11_a) + int(countbits(_11_b));
+    int b1 = _30;
+    int2 _43 = countbits(_11_a.xx) + int2(countbits(_11_b.xx));
+    int2 b2 = _43;
+    int3 _56 = countbits(_11_a.xxx) + int3(countbits(_11_b.xxx));
+    int3 b3 = _56;
+    int4 _69 = countbits(_11_a.xxxx) + int4(countbits(_11_b.xxxx));
+    int4 b4 = _69;
+    int4 _78 = ((_30.xxxx + _43.xyxy) + int4(_56, 1)) + _69;
+    sk_FragColor = float4(float(_78.x), float(_78.y), float(_78.z), float(_78.w));
 }
 
 SPIRV_Cross_Output main()
diff --git a/tests/sksl/intrinsics/BitCount.metal b/tests/sksl/intrinsics/BitCount.metal
index 5d7c1ad..7481823 100644
--- a/tests/sksl/intrinsics/BitCount.metal
+++ b/tests/sksl/intrinsics/BitCount.metal
@@ -16,7 +16,10 @@
 fragment Outputs fragmentMain(Inputs _in [[stage_in]], constant Uniforms& _uniforms [[buffer(0)]], bool _frontFacing [[front_facing]], float4 _fragCoord [[position]]) {
     Outputs _out;
     (void)_out;
-    _out.sk_FragColor.x = half(popcount(_uniforms.a));
-    _out.sk_FragColor.y = half(popcount(_uniforms.b));
+    int b1 = (popcount(_uniforms.a)) + int(popcount(_uniforms.b));
+    int2 b2 = (popcount(int2(_uniforms.a))) + int2(popcount(uint2(_uniforms.b)));
+    int3 b3 = (popcount(int3(_uniforms.a))) + int3(popcount(uint3(_uniforms.b)));
+    int4 b4 = (popcount(int4(_uniforms.a))) + int4(popcount(uint4(_uniforms.b)));
+    _out.sk_FragColor = half4(((int4(b1) + b2.xyxy) + int4(b3, 1)) + b4);
     return _out;
 }
diff --git a/tests/sksl/intrinsics/BitCount.skrp b/tests/sksl/intrinsics/BitCount.skrp
index 436b624..05d2f10 100644
--- a/tests/sksl/intrinsics/BitCount.skrp
+++ b/tests/sksl/intrinsics/BitCount.skrp
@@ -6,16 +6,43 @@
 error: 3: 'main' must return: 'vec4', 'float4', or 'half4'
 void main() {
 ^^^^^^^^^^^
-error: 4: unknown identifier 'sk_FragColor'
-    sk_FragColor.x = half(bitCount(a));
-    ^^^^^^^^^^^^
 error: 4: unknown identifier 'bitCount'
-    sk_FragColor.x = half(bitCount(a));
-                          ^^^^^^^^
-error: 5: unknown identifier 'sk_FragColor'
-    sk_FragColor.y = half(bitCount(b));
-    ^^^^^^^^^^^^
+    int b1 = bitCount(a) + bitCount(b);
+             ^^^^^^^^
+error: 4: unknown identifier 'bitCount'
+    int b1 = bitCount(a) + bitCount(b);
+                           ^^^^^^^^
 error: 5: unknown identifier 'bitCount'
-    sk_FragColor.y = half(bitCount(b));
-                          ^^^^^^^^
-6 errors
+    int2 b2 = bitCount(int2(a)) + bitCount(uint2(b));
+              ^^^^^^^^
+error: 5: unknown identifier 'bitCount'
+    int2 b2 = bitCount(int2(a)) + bitCount(uint2(b));
+                                  ^^^^^^^^
+error: 6: unknown identifier 'bitCount'
+    int3 b3 = bitCount(int3(a)) + bitCount(uint3(b));
+              ^^^^^^^^
+error: 6: unknown identifier 'bitCount'
+    int3 b3 = bitCount(int3(a)) + bitCount(uint3(b));
+                                  ^^^^^^^^
+error: 7: unknown identifier 'bitCount'
+    int4 b4 = bitCount(int4(a)) + bitCount(uint4(b));
+              ^^^^^^^^
+error: 7: unknown identifier 'bitCount'
+    int4 b4 = bitCount(int4(a)) + bitCount(uint4(b));
+                                  ^^^^^^^^
+error: 9: unknown identifier 'sk_FragColor'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+    ^^^^^^^^^^^^
+error: 9: unknown identifier 'b1'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+                         ^^
+error: 9: unknown identifier 'b2'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+                                   ^^
+error: 9: unknown identifier 'b3'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+                                             ^^
+error: 9: unknown identifier 'b4'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+                                                       ^^
+15 errors
diff --git a/tests/sksl/intrinsics/BitCount.wgsl b/tests/sksl/intrinsics/BitCount.wgsl
index 848d4bd..82e5720 100644
--- a/tests/sksl/intrinsics/BitCount.wgsl
+++ b/tests/sksl/intrinsics/BitCount.wgsl
@@ -1,7 +1,3 @@
-### Compilation failed:
-
-error: Tint compilation failed.
-
 diagnostic(off, derivative_uniformity);
 diagnostic(off, chromium.unreachable_code);
 struct FSOut {
@@ -14,8 +10,11 @@
 @binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
 fn _skslMain(_stageOut: ptr<function, FSOut>) {
   {
-    (*_stageOut).sk_FragColor.x = f32(bitCount(_globalUniforms.a));
-    (*_stageOut).sk_FragColor.y = f32(bitCount(_globalUniforms.b));
+    let b1: i32 = countOneBits(_globalUniforms.a) + i32(countOneBits(_globalUniforms.b));
+    let b2: vec2<i32> = countOneBits(vec2<i32>(_globalUniforms.a)) + vec2<i32>(countOneBits(vec2<u32>(_globalUniforms.b)));
+    let b3: vec3<i32> = countOneBits(vec3<i32>(_globalUniforms.a)) + vec3<i32>(countOneBits(vec3<u32>(_globalUniforms.b)));
+    let b4: vec4<i32> = countOneBits(vec4<i32>(_globalUniforms.a)) + vec4<i32>(countOneBits(vec4<u32>(_globalUniforms.b)));
+    (*_stageOut).sk_FragColor = vec4<f32>(((vec4<i32>(b1) + b2.xyxy) + vec4<i32>(b3, 1)) + b4);
   }
 }
 @fragment fn main() -> FSOut {
@@ -23,5 +22,3 @@
   _skslMain(&_stageOut);
   return _stageOut;
 }
-
-1 error
diff --git a/tests/sksl/intrinsics/FindLSB.asm.frag b/tests/sksl/intrinsics/FindLSB.asm.frag
index f927dc3..cb8fdd5 100644
--- a/tests/sksl/intrinsics/FindLSB.asm.frag
+++ b/tests/sksl/intrinsics/FindLSB.asm.frag
@@ -10,6 +10,10 @@
                OpMemberName %_UniformBuffer 0 "a"
                OpMemberName %_UniformBuffer 1 "b"
                OpName %main "main"                  ; id %6
+               OpName %b1 "b1"                      ; id %18
+               OpName %b2 "b2"                      ; id %31
+               OpName %b3 "b3"                      ; id %44
+               OpName %b4 "b4"                      ; id %57
 
                ; Annotations
                OpDecorate %sk_FragColor RelaxedPrecision
@@ -20,8 +24,11 @@
                OpDecorate %_UniformBuffer Block
                OpDecorate %11 Binding 0
                OpDecorate %11 DescriptorSet 0
-               OpDecorate %23 RelaxedPrecision
-               OpDecorate %31 RelaxedPrecision
+               OpDecorate %80 RelaxedPrecision
+               OpDecorate %82 RelaxedPrecision
+               OpDecorate %84 RelaxedPrecision
+               OpDecorate %86 RelaxedPrecision
+               OpDecorate %87 RelaxedPrecision
 
                ; Types, variables and constants
         %int = OpTypeInt 32 1
@@ -36,28 +43,86 @@
          %11 = OpVariable %_ptr_Uniform__UniformBuffer Uniform  ; Binding 0, DescriptorSet 0
        %void = OpTypeVoid
          %16 = OpTypeFunction %void
+%_ptr_Function_int = OpTypePointer Function %int
 %_ptr_Uniform_int = OpTypePointer Uniform %int
       %int_0 = OpConstant %int 0
-%_ptr_Output_float = OpTypePointer Output %float
 %_ptr_Uniform_uint = OpTypePointer Uniform %uint
       %int_1 = OpConstant %int 1
+      %v2int = OpTypeVector %int 2
+%_ptr_Function_v2int = OpTypePointer Function %v2int
+     %v2uint = OpTypeVector %uint 2
+      %v3int = OpTypeVector %int 3
+%_ptr_Function_v3int = OpTypePointer Function %v3int
+     %v3uint = OpTypeVector %uint 3
+      %v4int = OpTypeVector %int 4
+%_ptr_Function_v4int = OpTypePointer Function %v4int
+     %v4uint = OpTypeVector %uint 4
 
 
                ; Function main
        %main = OpFunction %void None %16
 
          %17 = OpLabel
-         %19 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
-         %22 =   OpLoad %int %19
-         %18 =   OpExtInst %int %5 FindILsb %22
-         %23 =   OpConvertSToF %float %18           ; RelaxedPrecision
-         %24 =   OpAccessChain %_ptr_Output_float %sk_FragColor %int_0
-                 OpStore %24 %23
-         %27 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
-         %30 =   OpLoad %uint %27
-         %26 =   OpExtInst %int %5 FindILsb %30
-         %31 =   OpConvertSToF %float %26           ; RelaxedPrecision
-         %32 =   OpAccessChain %_ptr_Output_float %sk_FragColor %int_1
-                 OpStore %32 %31
+         %b1 =   OpVariable %_ptr_Function_int Function
+         %b2 =   OpVariable %_ptr_Function_v2int Function
+         %b3 =   OpVariable %_ptr_Function_v3int Function
+         %b4 =   OpVariable %_ptr_Function_v4int Function
+         %21 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
+         %24 =   OpLoad %int %21
+         %20 =   OpExtInst %int %5 FindILsb %24
+         %26 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
+         %29 =   OpLoad %uint %26
+         %25 =   OpExtInst %int %5 FindILsb %29
+         %30 =   OpIAdd %int %20 %25
+                 OpStore %b1 %30
+         %35 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
+         %36 =   OpLoad %int %35
+         %37 =   OpCompositeConstruct %v2int %36 %36
+         %34 =   OpExtInst %v2int %5 FindILsb %37
+         %39 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
+         %40 =   OpLoad %uint %39
+         %42 =   OpCompositeConstruct %v2uint %40 %40
+         %38 =   OpExtInst %v2int %5 FindILsb %42
+         %43 =   OpIAdd %v2int %34 %38
+                 OpStore %b2 %43
+         %48 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
+         %49 =   OpLoad %int %48
+         %50 =   OpCompositeConstruct %v3int %49 %49 %49
+         %47 =   OpExtInst %v3int %5 FindILsb %50
+         %52 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
+         %53 =   OpLoad %uint %52
+         %55 =   OpCompositeConstruct %v3uint %53 %53 %53
+         %51 =   OpExtInst %v3int %5 FindILsb %55
+         %56 =   OpIAdd %v3int %47 %51
+                 OpStore %b3 %56
+         %61 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
+         %62 =   OpLoad %int %61
+         %63 =   OpCompositeConstruct %v4int %62 %62 %62 %62
+         %60 =   OpExtInst %v4int %5 FindILsb %63
+         %65 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
+         %66 =   OpLoad %uint %65
+         %68 =   OpCompositeConstruct %v4uint %66 %66 %66 %66
+         %64 =   OpExtInst %v4int %5 FindILsb %68
+         %69 =   OpIAdd %v4int %60 %64
+                 OpStore %b4 %69
+         %70 =   OpCompositeConstruct %v4int %30 %30 %30 %30
+         %71 =   OpVectorShuffle %v4int %43 %43 0 1 0 1
+         %72 =   OpIAdd %v4int %70 %71
+         %73 =   OpCompositeExtract %int %56 0
+         %74 =   OpCompositeExtract %int %56 1
+         %75 =   OpCompositeExtract %int %56 2
+         %76 =   OpCompositeConstruct %v4int %73 %74 %75 %int_1
+         %77 =   OpIAdd %v4int %72 %76
+         %78 =   OpIAdd %v4int %77 %69
+         %79 =   OpCompositeExtract %int %78 0
+         %80 =   OpConvertSToF %float %79           ; RelaxedPrecision
+         %81 =   OpCompositeExtract %int %78 1
+         %82 =   OpConvertSToF %float %81           ; RelaxedPrecision
+         %83 =   OpCompositeExtract %int %78 2
+         %84 =   OpConvertSToF %float %83           ; RelaxedPrecision
+         %85 =   OpCompositeExtract %int %78 3
+         %86 =   OpConvertSToF %float %85           ; RelaxedPrecision
+         %87 =   OpCompositeConstruct %v4float %80 %82 %84 %86  ; RelaxedPrecision
+                 OpStore %sk_FragColor %87
                  OpReturn
                OpFunctionEnd
diff --git a/tests/sksl/intrinsics/FindLSB.glsl b/tests/sksl/intrinsics/FindLSB.glsl
index 5249f24..3f97218 100644
--- a/tests/sksl/intrinsics/FindLSB.glsl
+++ b/tests/sksl/intrinsics/FindLSB.glsl
@@ -3,6 +3,9 @@
 uniform int a;
 uniform uint b;
 void main() {
-    sk_FragColor.x = float(findLSB(a));
-    sk_FragColor.y = float(findLSB(b));
+    int b1 = findLSB(a) + findLSB(b);
+    ivec2 b2 = findLSB(ivec2(a)) + findLSB(uvec2(b));
+    ivec3 b3 = findLSB(ivec3(a)) + findLSB(uvec3(b));
+    ivec4 b4 = findLSB(ivec4(a)) + findLSB(uvec4(b));
+    sk_FragColor = vec4(((ivec4(b1) + b2.xyxy) + ivec4(b3, 1)) + b4);
 }
diff --git a/tests/sksl/intrinsics/FindLSB.hlsl b/tests/sksl/intrinsics/FindLSB.hlsl
index 8e3fb74..8925ea8 100644
--- a/tests/sksl/intrinsics/FindLSB.hlsl
+++ b/tests/sksl/intrinsics/FindLSB.hlsl
@@ -14,8 +14,16 @@
 
 void frag_main()
 {
-    sk_FragColor.x = float(firstbitlow(_11_a));
-    sk_FragColor.y = float(int(firstbitlow(_11_b)));
+    int _30 = firstbitlow(_11_a) + int(firstbitlow(_11_b));
+    int b1 = _30;
+    int2 _43 = firstbitlow(_11_a.xx) + int2(firstbitlow(_11_b.xx));
+    int2 b2 = _43;
+    int3 _56 = firstbitlow(_11_a.xxx) + int3(firstbitlow(_11_b.xxx));
+    int3 b3 = _56;
+    int4 _69 = firstbitlow(_11_a.xxxx) + int4(firstbitlow(_11_b.xxxx));
+    int4 b4 = _69;
+    int4 _78 = ((_30.xxxx + _43.xyxy) + int4(_56, 1)) + _69;
+    sk_FragColor = float4(float(_78.x), float(_78.y), float(_78.z), float(_78.w));
 }
 
 SPIRV_Cross_Output main()
diff --git a/tests/sksl/intrinsics/FindLSB.metal b/tests/sksl/intrinsics/FindLSB.metal
index a37fb41..6d9f89e 100644
--- a/tests/sksl/intrinsics/FindLSB.metal
+++ b/tests/sksl/intrinsics/FindLSB.metal
@@ -18,7 +18,16 @@
     (void)_out;
     int _skTemp0;
     uint _skTemp1;
-    _out.sk_FragColor.x = half((_skTemp0 = (_uniforms.a), select(ctz(_skTemp0), int(-1), _skTemp0 == int(0))));
-    _out.sk_FragColor.y = half((_skTemp1 = (_uniforms.b), select(ctz(_skTemp1), uint(-1), _skTemp1 == uint(0))));
+    int2 _skTemp2;
+    uint2 _skTemp3;
+    int3 _skTemp4;
+    uint3 _skTemp5;
+    int4 _skTemp6;
+    uint4 _skTemp7;
+    int b1 = (_skTemp0 = (_uniforms.a), select((ctz(_skTemp0)), int(-1), _skTemp0 == int(0))) + (_skTemp1 = (_uniforms.b), select(int(ctz(_skTemp1)), int(-1), _skTemp1 == uint(0)));
+    int2 b2 = (_skTemp2 = (int2(_uniforms.a)), select((ctz(_skTemp2)), int2(-1), _skTemp2 == int2(0))) + (_skTemp3 = (uint2(_uniforms.b)), select(int2(ctz(_skTemp3)), int2(-1), _skTemp3 == uint2(0)));
+    int3 b3 = (_skTemp4 = (int3(_uniforms.a)), select((ctz(_skTemp4)), int3(-1), _skTemp4 == int3(0))) + (_skTemp5 = (uint3(_uniforms.b)), select(int3(ctz(_skTemp5)), int3(-1), _skTemp5 == uint3(0)));
+    int4 b4 = (_skTemp6 = (int4(_uniforms.a)), select((ctz(_skTemp6)), int4(-1), _skTemp6 == int4(0))) + (_skTemp7 = (uint4(_uniforms.b)), select(int4(ctz(_skTemp7)), int4(-1), _skTemp7 == uint4(0)));
+    _out.sk_FragColor = half4(((int4(b1) + b2.xyxy) + int4(b3, 1)) + b4);
     return _out;
 }
diff --git a/tests/sksl/intrinsics/FindLSB.skrp b/tests/sksl/intrinsics/FindLSB.skrp
index fc99548..f587757 100644
--- a/tests/sksl/intrinsics/FindLSB.skrp
+++ b/tests/sksl/intrinsics/FindLSB.skrp
@@ -6,16 +6,43 @@
 error: 3: 'main' must return: 'vec4', 'float4', or 'half4'
 void main() {
 ^^^^^^^^^^^
-error: 4: unknown identifier 'sk_FragColor'
-    sk_FragColor.x = half(findLSB(a));
-    ^^^^^^^^^^^^
 error: 4: unknown identifier 'findLSB'
-    sk_FragColor.x = half(findLSB(a));
+    int b1 = findLSB(a) + findLSB(b);
+             ^^^^^^^
+error: 4: unknown identifier 'findLSB'
+    int b1 = findLSB(a) + findLSB(b);
                           ^^^^^^^
-error: 5: unknown identifier 'sk_FragColor'
-    sk_FragColor.y = half(findLSB(b));
-    ^^^^^^^^^^^^
 error: 5: unknown identifier 'findLSB'
-    sk_FragColor.y = half(findLSB(b));
-                          ^^^^^^^
-6 errors
+    int2 b2 = findLSB(int2(a)) + findLSB(uint2(b));
+              ^^^^^^^
+error: 5: unknown identifier 'findLSB'
+    int2 b2 = findLSB(int2(a)) + findLSB(uint2(b));
+                                 ^^^^^^^
+error: 6: unknown identifier 'findLSB'
+    int3 b3 = findLSB(int3(a)) + findLSB(uint3(b));
+              ^^^^^^^
+error: 6: unknown identifier 'findLSB'
+    int3 b3 = findLSB(int3(a)) + findLSB(uint3(b));
+                                 ^^^^^^^
+error: 7: unknown identifier 'findLSB'
+    int4 b4 = findLSB(int4(a)) + findLSB(uint4(b));
+              ^^^^^^^
+error: 7: unknown identifier 'findLSB'
+    int4 b4 = findLSB(int4(a)) + findLSB(uint4(b));
+                                 ^^^^^^^
+error: 9: unknown identifier 'sk_FragColor'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+    ^^^^^^^^^^^^
+error: 9: unknown identifier 'b1'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+                         ^^
+error: 9: unknown identifier 'b2'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+                                   ^^
+error: 9: unknown identifier 'b3'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+                                             ^^
+error: 9: unknown identifier 'b4'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+                                                       ^^
+15 errors
diff --git a/tests/sksl/intrinsics/FindLSB.wgsl b/tests/sksl/intrinsics/FindLSB.wgsl
index 2f75d74..1226199 100644
--- a/tests/sksl/intrinsics/FindLSB.wgsl
+++ b/tests/sksl/intrinsics/FindLSB.wgsl
@@ -1,7 +1,3 @@
-### Compilation failed:
-
-error: Tint compilation failed.
-
 diagnostic(off, derivative_uniformity);
 diagnostic(off, chromium.unreachable_code);
 struct FSOut {
@@ -14,8 +10,11 @@
 @binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
 fn _skslMain(_stageOut: ptr<function, FSOut>) {
   {
-    (*_stageOut).sk_FragColor.x = f32(findLSB(_globalUniforms.a));
-    (*_stageOut).sk_FragColor.y = f32(findLSB(_globalUniforms.b));
+    let b1: i32 = firstTrailingBit(_globalUniforms.a) + i32(firstTrailingBit(_globalUniforms.b));
+    let b2: vec2<i32> = firstTrailingBit(vec2<i32>(_globalUniforms.a)) + vec2<i32>(firstTrailingBit(vec2<u32>(_globalUniforms.b)));
+    let b3: vec3<i32> = firstTrailingBit(vec3<i32>(_globalUniforms.a)) + vec3<i32>(firstTrailingBit(vec3<u32>(_globalUniforms.b)));
+    let b4: vec4<i32> = firstTrailingBit(vec4<i32>(_globalUniforms.a)) + vec4<i32>(firstTrailingBit(vec4<u32>(_globalUniforms.b)));
+    (*_stageOut).sk_FragColor = vec4<f32>(((vec4<i32>(b1) + b2.xyxy) + vec4<i32>(b3, 1)) + b4);
   }
 }
 @fragment fn main() -> FSOut {
@@ -23,5 +22,3 @@
   _skslMain(&_stageOut);
   return _stageOut;
 }
-
-1 error
diff --git a/tests/sksl/intrinsics/FindMSB.asm.frag b/tests/sksl/intrinsics/FindMSB.asm.frag
index 0d48fd0..cd1bf31 100644
--- a/tests/sksl/intrinsics/FindMSB.asm.frag
+++ b/tests/sksl/intrinsics/FindMSB.asm.frag
@@ -10,6 +10,10 @@
                OpMemberName %_UniformBuffer 0 "a"
                OpMemberName %_UniformBuffer 1 "b"
                OpName %main "main"                  ; id %6
+               OpName %b1 "b1"                      ; id %18
+               OpName %b2 "b2"                      ; id %31
+               OpName %b3 "b3"                      ; id %44
+               OpName %b4 "b4"                      ; id %57
 
                ; Annotations
                OpDecorate %sk_FragColor RelaxedPrecision
@@ -20,8 +24,11 @@
                OpDecorate %_UniformBuffer Block
                OpDecorate %11 Binding 0
                OpDecorate %11 DescriptorSet 0
-               OpDecorate %23 RelaxedPrecision
-               OpDecorate %31 RelaxedPrecision
+               OpDecorate %80 RelaxedPrecision
+               OpDecorate %82 RelaxedPrecision
+               OpDecorate %84 RelaxedPrecision
+               OpDecorate %86 RelaxedPrecision
+               OpDecorate %87 RelaxedPrecision
 
                ; Types, variables and constants
         %int = OpTypeInt 32 1
@@ -36,28 +43,86 @@
          %11 = OpVariable %_ptr_Uniform__UniformBuffer Uniform  ; Binding 0, DescriptorSet 0
        %void = OpTypeVoid
          %16 = OpTypeFunction %void
+%_ptr_Function_int = OpTypePointer Function %int
 %_ptr_Uniform_int = OpTypePointer Uniform %int
       %int_0 = OpConstant %int 0
-%_ptr_Output_float = OpTypePointer Output %float
 %_ptr_Uniform_uint = OpTypePointer Uniform %uint
       %int_1 = OpConstant %int 1
+      %v2int = OpTypeVector %int 2
+%_ptr_Function_v2int = OpTypePointer Function %v2int
+     %v2uint = OpTypeVector %uint 2
+      %v3int = OpTypeVector %int 3
+%_ptr_Function_v3int = OpTypePointer Function %v3int
+     %v3uint = OpTypeVector %uint 3
+      %v4int = OpTypeVector %int 4
+%_ptr_Function_v4int = OpTypePointer Function %v4int
+     %v4uint = OpTypeVector %uint 4
 
 
                ; Function main
        %main = OpFunction %void None %16
 
          %17 = OpLabel
-         %19 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
-         %22 =   OpLoad %int %19
-         %18 =   OpExtInst %int %5 FindSMsb %22
-         %23 =   OpConvertSToF %float %18           ; RelaxedPrecision
-         %24 =   OpAccessChain %_ptr_Output_float %sk_FragColor %int_0
-                 OpStore %24 %23
-         %27 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
-         %30 =   OpLoad %uint %27
-         %26 =   OpExtInst %int %5 FindUMsb %30
-         %31 =   OpConvertSToF %float %26           ; RelaxedPrecision
-         %32 =   OpAccessChain %_ptr_Output_float %sk_FragColor %int_1
-                 OpStore %32 %31
+         %b1 =   OpVariable %_ptr_Function_int Function
+         %b2 =   OpVariable %_ptr_Function_v2int Function
+         %b3 =   OpVariable %_ptr_Function_v3int Function
+         %b4 =   OpVariable %_ptr_Function_v4int Function
+         %21 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
+         %24 =   OpLoad %int %21
+         %20 =   OpExtInst %int %5 FindSMsb %24
+         %26 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
+         %29 =   OpLoad %uint %26
+         %25 =   OpExtInst %int %5 FindUMsb %29
+         %30 =   OpIAdd %int %20 %25
+                 OpStore %b1 %30
+         %35 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
+         %36 =   OpLoad %int %35
+         %37 =   OpCompositeConstruct %v2int %36 %36
+         %34 =   OpExtInst %v2int %5 FindSMsb %37
+         %39 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
+         %40 =   OpLoad %uint %39
+         %42 =   OpCompositeConstruct %v2uint %40 %40
+         %38 =   OpExtInst %v2int %5 FindUMsb %42
+         %43 =   OpIAdd %v2int %34 %38
+                 OpStore %b2 %43
+         %48 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
+         %49 =   OpLoad %int %48
+         %50 =   OpCompositeConstruct %v3int %49 %49 %49
+         %47 =   OpExtInst %v3int %5 FindSMsb %50
+         %52 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
+         %53 =   OpLoad %uint %52
+         %55 =   OpCompositeConstruct %v3uint %53 %53 %53
+         %51 =   OpExtInst %v3int %5 FindUMsb %55
+         %56 =   OpIAdd %v3int %47 %51
+                 OpStore %b3 %56
+         %61 =   OpAccessChain %_ptr_Uniform_int %11 %int_0
+         %62 =   OpLoad %int %61
+         %63 =   OpCompositeConstruct %v4int %62 %62 %62 %62
+         %60 =   OpExtInst %v4int %5 FindSMsb %63
+         %65 =   OpAccessChain %_ptr_Uniform_uint %11 %int_1
+         %66 =   OpLoad %uint %65
+         %68 =   OpCompositeConstruct %v4uint %66 %66 %66 %66
+         %64 =   OpExtInst %v4int %5 FindUMsb %68
+         %69 =   OpIAdd %v4int %60 %64
+                 OpStore %b4 %69
+         %70 =   OpCompositeConstruct %v4int %30 %30 %30 %30
+         %71 =   OpVectorShuffle %v4int %43 %43 0 1 0 1
+         %72 =   OpIAdd %v4int %70 %71
+         %73 =   OpCompositeExtract %int %56 0
+         %74 =   OpCompositeExtract %int %56 1
+         %75 =   OpCompositeExtract %int %56 2
+         %76 =   OpCompositeConstruct %v4int %73 %74 %75 %int_1
+         %77 =   OpIAdd %v4int %72 %76
+         %78 =   OpIAdd %v4int %77 %69
+         %79 =   OpCompositeExtract %int %78 0
+         %80 =   OpConvertSToF %float %79           ; RelaxedPrecision
+         %81 =   OpCompositeExtract %int %78 1
+         %82 =   OpConvertSToF %float %81           ; RelaxedPrecision
+         %83 =   OpCompositeExtract %int %78 2
+         %84 =   OpConvertSToF %float %83           ; RelaxedPrecision
+         %85 =   OpCompositeExtract %int %78 3
+         %86 =   OpConvertSToF %float %85           ; RelaxedPrecision
+         %87 =   OpCompositeConstruct %v4float %80 %82 %84 %86  ; RelaxedPrecision
+                 OpStore %sk_FragColor %87
                  OpReturn
                OpFunctionEnd
diff --git a/tests/sksl/intrinsics/FindMSB.glsl b/tests/sksl/intrinsics/FindMSB.glsl
index ba0ae07..b93aa3a 100644
--- a/tests/sksl/intrinsics/FindMSB.glsl
+++ b/tests/sksl/intrinsics/FindMSB.glsl
@@ -3,6 +3,9 @@
 uniform int a;
 uniform uint b;
 void main() {
-    sk_FragColor.x = float(findMSB(a));
-    sk_FragColor.y = float(findMSB(b));
+    int b1 = findMSB(a) + findMSB(b);
+    ivec2 b2 = findMSB(ivec2(a)) + findMSB(uvec2(b));
+    ivec3 b3 = findMSB(ivec3(a)) + findMSB(uvec3(b));
+    ivec4 b4 = findMSB(ivec4(a)) + findMSB(uvec4(b));
+    sk_FragColor = vec4(((ivec4(b1) + b2.xyxy) + ivec4(b3, 1)) + b4);
 }
diff --git a/tests/sksl/intrinsics/FindMSB.hlsl b/tests/sksl/intrinsics/FindMSB.hlsl
index 7ae8e82..6d61346 100644
--- a/tests/sksl/intrinsics/FindMSB.hlsl
+++ b/tests/sksl/intrinsics/FindMSB.hlsl
@@ -14,8 +14,16 @@
 
 void frag_main()
 {
-    sk_FragColor.x = float(firstbithigh(_11_a));
-    sk_FragColor.y = float(int(firstbithigh(_11_b)));
+    int _30 = firstbithigh(_11_a) + int(firstbithigh(_11_b));
+    int b1 = _30;
+    int2 _43 = firstbithigh(_11_a.xx) + int2(firstbithigh(_11_b.xx));
+    int2 b2 = _43;
+    int3 _56 = firstbithigh(_11_a.xxx) + int3(firstbithigh(_11_b.xxx));
+    int3 b3 = _56;
+    int4 _69 = firstbithigh(_11_a.xxxx) + int4(firstbithigh(_11_b.xxxx));
+    int4 b4 = _69;
+    int4 _78 = ((_30.xxxx + _43.xyxy) + int4(_56, 1)) + _69;
+    sk_FragColor = float4(float(_78.x), float(_78.y), float(_78.z), float(_78.w));
 }
 
 SPIRV_Cross_Output main()
diff --git a/tests/sksl/intrinsics/FindMSB.metal b/tests/sksl/intrinsics/FindMSB.metal
index f38f250..0ebfa05 100644
--- a/tests/sksl/intrinsics/FindMSB.metal
+++ b/tests/sksl/intrinsics/FindMSB.metal
@@ -19,7 +19,16 @@
     int _skTemp0;
     int _skTemp1;
     uint _skTemp2;
-    _out.sk_FragColor.x = half((_skTemp0 = (_uniforms.a), _skTemp1 = (select(_skTemp0, ~_skTemp0, _skTemp0 < 0)), select(int(clz(_skTemp1)), int(-1), _skTemp1 == int(0))));
-    _out.sk_FragColor.y = half((_skTemp2 = (_uniforms.b), select(int(clz(_skTemp2)), int(-1), _skTemp2 == uint(0))));
+    int2 _skTemp3;
+    uint2 _skTemp4;
+    int3 _skTemp5;
+    uint3 _skTemp6;
+    int4 _skTemp7;
+    uint4 _skTemp8;
+    int b1 = (_skTemp0 = (_uniforms.a), _skTemp1 = (select(_skTemp0, ~_skTemp0, _skTemp0 < 0)), select(31 - (clz(_skTemp1)), int(-1), _skTemp1 == int(0))) + (_skTemp2 = (_uniforms.b), select(31 - int(clz(_skTemp2)), int(-1), _skTemp2 == uint(0)));
+    int2 b2 = (_skTemp3 = (int2(_uniforms.a)), select(31 - (clz(_skTemp3)), int2(-1), _skTemp3 == int2(0))) + (_skTemp4 = (uint2(_uniforms.b)), select(31 - int2(clz(_skTemp4)), int2(-1), _skTemp4 == uint2(0)));
+    int3 b3 = (_skTemp5 = (int3(_uniforms.a)), select(31 - (clz(_skTemp5)), int3(-1), _skTemp5 == int3(0))) + (_skTemp6 = (uint3(_uniforms.b)), select(31 - int3(clz(_skTemp6)), int3(-1), _skTemp6 == uint3(0)));
+    int4 b4 = (_skTemp7 = (int4(_uniforms.a)), select(31 - (clz(_skTemp7)), int4(-1), _skTemp7 == int4(0))) + (_skTemp8 = (uint4(_uniforms.b)), select(31 - int4(clz(_skTemp8)), int4(-1), _skTemp8 == uint4(0)));
+    _out.sk_FragColor = half4(((int4(b1) + b2.xyxy) + int4(b3, 1)) + b4);
     return _out;
 }
diff --git a/tests/sksl/intrinsics/FindMSB.skrp b/tests/sksl/intrinsics/FindMSB.skrp
index 8dda8de..b3a9fa9 100644
--- a/tests/sksl/intrinsics/FindMSB.skrp
+++ b/tests/sksl/intrinsics/FindMSB.skrp
@@ -6,16 +6,43 @@
 error: 3: 'main' must return: 'vec4', 'float4', or 'half4'
 void main() {
 ^^^^^^^^^^^
-error: 4: unknown identifier 'sk_FragColor'
-    sk_FragColor.x = half(findMSB(a));
-    ^^^^^^^^^^^^
 error: 4: unknown identifier 'findMSB'
-    sk_FragColor.x = half(findMSB(a));
+    int b1 = findMSB(a) + findMSB(b);
+             ^^^^^^^
+error: 4: unknown identifier 'findMSB'
+    int b1 = findMSB(a) + findMSB(b);
                           ^^^^^^^
-error: 5: unknown identifier 'sk_FragColor'
-    sk_FragColor.y = half(findMSB(b));
-    ^^^^^^^^^^^^
 error: 5: unknown identifier 'findMSB'
-    sk_FragColor.y = half(findMSB(b));
-                          ^^^^^^^
-6 errors
+    int2 b2 = findMSB(int2(a)) + findMSB(uint2(b));
+              ^^^^^^^
+error: 5: unknown identifier 'findMSB'
+    int2 b2 = findMSB(int2(a)) + findMSB(uint2(b));
+                                 ^^^^^^^
+error: 6: unknown identifier 'findMSB'
+    int3 b3 = findMSB(int3(a)) + findMSB(uint3(b));
+              ^^^^^^^
+error: 6: unknown identifier 'findMSB'
+    int3 b3 = findMSB(int3(a)) + findMSB(uint3(b));
+                                 ^^^^^^^
+error: 7: unknown identifier 'findMSB'
+    int4 b4 = findMSB(int4(a)) + findMSB(uint4(b));
+              ^^^^^^^
+error: 7: unknown identifier 'findMSB'
+    int4 b4 = findMSB(int4(a)) + findMSB(uint4(b));
+                                 ^^^^^^^
+error: 9: unknown identifier 'sk_FragColor'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+    ^^^^^^^^^^^^
+error: 9: unknown identifier 'b1'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+                         ^^
+error: 9: unknown identifier 'b2'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+                                   ^^
+error: 9: unknown identifier 'b3'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+                                             ^^
+error: 9: unknown identifier 'b4'
+    sk_FragColor = half4(b1.xxxx + b2.xyxy + b3.xyz1 + b4);
+                                                       ^^
+15 errors
diff --git a/tests/sksl/intrinsics/FindMSB.wgsl b/tests/sksl/intrinsics/FindMSB.wgsl
index 76884f2..caeb576 100644
--- a/tests/sksl/intrinsics/FindMSB.wgsl
+++ b/tests/sksl/intrinsics/FindMSB.wgsl
@@ -1,7 +1,3 @@
-### Compilation failed:
-
-error: Tint compilation failed.
-
 diagnostic(off, derivative_uniformity);
 diagnostic(off, chromium.unreachable_code);
 struct FSOut {
@@ -14,8 +10,11 @@
 @binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
 fn _skslMain(_stageOut: ptr<function, FSOut>) {
   {
-    (*_stageOut).sk_FragColor.x = f32(findMSB(_globalUniforms.a));
-    (*_stageOut).sk_FragColor.y = f32(findMSB(_globalUniforms.b));
+    let b1: i32 = firstLeadingBit(_globalUniforms.a) + i32(firstLeadingBit(_globalUniforms.b));
+    let b2: vec2<i32> = firstLeadingBit(vec2<i32>(_globalUniforms.a)) + vec2<i32>(firstLeadingBit(vec2<u32>(_globalUniforms.b)));
+    let b3: vec3<i32> = firstLeadingBit(vec3<i32>(_globalUniforms.a)) + vec3<i32>(firstLeadingBit(vec3<u32>(_globalUniforms.b)));
+    let b4: vec4<i32> = firstLeadingBit(vec4<i32>(_globalUniforms.a)) + vec4<i32>(firstLeadingBit(vec4<u32>(_globalUniforms.b)));
+    (*_stageOut).sk_FragColor = vec4<f32>(((vec4<i32>(b1) + b2.xyxy) + vec4<i32>(b3, 1)) + b4);
   }
 }
 @fragment fn main() -> FSOut {
@@ -23,5 +22,3 @@
   _skslMain(&_stageOut);
   return _stageOut;
 }
-
-1 error
diff --git a/tests/sksl/intrinsics/FloatBitsToInt.wgsl b/tests/sksl/intrinsics/FloatBitsToInt.wgsl
index 3d58794..d140a6a 100644
--- a/tests/sksl/intrinsics/FloatBitsToInt.wgsl
+++ b/tests/sksl/intrinsics/FloatBitsToInt.wgsl
@@ -1,7 +1,3 @@
-### Compilation failed:
-
-error: Tint compilation failed.
-
 diagnostic(off, derivative_uniformity);
 diagnostic(off, chromium.unreachable_code);
 struct FSOut {
@@ -17,7 +13,7 @@
   {
     let inputVal: vec4<f32> = vec4<f32>(_globalUniforms.testMatrix2x2[0], _globalUniforms.testMatrix2x2[1]) * vec4<f32>(1.0, 1.0, -1.0, -1.0);
     const expectedB: vec4<i32> = vec4<i32>(1065353216, 1073741824, -1069547520, -1065353216);
-    return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>((((floatBitsToInt(inputVal.x) == 1065353216) && all(floatBitsToInt(inputVal.xy) == vec2<i32>(1065353216, 1073741824))) && all(floatBitsToInt(inputVal.xyz) == vec3<i32>(1065353216, 1073741824, -1069547520))) && all(floatBitsToInt(inputVal) == expectedB)));
+    return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>((((bitcast<i32>(inputVal.x) == 1065353216) && all(bitcast<vec2<i32>>(inputVal.xy) == vec2<i32>(1065353216, 1073741824))) && all(bitcast<vec3<i32>>(inputVal.xyz) == vec3<i32>(1065353216, 1073741824, -1069547520))) && all(bitcast<vec4<i32>>(inputVal) == expectedB)));
   }
 }
 @fragment fn main() -> FSOut {
@@ -25,5 +21,3 @@
   _stageOut.sk_FragColor = _skslMain(/*fragcoord*/ vec2<f32>());
   return _stageOut;
 }
-
-1 error
diff --git a/tests/sksl/intrinsics/FloatBitsToUint.wgsl b/tests/sksl/intrinsics/FloatBitsToUint.wgsl
index ab9ae88..aa6d10a 100644
--- a/tests/sksl/intrinsics/FloatBitsToUint.wgsl
+++ b/tests/sksl/intrinsics/FloatBitsToUint.wgsl
@@ -1,7 +1,3 @@
-### Compilation failed:
-
-error: Tint compilation failed.
-
 diagnostic(off, derivative_uniformity);
 diagnostic(off, chromium.unreachable_code);
 struct FSOut {
@@ -17,7 +13,7 @@
   {
     let inputVal: vec4<f32> = vec4<f32>(_globalUniforms.testMatrix2x2[0], _globalUniforms.testMatrix2x2[1]) * vec4<f32>(1.0, 1.0, -1.0, -1.0);
     const expectedB: vec4<u32> = vec4<u32>(1065353216u, 1073741824u, 3225419776u, 3229614080u);
-    return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>((((floatBitsToUint(inputVal.x) == 1065353216u) && all(floatBitsToUint(inputVal.xy) == vec2<u32>(1065353216u, 1073741824u))) && all(floatBitsToUint(inputVal.xyz) == vec3<u32>(1065353216u, 1073741824u, 3225419776u))) && all(floatBitsToUint(inputVal) == expectedB)));
+    return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>((((bitcast<u32>(inputVal.x) == 1065353216u) && all(bitcast<vec2<u32>>(inputVal.xy) == vec2<u32>(1065353216u, 1073741824u))) && all(bitcast<vec3<u32>>(inputVal.xyz) == vec3<u32>(1065353216u, 1073741824u, 3225419776u))) && all(bitcast<vec4<u32>>(inputVal) == expectedB)));
   }
 }
 @fragment fn main() -> FSOut {
@@ -25,5 +21,3 @@
   _stageOut.sk_FragColor = _skslMain(/*fragcoord*/ vec2<f32>());
   return _stageOut;
 }
-
-1 error
diff --git a/tests/sksl/intrinsics/IntBitsToFloat.wgsl b/tests/sksl/intrinsics/IntBitsToFloat.wgsl
index afb39eb..2671da1 100644
--- a/tests/sksl/intrinsics/IntBitsToFloat.wgsl
+++ b/tests/sksl/intrinsics/IntBitsToFloat.wgsl
@@ -1,7 +1,3 @@
-### Compilation failed:
-
-error: Tint compilation failed.
-
 diagnostic(off, derivative_uniformity);
 diagnostic(off, chromium.unreachable_code);
 struct FSOut {
@@ -17,7 +13,7 @@
   {
     let inputVal: vec4<f32> = vec4<f32>(_globalUniforms.testMatrix2x2[0], _globalUniforms.testMatrix2x2[1]) * vec4<f32>(1.0, 1.0, -1.0, -1.0);
     const expectedB: vec4<i32> = vec4<i32>(1065353216, 1073741824, -1069547520, -1065353216);
-    return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>((((inputVal.x == intBitsToFloat(expectedB.x)) && all(inputVal.xy == intBitsToFloat(expectedB.xy))) && all(inputVal.xyz == intBitsToFloat(expectedB.xyz))) && all(inputVal == intBitsToFloat(expectedB))));
+    return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>((((inputVal.x == bitcast<f32>(expectedB.x)) && all(inputVal.xy == bitcast<vec2<f32>>(expectedB.xy))) && all(inputVal.xyz == bitcast<vec3<f32>>(expectedB.xyz))) && all(inputVal == bitcast<vec4<f32>>(expectedB))));
   }
 }
 @fragment fn main() -> FSOut {
@@ -25,5 +21,3 @@
   _stageOut.sk_FragColor = _skslMain(/*fragcoord*/ vec2<f32>());
   return _stageOut;
 }
-
-1 error
diff --git a/tests/sksl/intrinsics/OuterProduct.wgsl b/tests/sksl/intrinsics/OuterProduct.wgsl
index 23ef1f9..842d54b 100644
--- a/tests/sksl/intrinsics/OuterProduct.wgsl
+++ b/tests/sksl/intrinsics/OuterProduct.wgsl
@@ -1,7 +1,3 @@
-### Compilation failed:
-
-error: Tint compilation failed.
-
 diagnostic(off, derivative_uniformity);
 diagnostic(off, chromium.unreachable_code);
 struct FSOut {
@@ -15,20 +11,50 @@
   testInputs: vec4<f32>,
 };
 @binding(0) @group(0) var<uniform> _globalUniforms: _GlobalUniforms;
+fn outer_product2x2(a: vec2<f32>, b: vec2<f32>) -> mat2x2<f32> {
+var m : mat2x2<f32>;
+for (var c = 0; c < 2; c++) { m[c] = a * b[c]; }
+return m;
+}
+fn outer_product3x3(a: vec3<f32>, b: vec3<f32>) -> mat3x3<f32> {
+var m : mat3x3<f32>;
+for (var c = 0; c < 3; c++) { m[c] = a * b[c]; }
+return m;
+}
+fn outer_product3x2(a: vec2<f32>, b: vec3<f32>) -> mat3x2<f32> {
+var m : mat3x2<f32>;
+for (var c = 0; c < 3; c++) { m[c] = a * b[c]; }
+return m;
+}
+fn outer_product4x4(a: vec4<f32>, b: vec4<f32>) -> mat4x4<f32> {
+var m : mat4x4<f32>;
+for (var c = 0; c < 4; c++) { m[c] = a * b[c]; }
+return m;
+}
+fn outer_product2x4(a: vec4<f32>, b: vec2<f32>) -> mat2x4<f32> {
+var m : mat2x4<f32>;
+for (var c = 0; c < 2; c++) { m[c] = a * b[c]; }
+return m;
+}
+fn outer_product4x2(a: vec2<f32>, b: vec4<f32>) -> mat4x2<f32> {
+var m : mat4x2<f32>;
+for (var c = 0; c < 4; c++) { m[c] = a * b[c]; }
+return m;
+}
 fn _skslMain(coords: vec2<f32>) -> vec4<f32> {
   {
     const c12: vec2<f32> = vec2<f32>(1.0, 2.0);
-    let _skTemp0 = outerProduct(_globalUniforms.testMatrix2x2[0], _globalUniforms.testMatrix2x2[1]);
+    let _skTemp0 = outer_product2x2(_globalUniforms.testMatrix2x2[0], _globalUniforms.testMatrix2x2[1]);
     const _skTemp1 = mat2x2<f32>(3.0, 6.0, 4.0, 8.0);
-    let _skTemp2 = outerProduct(_globalUniforms.testMatrix3x3[0], _globalUniforms.testMatrix3x3[1]);
+    let _skTemp2 = outer_product3x3(_globalUniforms.testMatrix3x3[0], _globalUniforms.testMatrix3x3[1]);
     const _skTemp3 = mat3x3<f32>(4.0, 8.0, 12.0, 5.0, 10.0, 15.0, 6.0, 12.0, 18.0);
-    let _skTemp4 = outerProduct(_globalUniforms.testMatrix2x2[0], _globalUniforms.testMatrix3x3[1]);
+    let _skTemp4 = outer_product3x2(_globalUniforms.testMatrix2x2[0], _globalUniforms.testMatrix3x3[1]);
     const _skTemp5 = mat3x2<f32>(4.0, 8.0, 5.0, 10.0, 6.0, 12.0);
-    let _skTemp6 = mat4x4<f32>(outerProduct(_globalUniforms.testInputs, vec4<f32>(1.0, 0.0, 0.0, 2.0)));
+    let _skTemp6 = mat4x4<f32>(outer_product4x4(_globalUniforms.testInputs, vec4<f32>(1.0, 0.0, 0.0, 2.0)));
     const _skTemp7 = mat4x4<f32>(-1.25, 0.0, 0.75, 2.25, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -2.5, 0.0, 1.5, 4.5);
-    let _skTemp8 = outerProduct(vec4<f32>(_globalUniforms.testInputs), c12);
+    let _skTemp8 = outer_product2x4(vec4<f32>(_globalUniforms.testInputs), c12);
     const _skTemp9 = mat2x4<f32>(-1.25, 0.0, 0.75, 2.25, -2.5, 0.0, 1.5, 4.5);
-    let _skTemp10 = outerProduct(c12, vec4<f32>(_globalUniforms.testInputs));
+    let _skTemp10 = outer_product4x2(c12, vec4<f32>(_globalUniforms.testInputs));
     const _skTemp11 = mat4x2<f32>(-1.25, -2.5, 0.0, 0.0, 0.75, 1.5, 2.25, 4.5);
     return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>((((((all(_skTemp0[0] == _skTemp1[0]) && all(_skTemp0[1] == _skTemp1[1])) && (all(_skTemp2[0] == _skTemp3[0]) && all(_skTemp2[1] == _skTemp3[1]) && all(_skTemp2[2] == _skTemp3[2]))) && (all(_skTemp4[0] == _skTemp5[0]) && all(_skTemp4[1] == _skTemp5[1]) && all(_skTemp4[2] == _skTemp5[2]))) && (all(_skTemp6[0] == _skTemp7[0]) && all(_skTemp6[1] == _skTemp7[1]) && all(_skTemp6[2] == _skTemp7[2]) && all(_skTemp6[3] == _skTemp7[3]))) && (all(_skTemp8[0] == _skTemp9[0]) && all(_skTemp8[1] == _skTemp9[1]))) && (all(_skTemp10[0] == _skTemp11[0]) && all(_skTemp10[1] == _skTemp11[1]) && all(_skTemp10[2] == _skTemp11[2]) && all(_skTemp10[3] == _skTemp11[3]))));
   }
@@ -38,5 +64,3 @@
   _stageOut.sk_FragColor = _skslMain(/*fragcoord*/ vec2<f32>());
   return _stageOut;
 }
-
-1 error
diff --git a/tests/sksl/intrinsics/RoundEven.wgsl b/tests/sksl/intrinsics/RoundEven.wgsl
index 8bd3b97..d004155 100644
--- a/tests/sksl/intrinsics/RoundEven.wgsl
+++ b/tests/sksl/intrinsics/RoundEven.wgsl
@@ -1,7 +1,3 @@
-### Compilation failed:
-
-error: Tint compilation failed.
-
 diagnostic(off, derivative_uniformity);
 diagnostic(off, chromium.unreachable_code);
 struct FSOut {
@@ -16,7 +12,7 @@
 fn _skslMain(coords: vec2<f32>) -> vec4<f32> {
   {
     const expectedA: vec4<f32> = vec4<f32>(-1.0, 0.0, 1.0, 2.0);
-    return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>((((f32(roundEven(_globalUniforms.testInputs.x)) == -1.0) && all(vec2<f32>(roundEven(_globalUniforms.testInputs.xy)) == vec2<f32>(-1.0, 0.0))) && all(vec3<f32>(roundEven(_globalUniforms.testInputs.xyz)) == vec3<f32>(-1.0, 0.0, 1.0))) && all(vec4<f32>(roundEven(_globalUniforms.testInputs)) == expectedA)));
+    return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>((((f32(round(_globalUniforms.testInputs.x)) == -1.0) && all(vec2<f32>(round(_globalUniforms.testInputs.xy)) == vec2<f32>(-1.0, 0.0))) && all(vec3<f32>(round(_globalUniforms.testInputs.xyz)) == vec3<f32>(-1.0, 0.0, 1.0))) && all(vec4<f32>(round(_globalUniforms.testInputs)) == expectedA)));
   }
 }
 @fragment fn main() -> FSOut {
@@ -24,5 +20,3 @@
   _stageOut.sk_FragColor = _skslMain(/*fragcoord*/ vec2<f32>());
   return _stageOut;
 }
-
-1 error
diff --git a/tests/sksl/intrinsics/UintBitsToFloat.wgsl b/tests/sksl/intrinsics/UintBitsToFloat.wgsl
index 2d3c295..0b7cdbf 100644
--- a/tests/sksl/intrinsics/UintBitsToFloat.wgsl
+++ b/tests/sksl/intrinsics/UintBitsToFloat.wgsl
@@ -1,7 +1,3 @@
-### Compilation failed:
-
-error: Tint compilation failed.
-
 diagnostic(off, derivative_uniformity);
 diagnostic(off, chromium.unreachable_code);
 struct FSOut {
@@ -17,7 +13,7 @@
   {
     let inputVal: vec4<f32> = vec4<f32>(_globalUniforms.testMatrix2x2[0], _globalUniforms.testMatrix2x2[1]) * vec4<f32>(1.0, 1.0, -1.0, -1.0);
     const expectedB: vec4<u32> = vec4<u32>(1065353216u, 1073741824u, 3225419776u, 3229614080u);
-    return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>((((inputVal.x == uintBitsToFloat(expectedB.x)) && all(inputVal.xy == uintBitsToFloat(expectedB.xy))) && all(inputVal.xyz == uintBitsToFloat(expectedB.xyz))) && all(inputVal == uintBitsToFloat(expectedB))));
+    return select(_globalUniforms.colorRed, _globalUniforms.colorGreen, vec4<bool>((((inputVal.x == bitcast<f32>(expectedB.x)) && all(inputVal.xy == bitcast<vec2<f32>>(expectedB.xy))) && all(inputVal.xyz == bitcast<vec3<f32>>(expectedB.xyz))) && all(inputVal == bitcast<vec4<f32>>(expectedB))));
   }
 }
 @fragment fn main() -> FSOut {
@@ -25,5 +21,3 @@
   _stageOut.sk_FragColor = _skslMain(/*fragcoord*/ vec2<f32>());
   return _stageOut;
 }
-
-1 error