[LibCallsShrinkWrap][NFC] Reuse createCond and createOrCond

[Jim]

Summary

Add two new functions createCond and createOrCond that accept extra
arguments Arg and Arg/Arg2 respectively.

[Jim]

Kindly ping. This revision is for https://reviews.llvm.org/D152776 to add if (BBBuilder.GetInsertBlock()->getParent()->hasFnAttribute(Attribute::StrictFP)) in only one site.

[efriedma]

LGTM

llvm/lib/Transforms/Utils/LibCallsShrinkWrap.cpp

private:
   void shrinkWrapCI(CallInst *CI, Value *Cond);
   bool performCallDomainErrorOnly(CallInst *CI, const LibFunc &Func);
   bool performCallErrors(CallInst *CI, const LibFunc &Func);
   bool performCallRangeErrorOnly(CallInst *CI, const LibFunc &Func);
   Value *generateOneRangeCond(CallInst *CI, const LibFunc &Func);
   Value *generateTwoRangeCond(CallInst *CI, const LibFunc &Func);
   Value *generateCondForPow(CallInst *CI, const LibFunc &Func);
 
+  // Create an OR of two conditions with given Arg and Arg2.
+  Value *createOrCond(CallInst *CI, Value *Arg, CmpInst::Predicate Cmp,
+                      float Val, Value *Arg2, CmpInst::Predicate Cmp2,
+                      float Val2) {
+    IRBuilder<> BBBuilder(CI);
+    auto Cond2 = createCond(BBBuilder, Arg2, Cmp2, Val2);
+    auto Cond1 = createCond(BBBuilder, Arg, Cmp, Val);
+    return BBBuilder.CreateOr(Cond1, Cond2);
+  }
+
   // 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);
+    return createOrCond(CI, Arg, Cmp, Val, Arg, Cmp2, Val2);
   }
 
   // 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 with given Arg.
+  Value *createCond(CallInst *CI, Value *Arg, CmpInst::Predicate Cmp,
+                    float Val) {
+    IRBuilder<> BBBuilder(CI);
+    return createCond(BBBuilder, Arg, Cmp, Val);
+  }
+
   // 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);
+    return createCond(CI, Arg, Cmp, Val);
   }
 
   const TargetLibraryInfo &TLI;
   DomTreeUpdater &DTU;
   SmallVector<CallInst *, 16> WorkList;
 };
 } // end anonymous namespace
 
Value *LibCallsShrinkWrap::generateCondForPow(CallInst *CI,
   // FIXME: LibFunc_powf and powl TBD.
   if (Func != LibFunc_pow) {
     LLVM_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()) {
       LLVM_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);
+    return createCond(CI, Exp, CmpInst::FCMP_OGT, 127.0f);
   }
 
   // If the Base value coming from an integer type.
   Instruction *I = dyn_cast<Instruction>(Base);
   if (!I) {
     LLVM_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 {
       LLVM_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);
+    return createOrCond(CI, Base, CmpInst::FCMP_OLE, 0.0f, Exp,
+                        CmpInst::FCMP_OGT, UpperV);
   }
   LLVM_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 LibCallsShrinkWrap::shrinkWrapCI(CallInst *CI, Value *Cond) {
   assert(Cond != nullptr && "ShrinkWrapCI is not expecting an empty call inst");