[GlobalOpt] Get DT only if it is available.

[fhahn]

Summary

D68298 updated GlobalOpt to use the DomTreeUpdater, but that can cause compile-time regressions for cases where we do not need to compute the DT for most functions. This patch adds some plumbing to only fetch the DT to update, if it was already requested elsewhere in GlobalOpt.

This is mostly a workaround a limitation of the legacy pass manager, which cannot return function analysis only if available for module passes. In the NewPassManager, getCachedResult works as expected.

[merge_guards_bot]

Unit tests: pass. 61243 tests passed, 0 failed and 736 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[nikic]

Do you plan to pursue this patch? It would be great to resolve this one way or the other before LLVM 10 branches.

[ekatz]

This is a welcoming improvement!
Is it sufficient that I'll approve it for you? Or are you waiting for the code-owner?

Other than that, I know that that it is a bit out of scope of this patch, but can we tag DT analysis as preserved?

llvm/lib/Transforms/IPO/GlobalOpt.cpp

114

Why the underscore? I think this is what clang-tidy warns about.

[fhahn]

In D72214#1810202, @nikic wrote:

Do you plan to pursue this patch? It would be great to resolve this one way or the other before LLVM 10 branches.

Yes I think it would be good to fix this. I'd like to hear what other people think about this workaround. Maybe there's something I am missing to do that in the legacy pass manager?

[ekatz]

The old PassManager has the function getAnalysisIfAvailable that should be used in case you only need to update an analysis (equivalent to getCachedResult of the new PassManager). You should probably switch to use this function, instead of the SmallPtrSet<> DTRequested technique.

[fhahn]

In D72214#1814399, @ekatz wrote:

The old PassManager has the function getAnalysisIfAvailable that should be used in case you only need to update an analysis (equivalent to getCachedResult of the new PassManager). You should probably switch to use this function, instead of the SmallPtrSet<> DTRequested technique.

I could not get getAnalysisIfAvailable to get a function level analysis from a module pass. IIUC it only works for function passes.

[ekatz]

In D72214#1814403, @fhahn wrote:

I could not get getAnalysisIfAvailable to get a function level analysis from a module pass. IIUC it only works for function passes.

And I guess adding this functionality to the Legacy PassManager is too much, for something that is going to be removed anyway.
Then the solution (in the patch) seems legit.

[fhahn]

