[clang] Revert "[CIR] Add math and builtin intrinsics support (#175233)" (PR #180916)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Feb 11 03:08:53 PST 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang
Author: Andrzej Warzyński (banach-space)
<details>
<summary>Changes</summary>
This reverts commit 550e0d1b0d7230350db783fbafbac17899e7474f.
As far as I know, there is no post-commit testing for CIR, so let share
a link to failing pre-commit CI instead:
* https://github.com/llvm/llvm-project/pull/180597#issuecomment-3883182714
I was able to reproduce the failure locally. Looks like the lowering for
`@<!-- -->my_fmaxf` (from builtin-floating-point.c) depends on whether
`-fclangir` is used or not:
```
// Default
call nsz float @<!-- -->llvm.maxnum.f32
```
or:
```
// With `-fclangir`
call float @<!-- -->llvm.maxnum.f32
```
---
Patch is 135.87 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/180916.diff
10 Files Affected:
- (modified) clang/include/clang/CIR/Dialect/IR/CIROps.td (-237)
- (modified) clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp (+18-124)
- (modified) clang/lib/CIR/CodeGen/CIRGenExpr.cpp (+2-6)
- (modified) clang/lib/CIR/CodeGen/CIRGenModule.cpp (+2-1)
- (modified) clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp (-190)
- (removed) clang/test/CIR/CodeGen/builtin-floating-point.c (-2212)
- (removed) clang/test/CIR/CodeGen/builtins-elementwise.c (-505)
- (modified) clang/test/CIR/CodeGen/libc.c (+23-5)
- (modified) clang/test/CIR/CodeGenBuiltins/builtin-fcmp-sse.c (+8-8)
- (modified) clang/test/CIR/CodeGenBuiltins/builtin-isfpclass.c (+2-2)
``````````diff
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index a576119b97dae..906bd247f60ef 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -5626,108 +5626,6 @@ def CIR_Exp2Op : CIR_UnaryFPToFPBuiltinOp<"exp2", "Exp2Op"> {
}];
}
-def CIR_LogOp : CIR_UnaryFPToFPBuiltinOp<"log", "LogOp"> {
- let summary = "Computes the floating-point natural logarithm";
- let description = [{
- `cir.log` computes the natural logarithm of a floating-point operand and
- returns a result of the same type.
-
- Floating-point exceptions are ignored, and it does not set `errno`.
- }];
-}
-
-def CIR_Log10Op : CIR_UnaryFPToFPBuiltinOp<"log10", "Log10Op"> {
- let summary = "Computes the floating-point base-10 logarithm";
- let description = [{
- `cir.log10` computes the base-10 logarithm of a floating-point operand and
- returns a result of the same type.
-
- Floating-point exceptions are ignored, and it does not set `errno`.
- }];
-}
-
-def CIR_Log2Op : CIR_UnaryFPToFPBuiltinOp<"log2", "Log2Op"> {
- let summary = "Computes the floating-point base-2 logarithm";
- let description = [{
- `cir.log2` computes the base-2 logarithm of a floating-point operand and
- returns a result of the same type.
-
- Floating-point exceptions are ignored, and it does not set `errno`.
- }];
-}
-
-def CIR_NearbyintOp : CIR_UnaryFPToFPBuiltinOp<"nearbyint", "NearbyintOp"> {
- let summary = "Rounds floating-point value to nearest integer";
- let description = [{
- `cir.nearbyint` rounds a floating-point operand to the nearest integer value
- and returns a result of the same type.
-
- Floating-point exceptions are ignored, and it does not set `errno`.
- }];
-}
-
-def CIR_RintOp : CIR_UnaryFPToFPBuiltinOp<"rint", "RintOp"> {
- let summary = "Rounds floating-point value to nearest integer";
- let description = [{
- `cir.rint` rounds a floating-point operand to the nearest integer value
- and returns a result of the same type.
-
- This operation does not set `errno`. Unlike `cir.nearbyint`, this operation
- may raise the `FE_INEXACT` exception if the input value is not an exact
- integer, but this is not guaranteed to happen.
- }];
-}
-
-def CIR_RoundOp : CIR_UnaryFPToFPBuiltinOp<"round", "RoundOp"> {
- let summary = "Rounds floating-point value to nearest integer";
- let description = [{
- `cir.round` rounds a floating-point operand to the nearest integer value
- and returns a result of the same type.
-
- Floating-point exceptions are ignored, and it does not set `errno`.
- }];
-}
-
-def CIR_RoundEvenOp : CIR_UnaryFPToFPBuiltinOp<"roundeven", "RoundEvenOp"> {
- let summary = "Rounds floating-point value to nearest integer, ties to even";
- let description = [{
- `cir.roundeven` rounds a floating-point operand to the nearest integer
- value, with ties rounding to even (banker's rounding).
-
- Floating-point exceptions are ignored, and it does not set `errno`.
- }];
-}
-
-def CIR_SinOp : CIR_UnaryFPToFPBuiltinOp<"sin", "SinOp"> {
- let summary = "Computes the floating-point sine";
- let description = [{
- `cir.sin` computes the sine of a floating-point operand and returns
- a result of the same type.
-
- Floating-point exceptions are ignored, and it does not set `errno`.
- }];
-}
-
-def CIR_TanOp : CIR_UnaryFPToFPBuiltinOp<"tan", "TanOp"> {
- let summary = "Computes the floating-point tangent";
- let description = [{
- `cir.tan` computes the tangent of a floating-point operand and returns
- a result of the same type.
-
- Floating-point exceptions are ignored, and it does not set `errno`.
- }];
-}
-
-def CIR_TruncOp : CIR_UnaryFPToFPBuiltinOp<"trunc", "TruncOp"> {
- let summary = "Truncates floating-point value to integer";
- let description = [{
- `cir.trunc` truncates a floating-point operand to an integer value
- and returns a result of the same type.
-
- Floating-point exceptions are ignored, and it does not set `errno`.
- }];
-}
-
def CIR_FAbsOp : CIR_UnaryFPToFPBuiltinOp<"fabs", "FAbsOp"> {
let summary = "Computes the floating-point absolute value";
let description = [{
@@ -5755,141 +5653,6 @@ def CIR_FloorOp : CIR_UnaryFPToFPBuiltinOp<"floor", "FloorOp"> {
}];
}
-class CIR_UnaryFPToIntBuiltinOp<string mnemonic, string llvmOpName>
- : CIR_Op<mnemonic, [Pure]>
-{
- let arguments = (ins CIR_AnyFloatType:$src);
- let results = (outs CIR_IntType:$result);
-
- let summary = [{
- Builtin function that takes a floating-point value as input and produces an
- integral value as output.
- }];
-
- let assemblyFormat = [{
- $src `:` type($src) `->` type($result) attr-dict
- }];
-
- let llvmOp = llvmOpName;
-}
-
-def CIR_LroundOp : CIR_UnaryFPToIntBuiltinOp<"lround", "LroundOp"> {
- let summary = "Rounds floating-point to long integer";
- let description = [{
- `cir.lround` rounds a floating-point value to the nearest integer value,
- rounding halfway cases away from zero, and returns the result as a `long`.
- }];
-}
-
-def CIR_LlroundOp : CIR_UnaryFPToIntBuiltinOp<"llround", "LlroundOp"> {
- let summary = "Rounds floating-point to long long integer";
- let description = [{
- `cir.llround` rounds a floating-point value to the nearest integer value,
- rounding halfway cases away from zero, and returns the result as a
- `long long`.
- }];
-}
-
-def CIR_LrintOp : CIR_UnaryFPToIntBuiltinOp<"lrint", "LrintOp"> {
- let summary = "Rounds floating-point to long integer using current rounding mode";
- let description = [{
- `cir.lrint` rounds a floating-point value to the nearest integer value
- using the current rounding mode and returns the result as a `long`.
- }];
-}
-
-def CIR_LlrintOp : CIR_UnaryFPToIntBuiltinOp<"llrint", "LlrintOp"> {
- let summary = "Rounds floating-point to long long integer using current rounding mode";
- let description = [{
- `cir.llrint` rounds a floating-point value to the nearest integer value
- using the current rounding mode and returns the result as a `long long`.
- }];
-}
-
-class CIR_BinaryFPToFPBuiltinOp<string mnemonic, string llvmOpName>
- : CIR_Op<mnemonic, [Pure, SameOperandsAndResultType]> {
- let summary = [{
- libc builtin equivalent ignoring floating-point exceptions and errno.
- }];
-
- let arguments = (ins
- CIR_AnyFloatOrVecOfFloatType:$lhs,
- CIR_AnyFloatOrVecOfFloatType:$rhs
- );
-
- let results = (outs CIR_AnyFloatOrVecOfFloatType:$result);
-
- let assemblyFormat = [{
- $lhs `,` $rhs `:` qualified(type($lhs)) attr-dict
- }];
-
- let llvmOp = llvmOpName;
-}
-
-def CIR_CopysignOp : CIR_BinaryFPToFPBuiltinOp<"copysign", "CopySignOp"> {
- let summary = "Copies the sign of a floating-point value";
- let description = [{
- `cir.copysign` returns a value with the magnitude of the first operand
- and the sign of the second operand.
- }];
-}
-
-def CIR_FMaxNumOp : CIR_BinaryFPToFPBuiltinOp<"fmaxnum", "MaxNumOp"> {
- let summary = "Returns the larger of two floating-point values";
- let description = [{
- `cir.fmaxnum` returns the larger of its two operands. If one operand is
- NaN, the other operand is returned.
- }];
-}
-
-def CIR_FMaximumOp : CIR_BinaryFPToFPBuiltinOp<"fmaximum", "MaximumOp"> {
- let summary = "Returns the larger of two floating-point values (IEEE 754-2019)";
- let description = [{
- `cir.fmaximum` returns the larger of its two operands according to
- IEEE 754-2019 semantics. If either operand is NaN, NaN is returned.
- }];
-}
-
-def CIR_FMinNumOp : CIR_BinaryFPToFPBuiltinOp<"fminnum", "MinNumOp"> {
- let summary = "Returns the smaller of two floating-point values";
- let description = [{
- `cir.fminnum` returns the smaller of its two operands. If one operand is
- NaN, the other operand is returned.
- }];
-}
-
-def CIR_FMinimumOp : CIR_BinaryFPToFPBuiltinOp<"fminimum", "MinimumOp"> {
- let summary = "Returns the smaller of two floating-point values (IEEE 754-2019)";
- let description = [{
- `cir.fminimum` returns the smaller of its two operands according to
- IEEE 754-2019 semantics. If either operand is NaN, NaN is returned.
- }];
-}
-
-def CIR_FModOp : CIR_BinaryFPToFPBuiltinOp<"fmod", "FRemOp"> {
- let summary = "Computes the floating-point remainder";
- let description = [{
- `cir.fmod` computes the floating-point remainder of dividing the first
- operand by the second operand.
- }];
-}
-
-def CIR_PowOp : CIR_BinaryFPToFPBuiltinOp<"pow", "PowOp"> {
- let summary = "Computes the power of a floating-point value";
- let description = [{
- `cir.pow` computes the first operand raised to the power of the second
- operand.
- }];
-}
-
-def CIR_ATan2Op : CIR_BinaryFPToFPBuiltinOp<"atan2", "ATan2Op"> {
- let summary = "Computes the arc tangent of y/x";
- let description = [{
- `cir.atan2` computes the arc tangent of the first operand divided by the
- second operand, using the signs of both to determine the quadrant.
- }];
-}
-
//===----------------------------------------------------------------------===//
// Variadic Operations
//===----------------------------------------------------------------------===//
diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp
index 72d004df40657..61db7efb092c3 100644
--- a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp
@@ -272,45 +272,6 @@ static RValue emitUnaryFPBuiltin(CIRGenFunction &cgf, const CallExpr &e) {
return RValue::get(call->getResult(0));
}
-template <typename Op>
-static RValue emitUnaryMaybeConstrainedFPToIntBuiltin(CIRGenFunction &cgf,
- const CallExpr &e) {
- mlir::Type resultType = cgf.convertType(e.getType());
- mlir::Value src = cgf.emitScalarExpr(e.getArg(0));
-
- assert(!cir::MissingFeatures::fpConstraints());
-
- auto call = Op::create(cgf.getBuilder(), src.getLoc(), resultType, src);
- return RValue::get(call->getResult(0));
-}
-
-template <typename Op>
-static RValue emitBinaryFPBuiltin(CIRGenFunction &cgf, const CallExpr &e) {
- mlir::Value arg0 = cgf.emitScalarExpr(e.getArg(0));
- mlir::Value arg1 = cgf.emitScalarExpr(e.getArg(1));
-
- mlir::Location loc = cgf.getLoc(e.getExprLoc());
- mlir::Type ty = cgf.convertType(e.getType());
- auto call = Op::create(cgf.getBuilder(), loc, ty, arg0, arg1);
-
- return RValue::get(call->getResult(0));
-}
-
-template <typename Op>
-static mlir::Value emitBinaryMaybeConstrainedFPBuiltin(CIRGenFunction &cgf,
- const CallExpr &e) {
- mlir::Value arg0 = cgf.emitScalarExpr(e.getArg(0));
- mlir::Value arg1 = cgf.emitScalarExpr(e.getArg(1));
-
- mlir::Location loc = cgf.getLoc(e.getExprLoc());
- mlir::Type ty = cgf.convertType(e.getType());
-
- assert(!cir::MissingFeatures::fpConstraints());
-
- auto call = Op::create(cgf.getBuilder(), loc, ty, arg0, arg1);
- return call->getResult(0);
-}
-
static RValue errorBuiltinNYI(CIRGenFunction &cgf, const CallExpr *e,
unsigned builtinID) {
@@ -424,7 +385,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_acosl:
case Builtin::BI__builtin_acosf128:
case Builtin::BI__builtin_elementwise_acos:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::ACosOp>(cgf, *e);
case Builtin::BIasin:
case Builtin::BIasinf:
case Builtin::BIasinl:
@@ -434,7 +394,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_asinl:
case Builtin::BI__builtin_asinf128:
case Builtin::BI__builtin_elementwise_asin:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::ASinOp>(cgf, *e);
case Builtin::BIatan:
case Builtin::BIatanf:
case Builtin::BIatanl:
@@ -444,7 +403,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_atanl:
case Builtin::BI__builtin_atanf128:
case Builtin::BI__builtin_elementwise_atan:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::ATanOp>(cgf, *e);
case Builtin::BIatan2:
case Builtin::BIatan2f:
case Builtin::BIatan2l:
@@ -454,8 +412,7 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_atan2l:
case Builtin::BI__builtin_atan2f128:
case Builtin::BI__builtin_elementwise_atan2:
- return RValue::get(
- emitBinaryMaybeConstrainedFPBuiltin<cir::ATan2Op>(cgf, *e));
+ return RValue::getIgnored();
case Builtin::BIceil:
case Builtin::BIceilf:
case Builtin::BIceill:
@@ -466,7 +423,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_ceilf128:
return emitUnaryMaybeConstrainedFPBuiltin<cir::CeilOp>(cgf, *e);
case Builtin::BI__builtin_elementwise_ceil:
- return RValue::getIgnored();
case Builtin::BIcopysign:
case Builtin::BIcopysignf:
case Builtin::BIcopysignl:
@@ -475,7 +431,7 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_copysignf16:
case Builtin::BI__builtin_copysignl:
case Builtin::BI__builtin_copysignf128:
- return emitBinaryFPBuiltin<cir::CopysignOp>(cgf, *e);
+ return RValue::getIgnored();
case Builtin::BIcos:
case Builtin::BIcosf:
case Builtin::BIcosl:
@@ -552,7 +508,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_fmal:
case Builtin::BI__builtin_fmaf128:
case Builtin::BI__builtin_elementwise_fma:
- return RValue::getIgnored();
case Builtin::BIfmax:
case Builtin::BIfmaxf:
case Builtin::BIfmaxl:
@@ -561,8 +516,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_fmaxf16:
case Builtin::BI__builtin_fmaxl:
case Builtin::BI__builtin_fmaxf128:
- return RValue::get(
- emitBinaryMaybeConstrainedFPBuiltin<cir::FMaxNumOp>(cgf, *e));
case Builtin::BIfmin:
case Builtin::BIfminf:
case Builtin::BIfminl:
@@ -571,8 +524,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_fminf16:
case Builtin::BI__builtin_fminl:
case Builtin::BI__builtin_fminf128:
- return RValue::get(
- emitBinaryMaybeConstrainedFPBuiltin<cir::FMinNumOp>(cgf, *e));
case Builtin::BIfmaximum_num:
case Builtin::BIfmaximum_numf:
case Builtin::BIfmaximum_numl:
@@ -589,7 +540,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_fminimum_numf16:
case Builtin::BI__builtin_fminimum_numl:
case Builtin::BI__builtin_fminimum_numf128:
- return RValue::getIgnored();
case Builtin::BIfmod:
case Builtin::BIfmodf:
case Builtin::BIfmodl:
@@ -599,8 +549,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_fmodl:
case Builtin::BI__builtin_fmodf128:
case Builtin::BI__builtin_elementwise_fmod:
- return RValue::get(
- emitBinaryMaybeConstrainedFPBuiltin<cir::FModOp>(cgf, *e));
case Builtin::BIlog:
case Builtin::BIlogf:
case Builtin::BIlogl:
@@ -610,7 +558,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_logl:
case Builtin::BI__builtin_logf128:
case Builtin::BI__builtin_elementwise_log:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::LogOp>(cgf, *e);
case Builtin::BIlog10:
case Builtin::BIlog10f:
case Builtin::BIlog10l:
@@ -620,7 +567,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_log10l:
case Builtin::BI__builtin_log10f128:
case Builtin::BI__builtin_elementwise_log10:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::Log10Op>(cgf, *e);
case Builtin::BIlog2:
case Builtin::BIlog2f:
case Builtin::BIlog2l:
@@ -630,7 +576,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_log2l:
case Builtin::BI__builtin_log2f128:
case Builtin::BI__builtin_elementwise_log2:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::Log2Op>(cgf, *e);
case Builtin::BInearbyint:
case Builtin::BInearbyintf:
case Builtin::BInearbyintl:
@@ -639,7 +584,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_nearbyintl:
case Builtin::BI__builtin_nearbyintf128:
case Builtin::BI__builtin_elementwise_nearbyint:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::NearbyintOp>(cgf, *e);
case Builtin::BIpow:
case Builtin::BIpowf:
case Builtin::BIpowl:
@@ -648,10 +592,7 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_powf16:
case Builtin::BI__builtin_powl:
case Builtin::BI__builtin_powf128:
- return RValue::get(
- emitBinaryMaybeConstrainedFPBuiltin<cir::PowOp>(cgf, *e));
case Builtin::BI__builtin_elementwise_pow:
- return RValue::getIgnored();
case Builtin::BIrint:
case Builtin::BIrintf:
case Builtin::BIrintl:
@@ -661,7 +602,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_rintl:
case Builtin::BI__builtin_rintf128:
case Builtin::BI__builtin_elementwise_rint:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::RintOp>(cgf, *e);
case Builtin::BIround:
case Builtin::BIroundf:
case Builtin::BIroundl:
@@ -671,7 +611,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_roundl:
case Builtin::BI__builtin_roundf128:
case Builtin::BI__builtin_elementwise_round:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::RoundOp>(cgf, *e);
case Builtin::BIroundeven:
case Builtin::BIroundevenf:
case Builtin::BIroundevenl:
@@ -681,7 +620,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_roundevenl:
case Builtin::BI__builtin_roundevenf128:
case Builtin::BI__builtin_elementwise_roundeven:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::RoundEvenOp>(cgf, *e);
case Builtin::BIsin:
case Builtin::BIsinf:
case Builtin::BIsinl:
@@ -691,7 +629,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_sinl:
case Builtin::BI__builtin_sinf128:
case Builtin::BI__builtin_elementwise_sin:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::SinOp>(cgf, *e);
case Builtin::BIsinh:
case Builtin::BIsinhf:
case Builtin::BIsinhl:
@@ -712,7 +649,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_sincosf16:
case Builtin::BI__builtin_sincosl:
case Builtin::BI__builtin_sincosf128:
- return RValue::getIgnored();
case Builtin::BIsqrt:
case Builtin::BIsqrtf:
case Builtin::BIsqrtl:
@@ -722,7 +658,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_sqrtl:
case Builtin::BI__builtin_sqrtf128:
case Builtin::BI__builtin_elementwise_sqrt:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::SqrtOp>(cgf, *e);
case Builtin::BItan:
case Builtin::BItanf:
case Builtin::BItanl:
@@ -732,7 +667,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_tanl:
case Builtin::BI__builtin_tanf128:
case Builtin::BI__builtin_elementwise_tan:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::TanOp>(cgf, *e);
case Builtin::BItanh:
case Builtin::BItanhf:
case Builtin::BItanhl:
@@ -742,7 +676,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_tanhl:
case Builtin::BI__builtin_tanhf128:
case Builtin::BI__builtin_elementwise_tanh:
- return RValue::getIgnored();
case Builtin::BItrunc:
case Builtin::BItruncf:
case Builtin::BItruncl:
@@ -752,7 +685,6 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e,
case Builtin::BI__builtin_truncl:
case Builtin::BI__builtin_truncf128:
case Builtin::BI__builtin_elementwise_trunc:
- return emitUnaryMaybeConstrainedFPBuiltin<cir::Trunc...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/180916
More information about the cfe-commits
mailing list