diff --git a/src/sksl/SkSLCompiler.cpp b/src/sksl/SkSLCompiler.cpp
index 41ff5cc..b19c94a 100644
--- a/src/sksl/SkSLCompiler.cpp
+++ b/src/sksl/SkSLCompiler.cpp
@@ -1301,6 +1301,26 @@
                 this->scanCFG((FunctionDefinition&) element);
             }
         }
+        if (program.fKind != Program::kFragmentProcessor_Kind) {
+            for (auto iter = program.fElements.begin(); iter != program.fElements.end();) {
+                if ((*iter)->fKind == ProgramElement::kVar_Kind) {
+                    VarDeclarations& vars = (VarDeclarations&) **iter;
+                    for (auto varIter = vars.fVars.begin(); varIter != vars.fVars.end();) {
+                        const Variable& var = *((VarDeclaration&) **varIter).fVar;
+                        if (var.dead()) {
+                            varIter = vars.fVars.erase(varIter);
+                        } else {
+                            ++varIter;
+                        }
+                    }
+                    if (vars.fVars.size() == 0) {
+                        iter = program.fElements.erase(iter);
+                        continue;
+                    }
+                }
+                ++iter;
+            }
+        }
         fSource = nullptr;
     }
     return fErrorCount == 0;
diff --git a/src/sksl/SkSLMetalCodeGenerator.cpp b/src/sksl/SkSLMetalCodeGenerator.cpp
index 928fa23..da206b4 100644
--- a/src/sksl/SkSLMetalCodeGenerator.cpp
+++ b/src/sksl/SkSLMetalCodeGenerator.cpp
@@ -26,6 +26,8 @@
 #define SPECIAL(x) std::make_pair(kSpecial_IntrinsicKind, k ## x ## _SpecialIntrinsic)
     fIntrinsicMap[String("texture")]            = SPECIAL(Texture);
     fIntrinsicMap[String("mod")]                = SPECIAL(Mod);
+    fIntrinsicMap[String("equal")]              = METAL(Equal);
+    fIntrinsicMap[String("notEqual")]           = METAL(NotEqual);
     fIntrinsicMap[String("lessThan")]           = METAL(LessThan);
     fIntrinsicMap[String("lessThanEqual")]      = METAL(LessThanEqual);
     fIntrinsicMap[String("greaterThan")]        = METAL(GreaterThan);
