Adding asuint implementation to hlsl

Author: joaosaffran-zz

clang/include/clang/Basic/Builtins.td

@@ -53,6 +53,9 @@ class MSInt32_64Template : Template<["msint32_t", "int64_t"],
 class FloatDoubleTemplate : Template<["float", "double"],
                                      ["f",     ""]>;
 
+class HLSLFloatAndIntTemplate : Template<
+            ["unsigned int", "int", "float"],
+            ["",             "si",    "f"]>;
 // FIXME: These assume that char -> i8, short -> i16, int -> i32,
 // long long -> i64.
 class SyncBuiltinsTemplate :
@@ -4751,10 +4754,10 @@ def HLSLRcp : LangBuiltin<"HLSL_LANG"> {
   let Prototype = "void(...)";
 }
 
-def HLSLAsUint : LangBuiltin<"HLSL_LANG"> {
+def HLSLAsUint : LangBuiltin<"HLSL_LANG">, HLSLFloatAndIntTemplate {
   let Spellings = ["__builtin_hlsl_elementwise_asuint"];
   let Attributes = [NoThrow, Const];
-  let Prototype = "void(...)";
+  let Prototype = "unsigned int (T)";
 }
 
 def HLSLRSqrt : LangBuiltin<"HLSL_LANG"> {

clang/lib/CodeGen/CGBuiltin.cpp

@@ -18816,7 +18816,7 @@ case Builtin::BI__builtin_hlsl_elementwise_isinf: {
         {}, false, true));
   }
   case Builtin::BI__builtin_hlsl_elementwise_asuint: {
-    Value *Op = EmitScalarExpr(E->getArg(0)->IgnoreImpCasts());
+    Value *Op = EmitScalarExpr(E->getArg(0));
 
     llvm::Type *DestTy = llvm::Type::getInt32Ty(this->getLLVMContext());
 

clang/lib/Headers/hlsl/hlsl_intrinsics.h

@@ -404,6 +404,24 @@ uint3 asuint(float3);
 _HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_asuint)
 uint4 asuint(float4);
 
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_asuint)
+uint asuint(uint);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_asuint)
+uint2 asuint(uint2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_asuint)
+uint3 asuint(uint3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_asuint)
+uint4 asuint(uint4);
+
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_asuint)
+uint asuint(int);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_asuint)
+uint2 asuint(int2);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_asuint)
+uint3 asuint(int3);
+_HLSL_BUILTIN_ALIAS(__builtin_hlsl_elementwise_asuint)
+uint4 asuint(int4);
+
 //===----------------------------------------------------------------------===//
 // atan builtins
 //===----------------------------------------------------------------------===//

clang/lib/Sema/SemaHLSL.cpp

@@ -1465,25 +1465,6 @@ bool CheckVectorElementCallArgs(Sema *S, CallExpr *TheCall) {
   return true;
 }
 
-bool CheckArgTypeWithoutImplicits(
-    Sema *S, Expr *Arg, QualType ExpectedType,
-    llvm::function_ref<bool(clang::QualType PassedType)> Check) {
-
-  QualType ArgTy = Arg->IgnoreImpCasts()->getType();
-
-  clang::QualType BaseType =
-      ArgTy->isVectorType()
-          ? ArgTy->getAs<clang::VectorType>()->getElementType()
-          : ArgTy;
-
-  if (Check(BaseType)) {
-    S->Diag(Arg->getBeginLoc(), diag::err_typecheck_convert_incompatible)
-        << ArgTy << ExpectedType << 1 << 0 << 0;
-    return true;
-  }
-  return false;
-}
-
 bool CheckArgsTypesAreCorrect(
     Sema *S, CallExpr *TheCall, QualType ExpectedType,
     llvm::function_ref<bool(clang::QualType PassedType)> Check) {
@@ -1510,12 +1491,16 @@ bool CheckAllArgsHaveFloatRepresentation(Sema *S, CallExpr *TheCall) {
                                   checkAllFloatTypes);
 }
 
