[CSP, Cloning] Update DuplicateInstructionsInSplitBetween to use DomTreeUpdater.

[fhahn]

Summary

This patch updates DuplicateInstructionsInSplitBetween to update a DTU
instead of applying updates to the DT directly.

Given that there only are 2 users, I also updated them in this patch to
avoid churn.

I slightly moved the code in CallSiteSplitting around to reduce the
places where we have to pass in DTU. If necessary, I could split those
changes in a separate patch.

This fixes missing DT updates when dealing with musttail calls in
CallSiteSplitting, by using DTU->deleteBB.

[kuhar]

lib/Transforms/Scalar/CallSiteSplitting.cpp

477–478

You can have just DTU and ask it for a DT: DTU.getDomTree(). This was it's easier to make sure you are not making any queries to an outdated DomTree.

[fhahn]

updated to use DTU.getDomTree(), thanks!

[junbuml]

lib/Transforms/Scalar/CallSiteSplitting.cpp

443

Now this function collects PredsWithCondsTy without performing splitting. Can you change this function name accordingly.

482–486

What about doing this in a separate function ?

[NutshellySima]

include/llvm/Transforms/Utils/Cloning.h

270

I think it's better to use a pointer to DomTreeUpdater here since DTU is not a must to use this function.

lib/Transforms/Scalar/CallSiteSplitting.cpp

457

I recommend adding assert(DTU.hasDomTree() && ...) here.

515

You need to be careful that BB isn't erased immediately because you use UpdateStrategy::Lazy.

lib/Transforms/Utils/CloneFunction.cpp

818

I have concerns on correctness here. It seems that llvm::SplitCriticalEdge used inside SplitEdge sometimes does not delete all edges between PredBB and BB. (More info)
And maybe it's better to do insertions then do deletions like this. It seems like a performance related consideration? @kuhar

unittests/Transforms/Utils/CloningTest.cpp

230

The unittest is not effective. Neither DT nor PDT is passed into DomTreeUpdater. And UpdateStrategy::Eager also needs testing.

Both DomTreeUpdater DTU(NotNullDT, NotNullPDT, Lazy) and DomTreeUpdater DTU(NotNullDT, NotNullPDT, Eager) need to be tested.

[fhahn]

Thanks, I'll address the comments on Monday.

include/llvm/Transforms/Utils/Cloning.h

270

I can change it, I just figured given the few users it might be better to require DTU.

lib/Transforms/Scalar/CallSiteSplitting.cpp

515

Right, I will update the comment. Having the blocks deleted at the end of this function (or when getDomTree() is called) should be fine.

lib/Transforms/Utils/CloneFunction.cpp

818

I basically took the updates from JumpThreading. I'll take another look on Monday.

[NutshellySima]

lib/Transforms/Utils/CloneFunction.cpp

818

You can also use DTU.applyUpdates(..., ForceRemoveDuplicate=true) here to automatically remove this invalid update under Eager UpdateStrategy. But it is a side-effect of deduplication which seems like a hack and I do not recommend using it :\. (JT uses Lazy UpdateStrategy which automatically does updates deduplication).

[fhahn]

Address comments: renamed CSP functions, add assertion ensuring there is a single edge between PredBB and BB. I hope this addresses all comments

lib/Transforms/Scalar/CallSiteSplitting.cpp

443

I've also added short comments.

457

I've reverted the patch using the DT here, because it depends on the current patch. So this code is gone in the latest revision.

482–486

You mean calling the 2 functions above in a separate function? Given that tryToSplitCallSite itself is quite small, I think it is clearer to have to calls here directly.

lib/Transforms/Utils/CloneFunction.cpp

818

It looks like DuplicateInstructionsInSplitBetween should only be called if there is a single edge between PredBB and BB, otherwise it is not really clear what the return value should be. I have added an assertion to make sure there is only one edge between PredBB and BB (and it holds for a bootstrap build & the test suite). IIUC, this should be enough to address the issue mentioned earlier?

unittests/Transforms/Utils/CloningTest.cpp

230