@@ -172,6 +174,12 @@
         case kMetal_IntrinsicKind:
             this->writeExpression(*c.fArguments[0], kSequence_Precedence);
             switch ((MetalIntrinsic) intrinsicId) {
+                case kEqual_MetalIntrinsic:
+                    this->write(" == ");
+                    break;
+                case kNotEqual_MetalIntrinsic:
+                    this->write(" != ");
+                    break;
                 case kLessThan_MetalIntrinsic:
                     this->write(" < ");
                     break;
@@ -248,18 +256,82 @@
 }
 
 void MetalCodeGenerator::writeInverseHack(const Expression& mat) {
-    String name = "ERROR_MatrixInverseNotImplementedFor_" + mat.fType.name();
-    if (mat.fType == *fContext.fFloat2x2_Type) {
-        name = "_inverse2";
+    String typeName = mat.fType.name();
+    String name = typeName + "_inverse";
+    if (mat.fType == *fContext.fFloat2x2_Type || mat.fType == *fContext.fHalf2x2_Type) {
         if (fWrittenIntrinsics.find(name) == fWrittenIntrinsics.end()) {
             fWrittenIntrinsics.insert(name);
             fExtraFunctions.writeText((
-                "float2x2 " + name + "(float2x2 m) {"
+                typeName + " " + name + "(" + typeName + " m) {"
                 "    return float2x2(m[1][1], -m[0][1], -m[1][0], m[0][0]) * (1/determinant(m));"
                 "}"
             ).c_str());
         }
     }
+    else if (mat.fType == *fContext.fFloat3x3_Type || mat.fType == *fContext.fHalf3x3_Type) {
+        if (fWrittenIntrinsics.find(name) == fWrittenIntrinsics.end()) {
+            fWrittenIntrinsics.insert(name);
+            fExtraFunctions.writeText((
+                typeName + " " +  name + "(" + typeName + " m) {"
+                "    float a00 = m[0][0], a01 = m[0][1], a02 = m[0][2];"
+                "    float a10 = m[1][0], a11 = m[1][1], a12 = m[1][2];"
+                "    float a20 = m[2][0], a21 = m[2][1], a22 = m[2][2];"
+                "    float b01 = a22 * a11 - a12 * a21;"
+                "    float b11 = -a22 * a10 + a12 * a20;"
+                "    float b21 = a21 * a10 - a11 * a20;"
+                "    float det = a00 * b01 + a01 * b11 + a02 * b21;"
+                "    return " + typeName +
+                "                   (b01, (-a22 * a01 + a02 * a21), (a12 * a01 - a02 * a11),"
+                "                    b11, (a22 * a00 - a02 * a20), (-a12 * a00 + a02 * a10),"
+                "                    b21, (-a21 * a00 + a01 * a20), (a11 * a00 - a01 * a10)) * "
+                "                   (1/det);"
+                "}"
+            ).c_str());
+        }
+    }
+    else if (mat.fType == *fContext.fFloat4x4_Type || mat.fType == *fContext.fHalf4x4_Type) {
+        if (fWrittenIntrinsics.find(name) == fWrittenIntrinsics.end()) {
+            fWrittenIntrinsics.insert(name);
+            fExtraFunctions.writeText((
+                typeName + " " +  name + "(" + typeName + " m) {"
+                "    float a00 = m[0][0], a01 = m[0][1], a02 = m[0][2], a03 = m[0][3];"
+                "    float a10 = m[1][0], a11 = m[1][1], a12 = m[1][2], a13 = m[1][3];"
+                "    float a20 = m[2][0], a21 = m[2][1], a22 = m[2][2], a23 = m[2][3];"
+                "    float a30 = m[3][0], a31 = m[3][1], a32 = m[3][2], a33 = m[3][3];"
+                "    float b00 = a00 * a11 - a01 * a10;"
+                "    float b01 = a00 * a12 - a02 * a10;"
+                "    float b02 = a00 * a13 - a03 * a10;"
+                "    float b03 = a01 * a12 - a02 * a11;"
+                "    float b04 = a01 * a13 - a03 * a11;"
+                "    float b05 = a02 * a13 - a03 * a12;"
+                "    float b06 = a20 * a31 - a21 * a30;"
+                "    float b07 = a20 * a32 - a22 * a30;"
+                "    float b08 = a20 * a33 - a23 * a30;"
+                "    float b09 = a21 * a32 - a22 * a31;"
+                "    float b10 = a21 * a33 - a23 * a31;"
+                "    float b11 = a22 * a33 - a23 * a32;"
+                "    float det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - "
+                "                b04 * b07 + b05 * b06;"
+                "    return " + typeName + "(a11 * b11 - a12 * b10 + a13 * b09,"
+                "                            a02 * b10 - a01 * b11 - a03 * b09,"
+                "                            a31 * b05 - a32 * b04 + a33 * b03,"
+                "                            a22 * b04 - a21 * b05 - a23 * b03,"
+                "                            a12 * b08 - a10 * b11 - a13 * b07,"
+                "                            a00 * b11 - a02 * b08 + a03 * b07,"
+                "                            a32 * b02 - a30 * b05 - a33 * b01,"
+                "                            a20 * b05 - a22 * b02 + a23 * b01,"
+                "                            a10 * b10 - a11 * b08 + a13 * b06,"
+                "                            a01 * b08 - a00 * b10 - a03 * b06,"
+                "                            a30 * b04 - a31 * b02 + a33 * b00,"
+                "                            a21 * b02 - a20 * b04 - a23 * b00,"
+                "                            a11 * b07 - a10 * b09 - a12 * b06,"
+                "                            a00 * b09 - a01 * b07 + a02 * b06,"
+                "                            a31 * b01 - a30 * b03 - a32 * b00,"
+                "                            a20 * b03 - a21 * b01 + a22 * b00) / det;"
+                "}"
+            ).c_str());
+        }
+    }
     this->write(name);
 }
 
@@ -300,8 +372,8 @@
 // of type 'arg'.
 String MetalCodeGenerator::getMatrixConstructHelper(const Type& matrix, const Type& arg) {
     String key = matrix.name() + arg.name();
-    auto found = fMatrixConstructHelpers.find(key);
-    if (found != fMatrixConstructHelpers.end()) {
+    auto found = fHelpers.find(key);
+    if (found != fHelpers.end()) {
         return found->second;
     }
     String name;
@@ -331,8 +403,34 @@
             fExtraFunctions.writeText(")");
         }
         fExtraFunctions.writeText(");\n}\n");
-    }
-    else if (matrix.rows() == 2 && matrix.columns() == 2) {
+    } else if (arg.kind() == Type::kMatrix_Kind) {
+        // creating a matrix from another matrix
+        int argColumns = arg.columns();
+        int argRows = arg.rows();
+        name = "float" + to_string(columns) + "x" + to_string(rows) + "_from_float" +
+               to_string(argColumns) + "x" + to_string(argRows);
+        fExtraFunctions.printf("float%dx%d %s(float%dx%d m) {\n",
+                               columns, rows, name.c_str(), argColumns, argRows);
+        fExtraFunctions.printf("    return float%dx%d(", columns, rows);
+        for (int i = 0; i < columns; ++i) {
+            if (i > 0) {
+                fExtraFunctions.writeText(", ");
+            }
+            fExtraFunctions.printf("float%d(", rows);
+            for (int j = 0; j < rows; ++j) {
+                if (j > 0) {
+                    fExtraFunctions.writeText(", ");
+                }
+                if (i < argColumns && j < argRows) {
+                    fExtraFunctions.printf("m[%d][%d]", i, j);
+                } else {
+                    fExtraFunctions.writeText("0");
+                }
+            }
+            fExtraFunctions.writeText(")");
+        }
+        fExtraFunctions.writeText(");\n}\n");
+    } else if (matrix.rows() == 2 && matrix.columns() == 2 && arg == *fContext.fFloat4_Type) {
         // float2x2(float4) doesn't work, need to split it into float2x2(float2, float2)
         name = "float2x2_from_float4";
         fExtraFunctions.printf(
@@ -341,12 +439,11 @@
             "}\n",
             name.c_str()
         );
-    }
-    else {
+    } else {
         SkASSERT(false);
         name = "<error>";
     }
-    fMatrixConstructHelpers[key] = name;
+    fHelpers[key] = name;
     return name;
 }
 
