Subzero: Provide a macro for iterating over instruction variables.

src/IceCfgNode.cpp

 //===- subzero/src/IceCfgNode.cpp - Basic block (node) implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements the CfgNode class, including the complexities
 /// of instruction insertion and in-edge calculation.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceCfgNode.h"
 
 #include "IceAssembler.h"
 #include "IceCfg.h"
 #include "IceGlobalInits.h"
 #include "IceInst.h"
+#include "IceInstVarIter.h"
 #include "IceLiveness.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 
 namespace Ice {
 
 CfgNode::CfgNode(Cfg *Func, SizeT LabelNumber)
     : Func(Func), Number(LabelNumber) {}
 
 // Returns the name the node was created with.  If no name was given,
@@ skipping 807 matching lines @@
     return;
   bool First = true;
   Variable *Dest = Instr->getDest();
   // Normally we increment the live count for the dest register.  But
   // we shouldn't if the instruction's IsDestNonKillable flag is set,
   // because this means that the target lowering created this
   // instruction as a non-SSA assignment; i.e., a different, previous
   // instruction started the dest variable's live range.
   if (!Instr->isDestNonKillable() && Dest && Dest->hasReg())
     ++LiveRegCount[Dest->getRegNum()];
-  for (SizeT I = 0; I < Instr->getSrcSize(); ++I) {
-    Operand *Src = Instr->getSrc(I);
-    SizeT NumVars = Src->getNumVars();
-    for (SizeT J = 0; J < NumVars; ++J) {
-      const Variable *Var = Src->getVar(J);
-      bool ShouldReport = Instr->isLastUse(Var);
-      if (ShouldReport && Var->hasReg()) {
-        // Don't report end of live range until the live count reaches 0.
-        SizeT NewCount = --LiveRegCount[Var->getRegNum()];
-        if (NewCount)
-          ShouldReport = false;
-      }
-      if (ShouldReport) {
-        if (First)
-          Str << " \t# END=";
-        else
-          Str << ",";
-        Var->emit(Func);
-        First = false;
-      }
+  FOREACH_VAR_IN_INST(Var, *Instr) {
+    bool ShouldReport = Instr->isLastUse(Var);
+    if (ShouldReport && Var->hasReg()) {
+      // Don't report end of live range until the live count reaches 0.
+      SizeT NewCount = --LiveRegCount[Var->getRegNum()];
+      if (NewCount)
+        ShouldReport = false;
+    }
+    if (ShouldReport) {
+      if (First)
+        Str << " \t# END=";
+      else
+        Str << ",";
+      Var->emit(Func);
+      First = false;
     }
   }
 }
 
 void updateStats(Cfg *Func, const Inst *I) {
   if (!BuildDefs::dump())
     return;
   // Update emitted instruction count, plus fill/spill count for
   // Variable operands without a physical register.
   if (uint32_t Count = I->getEmitInstCount()) {
@@ skipping 398 matching lines @@
   InstIntrinsicCall *Inst = InstIntrinsicCall::create(
       Func, 5, Func->makeVariable(IceType_i64), RMWI64Name, Info->Info);
   Inst->addArg(AtomicRMWOp);
   Inst->addArg(Counter);
   Inst->addArg(One);
   Inst->addArg(OrderAcquireRelease);
   Insts.push_front(Inst);
 }
 
 } // end of namespace Ice