WebAssembly: Avoid implicit iterator conversions, NFC

[dexonsmith]

Summary

Avoid implicit conversions from MachineInstrBundleIterator to
MachineInstr* in the WebAssembly backend by preferring MachineInstr&
over MachineInstr*.

[sunfish]

Looks good, thanks!

[llvm-commits]

Committed in r274912.

lib/Target/WebAssembly/WebAssemblyArgumentMove.cpp

 } // end anonymous namespace
 
 char WebAssemblyArgumentMove::ID = 0;
 FunctionPass *llvm::createWebAssemblyArgumentMove() {
   return new WebAssemblyArgumentMove();
 }
 
 /// Test whether the given instruction is an ARGUMENT.
-static bool IsArgument(const MachineInstr *MI) {
-  switch (MI->getOpcode()) {
+static bool IsArgument(const MachineInstr &MI) {
+  switch (MI.getOpcode()) {
   case WebAssembly::ARGUMENT_I32:
   case WebAssembly::ARGUMENT_I64:
   case WebAssembly::ARGUMENT_F32:
   case WebAssembly::ARGUMENT_F64:
     return true;
   default:
     return false;
   }
 }
 
 bool WebAssemblyArgumentMove::runOnMachineFunction(MachineFunction &MF) {
   DEBUG({
     dbgs() << "********** Argument Move **********\n"
            << "********** Function: " << MF.getName() << '\n';
   });
 
   bool Changed = false;
   MachineBasicBlock &EntryMBB = MF.front();
   MachineBasicBlock::iterator InsertPt = EntryMBB.end();
 
   // Look for the first NonArg instruction.
-  for (auto MII = EntryMBB.begin(), MIE = EntryMBB.end(); MII != MIE; ++MII) {
-    MachineInstr *MI = MII;
+  for (MachineInstr &MI : EntryMBB) {
     if (!IsArgument(MI)) {
-      InsertPt = MII;
+      InsertPt = MI;
       break;
     }
   }
 
   // Now move any argument instructions later in the block
   // to before our first NonArg instruction.
-  for (auto I = InsertPt, E = EntryMBB.end(); I != E; ++I) {
-    MachineInstr *MI = I;
+  for (MachineInstr &MI : llvm::make_range(InsertPt, EntryMBB.end())) {
     if (IsArgument(MI)) {
-      EntryMBB.insert(InsertPt, MI->removeFromParent());
+      EntryMBB.insert(InsertPt, MI.removeFromParent());
       Changed = true;
     }
   }
 
   return Changed;
 }

lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp

static bool ExplicitlyBranchesTo(MachineBasicBlock *Pred,
   for (MachineInstr &MI : Pred->terminators())
     for (MachineOperand &MO : MI.explicit_operands())
       if (MO.isMBB() && MO.getMBB() == MBB)
         return true;
   return false;
 }
 
 /// Test whether MI is a child of some other node in an expression tree.
-static bool IsChild(const MachineInstr *MI,
+static bool IsChild(const MachineInstr &MI,
                     const WebAssemblyFunctionInfo &MFI) {
-  if (MI->getNumOperands() == 0)
+  if (MI.getNumOperands() == 0)
     return false;
-  const MachineOperand &MO = MI->getOperand(0);
+  const MachineOperand &MO = MI.getOperand(0);
   if (!MO.isReg() || MO.isImplicit() || !MO.isDef())
     return false;
   unsigned Reg = MO.getReg();
   return TargetRegisterInfo::isVirtualRegister(Reg) &&
          MFI.isVRegStackified(Reg);
 }
 
 /// Insert a BLOCK marker for branches to MBB (if needed).
if (HeaderLoop && MBB.getNumber() > LoopBottom(HeaderLoop)->getNumber()) {
     // the BLOCK needs to be above the LOOP, after any END constructs.
     InsertPos = Header->begin();
     while (InsertPos->getOpcode() != WebAssembly::LOOP)
       ++InsertPos;
   } else {
     // Otherwise, insert the BLOCK as late in Header as we can, but before the
     // beginning of the local expression tree and any nested BLOCKs.
     InsertPos = Header->getFirstTerminator();
-    while (InsertPos != Header->begin() && IsChild(prev(InsertPos), MFI) &&
+    while (InsertPos != Header->begin() && IsChild(*prev(InsertPos), MFI) &&
            prev(InsertPos)->getOpcode() != WebAssembly::LOOP &&
            prev(InsertPos)->getOpcode() != WebAssembly::END_BLOCK &&
            prev(InsertPos)->getOpcode() != WebAssembly::END_LOOP)
       --InsertPos;
   }
 
   // Add the BLOCK.
   BuildMI(*Header, InsertPos, DebugLoc(), TII.get(WebAssembly::BLOCK));

lib/Target/WebAssembly/WebAssemblyRegStackify.cpp

if (!MI->readsRegister(WebAssembly::EXPR_STACK))
     MI->addOperand(MachineOperand::CreateReg(WebAssembly::EXPR_STACK,
                                              /*isDef=*/false,
                                              /*isImp=*/true));
 }
 
 // Determine whether a call to the callee referenced by
 // MI->getOperand(CalleeOpNo) reads memory, writes memory, and/or has side
 // effects.
-static void QueryCallee(const MachineInstr *MI, unsigned CalleeOpNo,
-                        bool &Read, bool &Write, bool &Effects,
-                        bool &StackPointer) {
+static void QueryCallee(const MachineInstr &MI, unsigned CalleeOpNo, bool &Read,
+                        bool &Write, bool &Effects, bool &StackPointer) {
   // All calls can use the stack pointer.
   StackPointer = true;
 
-  const MachineOperand &MO = MI->getOperand(CalleeOpNo);
+  const MachineOperand &MO = MI.getOperand(CalleeOpNo);
   if (MO.isGlobal()) {
     const Constant *GV = MO.getGlobal();
     if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(GV))
       if (!GA->isInterposable())
         GV = GA->getAliasee();
 
     if (const Function *F = dyn_cast<Function>(GV)) {
       if (!F->doesNotThrow())
static void QueryCallee(const MachineInstr &MI, unsigned CalleeOpNo, bool &Read,
   // Assume the worst.
   Write = true;
   Read = true;
   Effects = true;
 }
 
 // Determine whether MI reads memory, writes memory, has side effects,
 // and/or uses the __stack_pointer value.
-static void Query(const MachineInstr *MI, AliasAnalysis &AA,
-                  bool &Read, bool &Write, bool &Effects, bool &StackPointer) {
-  assert(!MI->isPosition());
-  assert(!MI->isTerminator());
+static void Query(const MachineInstr &MI, AliasAnalysis &AA, bool &Read,
+                  bool &Write, bool &Effects, bool &StackPointer) {
+  assert(!MI.isPosition());
+  assert(!MI.isTerminator());
 
-  if (MI->isDebugValue())
+  if (MI.isDebugValue())
     return;
 
   // Check for loads.
-  if (MI->mayLoad() && !MI->isInvariantLoad(&AA))
+  if (MI.mayLoad() && !MI.isInvariantLoad(&AA))
     Read = true;
 
   // Check for stores.
-  if (MI->mayStore()) {
+  if (MI.mayStore()) {
     Write = true;
 
     // Check for stores to __stack_pointer.
-    for (auto MMO : MI->memoperands()) {
+    for (auto MMO : MI.memoperands()) {
       const MachinePointerInfo &MPI = MMO->getPointerInfo();
       if (MPI.V.is<const PseudoSourceValue *>()) {
         auto PSV = MPI.V.get<const PseudoSourceValue *>();
         if (const ExternalSymbolPseudoSourceValue *EPSV =
                 dyn_cast<ExternalSymbolPseudoSourceValue>(PSV))
           if (StringRef(EPSV->getSymbol()) == "__stack_pointer")
             StackPointer = true;
       }
     }
-  } else if (MI->hasOrderedMemoryRef()) {
-    switch (MI->getOpcode()) {
+  } else if (MI.hasOrderedMemoryRef()) {
+    switch (MI.getOpcode()) {
     case WebAssembly::DIV_S_I32: case WebAssembly::DIV_S_I64:
     case WebAssembly::REM_S_I32: case WebAssembly::REM_S_I64:
     case WebAssembly::DIV_U_I32: case WebAssembly::DIV_U_I64:
     case WebAssembly::REM_U_I32: case WebAssembly::REM_U_I64:
     case WebAssembly::I32_TRUNC_S_F32: case WebAssembly::I64_TRUNC_S_F32:
     case WebAssembly::I32_TRUNC_S_F64: case WebAssembly::I64_TRUNC_S_F64:
     case WebAssembly::I32_TRUNC_U_F32: case WebAssembly::I64_TRUNC_U_F32:
     case WebAssembly::I32_TRUNC_U_F64: case WebAssembly::I64_TRUNC_U_F64:
       // These instruction have hasUnmodeledSideEffects() returning true
       // because they trap on overflow and invalid so they can't be arbitrarily
       // moved, however hasOrderedMemoryRef() interprets this plus their lack
       // of memoperands as having a potential unknown memory reference.
       break;
     default:
       // Record volatile accesses, unless it's a call, as calls are handled
       // specially below.
-      if (!MI->isCall()) {
+      if (!MI.isCall()) {
         Write = true;
         Effects = true;
       }
       break;
     }
   }
 
   // Check for side effects.
-  if (MI->hasUnmodeledSideEffects()) {
-    switch (MI->getOpcode()) {
+  if (MI.hasUnmodeledSideEffects()) {
+    switch (MI.getOpcode()) {
     case WebAssembly::DIV_S_I32: case WebAssembly::DIV_S_I64:
     case WebAssembly::REM_S_I32: case WebAssembly::REM_S_I64:
     case WebAssembly::DIV_U_I32: case WebAssembly::DIV_U_I64:
     case WebAssembly::REM_U_I32: case WebAssembly::REM_U_I64:
     case WebAssembly::I32_TRUNC_S_F32: case WebAssembly::I64_TRUNC_S_F32:
     case WebAssembly::I32_TRUNC_S_F64: case WebAssembly::I64_TRUNC_S_F64:
     case WebAssembly::I32_TRUNC_U_F32: case WebAssembly::I64_TRUNC_U_F32:
     case WebAssembly::I32_TRUNC_U_F64: case WebAssembly::I64_TRUNC_U_F64:
       // These instructions have hasUnmodeledSideEffects() returning true
       // because they trap on overflow and invalid so they can't be arbitrarily
       // moved, however in the specific case of register stackifying, it is safe
       // to move them because overflow and invalid are Undefined Behavior.
       break;
     default:
       Effects = true;
       break;
     }
   }
 
   // Analyze calls.
-  if (MI->isCall()) {
-    switch (MI->getOpcode()) {
+  if (MI.isCall()) {
+    switch (MI.getOpcode()) {
     case WebAssembly::CALL_VOID:
     case WebAssembly::CALL_INDIRECT_VOID:
       QueryCallee(MI, 0, Read, Write, Effects, StackPointer);
       break;
     case WebAssembly::CALL_I32: case WebAssembly::CALL_I64:
     case WebAssembly::CALL_F32: case WebAssembly::CALL_F64:
     case WebAssembly::CALL_INDIRECT_I32: case WebAssembly::CALL_INDIRECT_I64:
     case WebAssembly::CALL_INDIRECT_F32: case WebAssembly::CALL_INDIRECT_F64:
VNInfo *DefVNI =
         LI.getVNInfoBefore(LIS.getInstructionIndex(*Def));
     assert(DefVNI && "Instruction input missing value number");
     VNInfo *InsVNI = LI.getVNInfoBefore(LIS.getInstructionIndex(*Insert));
     if (InsVNI && DefVNI != InsVNI)
       return false;
   }
 
   bool Read = false, Write = false, Effects = false, StackPointer = false;
-  Query(Def, AA, Read, Write, Effects, StackPointer);
+  Query(*Def, AA, Read, Write, Effects, StackPointer);
 
   // If the instruction does not access memory and has no side effects, it has
   // no additional dependencies.
   if (!Read && !Write && !Effects && !StackPointer)
     return true;
 
   // Scan through the intervening instructions between Def and Insert.
   MachineBasicBlock::const_iterator D(Def), I(Insert);
   for (--I; I != D; --I) {
     bool InterveningRead = false;
     bool InterveningWrite = false;
     bool InterveningEffects = false;
     bool InterveningStackPointer = false;
-    Query(I, AA, InterveningRead, InterveningWrite, InterveningEffects,
+    Query(*I, AA, InterveningRead, InterveningWrite, InterveningEffects,
           InterveningStackPointer);
     if (Effects && InterveningEffects)
       return false;
     if (Read && InterveningWrite)
       return false;
     if (Write && (InterveningRead || InterveningWrite))
       return false;
     if (StackPointer && InterveningStackPointer)