fix tests + associated issues in code

Author: spall

clang/lib/Sema/SemaCast.cpp

@@ -2777,19 +2777,7 @@ void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
                                   ? CheckedConversionKind::FunctionalCast
                                   : CheckedConversionKind::CStyleCast;
 
-  // This case should not trigger on regular vector splat
   QualType SrcTy = SrcExpr.get()->getType();
-  if (Self.getLangOpts().HLSL &&
-      Self.HLSL().CanPerformSplatCast(SrcExpr.get(), DestType)) {
-    const VectorType *VT = SrcTy->getAs<VectorType>();
-    // change splat from vec1 case to splat from scalar
-    if (VT && VT->getNumElements() == 1)
-      SrcExpr = Self.ImpCastExprToType(SrcExpr.get(), VT->getElementType(),
-				       CK_HLSLVectorTruncation, VK_PRValue, nullptr, CCK);
-    Kind = CK_HLSLSplatCast;
-    return;
-  }
-
   // This case should not trigger on regular vector cast, vector truncation
   if (Self.getLangOpts().HLSL &&
       Self.HLSL().CanPerformElementwiseCast(SrcExpr.get(), DestType)) {
@@ -2801,6 +2789,21 @@ void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
     return;
   }
 
+  // This case should not trigger on regular vector splat
+  // If the relative order of this and the HLSLElementWise cast checks
+  // are changed, it might change which cast handles what in a few cases
+  if (Self.getLangOpts().HLSL &&
+      Self.HLSL().CanPerformSplatCast(SrcExpr.get(), DestType)) {
+    const VectorType *VT = SrcTy->getAs<VectorType>();
+    // change splat from vec1 case to splat from scalar
+    if (VT && VT->getNumElements() == 1)
+      SrcExpr = Self.ImpCastExprToType(SrcExpr.get(), VT->getElementType(),
+				       CK_HLSLVectorTruncation,
+				       SrcExpr.get()->getValueKind(), nullptr, CCK);
+    Kind = CK_HLSLSplatCast;
+    return;
+  }
+
   if (ValueKind == VK_PRValue && !DestType->isRecordType() &&
       !isPlaceholder(BuiltinType::Overload)) {
     SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());

clang/lib/Sema/SemaHLSL.cpp

