[Attributor] Split the runTillFixpoint function.

[kuter]

Summary

This patch splits the runTillFixpoint functions into two more functions
to improve readability and prevent logic duplication when we add more
scheduling options.

[jdoerfert]

llvm/include/llvm/Transforms/IPO/Attributor.h

1432

Use SmallVectorImpl<AbstractAttribute *> in APIs, or ArrayRef<...>

llvm/include/llvm/Transforms/IPO/Attributor.h

struct Attributor {
 
   /// Return the data layout associated with the anchor scope.
   const DataLayout &getDataLayout() const { return InfoCache.DL; }
 
   /// The allocator used to allocate memory, e.g. for `AbstractAttribute`s.
   BumpPtrAllocator &Allocator;
 
 private:
+  /// For invalid AAs we can fix dependent AAs that have a required dependence,
+  /// thereby folding long dependence chains in a single step without the need
+  /// to run updates. \see runTillFixpoint.
+  void invalidateTransative(SetVector<AbstractAttribute *> &InvalidAAs,
+                            SmallVector<AbstractAttribute *, 32> &ChangedAAs,
+                            SetVector<AbstractAttribute *> &Worklist);
+
+  /// Reset abstract arguments not settled in a sound fixpoint by the end of
+  /// the fixpoint iteration. This happens when we stopped the fixpoint
+  /// iteration early. Note that only the ones marked as "changed" *and* the
+  /// ones transitively depending on them need to be reverted to a pessimistic
+  /// state. Others might not be in a fixpoint state but we can use the
+  /// optimistic results for them anyway. \see runTillFixpoint.
+  void enforceFixpoint(SmallVector<AbstractAttribute *, 32> &ChangedAAs);
+
   /// This method will do fixpoint iteration until fixpoint or the
   /// maximum iteration count is reached.
   ///
   /// If the maximum iteration count is reached, This method will
   /// indicate pessimistic fixpoint on attributes that transitively depend
   /// on attributes that were scheduled for an update.
   void runTillFixpoint();
 

llvm/lib/Transforms/IPO/Attributor.cpp

for (Instruction *I :
 
     if (!Pred(*I))
       return false;
   }
 
   return true;
 }
 
