[ConstantFold] Fold `log1p` and `log1pf` when the input parameter is a constant value. #112113

c8ef · 2024-10-13T02:56:16Z

This patch adds support for constant folding for the log1p and log1pf libc functions.

llvmbot · 2024-10-13T04:17:34Z

@llvm/pr-subscribers-llvm-transforms

@llvm/pr-subscribers-llvm-analysis

Author: None (c8ef)

Changes

This patch adds support for constant folding for the log1p and log1pf libc functions.

Full diff: https://github.com/llvm/llvm-project/pull/112113.diff

2 Files Affected:

(modified) llvm/lib/Analysis/ConstantFolding.cpp (+7-1)
(added) llvm/test/Transforms/InstCombine/log1p.ll (+113)

diff --git a/llvm/lib/Analysis/ConstantFolding.cpp b/llvm/lib/Analysis/ConstantFolding.cpp
index 102762dc7937c6..303e1ca320e045 100644
--- a/llvm/lib/Analysis/ConstantFolding.cpp
+++ b/llvm/lib/Analysis/ConstantFolding.cpp
@@ -1679,7 +1679,8 @@ bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
   case 'l':
     return Name == "log" || Name == "logf" || Name == "logl" ||
            Name == "log2" || Name == "log2f" || Name == "log10" ||
-           Name == "log10f" || Name == "logb" || Name == "logbf";
+           Name == "log10f" || Name == "logb" || Name == "logbf" ||
+           Name == "log1p" || Name == "log1pf";
   case 'n':
     return Name == "nearbyint" || Name == "nearbyintf";
   case 'p':
