[ConstantFolding] Fold calls to FP remainder function

[ekatz]

Summary

With the fixed implementation of the "remainder" operation, we can now add support to folding calls to it.

[arsenm]

Needs test

[ekatz]

Added a test (copied from the one for "fmod").
Added handling of "remainder" to TargetLibraryInfo.cpp.

[arsenm]

llvm/lib/Analysis/ConstantFolding.cpp

2106

Backwards condition

llvm/test/Analysis/ConstantFolding/math-2.ll

31

Should have tests stressing all the handled types , and preferably a few for the special cases , like snan

[ekatz]

llvm/lib/Analysis/ConstantFolding.cpp

2106

Wanted to be consistent with the coding style on that particular file. See line 2095.
If I change this, should I also change it for "mod()" as well?

[arsenm]

llvm/lib/Analysis/ConstantFolding.cpp

2106

I would say change this, and leave the unrelated part alone

[ekatz]

llvm/test/Analysis/ConstantFolding/math-2.ll

31

I agree that it should be tested for double as well, but the test cases are not important, as we test them under the APFloat unit-test. Otherwise, we will just have duplicates in the implementation code and the using code.

[ekatz]

Added a test case for double.

[arsenm]

llvm/test/Analysis/ConstantFolding/math-2.ll

31

The code specifically checks for opStatus though, so the point isn't necessarily then folding result

[ekatz]

llvm/test/Analysis/ConstantFolding/math-2.ll

31

The APFloat unit test is also testing various combination of operations' results.

[ekatz]

Ping

[ekatz]

Ping

[arsenm]

llvm/test/Analysis/ConstantFolding/math-2.ll

31

But not in this usage context. The behavior here is changing based on it, so the point isn't testing what the opStatus is

37

also one for remainderl

[ekatz]

llvm/test/Analysis/ConstantFolding/math-2.ll

37

remainderl is not folded. Just wanted to be consistent with other math operations (like fmodl). I am not sure why they are not folded, but it is consistent with other compilers like icc and gcc).

[ekatz]

llvm/test/Analysis/ConstantFolding/math-2.ll

31

Right, but wouldn't adding a bunch of other value combinations just test the result of APFloat? For which we already have the unit test. It doesn't only test the status, but also the actual result (bitwise).

[ekatz]

Ping

[ekatz]

Ping

[hfinkel]

llvm/test/Analysis/ConstantFolding/math-2.ll

31

You don't need to add a large number of other tests, but you should have a test for something that shouldn't fold (V.remainder returns something other than opOK).

Otherwise, this LGTM.

37

Yeah, this is indeed consistent with the other similar functions. I'm not sure why either, and we probably should do this (at least on systems where we accurately model the semantics of the long double type).

[ekatz]

llvm/test/Analysis/ConstantFolding/math-2.ll

31

Sounds good. I added another test for success in folding, and another for a failure.

llvm/include/llvm/Analysis/TargetLibraryInfo.def

 TLI_DEFINE_ENUM_INTERNAL(realloc)
 TLI_DEFINE_STRING_INTERNAL("realloc")
 /// void *reallocf(void *ptr, size_t size);
 TLI_DEFINE_ENUM_INTERNAL(reallocf)
 TLI_DEFINE_STRING_INTERNAL("reallocf")
 /// char *realpath(const char *file_name, char *resolved_name);
 TLI_DEFINE_ENUM_INTERNAL(realpath)
 TLI_DEFINE_STRING_INTERNAL("realpath")
+/// double remainder(double x, double y);
+TLI_DEFINE_ENUM_INTERNAL(remainder)
+TLI_DEFINE_STRING_INTERNAL("remainder")
+/// float remainderf(float x, float y);
+TLI_DEFINE_ENUM_INTERNAL(remainderf)
+TLI_DEFINE_STRING_INTERNAL("remainderf")
+/// long double remainderl(long double x, long double y);
+TLI_DEFINE_ENUM_INTERNAL(remainderl)
+TLI_DEFINE_STRING_INTERNAL("remainderl")
 /// int remove(const char *path);
 TLI_DEFINE_ENUM_INTERNAL(remove)
 TLI_DEFINE_STRING_INTERNAL("remove")
 /// int rename(const char *old, const char *new);
 TLI_DEFINE_ENUM_INTERNAL(rename)
 TLI_DEFINE_STRING_INTERNAL("rename")
 /// void rewind(FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(rewind)