-bool CheckArgIsFloatOrIntWithoutImplicits(Sema *S, Expr *Arg) {
+bool CheckNotFloatAndInt(Sema *S, CallExpr *TheCall) {
   auto checkFloat = [](clang::QualType PassedType) -> bool {
-    return !PassedType->isFloat32Type() && !PassedType->isIntegerType();
+    clang::QualType BaseType =
+        PassedType->isVectorType()
+            ? PassedType->getAs<clang::VectorType>()->getElementType()
+            : PassedType;
+    return !(BaseType->isFloat32Type() || BaseType->isIntegerType());
   };
 
-  return CheckArgTypeWithoutImplicits(S, Arg, S->Context.FloatTy, checkFloat);
+  return CheckArgsTypesAreCorrect(S, TheCall, S->Context.FloatTy, checkFloat);
 }
 
 bool CheckFloatOrHalfRepresentations(Sema *S, CallExpr *TheCall) {
@@ -1676,8 +1661,7 @@ bool SemaHLSL::CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
     if (SemaRef.checkArgCount(TheCall, 1))
       return true;
 
-    Expr *Arg = TheCall->getArg(0);
-    if (CheckArgIsFloatOrIntWithoutImplicits(&SemaRef, Arg))
+    if (CheckNotFloatAndInt(&SemaRef, TheCall))
       return true;
 
     break;

clang/test/CodeGenHLSL/builtins/asuint.hlsl

@@ -1,26 +1,41 @@
-// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple dxil-pc-shadermodel6.3-library %s -fnative-half-type -emit-llvm -disable-llvm-passes -o - | FileCheck %s
+// RUN: %clang_cc1 -finclude-default-header -x hlsl -triple dxil-pc-shadermodel6.3-library %s -fnative-half-type -emit-llvm -O1 -o - | FileCheck %s
 
+// CHECK: define {{.*}}test_uint{{.*}}(i32 {{.*}} [[VAL:%.*]]){{.*}} 
+// CHECK-NOT: bitcast
+// CHECK: ret i32 [[VAL]]
+export uint test_uint(uint p0) {
+  return asuint(p0);
+}
+
+// CHECK: define {{.*}}test_int{{.*}}(i32 {{.*}} [[VAL:%.*]]){{.*}} 
+// CHECK-NOT: bitcast
+// CHECK: ret i32 [[VAL]]
+export uint test_int(int p0) {
+  return asuint(p0);
+}
 
-// CHECK-LABEL: test_asuint4_uint
-// CHECK: ret i32 %0
-export uint test_asuint4_uint(uint p0) {
+// CHECK: define {{.*}}test_float{{.*}}(float {{.*}} [[VAL:%.*]]){{.*}} 
+// CHECK: bitcast float [[VAL]] to i32
+export uint test_float(float p0) {
   return asuint(p0);
 }
 
-// CHECK-LABEL: test_asuint4_int
-// CHECK: %splat.splatinsert = insertelement <4 x i32> poison, i32 %0, i64 0
-export uint4 test_asuint4_int(int p0) {
+// CHECK: define {{.*}}test_vector_uint{{.*}}(<4 x i32> {{.*}} [[VAL:%.*]]){{.*}} 
+// CHECK-NOT: bitcast
+// CHECK: ret <4 x i32> [[VAL]]
+export uint4 test_vector_uint(uint4 p0) {
   return asuint(p0);
 }
 
-// CHECK-LABEL: test_asuint_float
-// CHECK: %1 = bitcast float %0 to i32
-export uint test_asuint_float(float p0) {
+// CHECK: define {{.*}}test_vector_int{{.*}}(<4 x i32> {{.*}} [[VAL:%.*]]){{.*}} 
+// CHECK-NOT: bitcast
+// CHECK: ret <4 x i32> [[VAL]]
+export uint4 test_vector_int(int4 p0) {
   return asuint(p0);
 }
 
-// CHECK-LABEL: test_asuint_float
-// CHECK: %1 = bitcast <4 x float> %0 to <4 x i32>
-export uint4 test_asuint_float4(float4 p0) {
+// CHECK: define {{.*}}test_vector_float{{.*}}(<4 x float> {{.*}} [[VAL:%.*]]){{.*}} 
+// CHECK: bitcast <4 x float> [[VAL]] to <4 x i32>
+export uint4 test_vector_float(float4 p0) {
   return asuint(p0);
-}
+}