[NFCI][IR] Introduce CallBase::Create() wrapper

[lebedev.ri]

Summary

It is reasonably common to want to clone some call with different bundles.
Let's actually provide an interface to do that.

[nickdesaulniers]

llvm/include/llvm/IR/InstrTypes.h

1145

No call sites make use of this default value (nullptr). Is it the right value? I'm not sure if you can default it to CB, but if not, should it just be a required parameter with no default value?

[lebedev.ri]

llvm/include/llvm/IR/InstrTypes.h

1145

This is a direct wrapper over all the subclasses Create() function with the same signature.
They all follow this pattern. I'm not sure why we should deviate here.

[nickdesaulniers]

llvm/include/llvm/IR/InstrTypes.h

1145

Ah, I missed the use in the child patch.

[lebedev.ri]

llvm/include/llvm/IR/InstrTypes.h

1145

Hm, that use wasn't supposed to be there.

llvm/include/llvm/IR/InstrTypes.h

protected:
 
   /// Get the number of extra operands for instructions that don't have a fixed
   /// number of extra operands.
   unsigned getNumSubclassExtraOperandsDynamic() const;
 
 public:
   using Instruction::getContext;
 
+  /// Create a clone of \p CB with a different set of operand bundles and
+  /// insert it before \p InsertPt.
+  ///
+  /// The returned call instruction is identical \p CB in every way except that
+  /// the operand bundles for the new instruction are set to the operand bundles
+  /// in \p Bundles.
+  static CallBase *Create(CallBase *CB, ArrayRef<OperandBundleDef> Bundles,
+                          Instruction *InsertPt = nullptr);
+
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Call ||
            I->getOpcode() == Instruction::Invoke ||
            I->getOpcode() == Instruction::CallBr;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }

llvm/lib/IR/Instructions.cpp

void LandingPadInst::addClause(Constant *Val) {
   setNumHungOffUseOperands(getNumOperands() + 1);
   getOperandList()[OpNo] = Val;
 }
 
 //===----------------------------------------------------------------------===//
 //                        CallBase Implementation
 //===----------------------------------------------------------------------===//
 