@@ -2810,7 +2810,9 @@ bool SemaHLSL::ContainsBitField(QualType BaseTy) {
 bool SemaHLSL::CanPerformSplatCast(Expr *Src, QualType DestTy) {
 
   QualType SrcTy = Src->getType();
-  if (SrcTy->isScalarType() && DestTy->isVectorType())
+  // Not a valid HLSL Splat cast if Dest is a scalar or if this is going to
+  // be a vector splat from a scalar.
+  if ((SrcTy->isScalarType() && DestTy->isVectorType()) || DestTy->isScalarType())
     return false;
 
   const VectorType *SrcVecTy = SrcTy->getAs<VectorType>();

clang/test/CodeGenHLSL/BasicFeatures/SplatCast.hlsl

@@ -20,9 +20,9 @@ export void call4() {
 // CHECK-NEXT: store <1 x i32> splat (i32 1), ptr [[A]], align 4
 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[B]], ptr align 4 {{.*}}, i32 8, i1 false)
 // CHECK-NEXT: [[L:%.*]] = load <1 x i32>, ptr [[A]], align 4
+// CHECK-NEXT: [[VL:%.*]] = extractelement <1 x i32> [[L]], i32 0
 // CHECK-NEXT: [[G1:%.*]] = getelementptr inbounds [2 x i32], ptr [[B]], i32 0, i32 0
 // CHECK-NEXT: [[G2:%.*]] = getelementptr inbounds [2 x i32], ptr [[B]], i32 0, i32 1
-// CHECK-NEXT: [[VL:%.*]] = extractelement <1 x i32> [[L]], i64 0
 // CHECK-NEXT: store i32 [[VL]], ptr [[G1]], align 4
 // CHECK-NEXT: store i32 [[VL]], ptr [[G2]], align 4
 export void call8() {
@@ -37,7 +37,7 @@ export void call8() {
 // CHECK-NEXT: [[A:%.*]] = alloca <4 x i32>, align 16
 // CHECK-NEXT: store <1 x float> splat (float 1.000000e+00), ptr [[B]], align 4
 // CHECK-NEXT: [[L:%.*]] = load <1 x float>, ptr [[B]], align 4
-// CHECK-NEXT: [[VL:%.*]] = extractelement <1 x float> [[L]], i64 0
+// CHECK-NEXT: [[VL:%.*]] = extractelement <1 x float> [[L]], i32 0
 // CHECK-NEXT: [[C:%.*]] = fptosi float [[VL]] to i32
 // CHECK-NEXT: [[SI:%.*]] = insertelement <4 x i32> poison, i32 [[C]], i64 0
 // CHECK-NEXT: [[S:%.*]] = shufflevector <4 x i32> [[SI]], <4 x i32> poison, <4 x i32> zeroinitializer
@@ -58,9 +58,9 @@ struct S {
 // CHECK: [[s:%.*]] = alloca %struct.S, align 4
 // CHECK-NEXT: store <1 x i32> splat (i32 1), ptr [[A]], align 4
 // CHECK-NEXT: [[L:%.*]] = load <1 x i32>, ptr [[A]], align 4
+// CHECK-NEXT: [[VL:%.*]] = extractelement <1 x i32> [[L]], i32 0
 // CHECK-NEXT: [[G1:%.*]] = getelementptr inbounds %struct.S, ptr [[s]], i32 0, i32 0
 // CHECK-NEXT: [[G2:%.*]] = getelementptr inbounds %struct.S, ptr [[s]], i32 0, i32 1
-// CHECK-NEXT: [[VL:%.*]] = extractelement <1 x i32> [[L]], i64 0
 // CHECK-NEXT: store i32 [[VL]], ptr [[G1]], align 4
 // CHECK-NEXT: [[C:%.*]] = sitofp i32 [[VL]] to float
 // CHECK-NEXT: store float [[C]], ptr [[G2]], align 4
@@ -75,9 +75,9 @@ export void call3() {
 // CHECK-NEXT: [[s:%.*]] = alloca %struct.S, align 4
 // CHECK-NEXT: store <1 x i32> splat (i32 1), ptr [[A]], align 4
 // CHECK-NEXT: [[L:%.*]] = load <1 x i32>, ptr [[A]], align 4
+// CHECK-NEXT: [[VL:%.*]] = extractelement <1 x i32> [[L]], i32 0
 // CHECK-NEXT: [[G1:%.*]] = getelementptr inbounds %struct.S, ptr [[s]], i32 0, i32 0
 // CHECK-NEXT: [[G2:%.*]] = getelementptr inbounds %struct.S, ptr [[s]], i32 0, i32 1
-// CHECK-NEXT: [[VL:%.*]] = extractelement <1 x i32> [[L]], i64 0
 // CHECK-NEXT: store i32 [[VL]], ptr [[G1]], align 4
 // CHECK-NEXT: [[C:%.*]] = sitofp i32 [[VL]] to float
 // CHECK-NEXT: store float [[C]], ptr [[G2]], align 4

clang/test/SemaHLSL/Language/SplatCasts.hlsl

@@ -3,6 +3,7 @@
 // splat from vec1 to vec
 // CHECK-LABEL: call1
 // CHECK: CStyleCastExpr {{.*}} 'int3':'vector<int, 3>' <HLSLSplatCast>
+// CHECK-NEXT: ImplicitCastExpr {{.*}} 'float' lvalue <HLSLVectorTruncation> part_of_explicit_cast
 // CHECK-NEXT: DeclRefExpr {{.*}} 'float1':'vector<float, 1>' lvalue Var {{.*}} 'A' 'float1':'vector<float, 1>'
 export void call1() {
   float1 A = {1.0};