[Matrix] Implement static cast for matrix types

[SaurabhJha]

Summary

This patch implements static casts for matrix types. This patch finishes all the work needed for https://bugs.llvm.org/show_bug.cgi?id=47141

[SaurabhJha]

I have commit access so I can get this into main branch after its approved.

[fhahn]

LGTM from the mechanical aspect. Please wait a few days with committing, in case there are any conceptual issues with supporting matrix casts here.

[SaurabhJha]

In D102125#2746764, @fhahn wrote:

LGTM from the mechanical aspect. Please wait a few days with committing, in case there are any conceptual issues with supporting matrix casts here.

Sure, sounds good.

[SaurabhJha]

I am planning to commit this on Sunday.

clang/lib/Sema/SemaCast.cpp

void CastOperation::CheckStaticCast() {
   CheckNoDerefRAII NoderefCheck(*this);
 
   if (isPlaceholder()) {
     checkNonOverloadPlaceholders();
     if (SrcExpr.isInvalid())
       return;
   }
 
+  if (DestType->getAs<MatrixType>() ||
+      SrcExpr.get()->getType()->getAs<MatrixType>()) {
+    if (Self.CheckMatrixCast(OpRange, DestType, SrcExpr.get()->getType(), Kind))
+      SrcExpr = ExprError();
+    return;
+  }
+
   // This test is outside everything else because it's the only case where
   // a non-lvalue-reference target type does not lead to decay.
   // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
   if (DestType->isVoidType()) {
     Kind = CK_ToVoid;
 
     if (claimPlaceholder(BuiltinType::Overload)) {
       Self.ResolveAndFixSingleFunctionTemplateSpecialization(SrcExpr,

clang/test/CodeGenCXX/matrix-casts.cpp

 // RUN: %clang_cc1 -std=c++11 -fenable-matrix -triple x86_64-apple-darwin %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s
 
 template <typename X>
 using matrix_4_4 = X __attribute__((matrix_type(4, 4)));
 
 template <typename Y>
 using matrix_5_5 = Y __attribute__((matrix_type(5, 5)));
 
-// CHECK-LABEL: define{{.*}} void @_Z19CastCharMatrixToIntv
-void CastCharMatrixToInt() {
+// CHECK-LABEL: define{{.*}} void @_Z25CastCharMatrixToIntCStylev()
+void CastCharMatrixToIntCStyle() {
   // CHECK: [[C:%.*]] = load <25 x i8>, <25 x i8>* {{.*}}, align 1
   // CHECK-NEXT: [[CONV:%.*]] = sext <25 x i8> [[C]] to <25 x i32>
   // CHECK-NEXT: [[CONV1:%.*]] = bitcast [25 x i32]* {{.*}} to <25 x i32>*
   // CHECK-NEXT: store <25 x i32> [[CONV]], <25 x i32>* [[CONV1]], align 4
 
   matrix_5_5<char> c;
   matrix_5_5<int> i;
   i = (matrix_5_5<int>)c;
 }
 
-// CHECK-LABEL: define{{.*}} void @_Z27CastCharMatrixToUnsignedIntv
-void CastCharMatrixToUnsignedInt() {
+// CHECK-LABEL: define{{.*}} void @_Z29CastCharMatrixToIntStaticCastv()
+void CastCharMatrixToIntStaticCast() {
+  // CHECK: [[C:%.*]] = load <25 x i8>, <25 x i8>* {{.*}}, align 1
+  // CHECK-NEXT: [[CONV:%.*]] = sext <25 x i8> [[C]] to <25 x i32>
+  // CHECK-NEXT: [[CONV1:%.*]] = bitcast [25 x i32]* {{.*}} to <25 x i32>*
+  // CHECK-NEXT: store <25 x i32> [[CONV]], <25 x i32>* [[CONV1]], align 4
+
+  matrix_5_5<char> c;
+  matrix_5_5<int> i;
+  i = static_cast<matrix_5_5<int>>(c);
+}
+
+// CHECK-LABEL: define{{.*}} void @_Z33CastCharMatrixToUnsignedIntCStylev
+void CastCharMatrixToUnsignedIntCStyle() {
   // CHECK:       [[C:%.*]] = load <25 x i8>, <25 x i8>* {{.*}}, align 1
   // CHECK-NEXT:  [[CONV:%.*]] = sext <25 x i8> [[C]] to <25 x i32>
   // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i32]* {{.*}} to <25 x i32>*
   // CHECK-NEXT:  store <25 x i32> [[CONV]], <25 x i32>* [[CONV1]], align 4
   // CHECK-NEXT:  ret void
 
   matrix_5_5<char> c;
   matrix_5_5<unsigned int> u;
   u = (matrix_5_5<unsigned int>)c;
 }
 
-// CHECK-LABEL: define{{.*}} void @_Z32CastUnsignedLongIntMatrixToShortv
-void CastUnsignedLongIntMatrixToShort() {
+// CHECK-LABEL: define{{.*}} void @_Z37CastCharMatrixToUnsignedIntStaticCastv
+void CastCharMatrixToUnsignedIntStaticCast() {
+  // CHECK:       [[C:%.*]] = load <25 x i8>, <25 x i8>* {{.*}}, align 1
+  // CHECK-NEXT:  [[CONV:%.*]] = sext <25 x i8> [[C]] to <25 x i32>
+  // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i32]* {{.*}} to <25 x i32>*
+  // CHECK-NEXT:  store <25 x i32> [[CONV]], <25 x i32>* [[CONV1]], align 4
+  // CHECK-NEXT:  ret void
+
+  matrix_5_5<char> c;
+  matrix_5_5<unsigned int> u;
+  u = static_cast<matrix_5_5<unsigned int>>(c);
+}
+
+// CHECK-LABEL: define{{.*}} void @_Z38CastUnsignedLongIntMatrixToShortCStylev
+void CastUnsignedLongIntMatrixToShortCStyle() {
   // CHECK:      [[U:%.*]] = load <25 x i64>, <25 x i64>* {{.*}}, align 8
   // CHECK-NEXT: [[CONV:%.*]] = trunc <25 x i64> {{.*}} to <25 x i16>
   // CHECK-NEXT: [[CONV1:%.*]] = bitcast [25 x i16]* {{.*}} to <25 x i16>*
   // CHECK-NEXT: store <25 x i16> [[CONV]], <25 x i16>* [[CONV1]], align 2
   // CHECK-NEXT: ret void
 
   matrix_5_5<unsigned long int> u;
   matrix_5_5<short int> s;
   s = (matrix_5_5<short int>)u;
 }
 
-// CHECK-LABEL: define{{.*}} void @_Z20CastIntMatrixToShortv()
-void CastIntMatrixToShort() {
+// CHECK-LABEL: define{{.*}} void @_Z42CastUnsignedLongIntMatrixToShortStaticCastv
+void CastUnsignedLongIntMatrixToShortStaticCast() {
+  // CHECK:      [[U:%.*]] = load <25 x i64>, <25 x i64>* {{.*}}, align 8
+  // CHECK-NEXT: [[CONV:%.*]] = trunc <25 x i64> {{.*}} to <25 x i16>
+  // CHECK-NEXT: [[CONV1:%.*]] = bitcast [25 x i16]* {{.*}} to <25 x i16>*
+  // CHECK-NEXT: store <25 x i16> [[CONV]], <25 x i16>* [[CONV1]], align 2
+  // CHECK-NEXT: ret void
+
+  matrix_5_5<unsigned long int> u;
+  matrix_5_5<short int> s;
+  s = static_cast<matrix_5_5<short int>>(u);
+}
+
+// CHECK-LABEL: define{{.*}} void @_Z26CastIntMatrixToShortCStylev()
+void CastIntMatrixToShortCStyle() {
   // CHECK:       [[I:%.*]] = load <25 x i32>, <25 x i32>* {{.*}}, align 4
   // CHECK-NEXT:  [[CONV:%.*]] = trunc <25 x i32> [[I]] to <25 x i16>
   // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i16]* {{.*}} to <25 x i16>*
   // CHECK-NEXT:  store <25 x i16> [[CONV]], <25 x i16>* [[CONV1]], align 2
   // CHECK-NEXT:  ret void
 
   matrix_5_5<int> i;
   matrix_5_5<short int> s;
   s = (matrix_5_5<short int>)i;
 }
 
-// CHECK-LABEL: define{{.*}} void @_Z20CastIntMatrixToFloatv()
-void CastIntMatrixToFloat() {
+// CHECK-LABEL: define{{.*}} void @_Z30CastIntMatrixToShortStaticCastv()
+void CastIntMatrixToShortStaticCast() {
+  // CHECK:       [[I:%.*]] = load <25 x i32>, <25 x i32>* {{.*}}, align 4
+  // CHECK-NEXT:  [[CONV:%.*]] = trunc <25 x i32> [[I]] to <25 x i16>
+  // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i16]* {{.*}} to <25 x i16>*
+  // CHECK-NEXT:  store <25 x i16> [[CONV]], <25 x i16>* [[CONV1]], align 2
+  // CHECK-NEXT:  ret void
+
+  matrix_5_5<int> i;
+  matrix_5_5<short int> s;
+  s = static_cast<matrix_5_5<short int>>(i);
+}
+
+// CHECK-LABEL: define{{.*}} void @_Z26CastIntMatrixToFloatCStylev()
+void CastIntMatrixToFloatCStyle() {
   // CHECK:       [[I:%.*]] = load <25 x i32>, <25 x i32>* {{.*}}, align 4
   // CHECK-NEXT:  [[CONV]] = sitofp <25 x i32> {{.*}} to <25 x float>
   // CHECK-NEXT:  [[CONV1]] = bitcast [25 x float]* {{.*}} to <25 x float>*
   // CHECK-NEXT:  store <25 x float> [[CONV]], <25 x float>* [[CONV1]], align 4
   // CHECK-NEXT:  ret void
 
   matrix_5_5<int> i;
   matrix_5_5<float> f;
   f = (matrix_5_5<float>)i;
 }
 
-// CHECK-LABEL: define{{.*}} void @_Z28CastUnsignedIntMatrixToFloatv()
-void CastUnsignedIntMatrixToFloat() {
+// CHECK-LABEL: define{{.*}} void @_Z30CastIntMatrixToFloatStaticCastv()
+void CastIntMatrixToFloatStaticCast() {
+  // CHECK:       [[I:%.*]] = load <25 x i32>, <25 x i32>* {{.*}}, align 4
+  // CHECK-NEXT:  [[CONV]] = sitofp <25 x i32> {{.*}} to <25 x float>
+  // CHECK-NEXT:  [[CONV1]] = bitcast [25 x float]* {{.*}} to <25 x float>*
+  // CHECK-NEXT:  store <25 x float> [[CONV]], <25 x float>* [[CONV1]], align 4
+  // CHECK-NEXT:  ret void
+
+  matrix_5_5<int> i;
+  matrix_5_5<float> f;
+  f = static_cast<matrix_5_5<float>>(i);
+}
+
+// CHECK-LABEL: define{{.*}} void @_Z34CastUnsignedIntMatrixToFloatCStylev()
+void CastUnsignedIntMatrixToFloatCStyle() {
   // CHECK:       [[U:%.*]] = load <25 x i16>, <25 x i16>* {{.*}}, align 2
   // CHECK-NEXT:  [[CONV:%.*]] = uitofp <25 x i16> [[U]] to <25 x float>
   // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x float]* {{.*}} to <25 x float>*
   // CHECK-NEXT:  store <25 x float> [[CONV]], <25 x float>* {{.*}}, align 4
   // CHECK-NEXT:  ret void
 
   matrix_5_5<unsigned short int> u;
   matrix_5_5<float> f;
   f = (matrix_5_5<float>)u;
 }
 
-// CHECK-LABEL: define{{.*}} void @_Z21CastDoubleMatrixToIntv()
-void CastDoubleMatrixToInt() {
+// CHECK-LABEL: define{{.*}} void @_Z38CastUnsignedIntMatrixToFloatStaticCastv()
+void CastUnsignedIntMatrixToFloatStaticCast() {
+  // CHECK:       [[U:%.*]] = load <25 x i16>, <25 x i16>* {{.*}}, align 2
+  // CHECK-NEXT:  [[CONV:%.*]] = uitofp <25 x i16> [[U]] to <25 x float>
+  // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x float]* {{.*}} to <25 x float>*
+  // CHECK-NEXT:  store <25 x float> [[CONV]], <25 x float>* {{.*}}, align 4
+  // CHECK-NEXT:  ret void
+
+  matrix_5_5<unsigned short int> u;
+  matrix_5_5<float> f;
+  f = static_cast<matrix_5_5<float>>(u);
+}
+
+// CHECK-LABEL: define{{.*}} void @_Z27CastDoubleMatrixToIntCStylev()
+void CastDoubleMatrixToIntCStyle() {
   // CHECK:       [[D:%.*]] = load <25 x double>, <25 x double>* {{.*}}, align 8
   // CHECK-NEXT:  [[CONV:%.*]] = fptosi <25 x double> [[D]] to <25 x i32>
   // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i32]* %i to <25 x i32>*
   // CHECK-NEXT:  store <25 x i32> [[CONV]], <25 x i32>* {{.*}}, align 4
   // CHECK-NEXT:  ret void
 
   matrix_5_5<double> d;
   matrix_5_5<int> i;
   i = (matrix_5_5<int>)d;
 }
 
-// CHECK-LABEL: define{{.*}} void @_Z33CastFloatMatrixToUnsignedShortIntv()
-void CastFloatMatrixToUnsignedShortInt() {
+// CHECK-LABEL: define{{.*}} void @_Z31CastDoubleMatrixToIntStaticCastv()
+void CastDoubleMatrixToIntStaticCast() {
+  // CHECK:       [[D:%.*]] = load <25 x double>, <25 x double>* {{.*}}, align 8
+  // CHECK-NEXT:  [[CONV:%.*]] = fptosi <25 x double> [[D]] to <25 x i32>
+  // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i32]* %i to <25 x i32>*
+  // CHECK-NEXT:  store <25 x i32> [[CONV]], <25 x i32>* {{.*}}, align 4
+  // CHECK-NEXT:  ret void
+
+  matrix_5_5<double> d;
+  matrix_5_5<int> i;
+  i = static_cast<matrix_5_5<int>>(d);
+}
+
+// CHECK-LABEL: define{{.*}} void @_Z39CastFloatMatrixToUnsignedShortIntCStylev()
+void CastFloatMatrixToUnsignedShortIntCStyle() {
   // CHECK:       [[F:%.*]] = load <25 x float>, <25 x float>* {{.*}}, align 4
   // CHECK-NEXT:  [[CONV:%.*]] = fptoui <25 x float> [[F]] to <25 x i16>
   // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i16]* {{.*}} to <25 x i16>*
   // CHECK-NEXT:  store <25 x i16> [[CONV]], <25 x i16>* [[CONV1]], align 2
   // CHECK-NEXT:  ret void
 
   matrix_5_5<float> f;
   matrix_5_5<unsigned short int> i;
   i = (matrix_5_5<unsigned short int>)f;
 }
 
-// CHECK-LABEL: define{{.*}} void @_Z23CastDoubleMatrixToFloatv()
-void CastDoubleMatrixToFloat() {
+// CHECK-LABEL: define{{.*}} void @_Z43CastFloatMatrixToUnsignedShortIntStaticCastv()
+void CastFloatMatrixToUnsignedShortIntStaticCast() {
+  // CHECK:       [[F:%.*]] = load <25 x float>, <25 x float>* {{.*}}, align 4
+  // CHECK-NEXT:  [[CONV:%.*]] = fptoui <25 x float> [[F]] to <25 x i16>
+  // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i16]* {{.*}} to <25 x i16>*
+  // CHECK-NEXT:  store <25 x i16> [[CONV]], <25 x i16>* [[CONV1]], align 2
+  // CHECK-NEXT:  ret void
+
+  matrix_5_5<float> f;
+  matrix_5_5<unsigned short int> i;
+  i = static_cast<matrix_5_5<unsigned short int>>(f);
+}
+
+// CHECK-LABEL: define{{.*}} void @_Z29CastDoubleMatrixToFloatCStylev()
+void CastDoubleMatrixToFloatCStyle() {
   // CHECK:       [[D:%.*]] = load <25 x double>, <25 x double>* {{.*}}, align 8
   // CHECK-NEXT:  [[CONV:%.*]] = fptrunc <25 x double> [[D]] to <25 x float>
   // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x float]* {{.*}} to <25 x float>*
   // CHECK-NEXT:  store <25 x float> [[CONV]], <25 x float>* [[CONV1]], align 4
   // CHECK-NEXT:  ret void
 
   matrix_5_5<double> d;
   matrix_5_5<float> f;
   f = (matrix_5_5<float>)d;
 }
 
-// CHECK-LABEL: define{{.*}} void @_Z33CastUnsignedShortIntToUnsignedIntv()
-void CastUnsignedShortIntToUnsignedInt() {
+// CHECK-LABEL: define{{.*}} void @_Z33CastDoubleMatrixToFloatStaticCastv()
+void CastDoubleMatrixToFloatStaticCast() {
+  // CHECK:       [[D:%.*]] = load <25 x double>, <25 x double>* {{.*}}, align 8
+  // CHECK-NEXT:  [[CONV:%.*]] = fptrunc <25 x double> [[D]] to <25 x float>
+  // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x float]* {{.*}} to <25 x float>*
+  // CHECK-NEXT:  store <25 x float> [[CONV]], <25 x float>* [[CONV1]], align 4
+  // CHECK-NEXT:  ret void
+
+  matrix_5_5<double> d;
+  matrix_5_5<float> f;
+  f = static_cast<matrix_5_5<float>>(d);
+}
+
+// CHECK-LABEL: define{{.*}} void @_Z39CastUnsignedShortIntToUnsignedIntCStylev()
+void CastUnsignedShortIntToUnsignedIntCStyle() {
   // CHECK:       [[S:%.*]] = load <25 x i16>, <25 x i16>* {{.*}}, align 2
   // CHECK-NEXT:  [[CONV:%.*]] = zext <25 x i16> [[S]] to <25 x i32>
   // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i32]* {{.*}} to <25 x i32>*
   // CHECK-NEXT:  store <25 x i32> [[CONV]], <25 x i32>* [[CONV1]], align 4
   // CHECK-NEXT:  ret void
 
   matrix_5_5<unsigned short int> s;
   matrix_5_5<unsigned int> i;
   i = (matrix_5_5<unsigned int>)s;
 }
 
-// CHECK-LABEL: define{{.*}} void @_Z37CastUnsignedLongIntToUnsignedShortIntv()
-void CastUnsignedLongIntToUnsignedShortInt() {
+// CHECK-LABEL: define{{.*}} void @_Z43CastUnsignedShortIntToUnsignedIntStaticCastv()
+void CastUnsignedShortIntToUnsignedIntStaticCast() {
+  // CHECK:       [[S:%.*]] = load <25 x i16>, <25 x i16>* {{.*}}, align 2
+  // CHECK-NEXT:  [[CONV:%.*]] = zext <25 x i16> [[S]] to <25 x i32>
+  // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i32]* {{.*}} to <25 x i32>*
+  // CHECK-NEXT:  store <25 x i32> [[CONV]], <25 x i32>* [[CONV1]], align 4
+  // CHECK-NEXT:  ret void
+
+  matrix_5_5<unsigned short int> s;
+  matrix_5_5<unsigned int> i;
+  i = static_cast<matrix_5_5<unsigned int>>(s);
+}
+
+// CHECK-LABEL: define{{.*}} void @_Z43CastUnsignedLongIntToUnsignedShortIntCStylev()
+void CastUnsignedLongIntToUnsignedShortIntCStyle() {
   // CHECK:       [[L:%.*]] = load <25 x i64>, <25 x i64>* %0, align 8
   // CHECK-NEXT:  [[CONV:%.*]] = trunc <25 x i64> [[L]] to <25 x i16>
   // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i16]* {{.*}} to <25 x i16>*
   // CHECK-NEXT:  store <25 x i16> [[CONV]], <25 x i16>* [[CONV1]], align 2
   // CHECK-NEXT:  ret void
 
   matrix_5_5<unsigned long int> l;
   matrix_5_5<unsigned short int> s;
   s = (matrix_5_5<unsigned short int>)l;
 }
 
-// CHECK-LABEL: define{{.*}} void @_Z25CastUnsignedShortIntToIntv()
-void CastUnsignedShortIntToInt() {
+// CHECK-LABEL: define{{.*}} void @_Z47CastUnsignedLongIntToUnsignedShortIntStaticCastv()
+void CastUnsignedLongIntToUnsignedShortIntStaticCast() {
+  // CHECK:       [[L:%.*]] = load <25 x i64>, <25 x i64>* %0, align 8
+  // CHECK-NEXT:  [[CONV:%.*]] = trunc <25 x i64> [[L]] to <25 x i16>
+  // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i16]* {{.*}} to <25 x i16>*
+  // CHECK-NEXT:  store <25 x i16> [[CONV]], <25 x i16>* [[CONV1]], align 2
+  // CHECK-NEXT:  ret void
+
+  matrix_5_5<unsigned long int> l;
+  matrix_5_5<unsigned short int> s;
+  s = static_cast<matrix_5_5<unsigned short int>>(l);
+}
+
+// CHECK-LABEL: define{{.*}} void @_Z31CastUnsignedShortIntToIntCStylev()
+void CastUnsignedShortIntToIntCStyle() {
   // CHECK:       [[U:%.*]] = load <25 x i16>, <25 x i16>* %0, align 2
   // CHECK-NEXT:  [[CONV:%.*]] = zext <25 x i16> [[U]] to <25 x i32>
   // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i32]* {{.*}} to <25 x i32>*
   // CHECK-NEXT:  store <25 x i32> [[CONV]], <25 x i32>* {{.*}}, align 4
   // CHECK-NEXT:  ret void
 
   matrix_5_5<unsigned short int> u;
   matrix_5_5<int> i;
   i = (matrix_5_5<int>)u;
 }
 
-// CHECK-LABEL: define{{.*}} void @_Z24CastIntToUnsignedLongIntv()
-void CastIntToUnsignedLongInt() {
+// CHECK-LABEL: define{{.*}} void @_Z35CastUnsignedShortIntToIntStaticCastv()
+void CastUnsignedShortIntToIntStaticCast() {
+  // CHECK:       [[U:%.*]] = load <25 x i16>, <25 x i16>* %0, align 2
+  // CHECK-NEXT:  [[CONV:%.*]] = zext <25 x i16> [[U]] to <25 x i32>
+  // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i32]* {{.*}} to <25 x i32>*
+  // CHECK-NEXT:  store <25 x i32> [[CONV]], <25 x i32>* {{.*}}, align 4
+  // CHECK-NEXT:  ret void
+
+  matrix_5_5<unsigned short int> u;
+  matrix_5_5<int> i;
+  i = static_cast<matrix_5_5<int>>(u);
+}
+
+// CHECK-LABEL: define{{.*}} void @_Z30CastIntToUnsignedLongIntCStylev()
+void CastIntToUnsignedLongIntCStyle() {
   // CHECK:       [[I:%.*]] = load <25 x i32>, <25 x i32>* %0, align 4
   // CHECK-NEXT:  [[CONV:%.*]] = sext <25 x i32> [[I]] to <25 x i64>
   // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i64]* {{.*}} to <25 x i64>*
   // CHECK-NEXT:  store <25 x i64> [[CONV]], <25 x i64>* {{.*}}, align 8
   // CHECK-NEXT:  ret void
 
   matrix_5_5<int> i;
   matrix_5_5<unsigned long int> u;
   u = (matrix_5_5<unsigned long int>)i;
 }
+
+// CHECK-LABEL: define{{.*}} void @_Z34CastIntToUnsignedLongIntStaticCastv()
+void CastIntToUnsignedLongIntStaticCast() {
+  // CHECK:       [[I:%.*]] = load <25 x i32>, <25 x i32>* %0, align 4
+  // CHECK-NEXT:  [[CONV:%.*]] = sext <25 x i32> [[I]] to <25 x i64>
+  // CHECK-NEXT:  [[CONV1:%.*]] = bitcast [25 x i64]* {{.*}} to <25 x i64>*
+  // CHECK-NEXT:  store <25 x i64> [[CONV]], <25 x i64>* {{.*}}, align 8
+  // CHECK-NEXT:  ret void
+
+  matrix_5_5<int> i;
+  matrix_5_5<unsigned long int> u;
+  u = static_cast<matrix_5_5<unsigned long int>>(i);
+}

clang/test/SemaCXX/matrix-casts.cpp

((matrix_type(4, 4)))') and incompatible type 'vec' (vector of 1 'int' value) is not allowed}}
 
   (test_struct *)m1;    // expected-error {{conversion between matrix type 'matrix_4_4<char>' (aka 'char __attribute__\
 ((matrix_type(4, 4)))') and incompatible type 'test_struct *' is not allowed}}'
   (matrix_5_5<float>)s; // expected-error {{conversion between matrix type 'matrix_5_5<float>' (aka 'float __attribute__\
 ((matrix_type(5, 5)))') and incompatible type 'test_struct *' is not allowed}}'
 }
 
 void f2() {
+  matrix_4_4<char> m1;
+  matrix_4_4<int> m2;
+  matrix_4_4<short> m3;
+  matrix_5_5<int> m4;
+  int i;
+  vec v;
+  test_struct *s;
+
+  m2 = static_cast<matrix_4_4<int>>(m1);
+  m3 = static_cast<matrix_4_4<short>>(m2);
+  static_cast<matrix_5_5<int>>(m3); // expected-error {{conversion between matrix types 'matrix_5_5<int>' (aka 'int __attribute__\
+((matrix_type(5, 5)))') and 'matrix_4_4<short>' (aka 'short __attribute__((matrix_type(4, 4)))') of different size is not\
+ allowed}}
+
+  static_cast<int>(m3);            // expected-error {{conversion between matrix type 'matrix_4_4<short>' (aka 'short __attribute__\
+((matrix_type(4, 4)))') and incompatible type 'int' is not allowed}}
+  static_cast<matrix_4_4<int>>(i); // expected-error {{conversion between matrix type 'matrix_4_4<int>' (aka 'int __attribute__\
+((matrix_type(4, 4)))') and incompatible type 'int' is not allowed}}
+
+  static_cast<vec>(m2);             // expected-error {{conversion between matrix type 'matrix_4_4<int>' (aka 'int __attribute__\
+((matrix_type(4, 4)))') and incompatible type 'vec' (vector of 1 'int' value) is not allowed}}
+  static_cast<matrix_4_4<char>>(v); // expected-error {{conversion between matrix type 'matrix_4_4<char>' (aka 'char __attribute__\
+((matrix_type(4, 4)))') and incompatible type 'vec' (vector of 1 'int' value) is not allowed}}
+
+  static_cast<test_struct *>(m1);    // expected-error {{conversion between matrix type 'matrix_4_4<char>' (aka 'char __attribute__\
+((matrix_type(4, 4)))') and incompatible type 'test_struct *' is not allowed}}'
+  static_cast<matrix_5_5<float>>(s); // expected-error {{conversion between matrix type 'matrix_5_5<float>' (aka 'float __attribute__\
+((matrix_type(5, 5)))') and incompatible type 'test_struct *' is not allowed}}'
+}
+
+void f3() {
   matrix_4_4<float> m1;
   matrix_4_4<double> m2;
   matrix_5_5<double> m3;
   matrix_5_5<signed int> m4;
   matrix_4_4<unsigned int> m5;
   matrix_5_5<unsigned int> m6;
   float f;
 
   m2 = (matrix_4_4<double>)m1;
   (matrix_5_5<double>)m1; // expected-error {{conversion between matrix types 'matrix_5_5<double>' (aka 'double __\
 attribute__((matrix_type(5, 5)))') and 'matrix_4_4<float>' (aka 'float __attribute__((matrix_type(4, 4)))') of different\
  size is not allowed}}
   m4 = (matrix_5_5<signed int>)m3;
   m5 = (matrix_5_5<unsigned int>)m4; // expected-error {{assigning to 'matrix_4_4<unsigned int>' (aka 'unsigned int \
 __attribute__((matrix_type(4, 4)))') from incompatible type 'matrix_5_5<unsigned int>' (aka 'unsigned int __attribute__\
 ((matrix_type(5, 5)))')}}
   m6 = (matrix_5_5<unsigned int>)m4;
   m4 = (matrix_5_5<signed int>)m6;
 }
+
+void f4() {
+  matrix_4_4<float> m1;
+  matrix_4_4<double> m2;
+  matrix_5_5<double> m3;
+  matrix_5_5<signed int> m4;
+  matrix_4_4<unsigned int> m5;
+  matrix_5_5<unsigned int> m6;
+  float f;
+
+  m2 = static_cast<matrix_4_4<double>>(m1);
+  static_cast<matrix_5_5<double>>(m1); // expected-error {{conversion between matrix types 'matrix_5_5<double>' (aka 'double __\
+attribute__((matrix_type(5, 5)))') and 'matrix_4_4<float>' (aka 'float __attribute__((matrix_type(4, 4)))') of different\
+ size is not allowed}}
+  m4 = static_cast<matrix_5_5<signed int>>(m3);
+  m5 = static_cast<matrix_5_5<unsigned int>>(m4); // expected-error {{assigning to 'matrix_4_4<unsigned int>' (aka 'unsigned int \
+__attribute__((matrix_type(4, 4)))') from incompatible type 'matrix_5_5<unsigned int>' (aka 'unsigned int __attribute__\
+((matrix_type(5, 5)))')}}
+  m6 = static_cast<matrix_5_5<unsigned int>>(m4);
+  m4 = static_cast<matrix_5_5<signed int>>(m6);
+}