remove type promotion changes

Author: farzonl

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -10270,8 +10270,6 @@ def err_vec_builtin_non_vector : Error<
  "first two arguments to %0 must be vectors">;
 def err_vec_builtin_incompatible_vector : Error<
   "first two arguments to %0 must have the same type">;
-def err_vec_builtin_incompatible_size : Error<
-  "first two arguments to %0 must have the same size">;
 def err_vsx_builtin_nonconstant_argument : Error<
   "argument %0 to %1 must be a 2-bit unsigned literal (i.e. 0, 1, 2 or 3)">;
 
@@ -12120,6 +12118,9 @@ def err_hlsl_param_qualifier_mismatch :
 def warn_hlsl_impcast_vector_truncation : Warning<
   "implicit conversion truncates vector: %0 to %1">, InGroup<Conversion>;
 
+def warn_hlsl_impcast_bitwidth_reduction : Warning<
+  "implicit conversion from larger type: %0 to smaller type %1, possible loss of data">, InGroup<Conversion>;
+
 // Layout randomization diagnostics.
 def err_non_designated_init_used : Error<
   "a randomized struct can only be initialized with a designated initializer">;

clang/lib/CodeGen/CGBuiltin.cpp

@@ -17977,11 +17977,11 @@ Value *CodeGenFunction::EmitHLSLBuiltinExpr(unsigned BuiltinID,
     llvm::Type *T1 = Op1->getType();
     if (!T0->isVectorTy() && !T1->isVectorTy()) {
       if (T0->isFloatingPointTy()) {
-      return Builder.CreateFMul(Op0, Op1, "dx.dot");
+        return Builder.CreateFMul(Op0, Op1, "dx.dot");
       }
 
       if (T0->isIntegerTy()) {
-      return Builder.CreateMul(Op0, Op1, "dx.dot");
+        return Builder.CreateMul(Op0, Op1, "dx.dot");
       }
       // Bools should have been promoted
       assert(

clang/lib/Sema/SemaChecking.cpp

@@ -5166,6 +5166,9 @@ bool Sema::CheckPPCMMAType(QualType Type, SourceLocation TypeLoc) {
   return false;
 }
 
+// Helper function for CheckHLSLBuiltinFunctionCall
+// Note: UsualArithmeticConversions handles the case where at least
+// one arg isn't a bool
 bool PromoteBoolsToInt(Sema *S, CallExpr *TheCall) {
   unsigned NumArgs = TheCall->getNumArgs();
 
@@ -5181,47 +5184,13 @@ bool PromoteBoolsToInt(Sema *S, CallExpr *TheCall) {
                                                    Sema::AA_Converting);
     if (ResA.isInvalid())
       return true;
-    TheCall->setArg(0, ResA.get());
+    TheCall->setArg(i, ResA.get());
   }
   return false;
 }
 
-int overloadOrder(Sema *S, QualType ArgTyA) {
-  auto kind = ArgTyA->getAs<BuiltinType>()->getKind();
-  switch (kind) {
-  case BuiltinType::Short:
-  case BuiltinType::UShort:
-    return 1;
-  case BuiltinType::Int:
-  case BuiltinType::UInt:
-    return 2;
-  case BuiltinType::Long:
-  case BuiltinType::ULong:
-    return 3;
-  case BuiltinType::LongLong:
-  case BuiltinType::ULongLong:
-    return 4;
-  case BuiltinType::Float16:
-  case BuiltinType::Half:
-    return 5;
-  case BuiltinType::Float:
-    return 6;
-  default:
-    break;
-  }
-  return 0;
-}
-
-QualType getVecLargestBitness(Sema *S, QualType ArgTyA, QualType ArgTyB) {
-  auto *VecTyA = ArgTyA->getAs<VectorType>();
-  auto *VecTyB = ArgTyB->getAs<VectorType>();
-  QualType VecTyAElem = VecTyA->getElementType();
-  QualType VecTyBElem = VecTyB->getElementType();
-  int vecAElemWidth = overloadOrder(S, VecTyAElem);
-  int vecBElemWidth = overloadOrder(S, VecTyBElem);
-  return vecAElemWidth > vecBElemWidth ? ArgTyA : ArgTyB;
-}
-
+// Helper function for CheckHLSLBuiltinFunctionCall
+// Handles the CK_HLSLVectorTruncation case for builtins
 void PromoteVectorArgTruncation(Sema *S, CallExpr *TheCall) {
   assert(TheCall->getNumArgs() > 1);
   ExprResult A = TheCall->getArg(0);
@@ -5246,6 +5215,7 @@ void PromoteVectorArgTruncation(Sema *S, CallExpr *TheCall) {
     SmallerArg = B.get();
     largerIndex = 0;
   }
+
   S->Diag(TheCall->getExprLoc(), diag::warn_hlsl_impcast_vector_truncation)
       << LargerArg->getType() << SmallerArg->getType()
       << LargerArg->getSourceRange() << SmallerArg->getSourceRange();
@@ -5255,61 +5225,79 @@ void PromoteVectorArgTruncation(Sema *S, CallExpr *TheCall) {
   return;
 }
 
-bool PromoteVectorElementCallArgs(Sema *S, CallExpr *TheCall) {
+// Helper function for CheckHLSLBuiltinFunctionCall
+void CheckVectorFloatPromotion(Sema *S, ExprResult &source, QualType targetTy,
+                               SourceRange targetSrcRange,
+                               SourceLocation BuiltinLoc) {
+  auto *vecTyTarget = source.get()->getType()->getAs<VectorType>();
+  assert(vecTyTarget);
+  QualType vecElemT = vecTyTarget->getElementType();
+  if (!vecElemT->isFloatingType() && targetTy->isFloatingType()) {
+    QualType floatVecTy = S->Context.getVectorType(
+        S->Context.FloatTy, vecTyTarget->getNumElements(), VectorKind::Generic);
+    int floatByteSize =
+        S->Context.getTypeSizeInChars(S->Context.FloatTy).getQuantity();
+    int vecElemByteSize = S->Context.getTypeSizeInChars(vecElemT).getQuantity();
+    if (vecElemByteSize > floatByteSize)
+      S->Diag(BuiltinLoc, diag::warn_hlsl_impcast_bitwidth_reduction)
+          << source.get()->getType() << floatVecTy
+          << source.get()->getSourceRange() << targetSrcRange;
+
+    source = S->SemaConvertVectorExpr(
+        source.get(), S->Context.CreateTypeSourceInfo(floatVecTy), BuiltinLoc,
+        source.get()->getBeginLoc());
+  }
+}
+
+// Helper function for CheckHLSLBuiltinFunctionCall
+void PromoteVectorArgSplat(Sema *S, ExprResult &source, QualType targetTy) {
+  QualType sourceTy = source.get()->getType();
+  auto *vecTyTarget = targetTy->getAs<VectorType>();
+  QualType vecElemT = vecTyTarget->getElementType();
+  if (vecElemT->isFloatingType() && sourceTy != vecElemT)
+    // if float vec splat wil do an unnecessary cast to double
+    source = S->ImpCastExprToType(source.get(), vecElemT, CK_FloatingCast);
+  source = S->ImpCastExprToType(source.get(), targetTy, CK_VectorSplat);
+}
+
+// Helper function for CheckHLSLBuiltinFunctionCall
+bool CheckVectorElementCallArgs(Sema *S, CallExpr *TheCall) {
   assert(TheCall->getNumArgs() > 1);
   ExprResult A = TheCall->getArg(0);
   ExprResult B = TheCall->getArg(1);
   QualType ArgTyA = A.get()->getType();
   QualType ArgTyB = B.get()->getType();
-
   auto *VecTyA = ArgTyA->getAs<VectorType>();
   auto *VecTyB = ArgTyB->getAs<VectorType>();
+
   if (VecTyA == nullptr && VecTyB == nullptr)
     return false;
+
   if (VecTyA && VecTyB) {
     if (VecTyA->getElementType() == VecTyB->getElementType()) {
       TheCall->setType(VecTyA->getElementType());
       return false;
     }
-    SourceLocation BuiltinLoc = TheCall->getBeginLoc();
-    QualType CastType = getVecLargestBitness(S, ArgTyA, ArgTyB);
-    if (CastType == ArgTyA) {
-      ExprResult ResB = S->SemaConvertVectorExpr(
-          B.get(), S->Context.CreateTypeSourceInfo(ArgTyA), BuiltinLoc,
-          B.get()->getBeginLoc());
-      TheCall->setArg(1, ResB.get());
-      TheCall->setType(VecTyA->getElementType());
-      return false;
-    }
-
-    if (CastType == ArgTyB) {
-      ExprResult ResA = S->SemaConvertVectorExpr(
-          A.get(), S->Context.CreateTypeSourceInfo(ArgTyB), BuiltinLoc,
-          A.get()->getBeginLoc());
-      TheCall->setArg(0, ResA.get());
-      TheCall->setType(VecTyB->getElementType());
-      return false;
-    }
-    return false;
+    // Note: type promotion is intended to be handeled via the intrinsics
+    //  and not the builtin itself.
+    S->Diag(TheCall->getBeginLoc(), diag::err_vec_builtin_incompatible_vector)
+        << TheCall->getDirectCallee()
+        << SourceRange(A.get()->getBeginLoc(), B.get()->getEndLoc());
+    return true;
   }
 
   if (VecTyB) {
-    // Convert  to the vector result type
-    ExprResult ResA = A;
-    if (VecTyB->getElementType() != ArgTyA)
-      ResA = S->ImpCastExprToType(ResA.get(), VecTyB->getElementType(),
-                                  CK_FloatingCast);
-    ResA = S->ImpCastExprToType(ResA.get(), ArgTyB, CK_VectorSplat);
-    TheCall->setArg(0, ResA.get());
+    CheckVectorFloatPromotion(S, B, ArgTyA, A.get()->getSourceRange(),
+                              TheCall->getBeginLoc());
+    PromoteVectorArgSplat(S, A, B.get()->getType());
   }
   if (VecTyA) {
-    ExprResult ResB = B;
-    if (VecTyA->getElementType() != ArgTyB)
-      ResB = S->ImpCastExprToType(ResB.get(), VecTyA->getElementType(),
-                                  CK_FloatingCast);
-    ResB = S->ImpCastExprToType(ResB.get(), ArgTyA, CK_VectorSplat);
-    TheCall->setArg(1, ResB.get());
+    CheckVectorFloatPromotion(S, A, ArgTyB, B.get()->getSourceRange(),
+                              TheCall->getBeginLoc());
+    PromoteVectorArgSplat(S, B, A.get()->getType());
   }
+  TheCall->setArg(0, A.get());
+  TheCall->setArg(1, B.get());
   return false;
 }
 
@@ -5322,7 +5310,7 @@ bool Sema::CheckHLSLBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
       return true;
     if (PromoteBoolsToInt(this, TheCall))
       return true;
-    if (PromoteVectorElementCallArgs(this, TheCall))
+    if (CheckVectorElementCallArgs(this, TheCall))
       return true;
     PromoteVectorArgTruncation(this, TheCall);
     if (SemaBuiltinVectorToScalarMath(TheCall))

clang/test/CodeGenHLSL/builtins/dot-builtin.hlsl

@@ -0,0 +1,83 @@
+// RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \
+// RUN:   dxil-pc-shadermodel6.3-library %s -fnative-half-type \
+// RUN:   -emit-llvm -disable-llvm-passes -O3 -o - | FileCheck %s \ 
+// RUN:   --check-prefixes=CHECK
+
+// CHECK:  %dx.dot = call float @llvm.dx.dot.v2f32(<2 x float> %splat.splat, <2 x float> %1)
+// CHECK: ret float %dx.dot
+float test_builtin_dot_float2_splat ( float p0, float2 p1 ) {
+  return __builtin_hlsl_dot( p0, p1 );
+}
+
+// CHECK:  %dx.dot = call float @llvm.dx.dot.v3f32(<3 x float> %splat.splat, <3 x float> %1)
+// CHECK: ret float %dx.dot
+float test_builtin_dot_float3_splat ( float p0, float3 p1 ) {
+  return __builtin_hlsl_dot( p0, p1 );
+}
+
+// CHECK:  %dx.dot = call float @llvm.dx.dot.v4f32(<4 x float> %splat.splat, <4 x float> %1)
+// CHECK: ret float %dx.dot
+float test_builtin_dot_float4_splat ( float p0, float4 p1 ) {
+  return __builtin_hlsl_dot( p0, p1 );
+}
+
+// CHECK: %conv = sitofp i32 %1 to float
+// CHECK: %splat.splatinsert = insertelement <2 x float> poison, float %conv, i64 0
+// CHECK: %splat.splat = shufflevector <2 x float> %splat.splatinsert, <2 x float> poison, <2 x i32> zeroinitializer
+// CHECK: %dx.dot = call float @llvm.dx.dot.v2f32(<2 x float> %0, <2 x float> %splat.splat)
+// CHECK: ret float %dx.dot
+float test_dot_float2_int_splat ( float2 p0, int p1 ) {
+  return __builtin_hlsl_dot ( p0, p1 );
+}
+
+// CHECK: %conv = sitofp i32 %1 to float
+// CHECK: %splat.splatinsert = insertelement <3 x float> poison, float %conv, i64 0
+// CHECK: %splat.splat = shufflevector <3 x float> %splat.splatinsert, <3 x float> poison, <3 x i32> zeroinitializer
+// CHECK: %dx.dot = call float @llvm.dx.dot.v3f32(<3 x float> %0, <3 x float> %splat.splat)
+// CHECK: ret float %dx.dot
+float test_dot_float3_int_splat ( float3 p0, int p1 ) {
+  return __builtin_hlsl_dot ( p0, p1 );
+}
+
+// CHECK: %conv1 = uitofp i1 %tobool to double
+// CHECK: %dx.dot = fmul double %conv, %conv1
+// CHECK: %conv2 = fptrunc double %dx.dot to float
+// CHECK: ret float %conv2
+float builtin_bool_to_float_type_promotion ( float p0, bool p1 ) {
+  return __builtin_hlsl_dot ( p0, p1 );
+}
+
+// CHECK: %conv = uitofp i1 %tobool to double
+// CHECK: %conv1 = fpext float %1 to double
+// CHECK: %dx.dot = fmul double %conv, %conv1
+// CHECK: %conv2 = fptrunc double %dx.dot to float
+// CHECK: ret float %conv2
+float builtin_bool_to_float_arg1_type_promotion ( bool p0, float p1 ) {
+  return __builtin_hlsl_dot ( p0, p1 );
+}
+
+// CHECK: %conv = zext i1 %tobool to i32
+// CHECK: %conv3 = zext i1 %tobool2 to i32
+// CHECK: %dx.dot = mul i32 %conv, %conv3
+// CHECK: ret i32 %dx.dot
+int test_builtin_dot_bool_type_promotion ( bool p0, bool p1 ) {
+  return __builtin_hlsl_dot ( p0, p1 );
+}
+
+// CHECK: %conv = fpext float %0 to double
+// CHECK: %conv1 = sitofp i32 %1 to double
+// CHECK: dx.dot = fmul double %conv, %conv1
+// CHECK: %conv2 = fptrunc double %dx.dot to float
+// CHECK: ret float %conv2
+float test_builtin_dot_int_to_float_promotion ( float p0, int p1 ) {
+  return __builtin_hlsl_dot ( p0, p1 );
+}
+
+
+// CHECK: %conv = sitofp <2 x i32> %0 to <2 x float>
+// CHECK: %splat.splat = shufflevector <2 x float> %splat.splatinsert, <2 x float> poison, <2 x i32> zeroinitializer
+// CHECK: %dx.dot = call float @llvm.dx.dot.v2f32(<2 x float> %conv, <2 x float> %splat.splat)
+// CHECK: ret float %dx.dot
+float test_builtin_dot_int-vect_to_float_vec_promotion ( int2 p0, float p1 ) {
+  return __builtin_hlsl_dot ( p0, p1 );
+}