+CallBase *CallBase::Create(CallBase *CB, ArrayRef<OperandBundleDef> Bundles,
+                           Instruction *InsertPt) {
+  switch (CB->getOpcode()) {
+  case Instruction::Call:
+    return CallInst::Create(cast<CallInst>(CB), Bundles, InsertPt);
+  case Instruction::Invoke:
+    return InvokeInst::Create(cast<InvokeInst>(CB), Bundles, InsertPt);
+  case Instruction::CallBr:
+    return CallBrInst::Create(cast<CallBrInst>(CB), Bundles, InsertPt);
+  default:
+    llvm_unreachable("Unknown CallBase sub-class!");
+  }
+}
+
 Function *CallBase::getCaller() { return getParent()->getParent(); }
 
 unsigned CallBase::getNumSubclassExtraOperandsDynamic() const {
   assert(getOpcode() == Instruction::CallBr && "Unexpected opcode!");
   return cast<CallBrInst>(this)->getNumIndirectDests() + 1;
 }
 
 bool CallBase::isIndirectCall() const {

llvm/lib/Transforms/CFGuard/CFGuard.cpp

void CFGuard::insertCFGuardDispatch(CallBase *CB) {
   LoadInst *GuardDispatchLoad = B.CreateLoad(CalledOperandType, GuardFnGlobal);
 
   // Add the original call target as a cfguardtarget operand bundle.
   SmallVector<llvm::OperandBundleDef, 1> Bundles;
   CB->getOperandBundlesAsDefs(Bundles);
   Bundles.emplace_back("cfguardtarget", CalledOperand);
 
   // Create a copy of the call/invoke instruction and add the new bundle.
-  CallBase *NewCB;
-  if (CallInst *CI = dyn_cast<CallInst>(CB)) {
-    NewCB = CallInst::Create(CI, Bundles, CB);
-  } else {
-    assert(isa<InvokeInst>(CB) && "Unknown indirect call type");
-    InvokeInst *II = cast<InvokeInst>(CB);
-    NewCB = llvm::InvokeInst::Create(II, Bundles, CB);
-  }
+  assert((isa<CallInst>(CB) || isa<InvokeInst>(CB)) &&
+         "Unknown indirect call type");
+  CallBase *NewCB = CallBase::Create(CB, Bundles, CB);
 
   // Change the target of the call to be the guard dispatch function.
   NewCB->setCalledOperand(GuardDispatchLoad);
 
   // Replace the original call/invoke with the new instruction.
   CB->replaceAllUsesWith(NewCB);
 
   // Delete the original call/invoke.

llvm/lib/Transforms/IPO/GlobalOpt.cpp

for (auto *It = OpBundles.begin(); It != OpBundles.end(); ++It) {
         PreallocatedSetup = cast<CallBase>(*It->input_begin());
         OpBundles.erase(It);
         break;
       }
     }
     assert(PreallocatedSetup && "Did not find preallocated bundle");
     uint64_t ArgCount =
         cast<ConstantInt>(PreallocatedSetup->getArgOperand(0))->getZExtValue();
-    CallBase *NewCB = nullptr;
-    if (InvokeInst *II = dyn_cast<InvokeInst>(CB)) {
-      NewCB = InvokeInst::Create(II, OpBundles, CB);
-    } else {
-      CallInst *CI = cast<CallInst>(CB);
-      NewCB = CallInst::Create(CI, OpBundles, CB);
-    }
+
+    assert((isa<CallInst>(CB) || isa<InvokeInst>(CB)) &&
+           "Unknown indirect call type");
+    CallBase *NewCB = CallBase::Create(CB, OpBundles, CB);
     CB->replaceAllUsesWith(NewCB);
     NewCB->takeName(CB);
     CB->eraseFromParent();
 
     Builder.SetInsertPoint(PreallocatedSetup);
     auto *StackSave =
         Builder.CreateCall(Intrinsic::getDeclaration(M, Intrinsic::stacksave));
 

llvm/lib/Transforms/Utils/InlineFunction.cpp

if (ParentDeopt) {
                                  ParentDeopt->Inputs.begin(),
                                  ParentDeopt->Inputs.end());
           MergedDeoptArgs.insert(MergedDeoptArgs.end(), ChildOB.Inputs.begin(),
                                  ChildOB.Inputs.end());
 
           OpDefs.emplace_back("deopt", std::move(MergedDeoptArgs));
         }
 
-        Instruction *NewI = nullptr;
-        if (isa<CallInst>(ICS))
-          NewI = CallInst::Create(cast<CallInst>(ICS), OpDefs, ICS);
-        else if (isa<CallBrInst>(ICS))
-          NewI = CallBrInst::Create(cast<CallBrInst>(ICS), OpDefs, ICS);
-        else
-          NewI = InvokeInst::Create(cast<InvokeInst>(ICS), OpDefs, ICS);
+        Instruction *NewI = CallBase::Create(ICS, OpDefs, ICS);
 
         // Note: the RAUW does the appropriate fixup in VMap, so we need to do
         // this even if the call returns void.
         ICS->replaceAllUsesWith(NewI);
 
         VH = nullptr;
         ICS->eraseFromParent();
       }
for (Function::iterator BB = FirstNewBlock->getIterator(),
 
         // Skip call sites which already have a "funclet" bundle.
         if (I->getOperandBundle(LLVMContext::OB_funclet))
           continue;
 
         I->getOperandBundlesAsDefs(OpBundles);
         OpBundles.emplace_back("funclet", CallSiteEHPad);
 
-        Instruction *NewInst;
-        if (auto *CallI = dyn_cast<CallInst>(I))
-          NewInst = CallInst::Create(CallI, OpBundles, CallI);
-        else if (auto *CallBrI = dyn_cast<CallBrInst>(I))
-          NewInst = CallBrInst::Create(CallBrI, OpBundles, CallBrI);
-        else
-          NewInst = InvokeInst::Create(cast<InvokeInst>(I), OpBundles, I);
+        Instruction *NewInst = CallBase::Create(I, OpBundles, I);
         NewInst->takeName(I);
         I->replaceAllUsesWith(NewInst);
         I->eraseFromParent();
 
         OpBundles.clear();
       }
 
       // It is problematic if the inlinee has a cleanupret which unwinds to