[NFC][NewPM] Remove some AnalysisManager invalidate methods

[aeubanks]

Summary

These were misleading, they're more of a "clear" than an "invalidate".

We shouldn't be individually clearing analysis results. Either we clear
all analyses when some IR becomes invalid, or we properly go through
invalidation.

There was only one use of this, which can be simulated with
AM.invalidate(F, PA).

[aeubanks]

This does break https://reviews.llvm.org/D98103, but IMO that analysis shouldn't be immutable, but rather just a typical function analysis that can be invalidated like any other stateful function analysis result.

[mtrofin]

In D100519#2690299, @aeubanks wrote:

This does break https://reviews.llvm.org/D98103, but IMO that analysis shouldn't be immutable, but rather just a typical function analysis that can be invalidated like any other stateful function analysis result.

Right, that captures what we agreed would be desirable.

[mtrofin]

llvm/include/llvm/IR/PassManager.h

867

so is there a way then to tell the FAM to delete an immutable analysis, or nothing uses that?

one possible scenario may be in the case the analysis occupies too much memory, and there's a good place to dispose of it.

[aeubanks]

llvm/include/llvm/IR/PassManager.h

867

Immutable analyses are generally stateless so they should be fairly small.

There wouldn't be a way to tell the FAM to delete an immutable analysis, outside of clearing all analyses for some (invalidated) IR. But I think that should be fine.

[mtrofin]

llvm/include/llvm/IR/PassManager.h

867

Immutable analyses are generally stateless so they should be fairly small.

Profile info could be large, for instance.

There wouldn't be a way to tell the FAM to delete an immutable analysis, outside of clearing all analyses for some (invalidated) IR. But I think that should be fine.

We could rename instead the invalidate API to "clearResult"?

[aeubanks]

Ah yeah profile summary info could be large.

But it doesn't seem like memory usage is a big issue right now. We can always revive these methods later if we want to.

[mtrofin]

In D100519#2690433, @aeubanks wrote:

Ah yeah profile summary info could be large.

But it doesn't seem like memory usage is a big issue right now. We can always revive these methods later if we want to.

True. It's also possible for the immutable analysis to offer its own APIs for managing its state.

llvm/include/llvm/IR/PassManager.h

if (PassPtr)
       // Already registered this pass type!
       return false;
 
     // Construct a new model around the instance returned by the builder.
     PassPtr.reset(new PassModelT(PassBuilder()));
     return true;
   }
 
-  /// Invalidate a specific analysis pass for an IR unit.
-  ///
-  /// Note that the analysis result can disregard invalidation, if it determines
-  /// it is in fact still valid.
-  template <typename PassT> void invalidate(IRUnitT &IR) {
-    assert(AnalysisPasses.count(PassT::ID()) &&
-           "This analysis pass was not registered prior to being invalidated");
-    invalidateImpl(PassT::ID(), IR);
-  }
-
   /// Invalidate cached analyses for an IR unit.
   ///
   /// Walk through all of the analyses pertaining to this unit of IR and
   /// invalidate them, unless they are preserved by the PreservedAnalyses set.
   void invalidate(IRUnitT &IR, const PreservedAnalyses &PA);
 
 private:
   /// Look up a registered analysis pass.
private:
 
   /// Get a cached analysis result or return null.
   ResultConceptT *getCachedResultImpl(AnalysisKey *ID, IRUnitT &IR) const {
     typename AnalysisResultMapT::const_iterator RI =
         AnalysisResults.find({ID, &IR});
     return RI == AnalysisResults.end() ? nullptr : &*RI->second->second;
   }
 
-  /// Invalidate a pass result for a IR unit.
-  void invalidateImpl(AnalysisKey *ID, IRUnitT &IR) {
-    typename AnalysisResultMapT::iterator RI =
-        AnalysisResults.find({ID, &IR});
-    if (RI == AnalysisResults.end())
-      return;
-
-    if (DebugLogging)
-      dbgs() << "Invalidating analysis: " << this->lookUpPass(ID).name()
-             << " on " << IR.getName() << "\n";
-    AnalysisResultLists[&IR].erase(RI->second);
-    AnalysisResults.erase(RI);
-  }
-
   /// Map type from analysis pass ID to pass concept pointer.
   using AnalysisPassMapT =
       DenseMap<AnalysisKey *, std::unique_ptr<PassConceptT>>;
 
   /// Collection of analysis passes, indexed by ID.
   AnalysisPassMapT AnalysisPasses;
 
   /// Map from IR unit to a list of analysis results.

llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

bool Changed = false;
     bool CFGChanged = false;
     for (const auto &L : LI) {
       CFGChanged |= simplifyLoop(L, &DT, &LI, &SE, nullptr, nullptr,
                                  /*PreserveLCSSA=*/false);
       Changed |= formLCSSARecursively(*L, DT, &LI, &SE);
     }
     Changed |= CFGChanged;
 
-    if (CFGChanged && !SkipProfitabilityChecks)
-      AM.invalidate<BlockFrequencyAnalysis>(F);
+    if (CFGChanged && !SkipProfitabilityChecks) {
+      PreservedAnalyses PA = PreservedAnalyses::all();
+      PA.abandon<BlockFrequencyAnalysis>();
+      AM.invalidate(F, PA);
+    }
   }
 
   SmallPriorityWorklist<Loop *, 4> Worklist;
   appendLoopsToWorklist(LI, Worklist);
   auto LPMAddNewLoop = [&Worklist](Loop *NL, bool IsSubloop) {
     if (!IsSubloop)
       appendLoopsToWorklist(*NL, Worklist);
   };
 
   while (!Worklist.empty()) {
     Loop *L = Worklist.pop_back_val();
     if (IRCE.run(L, LPMAddNewLoop)) {
       Changed = true;
-      if (!SkipProfitabilityChecks)
-        AM.invalidate<BlockFrequencyAnalysis>(F);
+      if (!SkipProfitabilityChecks) {
+        PreservedAnalyses PA = PreservedAnalyses::all();
+        PA.abandon<BlockFrequencyAnalysis>();
+        AM.invalidate(F, PA);
+      }
     }
   }
 
   if (!Changed)
     return PreservedAnalyses::all();
   return getLoopPassPreservedAnalyses();
 }