@@ -380,15 +477,14 @@
         for (const auto& arg : c.fArguments) {
             this->write(separator);
             separator = ", ";
-            if (Type::kMatrix_Kind == c.fType.kind() && Type::kScalar_Kind == arg->fType.kind()) {
-                // float2x2(float, float, float, float) doesn't work in Metal 1, so we need to merge
-                // to float2x2(float2, float2).
+            if (Type::kMatrix_Kind == c.fType.kind() && arg->fType.columns() != c.fType.rows()) {
+                // merge scalars and smaller vectors together
                 if (!scalarCount) {
                     this->writeType(c.fType.componentType());
                     this->write(to_string(c.fType.rows()));
                     this->write("(");
                 }
-                ++scalarCount;
+                scalarCount += arg->fType.columns();
             }
             this->writeExpression(*arg, kSequence_Precedence);
             if (scalarCount && scalarCount == c.fType.rows()) {
@@ -527,10 +623,39 @@
     }
 }
 
+void MetalCodeGenerator::writeMatrixTimesEqualHelper(const Type& left, const Type& right,
+                                                     const Type& result) {
+    String key = "TimesEqual" + left.name() + right.name();
+    if (fHelpers.find(key) == fHelpers.end()) {
+        fExtraFunctions.printf("%s operator*=(thread %s& left, thread const %s& right) {\n"
+                               "    left = left * right;\n"
+                               "    return left;\n"
+                               "}", result.name().c_str(), left.name().c_str(),
+                                    right.name().c_str());
+    }
+}
+
 void MetalCodeGenerator::writeBinaryExpression(const BinaryExpression& b,
                                                Precedence parentPrecedence) {
     Precedence precedence = GetBinaryPrecedence(b.fOperator);
-    if (precedence >= parentPrecedence) {
+    bool needParens = precedence >= parentPrecedence;
+    switch (b.fOperator) {
+        case Token::EQEQ:
+            if (b.fLeft->fType.kind() == Type::kVector_Kind) {
+                this->write("all");
+                needParens = true;
+            }
+            break;
+        case Token::NEQ:
+            if (b.fLeft->fType.kind() == Type::kVector_Kind) {
+                this->write("!all");
+                needParens = true;
+            }
+            break;
+        default:
+            break;
+    }
+    if (needParens) {
         this->write("(");
     }
     if (Compiler::IsAssignment(b.fOperator) &&
@@ -541,6 +666,10 @@
         // dereference it here.
         this->write("*");
     }
+    if (b.fOperator == Token::STAREQ && b.fLeft->fType.kind() == Type::kMatrix_Kind &&
+        b.fRight->fType.kind() == Type::kMatrix_Kind) {
+        this->writeMatrixTimesEqualHelper(b.fLeft->fType, b.fRight->fType, b.fType);
+    }
     this->writeExpression(*b.fLeft, precedence);
     if (b.fOperator != Token::EQ && Compiler::IsAssignment(b.fOperator) &&
         Expression::kSwizzle_Kind == b.fLeft->fKind && !b.fLeft->hasSideEffects()) {
@@ -561,7 +690,7 @@
         this->write(String(" ") + Compiler::OperatorName(b.fOperator) + " ");
     }
     this->writeExpression(*b.fRight, precedence);
-    if (precedence >= parentPrecedence) {
+    if (needParens) {
         this->write(")");
     }
 }
diff --git a/src/sksl/SkSLMetalCodeGenerator.h b/src/sksl/SkSLMetalCodeGenerator.h
index 3ed2524..16be50f 100644
--- a/src/sksl/SkSLMetalCodeGenerator.h
+++ b/src/sksl/SkSLMetalCodeGenerator.h
@@ -107,6 +107,8 @@
     };
 
     enum MetalIntrinsic {
+        kEqual_MetalIntrinsic,
+        kNotEqual_MetalIntrinsic,
         kLessThan_MetalIntrinsic,
         kLessThanEqual_MetalIntrinsic,
         kGreaterThan_MetalIntrinsic,
@@ -186,6 +188,8 @@
 
     String getMatrixConstructHelper(const Type& matrix, const Type& arg);
 
+    void writeMatrixTimesEqualHelper(const Type& left, const Type& right, const Type& result);
+
     void writeSpecialIntrinsic(const FunctionCall& c, SpecialIntrinsic kind);
 
     bool canCoerce(const Type& t1, const Type& t2);
@@ -272,7 +276,7 @@
     std::unordered_map<const FunctionDeclaration*, Requirements> fRequirements;
     bool fSetupFragPositionGlobal = false;
     bool fSetupFragPositionLocal = false;
-    std::unordered_map<String, String> fMatrixConstructHelpers;
+    std::unordered_map<String, String> fHelpers;
     int fUniformBuffer = -1;
 
     typedef CodeGenerator INHERITED;
diff --git a/src/sksl/ir/SkSLVariable.h b/src/sksl/ir/SkSLVariable.h
index 5624483..5a8e9d5 100644
--- a/src/sksl/ir/SkSLVariable.h
+++ b/src/sksl/ir/SkSLVariable.h
@@ -53,9 +53,11 @@
     }
 
     bool dead() const {
-        return !fWriteCount || (!fReadCount && !(fModifiers.fFlags & (Modifiers::kOut_Flag |
-                                                                      Modifiers::kPLS_Flag |
-                                                                      Modifiers::kPLSOut_Flag)));
+        return (!fWriteCount && !(fModifiers.fFlags & (Modifiers::kIn_Flag |
+                                                       Modifiers::kUniform_Flag))) ||
+               (!fReadCount && !(fModifiers.fFlags & (Modifiers::kOut_Flag |
+                                                      Modifiers::kPLS_Flag |
+                                                      Modifiers::kPLSOut_Flag)));
     }
 
     mutable Modifiers fModifiers;
diff --git a/tests/SkSLGLSLTest.cpp b/tests/SkSLGLSLTest.cpp
index a7ef69c..d21710e 100644
--- a/tests/SkSLGLSLTest.cpp
+++ b/tests/SkSLGLSLTest.cpp
@@ -261,40 +261,46 @@
          "};"
          "B b1, b2, b3;"
          "void main() {"
+         "    a1.x = 0;"
+         "    b1.x = 0;"
+         "    sk_FragColor.r = half(a1.x + b1.x);"
          "}",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
+         "out vec4 sk_FragColor;\n"
          "struct A {\n"
          "    int x;\n"
          "    int y;\n"
-         "} a1, a2;\n"
-         "A a3;\n"
+         "} a1;\n"
          "struct B {\n"
          "    float x;\n"
          "    float[2] y;\n"
          "    layout (binding = 1) A z;\n"
-         "} b1, b2, b3;\n"
+         "} b1;\n"
          "void main() {\n"
+         "    a1.x = 0;\n"
+         "    b1.x = 0.0;\n"
+         "    sk_FragColor.x = float(a1.x) + b1.x;\n"
          "}\n");
 }
 
 DEF_TEST(SkSLVersion, r) {
     test(r,
-         "in float test; void main() { sk_FragColor = half4(0.75); }",
+         "in float test; void main() { sk_FragColor.r = half(test); }",
          *SkSL::ShaderCapsFactory::Version450Core(),
          "#version 450 core\n"
          "out vec4 sk_FragColor;\n"
          "in float test;\n"
          "void main() {\n"
-         "    sk_FragColor = vec4(0.75);\n"
+         "    sk_FragColor.x = test;\n"
          "}\n");
     test(r,
-         "in float test; void main() { sk_FragColor = half4(0.75); }",
+         "in float test; void main() { sk_FragColor.r = half(test); }",
          *SkSL::ShaderCapsFactory::Version110(),
          "#version 110\n"
          "varying float test;\n"
          "void main() {\n"
-         "    gl_FragColor = vec4(0.75);\n"
+         "    gl_FragColor.x = test;\n"
          "}\n");
 }
 