I've added a comment to make clear that the DTU here is just a dummy, as the current tests do not test DT preservation. I suppose the existing JT & CSP test should cover DT preservation, but I would be happy to extend the tests in a separate patch if you think that is valuable.

[NutshellySima]

LGTM. Thanks!

[kuhar]

lib/Transforms/Scalar/CallSiteSplitting.cpp

444

nit: missing dot at the end of the comment

unittests/Transforms/Utils/CloningTest.cpp

228

nit: missing dot at the end of the comment

277

nit: missing dot at the end of the comment

330

nit: missing dot at the end of the comment

[fhahn]

Thanks, I'll update the comments before I commit this.

[fhahn]

submitted as rL346769

Thanks for having a look!

include/llvm/Transforms/Utils/Cloning.h

 class Function;
 class Instruction;
 class InvokeInst;
 class Loop;
 class LoopInfo;
 class Module;
 class ProfileSummaryInfo;
 class ReturnInst;
+class DomTreeUpdater;
 
 /// Return an exact copy of the specified module
 std::unique_ptr<Module> CloneModule(const Module &M);
 std::unique_ptr<Module> CloneModule(const Module &M, ValueToValueMapTy &VMap);
 
 /// Return a copy of the specified module. The ShouldCloneDefinition function
 /// controls whether a specific GlobalValue's definition is cloned. If the
 /// function returns false, the module copy will contain an external reference
void remapInstructionsInBlocks(const SmallVectorImpl<BasicBlock *> &Blocks,
                                ValueToValueMapTy &VMap);
 
 /// Split edge between BB and PredBB and duplicate all non-Phi instructions
 /// from BB between its beginning and the StopAt instruction into the split
 /// block. Phi nodes are not duplicated, but their uses are handled correctly:
 /// we replace them with the uses of corresponding Phi inputs. ValueMapping
 /// is used to map the original instructions from BB to their newly-created
 /// copies. Returns the split block.
-BasicBlock *
-DuplicateInstructionsInSplitBetween(BasicBlock *BB, BasicBlock *PredBB,
+BasicBlock *DuplicateInstructionsInSplitBetween(BasicBlock *BB,
+                                                BasicBlock *PredBB,
                                                 Instruction *StopAt,
                                                 ValueToValueMapTy &ValueMapping,
-                                    DominatorTree *DT = nullptr);
+                                                DomTreeUpdater &DTU);
+
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_CLONING_H

lib/Transforms/Scalar/CallSiteSplitting.cpp

 ///    %p = phi i1 [%ca1, %Tail-split1],[%ca2, %Tail-split2]
 ///
 /// Note that in case any arguments at the call-site are constrained by its
 /// predecessors, new call-sites with more constrained arguments will be
 /// created in createCallSitesOnPredicatedArgument().
 static void splitCallSite(
     CallSite CS,
     const SmallVectorImpl<std::pair<BasicBlock *, ConditionsTy>> &Preds,
-    DominatorTree *DT) {
+    DomTreeUpdater &DTU) {
   Instruction *Instr = CS.getInstruction();
   BasicBlock *TailBB = Instr->getParent();
   bool IsMustTailCall = CS.isMustTailCall();
 
   PHINode *CallPN = nullptr;
 
   // `musttail` calls must be followed by optional `bitcast`, and `ret`. The
   // split blocks will be terminated right after that so there're no users for
   // this phi in a `TailBB`.
   if (!IsMustTailCall && !Instr->use_empty()) {
     CallPN = PHINode::Create(Instr->getType(), Preds.size(), "phi.call");
     CallPN->setDebugLoc(Instr->getDebugLoc());
   }
 
   LLVM_DEBUG(dbgs() << "split call-site : " << *Instr << " into \n");
 
   assert(Preds.size() == 2 && "The ValueToValueMaps array has size 2.");
   // ValueToValueMapTy is neither copy nor moveable, so we use a simple array
   // here.
   ValueToValueMapTy ValueToValueMaps[2];
   for (unsigned i = 0; i < Preds.size(); i++) {
     BasicBlock *PredBB = Preds[i].first;
     BasicBlock *SplitBlock = DuplicateInstructionsInSplitBetween(
         TailBB, PredBB, &*std::next(Instr->getIterator()), ValueToValueMaps[i],
-        DT);
+        DTU);
     assert(SplitBlock && "Unexpected new basic block split.");
 
     Instruction *NewCI =
         &*std::prev(SplitBlock->getTerminator()->getIterator());
     CallSite NewCS(NewCI);
     addConditions(NewCS, Preds[i].second);
 
     // Handle PHIs used as arguments in the call-site.
if (IsMustTailCall) {
     // predecessors. Therefore we must get complete list of Splits before
     // attempting removal.
     SmallVector<BasicBlock *, 2> Splits(predecessors((TailBB)));
     assert(Splits.size() == 2 && "Expected exactly 2 splits!");
     for (unsigned i = 0; i < Splits.size(); i++)
       Splits[i]->getTerminator()->eraseFromParent();
 
     // Erase the tail block once done with musttail patching
-    TailBB->eraseFromParent();
+    DTU.deleteBB(TailBB);
     return;
   }
 
   auto *OriginalBegin = &*TailBB->begin();
   // Replace users of the original call with a PHI mering call-sites split.
   if (CallPN) {
     CallPN->insertBefore(OriginalBegin);
     Instr->replaceAllUsesWith(CallPN);
if (PHINode *PN = dyn_cast<PHINode>(&BI)) {
             return true;
         }
     }
     break;
   }
   return false;
 }
 
