Skip to content

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

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 6 commits into from
Oct 15, 2024
Merged

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

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
b49c6c1
constant folding log1p
c8ef Oct 13, 2024
cbeb725
constant folding log1p
c8ef Oct 13, 2024
b071121
add test
c8ef Oct 13, 2024
6e7496b
add readnone test
c8ef Oct 14, 2024
3c04e28
Merge branch 'main' into log1p
c8ef Oct 15, 2024
34a8746
APFloat::getOne
c8ef Oct 15, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 9 additions & 3 deletions llvm/lib/Analysis/ConstantFolding.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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':
Expand Down Expand Up @@ -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::getOne(APF.getSemantics(), true) && TLI->has(Func))
return ConstantFoldFP(log1p, APF, Ty);
break;
case LibFunc_logl:
return nullptr;
case LibFunc_nearbyint:
Expand Down Expand Up @@ -3588,8 +3594,8 @@ bool llvm::isMathLibCallNoop(const CallBase *Call,
case LibFunc_acosl:
case LibFunc_acos:
case LibFunc_acosf:
return !(Op < APFloat(Op.getSemantics(), "-1") ||
Op > APFloat(Op.getSemantics(), "1"));
return !(Op < APFloat::getOne(Op.getSemantics(), true) ||
Op > APFloat::getOne(Op.getSemantics()));

case LibFunc_sinh:
case LibFunc_cosh:
Expand Down
275 changes: 275 additions & 0 deletions llvm/test/Transforms/InstCombine/log1p.ll
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,275 @@
; 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_minus_one_memory_none() {
; CHECK-LABEL: define float @log1pf_minus_one_memory_none() {
; CHECK-NEXT: [[R:%.*]] = call float @log1pf(float -1.000000e+00) #[[ATTR0:[0-9]+]]
; CHECK-NEXT: ret float [[R]]
;
%r = call float @log1pf(float -1.000000e+00) readnone
ret float %r
}

define double @log1p_minus_one_memory_none() {
; CHECK-LABEL: define double @log1p_minus_one_memory_none() {
; CHECK-NEXT: [[R:%.*]] = call double @log1p(double -1.000000e+00) #[[ATTR0]]
; CHECK-NEXT: ret double [[R]]
;
%r = call double @log1p(double -1.000000e+00) readnone
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_neg_zero() {
; CHECK-LABEL: define float @log1pf_neg_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_neg_zero() {
; CHECK-LABEL: define double @log1p_neg_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_neg1() {
; CHECK-LABEL: define float @log1pf_neg1() {
; CHECK-NEXT: [[R:%.*]] = call float @log1pf(float -7.000000e+00)
; CHECK-NEXT: ret float [[R]]
;
%r = call float @log1pf(float -7.000000e+00)
ret float %r
}

define double @log1p_neg1() {
; CHECK-LABEL: define double @log1p_neg1() {
; CHECK-NEXT: [[R:%.*]] = call double @log1p(double -7.000000e+00)
; CHECK-NEXT: ret double [[R]]
;
%r = call double @log1p(double -7.000000e+00)
ret double %r
}

define float @log1pf_neg1_memory_none() {
; CHECK-LABEL: define float @log1pf_neg1_memory_none() {
; CHECK-NEXT: [[R:%.*]] = call float @log1pf(float -7.000000e+00) #[[ATTR0]]
; CHECK-NEXT: ret float [[R]]
;
%r = call float @log1pf(float -7.000000e+00) readnone
ret float %r
}

define double @log1p_neg1_memory_none() {
; CHECK-LABEL: define double @log1p_neg1_memory_none() {
; CHECK-NEXT: [[R:%.*]] = call double @log1p(double -7.000000e+00) #[[ATTR0]]
; CHECK-NEXT: ret double [[R]]
;
%r = call double @log1p(double -7.000000e+00) readnone
ret double %r
}

define float @log1pf_neg2() {
; CHECK-LABEL: define float @log1pf_neg2() {
; CHECK-NEXT: [[R:%.*]] = call float @log1pf(float -5.000000e-01)
; CHECK-NEXT: ret float 0xBFE62E4300000000
;
%r = call float @log1pf(float -5.000000e-01)
ret float %r
}

define double @log1p_neg2() {
; CHECK-LABEL: define double @log1p_neg2() {
; CHECK-NEXT: [[R:%.*]] = call double @log1p(double -5.000000e-01)
; CHECK-NEXT: ret double 0xBFE62E42FEFA39EF
;
%r = call double @log1p(double -5.000000e-01)
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_inf_memory_none() {
; CHECK-LABEL: define float @log1pf_inf_memory_none() {
; CHECK-NEXT: [[R:%.*]] = call float @log1pf(float 0x7FF0000000000000) #[[ATTR0]]
; CHECK-NEXT: ret float [[R]]
;
%r = call float @log1pf(float 0x7FF0000000000000) readnone
ret float %r
}

define double @log1p_inf_memory_none() {
; CHECK-LABEL: define double @log1p_inf_memory_none() {
; CHECK-NEXT: [[R:%.*]] = call double @log1p(double 0x7FF0000000000000) #[[ATTR0]]
; CHECK-NEXT: ret double [[R]]
;
%r = call double @log1p(double 0x7FF0000000000000) readnone
ret double %r
}

define float @log1pf_neg_inf() {
; CHECK-LABEL: define float @log1pf_neg_inf() {
; CHECK-NEXT: [[R:%.*]] = call float @log1pf(float 0xFFF0000000000000)
; CHECK-NEXT: ret float [[R]]
;
%r = call float @log1pf(float 0xFFF0000000000000)
ret float %r
}

define double @log1p_neg_inf() {
; CHECK-LABEL: define double @log1p_neg_inf() {
; CHECK-NEXT: [[R:%.*]] = call double @log1p(double 0xFFF0000000000000)
; CHECK-NEXT: ret double [[R]]
;
%r = call double @log1p(double 0xFFF0000000000000)
ret double %r
}

define float @log1pf_neg_inf_memory_none() {
; CHECK-LABEL: define float @log1pf_neg_inf_memory_none() {
; CHECK-NEXT: [[R:%.*]] = call float @log1pf(float 0xFFF0000000000000) #[[ATTR0]]
; CHECK-NEXT: ret float [[R]]
;
%r = call float @log1pf(float 0xFFF0000000000000) readnone
ret float %r
}

define double @log1p_neg_inf_memory_none() {
; CHECK-LABEL: define double @log1p_neg_inf_memory_none() {
; CHECK-NEXT: [[R:%.*]] = call double @log1p(double 0xFFF0000000000000) #[[ATTR0]]
; CHECK-NEXT: ret double [[R]]
;
%r = call double @log1p(double 0xFFF0000000000000) readnone
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_nan_memory_none() {
; CHECK-LABEL: define float @log1pf_nan_memory_none() {
; CHECK-NEXT: [[R:%.*]] = call float @log1pf(float 0x7FF8000000000000) #[[ATTR0]]
; CHECK-NEXT: ret float [[R]]
;
%r = call float @log1pf(float 0x7FF8000000000000) readnone
ret float %r
}

define double @log1p_nan_memory_none() {
; CHECK-LABEL: define double @log1p_nan_memory_none() {
; CHECK-NEXT: [[R:%.*]] = call double @log1p(double 0x7FF8000000000000) #[[ATTR0]]
; CHECK-NEXT: ret double [[R]]
;
%r = call double @log1p(double 0x7FF8000000000000) readnone
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
}

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Test memory none special cases

Copy link
Contributor Author

@c8ef c8ef Oct 13, 2024 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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?

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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

Done.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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)

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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.

declare float @log1pf(float)
declare double @log1p(double)
Loading