Conditionally eliminate library calls where the result value is not used

[xur]

Summary

This pass shrink-wraps a condition to some library calls where the call
result is not used. For example:

sqrt(val);

is transformed to

if (val < 0)
  sqrt(val);

Even if the result of library call is not being used, the compiler cannot
safely delete the call because the function can set errno on error
conditions.
Note in many functions, the error condition solely depends on the incoming
parameter. In this optimization, we can generate the condition can lead to
the errno to shrink-wrap the call. Since the chances of hitting the error
condition is low, the runtime call is effectively eliminated.

These partially dead calls are usually results of C++ abstraction penalty
exposed by inlining. This optimization hits 108 times in 19 C/C++ programs
in SPEC2006.

[davidxl]

Have not looked in details -- but just a quick note: you should annotate the created branches with MD_prof meta data to indicate it is not likely to be taken

[davidxl]

you should probably use 1/2000 which is the same value used in builtin_expect lowering. We can refactor the option for it later.

[davidxl]

lib/Transforms/Utils/CondDeadCallElimination.cpp

11

shrink wraps a call to function .. if the result is not used. The call can set errno but is otherwise side effect free.

55

The name of this option is quite confusing. Perhaps DoDeleteCallNoErrNo?

99

CICandidate or CICand?

105

-> checkCandidate

111

Missing documentation for the method. Also name it "CreateOrCond".

I also think it is better to pass the Arg directly instead of the CallInst&

119

Missing documentation; Pass Arg0 directly

128

This method can refactored to share code with CreateCond methods that takes two compares.

144

Fix documentation. This function does not 'find all ...'. It checks if CI is a candidate for shrinkwrapping and put it into work list if it is.

203

Perhaps break the giant switch into smaller helper functions. For instance define a helper function called:

bool doesFuncSetErrNo(...) { ..

}

212

DomeinError -> DomainError

553

When OptimizeForSize is on, this pass should not be turned on.

[xur]

Will branch-weight to 1/2000.

lib/Transforms/Utils/CondDeadCallElimination.cpp

111

I will change the name.
I'm not sure if it's better to pass Arg directly. I also need the instruction for the IRBuilder (either IRBuilder or CallInst).

203

Will do.

[xur]

Addressed David's review comments. Also changed the coding structure so that
the transformaton in one place.

[davidxl]

lib/Transforms/Utils/CondDeadCallElimination.cpp

132

Make this one also takes IRBuilder<>& as parameter. Introduce another overload of CreateCond that does not have IRBuilder<>&

150

why not having a separate patch to improve FE?

162

Why not using attribute marked by FE?

370

If the runtime exposes API to invoke fast path no-errorno implementation, this pass can also be enhanced to handle calls that have uses. Perhaps add a comment here for future enhancement

472

Add a comment that the condition can be more conservative than it actually is.

486

// FIXME

596

Should OptimizeForSize be passed in via pass builder (see LoopUnswitch) as well?

[xur]

lib/Transforms/Utils/CondDeadCallElimination.cpp

150

we could. I only tested c/c++ FE. I think the good thing doing here is this applies to all FE.

I'll leave it here for now. Will do post commit fix if needed.

162

I haven't tested that. But why bother? we can safely delete them here.

596

the parameter OptForSize is passed from pass builder.
Here we also check the function attribute that can overwrite the command line options.

[xur]

Addressed David's review comments.

[davidxl]

lib/Transforms/Utils/CondDeadCallElimination.cpp

162

Actually I think it is the wrong place to handle these no-errno functions here -- they should be handled by regular DCE pass.

In fact functions like ceil etc are already handled by DCE.

So my suggestion is to completely get rid of these no-side effect functions from this patch. Have a separate patch to fix CFE for the missing cases like asinh.

[xur]

Removed the deleting for no-errno functionality suggested by David.
Will submit a separated patch in DCE.

[davidxl]

lib/Transforms/Utils/CondDeadCallElimination.cpp

108

Remove this line.

305

Move this check into ShrinkWrapCI

test/Transforms/Util/cond-call-dce-double.ll

25

no need to redefine BRANCH_WEIGHT

35

same here and other places.

[xur]

Integrated David's review comments.

[davidxl]

The plan is to have this pass provide a more general framework to do math function partial inlining as well (as followup). Once that is done, the existing SQRT partial inliine pass can be subsumed.

[mehdi_amini]

That's a smart transformation!
The patch looks good overall, I only have minor comments inline.

include/llvm/Transforms/Scalar.h

525

I'm not super convinced by the "DCE" in the name, there does not seem to be "dead code" here, and no "code elimination" either.

Also you need to document the parameter OptimizeForSize, which I'm not convinced should be there at all. If I read correctly the code it totally disable this pass. So adding a pass to the pipeline while disabling it at the same time does not make sense to me.
Also, it handled the function attribute, isn't it enough?

lib/Transforms/Utils/CondDeadCallElimination.cpp

16

Can you turn this into "if (val < 0) { errno = ... }" and eliminate the call?
Maybe we don't have guarantee that errno is available?

53

I don't believe it is common to have such flags in pass implementations?

130

What about FP16 here?

315

That's a neat idea!

326

Any example in mind?

Also there is no test for any of the bailout here. Can you add some?

519

Usually we try to add a message in assertion, something like "checkCandidate shouldn't queue non-TLI func"

[davidxl]

lib/Transforms/Utils/CondDeadCallElimination.cpp

313

used, if there is API .. ---> used. If there is an API ..

314

errno). We ... --> errno, we ...

Also, the description should be :

.. can use the same framework to direct/wrap the call to the fast API in the error free path, and leave the original call in the slow path.

[xur]

Thanks for reviewing this patch. I'll update with your comments and upload it soon.

include/llvm/Transforms/Scalar.h

525

The intention is to eliminate the call in the runtime. But I agree that there should be a better name for this. Let me think about this.

Thanks for finding OptimizeForSize issue. In the earlier implementation, there is a part of pass still doing some work with OptimizeForSize==true . Now that part is removed from the pass which makes the OptimizeForSize useless. I'll remove this part.

OptimizeForSize is passed from pass manager and it also reads the function attribute. I'm not sure I understand your last question. Can you explain more?

lib/Transforms/Utils/CondDeadCallElimination.cpp

16

I can do this for some calls -- if I can use the exact condition for the call. For others, like pow(), the conditions we used here are the superset of the true conditions of generating errno . We can not set the errno directly.

Also the assumption is that the chance of getting to the err code path is low. We probably don't concern the performance of this cold path. I would prefer to keep as it is.

53

You mean in PassManagerBuilder?

130

Are there math lib calls using FP16 type?
I only know the following types for the math lib calls: double, float and long double.

326

We probably do not need this check.
Let me try to remove this.

[xur]

Addressed Mehdi and David review comments. The bigger ones are:
(1) removed the use of the OptimizedForSize passed from passmanagerbuild.
(2) renamed the pass to LibCallsShrinkWrap.

[mehdi_amini]

include/llvm/Transforms/Scalar.h

525

That's fine, removing OptimizeForSize addresses it.

lib/Transforms/Utils/CondDeadCallElimination.cpp

16

OK!

53

We have such flags in the pass manager builder, yes. But not here in within the pass itself I think.

130

I don't know about what can we stuck into TLI? What would the Cuda target do for instance?

[xur]

lib/Transforms/Utils/CondDeadCallElimination.cpp

53

OK. I'll move this "disable" option to pass manager build. I'll rename it to "disable-libcalls-shrinkwrap"

130

the library calls I handled in this pass are white-listed. They should take either "float", "double", or "long double" as the argument. I don't think we will ever see a FP16 type here.

[mehdi_amini]

lib/Transforms/Utils/CondDeadCallElimination.cpp

130

You're right!

[xur]

Move internal option -disable-libcalls-shrinkwrap to PassBuilderManager per
Mehdi's suggestion. Also check the FP format. This is primarily for long double
type where the powerpc has narrower range than in x86. We only handle
x87DoubleExtended format for long double for now.

[davidxl]

lgtm