-static bool tryToSplitOnPHIPredicatedArgument(CallSite CS, DominatorTree *DT) {
+using PredsWithCondsTy = SmallVector<std::pair<BasicBlock *, ConditionsTy>, 2>;
+
+// Check if any of the arguments in CS are predicated on a PHI node and return
+// the set of predecessors we should use for splitting
+static PredsWithCondsTy shouldSplitOnPHIPredicatedArgument(CallSite CS) {
   if (!isPredicatedOnPHI(CS))
-    return false;
+    return {};
 
   auto Preds = getTwoPredecessors(CS.getInstruction()->getParent());
-  SmallVector<std::pair<BasicBlock *, ConditionsTy>, 2> PredsCS = {
-      {Preds[0], {}}, {Preds[1], {}}};
-  splitCallSite(CS, PredsCS, DT);
-  return true;
+  return {{Preds[0], {}}, {Preds[1], {}}};
 }
 
-static bool tryToSplitOnPredicatedArgument(CallSite CS, DominatorTree *DT) {
+// Checks if any of the arguments in CS are predicated in a predecessor and
+// returns a list of predecessors with the conditions that hold on their edges
+// to CS.
+static PredsWithCondsTy shouldSplitOnPredicatedArgument(CallSite CS) {
   auto Preds = getTwoPredecessors(CS.getInstruction()->getParent());
   if (Preds[0] == Preds[1])
-    return false;
+    return {};
 
   SmallVector<std::pair<BasicBlock *, ConditionsTy>, 2> PredsCS;
   for (auto *Pred : make_range(Preds.rbegin(), Preds.rend())) {
     ConditionsTy Conditions;
     recordConditions(CS, Pred, Conditions);
     PredsCS.push_back({Pred, Conditions});
   }
 
   if (all_of(PredsCS, [](const std::pair<BasicBlock *, ConditionsTy> &P) {
         return P.second.empty();
       }))
-    return false;
+    return {};
 
-  splitCallSite(CS, PredsCS, DT);
-  return true;
+  return PredsCS;
 }
 
 static bool tryToSplitCallSite(CallSite CS, TargetTransformInfo &TTI,
-                               DominatorTree *DT) {
+                               DomTreeUpdater &DTU) {
+  // Check if we can split the call site.
   if (!CS.arg_size() || !canSplitCallSite(CS, TTI))
     return false;
-  return tryToSplitOnPredicatedArgument(CS, DT) ||
-         tryToSplitOnPHIPredicatedArgument(CS, DT);
+
+  auto PredsWithConds = shouldSplitOnPredicatedArgument(CS);
+  if (PredsWithConds.empty())
+    PredsWithConds = shouldSplitOnPHIPredicatedArgument(CS);
+  if (PredsWithConds.empty())
+    return false;
+
+  splitCallSite(CS, PredsWithConds, DTU);
+  return true;
 }
 
 static bool doCallSiteSplitting(Function &F, TargetLibraryInfo &TLI,
                                 TargetTransformInfo &TTI, DominatorTree *DT) {
+
+  DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Lazy);
   bool Changed = false;
   for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE;) {
     BasicBlock &BB = *BI++;
     auto II = BB.getFirstNonPHIOrDbg()->getIterator();
     auto IE = BB.getTerminator()->getIterator();
     // Iterate until we reach the terminator instruction. tryToSplitCallSite
     // can replace BB's terminator in case BB is a successor of itself. In that
     // case, IE will be invalidated and we also have to check the current
     // terminator.
     while (II != IE && &*II != BB.getTerminator()) {
       Instruction *I = &*II++;
       CallSite CS(cast<Value>(I));
       if (!CS || isa<IntrinsicInst>(I) || isInstructionTriviallyDead(I, &TLI))
         continue;
 
       Function *Callee = CS.getCalledFunction();
       if (!Callee || Callee->isDeclaration())
         continue;
 
       // Successful musttail call-site splits result in erased CI and erased BB.
       // Check if such path is possible before attempting the splitting.
       bool IsMustTail = CS.isMustTailCall();
 
-      Changed |= tryToSplitCallSite(CS, TTI, DT);
+      Changed |= tryToSplitCallSite(CS, TTI, DTU);
 
       // There're no interesting instructions after this. The call site
       // itself might have been erased on splitting.
       if (IsMustTail)
         break;
     }
   }
   return Changed;

lib/Transforms/Scalar/JumpThreading.cpp

bool JumpThreadingPass::ThreadGuard(BasicBlock *BB, IntrinsicInst *Guard,
   ValueToValueMapTy UnguardedMapping, GuardedMapping;
   Instruction *AfterGuard = Guard->getNextNode();
   unsigned Cost = getJumpThreadDuplicationCost(BB, AfterGuard, BBDupThreshold);
   if (Cost > BBDupThreshold)
     return false;
   // Duplicate all instructions before the guard and the guard itself to the
   // branch where implication is not proved.
   BasicBlock *GuardedBlock = DuplicateInstructionsInSplitBetween(
-      BB, PredGuardedBlock, AfterGuard, GuardedMapping);
+      BB, PredGuardedBlock, AfterGuard, GuardedMapping, *DTU);
   assert(GuardedBlock && "Could not create the guarded block?");
   // Duplicate all instructions before the guard in the unguarded branch.
   // Since we have successfully duplicated the guarded block and this block
   // has fewer instructions, we expect it to succeed.
   BasicBlock *UnguardedBlock = DuplicateInstructionsInSplitBetween(
-      BB, PredUnguardedBlock, Guard, UnguardedMapping);
+      BB, PredUnguardedBlock, Guard, UnguardedMapping, *DTU);
   assert(UnguardedBlock && "Could not create the unguarded block?");
   LLVM_DEBUG(dbgs() << "Moved guard " << *Guard << " to block "
                     << GuardedBlock->getName() << "\n");
