Reverted: Track validity of pass results

Commits r291882 and related r291887.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@292062 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/Pass.h

@@ -29,7 +29,6 @@
 #ifndef LLVM_PASS_H
 #define LLVM_PASS_H
 
-#include <assert.h>
 #include <string>
 
 namespace llvm {
@@ -83,39 +82,16 @@ class Pass {
   AnalysisResolver *Resolver;  // Used to resolve analysis
   const void *PassID;
   PassKind Kind;
-  bool Executed;
-
   void operator=(const Pass&) = delete;
   Pass(const Pass &) = delete;
 
 public:
   explicit Pass(PassKind K, char &pid)
-    : Resolver(nullptr), PassID(&pid), Kind(K), Executed(false) { }
+    : Resolver(nullptr), PassID(&pid), Kind(K) { }
   virtual ~Pass();
 
-  PassKind getPassKind() const { return Kind; }
-
-  /// Returns true if the pass has already executed.
-  ///
-  /// For an analysis pass it means the result is available. If the function
-  /// returns false, the pass was not run, was skipped or freed.
-  ///
-  bool isExecuted() const { return Executed; }
 
-  /// Marks the pass as executed or not.
-  ///
-  /// A pass should be marked as executed, if its 'runOn*' method successfully
-  /// finished. When the pass is not needed anymore, it is marked as
-  /// 'non-executed', it takes place in \c freePass. It also occurs when the
-  /// pass is skipped for some reason.
-  ///
-  /// The flag should be set prior to call to 'runOn*' method. If it decides
-  /// that the pass should be skipped, it will reset the flag.
-  ///
-  void setExecuted(bool x) {
-    assert(x || !getAsImmutablePass()); // Immutable pass cannot be invalidated.
-    Executed = x;
-  }
+  PassKind getPassKind() const { return Kind; }
 
   /// getPassName - Return a nice clean name for a pass.  This usually
   /// implemented in terms of the name that is registered by one of the
@@ -303,7 +279,8 @@ class ImmutablePass : public ModulePass {
   ///
   bool runOnModule(Module &) override { return false; }
 
-  explicit ImmutablePass(char &pid) : ModulePass(pid) { setExecuted(true); }
+  explicit ImmutablePass(char &pid)
+  : ModulePass(pid) {}
 
   // Force out-of-line virtual method.
   ~ImmutablePass() override;
@@ -339,9 +316,8 @@ class FunctionPass : public Pass {
 protected:
   /// Optional passes call this function to check whether the pass should be
   /// skipped. This is the case when Attribute::OptimizeNone is set or when
-  /// optimization bisect is over the limit. It also resets flag Executed on
-  /// the pass.
-  bool skipFunction(const Function &F);
+  /// optimization bisect is over the limit.
+  bool skipFunction(const Function &F) const;
 };
 
 

include/llvm/PassAnalysisSupport.h

@@ -206,9 +206,6 @@ AnalysisType *Pass::getAnalysisIfAvailable() const {
   Pass *ResultPass = Resolver->getAnalysisIfAvailable(PI, true);
   if (!ResultPass) return nullptr;
 
-  if (!ResultPass->isExecuted())
-    return nullptr;
-
   // Because the AnalysisType may not be a subclass of pass (for
   // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially
   // adjust the return pointer (because the class may multiply inherit, once
@@ -237,8 +234,6 @@ AnalysisType &Pass::getAnalysisID(AnalysisID PI) const {
   assert (ResultPass && 
           "getAnalysis*() called on an analysis that was not "
           "'required' by pass!");
-  assert(ResultPass->isExecuted() &&
-         "getAnalysis*() called on an analysis that was freed");
 
   // Because the AnalysisType may not be a subclass of pass (for
   // AnalysisGroups), we use getAdjustedAnalysisPointer here to potentially

lib/Analysis/CallGraphSCCPass.cpp

@@ -414,7 +414,6 @@ bool CGPassManager::RunAllPassesOnSCC(CallGraphSCC &CurSCC, CallGraph &CG,
     initializeAnalysisImpl(P);
 
     // Actually run this pass on the current SCC.
-    P->setExecuted(true);
     Changed |= RunPassOnSCC(P, CurSCC, CG,
                             CallGraphUpToDate, DevirtualizedCall);
 

lib/Analysis/LoopInfo.cpp

@@ -731,10 +731,8 @@ void LoopInfoWrapperPass::verifyAnalysis() const {
   // checking by default, LoopPass has been taught to call verifyLoop manually
   // during loop pass sequences.
   if (VerifyLoopInfo) {
-    if (auto *Analysis = getAnalysisIfAvailable<DominatorTreeWrapperPass>()) {
-      auto &DT = Analysis->getDomTree();
-      LI.verify(DT);
-    }
+    auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
+    LI.verify(DT);
   }
 }
 

lib/Analysis/LoopPass.cpp

@@ -198,7 +198,6 @@ bool LPPassManager::runOnFunction(Function &F) {
         PassManagerPrettyStackEntry X(P, *CurrentLoop->getHeader());
         TimeRegion PassTimer(getPassTimer(P));
 
-        P->setExecuted(true);
         Changed |= P->runOnLoop(CurrentLoop, *this);
       }
       LoopWasDeleted = CurrentLoop->isInvalid();

lib/Analysis/RegionPass.cpp

@@ -94,7 +94,6 @@ bool RGPassManager::runOnFunction(Function &F) {
         PassManagerPrettyStackEntry X(P, *CurrentRegion->getEntry());
 
         TimeRegion PassTimer(getPassTimer(P));
-        P->setExecuted(true);
         Changed |= P->runOnRegion(CurrentRegion, *this);
       }
 

lib/CodeGen/MachineDominators.cpp

@@ -69,7 +69,7 @@ void MachineDominatorTree::releaseMemory() {
 }
 
 void MachineDominatorTree::verifyAnalysis() const {
-  if (VerifyMachineDomInfo && isExecuted())
+  if (VerifyMachineDomInfo)
     verifyDomTree();
 }
 

lib/CodeGen/MachineFunctionPass.cpp

@@ -38,10 +38,8 @@ Pass *MachineFunctionPass::createPrinterPass(raw_ostream &O,
 bool MachineFunctionPass::runOnFunction(Function &F) {
   // Do not codegen any 'available_externally' functions at all, they have
   // definitions outside the translation unit.
-  if (F.hasAvailableExternallyLinkage()) {
-    setExecuted(false);
+  if (F.hasAvailableExternallyLinkage())
     return false;
-  }
 
   MachineModuleInfo &MMI = getAnalysis<MachineModuleInfo>();
   MachineFunction &MF = MMI.getMachineFunction(F);

lib/IR/LegacyPassManager.cpp

@@ -955,9 +955,6 @@ void PMDataManager::freePass(Pass *P, StringRef Msg,
         AvailableAnalysis.erase(Pos);
     }
   }
-
-  if (!P->getAsImmutablePass())
-    P->setExecuted(false);
 }
 
 /// Add pass P into the PassVector. Update
@@ -1296,7 +1293,6 @@ bool BBPassManager::runOnFunction(Function &F) {
         PassManagerPrettyStackEntry X(BP, *I);
         TimeRegion PassTimer(getPassTimer(BP));
 
-        BP->setExecuted(true);
         LocalChanged |= BP->runOnBasicBlock(*I);
       }
 
@@ -1463,9 +1459,7 @@ bool FunctionPassManagerImpl::run(Function &F) {
 
   initializeAllAnalysisInfo();
   for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
-    FPPassManager *P = getContainedManager(Index);
-    P->setExecuted(true);
-    Changed |= P->runOnFunction(F);
+    Changed |= getContainedManager(Index)->runOnFunction(F);
     F.getContext().yield();
   }
 
@@ -1516,7 +1510,6 @@ bool FPPassManager::runOnFunction(Function &F) {
       PassManagerPrettyStackEntry X(FP, F);
       TimeRegion PassTimer(getPassTimer(FP));
 
-      FP->setExecuted(true);
       LocalChanged |= FP->runOnFunction(F);
     }
 
@@ -1537,10 +1530,8 @@ bool FPPassManager::runOnFunction(Function &F) {
 bool FPPassManager::runOnModule(Module &M) {
   bool Changed = false;
 
-  for (Function &F : M) {
-    setExecuted(true);
+  for (Function &F : M)
     Changed |= runOnFunction(F);
-  }
 
   return Changed;
 }
@@ -1596,7 +1587,6 @@ MPPassManager::runOnModule(Module &M) {
       PassManagerPrettyStackEntry X(MP, M);
       TimeRegion PassTimer(getPassTimer(MP));
 
-      MP->setExecuted(true);
       LocalChanged |= MP->runOnModule(M);
     }
 
@@ -1700,9 +1690,7 @@ bool PassManagerImpl::run(Module &M) {
 
   initializeAllAnalysisInfo();
   for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
-    MPPassManager *P = getContainedManager(Index);
-    P->setExecuted(true);
-    Changed |= P->runOnModule(M);
+    Changed |= getContainedManager(Index)->runOnModule(M);
     M.getContext().yield();
   }
 

lib/IR/Pass.cpp

@@ -146,16 +146,13 @@ PassManagerType FunctionPass::getPotentialPassManagerType() const {
   return PMT_FunctionPassManager;
 }
 
-bool FunctionPass::skipFunction(const Function &F) {
-  if (!F.getContext().getOptBisect().shouldRunPass(this, F)) {
-    setExecuted(false);
+bool FunctionPass::skipFunction(const Function &F) const {
+  if (!F.getContext().getOptBisect().shouldRunPass(this, F))
     return true;
-  }
 
   if (F.hasFnAttribute(Attribute::OptimizeNone)) {
     DEBUG(dbgs() << "Skipping pass '" << getPassName() << "' on function "
                  << F.getName() << "\n");
-    setExecuted(false);
     return true;
   }
   return false;

test/CodeGen/Generic/externally_available.ll

@@ -1,4 +1,4 @@
-; RUN: llc -verify-machine-dom-info < %s | not grep test_
+; RUN: llc < %s | not grep test_
 
 ; test_function should not be emitted to the .s file.
 define available_externally i32 @test_function() {

test/CodeGen/Mips/mul.ll

@@ -1,4 +1,4 @@
-; RUN: llc  -march=mipsel -mattr=mips16 -relocation-model=pic -O3 -verify-loop-info < %s | FileCheck %s -check-prefix=16
+; RUN: llc  -march=mipsel -mattr=mips16 -relocation-model=pic -O3 < %s | FileCheck %s -check-prefix=16
 
 @iiii = global i32 5, align 4
 @jjjj = global i32 -6, align 4