diff --git a/include/swift/SILAnalysis/AliasAnalysis.h b/include/swift/SILAnalysis/AliasAnalysis.h
index 31dbd1c9b50..ec556eff635 100644
--- a/include/swift/SILAnalysis/AliasAnalysis.h
+++ b/include/swift/SILAnalysis/AliasAnalysis.h
@@ -127,9 +127,11 @@ public:
     return getMemoryBehavior(Inst, V) == MemoryBehavior::MayHaveSideEffects;
   }
 
-  virtual void invalidate(InvalidationKind K) { AliasCache.clear(); }
+  virtual void invalidate(SILAnalysis::PreserveKind K) { AliasCache.clear(); }
 
-  virtual void invalidate(SILFunction *, InvalidationKind K) { invalidate(K); }
+  virtual void invalidate(SILFunction *, SILAnalysis::PreserveKind K) {
+    invalidate(K);
+  }
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
diff --git a/include/swift/SILAnalysis/Analysis.h b/include/swift/SILAnalysis/Analysis.h
index 8985db5698b..1d15c69ee84 100644
--- a/include/swift/SILAnalysis/Analysis.h
+++ b/include/swift/SILAnalysis/Analysis.h
@@ -27,15 +27,21 @@ namespace swift {
   /// The base class for all SIL-level analysis.
   class SILAnalysis {
   public:
-    /// The invalidation Lattice.
-    /// This is a hierarchy of invalidation messages that are sent to analysis
-    /// objects. Every invalidation kind invalidates the levels before it. For
-    /// example, CFG invalidates Instructions and CFG.
-    enum class InvalidationKind {
-      Instructions,  // Invalidate instruction-related analysis.
-      CFG,           // The control flow changes.
-      CallGraph,     // The call graph changed.
-      All,           // Invalidate everything.
+    /// This is a list of values that allow passes to communicate to analysis
+    /// which traits of the code were preserved. Based on this information
+    /// the analysis can decide if it needs to be invalidated. This information
+    /// may refer to a specific function or to a list of functions depending
+    /// on the context in which it is used.
+    enum PreserveKind : unsigned {
+      Nothing     = 0x0,   // The pass does not preserve any analysis trait.
+      Calls       = 0x1,   // The pass did not modify any calls.
+      Branches    = 0x2,   // The pass did not modify any branches.
+
+      // This is a list of combined traits that is defined to make the use of
+      /// the invalidation API more convenient.
+      ProgramFlow = Calls | Branches, // The pass changed some instructions but
+                                   // did not change the overall flow
+                                   // of the code.
     };
 
     /// A list of the known analysis.
@@ -82,10 +88,10 @@ namespace swift {
     bool isLocked() { return invalidationLock; }
 
     /// Invalidate all information in this analysis.
-    virtual void invalidate(InvalidationKind K) {}
+    virtual void invalidate(PreserveKind K) {}
 
     /// Invalidate all of the information for a specific function.
-    virtual void invalidate(SILFunction *F, InvalidationKind K) {}
+    virtual void invalidate(SILFunction *F, PreserveKind K) {}
 
     /// Verify the state of this analysis.
     virtual void verify() const {}
@@ -109,12 +115,12 @@ namespace swift {
       return S->getKind() == AnalysisKind::CompleteFuncs;
     }
 
-    virtual void invalidate(InvalidationKind K) {
+    virtual void invalidate(PreserveKind K) {
       IsModulePending = true;
       HasChanged = true;
     }
 
-    virtual void invalidate(SILFunction* F, InvalidationKind) {
+    virtual void invalidate(SILFunction* F, PreserveKind) {
       PendingFuncs.insert(F);
       HasChanged = true;
     }
diff --git a/include/swift/SILAnalysis/CallGraphAnalysis.h b/include/swift/SILAnalysis/CallGraphAnalysis.h
index a8826658658..3ee4fbe3505 100644
--- a/include/swift/SILAnalysis/CallGraphAnalysis.h
+++ b/include/swift/SILAnalysis/CallGraphAnalysis.h
@@ -356,15 +356,15 @@ public:
     return *CG;
   }
 
-  virtual void invalidate(InvalidationKind K) {
-    if (K >= InvalidationKind::CallGraph) {
+  virtual void invalidate(SILAnalysis::PreserveKind K) {
+    if (!(K & PreserveKind::Calls)) {
       BottomUpFunctionOrder.clear();
       delete CG;
       CG = nullptr;
     }
   }
 
-  virtual void invalidate(SILFunction*, InvalidationKind K) { invalidate(K); }
+  virtual void invalidate(SILFunction*, SILAnalysis::PreserveKind K) { invalidate(K); }
 
   virtual void verify() const;
 };
diff --git a/include/swift/SILAnalysis/ClassHierarchyAnalysis.h b/include/swift/SILAnalysis/ClassHierarchyAnalysis.h
index b48dd8f4425..07bdbe6ee7e 100644
--- a/include/swift/SILAnalysis/ClassHierarchyAnalysis.h
+++ b/include/swift/SILAnalysis/ClassHierarchyAnalysis.h
@@ -42,12 +42,8 @@ public:
     return S->getKind() == AnalysisKind::ClassHierarchyAnalysis;
   }
 
-  virtual void invalidate(InvalidationKind K) {
-    if (K >= InvalidationKind::All) {
-      DirectSubclassesCache.clear();
-      IndirectSubclassesCache.clear();
-      init(); 
-    }
+  virtual void invalidate(SILAnalysis::PreserveKind K) {
+    // Nothing can invalidate the ClassHierarchyAnalysis!
   }
 
 
@@ -80,7 +76,7 @@ public:
            IndirectSubclassesCache[C].size() > 0;
   }
 
-  virtual void invalidate(SILFunction *F, InvalidationKind K) {
+  virtual void invalidate(SILFunction *F, SILAnalysis::PreserveKind K) {
     invalidate(K);
   }
 
diff --git a/include/swift/SILAnalysis/DominanceAnalysis.h b/include/swift/SILAnalysis/DominanceAnalysis.h
index 79d0daa8bab..39033570ce9 100644
--- a/include/swift/SILAnalysis/DominanceAnalysis.h
+++ b/include/swift/SILAnalysis/DominanceAnalysis.h
@@ -60,11 +60,9 @@ class SILInstruction;
       return S->getKind() == AnalysisKind::Dominance;
     }
 
-    virtual void invalidate(InvalidationKind K) {
+    virtual void invalidate(SILAnalysis::PreserveKind K) {
       assert(!isLocked() && "invalidating a locked analysis?!");
-      // FIXME: Invalidating the call graph should not invalidate the domtrees
-      // of all functions.
-      if (K >= InvalidationKind::CFG) {
+      if (!(K & PreserveKind::Branches)) {
         // Delete Dominance Info.
         for (auto D : DomInfo)
           delete D.second;
@@ -79,8 +77,8 @@ class SILInstruction;
       }
     }
 
-    virtual void invalidate(SILFunction* F, InvalidationKind K) {
-      if (K >= InvalidationKind::CFG) {
+    virtual void invalidate(SILFunction* F, SILAnalysis::PreserveKind K) {
+      if (!(K & PreserveKind::Branches)) {
         auto &it= DomInfo.FindAndConstruct(F);
         if (it.second) {
           delete it.second;
diff --git a/include/swift/SILAnalysis/IVAnalysis.h b/include/swift/SILAnalysis/IVAnalysis.h
index 96951fa3f72..28c2886c39a 100644
--- a/include/swift/SILAnalysis/IVAnalysis.h
+++ b/include/swift/SILAnalysis/IVAnalysis.h
@@ -94,22 +94,18 @@ public:
     return *IVInfos[F];
   }
 
-  virtual void invalidate(InvalidationKind K) {
-    if (K >= InvalidationKind::Instructions) {
+  virtual void invalidate(SILAnalysis::PreserveKind K) {
       for (auto IVI : IVInfos)
         delete IVI.second;
 
       IVInfos.clear();
-    }
   }
 
-  virtual void invalidate(SILFunction *F, InvalidationKind K) {
-    if (K >= InvalidationKind::Instructions) {
+  virtual void invalidate(SILFunction *F, SILAnalysis::PreserveKind K) {
       if (IVInfos.count(F)) {
         delete IVInfos[F];
         IVInfos.erase(F);
       }
-    }
   }
 
 private:
diff --git a/include/swift/SILAnalysis/LoopAnalysis.h b/include/swift/SILAnalysis/LoopAnalysis.h
index c2d940b18fd..46a13a27c0f 100644
--- a/include/swift/SILAnalysis/LoopAnalysis.h
+++ b/include/swift/SILAnalysis/LoopAnalysis.h
@@ -46,8 +46,8 @@ public:
     return S->getKind() == AnalysisKind::LoopInfo;
   }
 
-  virtual void invalidate(InvalidationKind K) {
-    if (K >= InvalidationKind::CFG) {
+  virtual void invalidate(SILAnalysis::PreserveKind K) {
+    if (!(K & PreserveKind::Branches)) {
       for (auto LI : LoopInfos)
         delete LI.second;
 
@@ -56,8 +56,8 @@ public:
     }
   }
 
-  virtual void invalidate(SILFunction* F, InvalidationKind K) {
-    if (K >= InvalidationKind::CFG) {
+  virtual void invalidate(SILFunction* F, SILAnalysis::PreserveKind K) {
+    if (!(K & PreserveKind::Branches)) {
       if (LoopInfos.count(F)) {
         delete LoopInfos[F];
         LoopInfos.erase(F);
diff --git a/include/swift/SILAnalysis/PostOrderAnalysis.h b/include/swift/SILAnalysis/PostOrderAnalysis.h
index a1dabb31a8a..2b6721c59f7 100644
--- a/include/swift/SILAnalysis/PostOrderAnalysis.h
+++ b/include/swift/SILAnalysis/PostOrderAnalysis.h
@@ -98,16 +98,14 @@ public:
     return S->getKind() == AnalysisKind::PostOrder;
   }
 
-  virtual void invalidate(InvalidationKind K) {
-    // FIXME: Invalidating the call graph should not invalidate the domtrees
-    // of all functions.
-    if (K >= InvalidationKind::CFG) {
+  virtual void invalidate(SILAnalysis::PreserveKind K) {
+    if (!(K & PreserveKind::Branches)) {
       FunctionToPOTMap.clear();
     }
   }
 
-  virtual void invalidate(SILFunction* F, InvalidationKind K) {
-    if (K >= InvalidationKind::CFG) {
+  virtual void invalidate(SILFunction* F, SILAnalysis::PreserveKind K) {
+    if (!(K & PreserveKind::Branches)) {
       // Invalidate just this one function. We will lazily recompute it.
       FunctionToPOTMap[F].IsInvalidated = true;
     }
diff --git a/include/swift/SILAnalysis/RCIdentityAnalysis.h b/include/swift/SILAnalysis/RCIdentityAnalysis.h
index 5d90ced2b53..bea6f75c096 100644
--- a/include/swift/SILAnalysis/RCIdentityAnalysis.h
+++ b/include/swift/SILAnalysis/RCIdentityAnalysis.h
@@ -52,14 +52,12 @@ public:
     return S->getKind() == AnalysisKind::RCIdentity;
   }
 
-  virtual void invalidate(InvalidationKind K) {
-    if (K >= InvalidationKind::Instructions) {
+  virtual void invalidate(SILAnalysis::PreserveKind K) {
       Cache.clear();
-    }
   }
 
   // TODO: Add function specific cache to save compile time.
-  virtual void invalidate(SILFunction* F, InvalidationKind K) {
+  virtual void invalidate(SILFunction* F, SILAnalysis::PreserveKind K) {
     invalidate(K);
   }
 
diff --git a/include/swift/SILPasses/PassManager.h b/include/swift/SILPasses/PassManager.h
index b5d69a8bf86..8aaaed747bf 100644
--- a/include/swift/SILPasses/PassManager.h
+++ b/include/swift/SILPasses/PassManager.h
@@ -93,7 +93,7 @@ class SILPassManager {
   void scheduleAnotherIteration() { anotherIteration = true; }
 
   ///  \brief Broadcast the invalidation of the module to all analysis.
-  void invalidateAnalysis(SILAnalysis::InvalidationKind K) {
+  void invalidateAnalysis(SILAnalysis::PreserveKind K) {
     for (auto AP : Analysis)
       if (!AP->isLocked())
         AP->invalidate(K);
@@ -101,7 +101,7 @@ class SILPassManager {
 
   /// \brief Broadcast the invalidation of the function to all analysis.
   void invalidateAnalysis(SILFunction *F,
-                          SILAnalysis::InvalidationKind K) {
+                          SILAnalysis::PreserveKind K) {
     // Invalidate the analysis (unless they are locked)
     for (auto AP : Analysis)
       if (!AP->isLocked())
diff --git a/include/swift/SILPasses/Transforms.h b/include/swift/SILPasses/Transforms.h
index 9d65e128743..6981e60542d 100644
--- a/include/swift/SILPasses/Transforms.h
+++ b/include/swift/SILPasses/Transforms.h
@@ -81,7 +81,7 @@ namespace swift {
   protected:
     SILFunction *getFunction() { return F; }
 
-    void invalidateAnalysis(SILAnalysis::InvalidationKind K) {
+    void invalidateAnalysis(SILAnalysis::PreserveKind K) {
       PM->invalidateAnalysis(F, K);
     }
   };
@@ -108,12 +108,12 @@ namespace swift {
 
     /// Invalidate all of functions in the module, using invalidation
     /// information \p K.
-    void invalidateAnalysis(SILAnalysis::InvalidationKind K) {
+    void invalidateAnalysis(SILAnalysis::PreserveKind K) {
       PM->invalidateAnalysis(K);
     }
 
     /// Invalidate only the function \p F, using invalidation information \p K.
-    void invalidateAnalysis(SILFunction *F, SILAnalysis::InvalidationKind K) {
+    void invalidateAnalysis(SILFunction *F, SILAnalysis::PreserveKind K) {
       PM->invalidateAnalysis(F, K);
     }
 
diff --git a/lib/SILPasses/AllocBoxToStack.cpp b/lib/SILPasses/AllocBoxToStack.cpp
index a08a200cc00..697e8b8ee26 100644
--- a/lib/SILPasses/AllocBoxToStack.cpp
+++ b/lib/SILPasses/AllocBoxToStack.cpp
@@ -790,7 +790,7 @@ class AllocBoxToStack : public SILFunctionTransform {
     if (!Promotable.empty()) {
       auto Count = rewritePromotedBoxes(Promotable, ElidedOperands, Returns);
       NumStackPromoted += Count;
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
     }
   }
 
diff --git a/lib/SILPasses/ArrayBoundsCheckOpts.cpp b/lib/SILPasses/ArrayBoundsCheckOpts.cpp
index bcdf75542a6..5d66453f42a 100644
--- a/lib/SILPasses/ArrayBoundsCheckOpts.cpp
+++ b/lib/SILPasses/ArrayBoundsCheckOpts.cpp
@@ -1135,7 +1135,7 @@ public:
     }
 
     if (Changed)
-      PM->invalidateAnalysis(F, SILAnalysis::InvalidationKind::Instructions);
+      PM->invalidateAnalysis(F, SILAnalysis::PreserveKind::ProgramFlow);
   }
 };
 }
diff --git a/lib/SILPasses/COWArrayOpt.cpp b/lib/SILPasses/COWArrayOpt.cpp
index a9ca44d433b..63fe2704c50 100644
--- a/lib/SILPasses/COWArrayOpt.cpp
+++ b/lib/SILPasses/COWArrayOpt.cpp
@@ -891,7 +891,7 @@ class COWArrayOptPass : public SILFunctionTransform
       HasChanged |= COWArrayOpt(RCIA, L, DA).run();
 
     if (HasChanged)
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   StringRef getName() override { return "SIL COW Array Optimization"; }
@@ -1602,7 +1602,7 @@ void ArrayPropertiesSpecializer::specializeLoopNest() {
 
   // We have potentially cloned a loop - invalidate loop info.
   LoopAnalysis->invalidate(Header->getParent(),
-                           SILAnalysis::InvalidationKind::CFG);
+                           SILAnalysis::PreserveKind::Nothing);
 }
 
 namespace {
@@ -1658,10 +1658,10 @@ class SwiftArrayOptPass : public SILFunctionTransform {
       DEBUG(getFunction()->viewCFG());
     }
 
-    // We preserve the dominator tree.
     if (HasChanged) {
+      // We preserve the dominator tree. Let's invalidate everything else.
       DA->lockInvalidation();
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CFG);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
       DA->unlockInvalidation();
     }
   }
diff --git a/lib/SILPasses/CSE.cpp b/lib/SILPasses/CSE.cpp
index 8b01c85e48c..16ec3da3f2f 100644
--- a/lib/SILPasses/CSE.cpp
+++ b/lib/SILPasses/CSE.cpp
@@ -608,7 +608,7 @@ class SILCSE : public SILFunctionTransform {
 
     CSE C;
     if (C.processFunction(*getFunction(), DA->getDomInfo(getFunction())))
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   StringRef getName() override { return "CSE"; }
diff --git a/lib/SILPasses/CapturePromotion.cpp b/lib/SILPasses/CapturePromotion.cpp
index 7f0ca6eaf07..87ef730818a 100644
--- a/lib/SILPasses/CapturePromotion.cpp
+++ b/lib/SILPasses/CapturePromotion.cpp
@@ -965,7 +965,7 @@ class CapturePromotionPass : public SILModuleTransform {
       processFunction(&F, Worklist);
 
     if (!Worklist.empty())
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
 
     while (!Worklist.empty())
       processFunction(Worklist.pop_back_val(), Worklist);
diff --git a/lib/SILPasses/CapturePropagation.cpp b/lib/SILPasses/CapturePropagation.cpp
index 10f45fb35a6..8bc693860a0 100644
--- a/lib/SILPasses/CapturePropagation.cpp
+++ b/lib/SILPasses/CapturePropagation.cpp
@@ -330,7 +330,7 @@ void CapturePropagation::run() {
   // this conservative in case someone implements interprocedural/dynamic call
   // graph analysis later.
   if (HasChanged)
-    invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph);
+    invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
 }
 
 SILTransform *swift::createCapturePropagation() {
diff --git a/lib/SILPasses/ClosureSpecializer.cpp b/lib/SILPasses/ClosureSpecializer.cpp
index 4a3494b4c94..560f6781e55 100644
--- a/lib/SILPasses/ClosureSpecializer.cpp
+++ b/lib/SILPasses/ClosureSpecializer.cpp
@@ -741,7 +741,7 @@ public:
 
     // Invalidate the call graph.
     if (Changed)
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
 
     // If for testing purposes we were asked to not eliminate dead closures,
     // return.
diff --git a/lib/SILPasses/ConstantPropagation.cpp b/lib/SILPasses/ConstantPropagation.cpp
index 0975c8adb3c..41ce6f0cde7 100644
--- a/lib/SILPasses/ConstantPropagation.cpp
+++ b/lib/SILPasses/ConstantPropagation.cpp
@@ -950,7 +950,7 @@ private:
   void run() override {
     if (CCPFunctionBody(*getFunction(), EnableDiagnostics,
                         getOptions().AssertConfig))
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   StringRef getName() override { return "Constant Propagation"; }
diff --git a/lib/SILPasses/CopyForwarding.cpp b/lib/SILPasses/CopyForwarding.cpp
index f260df2f75d..27bdc44bd42 100644
--- a/lib/SILPasses/CopyForwarding.cpp
+++ b/lib/SILPasses/CopyForwarding.cpp
@@ -312,8 +312,10 @@ public:
     // global hoisting will be done.
     DoGlobalHoisting = !F->isTransparent();
     if (HasChangedCFG) {
-      DomAnalysis->invalidate(F, SILAnalysis::InvalidationKind::CFG);
-      PostOrder->invalidate(F, SILAnalysis::InvalidationKind::CFG);
+      // We are only invalidating the analysis that we use internally.
+      // We'll invalidate the analysis that are used by other passes at the end.
+      DomAnalysis->invalidate(F, SILAnalysis::PreserveKind::Nothing);
+      PostOrder->invalidate(F, SILAnalysis::PreserveKind::Nothing);
     }
     CurrentDef = SILValue();
     IsLoadedFrom = false;
@@ -984,7 +986,7 @@ class CopyForwardingPass : public SILFunctionTransform
     // Perform NRVO
     for (auto Copy : NRVOCopies) {
       performNRVO(Copy);
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
     }
 
     // Perform Copy Forwarding.
@@ -1008,9 +1010,11 @@ class CopyForwardingPass : public SILFunctionTransform
       } while (Forwarding.hasForwardedToCopy());
     }
     if (Forwarding.hasChangedCFG())
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CFG);
+      // We've split critical edges so we can't preserve CFG, but we did not
+      // change calls so we can preserve them.
+      invalidateAnalysis(SILAnalysis::PreserveKind::Calls);
     else
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   StringRef getName() override { return "Copy Forwarding"; }
diff --git a/lib/SILPasses/CropOverflowChecks.cpp b/lib/SILPasses/CropOverflowChecks.cpp
index 4fb4992ba74..97326f5e5a8 100644
--- a/lib/SILPasses/CropOverflowChecks.cpp
+++ b/lib/SILPasses/CropOverflowChecks.cpp
@@ -194,7 +194,7 @@ public:
 
     if (Changed)
       PM->invalidateAnalysis(getFunction(),
-                             SILAnalysis::InvalidationKind::Instructions);
+                             SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   /// Return True if the relationship \p Rel describes a known relation
diff --git a/lib/SILPasses/DeadCodeElimination.cpp b/lib/SILPasses/DeadCodeElimination.cpp
index 472a2b8d80e..b125511154f 100644
--- a/lib/SILPasses/DeadCodeElimination.cpp
+++ b/lib/SILPasses/DeadCodeElimination.cpp
@@ -105,7 +105,7 @@ class DCE : public SILFunctionTransform {
 
     markLive(*F);
     if (removeDead(*F))
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CFG);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
 
   bool precomputeControlInfo(SILFunction &F);
diff --git a/lib/SILPasses/DeadFunctionElimination.cpp b/lib/SILPasses/DeadFunctionElimination.cpp
index 4e8e5dbe4fe..afe679ae671 100644
--- a/lib/SILPasses/DeadFunctionElimination.cpp
+++ b/lib/SILPasses/DeadFunctionElimination.cpp
@@ -456,7 +456,7 @@ class SILDeadFuncElimination : public SILModuleTransform {
     bool changed = deadFunctionElimination.eliminateFunctions();
     
     if (changed)
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
   
   StringRef getName() override { return "Dead Function Elimination"; }
@@ -475,7 +475,7 @@ class SILExternalFuncDefinitionsElimination : public SILModuleTransform {
     bool changed = externalFunctionDefinitionsElimination.eliminateFunctions();
 
     if (changed)
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
 
   StringRef getName() override {
diff --git a/lib/SILPasses/DeadObjectElimination.cpp b/lib/SILPasses/DeadObjectElimination.cpp
index e14edd65d91..559896e53e4 100644
--- a/lib/SILPasses/DeadObjectElimination.cpp
+++ b/lib/SILPasses/DeadObjectElimination.cpp
@@ -293,7 +293,7 @@ class DeadObjectElimination : public SILFunctionTransform {
 
   void run() override {
     if (processFunction(*getFunction()))
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   StringRef getName() override { return "Dead Object Elimination"; }
diff --git a/lib/SILPasses/DefiniteInitialization.cpp b/lib/SILPasses/DefiniteInitialization.cpp
index 1c10c4732b6..b4192fc0c11 100644
--- a/lib/SILPasses/DefiniteInitialization.cpp
+++ b/lib/SILPasses/DefiniteInitialization.cpp
@@ -2003,13 +2003,13 @@ class DefiniteInitialization : public SILFunctionTransform {
   void run() override {
     // Walk through and promote all of the alloc_box's that we can.
     if (checkDefiniteInitialization(*getFunction()))
-      invalidateAnalysis(SILAnalysis::InvalidationKind::All);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
 
     DEBUG(getFunction()->verify());
 
     // Lower raw-sil only instructions used by this pass, like "assign".
     if (lowerRawSILOperations(*getFunction()))
-      invalidateAnalysis(SILAnalysis::InvalidationKind::All);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
 
   StringRef getName() override { return "Definite Initialization"; }
diff --git a/lib/SILPasses/Devirtualizer.cpp b/lib/SILPasses/Devirtualizer.cpp
index c84faa3843c..2b32433e4d6 100644
--- a/lib/SILPasses/Devirtualizer.cpp
+++ b/lib/SILPasses/Devirtualizer.cpp
@@ -83,7 +83,7 @@ public:
     // Invalidate the analysis of caller functions.
     for (auto *AI : DevirtualizedCalls) {
       invalidateAnalysis(AI->getFunction(),
-                         SILAnalysis::InvalidationKind::CallGraph);
+                         SILAnalysis::PreserveKind::Branches);
     }
 
     if (Changed) {
@@ -102,7 +102,7 @@ public:
       if (Specialized) {
         // We've specialized some functions and created new ones, so invalidate
         // the world.
-        invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph);
+        invalidateAnalysis(SILAnalysis::PreserveKind::Branches);
       }
 
       PM->scheduleAnotherIteration();
@@ -494,7 +494,7 @@ namespace {
         Changed |= insertInlineCaches(AI, CHA);
 
       if (Changed) {
-        invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph);
+        invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
       }
     }
 
diff --git a/lib/SILPasses/DiagnoseUnreachable.cpp b/lib/SILPasses/DiagnoseUnreachable.cpp
index 17976484471..1dad0a8258a 100644
--- a/lib/SILPasses/DiagnoseUnreachable.cpp
+++ b/lib/SILPasses/DiagnoseUnreachable.cpp
@@ -748,7 +748,7 @@ namespace {
   class NoReturnFolding : public SILModuleTransform {
     void run() override {
       performNoReturnFunctionProcessing(getModule());
-      invalidateAnalysis(SILAnalysis::InvalidationKind::All);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
     }
     
     StringRef getName() override { return "NoReturnFolding"; }
@@ -764,7 +764,7 @@ namespace {
   class DiagnoseUnreachable : public SILModuleTransform {
     void run() override {
       performSILDiagnoseUnreachable(getModule());
-      invalidateAnalysis(SILAnalysis::InvalidationKind::All);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
     }
 
     StringRef getName() override { return "Diagnose Unreachable"; }
diff --git a/lib/SILPasses/ExternalDefsToDecls.cpp b/lib/SILPasses/ExternalDefsToDecls.cpp
index 55866b2c0d7..492dfb62330 100644
--- a/lib/SILPasses/ExternalDefsToDecls.cpp
+++ b/lib/SILPasses/ExternalDefsToDecls.cpp
@@ -27,7 +27,7 @@ class ExternalDefsToDecls : public SILModuleTransform {
       if (isAvailableExternally(F.getLinkage()) && F.isDefinition())
         F.convertToDeclaration();
 
-    invalidateAnalysis(SILAnalysis::InvalidationKind::All);
+    invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
 
   StringRef getName() override { return "External Defs To Decls"; }
diff --git a/lib/SILPasses/FunctionSignatureOpts.cpp b/lib/SILPasses/FunctionSignatureOpts.cpp
index 37ba7dcca58..ef1c4b1a621 100644
--- a/lib/SILPasses/FunctionSignatureOpts.cpp
+++ b/lib/SILPasses/FunctionSignatureOpts.cpp
@@ -838,7 +838,7 @@ public:
 
     // If we changed anything, invalidate the call graph.
     if (Changed)
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
 
   StringRef getName() override { return "Function Signature Optimization"; }
diff --git a/lib/SILPasses/GenericSpecializer.cpp b/lib/SILPasses/GenericSpecializer.cpp
index 6c5386ab829..35029b86e98 100644
--- a/lib/SILPasses/GenericSpecializer.cpp
+++ b/lib/SILPasses/GenericSpecializer.cpp
@@ -50,7 +50,7 @@ public:
       PM->scheduleAnotherIteration();
 
       // Invalidate the call graph.
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
     }
   }
 
diff --git a/lib/SILPasses/GlobalARCOpts.cpp b/lib/SILPasses/GlobalARCOpts.cpp
index b3ae973b0a6..b00cab2abb5 100644
--- a/lib/SILPasses/GlobalARCOpts.cpp
+++ b/lib/SILPasses/GlobalARCOpts.cpp
@@ -229,7 +229,7 @@ class GlobalARCOpts : public SILFunctionTransform {
     auto *RCIA = getAnalysis<RCIdentityAnalysis>();
     if (processFunction(*getFunction(), false, AA, POTA, RCIA)) {
       processFunction(*getFunction(), true, AA, POTA, RCIA);
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
     }
   }
 
diff --git a/lib/SILPasses/GlobalOpt.cpp b/lib/SILPasses/GlobalOpt.cpp
index cab4398ca77..ae9a26ab9b9 100644
--- a/lib/SILPasses/GlobalOpt.cpp
+++ b/lib/SILPasses/GlobalOpt.cpp
@@ -314,7 +314,7 @@ class SILGlobalOptPass : public SILModuleTransform
   void run() override {
     DominanceAnalysis *DA = PM->getAnalysis<DominanceAnalysis>();
     if (SILGlobalOpt(getModule(), DA).run())
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
 
   StringRef getName() override { return "SIL Global Optimization"; }
diff --git a/lib/SILPasses/LICM.cpp b/lib/SILPasses/LICM.cpp
index 8638f1c5e02..103b253bccf 100644
--- a/lib/SILPasses/LICM.cpp
+++ b/lib/SILPasses/LICM.cpp
@@ -460,9 +460,11 @@ public:
     }
 
     if (Changed) {
-      // TODO: Verify: We have updated the DominanceInfo and SILLoopInfo. It
-      // should be safe not to invalidate the CFG.
-      PM->invalidateAnalysis(F, SILAnalysis::InvalidationKind::Instructions);
+      LA->lockInvalidation();
+      DA->lockInvalidation();
+      PM->invalidateAnalysis(F, SILAnalysis::PreserveKind::Nothing);
+      LA->unlockInvalidation();
+      DA->unlockInvalidation();
     }
   }
 };
diff --git a/lib/SILPasses/Link.cpp b/lib/SILPasses/Link.cpp
index 3a4b79830ec..9dbdedf9e90 100644
--- a/lib/SILPasses/Link.cpp
+++ b/lib/SILPasses/Link.cpp
@@ -48,7 +48,7 @@ class SILLinker : public SILModuleTransform {
       Changed |= M.linkFunction(&Fn, SILModule::LinkingMode::LinkAll);
 
     if (Changed)
-      invalidateAnalysis(SILAnalysis::InvalidationKind::All);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
 
   StringRef getName() override { return "SIL Linker"; }
diff --git a/lib/SILPasses/LoadStoreOpts.cpp b/lib/SILPasses/LoadStoreOpts.cpp
index f23a12fa420..97a4e376d5f 100644
--- a/lib/SILPasses/LoadStoreOpts.cpp
+++ b/lib/SILPasses/LoadStoreOpts.cpp
@@ -1417,7 +1417,7 @@ class GlobalLoadStoreOpts : public SILFunctionTransform {
       Changed = true;
 
     if (Changed)
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   StringRef getName() override { return "SIL Load Store Opts"; }
diff --git a/lib/SILPasses/LoopRotate.cpp b/lib/SILPasses/LoopRotate.cpp
index 569084450c0..4a12084840f 100644
--- a/lib/SILPasses/LoopRotate.cpp
+++ b/lib/SILPasses/LoopRotate.cpp
@@ -576,7 +576,7 @@ class LoopRotation : public SILFunctionTransform {
       // We preserve loop info and the dominator tree.
       DA->lockInvalidation();
       LA->lockInvalidation();
-      PM->invalidateAnalysis(F, SILAnalysis::InvalidationKind::All);
+      PM->invalidateAnalysis(F, SILAnalysis::PreserveKind::Nothing);
       DA->unlockInvalidation();
       LA->unlockInvalidation();
     }
diff --git a/lib/SILPasses/MandatoryInlining.cpp b/lib/SILPasses/MandatoryInlining.cpp
index deee4b43217..b0776a039e9 100644
--- a/lib/SILPasses/MandatoryInlining.cpp
+++ b/lib/SILPasses/MandatoryInlining.cpp
@@ -515,7 +515,7 @@ class MandatoryInlining : public SILModuleTransform {
       M->eraseFunction(&F);
     }
 
-    invalidateAnalysis(SILAnalysis::InvalidationKind::All);
+    invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
 
   StringRef getName() override { return "Mandatory Inlining"; }
diff --git a/lib/SILPasses/MergeCondFail.cpp b/lib/SILPasses/MergeCondFail.cpp
index 4fc40a9bd3e..9c62cd7292a 100644
--- a/lib/SILPasses/MergeCondFail.cpp
+++ b/lib/SILPasses/MergeCondFail.cpp
@@ -81,7 +81,7 @@ public:
     }
     if (Changed)
       PM->invalidateAnalysis(getFunction(),
-                             SILAnalysis::InvalidationKind::Instructions);
+                             SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   /// \brief Try to merge the cond_fail instructions. Returns true if any could
diff --git a/lib/SILPasses/PerformanceInliner.cpp b/lib/SILPasses/PerformanceInliner.cpp
index 30053a231dd..0010cb78e0e 100644
--- a/lib/SILPasses/PerformanceInliner.cpp
+++ b/lib/SILPasses/PerformanceInliner.cpp
@@ -834,8 +834,8 @@ bool SILPerformanceInliner::inlineCallsIntoFunction(SILFunction *Caller,
     // we expect it to have happened.
     assert(Success && "Expected inliner to inline this function!");
     AI->eraseFromParent();
-    DA->invalidate(Caller, SILAnalysis::InvalidationKind::CFG);
-    LA->invalidate(Caller, SILAnalysis::InvalidationKind::CFG);
+    DA->invalidate(Caller, SILAnalysis::PreserveKind::Nothing);
+    LA->invalidate(Caller, SILAnalysis::PreserveKind::Nothing);
     NumFunctionsInlined++;
     Changed = true;
   }
@@ -910,7 +910,7 @@ public:
 
     // Invalidate the call graph.
     if (Changed)
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
 
   StringRef getName() override { return PassName; }
diff --git a/lib/SILPasses/PredictableMemOpt.cpp b/lib/SILPasses/PredictableMemOpt.cpp
index 5fb94e0af08..55a21012b24 100644
--- a/lib/SILPasses/PredictableMemOpt.cpp
+++ b/lib/SILPasses/PredictableMemOpt.cpp
@@ -1000,7 +1000,7 @@ class PredictableMemoryOptimizations : public SILFunctionTransform {
   /// The entry point to the transformation.
   void run() override {
     if (optimizeMemoryAllocations(*getFunction()))
-      invalidateAnalysis(SILAnalysis::InvalidationKind::All);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
 
   StringRef getName() override { return "Predictable Memory Opts"; }
diff --git a/lib/SILPasses/RemovePin.cpp b/lib/SILPasses/RemovePin.cpp
index 3c081bb4e56..33acc046180 100644
--- a/lib/SILPasses/RemovePin.cpp
+++ b/lib/SILPasses/RemovePin.cpp
@@ -109,7 +109,7 @@ public:
 
     if (Changed)
       PM->invalidateAnalysis(getFunction(),
-                             SILAnalysis::InvalidationKind::Instructions);
+                             SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   /// Pin uses are safe if they either mark a dependence or if it is the unpin we
diff --git a/lib/SILPasses/SILCleanup.cpp b/lib/SILPasses/SILCleanup.cpp
index b80c7415615..413538fd6f4 100644
--- a/lib/SILPasses/SILCleanup.cpp
+++ b/lib/SILPasses/SILCleanup.cpp
@@ -62,7 +62,7 @@ class SILCleanup : public swift::SILFunctionTransform {
   /// The entry point to the transformation.
   void run() override {
     cleanFunction(*getFunction());
-    invalidateAnalysis(SILAnalysis::InvalidationKind::All);
+    invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
 
   StringRef getName() override { return "SIL Cleanup"; }
diff --git a/lib/SILPasses/SILCodeMotion.cpp b/lib/SILPasses/SILCodeMotion.cpp
index 360af73d79c..9d5eb9a9f49 100644
--- a/lib/SILPasses/SILCodeMotion.cpp
+++ b/lib/SILPasses/SILCodeMotion.cpp
@@ -1398,7 +1398,7 @@ public:
           " *****\n");
 
     if (processFunction(F, AA, POTA, RCIA, HoistReleases))
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   StringRef getName() override { return "SIL Code Motion"; }
diff --git a/lib/SILPasses/SILCombine.cpp b/lib/SILPasses/SILCombine.cpp
index 3d85c87370e..da8681c9500 100644
--- a/lib/SILPasses/SILCombine.cpp
+++ b/lib/SILPasses/SILCombine.cpp
@@ -327,7 +327,7 @@ class SILCombine : public SILFunctionTransform {
     SILCombiner Combiner(AA, getOptions().RemoveRuntimeAsserts);
     bool Changed = Combiner.runOnFunction(*getFunction());
     if (Changed)
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   StringRef getName() override { return "SIL Combine"; }
diff --git a/lib/SILPasses/SILLowerAggregateInstrs.cpp b/lib/SILPasses/SILLowerAggregateInstrs.cpp
index 3c45e45590c..0f2a9bbff4b 100644
--- a/lib/SILPasses/SILLowerAggregateInstrs.cpp
+++ b/lib/SILPasses/SILLowerAggregateInstrs.cpp
@@ -260,7 +260,7 @@ class SILLowerAggregate : public SILFunctionTransform {
           F->getName() << " *****\n");
     bool Changed = processFunction(*F);
     if (Changed)
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   StringRef getName() override { return "Lower Aggregate Instructions"; }
diff --git a/lib/SILPasses/SILMem2Reg.cpp b/lib/SILPasses/SILMem2Reg.cpp
index 0bc9b541fa0..0f4f74a09fc 100644
--- a/lib/SILPasses/SILMem2Reg.cpp
+++ b/lib/SILPasses/SILMem2Reg.cpp
@@ -845,7 +845,7 @@ class SILMem2Reg : public SILFunctionTransform {
     bool Changed = MemoryToRegisters(*F, DA->getDomInfo(F)).run();
 
     if (Changed)
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   StringRef getName() override { return "SIL Mem2Reg"; }
diff --git a/lib/SILPasses/SILSROA.cpp b/lib/SILPasses/SILSROA.cpp
index c5729efc339..75f7c940492 100644
--- a/lib/SILPasses/SILSROA.cpp
+++ b/lib/SILPasses/SILSROA.cpp
@@ -311,7 +311,7 @@ class SILSROA : public SILFunctionTransform {
           " *****\n");
 
     if (runSROAOnFunction(*F))
-      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+      invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   StringRef getName() override { return "SROA"; }
diff --git a/lib/SILPasses/SimplifyCFG.cpp b/lib/SILPasses/SimplifyCFG.cpp
index 729c7b6fae2..52503eae7bf 100644
--- a/lib/SILPasses/SimplifyCFG.cpp
+++ b/lib/SILPasses/SimplifyCFG.cpp
@@ -2326,7 +2326,7 @@ bool SimplifyCFG::run() {
     RU.run();
 
     // Force dominator recomputation below.
-    PM->invalidateAnalysis(&Fn, SILAnalysis::InvalidationKind::CFG);
+    PM->invalidateAnalysis(&Fn, SILAnalysis::PreserveKind::Nothing);
     Changed = true;
   }
 
@@ -3074,7 +3074,7 @@ class SimplifyCFGPass : public SILFunctionTransform {
   /// The entry point to the transformation.
   void run() override {
     if (SimplifyCFG(*getFunction(), PM).run())
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CFG);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
 
   StringRef getName() override { return "Simplify CFG"; }
@@ -3108,7 +3108,7 @@ public:
         splitAllCriticalEdges(Fn, OnlyNonCondBrEdges, nullptr, nullptr);
 
     if (Changed)
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CFG);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Calls);
   }
 
   StringRef getName() override { return "Split Critical Edges"; }
@@ -3122,7 +3122,7 @@ public:
   /// The entry point to the transformation.
   void run() override {
     if (SimplifyCFG(*getFunction(), PM).simplifyBlockArgs())
-      invalidateAnalysis(SILAnalysis::InvalidationKind::CFG);
+      invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
   }
   
   StringRef getName() override { return "Simplify Block Args"; }
diff --git a/lib/SILPasses/StripDebugInfo.cpp b/lib/SILPasses/StripDebugInfo.cpp
index 3a54b9fb08f..8f6f6ea8426 100644
--- a/lib/SILPasses/StripDebugInfo.cpp
+++ b/lib/SILPasses/StripDebugInfo.cpp
@@ -40,7 +40,7 @@ class StripDebugInfo : public swift::SILFunctionTransform {
   /// The entry point to the transformation.
   void run() override {
     stripFunction(getFunction());
-    invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+    invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
   }
 
   StringRef getName() override { return "Strip Debug Info"; }