After thinking about it a bit more, I think this patch makes things too brittle with the legacy pass manager (e.g. we might end up with invalid DTs, if they are not used by GlobalOpt, but removeUnreachableBlocks makes changes. I'll revert D68298 for now.

llvm/lib/Transforms/IPO/GlobalOpt.cpp

 
 static cl::opt<int> ColdCCRelFreq(
     "coldcc-rel-freq", cl::Hidden, cl::init(2), cl::ZeroOrMore,
     cl::desc(
         "Maximum block frequency, expressed as a percentage of caller's "
         "entry frequency, for a call site to be considered cold for enabling"
         "coldcc"));
 
+namespace {
+struct AnalysisLookup {
+  function_ref<TargetLibraryInfo &(Function &)> GetTLI;
+  function_ref<TargetTransformInfo &(Function &)> GetTTI;
+  function_ref<BlockFrequencyInfo &(Function &)> GetBFI;
+  function_ref<DominatorTree &(Function &)> GetDT_;
+  function_ref<DominatorTree *(Function &)> GetDTIfAvailable_;
+
+  bool NewPM;
+
+  AnalysisLookup(function_ref<TargetLibraryInfo &(Function &)> GetTLI,
+                 function_ref<TargetTransformInfo &(Function &)> GetTTI,
+                 function_ref<BlockFrequencyInfo &(Function &)> GetBFI,
+                 function_ref<DominatorTree &(Function &)> GetDT_,
+                 function_ref<DominatorTree *(Function &)> GetDTIfAvailable_,
+                 bool NewPM)
+      : GetTLI(GetTLI), GetTTI(GetTTI), GetBFI(GetBFI), GetDT_(GetDT_),
+        GetDTIfAvailable_(GetDTIfAvailable_), NewPM(NewPM) {}
+
+  DominatorTree &GetDT(Function &F) {
+    if (!NewPM)
+      DTRequested.insert(&F);
+    return GetDT_(F);
+  }
+
+  DominatorTree *GetDTIfAvailable(Function &F) {
+    if (NewPM)
+      return GetDTIfAvailable_(F);
+
+    if (DTRequested.find(&F) == DTRequested.end())
+      return nullptr;
+    return &GetDT_(F);
+  }
+
+  SmallPtrSet<Function *, 16> DTRequested;
+};
+
+} // namespace
 /// Is this global variable possibly used by a leak checker as a root?  If so,
 /// we might not really want to eliminate the stores to it.
 static bool isLeakCheckerRoot(GlobalVariable *GV) {
   // A global variable is a root if it is a pointer, or could plausibly contain
   // a pointer.  There are two challenges; one is that we could have a struct
   // the has an inner member which is a pointer.  We recurse through the type to
   // detect these (up to a point).  The other is that we may actually be a union
   // of a pointer and another type, and so our LLVM type is an integer which
if (!Dead)
     return false;
 
   LLVM_DEBUG(dbgs() << "GLOBAL DEAD: " << GV << "\n");
   GV.eraseFromParent();
   ++NumDeleted;
   return true;
 }
 
-static bool isPointerValueDeadOnEntryToFunction(
-    const Function *F, GlobalValue *GV,
-    function_ref<DominatorTree &(Function &)> LookupDomTree) {
+static bool isPointerValueDeadOnEntryToFunction(const Function *F,
+                                                GlobalValue *GV,
+                                                AnalysisLookup &Lookup) {
   // Find all uses of GV. We expect them all to be in F, and if we can't
   // identify any of the uses we bail out.
   //
   // On each of these uses, identify if the memory that GV points to is
   // used/required/live at the start of the function. If it is not, for example
   // if the first thing the function does is store to the GV, the GV can
   // possibly be demoted.
   //
for (auto *U : GV->users()) {
     else
       return false;
   }
 
   // We have identified all uses of GV into loads and stores. Now check if all
   // of them are known not to depend on the value of the global at the function
   // entry point. We do this by ensuring that every load is dominated by at
   // least one store.
-  auto &DT = LookupDomTree(*const_cast<Function *>(F));
+  auto &DT = Lookup.GetDT(*const_cast<Function *>(F));
 
   // The below check is quadratic. Check we're not going to do too many tests.
   // FIXME: Even though this will always have worst-case quadratic time, we
   // could put effort into minimizing the average time by putting stores that
   // have been shown to dominate at least one load at the beginning of the
   // Stores array, making subsequent dominance checks more likely to succeed
   // early.
   //
for (auto *U : Users) {
     // We've replaced all the uses, so destroy the constant. (destroyConstant
     // will update value handles and metadata.)
     U->destroyConstant();
   }
 }
 
 /// Analyze the specified global variable and optimize
 /// it if possible.  If we make a change, return true.
-static bool
-processInternalGlobal(GlobalVariable *GV, const GlobalStatus &GS,
-                      function_ref<TargetLibraryInfo &(Function &)> GetTLI,
-                      function_ref<DominatorTree &(Function &)> LookupDomTree) {
+static bool processInternalGlobal(GlobalVariable *GV, const GlobalStatus &GS,
+                                  AnalysisLookup &Lookup) {
   auto &DL = GV->getParent()->getDataLayout();
   // If this is a first class global and has only one accessing function and
   // this function is non-recursive, we replace the global with a local alloca
   // in this function.
   //
   // NOTE: It doesn't make sense to promote non-single-value types since we
   // are just replacing static memory to stack memory.
   //
   // If the global is in different address space, don't bring it to stack.
-  if (!GS.HasMultipleAccessingFunctions &&
-      GS.AccessingFunction &&
+  if (!GS.HasMultipleAccessingFunctions && GS.AccessingFunction &&
       GV->getValueType()->isSingleValueType() &&
-      GV->getType()->getAddressSpace() == 0 &&
-      !GV->isExternallyInitialized() &&
+      GV->getType()->getAddressSpace() == 0 && !GV->isExternallyInitialized() &&
       allNonInstructionUsersCanBeMadeInstructions(GV) &&
       GS.AccessingFunction->doesNotRecurse() &&
-      isPointerValueDeadOnEntryToFunction(GS.AccessingFunction, GV,
-                                          LookupDomTree)) {
+      isPointerValueDeadOnEntryToFunction(GS.AccessingFunction, GV, Lookup)) {
     const DataLayout &DL = GV->getParent()->getDataLayout();
 
     LLVM_DEBUG(dbgs() << "LOCALIZING GLOBAL: " << *GV << "\n");
     Instruction &FirstI = const_cast<Instruction&>(*GS.AccessingFunction
                                                    ->getEntryBlock().begin());
     Type *ElemTy = GV->getValueType();
     // FIXME: Pass Global's alignment when globals have alignment
     AllocaInst *Alloca = new AllocaInst(ElemTy, DL.getAllocaAddrSpace(), nullptr,
static bool processInternalGlobal(GlobalVariable *GV, const GlobalStatus &GS,
   // If the global is never loaded (but may be stored to), it is dead.
   // Delete it now.
   if (!GS.IsLoaded) {
     LLVM_DEBUG(dbgs() << "GLOBAL NEVER LOADED: " << *GV << "\n");
 
     bool Changed;
     if (isLeakCheckerRoot(GV)) {
       // Delete any constant stores to the global.
-      Changed = CleanupPointerRootUsers(GV, GetTLI);
+      Changed = CleanupPointerRootUsers(GV, Lookup.GetTLI);
     } else {
       // Delete any stores we can find to the global.  We may not be able to
       // make it completely dead though.
-      Changed =
-          CleanupConstantGlobalUsers(GV, GV->getInitializer(), DL, GetTLI);
+      Changed = CleanupConstantGlobalUsers(GV, GV->getInitializer(), DL,
+                                           Lookup.GetTLI);
     }
 
     // If the global is dead now, delete it.
     if (GV->use_empty()) {
       GV->eraseFromParent();
       ++NumDeleted;
       Changed = true;
     }
     return Changed;
 
   }
   if (GS.StoredType <= GlobalStatus::InitializerStored) {
     LLVM_DEBUG(dbgs() << "MARKING CONSTANT: " << *GV << "\n");
 
     // Don't actually mark a global constant if it's atomic because atomic loads
     // are implemented by a trivial cmpxchg in some edge-cases and that usually
     // requires write access to the variable even if it's not actually changed.
     if (GS.Ordering == AtomicOrdering::NotAtomic)
       GV->setConstant(true);
 
     // Clean up any obviously simplifiable users now.
-    CleanupConstantGlobalUsers(GV, GV->getInitializer(), DL, GetTLI);
+    CleanupConstantGlobalUsers(GV, GV->getInitializer(), DL, Lookup.GetTLI);
 
     // If the global is dead now, just nuke it.
     if (GV->use_empty()) {
       LLVM_DEBUG(dbgs() << "   *** Marking constant allowed us to simplify "
                         << "all users and delete global!\n");
       GV->eraseFromParent();
       ++NumDeleted;
       return true;
if (GS.StoredType == GlobalStatus::StoredOnce && GS.StoredOnceValue) {
     // initializer to be the stored value, then delete all stores to the
     // global.  This allows us to mark it constant.
     if (Constant *SOVConstant = dyn_cast<Constant>(GS.StoredOnceValue))
       if (isa<UndefValue>(GV->getInitializer())) {
         // Change the initial value here.
         GV->setInitializer(SOVConstant);
 
         // Clean up any obviously simplifiable users now.
-        CleanupConstantGlobalUsers(GV, GV->getInitializer(), DL, GetTLI);
+        CleanupConstantGlobalUsers(GV, GV->getInitializer(), DL, Lookup.GetTLI);
 
         if (GV->use_empty()) {
           LLVM_DEBUG(dbgs() << "   *** Substituting initializer allowed us to "
                             << "simplify all users and delete global!\n");
           GV->eraseFromParent();
           ++NumDeleted;
         }
         ++NumSubstitute;
         return true;
       }
 
     // Try to optimize globals based on the knowledge that only one value
     // (besides its initializer) is ever stored to the global.
     if (optimizeOnceStoredGlobal(GV, GS.StoredOnceValue, GS.Ordering, DL,
-                                 GetTLI))
+                                 Lookup.GetTLI))
       return true;
 
     // Otherwise, if the global was not a boolean, we can shrink it to be a
     // boolean.
     if (Constant *SOVConstant = dyn_cast<Constant>(GS.StoredOnceValue)) {
       if (GS.Ordering == AtomicOrdering::NotAtomic) {
         if (TryToShrinkGlobalToBoolean(GV, SOVConstant)) {
           ++NumShrunkToBool;
           return true;
         }
       }
     }
   }
 
   return false;
 }
 
 /// Analyze the specified global variable and optimize it if possible.  If we
 /// make a change, return true.
-static bool
-processGlobal(GlobalValue &GV,
-              function_ref<TargetLibraryInfo &(Function &)> GetTLI,
-              function_ref<DominatorTree &(Function &)> LookupDomTree) {
+static bool processGlobal(GlobalValue &GV, AnalysisLookup &Lookup) {
   if (GV.getName().startswith("llvm."))
     return false;
 
   GlobalStatus GS;
 
   if (GlobalStatus::analyzeGlobal(&GV, GS))
     return false;
 
static bool processGlobal(GlobalValue &GV, AnalysisLookup &Lookup) {
 
   auto *GVar = dyn_cast<GlobalVariable>(&GV);
   if (!GVar)
     return Changed;
 
   if (GVar->isConstant() || !GVar->hasInitializer())
     return Changed;
 
-  return processInternalGlobal(GVar, GS, GetTLI, LookupDomTree) || Changed;
+  return processInternalGlobal(GVar, GS, Lookup) || Changed;
 }
 
 /// Walk all of the direct calls of the specified function, changing them to
 /// FastCC.
 static void ChangeCalleesToFastCall(Function *F) {
   for (User *U : F->users()) {
     if (isa<BlockAddress>(U))
       continue;
for (Instruction &I : BB) {
           return false;
       }
     }
   }
   return true;
 }
 
 static bool
-OptimizeFunctions(Module &M,
-                  function_ref<TargetLibraryInfo &(Function &)> GetTLI,
-                  function_ref<TargetTransformInfo &(Function &)> GetTTI,
-                  function_ref<BlockFrequencyInfo &(Function &)> GetBFI,
-                  function_ref<DominatorTree &(Function &)> LookupDomTree,
+OptimizeFunctions(Module &M, AnalysisLookup &Lookup,
                   SmallPtrSetImpl<const Comdat *> &NotDiscardableComdats) {
 
   bool Changed = false;
 
   std::vector<Function *> AllCallsCold;
   for (Module::iterator FI = M.begin(), E = M.end(); FI != E;) {
     Function *F = &*FI++;
-    if (hasOnlyColdCalls(*F, GetBFI))
+    if (hasOnlyColdCalls(*F, Lookup.GetBFI))
       AllCallsCold.push_back(F);
   }
 
   // Optimize functions.
   for (Module::iterator FI = M.begin(), E = M.end(); FI != E; ) {
     Function *F = &*FI++;
 
     // Don't perform global opt pass on naked functions; we don't want fast
for (Module::iterator FI = M.begin(), E = M.end(); FI != E; ) {
     // in unreachable blocks, e.g.:
     // %pat = select i1 %condition, @global, i16* %pat
     // because any instruction dominates an instruction in a block that's
     // not reachable from entry.
     // So, remove unreachable blocks from the function, because a) there's
     // no point in analyzing them and b) GlobalOpt should otherwise grow
     // some more complicated logic to break these cycles.
     if (!F->isDeclaration()) {
-      auto &DT = LookupDomTree(*F);
+      auto *DT = Lookup.GetDTIfAvailable(*F);
       DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Lazy);
       Changed |= removeUnreachableBlocks(*F, &DTU);
     }
 
-    Changed |= processGlobal(*F, GetTLI, LookupDomTree);
+    Changed |= processGlobal(*F, Lookup);
 
     if (!F->hasLocalLinkage())
       continue;
 
     // If we have an inalloca parameter that we can safely remove the
     // inalloca attribute from, do so. This unlocks optimizations that
     // wouldn't be safe in the presence of inalloca.
     // FIXME: We should also hoist alloca affected by this to the entry
     // block if possible.
     if (F->getAttributes().hasAttrSomewhere(Attribute::InAlloca) &&
         !F->hasAddressTaken()) {
       RemoveAttribute(F, Attribute::InAlloca);
       Changed = true;
     }
 
     if (hasChangeableCC(F) && !F->isVarArg() && !F->hasAddressTaken()) {
       NumInternalFunc++;
-      TargetTransformInfo &TTI = GetTTI(*F);
+      TargetTransformInfo &TTI = Lookup.GetTTI(*F);
       // Change the calling convention to coldcc if either stress testing is
       // enabled or the target would like to use coldcc on functions which are
       // cold at all call sites and the callers contain no other non coldcc
       // calls.
       if (EnableColdCCStressTest ||
           (TTI.useColdCCForColdCall(*F) &&
-           isValidCandidateForColdCC(*F, GetBFI, AllCallsCold))) {
+           isValidCandidateForColdCC(*F, Lookup.GetBFI, AllCallsCold))) {
         F->setCallingConv(CallingConv::Cold);
         changeCallSitesToColdCC(F);
         Changed = true;
         NumColdCC++;
       }
     }
 
     if (hasChangeableCC(F) && !F->isVarArg() &&
if (F->getAttributes().hasAttrSomewhere(Attribute::Nest) &&
       ++NumNestRemoved;
       Changed = true;
     }
   }
   return Changed;
 }
 
 static bool
-OptimizeGlobalVars(Module &M,
-                   function_ref<TargetLibraryInfo &(Function &)> GetTLI,
-                   function_ref<DominatorTree &(Function &)> LookupDomTree,
+OptimizeGlobalVars(Module &M, AnalysisLookup &Lookup,
                    SmallPtrSetImpl<const Comdat *> &NotDiscardableComdats) {
   bool Changed = false;
 
   for (Module::global_iterator GVI = M.global_begin(), E = M.global_end();
        GVI != E; ) {
     GlobalVariable *GV = &*GVI++;
     // Global variables without names cannot be referenced outside this module.
     if (!GV->hasName() && !GV->isDeclaration() && !GV->hasLocalLinkage())
if (GV->hasInitializer())
           GV->setInitializer(New);
       }
 
     if (deleteIfDead(*GV, NotDiscardableComdats)) {
       Changed = true;
       continue;
     }
 
-    Changed |= processGlobal(*GV, GetTLI, LookupDomTree);
+    Changed |= processGlobal(*GV, Lookup);
   }
   return Changed;
 }
 
 /// Evaluate a piece of a constantexpr store into a global initializer.  This
 /// returns 'Init' modified to reflect 'Val' stored into it.  At this point, the
 /// GEP operands of Addr [0, OpNo) have been stepped into.
 static Constant *EvaluateStoreInto(Constant *Init, Constant *Val,
for (auto I = CXAAtExitFn->user_begin(), E = CXAAtExitFn->user_end();
     ++NumCXXDtorsRemoved;
 
     Changed |= true;
   }
 
   return Changed;
 }
 
-static bool optimizeGlobalsInModule(
-    Module &M, const DataLayout &DL,
-    function_ref<TargetLibraryInfo &(Function &)> GetTLI,
-    function_ref<TargetTransformInfo &(Function &)> GetTTI,
-    function_ref<BlockFrequencyInfo &(Function &)> GetBFI,
-    function_ref<DominatorTree &(Function &)> LookupDomTree) {
+static bool optimizeGlobalsInModule(Module &M, const DataLayout &DL,
+                                    AnalysisLookup &Lookup) {
   SmallPtrSet<const Comdat *, 8> NotDiscardableComdats;
   bool Changed = false;
   bool LocalChange = true;
   while (LocalChange) {
     LocalChange = false;
 
     NotDiscardableComdats.clear();
     for (const GlobalVariable &GV : M.globals())
       if (const Comdat *C = GV.getComdat())
         if (!GV.isDiscardableIfUnused() || !GV.use_empty())
           NotDiscardableComdats.insert(C);
     for (Function &F : M)
       if (const Comdat *C = F.getComdat())
         if (!F.isDefTriviallyDead())
           NotDiscardableComdats.insert(C);
     for (GlobalAlias &GA : M.aliases())
       if (const Comdat *C = GA.getComdat())
         if (!GA.isDiscardableIfUnused() || !GA.use_empty())
           NotDiscardableComdats.insert(C);
 
     // Delete functions that are trivially dead, ccc -> fastcc
-    LocalChange |= OptimizeFunctions(M, GetTLI, GetTTI, GetBFI, LookupDomTree,
-                                     NotDiscardableComdats);
+    LocalChange |= OptimizeFunctions(M, Lookup, NotDiscardableComdats);
 
     // Optimize global_ctors list.
     LocalChange |= optimizeGlobalCtorsList(M, [&](Function *F) {
-      return EvaluateStaticConstructor(F, DL, &GetTLI(*F));
+      return EvaluateStaticConstructor(F, DL, &Lookup.GetTLI(*F));
     });
 
     // Optimize non-address-taken globals.
-    LocalChange |=
-        OptimizeGlobalVars(M, GetTLI, LookupDomTree, NotDiscardableComdats);
+    LocalChange |= OptimizeGlobalVars(M, Lookup, NotDiscardableComdats);
 
     // Resolve aliases, when possible.
     LocalChange |= OptimizeGlobalAliases(M, NotDiscardableComdats);
 
     // Try to remove trivial global destructors if they are not removed
     // already.
-    Function *CXAAtExitFn = FindCXAAtExit(M, GetTLI);
+    Function *CXAAtExitFn = FindCXAAtExit(M, Lookup.GetTLI);
     if (CXAAtExitFn)
       LocalChange |= OptimizeEmptyGlobalCXXDtors(CXAAtExitFn);
 
     Changed |= LocalChange;
   }
 
   // TODO: Move all global ctors functions to the end of the module for code
   // layout.
 
   return Changed;
 }
 
 PreservedAnalyses GlobalOptPass::run(Module &M, ModuleAnalysisManager &AM) {
     auto &DL = M.getDataLayout();
     auto &FAM =
         AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
-    auto LookupDomTree = [&FAM](Function &F) -> DominatorTree &{
+    auto LookupDomTree = [&FAM](Function &F) -> DominatorTree & {
       return FAM.getResult<DominatorTreeAnalysis>(F);
     };
+    auto LookupDomTreeIfAvailable = [&FAM](Function &F) -> DominatorTree * {
+      return FAM.getCachedResult<DominatorTreeAnalysis>(F);
+    };
     auto GetTLI = [&FAM](Function &F) -> TargetLibraryInfo & {
       return FAM.getResult<TargetLibraryAnalysis>(F);
     };
     auto GetTTI = [&FAM](Function &F) -> TargetTransformInfo & {
       return FAM.getResult<TargetIRAnalysis>(F);
     };
 
     auto GetBFI = [&FAM](Function &F) -> BlockFrequencyInfo & {
       return FAM.getResult<BlockFrequencyAnalysis>(F);
     };
 
-    if (!optimizeGlobalsInModule(M, DL, GetTLI, GetTTI, GetBFI, LookupDomTree))
+    AnalysisLookup Lookup(GetTLI, GetTTI, GetBFI, LookupDomTree,
+                          LookupDomTreeIfAvailable, true);
+    if (!optimizeGlobalsInModule(M, DL, Lookup))
       return PreservedAnalyses::all();
     return PreservedAnalyses::none();
 }
 
 namespace {
 
 struct GlobalOptLegacyPass : public ModulePass {
   static char ID; // Pass identification, replacement for typeid
 
   GlobalOptLegacyPass() : ModulePass(ID) {
     initializeGlobalOptLegacyPassPass(*PassRegistry::getPassRegistry());
   }
 
   bool runOnModule(Module &M) override {
     if (skipModule(M))
       return false;
 
     auto &DL = M.getDataLayout();
     auto LookupDomTree = [this](Function &F) -> DominatorTree & {
       return this->getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
     };
+    auto LookupDomTreeIfAvailable = [](Function &F) -> DominatorTree * {
+      return nullptr;
+    };
     auto GetTLI = [this](Function &F) -> TargetLibraryInfo & {
       return this->getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
     };
     auto GetTTI = [this](Function &F) -> TargetTransformInfo & {
       return this->getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
     };
 
     auto GetBFI = [this](Function &F) -> BlockFrequencyInfo & {
       return this->getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI();
     };
 
-    return optimizeGlobalsInModule(M, DL, GetTLI, GetTTI, GetBFI,
-                                   LookupDomTree);
+    AnalysisLookup Lookup(GetTLI, GetTTI, GetBFI, LookupDomTree,
+                          LookupDomTreeIfAvailable, false);
+    return optimizeGlobalsInModule(M, DL, Lookup);
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<TargetLibraryInfoWrapperPass>();
     AU.addRequired<TargetTransformInfoWrapperPass>();
     AU.addRequired<DominatorTreeWrapperPass>();
     AU.addRequired<BlockFrequencyInfoWrapperPass>();
   }