(the original patch also includes handling of math libs which are not properly annotated by Clang FE. Is there a patch submitted for that fix?)

lib/Transforms/Utils/LibCallsShrinkWrap.cpp

320 ↗

(On Diff #74299)

Add a comment (todo) for handle long double in other formats (either with conservative range test or precise handling).

[xur]

Add a TODO comment for long double suggested by David.

To david: I'll send another patch for mathlib functions that not properly annotated.

[mehdi_amini]

LGTM as well, thanks!

include/llvm/InitializePasses.h

 void initializeCFGViewerLegacyPassPass(PassRegistry&);
 void initializeCFLAndersAAWrapperPassPass(PassRegistry&);
 void initializeCFLSteensAAWrapperPassPass(PassRegistry&);
 void initializeCallGraphDOTPrinterPass(PassRegistry&);
 void initializeCallGraphPrinterLegacyPassPass(PassRegistry&);
 void initializeCallGraphViewerPass(PassRegistry&);
 void initializeCallGraphWrapperPassPass(PassRegistry &);
 void initializeCodeGenPreparePass(PassRegistry&);
+void initializeCondCallDCELegacyPassPass(PassRegistry&);
 void initializeCountingFunctionInserterPass(PassRegistry&);
 void initializeConstantHoistingLegacyPassPass(PassRegistry&);
 void initializeConstantMergeLegacyPassPass(PassRegistry &);
 void initializeConstantPropagationPass(PassRegistry&);
 void initializeCorrelatedValuePropagationPass(PassRegistry&);
 void initializeCostModelAnalysisPass(PassRegistry&);
 void initializeCrossDSOCFIPass(PassRegistry&);
 void initializeDAEPass(PassRegistry&);

include/llvm/LinkAllPasses.h

ForcePassLinking() {
       (void) llvm::createBoundsCheckingPass();
       (void) llvm::createBreakCriticalEdgesPass();
       (void) llvm::createCallGraphDOTPrinterPass();
       (void) llvm::createCallGraphViewerPass();
       (void) llvm::createCFGSimplificationPass();
       (void) llvm::createCFLAndersAAWrapperPass();
       (void) llvm::createCFLSteensAAWrapperPass();
       (void) llvm::createStructurizeCFGPass();
+      (void) llvm::createCondCallDCEPass();
       (void) llvm::createConstantMergePass();
       (void) llvm::createConstantPropagationPass();
       (void) llvm::createCostModelAnalysisPass();
       (void) llvm::createDeadArgEliminationPass();
       (void) llvm::createDeadCodeEliminationPass();
       (void) llvm::createDeadInstEliminationPass();
       (void) llvm::createDeadStoreEliminationPass();
       (void) llvm::createDependenceAnalysisWrapperPass();

include/llvm/Transforms/Scalar.h

 //
 // LoopDataPrefetch - Perform data prefetching in loops.
 //
 FunctionPass *createLoopDataPrefetchPass();
 
 ///===---------------------------------------------------------------------===//
 ModulePass *createNameAnonGlobalPass();
 
+//===----------------------------------------------------------------------===//
+//
+// CondCallDCE - Shrink-wraps a call to function if the result is not used.
+//
+FunctionPass *createCondCallDCEPass(bool OptimizeForSize = false);
 } // End llvm namespace
 
 #endif

include/llvm/Transforms/Utils/CondDeadCallElimination.h

+//===- CondDeadCallElimination.h - Conditionally Eliminate Dead Library Calls --===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_CONDDEADCALLELIMINATION_H
+#define LLVM_TRANSFORMS_UTILS_CONDDEADCALLELIMINATION_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class CondCallDCEPass : public PassInfoMixin<CondCallDCEPass> {
+public:
+  static StringRef name() { return "CondCallDCEPass"; }
+
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+  CondCallDCEPass(bool OptimizeForSize = false)
+      : OptimizeForSize(OptimizeForSize) {}
+
+private:
+  bool OptimizeForSize;
+};
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_CONDDEADcALLELIMINATION_H

lib/Passes/PassBuilder.cpp

 #include "llvm/Transforms/Scalar/SCCP.h"
 #include "llvm/Transforms/Scalar/SROA.h"
 #include "llvm/Transforms/Scalar/SimplifyCFG.h"
 #include "llvm/Transforms/Scalar/Sink.h"
 #include "llvm/Transforms/Scalar/SpeculativeExecution.h"
 #include "llvm/Transforms/Scalar/TailRecursionElimination.h"
 #include "llvm/Transforms/Utils/AddDiscriminators.h"
 #include "llvm/Transforms/Utils/BreakCriticalEdges.h"
+#include "llvm/Transforms/Utils/CondDeadCallElimination.h"
 #include "llvm/Transforms/Utils/LCSSA.h"
 #include "llvm/Transforms/Utils/LoopSimplify.h"
 #include "llvm/Transforms/Utils/LowerInvoke.h"
 #include "llvm/Transforms/Utils/Mem2Reg.h"
 #include "llvm/Transforms/Utils/MemorySSA.h"
 #include "llvm/Transforms/Utils/NameAnonGlobals.h"
 #include "llvm/Transforms/Utils/SimplifyInstructions.h"
 #include "llvm/Transforms/Utils/SymbolRewriter.h"

lib/Passes/PassRegistry.def

 #define FUNCTION_PASS(NAME, CREATE_PASS)
 #endif
 FUNCTION_PASS("aa-eval", AAEvaluator())
 FUNCTION_PASS("adce", ADCEPass())
 FUNCTION_PASS("add-discriminators", AddDiscriminatorsPass())
 FUNCTION_PASS("alignment-from-assumptions", AlignmentFromAssumptionsPass())
 FUNCTION_PASS("bdce", BDCEPass())
 FUNCTION_PASS("break-crit-edges", BreakCriticalEdgesPass())
+FUNCTION_PASS("cond-call-dce", CondCallDCEPass())
 FUNCTION_PASS("consthoist", ConstantHoistingPass())
 FUNCTION_PASS("correlated-propagation", CorrelatedValuePropagationPass())
 FUNCTION_PASS("dce", DCEPass())
 FUNCTION_PASS("dse", DSEPass())
 FUNCTION_PASS("dot-cfg", CFGPrinterPass())
 FUNCTION_PASS("dot-cfg-only", CFGOnlyPrinterPass())
 FUNCTION_PASS("early-cse", EarlyCSEPass(/*UseMemorySSA=*/false))
 FUNCTION_PASS("early-cse-memssa", EarlyCSEPass(/*UseMemorySSA=*/true))

lib/Transforms/IPO/PassManagerBuilder.cpp

