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 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
