[ExecutionDepsFix] Don't recurse over the CFG

[loladiro]

Summary

Use an explicit std::vector instead, to avoid accidentally causing stack overflows
for input with very large CFGs.

[mehdi_amini]

lib/CodeGen/ExecutionDepsFix.cpp

710

SmallVector?
Worklist or Workqueue seems a more common name for iterative algorithm I think.

719

Seed the workqueue instead to remove this call.

724

Is it the only use of updateSuccessors? Could be inlined if so, the code seems simple enough.

include/llvm/CodeGen/ExecutionDepsFix.h

private:
   void force(int rx, unsigned domain);
   void collapse(DomainValue *dv, unsigned domain);
   bool merge(DomainValue *A, DomainValue *B);
 
   void enterBasicBlock(MachineBasicBlock*);
   void leaveBasicBlock(MachineBasicBlock*);
   bool isBlockDone(MachineBasicBlock *);
   void processBasicBlock(MachineBasicBlock *MBB, bool PrimaryPass);
-  void updateSuccessors(MachineBasicBlock *MBB, bool PrimaryPass);
+  void updateSuccessors(std::vector<MachineBasicBlock *> &ToRevisit,
+                        MachineBasicBlock *MBB, bool PrimaryPass);
   bool visitInstr(MachineInstr *);
   void processDefs(MachineInstr *, bool breakDependency, bool Kill);
   void visitSoftInstr(MachineInstr*, unsigned mask);
   void visitHardInstr(MachineInstr*, unsigned domain);
   bool pickBestRegisterForUndef(MachineInstr *MI, unsigned OpIdx,
                                 unsigned Pref);
   bool shouldBreakDependence(MachineInstr*, unsigned OpIdx, unsigned Pref);
   void processUndefReads(MachineBasicBlock*);
 };
 
 } // end namepsace llvm
 
 #endif

lib/CodeGen/ExecutionDepsFix.cpp

 }
 
 bool ExecutionDepsFix::isBlockDone(MachineBasicBlock *MBB) {
   return MBBInfos[MBB].PrimaryCompleted &&
          MBBInfos[MBB].IncomingCompleted == MBBInfos[MBB].PrimaryIncoming &&
          MBBInfos[MBB].IncomingProcessed == MBB->pred_size();
 }
 
-void ExecutionDepsFix::updateSuccessors(MachineBasicBlock *MBB, bool Primary) {
+void ExecutionDepsFix::updateSuccessors(
+    std::vector<MachineBasicBlock *> &ToRevisit, MachineBasicBlock *MBB,
+    bool Primary) {
   bool Done = isBlockDone(MBB);
   for (auto *Succ : MBB->successors()) {
     if (!isBlockDone(Succ)) {
       if (Primary) {
         MBBInfos[Succ].IncomingProcessed++;
       }
       if (Done) {
         MBBInfos[Succ].IncomingCompleted++;
       }
       if (isBlockDone(Succ)) {
-        // Perform secondary processing for this successor. See the big comment
-        // in runOnMachineFunction, for an explanation of the iteration order.
-        processBasicBlock(Succ, false);
-        updateSuccessors(Succ, false);
+        ToRevisit.push_back(Succ);
       }
     }
   }
 }
 
 bool ExecutionDepsFix::runOnMachineFunction(MachineFunction &mf) {
   if (skipFunction(*mf.getFunction()))
     return false;
bool ExecutionDepsFix::runOnMachineFunction(MachineFunction &mf) {
    *  the predecessors before getting to D. We call a block that is ready
    *  for its second round of processing `done` (isBlockDone). Once we finish
    *  processing some block, we update the counters in MBBInfos and re-process
    *  any successors that are now done.
    */
 
   MachineBasicBlock *Entry = &*MF->begin();
   ReversePostOrderTraversal<MachineBasicBlock*> RPOT(Entry);
+  std::vector<MachineBasicBlock *> ToRevisit;
   for (ReversePostOrderTraversal<MachineBasicBlock*>::rpo_iterator
          MBBI = RPOT.begin(), MBBE = RPOT.end(); MBBI != MBBE; ++MBBI) {
     MachineBasicBlock *MBB = *MBBI;
     // N.B: IncomingProcessed and IncomingCompleted were already updated while
     // processing this block's predecessors.
     MBBInfos[MBB].PrimaryCompleted = true;
     MBBInfos[MBB].PrimaryIncoming = MBBInfos[MBB].IncomingProcessed;
     processBasicBlock(MBB, true);
-    updateSuccessors(MBB, true);
+    updateSuccessors(ToRevisit, MBB, true);
+    while (!ToRevisit.empty()) {
+      MachineBasicBlock *ToRevisitBB = &*ToRevisit.back();
+      ToRevisit.pop_back();
+      processBasicBlock(ToRevisitBB, false);
+      updateSuccessors(ToRevisit, ToRevisitBB, false);
+    }
   }
 
   // We need to go through again and finalize any blocks that are not done yet.
   // This is possible if blocks have dead predecessors, so we didn't visit them
   // above.
   for (ReversePostOrderTraversal<MachineBasicBlock *>::rpo_iterator
            MBBI = RPOT.begin(),
            MBBE = RPOT.end();