self review

Author: spall

clang/include/clang/Sema/SemaHLSL.h

@@ -144,7 +144,7 @@ class SemaHLSL : public SemaBase {
   bool CanPerformScalarCast(QualType SrcTy, QualType DestTy);
   bool ContainsBitField(QualType BaseTy);
   bool CanPerformElementwiseCast(Expr *Src, QualType DestType);
-  bool CanPerformSplat(Expr *Src, QualType DestType);
+  bool CanPerformSplatCast(Expr *Src, QualType DestType);
   ExprResult ActOnOutParamExpr(ParmVarDecl *Param, Expr *Arg);
 
   QualType getInoutParameterType(QualType Ty);

clang/lib/CodeGen/CGExprAgg.cpp

@@ -500,25 +500,19 @@ static void EmitHLSLSplatCast(CodeGenFunction &CGF, Address DestVal,
   // ^^ Flattened accesses to DestVal we want to store into
   CGF.FlattenAccessAndType(DestVal, DestTy, StoreGEPList, DestTypes);
 
-  if (const VectorType *VT = SrcTy->getAs<VectorType>()) {
-    assert(VT->getNumElements() == 1 && "Invalid HLSL splat cast.");
-
-    SrcTy = VT->getElementType();
-    SrcVal = CGF.Builder.CreateExtractElement(SrcVal, (uint64_t)0, "vec.load");
-  }
   assert(SrcTy->isScalarType() && "Invalid HLSL splat cast.");
-  for (unsigned i = 0; i < StoreGEPList.size(); i++) {
+  for (unsigned I = 0, Size = StoreGEPList.size(); I < Size; I++) {
     llvm::Value *Cast =
-        CGF.EmitScalarConversion(SrcVal, SrcTy, DestTypes[i], Loc);
+        CGF.EmitScalarConversion(SrcVal, SrcTy, DestTypes[I], Loc);
 
     // store back
-    llvm::Value *Idx = StoreGEPList[i].second;
+    llvm::Value *Idx = StoreGEPList[I].second;
     if (Idx) {
       llvm::Value *V =
-          CGF.Builder.CreateLoad(StoreGEPList[i].first, "load.for.insert");
+          CGF.Builder.CreateLoad(StoreGEPList[I].first, "load.for.insert");
       Cast = CGF.Builder.CreateInsertElement(V, Cast, Idx);
     }
-    CGF.Builder.CreateStore(Cast, StoreGEPList[i].first);
+    CGF.Builder.CreateStore(Cast, StoreGEPList[I].first);
   }
 }
 
@@ -1002,12 +996,10 @@ void AggExprEmitter::VisitCastExpr(CastExpr *E) {
     Address DestVal = Dest.getAddress();
     SourceLocation Loc = E->getExprLoc();
 
-    if (RV.isScalar()) {
-      llvm::Value *SrcVal = RV.getScalarVal();
-      EmitHLSLSplatCast(CGF, DestVal, DestTy, SrcVal, SrcTy, Loc);
-      break;
-    }
-    llvm_unreachable("RHS of HLSL splat cast must be a scalar or vector.");
+    assert (RV.isScalar() && "RHS of HLSL splat cast must be a scalar.");
+    llvm::Value *SrcVal = RV.getScalarVal();
+    EmitHLSLSplatCast(CGF, DestVal, DestTy, SrcVal, SrcTy, Loc);
+    break;
   }
   case CK_HLSLElementwiseCast: {
     Expr *Src = E->getSubExpr();

clang/lib/CodeGen/CGExprScalar.cpp

@@ -2796,19 +2796,14 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
     return Builder.CreateExtractElement(Vec, Zero, "cast.vtrunc");
   }
   case CK_HLSLSplatCast: {
-    // This code should only handle splatting from vectors of length 1.
+    // This cast should only handle splatting from vectors of length 1.
+    // But in Sema a cast should have been inserted to convert the vec1 to a scalar
     assert(DestTy->isVectorType() && "Destination type must be a vector.");
     auto *DestVecTy = DestTy->getAs<VectorType>();
     QualType SrcTy = E->getType();
     SourceLocation Loc = CE->getExprLoc();
     Value *V = Visit(const_cast<Expr *>(E));
-    assert(SrcTy->isVectorType() && "Invalid HLSL splat cast.");
-
-    auto *VecTy = SrcTy->getAs<VectorType>();
-    assert(VecTy->getNumElements() == 1 && "Invalid HLSL splat cast.");
-
-    V = CGF.Builder.CreateExtractElement(V, (uint64_t)0, "vec.load");
-    SrcTy = VecTy->getElementType();
+    assert(SrcTy->isBuiltinType() && "Invalid HLSL splat cast.");
 
     Value *Cast =
         EmitScalarConversion(V, SrcTy, DestVecTy->getElementType(), Loc);

clang/lib/Sema/SemaCast.cpp

@@ -2780,7 +2780,12 @@ void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
   // This case should not trigger on regular vector splat
   QualType SrcTy = SrcExpr.get()->getType();
   if (Self.getLangOpts().HLSL &&
-      Self.HLSL().CanPerformSplat(SrcExpr.get(), DestType)) {
+      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;
   }

clang/lib/Sema/SemaHLSL.cpp

@@ -2807,7 +2807,7 @@ bool SemaHLSL::ContainsBitField(QualType BaseTy) {
 // Can perform an HLSL splat cast if the Dest is an aggregate and the
 // Src is a scalar or a vector of length 1
 // Or if Dest is a vector and Src is a vector of length 1
-bool SemaHLSL::CanPerformSplat(Expr *Src, QualType DestTy) {
+bool SemaHLSL::CanPerformSplatCast(Expr *Src, QualType DestTy) {
 
   QualType SrcTy = Src->getType();
   if (SrcTy->isScalarType() && DestTy->isVectorType())

clang/test/SemaHLSL/Language/SplatCasts.hlsl

@@ -22,4 +22,4 @@ struct S {
 // CHECK-NEXt: IntegerLiteral {{.*}} 'int' 5
 export void call2() {
   S s = (S)5; 
-}
+}