-void Attributor::runTillFixpoint() {
-  TimeTraceScope TimeScope("Attributor::runTillFixpoint");
-  LLVM_DEBUG(dbgs() << "[Attributor] Identified and initialized "
-                    << DG.SyntheticRoot.Deps.size()
-                    << " abstract attributes.\n");
-
-  // Now that all abstract attributes are collected and initialized we start
-  // the abstract analysis.
-
-  unsigned IterationCounter = 1;
-
-  SmallVector<AbstractAttribute *, 32> ChangedAAs;
-  SetVector<AbstractAttribute *> Worklist, InvalidAAs;
-  Worklist.insert(DG.SyntheticRoot.begin(), DG.SyntheticRoot.end());
-
-  do {
-    // Remember the size to determine new attributes.
-    size_t NumAAs = DG.SyntheticRoot.Deps.size();
-    LLVM_DEBUG(dbgs() << "\n\n[Attributor] #Iteration: " << IterationCounter
-                      << ", Worklist size: " << Worklist.size() << "\n");
-
-    // For invalid AAs we can fix dependent AAs that have a required dependence,
-    // thereby folding long dependence chains in a single step without the need
-    // to run updates.
-    for (unsigned u = 0; u < InvalidAAs.size(); ++u) {
-      AbstractAttribute *InvalidAA = InvalidAAs[u];
+void Attributor::invalidateTransative(
+    SetVector<AbstractAttribute *> &InvalidAAs,
+    SmallVector<AbstractAttribute *, 32> &ChangedAAs,
+    SetVector<AbstractAttribute *> &Worklist) {
 
-      // Check the dependences to fast track invalidation.
-      LLVM_DEBUG(dbgs() << "[Attributor] InvalidAA: " << *InvalidAA << " has "
-                        << InvalidAA->Deps.size()
-                        << " required & optional dependences\n");
-      while (!InvalidAA->Deps.empty()) {
-        const auto &Dep = InvalidAA->Deps.back();
-        InvalidAA->Deps.pop_back();
-        AbstractAttribute *DepAA = cast<AbstractAttribute>(Dep.getPointer());
-        if (Dep.getInt() == unsigned(DepClassTy::OPTIONAL)) {
-          Worklist.insert(DepAA);
-          continue;
-        }
-        DepAA->getState().indicatePessimisticFixpoint();
-        assert(DepAA->getState().isAtFixpoint() && "Expected fixpoint state!");
-        if (!DepAA->getState().isValidState())
-          InvalidAAs.insert(DepAA);
-        else
-          ChangedAAs.push_back(DepAA);
-      }
-    }
+  InvalidAAs.clear();
+}
+
+void Attributor::enforceFixpoint(
+    SmallVector<AbstractAttribute *, 32> &ChangedAAs) {
+  SmallPtrSet<AbstractAttribute *, 32> Visited;
+  for (unsigned u = 0; u < ChangedAAs.size(); u++) {
+    AbstractAttribute *ChangedAA = ChangedAAs[u];
+    if (!Visited.insert(ChangedAA).second)
+      continue;
+
+    AbstractState &State = ChangedAA->getState();
+    if (!State.isAtFixpoint()) {
+      State.indicatePessimisticFixpoint();
+
+      NumAttributesTimedOut++;
+    }
+
+    while (!ChangedAA->Deps.empty()) {
+      ChangedAAs.push_back(
+          cast<AbstractAttribute>(ChangedAA->Deps.back().getPointer()));
+      ChangedAA->Deps.pop_back();
+    }
+  }
+
+  LLVM_DEBUG({
+    if (!Visited.empty())
+      dbgs() << "\n[Attributor] Finalized " << Visited.size()
+             << " abstract attributes.\n";
+  });
+}
+
+void Attributor::runTillFixpoint() {
+  TimeTraceScope TimeScope("Attributor::runTillFixpoint");
+  LLVM_DEBUG(dbgs() << "[Attributor] Identified and initialized "
+                    << DG.SyntheticRoot.Deps.size()
+                    << " abstract attributes.\n");
+
+  // Now that all abstract attributes are collected and initialized we start
+  // the abstract analysis.
+
+  unsigned IterationCounter = 1;
+
+  SmallVector<AbstractAttribute *, 32> ChangedAAs;
+  SetVector<AbstractAttribute *> Worklist, InvalidAAs;
+  Worklist.insert(DG.SyntheticRoot.begin(), DG.SyntheticRoot.end());
+
+  do {
+    // Remember the size to determine new attributes.
+    size_t NumAAs = DG.SyntheticRoot.Deps.size();
+    LLVM_DEBUG(dbgs() << "\n\n[Attributor] #Iteration: " << IterationCounter
+                      << ", Worklist size: " << Worklist.size() << "\n");
+
+    // For invalid AAs we can fix dependent AAs that have a required dependence.
+    invalidateTransative(InvalidAAs, ChangedAAs, Worklist);
 
     // Add all abstract attributes that are potentially dependent on one that
     // changed to the work list.
     for (AbstractAttribute *ChangedAA : ChangedAAs)
       while (!ChangedAA->Deps.empty()) {
         Worklist.insert(
             cast<AbstractAttribute>(ChangedAA->Deps.back().getPointer()));
         ChangedAA->Deps.pop_back();
       }
 
     LLVM_DEBUG(dbgs() << "[Attributor] #Iteration: " << IterationCounter
                       << ", Worklist+Dependent size: " << Worklist.size()
                       << "\n");
 
     // Reset the changed and invalid set.
     ChangedAAs.clear();
-    InvalidAAs.clear();
 
     // Update all abstract attribute in the work list and record the ones that
     // changed.
     for (AbstractAttribute *AA : Worklist) {
       const auto &AAState = AA->getState();
       if (!AAState.isAtFixpoint())
         if (updateAA(*AA) == ChangeStatus::CHANGED)
           ChangedAAs.push_back(AA);
void Attributor::runTillFixpoint() {
   } while (!Worklist.empty() && (IterationCounter++ < MaxFixpointIterations ||
                                  VerifyMaxFixpointIterations));
 
   LLVM_DEBUG(dbgs() << "\n[Attributor] Fixpoint iteration done after: "
                     << IterationCounter << "/" << MaxFixpointIterations
                     << " iterations\n");
 
   // Reset abstract arguments not settled in a sound fixpoint by now. This
-  // happens when we stopped the fixpoint iteration early. Note that only the
-  // ones marked as "changed" *and* the ones transitively depending on them
-  // need to be reverted to a pessimistic state. Others might not be in a
-  // fixpoint state but we can use the optimistic results for them anyway.
-  SmallPtrSet<AbstractAttribute *, 32> Visited;
-  for (unsigned u = 0; u < ChangedAAs.size(); u++) {
-    AbstractAttribute *ChangedAA = ChangedAAs[u];
-    if (!Visited.insert(ChangedAA).second)
-      continue;
-
-    AbstractState &State = ChangedAA->getState();
-    if (!State.isAtFixpoint()) {
-      State.indicatePessimisticFixpoint();
-
-      NumAttributesTimedOut++;
-    }
-
-    while (!ChangedAA->Deps.empty()) {
-      ChangedAAs.push_back(
-          cast<AbstractAttribute>(ChangedAA->Deps.back().getPointer()));
-      ChangedAA->Deps.pop_back();
-    }
-  }
-
-  LLVM_DEBUG({
-    if (!Visited.empty())
-      dbgs() << "\n[Attributor] Finalized " << Visited.size()
-             << " abstract attributes.\n";
-  });
+  // happens when we stopped the fixpoint iteration early.
+  enforceFixpoint(ChangedAAs);
 
   if (VerifyMaxFixpointIterations &&
       IterationCounter != MaxFixpointIterations) {
     errs() << "\n[Attributor] Fixpoint iteration done after: "
            << IterationCounter << "/" << MaxFixpointIterations
            << " iterations\n";
     llvm_unreachable("The fixpoint was not reached with exactly the number of "
                      "specified iterations!");