llvm/lib/Analysis/ConstantFolding.cpp

case 'l':
     return Name == "log" || Name == "logf" ||
            Name == "log2" || Name == "log2f" ||
            Name == "log10" || Name == "log10f";
   case 'n':
     return Name == "nearbyint" || Name == "nearbyintf";
   case 'p':
     return Name == "pow" || Name == "powf";
   case 'r':
-    return Name == "rint" || Name == "rintf" ||
+    return Name == "remainder" || Name == "remainderf" ||
+           Name == "rint" || Name == "rintf" ||
            Name == "round" || Name == "roundf";
   case 's':
     return Name == "sin" || Name == "sinf" ||
            Name == "sinh" || Name == "sinhf" ||
            Name == "sqrt" || Name == "sqrtf";
   case 't':
     return Name == "tan" || Name == "tanf" ||
            Name == "tanh" || Name == "tanhf" ||
if (auto *Op2 = dyn_cast<ConstantFP>(Operands[1])) {
       case LibFunc_fmod:
       case LibFunc_fmodf:
         if (TLI->has(Func)) {
           APFloat V = Op1->getValueAPF();
           if (APFloat::opStatus::opOK == V.mod(Op2->getValueAPF()))
             return ConstantFP::get(Ty->getContext(), V);
         }
         break;
+      case LibFunc_remainder:
+      case LibFunc_remainderf:
+        if (TLI->has(Func)) {
+          APFloat V = Op1->getValueAPF();
+          if (APFloat::opStatus::opOK == V.remainder(Op2->getValueAPF()))
+            return ConstantFP::get(Ty->getContext(), V);
+        }
+        break;
       case LibFunc_atan2:
       case LibFunc_atan2f:
       case LibFunc_atan2_finite:
       case LibFunc_atan2f_finite:
         if (TLI->has(Func))
           return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty);
         break;
       }
if (Op0C && Op1C) {
           }
         }
         break;
       }
 
       case LibFunc_fmodl:
       case LibFunc_fmod:
       case LibFunc_fmodf:
+      case LibFunc_remainderl:
+      case LibFunc_remainder:
+      case LibFunc_remainderf:
         return Op0.isNaN() || Op1.isNaN() ||
                (!Op0.isInfinity() && !Op1.isZero());
 
       default:
         break;
       }
     }
   }
 
   return false;
 }

llvm/lib/Analysis/TargetLibraryInfo.cpp

if (!hasPartialFloat) {
       TLI.setUnavailable(LibFunc_coshf);
       TLI.setUnavailable(LibFunc_expf);
       TLI.setUnavailable(LibFunc_floorf);
       TLI.setUnavailable(LibFunc_fmodf);
       TLI.setUnavailable(LibFunc_log10f);
       TLI.setUnavailable(LibFunc_logf);
       TLI.setUnavailable(LibFunc_modff);
       TLI.setUnavailable(LibFunc_powf);
+      TLI.setUnavailable(LibFunc_remainderf);
       TLI.setUnavailable(LibFunc_sinf);
       TLI.setUnavailable(LibFunc_sinhf);
       TLI.setUnavailable(LibFunc_sqrtf);
       TLI.setUnavailable(LibFunc_tanf);
       TLI.setUnavailable(LibFunc_tanhf);
     }
     if (!isARM)
       TLI.setUnavailable(LibFunc_fabsf);