-  // DuplicateInstructionsInSplitBetween inserts a new block "BB.split" between
-  // PredBB and BB. We need to perform two inserts and one delete for each of
-  // the above calls to update Dominators.
-  DTU->applyUpdates(
-      {// Guarded block split.
-       {DominatorTree::Delete, PredGuardedBlock, BB},
-       {DominatorTree::Insert, PredGuardedBlock, GuardedBlock},
-       {DominatorTree::Insert, GuardedBlock, BB},
-       // Unguarded block split.
-       {DominatorTree::Delete, PredUnguardedBlock, BB},
-       {DominatorTree::Insert, PredUnguardedBlock, UnguardedBlock},
-       {DominatorTree::Insert, UnguardedBlock, BB}});
   // Some instructions before the guard may still have uses. For them, we need
   // to create Phi nodes merging their copies in both guarded and unguarded
   // branches. Those instructions that have no uses can be just removed.
   SmallVector<Instruction *, 4> ToRemove;
   for (auto BI = BB->begin(); &*BI != AfterGuard; ++BI)
     if (!isa<PHINode>(&*BI))
       ToRemove.push_back(&*BI);
 

lib/Transforms/Utils/CloneFunction.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/LoopInfo.h"
-#include "llvm/Transforms/Utils/Local.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/DomTreeUpdater.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
+#include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/ValueMapper.h"
 #include <map>
 using namespace llvm;
 
 /// See comments in Cloning.h.
 BasicBlock *llvm::CloneBasicBlock(const BasicBlock *BB, ValueToValueMapTy &VMap,
                                   const Twine &NameSuffix, Function *F,
                                   ClonedCodeInfo *CodeInfo,
Loop *llvm::cloneLoopWithPreheader(BasicBlock *Before, BasicBlock *LoopDomBB,
   F->getBasicBlockList().splice(Before->getIterator(), F->getBasicBlockList(),
                                 NewLoop->getHeader()->getIterator(), F->end());
 
   return NewLoop;
 }
 
 /// Duplicate non-Phi instructions from the beginning of block up to
 /// StopAt instruction into a split block between BB and its predecessor.
-BasicBlock *
-llvm::DuplicateInstructionsInSplitBetween(BasicBlock *BB, BasicBlock *PredBB,
-                                          Instruction *StopAt,
-                                          ValueToValueMapTy &ValueMapping,
-                                          DominatorTree *DT) {
+BasicBlock *llvm::DuplicateInstructionsInSplitBetween(
+    BasicBlock *BB, BasicBlock *PredBB, Instruction *StopAt,
+    ValueToValueMapTy &ValueMapping, DomTreeUpdater &DTU) {
+
+  assert(count(successors(PredBB), BB) == 1 &&
+         "There must be a single edge between PredBB and BB!");
   // We are going to have to map operands from the original BB block to the new
   // copy of the block 'NewBB'.  If there are PHI nodes in BB, evaluate them to
   // account for entry from PredBB.
   BasicBlock::iterator BI = BB->begin();
   for (; PHINode *PN = dyn_cast<PHINode>(BI); ++BI)
     ValueMapping[PN] = PN->getIncomingValueForBlock(PredBB);
 
-  BasicBlock *NewBB = SplitEdge(PredBB, BB, DT);
+  BasicBlock *NewBB = SplitEdge(PredBB, BB);
   NewBB->setName(PredBB->getName() + ".split");
   Instruction *NewTerm = NewBB->getTerminator();
 
+  // FIXME: SplitEdge does not yet take a DTU, so we include the split edge
+  //        in the update set here.
+  DTU.applyUpdates({{DominatorTree::Delete, PredBB, BB},
+                    {DominatorTree::Insert, PredBB, NewBB},
+                    {DominatorTree::Insert, NewBB, BB}});
+
   // Clone the non-phi instructions of BB into NewBB, keeping track of the
   // mapping and using it to remap operands in the cloned instructions.
   // Stop once we see the terminator too. This covers the case where BB's
   // terminator gets replaced and StopAt == BB's terminator.
   for (; StopAt != &*BI && BB->getTerminator() != &*BI; ++BI) {
     Instruction *New = BI->clone();
     New->setName(BI->getName());
     New->insertBefore(NewTerm);

test/Transforms/CallSiteSplitting/musttail.ll

-; RUN: opt < %s -callsite-splitting -S | FileCheck %s
+; RUN: opt < %s -callsite-splitting -verify-dom-info -S | FileCheck %s
 
 ;CHECK-LABEL: @caller
 ;CHECK-LABEL: Top.split:
 ;CHECK: %ca1 = musttail call i8* @callee(i8* null, i8* %b)
 ;CHECK: %cb2 = bitcast i8* %ca1 to i8*
 ;CHECK: ret i8* %cb2
 ;CHECK-LABEL: TBB.split
 ;CHECK: %ca3 = musttail call i8* @callee(i8* nonnull %a, i8* null)

unittests/Transforms/Utils/CloningTest.cpp

 //===- Cloning.cpp - Unit tests for the Cloner ----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DebugInfo.h"
+#include "llvm/IR/DomTreeUpdater.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
TEST_F(CloneInstruction, DuplicateInstructionsToSplit) {
 
   Builder1.CreateBr(BB2);
 
   Instruction *AddInst = cast<Instruction>(Builder2.CreateAdd(V, V));
   Instruction *MulInst = cast<Instruction>(Builder2.CreateMul(AddInst, V));
   Instruction *SubInst = cast<Instruction>(Builder2.CreateSub(MulInst, V));
   Builder2.CreateRetVoid();
 
+  // Dummy DTU
   ValueToValueMapTy Mapping;
-
-  auto Split = DuplicateInstructionsInSplitBetween(BB2, BB1, SubInst, Mapping);
+  DomTreeUpdater DTU(DomTreeUpdater::UpdateStrategy::Lazy);
+  auto Split =
+      DuplicateInstructionsInSplitBetween(BB2, BB1, SubInst, Mapping, DTU);
 
   EXPECT_TRUE(Split);
   EXPECT_EQ(Mapping.size(), 2u);
   EXPECT_TRUE(Mapping.find(AddInst) != Mapping.end());
   EXPECT_TRUE(Mapping.find(MulInst) != Mapping.end());
 
   auto AddSplit = dyn_cast<Instruction>(Mapping[AddInst]);
   EXPECT_TRUE(AddSplit);
TEST_F(CloneInstruction, DuplicateInstructionsToSplitBlocksEq1) {
 
   Builder1.CreateBr(BB2);
 
   Instruction *AddInst = cast<Instruction>(Builder2.CreateAdd(V, V));
   Instruction *MulInst = cast<Instruction>(Builder2.CreateMul(AddInst, V));
   Instruction *SubInst = cast<Instruction>(Builder2.CreateSub(MulInst, V));
   Builder2.CreateBr(BB2);
 
+  // Dummy DTU
+  DomTreeUpdater DTU(DomTreeUpdater::UpdateStrategy::Lazy);
   ValueToValueMapTy Mapping;
-
-  auto Split = DuplicateInstructionsInSplitBetween(BB2, BB2, BB2->getTerminator(), Mapping);
+  auto Split = DuplicateInstructionsInSplitBetween(
+      BB2, BB2, BB2->getTerminator(), Mapping, DTU);
 
   EXPECT_TRUE(Split);
   EXPECT_EQ(Mapping.size(), 3u);
   EXPECT_TRUE(Mapping.find(AddInst) != Mapping.end());
   EXPECT_TRUE(Mapping.find(MulInst) != Mapping.end());
   EXPECT_TRUE(Mapping.find(SubInst) != Mapping.end());
 
   auto AddSplit = dyn_cast<Instruction>(Mapping[AddInst]);
TEST_F(CloneInstruction, DuplicateInstructionsToSplitBlocksEq2) {
 
   Builder1.CreateBr(BB2);
 
   Instruction *AddInst = cast<Instruction>(Builder2.CreateAdd(V, V));
   Instruction *MulInst = cast<Instruction>(Builder2.CreateMul(AddInst, V));
   Instruction *SubInst = cast<Instruction>(Builder2.CreateSub(MulInst, V));
   Builder2.CreateBr(BB2);
 
+  // Dummy DTU
+  DomTreeUpdater DTU(DomTreeUpdater::UpdateStrategy::Lazy);
   ValueToValueMapTy Mapping;
-
-  auto Split = DuplicateInstructionsInSplitBetween(BB2, BB2, SubInst, Mapping);
+  auto Split =
+      DuplicateInstructionsInSplitBetween(BB2, BB2, SubInst, Mapping, DTU);
 
   EXPECT_TRUE(Split);
   EXPECT_EQ(Mapping.size(), 2u);
   EXPECT_TRUE(Mapping.find(AddInst) != Mapping.end());
   EXPECT_TRUE(Mapping.find(MulInst) != Mapping.end());
 
   auto AddSplit = dyn_cast<Instruction>(Mapping[AddInst]);
   EXPECT_TRUE(AddSplit);