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);
-}
+}