if (T.isOSWindows() && !T.isOSCygMing()) {
     TLI.setUnavailable(LibFunc_floorl);
     TLI.setUnavailable(LibFunc_fmodl);
     TLI.setUnavailable(LibFunc_frexpl);
     TLI.setUnavailable(LibFunc_ldexpl);
     TLI.setUnavailable(LibFunc_log10l);
     TLI.setUnavailable(LibFunc_logl);
     TLI.setUnavailable(LibFunc_modfl);
     TLI.setUnavailable(LibFunc_powl);
+    TLI.setUnavailable(LibFunc_remainderl);
     TLI.setUnavailable(LibFunc_sinl);
     TLI.setUnavailable(LibFunc_sinhl);
     TLI.setUnavailable(LibFunc_sqrtl);
     TLI.setUnavailable(LibFunc_tanl);
     TLI.setUnavailable(LibFunc_tanhl);
 
     // Win32 does not fully support C99 math functions.
     if (!hasPartialC99) {
bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
   case LibFunc_fminf:
   case LibFunc_fminl:
   case LibFunc_fmax:
   case LibFunc_fmaxf:
   case LibFunc_fmaxl:
   case LibFunc_fmod:
   case LibFunc_fmodf:
   case LibFunc_fmodl:
+  case LibFunc_remainder:
+  case LibFunc_remainderf:
+  case LibFunc_remainderl:
   case LibFunc_copysign:
   case LibFunc_copysignf:
   case LibFunc_copysignl:
   case LibFunc_pow:
   case LibFunc_pow_finite:
   case LibFunc_powf:
   case LibFunc_powf_finite:
   case LibFunc_powl:

llvm/test/Analysis/ConstantFolding/math-2.ll

 define float @f_fmodf() {
 ; CHECK-LABEL: @f_fmodf(
 ; CHECK-NEXT:    ret float 1.000000e+00
 ;
   %res = tail call fast float @fmodf(float 1.0, float 2.0)
   ret float %res
 }
 
+declare float @remainderf(float, float)
+define float @f_remainderf_fold1() {
+; CHECK-LABEL: @f_remainderf_fold1(
+; CHECK-NEXT:    ret float 1.000000e+00
+;
+  %res = tail call fast float @remainderf(float 1.0, float 2.0)
+  ret float %res
+}
+
+define float @f_remainderf_fold2() {
+; CHECK-LABEL: @f_remainderf_fold2(
+; CHECK-NEXT:    ret float -5.000000e-01
+;
+  %res = tail call fast float @remainderf(float 1.5, float 1.0)
+  ret float %res
+}
+
+define float @f_remainderf_nofold() {
+; CHECK-LABEL: @f_remainderf_nofold(
+; CHECK-NEXT:    [[RES:%.*]] = tail call fast float @remainderf(float 1.000000e+00, float 0.000000e+00)
+; CHECK-NEXT:    ret float [[RES]]
+;
+  %res = tail call fast float @remainderf(float 1.0, float 0.0)
+  ret float %res
+}
+
+declare double @remainder(double, double)
+define double @f_remainder_fold1() {
+; CHECK-LABEL: @f_remainder_fold1(
+; CHECK-NEXT:    ret double 1.000000e+00
+;
+  %res = tail call fast double @remainder(double 1.0, double 2.0)
+  ret double %res
+}
+
+define double @f_remainder_fold2() {
+; CHECK-LABEL: @f_remainder_fold2(
+; CHECK-NEXT:    ret double -5.000000e-01
+;
+  %res = tail call fast double @remainder(double 1.5, double 1.0)
+  ret double %res
+}
+
+define double @f_remainder_nofold() {
+; CHECK-LABEL: @f_remainder_nofold(
+; CHECK-NEXT:    [[RES:%.*]] = tail call fast double @remainder(double 1.000000e+00, double 0.000000e+00)
+; CHECK-NEXT:    ret double [[RES]]
+;
+  %res = tail call fast double @remainder(double 1.0, double 0.0)
+  ret double %res
+}
+
 declare double @pow(double, double)
 define double @f_pow() {
 ; CHECK-LABEL: @f_pow(
 ; CHECK-NEXT:    ret double 1.000000e+00
 ;
   %res = tail call fast double @pow(double 1.0, double 2.0)
   ret double %res
 }