[WebAssembly] Small improvements in FixIrreducibleControlFlow (NFC)

[aheejin]

Summary

• Make some class member methods const
• Delete unnecessary includes
• Use a simpler form of BuildMI

[kripken]

lgtm, nice!

I'm not that familiar with the BuildMI parts though.

[aheejin]

The version of BuildMI I used defaults to add instructions at the end of a basic block, so we don't need to add BB->end() every time.

[aheejin]

rebase

lib/Target/WebAssembly/WebAssemblyFixIrreducibleControlFlow.cpp

 /// programming systems languages and applications companion (SPLASH '11). ACM,
 /// New York, NY, USA, 301-312. DOI=10.1145/2048147.2048224
 /// http://doi.acm.org/10.1145/2048147.2048224
 ///
 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 #include "WebAssembly.h"
-#include "WebAssemblyMachineFunctionInfo.h"
 #include "WebAssemblySubtarget.h"
-#include "llvm/ADT/PriorityQueue.h"
-#include "llvm/ADT/SCCIterator.h"
-#include "llvm/ADT/SetVector.h"
-#include "llvm/CodeGen/MachineDominators.h"
-#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
-#include "llvm/CodeGen/MachineLoopInfo.h"
-#include "llvm/CodeGen/MachineRegisterInfo.h"
-#include "llvm/CodeGen/Passes.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "wasm-fix-irreducible-control-flow"
 
 namespace {
 
 using BlockVector = SmallVector<MachineBasicBlock *, 4>;
 using BlockSet = SmallPtrSet<MachineBasicBlock *, 4>;
for (auto *MBB : Blocks) {
           assert(inRegion(Pred));
         }
       }
     }
 #endif
     calculate();
   }
 
-  bool canReach(MachineBasicBlock *From, MachineBasicBlock *To) {
+  bool canReach(MachineBasicBlock *From, MachineBasicBlock *To) const {
     assert(inRegion(From) && inRegion(To));
-    return Reachable[From].count(To);
+    auto I = Reachable.find(From);
+    if (I == Reachable.end())
+      return false;
+    return I->second.count(To);
   }
 
   // "Loopers" are blocks that are in a loop. We detect these by finding blocks
   // that can reach themselves.
-  const BlockSet &getLoopers() { return Loopers; }
+  const BlockSet &getLoopers() const { return Loopers; }
 
   // Get all blocks that are loop entries.
-  const BlockSet &getLoopEntries() { return LoopEntries; }
+  const BlockSet &getLoopEntries() const { return LoopEntries; }
 
   // Get all blocks that enter a particular loop from outside.
-  const BlockSet &getLoopEnterers(MachineBasicBlock *LoopEntry) {
+  const BlockSet &getLoopEnterers(MachineBasicBlock *LoopEntry) const {
     assert(inRegion(LoopEntry));
-    return LoopEnterers[LoopEntry];
+    auto I = LoopEnterers.find(LoopEntry);
+    assert(I != LoopEnterers.end());
+    return I->second;
   }
 
 private:
   MachineBasicBlock *Entry;
   const BlockSet &Blocks;
 
   BlockSet Loopers, LoopEntries;
   DenseMap<MachineBasicBlock *, BlockSet> LoopEnterers;
 
-  bool inRegion(MachineBasicBlock *MBB) { return Blocks.count(MBB); }
+  bool inRegion(MachineBasicBlock *MBB) const { return Blocks.count(MBB); }
 
   // Maps a block to all the other blocks it can reach.
   DenseMap<MachineBasicBlock *, BlockSet> Reachable;
 
   void calculate() {
     // Reachability computation work list. Contains pairs of recent additions
     // (A, B) where we just added a link A => B.
     using BlockPair = std::pair<MachineBasicBlock *, MachineBasicBlock *>;
#endif
 
   // Create a dispatch block which will contain a jump table to the entries.
   MachineBasicBlock *Dispatch = MF.CreateMachineBasicBlock();
   MF.insert(MF.end(), Dispatch);
   Blocks.insert(Dispatch);
 
   // Add the jump table.
   const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
-  MachineInstrBuilder MIB = BuildMI(*Dispatch, Dispatch->end(), DebugLoc(),
-                                    TII.get(WebAssembly::BR_TABLE_I32));
+  MachineInstrBuilder MIB =
+      BuildMI(Dispatch, DebugLoc(), TII.get(WebAssembly::BR_TABLE_I32));
 
   // Add the register which will be used to tell the jump table which block to
   // jump to.
   MachineRegisterInfo &MRI = MF.getRegInfo();
   unsigned Reg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
   MIB.addReg(Reg);
 
   // Compute the indices in the superheader, one for each bad block, and
for (auto *Entry : Pred->successors()) {
       MF.insert(Pred->isLayoutSuccessor(Entry)
                     ? MachineFunction::iterator(Entry)
                     : MF.end(),
                 Split);
       Blocks.insert(Split);
 
       // Set the jump table's register of the index of the block we wish to
       // jump to, and jump to the jump table.
-      BuildMI(*Split, Split->end(), DebugLoc(), TII.get(WebAssembly::CONST_I32),
-              Reg)
+      BuildMI(Split, DebugLoc(), TII.get(WebAssembly::CONST_I32), Reg)
           .addImm(Indices[Entry]);
-      BuildMI(*Split, Split->end(), DebugLoc(), TII.get(WebAssembly::BR))
-          .addMBB(Dispatch);
+      BuildMI(Split, DebugLoc(), TII.get(WebAssembly::BR)).addMBB(Dispatch);
       Split->addSuccessor(Dispatch);
       Map[Entry] = Split;
     }
     // Remap the terminator operands and the successor list.
     for (MachineInstr &Term : Pred->terminators())
       for (auto &Op : Term.explicit_uses())
         if (Op.isMBB() && Indices.count(Op.getMBB()))
           Op.setMBB(Map[Op.getMBB()]);