Verify that assumption cache has valid entries.

[hiraditya]

Summary

Verify the AssumptionCache of the original function to make sure no stale entries remain

[hiraditya]

llvm/test/Transforms/HotColdSplit/assumption-cache-invalidation.ll

3

The fix is in: https://reviews.llvm.org/D68318

[hiraditya]

remove XFAIL now that fix had landed

[hiraditya]

Reviewed and committed: https://reviews.llvm.org/D67941

llvm/include/llvm/Transforms/Utils/CodeExtractor.h

CodeExtractor(DominatorTree &DT, Loop &L, bool AggregateArgs = false,
                   std::string Suffix = "");
 
     /// Perform the extraction, returning the new function.
     ///
     /// Returns zero when called on a CodeExtractor instance where isEligible
     /// returns false.
     Function *extractCodeRegion();
 
+    /// Verify that assumption cache isn't stale after a region is extracted.
+    /// Returns false when verifier finds errors. AssumptionCache is passed as
+    /// parameter to make this function stateless.
+    static bool verifyAssumptionCache(const Function& F, AssumptionCache *AC);
+
     /// Test whether this code extractor is eligible.
     ///
     /// Based on the blocks used when constructing the code extractor,
     /// determine whether it is eligible for extraction.
     /// 
     /// Checks that varargs handling (with vastart and vaend) is only done in
     /// the outlined blocks.
     bool isEligible() const;

llvm/lib/Transforms/Utils/CodeExtractor.cpp

if (doesNotReturn)
     newFunction->setDoesNotReturn();
 
   LLVM_DEBUG(if (verifyFunction(*newFunction, &errs())) {
     newFunction->dump();
     report_fatal_error("verification of newFunction failed!");
   });
   LLVM_DEBUG(if (verifyFunction(*oldFunction))
              report_fatal_error("verification of oldFunction failed!"));
+  LLVM_DEBUG(if (AC && verifyAssumptionCache(*oldFunction, AC))
+             report_fatal_error("Stale Asumption cache for old Function!"));
   return newFunction;
 }
+
+bool CodeExtractor::verifyAssumptionCache(const Function& F,
+                                          AssumptionCache *AC) {
+  for (auto AssumeVH : AC->assumptions()) {
+    CallInst *I = cast<CallInst>(AssumeVH);
+    if (I->getParent()->getParent() != &F)
+      return true;
+  }
+  return false;
+}

llvm/test/Transforms/HotColdSplit/assumption-cache-invalidation.ll

-; RUN: opt -instcombine -hotcoldsplit -instsimplify %s -o /dev/null
+; REQUIRES: asserts
+; RUN: opt -instcombine -hotcoldsplit -instsimplify -debug %s -o /dev/null
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64"
 
 %a = type { i64, i64 }
 %b = type { i64 }
 
 define void @f() {
 entry: