[InstCombiner] Simplify lib calls to `round{,f}`

[bryant]

Summary

From IRC:

12:30:04 -!- Noxbru [~[e-mail]] has joined #llvm
12:32:20 < Noxbru> hi, I have a quick question about llvm: is there a way to make the optimizer optimize away the calls to 'round' when the arguments are known constants?
12:33:09 < Noxbru> for example, I have 'round(0.9)' and GCC -O2 simply puts a '1' while clang makes the full call to round
12:33:24 < Noxbru> at least when checking the assembly output
12:36:36 < Noxbru> BTW, this is with clang 3.9.0
12:38:10 < gronsaken> gamester: See the answer from Duncan in this thread https://groups.google.com/forum/#!topic/llvm-dev/uk4uiK93jeM
12:46:48 < davide> Noxbru: missing optimization in SimplifyLibCalls.cpp
12:46:58 < davide> Noxbru: open a bug
12:48:16 < Noxbru> davide: ah, okay, against which component should I file it?
12:48:33 < davide> scalar optimizations
12:48:39 < davide> libraries
12:48:49 < davide> it should be easy to fix, FWIW

[majnemer]

LGTM

llvm/trunk/lib/Analysis/ConstantFolding.cpp

bool llvm::canConstantFoldCallTo(const Function *F) {
   case 'f':
     return Name == "fabs" || Name == "floor" || Name == "fmod" ||
            Name == "fabsf" || Name == "floorf" || Name == "fmodf";
   case 'l':
     return Name == "log" || Name == "log10" || Name == "logf" ||
            Name == "log10f";
   case 'p':
     return Name == "pow" || Name == "powf";
+  case 'r':
+    return Name == "round" || Name == "roundf";
   case 's':
     return Name == "sin" || Name == "sinh" || Name == "sqrt" ||
            Name == "sinf" || Name == "sinhf" || Name == "sqrtf";
   case 't':
     return Name == "tan" || Name == "tanh" || Name == "tanf" || Name == "tanhf";
   }
 }
 
if (auto *Op = dyn_cast<ConstantFP>(Operands[0])) {
             // all guarantee or favor returning NaN - the square root of a
             // negative number is not defined for the LLVM sqrt intrinsic.
             // This is because the intrinsic should only be emitted in place of
             // libm's sqrt function when using "no-nans-fp-math".
             return UndefValue::get(Ty);
           }
         }
         break;
+      case 'r':
+        if ((Name == "round" && TLI->has(LibFunc::round)) ||
+            (Name == "roundf" && TLI->has(LibFunc::roundf)))
+          return ConstantFoldFP(round, V, Ty);
       case 's':
         if ((Name == "sin" && TLI->has(LibFunc::sin)) ||
             (Name == "sinf" && TLI->has(LibFunc::sinf)))
           return ConstantFoldFP(sin, V, Ty);
         else if ((Name == "sinh" && TLI->has(LibFunc::sinh)) ||
                  (Name == "sinhf" && TLI->has(LibFunc::sinhf)))
           return ConstantFoldFP(sinh, V, Ty);
         else if ((Name == "sqrt" && V >= 0 && TLI->has(LibFunc::sqrt)) ||

llvm/trunk/test/Transforms/ConstProp/calls.ll

 declare double @exp(double) readnone nounwind
 declare double @exp2(double) readnone nounwind
 declare double @fabs(double) readnone nounwind
 declare double @floor(double) readnone nounwind
 declare double @fmod(double, double) readnone nounwind
 declare double @log(double) readnone nounwind
 declare double @log10(double) readnone nounwind
 declare double @pow(double, double) readnone nounwind
+declare double @round(double) readnone nounwind
 declare double @sin(double) readnone nounwind
 declare double @sinh(double) readnone nounwind
 declare double @sqrt(double) readnone nounwind
 declare double @tan(double) readnone nounwind
 declare double @tanh(double) readnone nounwind
 
 declare float @acosf(float) readnone nounwind
 declare float @asinf(float) readnone nounwind
 declare float @atanf(float) readnone nounwind
 declare float @atan2f(float, float) readnone nounwind
 declare float @ceilf(float) readnone nounwind
 declare float @cosf(float) readnone nounwind
 declare float @coshf(float) readnone nounwind
 declare float @expf(float) readnone nounwind
 declare float @exp2f(float) readnone nounwind
 declare float @fabsf(float) readnone nounwind
 declare float @floorf(float) readnone nounwind
 declare float @fmodf(float, float) readnone nounwind
 declare float @logf(float) readnone nounwind
 declare float @log10f(float) readnone nounwind
 declare float @powf(float, float) readnone nounwind
+declare float @roundf(float) readnone nounwind
 declare float @sinf(float) readnone nounwind
 declare float @sinhf(float) readnone nounwind
 declare float @sqrtf(float) readnone nounwind
 declare float @tanf(float) readnone nounwind
 declare float @tanhf(float) readnone nounwind
 
 define double @T() {
 ; CHECK-LABEL: @T(
; FNOBUILTIN: call
   store double %12, double* %slot
 ; FNOBUILTIN: call
   %13 = call double @log10(double 3.000000e+00)
   store double %13, double* %slot
 ; FNOBUILTIN: call
   %14 = call double @pow(double 3.000000e+00, double 4.000000e+00)
   store double %14, double* %slot
 ; FNOBUILTIN: call
+  %round_val = call double @round(double 3.000000e+00)
+  store double %round_val, double* %slot
+; FNOBUILTIN: call
   %15 = call double @sinh(double 3.000000e+00)
   store double %15, double* %slot
 ; FNOBUILTIN: call
   %16 = call double @tanh(double 3.000000e+00)
   store double %16, double* %slot
 ; FNOBUILTIN: call
   %17 = call float @acosf(float 1.000000e+00)
   store float %17, float* %slotf
; FNOBUILTIN: call
   store float %29, float* %slotf
 ; FNOBUILTIN: call
   %30 = call float @log10f(float 3.000000e+00)
   store float %30, float* %slotf
 ; FNOBUILTIN: call
   %31 = call float @powf(float 3.000000e+00, float 4.000000e+00)
   store float %31, float* %slotf
 ; FNOBUILTIN: call
+  %roundf_val = call float @roundf(float 3.000000e+00)
+  store float %roundf_val, float* %slotf
+; FNOBUILTIN: call
   %32 = call float @sinf(float 3.000000e+00)
   store float %32, float* %slotf
 ; FNOBUILTIN: call
   %33 = call float @sinhf(float 3.000000e+00)
   store float %33, float* %slotf
 ; FNOBUILTIN: call
   %34 = call float @sqrtf(float 3.000000e+00)
   store float %34, float* %slotf