@@ -2394,6 +2395,11 @@ static Constant *ConstantFoldScalarCall1(StringRef Name,
       if (!APF.isZero() && TLI->has(Func))
         return ConstantFoldFP(logb, APF, Ty);
       break;
+    case LibFunc_log1p:
+    case LibFunc_log1pf:
+      if (APF > APFloat(APF.getSemantics(), "-1") && TLI->has(Func))
+        return ConstantFoldFP(log1p, APF, Ty);
+      break;
     case LibFunc_logl:
       return nullptr;
     case LibFunc_nearbyint:
diff --git a/llvm/test/Transforms/InstCombine/log1p.ll b/llvm/test/Transforms/InstCombine/log1p.ll
new file mode 100644
index 00000000000000..9e22c3f43fb7a2
--- /dev/null
+++ b/llvm/test/Transforms/InstCombine/log1p.ll
@@ -0,0 +1,113 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
+
+define float @log1pf_const() {
+; CHECK-LABEL: define float @log1pf_const() {
+; CHECK-NEXT:    [[R:%.*]] = call float @log1pf(float 7.000000e+00)
+; CHECK-NEXT:    ret float 0x4000A2B240000000
+;
+  %r = call float @log1pf(float 7.000000e+00)
+  ret float %r
+}
+
+define double @log1p_const() {
+; CHECK-LABEL: define double @log1p_const() {
+; CHECK-NEXT:    [[R:%.*]] = call double @log1p(double 7.000000e+00)
+; CHECK-NEXT:    ret double 0x4000A2B23F3BAB73
+;
+  %r = call double @log1p(double 7.000000e+00)
+  ret double %r
+}
+
+define float @log1pf_minus_one() {
+; CHECK-LABEL: define float @log1pf_minus_one() {
+; CHECK-NEXT:    [[R:%.*]] = call float @log1pf(float -1.000000e+00)
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @log1pf(float -1.000000e+00)
+  ret float %r
+}
+
+define double @log1p_minus_one() {
+; CHECK-LABEL: define double @log1p_minus_one() {
+; CHECK-NEXT:    [[R:%.*]] = call double @log1p(double -1.000000e+00)
+; CHECK-NEXT:    ret double [[R]]
+;
+  %r = call double @log1p(double -1.000000e+00)
+  ret double %r
+}
+
+define float @log1pf_zero() {
+; CHECK-LABEL: define float @log1pf_zero() {
+; CHECK-NEXT:    [[R:%.*]] = call float @log1pf(float 0.000000e+00)
+; CHECK-NEXT:    ret float 0.000000e+00
+;
+  %r = call float @log1pf(float 0.000000e+00)
+  ret float %r
+}
+
+define double @log1p_zero() {
+; CHECK-LABEL: define double @log1p_zero() {
+; CHECK-NEXT:    [[R:%.*]] = call double @log1p(double 0.000000e+00)
+; CHECK-NEXT:    ret double 0.000000e+00
+;
+  %r = call double @log1p(double 0.000000e+00)
+  ret double %r
+}
+
+define float @log1pf_inf() {
+; CHECK-LABEL: define float @log1pf_inf() {
+; CHECK-NEXT:    [[R:%.*]] = call float @log1pf(float 0x7FF0000000000000)
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @log1pf(float 0x7FF0000000000000)
+  ret float %r
+}
+
+define double @log1p_inf() {
+; CHECK-LABEL: define double @log1p_inf() {
+; CHECK-NEXT:    [[R:%.*]] = call double @log1p(double 0x7FF0000000000000)
+; CHECK-NEXT:    ret double [[R]]
+;
+  %r = call double @log1p(double 0x7FF0000000000000)
+  ret double %r
+}
+
+define float @log1pf_nan() {
+; CHECK-LABEL: define float @log1pf_nan() {
+; CHECK-NEXT:    [[R:%.*]] = call float @log1pf(float 0x7FF8000000000000)
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @log1pf(float 0x7FF8000000000000)
+  ret float %r
+}
+
+define double @log1p_nan() {
+; CHECK-LABEL: define double @log1p_nan() {
+; CHECK-NEXT:    [[R:%.*]] = call double @log1p(double 0x7FF8000000000000)
+; CHECK-NEXT:    ret double [[R]]
+;
+  %r = call double @log1p(double 0x7FF8000000000000)
+  ret double %r
+}
+
+define float @log1pf_poison() {
+; CHECK-LABEL: define float @log1pf_poison() {
+; CHECK-NEXT:    [[R:%.*]] = call float @log1pf(float poison)
+; CHECK-NEXT:    ret float [[R]]
+;
+  %r = call float @log1pf(float poison)
+  ret float %r
+}
+
+define double @log1p_poison() {
+; CHECK-LABEL: define double @log1p_poison() {
+; CHECK-NEXT:    [[R:%.*]] = call double @log1p(double poison)
+; CHECK-NEXT:    ret double [[R]]
+;
+  %r = call double @log1p(double poison)
+  ret double %r
+}
+
+declare float @log1pf(float)
+declare double @log1p(double)

llvm/test/Transforms/InstCombine/log1p.ll

arsenm · 2024-10-13T09:05:41Z

llvm/lib/Analysis/ConstantFolding.cpp

@@ -2394,6 +2395,11 @@ static Constant *ConstantFoldScalarCall1(StringRef Name,
      if (!APF.isZero() && TLI->has(Func))
        return ConstantFoldFP(logb, APF, Ty);
      break;
+    case LibFunc_log1p:
+    case LibFunc_log1pf:
+      if (APF > APFloat(APF.getSemantics(), "-1") && TLI->has(Func))


Avoid the string? Also still fold if call is memory none

Using -1 directly seems to pick a different constructor and not achieve the intended behavior. Using -1.0 will pick a deleted constructor, so I opted to use "-1" here.

There is an APFloat::getOne constructor

I tried this as well, but it still doesn't work. It seems really strange.

What do you mean doesn't work?

So APFloat bug, cool

cc @davemgreen Can you have a look and add some unittests?

I will fix this.

Fixed. Please rebase this patch on a54d88f.

arsenm · 2024-10-13T09:06:16Z

llvm/test/Transforms/InstCombine/log1p.ll

+  %r = call double @log1p(double poison)
+  ret double %r
+}
+


Test memory none special cases

I have indeed considered handling memory(none) cases. My current plan is not to handle libc functions on a case-by-case basis, but to directly use the value from the libc function regardless of its parameter. Essentially, what I want is to pass the CallBase into the constantFold function, which involves two scenarios. In Case 1, if there are no floating-point exceptions, everything is fine, and we return the folded value. In Case 2, if there is a floating-point exception, we return either nullptr or the exact value returned from the function (such as NaN, HUGE_VAL, etc.) depending on whether this call accesses memory. By doing this, we can eliminate the range check in the Constant Folding phase and avoid error handling based on each function. I look forward to hearing your thoughts on this initial plan.

Constant *ConstantFoldFP(double (*NativeFP)(double), const APFloat &V, Type *Ty, CallBase *CB) { llvm_fenv_clearexcept(); double Result = NativeFP(V.convertToDouble()); if (llvm_fenv_testexcept()) { llvm_fenv_clearexcept(); if (CB->doesNotAccessMemory()) return GetConstantFoldFPValue(Result, Ty); else return nullptr; } return GetConstantFoldFPValue(Result, Ty); }

Handling memory(none) cases will impact all current folding operations. I believe it may break some tests and require additional testing. Therefore, my preference is to constant fold most common math functions as much as possible, and then address edge cases afterwards. Would this approach be acceptable?

I don't think the consideration of doesNotAccessMemory belongs down in ConstantFoldFP. It should produce the constant folded value regardless of the side effects. The legality of ignoring the side effects is context dependent

Plus you can and should still add the tests for these cases here, even if they do not fold yet

Plus you can and should still add the tests for these cases here, even if they do not fold yet

Done.

I don't think the consideration of doesNotAccessMemory belongs down in ConstantFoldFP. It should produce the constant folded value regardless of the side effects. The legality of ignoring the side effects is context dependent

But IIUC the current implementation of ConstantFoldFP already considers side effects? If errno is set or a floating-point exception occurs, it returns nullptr instead of the expected return value.

I would consider that a defect of implementation. The separation of concerns should yield the result. If we wanted, we could produce a side piece of information for raised errors. Whether or not you care if an error occurred depend on the callsite (i.e we can ignore any exceptions in default FP environment, and memory(none) callsites can ignore errno writes)

I believe our ideas align. Even if the implementation of ConstantFolfFP directly returns the result from the underlying libc, we still need a wrapper to validate the libc function parameter. Utilizing fp exceptions and errno to determine the legitimacy of the parameter is convenient as it eliminates the need to write range checks for each individual function.

llvm/test/Transforms/InstCombine/log1p.ll

`APFloat::APFloat(const fltSemantics &Semantics, integerPart I)` interprets 'I' as a unsigned integer. Fix the bug found in #112113 (comment).

`APFloat::APFloat(const fltSemantics &Semantics, integerPart I)` interprets 'I' as a unsigned integer. Fix the bug found in llvm#112113 (comment).

…a constant value. (llvm#112113) This patch adds support for constant folding for the `log1p` and `log1pf` libc functions.

jakeegan · 2024-10-18T06:45:29Z

This test fails on the AIX bot, could you take a look?
https://lab.llvm.org/buildbot/#/builders/64/builds/1232/steps/6/logs/FAIL__LLVM__log1p_ll

c8ef · 2024-10-18T07:22:22Z

The current constant folding of the log1p function relies on the host's libc to compute the folded result. I'm not very familiar with the Power platform. Does its implementation differ from x86 or AArch64, particularly in handling positive or negative zero?

c8ef · 2024-10-18T08:37:32Z

Based on this Godbolt example (https://godbolt.org/z/a9f6xjvK1), it appears that the log1p constant folding handles negative zero correctly. Since I don't have access to a PowerPC machine, could you assist me in verifying this on current trunk?
@jakeegan

jakeegan · 2024-10-21T14:54:29Z

@c8ef The result is:

define noundef double @f() local_unnamed_addr #0 {
entry:
  ret double 0.000000e+00
}

It seems this will require more investigation on an AIX machine, so I'll XFAIL the test on AIX and investigate further.

hubert-reinterpretcast · 2024-10-21T18:54:59Z

The negative zero behaviour is optional. Clang on AIX defines neither __STDC_IEC_559__ nor __STDC_IEC_60559_BFP__.

jakeegan · 2024-10-23T14:28:37Z

@c8ef Would you be able to adapt the test to reflect negative zero behaviour being optional?

c8ef · 2024-10-23T15:46:40Z

Marking it as XFAIL: target={{.*}}-aix{{.*}} will be sufficient?

hubert-reinterpretcast · 2024-10-23T22:04:25Z

Marking it as XFAIL: target={{.*}}-aix{{.*}} will be sufficient?

The XFAIL is actually wrong. The real issue is that compiling for a non-AIX target on an AIX machine will not generate the negative zero result.

A possible solution is to add the special cases to the constant-folding code in LLVM.

c8ef · 2024-10-24T13:49:43Z

Marking it as XFAIL: target={{.*}}-aix{{.*}} will be sufficient?

The XFAIL is actually wrong. The real issue is that compiling for a non-AIX target on an AIX machine will not generate the negative zero result.

A possible solution is to add the special cases to the constant-folding code in LLVM.

It appears that when using the default libc for constant folding, the result's dependency on the platform is unavoidable. In contrast, GCC uses mpfr for constant folding, which may help in disregarding platform information during computation and performing the transformation later.

BTW, could you please review #113020 if you are available? @hubert-reinterpretcast

arsenm · 2024-10-24T19:25:21Z

Can you write a regex check allowing flexibility in the low bits?

arsenm · 2024-10-24T19:26:01Z

Also could special case the zero

hubert-reinterpretcast · 2024-11-02T03:32:21Z

Also could special case the zero

#114635 created to implement that direction.

c8ef added 2 commits October 13, 2024 10:49

constant folding log1p

b49c6c1

constant folding log1p

cbeb725

c8ef changed the title ~~Draft~~ [ConstantFold] Fold log1p and log1pf when the input parameter is a constant value. Oct 13, 2024

c8ef marked this pull request as ready for review October 13, 2024 04:16

llvmbot added llvm:analysis llvm:transforms labels Oct 13, 2024

c8ef requested review from arsenm and dtcxzyw October 13, 2024 04:17

arsenm reviewed Oct 13, 2024

View reviewed changes

add test

b071121

c8ef requested a review from arsenm October 13, 2024 10:18

add readnone test

6e7496b

dtcxzyw mentioned this pull request Oct 15, 2024

[APFloat] Fix APFloat::getOne #112308

Merged

dtcxzyw added a commit that referenced this pull request Oct 15, 2024

[APFloat] Fix APFloat::getOne (#112308)

a54d88f

`APFloat::APFloat(const fltSemantics &Semantics, integerPart I)` interprets 'I' as a unsigned integer. Fix the bug found in #112113 (comment).

c8ef added 2 commits October 15, 2024 19:48

Merge branch 'main' into log1p

3c04e28

APFloat::getOne

34a8746

arsenm approved these changes Oct 15, 2024

View reviewed changes

c8ef merged commit 47a6da2 into llvm:main Oct 15, 2024
8 checks passed

c8ef deleted the log1p branch October 15, 2024 16:19

c8ef mentioned this pull request Oct 19, 2024

[ConstantFold] Fold ilogb and ilogbf when the input parameter is a constant value. #113014

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[ConstantFold] Fold `log1p` and `log1pf` when the input parameter is a constant value. #112113

[ConstantFold] Fold `log1p` and `log1pf` when the input parameter is a constant value. #112113

c8ef commented Oct 13, 2024 •

edited

Loading

llvmbot commented Oct 13, 2024 •

edited

Loading

arsenm Oct 13, 2024

c8ef Oct 13, 2024

arsenm Oct 14, 2024

c8ef Oct 14, 2024

arsenm Oct 14, 2024

arsenm Oct 14, 2024

dtcxzyw Oct 14, 2024

dtcxzyw Oct 15, 2024

dtcxzyw Oct 15, 2024

c8ef Oct 15, 2024

arsenm Oct 13, 2024

c8ef Oct 13, 2024 •

edited

Loading

arsenm Oct 14, 2024

arsenm Oct 14, 2024

c8ef Oct 14, 2024

c8ef Oct 14, 2024

arsenm Oct 14, 2024

c8ef Oct 15, 2024

jakeegan commented Oct 18, 2024

c8ef commented Oct 18, 2024

c8ef commented Oct 18, 2024

jakeegan commented Oct 21, 2024

hubert-reinterpretcast commented Oct 21, 2024

jakeegan commented Oct 23, 2024

c8ef commented Oct 23, 2024

hubert-reinterpretcast commented Oct 23, 2024

c8ef commented Oct 24, 2024

arsenm commented Oct 24, 2024

arsenm commented Oct 24, 2024

hubert-reinterpretcast commented Nov 2, 2024

[ConstantFold] Fold log1p and log1pf when the input parameter is a constant value. #112113

[ConstantFold] Fold log1p and log1pf when the input parameter is a constant value. #112113

Conversation

c8ef commented Oct 13, 2024 • edited Loading

llvmbot commented Oct 13, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

c8ef Oct 13, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jakeegan commented Oct 18, 2024

c8ef commented Oct 18, 2024

c8ef commented Oct 18, 2024

jakeegan commented Oct 21, 2024

hubert-reinterpretcast commented Oct 21, 2024

jakeegan commented Oct 23, 2024

c8ef commented Oct 23, 2024

hubert-reinterpretcast commented Oct 23, 2024

c8ef commented Oct 24, 2024

arsenm commented Oct 24, 2024

arsenm commented Oct 24, 2024

hubert-reinterpretcast commented Nov 2, 2024

[ConstantFold] Fold `log1p` and `log1pf` when the input parameter is a constant value. #112113

[ConstantFold] Fold `log1p` and `log1pf` when the input parameter is a constant value. #112113

c8ef commented Oct 13, 2024 •

edited

Loading

llvmbot commented Oct 13, 2024 •

edited

Loading

c8ef Oct 13, 2024 •

edited

Loading