Subzero: Provide a macro for iterating over instruction variables.

src/IceInst.cpp

 //===- subzero/src/IceInst.cpp - High-level instruction 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 Inst class, primarily the various
 /// subclass constructors and dump routines.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceInst.h"
 
 #include "IceCfg.h"
 #include "IceCfgNode.h"
+#include "IceInstVarIter.h"
 #include "IceLiveness.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 
 namespace Ice {
 
 namespace {
 
 // Using non-anonymous struct so that array_lengthof works.
 const struct InstArithmeticAttributes_ {
@@ skipping 58 matching lines @@
     setDeleted();
 }
 
 // If Src is a Variable, it returns true if this instruction ends
 // Src's live range.  Otherwise, returns false.
 bool Inst::isLastUse(const Operand *TestSrc) const {
   if (LiveRangesEnded == 0)
     return false; // early-exit optimization
   if (const Variable *TestVar = llvm::dyn_cast<const Variable>(TestSrc)) {
     LREndedBits Mask = LiveRangesEnded;
-    for (SizeT I = 0; I < getSrcSize(); ++I) {
-      Operand *Src = getSrc(I);
-      SizeT NumVars = Src->getNumVars();
-      for (SizeT J = 0; J < NumVars; ++J) {
-        const Variable *Var = Src->getVar(J);
-        if (Var == TestVar) {
-          // We've found where the variable is used in the instruction.
-          return Mask & 1;
-        }
-        Mask >>= 1;
-        if (Mask == 0)
-          return false; // another early-exit optimization
+    FOREACH_VAR_IN_INST(Var, *this) {
+      if (Var == TestVar) {
+        // We've found where the variable is used in the instruction.
+        return Mask & 1;
       }
+      Mask >>= 1;
+      if (Mask == 0)
+        return false; // another early-exit optimization
     }
   }
   return false;
 }
 
 // Given an instruction like:
 //   a = b + c + [x,y] + e
 // which was created from OrigInst:
 //   a = b + c + d + e
 // with SpliceAssn spliced in:
@@ skipping 27 matching lines @@
     }
     Index += getSrc(I)->getNumVars();
   }
   llvm::report_fatal_error("Failed to find splice operand");
 }
 
 void Inst::livenessLightweight(Cfg *Func, LivenessBV &Live) {
   assert(!isDeleted());
   resetLastUses();
   VariablesMetadata *VMetadata = Func->getVMetadata();
-  SizeT VarIndex = 0;
-  for (SizeT I = 0; I < getSrcSize(); ++I) {
-    Operand *Src = getSrc(I);
-    SizeT NumVars = Src->getNumVars();
-    for (SizeT J = 0; J < NumVars; ++J, ++VarIndex) {
-      const Variable *Var = Src->getVar(J);
-      if (VMetadata->isMultiBlock(Var))
-        continue;
-      SizeT Index = Var->getIndex();
-      if (Live[Index])
-        continue;
-      Live[Index] = true;
-      setLastUse(VarIndex);
-    }
+  FOREACH_VAR_IN_INST(Var, *this) {
+    if (VMetadata->isMultiBlock(Var))
+      continue;
+    SizeT Index = Var->getIndex();
+    if (Live[Index])
+      continue;
+    Live[Index] = true;
+    setLastUse(IndexOfVarInInst(Var));
   }
 }
 
 bool Inst::liveness(InstNumberT InstNumber, LivenessBV &Live,
                     Liveness *Liveness, LiveBeginEndMap *LiveBegin,
                     LiveBeginEndMap *LiveEnd) {
   assert(!isDeleted());
 
   Dead = false;
   if (Dest) {
     SizeT VarNum = Liveness->getLiveIndex(Dest->getIndex());
     if (Live[VarNum]) {
       if (!isDestNonKillable()) {
         Live[VarNum] = false;
         if (LiveBegin && Liveness->getRangeMask(Dest->getIndex())) {
           LiveBegin->push_back(std::make_pair(VarNum, InstNumber));
         }
       }
     } else {
       if (!hasSideEffects())
         Dead = true;
     }
   }
   if (Dead)
     return false;
   // Phi arguments only get added to Live in the predecessor node, but
   // we still need to update LiveRangesEnded.
   bool IsPhi = llvm::isa<InstPhi>(this);
   resetLastUses();
-  SizeT VarIndex = 0;
-  for (SizeT I = 0; I < getSrcSize(); ++I) {
-    Operand *Src = getSrc(I);
-    SizeT NumVars = Src->getNumVars();
-    for (SizeT J = 0; J < NumVars; ++J, ++VarIndex) {
-      const Variable *Var = Src->getVar(J);
-      SizeT VarNum = Liveness->getLiveIndex(Var->getIndex());
-      if (!Live[VarNum]) {
-        setLastUse(VarIndex);
-        if (!IsPhi) {
-          Live[VarNum] = true;
-          // For a variable in SSA form, its live range can end at
-          // most once in a basic block.  However, after lowering to
-          // two-address instructions, we end up with sequences like
-          // "t=b;t+=c;a=t" where t's live range begins and ends
-          // twice.  ICE only allows a variable to have a single
-          // liveness interval in a basic block (except for blocks
-          // where a variable is live-in and live-out but there is a
-          // gap in the middle).  Therefore, this lowered sequence
-          // needs to represent a single conservative live range for
-          // t.  Since the instructions are being traversed backwards,
-          // we make sure LiveEnd is only set once by setting it only
-          // when LiveEnd[VarNum]==0 (sentinel value).  Note that it's
-          // OK to set LiveBegin multiple times because of the
-          // backwards traversal.
-          if (LiveEnd && Liveness->getRangeMask(Var->getIndex())) {
-            // Ideally, we would verify that VarNum wasn't already
-            // added in this block, but this can't be done very
-            // efficiently with LiveEnd as a vector.  Instead,
-            // livenessPostprocess() verifies this after the vector
-            // has been sorted.
-            LiveEnd->push_back(std::make_pair(VarNum, InstNumber));
-          }
+  FOREACH_VAR_IN_INST(Var, *this) {
+    SizeT VarNum = Liveness->getLiveIndex(Var->getIndex());
+    if (!Live[VarNum]) {
+      setLastUse(IndexOfVarInInst(Var));
+      if (!IsPhi) {
+        Live[VarNum] = true;
+        // For a variable in SSA form, its live range can end at most once in a
+        // basic block.  However, after lowering to two-address instructions, we
+        // end up with sequences like "t=b;t+=c;a=t" where t's live range begins
+        // and ends twice.  ICE only allows a variable to have a single liveness
+        // interval in a basic block (except for blocks where a variable is
+        // live-in and live-out but there is a gap in the middle).  Therefore,
+        // this lowered sequence needs to represent a single conservative live
+        // range for t.  Since the instructions are being traversed backwards,
+        // we make sure LiveEnd is only set once by setting it only when
+        // LiveEnd[VarNum]==0 (sentinel value).  Note that it's OK to set
+        // LiveBegin multiple times because of the backwards traversal.
+        if (LiveEnd && Liveness->getRangeMask(Var->getIndex())) {
+          // Ideally, we would verify that VarNum wasn't already added in this
+          // block, but this can't be done very efficiently with LiveEnd as a
+          // vector.  Instead, livenessPostprocess() verifies this after the
+          // vector has been sorted.
+          LiveEnd->push_back(std::make_pair(VarNum, InstNumber));
         }
       }
     }
   }
   return true;
 }
 
 InstAlloca::InstAlloca(Cfg *Func, Operand *ByteCount, uint32_t AlignInBytes,
                        Variable *Dest)
     : InstHighLevel(Func, Inst::Alloca, 1, Dest), AlignInBytes(AlignInBytes) {
@@ skipping 330 matching lines @@
 }
 
 void Inst::dumpExtras(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   bool First = true;
   // Print "LIVEEND={a,b,c}" for all source operands whose live ranges
   // are known to end at this instruction.
   if (Func->isVerbose(IceV_Liveness)) {
-    for (SizeT I = 0; I < getSrcSize(); ++I) {
-      Operand *Src = getSrc(I);
-      SizeT NumVars = Src->getNumVars();
-      for (SizeT J = 0; J < NumVars; ++J) {
-        const Variable *Var = Src->getVar(J);
-        if (isLastUse(Var)) {
-          if (First)
-            Str << " // LIVEEND={";
-          else
-            Str << ",";
-          Var->dump(Func);
-          First = false;
-        }
+    FOREACH_VAR_IN_INST(Var, *this) {
+      if (isLastUse(Var)) {
+        if (First)
+          Str << " // LIVEEND={";
+        else
+          Str << ",";
+        Var->dump(Func);
+        First = false;
       }
     }
     if (!First)
       Str << "}";
   }
 }
 
 void Inst::dumpSources(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
@@ skipping 367 matching lines @@
     // preserve these.
     return true;
   }
   if (!Dest->hasReg() && !SrcVar->hasReg() &&
       Dest->getStackOffset() == SrcVar->getStackOffset())
     return true;
   return false;
 }
 
 } // end of namespace Ice