CallerAnalysis: be more tolerant about missing FunctionInfos.

In theory, the analysis invalidation notifications should assure that every function has a CallerAnalysis::FunctionInfo in `funcInfos`.
But it's not unlikely that we are missing some of those notifications.
We got some not-reproducible crash reports because of missing function infos in CallerAnalysis.
With this change the analysis accepts missing function infos and does the right thing if such an info is missing.

In the long term we should replace CallerAnalysis by FunctionUses, anyway.

rdar://99653954

Author: eeckstein

include/swift/SILOptimizer/Analysis/CallerAnalysis.h

@@ -91,12 +91,7 @@ class CallerAnalysis final : public SILAnalysis {
 
   /// Notify the analysis about a function which will be deleted from the
   /// module.
-  void notifyWillDeleteFunction(SILFunction *f) override {
-    invalidateAllInfo(f);
-    recomputeFunctionList.remove(f);
-    // Now that we have invalidated all references to the function, delete it.
-    funcInfos.erase(f);
-  }
+  void notifyWillDeleteFunction(SILFunction *f) override;
 
   /// Notify the analysis about changed witness or vtables.
   ///
@@ -107,6 +102,9 @@ class CallerAnalysis final : public SILAnalysis {
 
   /// Look up the function info that we have stored for f, recomputing all
   /// invalidating parts of the call graph.
+  ///
+  /// Warning: The returned FunctionInfo is only alive until the next call to
+  /// `getFunctionInfo`.
   const FunctionInfo &getFunctionInfo(SILFunction *f) const;
 
   SWIFT_DEBUG_DUMP;
@@ -146,7 +144,7 @@ class CallerAnalysis final : public SILAnalysis {
   void invalidateKnownCallees(SILFunction *caller, FunctionInfo &callerInfo);
 
   /// Invalidate both the known callees of f and the known callers of f.
-  void invalidateAllInfo(SILFunction *f);
+  void invalidateAllInfo(SILFunction *f, FunctionInfo &fInfo);
 
   /// Helper method that reprocesses all elements of recomputeFunctionList and
   /// then clears the function list.

lib/SILOptimizer/Analysis/CallerAnalysis.cpp

@@ -48,16 +48,14 @@ struct CallerAnalysis::ApplySiteFinderVisitor
     : SILInstructionVisitor<ApplySiteFinderVisitor, bool> {
   CallerAnalysis *analysis;
   SILFunction *callerFn;
-  FunctionInfo &callerInfo;
 
 #ifndef NDEBUG
   SmallPtrSet<SILInstruction *, 8> visitedCallSites;
   SmallSetVector<SILInstruction *, 8> callSitesThatMustBeVisited;
 #endif
 
   ApplySiteFinderVisitor(CallerAnalysis *analysis, SILFunction *callerFn)
-      : analysis(analysis), callerFn(callerFn),
-        callerInfo(analysis->unsafeGetFunctionInfo(callerFn)) {}
+      : analysis(analysis), callerFn(callerFn) {}
   ~ApplySiteFinderVisitor();
 
   bool visitSILInstruction(SILInstruction *) { return false; }
@@ -120,14 +118,14 @@ bool CallerAnalysis::ApplySiteFinderVisitor::visitFunctionRefBaseInst(
     FunctionRefBaseInst *fri) {
   auto optResult = findLocalApplySites(fri);
   auto *calleeFn = fri->getInitiallyReferencedFunction();
-  FunctionInfo &calleeInfo = analysis->unsafeGetFunctionInfo(calleeFn);
 
   // First make an edge from our callerInfo to our calleeState for invalidation
   // purposes.
-  callerInfo.calleeStates.insert(calleeFn);
+  analysis->getOrInsertFunctionInfo(callerFn).calleeStates.insert(calleeFn);
 
   // Then grab our callee state and update it with state for this caller.
-  auto iter = calleeInfo.callerStates.insert({callerFn, {}});
+  auto iter = analysis->getOrInsertFunctionInfo(calleeFn).callerStates.
+                  insert({callerFn, {}});
   // If we succeeded in inserting a new value, put in an optimistic
   // value for escaping.
   if (iter.second) {
@@ -222,6 +220,10 @@ const FunctionInfo &CallerAnalysis::getFunctionInfo(SILFunction *f) const {
   // Recompute every function in the invalidated function list and empty the
   // list.
   auto &self = const_cast<CallerAnalysis &>(*this);
+  if (funcInfos.find(f) == funcInfos.end()) {
+    (void)self.getOrInsertFunctionInfo(f);
+    self.recomputeFunctionList.insert(f);
+  }
   self.processRecomputeFunctionList();
   return self.unsafeGetFunctionInfo(f);
 }
@@ -262,11 +264,7 @@ void CallerAnalysis::processFunctionCallSites(SILFunction *callerFn) {
   visitor.process();
 }
 
-void CallerAnalysis::invalidateAllInfo(SILFunction *f) {
-  // Look up the callees that our caller refers to and invalidate any
-  // values that point back at the caller.
-  FunctionInfo &fInfo = unsafeGetFunctionInfo(f);
-
+void CallerAnalysis::invalidateAllInfo(SILFunction *f, FunctionInfo &fInfo) {
   // Then we first eliminate any callees that we point at.
   invalidateKnownCallees(f, fInfo);
 
@@ -303,9 +301,12 @@ void CallerAnalysis::invalidateKnownCallees(SILFunction *caller,
 }
 
 void CallerAnalysis::invalidateKnownCallees(SILFunction *caller) {
-  // Look up the callees that our caller refers to and invalidate any
-  // values that point back at the caller.
-  invalidateKnownCallees(caller, unsafeGetFunctionInfo(caller));
+  auto iter = funcInfos.find(caller);
+  if (iter != funcInfos.end()) {
+    // Look up the callees that our caller refers to and invalidate any
+    // values that point back at the caller.
+    invalidateKnownCallees(caller, iter->second);
+  }
 }
 
 void CallerAnalysis::verify(SILFunction *caller) const {
@@ -377,6 +378,17 @@ void CallerAnalysis::invalidate() {
   }
 }
 
+void CallerAnalysis::notifyWillDeleteFunction(SILFunction *f) {
+  auto iter = funcInfos.find(f);
+  if (iter == funcInfos.end())
+    return;
+    
+  invalidateAllInfo(f, iter->second);
+  recomputeFunctionList.remove(f);
+  // Now that we have invalidated all references to the function, delete it.
+  funcInfos.erase(iter);
+}
+
 //===----------------------------------------------------------------------===//
 //                         CallerAnalysis YAML Dumper
 //===----------------------------------------------------------------------===//