void PassManagerBuilder::addFunctionSimplificationPasses(
   MPM.add(createEarlyCSEPass());              // Catch trivial redundancies
   // Speculative execution if the target has divergent branches; otherwise nop.
   MPM.add(createSpeculativeExecutionIfHasBranchDivergencePass());
   MPM.add(createJumpThreadingPass());         // Thread jumps.
   MPM.add(createCorrelatedValuePropagationPass()); // Propagate conditionals
   MPM.add(createCFGSimplificationPass());     // Merge & remove BBs
   // Combine silly seq's
   addInstructionCombiningPass(MPM);
+  MPM.add(createCondCallDCEPass(SizeLevel > 0));
   addExtensionsToPM(EP_Peephole, MPM);
 
   MPM.add(createTailCallEliminationPass()); // Eliminate tail calls
   MPM.add(createCFGSimplificationPass());     // Merge & remove BBs
   MPM.add(createReassociatePass());           // Reassociate expressions
   // Rotate Loop - disable header duplication at -Oz
   MPM.add(createLoopRotatePass(SizeLevel == 2 ? 0 : -1));
   MPM.add(createLICMPass());                  // Hoist loop invariants

lib/Transforms/Utils/CMakeLists.txt

 add_llvm_library(LLVMTransformUtils
   ASanStackFrameLayout.cpp
   AddDiscriminators.cpp
   BasicBlockUtils.cpp
   BreakCriticalEdges.cpp
   BuildLibCalls.cpp
   BypassSlowDivision.cpp
   CloneFunction.cpp
   CloneModule.cpp
   CmpInstAnalysis.cpp
   CodeExtractor.cpp
+  CondDeadCallElimination.cpp
   CtorUtils.cpp
   DemoteRegToStack.cpp
   Evaluator.cpp
   FlattenCFG.cpp
   FunctionImportUtils.cpp
   GlobalStatus.cpp
   InlineFunction.cpp
   ImportedFunctionsInliningStatistics.cpp

lib/Transforms/Utils/CondDeadCallElimination.cpp

+//===-- CondDeadCallElimination.cpp -----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass shrink-wraps a call to function if the result is not used.
+// The call can set errno but is otherwise side effect free. For example:
+//    sqrt(val);
+//  is transformed to
+//    if (val < 0)
+//      sqrt(val);
+//  Even if the result of library call is not being used, the compiler cannot
+//  safely delete the call because the function can set errno on error
+//  conditions.
+//  Note in many functions, the error condition solely depends on the incoming
+//  parameter. In this optimization, we can generate the condition can lead to
+//  the errno to shrink-wrap the call. Since the chances of hitting the error
+//  condition is low, the runtime call is effectively eliminated.
+//
+//  These partially dead calls are usually results of C++ abstraction penalty
+//  exposed by inlining.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Transforms/Utils/CondDeadCallElimination.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/IR/CFG.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/InstVisitor.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/MDBuilder.h"
+#include "llvm/Pass.h"
+#include "llvm/Transforms/Utils/BasicBlockUtils.h"
+using namespace llvm;
+
+#define DEBUG_TYPE "cond-call-dce"
+
+STATISTIC(NumWrappedOneCond, "Number of One-Condition Wrappers Inserted");
+STATISTIC(NumWrappedTwoCond, "Number of Two-Condition Wrappers Inserted");
+STATISTIC(NumRemoved, "Number of Dead Calls Eliminated");
+
+static cl::opt<bool> CondCallDCEDisable(
+    "cond-call-dce-disable", cl::init(false), cl::Hidden,
+    cl::desc("Disable conditional call Dead Code Elimination"));
+static cl::opt<bool> DoDeleteCallNoErrNo(
+    "delete-call-no-errno", cl::init(true), cl::Hidden,
+    cl::desc(
+        "Delete lib calls that does not set errno and result not being used"));
+static cl::opt<bool> CondCallDCEDoDomainError(
+    "cond-call-dce-domain-error", cl::init(true), cl::Hidden,
+    cl::desc("Perform conditional call DCE on libs call with domain errors"));
+static cl::opt<bool> CondCallDCEDoRangeError(
+    "cond-call-dce-range-error", cl::init(true), cl::Hidden,
+    cl::desc("Perform conditional call DCE on libs call with range errors"));
+static cl::opt<bool> CondCallDCEDoPoleError(
+    "cond-call-dce-pole-error", cl::init(true), cl::Hidden,
+    cl::desc("Perform conditional call DCE on libs call with pole errors"));
+
+namespace {
+class CondCallDCELegacyPass : public FunctionPass {
+public:
+  static char ID; // Pass identification, replacement for typeid
+  explicit CondCallDCELegacyPass(bool OptForSize = false)
+      : FunctionPass(ID), OptimizeForSize(OptForSize) {
+    initializeCondCallDCELegacyPassPass(*PassRegistry::getPassRegistry());
+  }
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  bool runOnFunction(Function &F) override;
+
+private:
+  bool OptimizeForSize;
+};
+}
+
+char CondCallDCELegacyPass::ID = 0;
+INITIALIZE_PASS_BEGIN(CondCallDCELegacyPass, "cond-call-dce",
+                      "Conditionally eliminate dead library calls", false,
+                      false)
+INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
+INITIALIZE_PASS_END(CondCallDCELegacyPass, "cond-call-dce",
+                    "Conditionally eliminate dead library calls", false, false)
+
+class CondCallDCE : public InstVisitor<CondCallDCE> {
+public:
+  CondCallDCE(const TargetLibraryInfo &TLI, bool OptimizeForSize)
+      : TLI(TLI), OptimizeForSize(OptimizeForSize), Changed(false){};
+  bool isChanged() const { return Changed; }
+  void visitCallInst(CallInst &CI) { checkCandidate(CI); }
+  void perform() {
+    for (auto &CI : WorkList) {
+      DEBUG(dbgs() << "CDCE calls: " << CI->getCalledFunction()->getName()
+                   << "\n");
+      if (perform(CI)) {
+        Changed = true;
+        DEBUG(dbgs() << "Transformed\n");
+      }
+    }
+  }
+
+private:
+  bool perform(CallInst *CI);
+  void checkCandidate(CallInst &CI);
+  void shrinkWrapCI(CallInst *CI, Value *Cond);
+  bool performCallNoErrNo(CallInst *CI, const LibFunc::Func &Func);
+  bool performCallDomainErrorOnly(CallInst *CI, const LibFunc::Func &Func);
+  bool performCallErrors(CallInst *CI, const LibFunc::Func &Func);
+  bool performCallRangeErrorOnly(CallInst *CI, const LibFunc::Func &Func);
+  Value *generateOneRangeCond(CallInst *CI, const LibFunc::Func &Func);
+  Value *generateTwoRangeCond(CallInst *CI, const LibFunc::Func &Func);
+  Value *generateCondForPow(CallInst *CI, const LibFunc::Func &Func);
+
+  // Create an OR of two conditions.
+  Value *createOrCond(CallInst *CI, CmpInst::Predicate Cmp, float Val,
+                      CmpInst::Predicate Cmp2, float Val2) {
+    IRBuilder<> BBBuilder(CI);
+    Value *Arg = CI->getArgOperand(0);
+    auto Cond2 = createCond(BBBuilder, Arg, Cmp2, Val2);
+    auto Cond1 = createCond(BBBuilder, Arg, Cmp, Val);
+    return BBBuilder.CreateOr(Cond1, Cond2);
+  }
+
+  // Create a single condition using IRBuilder.
+  Value *createCond(IRBuilder<> &BBBuilder, Value *Arg, CmpInst::Predicate Cmp,
+                    float Val) {
+    Constant *V = ConstantFP::get(BBBuilder.getContext(), APFloat(Val));
+    if (!Arg->getType()->isFloatTy())
+      V = ConstantExpr::getFPExtend(V, Arg->getType());
+    return BBBuilder.CreateFCmp(Cmp, Arg, V);
+  }
+
+  // Create a single condition.
+  Value *createCond(CallInst *CI, CmpInst::Predicate Cmp, float Val) {
+    IRBuilder<> BBBuilder(CI);
+    Value *Arg = CI->getArgOperand(0);
+    return createCond(BBBuilder, Arg, Cmp, Val);
+  }
+
+  const TargetLibraryInfo &TLI;
+  SmallVector<CallInst *, 16> WorkList;
+  bool OptimizeForSize;
+  bool Changed;
+};
+
+// Remove calls that having no side effects.
+bool CondCallDCE::performCallNoErrNo(CallInst *CI, const LibFunc::Func &Func) {
+  switch (Func) {
+  case LibFunc::asinh:
+  case LibFunc::asinhf:
+  case LibFunc::asinhl:
+  case LibFunc::atan:
+  case LibFunc::atanf:
+  case LibFunc::atanl:
+  case LibFunc::cbrt:
+  case LibFunc::cbrtf:
+  case LibFunc::cbrtl:
+  case LibFunc::tanh:
+  case LibFunc::tanhf:
+  case LibFunc::tanhl:
+  // The following functions seem already being marked by FE.
+  case LibFunc::ceil:
+  case LibFunc::ceilf:
+  case LibFunc::ceill:
+  case LibFunc::copysign:
+  case LibFunc::copysignf:
+  case LibFunc::copysignl:
+  case LibFunc::fabs:
+  case LibFunc::fabsf:
+  case LibFunc::fabsl:
+  case LibFunc::floor:
+  case LibFunc::floorf:
+  case LibFunc::floorl:
+  case LibFunc::fmax:
+  case LibFunc::fmaxf:
+  case LibFunc::fmaxl:
+  case LibFunc::fmin:
+  case LibFunc::fminf:
+  case LibFunc::fminl:
+  case LibFunc::nearbyint:
+  case LibFunc::nearbyintf:
+  case LibFunc::nearbyintl:
+  case LibFunc::rint:
+  case LibFunc::rintf:
+  case LibFunc::rintl:
+  case LibFunc::round:
+  case LibFunc::roundf:
+  case LibFunc::roundl:
+  case LibFunc::trunc:
+  case LibFunc::truncf:
+  case LibFunc::truncl: {
+    ++NumRemoved;
+    CI->eraseFromParent();
+    return true;
+  }
+  default:
+    return false;
+  }
+}
+
+// Perform the transformation to calls with errno set by domain error.
+bool CondCallDCE::performCallDomainErrorOnly(CallInst *CI,
+                                             const LibFunc::Func &Func) {
+  Value *Cond = nullptr;
+
+  switch (Func) {
+  case LibFunc::acos:  // DomainError: (x < -1 || x > 1)
+  case LibFunc::acosf: // Same as acos
+  case LibFunc::acosl: // Same as acos
+  case LibFunc::asin:  // DomainError: (x < -1 || x > 1)
+  case LibFunc::asinf: // Same as asin
+  case LibFunc::asinl: // Same as asin
+  {
+    ++NumWrappedTwoCond;
+    Cond = createOrCond(CI, CmpInst::FCMP_OLT, -1.0f, CmpInst::FCMP_OGT, 1.0f);
+    break;
+  }
+  case LibFunc::cos:  // DomainError: (x == +inf || x == -inf)
+  case LibFunc::cosf: // Same as cos
+  case LibFunc::cosl: // Same as cos
+  case LibFunc::sin:  // DomainError: (x == +inf || x == -inf)
+  case LibFunc::sinf: // Same as sin
+  case LibFunc::sinl: // Same as sin
+  {
+    ++NumWrappedTwoCond;
+    Cond = createOrCond(CI, CmpInst::FCMP_OEQ, INFINITY, CmpInst::FCMP_OEQ,
+                        -INFINITY);
+    break;
+  }
+  case LibFunc::acosh:  // DomainError: (x < 1)
+  case LibFunc::acoshf: // Same as acosh
+  case LibFunc::acoshl: // Same as acosh
+  {
+    ++NumWrappedOneCond;
+    Cond = createCond(CI, CmpInst::FCMP_OLT, 1.0f);
+    break;
+  }
+  case LibFunc::sqrt:  // DomainError: (x < 0)
+  case LibFunc::sqrtf: // Same as sqrt
+  case LibFunc::sqrtl: // Same as sqrt
+  {
+    ++NumWrappedOneCond;
+    Cond = createCond(CI, CmpInst::FCMP_OLT, 0.0f);
+    break;
+  }
+  default:
+    return false;
+  }
+  assert(Cond != nullptr);
+  shrinkWrapCI(CI, Cond);
+  return true;
+}
+
+// Perform the transformation to calls with errno set by range error.
+bool CondCallDCE::performCallRangeErrorOnly(CallInst *CI,
+                                            const LibFunc::Func &Func) {
+  Value *Cond = nullptr;
+
+  switch (Func) {
+  case LibFunc::cosh:
+  case LibFunc::coshf:
+  case LibFunc::coshl:
+  case LibFunc::exp:
+  case LibFunc::expf:
+  case LibFunc::expl:
+  case LibFunc::exp10:
+  case LibFunc::exp10f:
+  case LibFunc::exp10l:
+  case LibFunc::exp2:
+  case LibFunc::exp2f:
+  case LibFunc::exp2l:
+  case LibFunc::sinh:
+  case LibFunc::sinhf:
+  case LibFunc::sinhl: {
+    Cond = generateTwoRangeCond(CI, Func);
+    break;
+  }
+  case LibFunc::expm1:  // RangeError: (709, inf)
+  case LibFunc::expm1f: // RangeError: (88, inf)
+  case LibFunc::expm1l: // RangeError: (11356, inf)
+  {
+    Cond = generateOneRangeCond(CI, Func);
+    break;
+  }
+  default:
+    return false;
+  }
+  assert(Cond != nullptr);
+  shrinkWrapCI(CI, Cond);
+  return true;
+}
+
+// Perform the transformation to calls with errno set by combination of errors.
+bool CondCallDCE::performCallErrors(CallInst *CI, const LibFunc::Func &Func) {
+  Value *Cond = nullptr;
+
+  switch (Func) {
+  case LibFunc::atanh:  // DomainError: (x < -1 || x > 1)
+                        // PoleError:   (x == -1 || x == 1)
+                        // Overall Cond: (x <= -1 || x >= 1)
+  case LibFunc::atanhf: // Same as atanh
+  case LibFunc::atanhl: // Same as atanh
+  {
+    if (!CondCallDCEDoDomainError || !CondCallDCEDoPoleError)
+      return false;
+    ++NumWrappedTwoCond;
+    Cond = createOrCond(CI, CmpInst::FCMP_OLE, -1.0f, CmpInst::FCMP_OGE, 1.0f);
+    break;
+  }
+  case LibFunc::log:    // DomainError: (x < 0)
+                        // PoleError:   (x == 0)
+                        // Overall Cond: (x <= 0)
+  case LibFunc::logf:   // Same as log
+  case LibFunc::logl:   // Same as log
+  case LibFunc::log10:  // Same as log
+  case LibFunc::log10f: // Same as log
+  case LibFunc::log10l: // Same as log
+  case LibFunc::log2:   // Same as log
+  case LibFunc::log2f:  // Same as log
+  case LibFunc::log2l:  // Same as log
+  case LibFunc::logb:   // Same as log
+  case LibFunc::logbf:  // Same as log
+  case LibFunc::logbl:  // Same as log
+  {
+    if (!CondCallDCEDoDomainError || !CondCallDCEDoPoleError)
+      return false;
+    ++NumWrappedOneCond;
+    Cond = createCond(CI, CmpInst::FCMP_OLE, 0.0f);
+    break;
+  }
+  case LibFunc::log1p:  // DomainError: (x < -1)
+                        // PoleError:   (x == -1)
+                        // Overall Cond: (x <= -1)
+  case LibFunc::log1pf: // Same as log1p
+  case LibFunc::log1pl: // Same as log1p
+  {
+    if (!CondCallDCEDoDomainError || !CondCallDCEDoPoleError)
+      return false;
+    ++NumWrappedOneCond;
+    Cond = createCond(CI, CmpInst::FCMP_OLE, -1.0f);
+    break;
+  }
+  case LibFunc::pow: // DomainError: x < 0 and y is noninteger
+                     // PoleError:   x == 0 and y < 0
+                     // RangeError:  overflow or underflow
+  case LibFunc::powf:
+  case LibFunc::powl: {
+    if (!CondCallDCEDoDomainError || !CondCallDCEDoPoleError ||
+        !CondCallDCEDoRangeError)
+      return false;
+    Cond = generateCondForPow(CI, Func);
+    if (Cond == nullptr)
+      return false;
+    break;
+  }
+  default:
+    return false;
+  }
+  assert(Cond != nullptr);
+  shrinkWrapCI(CI, Cond);
+  return true;
+}
+
+// Checks if CI is a candidate for shrinkwrapping and put it into work list if
+// true.
+void CondCallDCE::checkCandidate(CallInst &CI) {
+  if (CI.isNoBuiltin())
+    return;
+  // A possible improvement is to handle the calls with return valued being
+  // used, if there is API for fast libcall implementation (without setting
+  // errno). We can use the same framework to direct calls that known
+  // errno-free to the new API calls.
+  if (!CI.use_empty())
+    return;
+
+  LibFunc::Func Func;
+  Function *Callee = CI.getCalledFunction();
+  if (!Callee)
+    return;
+  if (!TLI.getLibFunc(*Callee, Func) || !TLI.has(Func))
+    return;
+  if (CI.getCallingConv() != llvm::CallingConv::C)
+    return;
+  WorkList.push_back(&CI);
+}
+
+// Generate the upper bound condition for RangeError.
+Value *CondCallDCE::generateOneRangeCond(CallInst *CI,
+                                         const LibFunc::Func &Func) {
+  float UpperBound;
+  switch (Func) {
+  case LibFunc::expm1: // RangeError: (709, inf)
+    UpperBound = 709.0f;
+    break;
+  case LibFunc::expm1f: // RangeError: (88, inf)
+    UpperBound = 88.0f;
+    break;
+  case LibFunc::expm1l: // RangeError: (11356, inf)
+    UpperBound = 11356.0f;
+    break;
+  default:
+    llvm_unreachable("Should be reach here");
+  }
+
+  ++NumWrappedOneCond;
+  return createCond(CI, CmpInst::FCMP_OGT, UpperBound);
+}
+
+// Generate the lower and upper bound condition for RangeError.
+Value *CondCallDCE::generateTwoRangeCond(CallInst *CI,
+                                         const LibFunc::Func &Func) {
+  float UpperBound, LowerBound;
+  switch (Func) {
+  case LibFunc::cosh: // RangeError: (x < -710 || x > 710)
+  case LibFunc::sinh: // Same as cosh
+    LowerBound = -710.0f;
+    UpperBound = 710.0f;
+    break;
+  case LibFunc::coshf: // RangeError: (x < -89 || x > 89)
+  case LibFunc::sinhf: // Same as coshf
+    LowerBound = -89.0f;
+    UpperBound = 89.0f;
+    break;
+  case LibFunc::coshl: // RangeError: (x < -11357 || x > 11357)
+  case LibFunc::sinhl: // Same as coshl
+    LowerBound = -11357.0f;
+    UpperBound = 11357.0f;
+    break;
+  case LibFunc::exp: // RangeError: (x < -745 || x > 709)
+    LowerBound = -745.0f;
+    UpperBound = 709.0f;
+    break;
+  case LibFunc::expf: // RangeError: (x < -103 || x > 88)
+    LowerBound = -103.0f;
+    UpperBound = 88.0f;
+    break;
+  case LibFunc::expl: // RangeError: (x < -11399 || x > 11356)
+    LowerBound = -11399.0f;
+    UpperBound = 11356.0f;
+    break;
+  case LibFunc::exp10: // RangeError: (x < -323 || x > 308)
+    LowerBound = -323.0f;
+    UpperBound = 308.0f;
+    break;
+  case LibFunc::exp10f: // RangeError: (x < -45 || x > 38)
+    LowerBound = -45.0f;
+    UpperBound = 38.0f;
+    break;
+  case LibFunc::exp10l: // RangeError: (x < -4950 || x > 4932)
+    LowerBound = -4950.0f;
+    UpperBound = 4932.0f;
+    break;
+  case LibFunc::exp2: // RangeError: (x < -1074 || x > 1023)
+    LowerBound = -1074.0f;
+    UpperBound = 1023.0f;
+    break;
+  case LibFunc::exp2f: // RangeError: (x < -149 || x > 127)
+    LowerBound = -149.0f;
+    UpperBound = 127.0f;
+    break;
+  case LibFunc::exp2l: // RangeError: (x < -16445 || x > 11383)
+    LowerBound = -16445.0f;
+    UpperBound = 11383.0f;
+    break;
+  default:
+    llvm_unreachable("Should be reach here");
+  }
+
+  ++NumWrappedTwoCond;
+  return createOrCond(CI, CmpInst::FCMP_OGT, UpperBound, CmpInst::FCMP_OLT,
+                      LowerBound);
+}
+
+// For pow(x,y), We only handle the following cases:
+// (1) x is a constant && (x >= 1) && (x < MaxUInt8)
+//     Cond is: (y > 127)
+// (2) x is a value coming from an integer type.
+//   (2.1) if x's bit_size == 8
+//         Cond: (x <= 0 || y > 128)
+//   (2.2) if x's bit_size is 16
+//         Cond: (x <= 0 || y > 64)
+//   (2.3) if x's bit_size is 32
+//         Cond: (x <= 0 || y > 32)
+// Support for powl(x,y) and powf(x,y) are TBD.
+//
+// Note that condition can be more conservative than the actual condition
+// (i.e. we might invoke the calls that will not set the errno.).
+//
+Value *CondCallDCE::generateCondForPow(CallInst *CI,
+                                       const LibFunc::Func &Func) {
+  // FIXME: LibFunc::powf and powl TBD.
+  if (Func != LibFunc::pow) {
+    DEBUG(dbgs() << "Not handled powf() and powl()\n");
+    return nullptr;
+  }
+
+  Value *Base = CI->getArgOperand(0);
+  Value *Exp = CI->getArgOperand(1);
+  IRBuilder<> BBBuilder(CI);
+
+  // Constant Base case.
+  if (ConstantFP *CF = dyn_cast<ConstantFP>(Base)) {
+    double D = CF->getValueAPF().convertToDouble();
+    if (D < 1.0f || D > APInt::getMaxValue(8).getZExtValue()) {
+      DEBUG(dbgs() << "Not handled pow(): constant base out of range\n");
+      return nullptr;
+    }
+
+    ++NumWrappedOneCond;
+    Constant *V = ConstantFP::get(CI->getContext(), APFloat(127.0f));
+    if (!Exp->getType()->isFloatTy())
+      V = ConstantExpr::getFPExtend(V, Exp->getType());
+    return BBBuilder.CreateFCmp(CmpInst::FCMP_OGT, Exp, V);
+  }
+
+  // If the Base value coming from an integer type.
+  Instruction *I = dyn_cast<Instruction>(Base);
+  if (!I) {
+    DEBUG(dbgs() << "Not handled pow(): FP type base\n");
+    return nullptr;
+  }
+  unsigned Opcode = I->getOpcode();
+  if (Opcode == Instruction::UIToFP || Opcode == Instruction::SIToFP) {
+    unsigned BW = I->getOperand(0)->getType()->getPrimitiveSizeInBits();
+    float UpperV = 0.0f;
+    if (BW == 8)
+      UpperV = 128.0f;
+    else if (BW == 16)
+      UpperV = 64.0f;
+    else if (BW == 32)
+      UpperV = 32.0f;
+    else {
+      DEBUG(dbgs() << "Not handled pow(): type too wide\n");
+      return nullptr;
+    }
+
+    ++NumWrappedTwoCond;
+    Constant *V = ConstantFP::get(CI->getContext(), APFloat(UpperV));
+    Constant *V0 = ConstantFP::get(CI->getContext(), APFloat(0.0f));
+    if (!Exp->getType()->isFloatTy())
+      V = ConstantExpr::getFPExtend(V, Exp->getType());
+    if (!Base->getType()->isFloatTy())
+      V0 = ConstantExpr::getFPExtend(V0, Exp->getType());
+
+    Value *Cond = BBBuilder.CreateFCmp(CmpInst::FCMP_OGT, Exp, V);
+    Value *Cond0 = BBBuilder.CreateFCmp(CmpInst::FCMP_OLE, Base, V0);
+    return BBBuilder.CreateOr(Cond0, Cond);
+  }
+  DEBUG(dbgs() << "Not handled pow(): base not from integer convert\n");
+  return nullptr;
+}
+
+// Wrap conditions that can potentially generate errno to the library call.
+void CondCallDCE::shrinkWrapCI(CallInst *CI, Value *Cond) {
+  MDNode *BranchWeights =
+      MDBuilder(CI->getContext()).createBranchWeights(1, 2000);
+  TerminatorInst *NewInst =
+      SplitBlockAndInsertIfThen(Cond, CI, false, BranchWeights);
+  BasicBlock *CallBB = NewInst->getParent();
+  CallBB->setName("cdce.call");
+  CallBB->getSingleSuccessor()->setName("cdce.end");
+  CI->removeFromParent();
+  CallBB->getInstList().insert(CallBB->getFirstInsertionPt(), CI);
+  DEBUG(dbgs() << "== Basic Block After ==");
+  DEBUG(dbgs() << *CallBB->getSinglePredecessor() << *CallBB
+               << *CallBB->getSingleSuccessor() << "\n");
+}
+
+// Perform the transformation to a single candidate.
+bool CondCallDCE::perform(CallInst *CI) {
+  LibFunc::Func Func;
+  Function *Callee = CI->getCalledFunction();
+  assert(Callee);
+  TLI.getLibFunc(*Callee, Func);
+  assert(Func);
+
+  if (DoDeleteCallNoErrNo && performCallNoErrNo(CI, Func))
+    return true;
+
+  if (OptimizeForSize)
+    return false;
+
+  if (CondCallDCEDoDomainError && performCallDomainErrorOnly(CI, Func))
+    return true;
+
+  if (CondCallDCEDoRangeError && performCallRangeErrorOnly(CI, Func))
+    return true;
+
+  return performCallErrors(CI, Func);
+}
+
+void CondCallDCELegacyPass::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.setPreservesCFG();
+  AU.addRequired<TargetLibraryInfoWrapperPass>();
+}
+
+bool runImpl(Function &F, const TargetLibraryInfo &TLI,
+             bool OptForSize = false) {
+  if (CondCallDCEDisable)
+    return false;
+  if (F.hasFnAttribute(Attribute::OptimizeForSize))
+    OptForSize = true;
+  CondCallDCE CCDCE(TLI, OptForSize);
+  CCDCE.visit(F);
+  CCDCE.perform();
+  return CCDCE.isChanged();
+}
+
+bool CondCallDCELegacyPass::runOnFunction(Function &F) {
+  auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
+  return runImpl(F, TLI, OptimizeForSize);
+}
+
+namespace llvm {
+char &CondCallDCEPassID = CondCallDCELegacyPass::ID;
+
+// Public interface to CondCallDCE pass.
+FunctionPass *createCondCallDCEPass(bool OptimizeForSize) {
+  return new CondCallDCELegacyPass(OptimizeForSize);
+}
+
+PreservedAnalyses CondCallDCEPass::run(Function &F,
+                                       FunctionAnalysisManager &FAM) {
+  auto &TLI = FAM.getResult<TargetLibraryAnalysis>(F);
+  bool Changed = runImpl(F, TLI, OptimizeForSize);
+  if (!Changed)
+    return PreservedAnalyses::all();
+  return PreservedAnalyses::none();
+}
+}

lib/Transforms/Utils/Utils.cpp

 using namespace llvm;
 
 /// initializeTransformUtils - Initialize all passes in the TransformUtils
 /// library.
 void llvm::initializeTransformUtils(PassRegistry &Registry) {
   initializeAddDiscriminatorsLegacyPassPass(Registry);
   initializeBreakCriticalEdgesPass(Registry);
   initializeInstNamerPass(Registry);
+  initializeCondCallDCELegacyPassPass(Registry);
   initializeLCSSAWrapperPassPass(Registry);
   initializeLoopSimplifyPass(Registry);
   initializeLowerInvokeLegacyPassPass(Registry);
   initializeLowerSwitchPass(Registry);
   initializeNameAnonGlobalLegacyPassPass(Registry);
   initializePromoteLegacyPassPass(Registry);
   initializeUnifyFunctionExitNodesPass(Registry);
   initializeInstSimplifierPass(Registry);

test/Transforms/Util/cond-call-dce-double.ll

+; RUN: opt < %s -cond-call-dce -S | FileCheck %s
+; New PM
+; RUN: opt < %s -passes=cond-call-dce -S | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define void @test_delete(double %value) {
+entry:
+  %call_00 = call double @asinh(double %value)
+  %call_01 = call double @atan(double %value)
+  %call_02 = call double @cbrt(double %value)
+  %call_03 = call double @tanh(double %value)
+  %call_04 = call double @ceil(double %value)
+  %call_05 = call double @copysign(double %value, double 1.000000e+01)
+  %call_06 = call double @fabs(double %value)
+  %call_07 = call double @floor(double %value)
+  %call_08 = call double @fmax(double %value, double 1.000000e+01)
+  %call_09 = call double @fmin(double %value, double 1.000000e+01)
+  %call_10 = call double @nearbyint(double %value)
+  %call_11 = call double @rint(double %value)
+  %call_12 = call double @round(double %value)
+  %call_13 = call double @trunc(double %value)
+; CHECK: entry:
+; CHECK-NEXT: ret void
+  ret void
+}
+
+declare double @asinh(double)
+declare double @atan(double)
+declare double @cbrt(double)
+declare double @tanh(double)
+declare double @ceil(double)
+declare double @copysign(double, double)
+declare double @fabs(double)
+declare double @floor(double)
+declare double @fmax(double, double)
+declare double @fmin(double, double)
+declare double @nearbyint(double)
+declare double @rint(double)
+declare double @round(double)
+declare double @trunc(double)
+
+define void @test_range_error(double %value) {
+entry:
+  %call_0 = call double @cosh(double %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp olt double %value, -7.100000e+02
+; CHECK: [[COND2:%[0-9]+]] = fcmp ogt double %value, 7.100000e+02
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_0 = call double @cosh(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_1 = call double @exp(double %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp olt double %value, -7.450000e+02
+; CHECK: [[COND2:%[0-9]+]] = fcmp ogt double %value, 7.090000e+02
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_1 = call double @exp(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_3 = call double @exp2(double %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp olt double %value, -1.074000e+03
+; CHECK: [[COND2:%[0-9]+]] = fcmp ogt double %value, 1.023000e+03
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_3 = call double @exp2(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_4 = call double @sinh(double %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp olt double %value, -7.100000e+02
+; CHECK: [[COND2:%[0-9]+]] = fcmp ogt double %value, 7.100000e+02
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_4 = call double @sinh(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_5 = call double @expm1(double %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ogt double %value, 7.090000e+02
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_5 = call double @expm1(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  ret void
+}
+
+declare double @cosh(double)
+declare double @exp(double)
+declare double @exp2(double)
+declare double @sinh(double)
+declare double @expm1(double)
+
+define void @test_domain_error(double %value) {
+entry:
+  %call_00 = call double @acos(double %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp ogt double %value, 1.000000e+00
+; CHECK: [[COND2:%[0-9]+]] = fcmp olt double %value, -1.000000e+00
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_00 = call double @acos(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_01 = call double @asin(double %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp ogt double %value, 1.000000e+00
+; CHECK: [[COND2:%[0-9]+]] = fcmp olt double %value, -1.000000e+00
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_01 = call double @asin(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_02 = call double @cos(double %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp oeq double %value, 0xFFF0000000000000
+; CHECK: [[COND2:%[0-9]+]] = fcmp oeq double %value, 0x7FF0000000000000
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_02 = call double @cos(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_03 = call double @sin(double %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp oeq double %value, 0xFFF0000000000000
+; CHECK: [[COND2:%[0-9]+]] = fcmp oeq double %value, 0x7FF0000000000000
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_03 = call double @sin(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_04 = call double @acosh(double %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp olt double %value, 1.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_04 = call double @acosh(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_05 = call double @sqrt(double %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp olt double %value, 0.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_05 = call double @sqrt(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_06 = call double @atanh(double %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp oge double %value, 1.000000e+00
+; CHECK: [[COND2:%[0-9]+]] = fcmp ole double %value, -1.000000e+00
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_06 = call double @atanh(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_07 = call double @log(double %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole double %value, 0.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_07 = call double @log(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_08 = call double @log10(double %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole double %value, 0.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_08 = call double @log10(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_09 = call double @log2(double %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole double %value, 0.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_09 = call double @log2(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_10 = call double @logb(double %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole double %value, 0.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_10 = call double @logb(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_11 = call double @log1p(double %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole double %value, -1.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_11 = call double @log1p(double %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  ret void
+}
+
+declare double @acos(double)
+declare double @asin(double)
+declare double @cos(double)
+declare double @sin(double)
+declare double @acosh(double)
+declare double @sqrt(double)
+declare double @atanh(double)
+declare double @log(double)
+declare double @log10(double)
+declare double @log2(double)
+declare double @logb(double)
+declare double @log1p(double)
+
+define void @test_pow(i32 %int_val, double %exp) {
+  %call = call double @pow(double 2.500000e+00, double %exp)
+; CHECK: [[COND:%[0-9]+]] = fcmp ogt double %exp, 1.270000e+02
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call = call double @pow(double 2.500000e+00, double %exp)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %conv = sitofp i32 %int_val to double
+  %call1 = call double @pow(double %conv, double %exp)
+; CHECK: [[COND1:%[0-9]+]] = fcmp ogt double %exp, 3.200000e+01
+; CHECK: [[COND2:%[0-9]+]] = fcmp ole double %conv, 0.000000e+00
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call1 = call double @pow(double %conv, double %exp)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %conv2 = trunc i32 %int_val to i8
+  %conv3 = uitofp i8 %conv2 to double
+  %call4 = call double @pow(double %conv3, double %exp)
+; CHECK: [[COND1:%[0-9]+]] = fcmp ogt double %exp, 1.280000e+02
+; CHECK: [[COND2:%[0-9]+]] = fcmp ole double %conv3, 0.000000e+00
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call4 = call double @pow(double %conv3, double %exp)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+
+  %conv5 = trunc i32 %int_val to i16
+  %conv6 = uitofp i16 %conv5 to double
+  %call7 = call double @pow(double %conv6, double %exp)
+; CHECK: [[COND1:%[0-9]+]] = fcmp ogt double %exp, 6.400000e+01
+; CHECK: [[COND2:%[0-9]+]] = fcmp ole double %conv6, 0.000000e+00
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call7 = call double @pow(double %conv6, double %exp)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  ret void
+}
+
+declare double @pow(double, double)
+
+; CHECK: ![[BRANCH_WEIGHT]] = !{!"branch_weights", i32 1, i32 2000}

test/Transforms/Util/cond-call-dce-float.ll

+; RUN: opt < %s -cond-call-dce -S | FileCheck %s
+; New PM
+; RUN: opt < %s -passes=cond-call-dce -S | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define void @test_delete(float %value) {
+entry:
+  %call_00 = call float @asinhf(float %value)
+  %call_01 = call float @atanf(float %value)
+  %call_02 = call float @cbrtf(float %value)
+  %call_03 = call float @tanhf(float %value)
+  %call_04 = call float @ceilf(float %value)
+  %call_05 = call float @copysignf(float %value, float 1.000000e+01)
+  %call_06 = call float @fabsf(float %value)
+  %call_07 = call float @floorf(float %value)
+  %call_08 = call float @fmaxf(float %value, float 1.000000e+01)
+  %call_09 = call float @fminf(float %value, float 1.000000e+01)
+  %call_10 = call float @nearbyintf(float %value)
+  %call_11 = call float @rintf(float %value)
+  %call_12 = call float @roundf(float %value)
+  %call_13 = call float @truncf(float %value)
+; CHECK: entry:
+; CHECK-NEXT: ret void
+  ret void
+}
+
+declare float @asinhf(float)
+declare float @atanf(float)
+declare float @cbrtf(float)
+declare float @tanhf(float)
+declare float @ceilf(float)
+declare float @copysignf(float, float)
+declare float @fabsf(float)
+declare float @floorf(float)
+declare float @fmaxf(float, float)
+declare float @fminf(float, float)
+declare float @nearbyintf(float)
+declare float @rintf(float)
+declare float @roundf(float)
+declare float @truncf(float)
+
+define void @test_range_error(float %value) {
+entry:
+  %call_0 = call float @coshf(float %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp olt float %value, -8.900000e+01
+; CHECK: [[COND2:%[0-9]+]] = fcmp ogt float %value, 8.900000e+01
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_0 = call float @coshf(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_1 = call float @expf(float %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp olt float %value, -1.030000e+02
+; CHECK: [[COND2:%[0-9]+]] = fcmp ogt float %value, 8.800000e+01
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_1 = call float @expf(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_3 = call float @exp2f(float %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp olt float %value, -1.490000e+02
+; CHECK: [[COND2:%[0-9]+]] = fcmp ogt float %value, 1.270000e+02
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_3 = call float @exp2f(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_4 = call float @sinhf(float %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp olt float %value, -8.900000e+01
+; CHECK: [[COND2:%[0-9]+]] = fcmp ogt float %value, 8.900000e+01
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_4 = call float @sinhf(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_5 = call float @expm1f(float %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ogt float %value, 8.800000e+01
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_5 = call float @expm1f(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  ret void
+}
+
+declare float @coshf(float)
+declare float @expf(float)
+declare float @exp2f(float)
+declare float @sinhf(float)
+declare float @expm1f(float)
+
+define void @test_domain_error(float %value) {
+entry:
+
+  %call_00 = call float @acosf(float %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp ogt float %value, 1.000000e+00
+; CHECK: [[COND2:%[0-9]+]] = fcmp olt float %value, -1.000000e+00
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_00 = call float @acosf(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_01 = call float @asinf(float %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp ogt float %value, 1.000000e+00
+; CHECK: [[COND2:%[0-9]+]] = fcmp olt float %value, -1.000000e+00
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_01 = call float @asinf(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_02 = call float @cosf(float %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp oeq float %value, 0xFFF0000000000000
+; CHECK: [[COND2:%[0-9]+]] = fcmp oeq float %value, 0x7FF0000000000000
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_02 = call float @cosf(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_03 = call float @sinf(float %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp oeq float %value, 0xFFF0000000000000
+; CHECK: [[COND2:%[0-9]+]] = fcmp oeq float %value, 0x7FF0000000000000
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_03 = call float @sinf(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_04 = call float @acoshf(float %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp olt float %value, 1.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_04 = call float @acoshf(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_05 = call float @sqrtf(float %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp olt float %value, 0.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_05 = call float @sqrtf(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_06 = call float @atanhf(float %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp oge float %value, 1.000000e+00
+; CHECK: [[COND2:%[0-9]+]] = fcmp ole float %value, -1.000000e+00
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_06 = call float @atanhf(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_07 = call float @logf(float %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole float %value, 0.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_07 = call float @logf(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_08 = call float @log10f(float %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole float %value, 0.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_08 = call float @log10f(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_09 = call float @log2f(float %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole float %value, 0.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_09 = call float @log2f(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_10 = call float @logbf(float %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole float %value, 0.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_10 = call float @logbf(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_11 = call float @log1pf(float %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole float %value, -1.000000e+00
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_11 = call float @log1pf(float %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+  ret void
+}
+
+declare float @acosf(float)
+declare float @asinf(float)
+declare float @cosf(float)
+declare float @sinf(float)
+declare float @acoshf(float)
+declare float @sqrtf(float)
+declare float @atanhf(float)
+declare float @logf(float)
+declare float @log10f(float)
+declare float @log2f(float)
+declare float @logbf(float)
+declare float @log1pf(float)
+
+; CHECK: ![[BRANCH_WEIGHT]] = !{!"branch_weights", i32 1, i32 2000}

test/Transforms/Util/cond-call-dce-long-double.ll

+; RUN: opt < %s -cond-call-dce -S | FileCheck %s
+; New PM
+; RUN: opt < %s -passes=cond-call-dce -S | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define void @test_delete(x86_fp80 %value) {
+entry:
+  %call_00 = call x86_fp80 @asinhl(x86_fp80 %value)
+  %call_01 = call x86_fp80 @atanl(x86_fp80 %value)
+  %call_02 = call x86_fp80 @cbrtl(x86_fp80 %value)
+  %call_03 = call x86_fp80 @tanhl(x86_fp80 %value)
+  %call_04 = call x86_fp80 @ceill(x86_fp80 %value)
+  %call_05 = call x86_fp80 @copysignl(x86_fp80 %value, x86_fp80 0xK4002A000000000000000)
+  %call_06 = call x86_fp80 @fabsl(x86_fp80 %value)
+  %call_07 = call x86_fp80 @floorl(x86_fp80 %value)
+  %call_08 = call x86_fp80 @fmaxl(x86_fp80 %value, x86_fp80 0xK4002A000000000000000)
+  %call_09 = call x86_fp80 @fminl(x86_fp80 %value, x86_fp80 0xK4002A000000000000000)
+  %call_10 = call x86_fp80 @nearbyintl(x86_fp80 %value)
+  %call_11 = call x86_fp80 @rintl(x86_fp80 %value)
+  %call_12 = call x86_fp80 @roundl(x86_fp80 %value)
+  %call_13 = call x86_fp80 @truncl(x86_fp80 %value)
+; CHECK: entry:
+; CHECK-NEXT: ret void
+  ret void
+}
+
+declare x86_fp80 @asinhl(x86_fp80)
+declare x86_fp80 @atanl(x86_fp80)
+declare x86_fp80 @cbrtl(x86_fp80)
+declare x86_fp80 @tanhl(x86_fp80)
+declare x86_fp80 @ceill(x86_fp80)
+declare x86_fp80 @copysignl(x86_fp80, x86_fp80)
+declare x86_fp80 @fabsl(x86_fp80)
+declare x86_fp80 @floorl(x86_fp80)
+declare x86_fp80 @fmaxl(x86_fp80, x86_fp80)
+declare x86_fp80 @fminl(x86_fp80, x86_fp80)
+declare x86_fp80 @nearbyintl(x86_fp80)
+declare x86_fp80 @rintl(x86_fp80)
+declare x86_fp80 @roundl(x86_fp80)
+declare x86_fp80 @truncl(x86_fp80)
+
+define void @test_range_error(x86_fp80 %value) {
+entry:
+  %call_0 = call x86_fp80 @coshl(x86_fp80 %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp olt x86_fp80 %value, 0xKC00CB174000000000000
+; CHECK: [[COND2:%[0-9]+]] = fcmp ogt x86_fp80 %value, 0xK400CB174000000000000
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_0 = call x86_fp80 @coshl(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_1 = call x86_fp80 @expl(x86_fp80 %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp olt x86_fp80 %value, 0xKC00CB21C000000000000
+; CHECK: [[COND2:%[0-9]+]] = fcmp ogt x86_fp80 %value, 0xK400CB170000000000000
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_1 = call x86_fp80 @expl(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_3 = call x86_fp80 @exp2l(x86_fp80 %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp olt x86_fp80 %value, 0xKC00D807A000000000000
+; CHECK: [[COND2:%[0-9]+]] = fcmp ogt x86_fp80 %value, 0xK400CB1DC000000000000
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_3 = call x86_fp80 @exp2l(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_4 = call x86_fp80 @sinhl(x86_fp80 %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp olt x86_fp80 %value, 0xKC00CB174000000000000
+; CHECK: [[COND2:%[0-9]+]] = fcmp ogt x86_fp80 %value, 0xK400CB174000000000000
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_4 = call x86_fp80 @sinhl(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_5 = call x86_fp80 @expm1l(x86_fp80 %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ogt x86_fp80 %value, 0xK400CB170000000000000
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_5 = call x86_fp80 @expm1l(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  ret void
+}
+
+declare x86_fp80 @coshl(x86_fp80)
+declare x86_fp80 @expl(x86_fp80)
+declare x86_fp80 @exp10l(x86_fp80)
+declare x86_fp80 @exp2l(x86_fp80)
+declare x86_fp80 @sinhl(x86_fp80)
+declare x86_fp80 @expm1l(x86_fp80)
+
+define void @test_domain_error(x86_fp80 %value) {
+entry:
+  %call_00 = call x86_fp80 @acosl(x86_fp80 %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp ogt x86_fp80 %value, 0xK3FFF8000000000000000
+; CHECK: [[COND2:%[0-9]+]] = fcmp olt x86_fp80 %value, 0xKBFFF8000000000000000
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_00 = call x86_fp80 @acosl(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_01 = call x86_fp80 @asinl(x86_fp80 %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp ogt x86_fp80 %value, 0xK3FFF8000000000000000
+; CHECK: [[COND2:%[0-9]+]] = fcmp olt x86_fp80 %value, 0xKBFFF8000000000000000
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_01 = call x86_fp80 @asinl(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_02 = call x86_fp80 @cosl(x86_fp80 %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp oeq x86_fp80 %value, 0xKFFFF8000000000000000
+; CHECK: [[COND2:%[0-9]+]] = fcmp oeq x86_fp80 %value, 0xK7FFF8000000000000000
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_02 = call x86_fp80 @cosl(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_03 = call x86_fp80 @sinl(x86_fp80 %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp oeq x86_fp80 %value, 0xKFFFF8000000000000000
+; CHECK: [[COND2:%[0-9]+]] = fcmp oeq x86_fp80 %value, 0xK7FFF8000000000000000
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_03 = call x86_fp80 @sinl(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_04 = call x86_fp80 @acoshl(x86_fp80 %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp olt x86_fp80 %value, 0xK3FFF8000000000000000
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_04 = call x86_fp80 @acoshl(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_05 = call x86_fp80 @sqrtl(x86_fp80 %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp olt x86_fp80 %value, 0xK00000000000000000000
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_05 = call x86_fp80 @sqrtl(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_06 = call x86_fp80 @atanhl(x86_fp80 %value)
+; CHECK: [[COND1:%[0-9]+]] = fcmp oge x86_fp80 %value, 0xK3FFF8000000000000000
+; CHECK: [[COND2:%[0-9]+]] = fcmp ole x86_fp80 %value, 0xKBFFF8000000000000000
+; CHECK: [[COND:%[0-9]+]] = or i1 [[COND2]], [[COND1]]
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_06 = call x86_fp80 @atanhl(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_07 = call x86_fp80 @logl(x86_fp80 %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole x86_fp80 %value, 0xK00000000000000000000
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_07 = call x86_fp80 @logl(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_08 = call x86_fp80 @log10l(x86_fp80 %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole x86_fp80 %value, 0xK00000000000000000000
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_08 = call x86_fp80 @log10l(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_09 = call x86_fp80 @log2l(x86_fp80 %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole x86_fp80 %value, 0xK00000000000000000000
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_09 = call x86_fp80 @log2l(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_10 = call x86_fp80 @logbl(x86_fp80 %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole x86_fp80 %value, 0xK00000000000000000000
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_10 = call x86_fp80 @logbl(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  %call_11 = call x86_fp80 @log1pl(x86_fp80 %value)
+; CHECK: [[COND:%[0-9]+]] = fcmp ole x86_fp80 %value, 0xKBFFF8000000000000000
+; CHECK: br i1 [[COND]], label %[[CALL_LABEL:cdce.call[0-9]*]], label %[[END_LABEL:cdce.end[0-9]*]], !prof ![[BRANCH_WEIGHT:[0-9]+]]
+; CHECK: [[CALL_LABEL]]:
+; CHECK-NEXT: %call_11 = call x86_fp80 @log1pl(x86_fp80 %value)
+; CHECK-NEXT: br label %[[END_LABEL]]
+; CHECK: [[END_LABEL]]:
+
+  ret void
+}
+
+declare x86_fp80 @acosl(x86_fp80)
+declare x86_fp80 @asinl(x86_fp80)
+declare x86_fp80 @cosl(x86_fp80)
+declare x86_fp80 @sinl(x86_fp80)
+declare x86_fp80 @acoshl(x86_fp80)
+declare x86_fp80 @sqrtl(x86_fp80)
+declare x86_fp80 @atanhl(x86_fp80)
+declare x86_fp80 @logl(x86_fp80)
+declare x86_fp80 @log10l(x86_fp80)
+declare x86_fp80 @log2l(x86_fp80)
+declare x86_fp80 @logbl(x86_fp80)
+declare x86_fp80 @log1pl(x86_fp80)
+
+; CHECK: ![[BRANCH_WEIGHT]] = !{!"branch_weights", i32 1, i32 2000}