llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clangir Author: Alex Denisov (AlexDenisov) <details> <summary>Changes</summary> Adds support for `ldexp` variants. The new op lowers to `llvm.ldexp` or `llvm.experimental.constrained.ldexp` depending on `fenv` attribute. Assisted-by: Claude --- Patch is 26.14 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/236997.diff 5 Files Affected: - (modified) clang/include/clang/CIR/Dialect/IR/CIROps.td (+37) - (modified) clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp (+2) - (modified) clang/test/CIR/CodeGen/pragma-fenv_access.c (+90) - (modified) clang/test/CIR/CodeGenBuiltins/builtin-float.c (+66) - (modified) clang/test/CIR/Lowering/fenv.cir (+11) ``````````diff diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td index bd762aae3e1d7e..04c549d9e3317b 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIROps.td +++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td @@ -8761,6 +8761,43 @@ def CIR_ATan2Op : CIR_BinaryFPToFPBuiltinOp<"atan2", "ATan2Op"> { let constrainedLLVMIntrinsic = "atan2"; } +def CIR_LdexpOp : CIR_Op<"ldexp", + !listconcat([AllTypesMatch<["src", "result"]>], CIR_FenvOpTraits)> { + let summary = "Multiplies a floating-point value by an integral power of two"; + let description = [{ + `cir.ldexp` computes `src * 2^exp`. + + Lowers to `llvm.ldexp`, or to `llvm.experimental.constrained.ldexp` when + the `fenv` attribute is present. + + Example: + %r = cir.ldexp %x, %e : !cir.float, !s32i + }]; + + let arguments = (ins + CIR_AnyFloatType:$src, + CIR_AnyIntType:$exp, + OptionalAttr<CIR_FenvAttr>:$fenv + ); + + let results = (outs CIR_AnyFloatType:$result); + + let assemblyFormat = [{ + $src `,` $exp `:` qualified(type($src)) `,` qualified(type($exp)) + (`fenv` `` $fenv^)? attr-dict + }]; + + let builders = [ + OpBuilder<(ins "mlir::Value":$src, "mlir::Value":$exp), [{ + build($_builder, $_state, src, exp, cir::FenvAttr{}); + }]> + ]; + + let llvmOp = "LoadExpOp"; + let constrainedLLVMIntrinsic = "ldexp"; + let constrainedLLVMIntrinsicHasRoundingMode = 0; // MUTATION +} + def CIR_FrexpOp : CIR_Op<"frexp", [Pure]> { let summary = "Decomposes a floating-point value into significand and exponent"; let description = [{ diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp index 21a86114420e19..8e3b95fa6746aa 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp @@ -1128,6 +1128,8 @@ static RValue tryEmitFPMathIntrinsic(CIRGenFunction &cgf, const CallExpr *e, case Builtin::BI__builtin_ldexpl: case Builtin::BI__builtin_ldexpf16: case Builtin::BI__builtin_ldexpf128: + return RValue::get( + emitBinaryMaybeConstrainedFPBuiltin<cir::LdexpOp>(cgf, *e)); case Builtin::BI__builtin_elementwise_ldexp: return errorBuiltinNYI(cgf, e, builtinID); default: diff --git a/clang/test/CIR/CodeGen/pragma-fenv_access.c b/clang/test/CIR/CodeGen/pragma-fenv_access.c index 2f422a81e70abc..b947d1cb6ec46f 100644 --- a/clang/test/CIR/CodeGen/pragma-fenv_access.c +++ b/clang/test/CIR/CodeGen/pragma-fenv_access.c @@ -176,6 +176,15 @@ void test_cmdline_defaults(float x, float y, float z, int i, double d) { // LLVM-STRICT-RND: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") // LLVM-DEFAULT: call float @llvm.pow.f32 // LLVM-DEFAULT-RND: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.ignore") + sf = __builtin_ldexpf(x, i); +// CIR-STRICT: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true> +// CIR-STRICT-RND: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> +// CIR-DEFAULT: cir.ldexp {{.*}} : !cir.float, !s32i loc +// CIR-DEFAULT-RND: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = unknown, except_mode = masked, strict_except = false> +// LLVM-STRICT: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict") +// LLVM-STRICT-RND: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") +// LLVM-DEFAULT: call float @llvm.ldexp.f32.i32 +// LLVM-DEFAULT-RND: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.ignore") sf = __builtin_fmaf(x, y, z); // CIR-STRICT: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true> // CIR-STRICT-RND: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> @@ -251,6 +260,9 @@ void test_global_fenv_access_on(float x, float y, float z, int i, double d) { sf = __builtin_powf(x, y); // CIR: cir.pow {{.*}} : !cir.float fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> // LLVM: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") + sf = __builtin_ldexpf(x, i); +// CIR: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> +// LLVM: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") sf = __builtin_fmaf(x, y, z); // CIR: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> // LLVM-STRICT: call float @llvm.experimental.constrained.fma.f32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") @@ -311,6 +323,9 @@ void test_except_off_fenv_access_off(float x, float y, float z, int i, double d) sf = __builtin_powf(x, y); // CIR: cir.pow {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> // LLVM: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") + sf = __builtin_ldexpf(x, i); +// CIR: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> +// LLVM: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") sf = __builtin_fmaf(x, y, z); // CIR: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> // LLVM-STRICT: call float @llvm.experimental.constrained.fma.f32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") @@ -369,6 +384,9 @@ void test_fenv_access_on_after_local_off(float x, float y, float z, int i, doubl sf = __builtin_powf(x, y); // CIR: cir.pow {{.*}} : !cir.float fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> // LLVM: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") + sf = __builtin_ldexpf(x, i); +// CIR: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> +// LLVM: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") sf = __builtin_fmaf(x, y, z); // CIR: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> // LLVM-STRICT: call float @llvm.experimental.constrained.fma.f32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") @@ -496,6 +514,15 @@ void test_float_control_except_off(float x, float y, float z, int i, double d) { // LLVM-STRICT-RND: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") // LLVM-DEFAULT: call float @llvm.pow.f32 // LLVM-DEFAULT-RND: call float @llvm.pow.f32 + sf = __builtin_ldexpf(x, i); +// CIR-STRICT: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> +// CIR-STRICT-RND: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> +// CIR-DEFAULT: cir.ldexp {{.*}} : !cir.float, !s32i loc +// CIR-DEFAULT-RND: cir.ldexp {{.*}} : !cir.float, !s32i loc +// LLVM-STRICT: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") +// LLVM-STRICT-RND: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") +// LLVM-DEFAULT: call float @llvm.ldexp.f32.i32 +// LLVM-DEFAULT-RND: call float @llvm.ldexp.f32.i32 sf = __builtin_fmaf(x, y, z); // CIR-STRICT: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> // CIR-STRICT-RND: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> @@ -570,6 +597,9 @@ void test_float_control_except_on(float x, float y, float z, int i, double d) { sf = __builtin_powf(x, y); // CIR: cir.pow {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true> // LLVM: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict") + sf = __builtin_ldexpf(x, i); +// CIR: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true> +// LLVM: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict") sf = __builtin_fmaf(x, y, z); // CIR: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true> // LLVM-STRICT: call float @llvm.experimental.constrained.fma.f32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict") @@ -629,6 +659,9 @@ void test_local_fenv_access_on(float x, float y, float z, int i, double d) { sf = __builtin_powf(x, y); // CIR: cir.pow {{.*}} : !cir.float fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> // LLVM: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") + sf = __builtin_ldexpf(x, i); +// CIR: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> +// LLVM: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") sf = __builtin_fmaf(x, y, z); // CIR: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> // LLVM-STRICT: call float @llvm.experimental.constrained.fma.f32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") @@ -754,6 +787,15 @@ void test_float_control_except_off_after_on(float x, float y, float z, int i, do // LLVM-STRICT-RND: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") // LLVM-DEFAULT: call float @llvm.pow.f32 // LLVM-DEFAULT-RND: call float @llvm.pow.f32 + sf = __builtin_ldexpf(x, i); +// CIR-STRICT: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> +// CIR-STRICT-RND: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> +// CIR-DEFAULT: cir.ldexp {{.*}} : !cir.float, !s32i loc +// CIR-DEFAULT-RND: cir.ldexp {{.*}} : !cir.float, !s32i loc +// LLVM-STRICT: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") +// LLVM-STRICT-RND: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") +// LLVM-DEFAULT: call float @llvm.ldexp.f32.i32 +// LLVM-DEFAULT-RND: call float @llvm.ldexp.f32.i32 sf = __builtin_fmaf(x, y, z); // CIR-STRICT: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> // CIR-STRICT-RND: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> @@ -841,6 +883,9 @@ void test_fenv_round_upward(float x, float y, float z, int i, double d) { sf = __builtin_powf(x, y); // CIR: cir.pow {{.*}} : !cir.float fenv<dynamic_rounding_mode = upward, except_mode = unknown, strict_except = true> // LLVM: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.upward", metadata !"fpexcept.strict") + sf = __builtin_ldexpf(x, i); +// CIR: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = upward, except_mode = unknown, strict_except = true> +// LLVM: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.upward", metadata !"fpexcept.strict") sf = __builtin_fmaf(x, y, z); // CIR: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = upward, except_mode = unknown, strict_except = true> // LLVM-STRICT: call float @llvm.experimental.constrained.fma.f32({{.*}}, metadata !"round.upward", metadata !"fpexcept.strict") @@ -901,6 +946,9 @@ void test_fenv_round_tonearest(float x, float y, float z, int i, double d) { sf = __builtin_powf(x, y); // CIR: cir.pow {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true> // LLVM: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict") + sf = __builtin_ldexpf(x, i); +// CIR: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true> +// LLVM: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict") sf = __builtin_fmaf(x, y, z); // CIR: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true> // LLVM-STRICT: call float @llvm.experimental.constrained.fma.f32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict") @@ -962,6 +1010,9 @@ void test_fenv_round_tonearest_except_ignore(float x, float y, float z, int i, d sf = __builtin_powf(x, y); // CIR: cir.pow {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> // LLVM: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") + sf = __builtin_ldexpf(x, i); +// CIR: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> +// LLVM: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") sf = __builtin_fmaf(x, y, z); // CIR: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> // LLVM-STRICT: call float @llvm.experimental.constrained.fma.f32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") @@ -1089,6 +1140,15 @@ void test_fenv_round_tonearest_except_ignore_fenv_off(float x, float y, float z, // LLVM-STRICT-RND: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") // LLVM-DEFAULT: call float @llvm.pow.f32 // LLVM-DEFAULT-RND: call float @llvm.pow.f32 + sf = __builtin_ldexpf(x, i); +// CIR-STRICT: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> +// CIR-STRICT-RND: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> +// CIR-DEFAULT: cir.ldexp {{.*}} : !cir.float, !s32i loc +// CIR-DEFAULT-RND: cir.ldexp {{.*}} : !cir.float, !s32i loc +// LLVM-STRICT: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") +// LLVM-STRICT-RND: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.ignore") +// LLVM-DEFAULT: call float @llvm.ldexp.f32.i32 +// LLVM-DEFAULT-RND: call float @llvm.ldexp.f32.i32 sf = __builtin_fmaf(x, y, z); // CIR-STRICT: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> // CIR-STRICT-RND: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = masked, strict_except = false> @@ -1164,6 +1224,9 @@ void test_fp_exceptions_maytrap(float x, float y, float z, int i, double d) { sf = __builtin_powf(x, y); // CIR: cir.pow {{.*}} : !cir.float fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = false> // LLVM: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.maytrap") + sf = __builtin_ldexpf(x, i); +// CIR: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = false> +// LLVM: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.maytrap") sf = __builtin_fmaf(x, y, z); // CIR: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = false> // LLVM-STRICT: call float @llvm.experimental.constrained.fma.f32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.maytrap") @@ -1225,6 +1288,9 @@ void test_fp_exceptions_maytrap_round_upward(float x, float y, float z, int i, d sf = __builtin_powf(x, y); // CIR: cir.pow {{.*}} : !cir.float fenv<dynamic_rounding_mode = upward, except_mode = unknown, strict_except = false> // LLVM: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.upward", metadata !"fpexcept.maytrap") + sf = __builtin_ldexpf(x, i); +// CIR: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = upward, except_mode = unknown, strict_except = false> +// LLVM: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.upward", metadata !"fpexcept.maytrap") sf = __builtin_fmaf(x, y, z); // CIR: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = upward, except_mode = unknown, strict_except = false> // LLVM-STRICT: call float @llvm.experimental.constrained.fma.f32({{.*}}, metadata !"round.upward", metadata !"fpexcept.maytrap") @@ -1358,6 +1424,9 @@ void test_fenv_round_dynamic_with_fenv_access(float x, float y, float z, int i, sf = __builtin_powf(x, y); // CIR: cir.pow {{.*}} : !cir.float fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> // LLVM: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") + sf = __builtin_ldexpf(x, i); +// CIR: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> +// LLVM: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") sf = __builtin_fmaf(x, y, z); // CIR: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = unknown, except_mode = unknown, strict_except = true> // LLVM-STRICT: call float @llvm.experimental.constrained.fma.f32({{.*}}, metadata !"round.dynamic", metadata !"fpexcept.strict") @@ -1483,6 +1552,15 @@ void test_fenv_round_dynamic_without_fenv_access(float x, float y, float z, int // LLVM-STRICT-RND: call float @llvm.experimental.constrained.pow.f32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict") // LLVM-DEFAULT: call float @llvm.pow.f32 // LLVM-DEFAULT-RND: call float @llvm.pow.f32 + sf = __builtin_ldexpf(x, i); +// CIR-STRICT: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true> +// CIR-STRICT-RND: cir.ldexp {{.*}} : !cir.float, !s32i fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true> +// CIR-DEFAULT: cir.ldexp {{.*}} : !cir.float, !s32i loc +// CIR-DEFAULT-RND: cir.ldexp {{.*}} : !cir.float, !s32i loc +// LLVM-STRICT: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict") +// LLVM-STRICT-RND: call float @llvm.experimental.constrained.ldexp.f32.i32({{.*}}, metadata !"round.tonearest", metadata !"fpexcept.strict") +// LLVM-DEFAULT: call float @llvm.ldexp.f32.i32 +// LLVM-DEFAULT-RND: call float @llvm.ldexp.f32.i32 sf = __builtin_fmaf(x, y, z); // CIR-STRICT: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true> // CIR-STRICT-RND: cir.fma {{.*}} : !cir.float fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true> @@ -1557,6 +1635,9 @@ void test_file_scope_fenv_... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/236997 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