@@ -502,28 +508,43 @@
          "float3 v4 = float3(float2(1), 1.0);"
          "int2 v5 = int2(1);"
          "int2 v6 = int2(float2(1, 2));"
-         "float2 v7 = float2(int2(1, 2));",
+         "float2 v7 = float2(int2(1, 2));"
+         "void main() {"
+         "sk_FragColor.r = half(v1.x + v2.x + v3.x + v4.x + v5.x + v6.x + v7.x);"
+         "}",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
+         "out vec4 sk_FragColor;\n"
          "vec2 v1 = vec2(1.0);\n"
          "vec2 v2 = vec2(1.0, 2.0);\n"
          "vec2 v3 = vec2(1.0);\n"
          "vec3 v4 = vec3(vec2(1.0), 1.0);\n"
          "ivec2 v5 = ivec2(1);\n"
          "ivec2 v6 = ivec2(vec2(1.0, 2.0));\n"
-         "vec2 v7 = vec2(ivec2(1, 2));\n");
+         "vec2 v7 = vec2(ivec2(1, 2));\n"
+         "void main() {\n"
+         "    sk_FragColor.x = (((((v1.x + v2.x) + v3.x) + v4.x) + float(v5.x)) + float(v6.x)) + "
+         "v7.x;\n"
+         "}\n");
 }
 
 DEF_TEST(SkSLArrayConstructors, r) {
     test(r,
          "float test1[] = float[](1, 2, 3, 4);"
          "float2 test2[] = float2[](float2(1, 2), float2(3, 4));"
-         "float4x4 test3[] = float4x4[]();",
+         "float4x4 test3[] = float4x4[]();"
+         "void main() {"
+         "sk_FragColor.r = half(test1[0] + test2[0].x + test3[0][0][0]);"
+         "}",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
+         "out vec4 sk_FragColor;\n"
          "float test1[] = float[](1.0, 2.0, 3.0, 4.0);\n"
          "vec2 test2[] = vec2[](vec2(1.0, 2.0), vec2(3.0, 4.0));\n"
-         "mat4 test3[] = mat4[]();\n");
+         "mat4 test3[] = mat4[]();\n"
+         "void main() {\n"
+         "    sk_FragColor.x = (test1[0] + test2[0].x) + test3[0][0][0];\n"
+         "}\n");
 }
 
 DEF_TEST(SkSLDerivatives, r) {
@@ -1089,14 +1110,24 @@
          "layout(offset = 0) int x;"
          "layout(offset = 4) int y;"
          "int z;"
-         "} test;",
+         "} test;"
+         "void main() {"
+         "Test t;"
+         "t.x = 0;"
+         "sk_FragColor.r = half(t.x);"
+         "}",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
-         "struct Test {\n"
-         "    layout (offset = 0) int x;\n"
-         "    layout (offset = 4) int y;\n"
-         "    int z;\n"
-         "} test;\n");
+         "out vec4 sk_FragColor;\n"
+         "void main() {\n"
+         "    struct Test {\n"
+         "        layout (offset = 0) int x;\n"
+         "        layout (offset = 4) int y;\n"
+         "        int z;\n"
+         "    } t;\n"
+         "    t.x = 0;\n"
+         "    sk_FragColor.x = float(t.x);\n"
+         "}\n");
 }
 
 DEF_TEST(SkSLFragCoord, r) {
@@ -1752,9 +1783,14 @@
          "double4 d4 = double4(1, 2, 3, 4);"
          "float2x2 f22 = float2x2(1, 2, 3, 4);"
          "half2x4 h24 = half2x4(1, 2, 3, 4, 5, 6, 7, 8);"
-         "double4x2 d42 = double4x2(1, 2, 3, 4, 5, 6, 7, 8);",
+         "double4x2 d42 = double4x2(1, 2, 3, 4, 5, 6, 7, 8);"
+         "void main() {"
+         "sk_FragColor.r = half(f + h + d + f2.x + h3.x + d4.x + f22[0][0] + h24[0][0] + "
+                               "d42[0][0]);"
+         "}",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
+         "out vec4 sk_FragColor;\n"
          "float f = 1.0;\n"
          "float h = 2.0;\n"
          "double d = 3.0;\n"
@@ -1763,23 +1799,34 @@
          "dvec4 d4 = dvec4(1.0, 2.0, 3.0, 4.0);\n"
          "mat2 f22 = mat2(1.0, 2.0, 3.0, 4.0);\n"
          "mat2x4 h24 = mat2x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);\n"
-         "dmat4x2 d42 = dmat4x2(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);\n");
+         "dmat4x2 d42 = dmat4x2(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);\n"
+         "void main() {\n"
+         "    sk_FragColor.x = float(((((((double(f + h) + d) + double(f2.x)) + double(h3.x)) + "
+         "d4.x) + double(f22[0][0])) + double(h24[0][0])) + d42[0][0]);\n"
+         "}\n");
     test(r,
          "float f = 1;"
          "half h = 2;"
          "float2 f2 = float2(1, 2);"
          "half3 h3 = half3(1, 2, 3);"
          "float2x2 f22 = float2x2(1, 2, 3, 4);"
-         "half2x4 h24 = half2x4(1, 2, 3, 4, 5, 6, 7, 8);",
+         "half2x4 h24 = half2x4(1, 2, 3, 4, 5, 6, 7, 8);"
+         "void main() {"
+         "sk_FragColor.r = half(f + h + f2.x + h3.x + f22[0][0] + h24[0][0]);"
+         "}",
          *SkSL::ShaderCapsFactory::UsesPrecisionModifiers(),
          "#version 400\n"
          "precision mediump float;\n"
+         "out mediump vec4 sk_FragColor;\n"
          "highp float f = 1.0;\n"
          "mediump float h = 2.0;\n"
          "highp vec2 f2 = vec2(1.0, 2.0);\n"
          "mediump vec3 h3 = vec3(1.0, 2.0, 3.0);\n"
          "highp mat2 f22 = mat2(1.0, 2.0, 3.0, 4.0);\n"
-         "mediump mat2x4 h24 = mat2x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);\n");
+         "mediump mat2x4 h24 = mat2x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);\n"
+         "void main() {\n"
+         "    sk_FragColor.x = ((((f + h) + f2.x) + h3.x) + f22[0][0]) + h24[0][0];\n"
+         "}\n");
 }
 
 DEF_TEST(SkSLNumberConversions, r) {
@@ -1819,9 +1866,17 @@
          "float us2f = us;"
          "float ui2f = ui;"
          "float h2f = h;"
-         "float f2f = f;",
+         "float f2f = f;"
+         "void main() {"
+         "sk_FragColor.r = half(s + i + us + half(ui) + h + f + s2s + i2s + us2s + ui2s + h2s + "
+                               "f2s + s2i + i2i + us2i + ui2i + h2i + f2i + s2us + i2us + us2us + "
+                               "ui2us + h2us + f2us + half(s2ui) + half(i2ui) + half(us2ui) + "
+                               "half(ui2ui) + half(h2ui) + half(f2ui) + s2f + i2f + us2f + ui2f + "
+                               "h2f + f2f);"
+         "}",
          *SkSL::ShaderCapsFactory::Default(),
          "#version 400\n"
+         "out vec4 sk_FragColor;\n"
          "int s = int(sqrt(1.0));\n"
          "int i = int(sqrt(1.0));\n"
          "uint us = uint(sqrt(1.0));\n"
@@ -1857,7 +1912,16 @@
          "float us2f = float(us);\n"
          "float ui2f = float(ui);\n"
          "float h2f = h;\n"
-         "float f2f = f;\n");
+         "float f2f = f;\n"
+         "void main() {\n"
+         "    sk_FragColor.x = ((((((((((((((((((((((((((((((((float((s + i) + int(us)) + "
+         "float(ui)) + h) + f) + float(s2s)) + float(i2s)) + float(us2s)) + float(ui2s)) + "
+         "float(h2s)) + float(f2s)) + float(s2i)) + float(i2i)) + float(us2i)) + float(ui2i)) + "
+         "float(h2i)) + float(f2i)) + float(s2us)) + float(i2us)) + float(us2us)) + "
+         "float(ui2us)) + float(h2us)) + float(f2us)) + float(s2ui)) + float(i2ui)) + "
+         "float(us2ui)) + float(ui2ui)) + float(h2ui)) + float(f2ui)) + s2f) + i2f) + us2f) + "
+         "ui2f) + h2f) + f2f;\n"
+         "}\n");
 }
 
 DEF_TEST(SkSLForceHighPrecision, r) {