llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-backend-x86 Author: None (metkarpoonam) <details> <summary>Changes</summary> Include HLSL or_intrinsic, add codegen in CGBuiltin, and the corresponding tests in or.hlsl. Additionally, incorporate logical-operator-errors to handle both 'and' and 'or' semantic diagnostics. --- Full diff: https://github.com/llvm/llvm-project/pull/128979.diff 7 Files Affected: - (modified) clang/include/clang/Basic/Builtins.td (+6) - (modified) clang/lib/CodeGen/CGBuiltin.cpp (+5) - (modified) clang/lib/Headers/hlsl/hlsl_intrinsics.h (+18) - (modified) clang/lib/Sema/SemaHLSL.cpp (+19) - (added) clang/test/CodeGenHLSL/builtins/or.hlsl (+85) - (removed) clang/test/SemaHLSL/BuiltIns/and-errors.hlsl (-22) - (added) clang/test/SemaHLSL/BuiltIns/logical-operator-errors.hlsl (+27) ``````````diff diff --git a/clang/include/clang/Basic/Builtins.td b/clang/include/clang/Basic/Builtins.td index 598ae171b1389..f7027331cd6c5 100644 --- a/clang/include/clang/Basic/Builtins.td +++ b/clang/include/clang/Basic/Builtins.td @@ -4783,6 +4783,12 @@ def HLSLAnd : LangBuiltin<"HLSL_LANG"> { let Prototype = "void(...)"; } +def HLSLOr : LangBuiltin<"HLSL_LANG"> { + let Spellings = ["__builtin_hlsl_or"]; + let Attributes = [NoThrow, Const]; + let Prototype = "void(...)"; +} + def HLSLAny : LangBuiltin<"HLSL_LANG"> { let Spellings = ["__builtin_hlsl_any"]; let Attributes = [NoThrow, Const]; diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 65fac01d58362..599e05819ec7c 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -19492,6 +19492,11 @@ Value *CodeGenFunction::EmitHLSLBuiltinExpr(unsigned BuiltinID, Value *Op1 = EmitScalarExpr(E->getArg(1)); return Builder.CreateAnd(Op0, Op1, "hlsl.and"); } + case Builtin::BI__builtin_hlsl_or: { + Value *Op0 = EmitScalarExpr(E->getArg(0)); + Value *Op1 = EmitScalarExpr(E->getArg(1)); + return Builder.CreateOr(Op0, Op1, "hlsl.or"); + } case Builtin::BI__builtin_hlsl_any: { Value *Op0 = EmitScalarExpr(E->getArg(0)); return Builder.CreateIntrinsic( diff --git a/clang/lib/Headers/hlsl/hlsl_intrinsics.h b/clang/lib/Headers/hlsl/hlsl_intrinsics.h index 239d7a3f59b77..764cf671dce31 100644 --- a/clang/lib/Headers/hlsl/hlsl_intrinsics.h +++ b/clang/lib/Headers/hlsl/hlsl_intrinsics.h @@ -290,6 +290,24 @@ _HLSL_BUILTIN_ALIAS(__builtin_hlsl_and) bool4 and(bool4 x, bool4 y); // clang-format on +//===----------------------------------------------------------------------===// +// or builtins +//===----------------------------------------------------------------------===// + +/// \fn T or(T x, T y) +/// \brief Returns the bitwise OR of the two input values, \a x and \a y. +/// \param x The first input value and y The second input value. +/// +/// \returns The logically OR a vector and retuens bool vector. + +_HLSL_BUILTIN_ALIAS(__builtin_hlsl_or) +bool or(bool, bool); +_HLSL_BUILTIN_ALIAS(__builtin_hlsl_or) +bool2 or(bool2, bool2); +_HLSL_BUILTIN_ALIAS(__builtin_hlsl_or) +bool3 or(bool3, bool3); +_HLSL_BUILTIN_ALIAS(__builtin_hlsl_or) +bool4 or(bool4, bool4); //===----------------------------------------------------------------------===// // any builtins //===----------------------------------------------------------------------===// diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index 283a9801fc707..c48512673be58 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -2305,6 +2305,25 @@ bool SemaHLSL::CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { TheCall->setType(ArgTyA); break; } + case Builtin::BI__builtin_hlsl_or: { + if (SemaRef.checkArgCount(TheCall, 2)) + return true; + if (CheckVectorElementCallArgs(&SemaRef, TheCall)) + return true; + + // Ensure input expr type is a scalar/vector and the same as the return type + if (CheckScalarOrVector(&SemaRef, TheCall, getASTContext().BoolTy, 0)) + return true; + + // Ensure input parameter type is bool + ExprResult A = TheCall->getArg(0); + QualType ArgTyA = A.get()->getType(); + + // return type is the same as the input type + TheCall->setType(ArgTyA); + + break; + } case Builtin::BI__builtin_hlsl_all: case Builtin::BI__builtin_hlsl_any: { if (SemaRef.checkArgCount(TheCall, 1)) diff --git a/clang/test/CodeGenHLSL/builtins/or.hlsl b/clang/test/CodeGenHLSL/builtins/or.hlsl new file mode 100644 index 0000000000000..0c21973bda17c --- /dev/null +++ b/clang/test/CodeGenHLSL/builtins/or.hlsl @@ -0,0 +1,85 @@ +// RUN: %clang_cc1 -finclude-default-header -triple \ +// RUN: dxil-pc-shadermodel6.3-library %s \ +// RUN: -emit-llvm -O1 -o - | FileCheck %s + +//CHECK-LABEL: define noundef i1 @_Z12test_or_boolbb( +//CHECK-SAME: i1 noundef [[X:%.*]], i1 noundef [[Y:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] { +//CHECK-NEXT: [[ENTRY:.*:]] +//CHECK-NEXT: [[HLSL_OR:%.*]] = or i1 [[x]], [[y]] +//CHECK-NEXT: ret i1 [[HLSL_OR]] +//CHECK_NEXT: } +bool test_or_bool(bool x, bool y) +{ + return or(x, y); + +} + +//CHECK-LABEL: define noundef <2 x i1> @_Z13test_or_bool2Dv2_bS_( +//CHECK-SAME: <2 x i1> noundef [[X:%.*]], <2 x i1> noundef [[Y:%.*]]) local_unnamed_addr #[[ATTR0]] { +//CHECK-NEXT: [[ENTRY:.*:]] +//CHECK-NEXT: [[HLSL_OR:%.*]] = or <2 xi1> [[x]], [[y]] +//CHECK-NEXT: ret <2 x i1> [[HLSL_OR]] +//CHECK_NEXT: } +bool2 test_or_bool2(bool2 x, bool2 y) +{ + return or(x, y); +} + +//CHECK-LABEL: define noundef <3 x i1> @_Z13test_or_bool3Dv3_bS_( +//CHECK-SAME: <3 x i1> noundef [[X:%.*]], <3 x i1> noundef [[Y:%.*]]) local_unnamed_addr #[[ATTR0]] { +//CHECK-NEXT: [[ENTRY:.*:]] +//CHECK-NEXT: [[HLSL_OR:%.*]] = or <3 xi1> [[x]], [[y]] +//CHECK-NEXT: ret <3 x i1> [[HLSL_OR]] +//CHECK_NEXT: } +bool3 test_or_bool3(bool3 x, bool3 y) +{ + return or(x, y); +} + +//CHECK-LABEL: define noundef <4 x i1> @_Z13test_or_bool4Dv4_bS_( +//CHECK-SAME: <4 x i1> noundef [[X:%.*]], <4 x i1> noundef [[Y:%.*]]) local_unnamed_addr #[[ATTR0]] { +//CHECK-NEXT: [[ENTRY:.*:]] +//CHECK-NEXT: [[HLSL_OR:%.*]] = or <4 xi1> [[x]], [[y]] +//CHECK-NEXT: ret <4 x i1> [[HLSL_OR]] +//CHECK_NEXT: } +bool4 test_or_bool4(bool4 x, bool4 y) +{ + return or(x, y); +} + +//CHECK-LABEL: define noundef i1 @_Z11test_or_intii( +//CHECK-SAME: i32 noundef [[X:%.*]], i32 noundef [[Y:%.*]]) local_unnamed_addr #[[ATTR0]] { +//CHECK-NEXT: [[ENTRY:.*:]] +//CHECK_NEXT: [[0:%.*]] = or i32 [[y]], [[x]] +//CHECK-NEXT: [[HLSL_OR:%.*]] = icmp ne i32 [[0]], 0 +//CHECK-NEXT: ret i1 [[HLSL_OR]] +//CHECK_NEXT: } +bool test_or_int(int x, int y) +{ + return or(x, y); +} + +//CHECK-LABEL: define noundef <4 x i1> @_Z12test_or_int4Dv4_iS_( +//CHECK-SAME: <4 x i32> noundef [[X:%.*]], <4 x i32> noundef [[Y:%.*]]) local_unnamed_addr #[[ATTR0]] { +//CHECK-NEXT: [[ENTRY:.*:]] +//CHECK_NEXT: [[0:%.*]] = or <4 x i32> [[y]], [[x]] +//CHECK-NEXT: [[HLSL_OR:%.*]] = icmp ne <4 x i32> [[0]], zeroinitializer +//CHECK-NEXT: ret <4 x i1> [[HLSL_OR]] +//CHECK_NEXT: } +bool4 test_or_int4(int4 x, int4 y) +{ + return or(x, y); +} + +//CHECK-LABEL: noundef <4 x i1> @_Z14test_or_float4Dv4_fS_( +//CHECK-SAME: <4 x float> noundef nofpclass(nan inf) [[X:%.*]], <4 x float> noundef nofpclass(nan inf) [[Y:%.*]]) local_unnamed_addr #[[ATTR0]] { +//CHECK-NEXT: [[ENTRY:.*:]] +//CHECK-NEXT: [[TOBOOL:%.*]] = fcmp reassoc nnan ninf nsz arcp afn une <4 x float> [[X]], zeroinitializer +//CHECK-NEXT: [[TOBOOL1:%.*]] = fcmp reassoc nnan ninf nsz arcp afn une <4 x float> [[Y]], zeroinitializer +//CHECK-NEXT: [[HLSL_OR:%.*]] = or <4 x i1> [[TOBOOL]], [[TOBOOL1]] +//CHECK-NEXT: ret <4 x i1> [[HLSL_OR]] +//CHECK_NEXT: } +bool4 test_or_float4(float4 x, float4 y) +{ + return or(x, y); +} \ No newline at end of file diff --git a/clang/test/SemaHLSL/BuiltIns/and-errors.hlsl b/clang/test/SemaHLSL/BuiltIns/and-errors.hlsl deleted file mode 100644 index d9721140b9bf9..0000000000000 --- a/clang/test/SemaHLSL/BuiltIns/and-errors.hlsl +++ /dev/null @@ -1,22 +0,0 @@ -// RUN: %clang_cc1 -finclude-default-header -triple \ -// RUN: dxil-pc-shadermodel6.3-library %s -O1 -verify - -bool test_too_few_arg(bool a) { - return __builtin_hlsl_and(a); - // expected-error@-1 {{too few arguments to function call, expected 2, have 1}} -} - -bool test_too_many_arg(bool a) { - return __builtin_hlsl_and(a, a, a); - // expected-error@-1 {{too many arguments to function call, expected 2, have 3}} -} - -bool2 test_mismatched_args(bool2 a, bool3 b) { - return __builtin_hlsl_and(a, b); - // expected-error@-1 {{all arguments to '__builtin_hlsl_and' must have the same type}} -} - -bool test_incorrect_type(int a) { - return __builtin_hlsl_and(a, a); - // expected-error@-1{{invalid operand of type 'int' where 'bool' or a vector of such type is required}} -} diff --git a/clang/test/SemaHLSL/BuiltIns/logical-operator-errors.hlsl b/clang/test/SemaHLSL/BuiltIns/logical-operator-errors.hlsl new file mode 100644 index 0000000000000..41bf3c4b2f663 --- /dev/null +++ b/clang/test/SemaHLSL/BuiltIns/logical-operator-errors.hlsl @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 -finclude-default-header -triple dxil-pc-shadermodel6.6-library %s -verify -DTEST_FUNC=__builtin_hlsl_or +// RUN: %clang_cc1 -finclude-default-header -triple dxil-pc-shadermodel6.6-library %s -verify -DTEST_FUNC=__builtin_hlsl_and + + +bool test_too_few_arg(bool a) +{ + return TEST_FUNC(a); + // expected-error@-1 {{too few arguments to function call, expected 2, have 1}} +} + +bool test_too_many_arg(bool a) +{ + return TEST_FUNC(a, a, a); + // expected-error@-1 {{too many arguments to function call, expected 2, have 3}} +} + +bool2 test_mismatched_args(bool2 a, bool3 b) +{ + return TEST_FUNC(a, b); + // expected-error@-1 {{all arguments to}}{{.*}}{{must have the same type}} +} + +bool test_incorrect_type(int a) +{ + return TEST_FUNC(a, a); + // expected-error@-1{{invalid operand of type 'int' where 'bool' or a vector of such type is required}} +} \ No newline at end of file `````````` </details> https://github.com/llvm/llvm-project/pull/128979 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
