Subzero: Auto-awesome iterators.

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the TargetLoweringX8632 class, which
@@ skipping 527 matching lines @@
   }
 }
 
 void TargetX8632::sortByAlignment(VarList &Dest, const VarList &Source) const {
   // Sort the variables into buckets according to the log of their width
   // in bytes.
   const SizeT NumBuckets =
       X86_LOG2_OF_MAX_STACK_SLOT_SIZE - X86_LOG2_OF_MIN_STACK_SLOT_SIZE + 1;
   VarList Buckets[NumBuckets];
 
-  for (VarList::const_iterator I = Source.begin(), E = Source.end(); I != E;
-       ++I) {
-    Variable *Var = *I;
+  for (auto &Var : Source) {
     uint32_t NaturalAlignment = typeWidthInBytesOnStack(Var->getType());
     SizeT LogNaturalAlignment = llvm::findFirstSet(NaturalAlignment);
     assert(LogNaturalAlignment >= X86_LOG2_OF_MIN_STACK_SLOT_SIZE);
     assert(LogNaturalAlignment <= X86_LOG2_OF_MAX_STACK_SLOT_SIZE);
     SizeT BucketIndex = LogNaturalAlignment - X86_LOG2_OF_MIN_STACK_SLOT_SIZE;
     Buckets[BucketIndex].push_back(Var);
   }
 
   for (SizeT I = 0, E = NumBuckets; I < E; ++I) {
     VarList &List = Buckets[NumBuckets - I - 1];
@@ skipping 120 matching lines @@
   const VarList &Variables = Func->getVariables();
   const VarList &Args = Func->getArgs();
   VarList SpilledVariables, SortedSpilledVariables, VariablesLinkedToSpillSlots;
 
   // If there is a separate locals area, this specifies the alignment
   // for it.
   uint32_t LocalsSlotsAlignmentBytes = 0;
   // The entire spill locations area gets aligned to largest natural
   // alignment of the variables that have a spill slot.
   uint32_t SpillAreaAlignmentBytes = 0;
-  for (VarList::const_iterator I = Variables.begin(), E = Variables.end();
-       I != E; ++I) {
-    Variable *Var = *I;
+  for (auto &Var : Variables) {
     if (Var->hasReg()) {
       RegsUsed[Var->getRegNum()] = true;
       continue;
     }
     // An argument either does not need a stack slot (if passed in a
     // register) or already has one (if passed on the stack).
     if (Var->getIsArg())
       continue;
     // An unreferenced variable doesn't need a stack slot.
     if (ComputedLiveRanges && Var->getLiveRange().isEmpty())
       continue;
     // A spill slot linked to a variable with a stack slot should reuse
     // that stack slot.
     if (SpillVariable *SpillVar = llvm::dyn_cast<SpillVariable>(Var)) {
       assert(Var->getWeight() == RegWeight::Zero);
       if (!SpillVar->getLinkedTo()->hasReg()) {
         VariablesLinkedToSpillSlots.push_back(Var);
         continue;
       }
     }
     SpilledVariables.push_back(Var);
   }
 
   SortedSpilledVariables.reserve(SpilledVariables.size());
   sortByAlignment(SortedSpilledVariables, SpilledVariables);
-  for (VarList::const_iterator I = SortedSpilledVariables.begin(),
-                               E = SortedSpilledVariables.end();
-       I != E; ++I) {
-    Variable *Var = *I;
+  for (auto &Var : SortedSpilledVariables) {
     size_t Increment = typeWidthInBytesOnStack(Var->getType());
     if (!SpillAreaAlignmentBytes)
       SpillAreaAlignmentBytes = Increment;
     if (SimpleCoalescing && VMetadata->isTracked(Var)) {
       if (VMetadata->isMultiBlock(Var)) {
         GlobalsSize += Increment;
       } else {
         SizeT NodeIndex = VMetadata->getLocalUseNode(Var)->getIndex();
         LocalsSize[NodeIndex] += Increment;
         if (LocalsSize[NodeIndex] > SpillAreaSizeBytes)
@@ skipping 87 matching lines @@
       ++NumXmmArgs;
       continue;
     }
     finishArgumentLowering(Arg, FramePtr, BasicFrameOffset, InArgsSizeBytes);
   }
 
   // Fill in stack offsets for locals.
   size_t GlobalsSpaceUsed = SpillAreaPaddingBytes;
   LocalsSize.assign(LocalsSize.size(), 0);
   size_t NextStackOffset = GlobalsSpaceUsed;
-  for (VarList::const_iterator I = SortedSpilledVariables.begin(),
-                               E = SortedSpilledVariables.end();
-       I != E; ++I) {
-    Variable *Var = *I;
+  for (auto &Var : SortedSpilledVariables) {
     size_t Increment = typeWidthInBytesOnStack(Var->getType());
     if (SimpleCoalescing && VMetadata->isTracked(Var)) {
       if (VMetadata->isMultiBlock(Var)) {
         GlobalsSpaceUsed += Increment;
         NextStackOffset = GlobalsSpaceUsed;
       } else {
         SizeT NodeIndex = VMetadata->getLocalUseNode(Var)->getIndex();
         LocalsSize[NodeIndex] += Increment;
         NextStackOffset = SpillAreaPaddingBytes +
                           GlobalsAndSubsequentPaddingSize +
                           LocalsSize[NodeIndex];
       }
     } else {
       NextStackOffset += Increment;
     }
     if (IsEbpBasedFrame)
       Var->setStackOffset(-NextStackOffset);
     else
       Var->setStackOffset(SpillAreaSizeBytes - NextStackOffset);
   }
   this->FrameSizeLocals = NextStackOffset - SpillAreaPaddingBytes;
   this->HasComputedFrame = true;
 
   // Assign stack offsets to variables that have been linked to spilled
   // variables.
-  for (VarList::const_iterator I = VariablesLinkedToSpillSlots.begin(),
-                               E = VariablesLinkedToSpillSlots.end();
-       I != E; ++I) {
-    Variable *Var = *I;
+  for (auto &Var : VariablesLinkedToSpillSlots) {
     Variable *Linked = (llvm::cast<SpillVariable>(Var))->getLinkedTo();
     Var->setStackOffset(Linked->getStackOffset());
   }
 
   if (Func->getContext()->isVerbose(IceV_Frame)) {
     Ostream &Str = Func->getContext()->getStrDump();
 
     Str << "Stack layout:\n";
     uint32_t EspAdjustmentPaddingSize =
         SpillAreaSizeBytes - LocalsSpillAreaSize -
@@ skipping 89 matching lines @@
 
 template <typename T> void TargetX8632::emitConstantPool() const {
   Ostream &Str = Ctx->getStrEmit();
   Type Ty = T::Ty;
   SizeT Align = typeAlignInBytes(Ty);
   ConstantList Pool = Ctx->getConstantPool(Ty);
 
   Str << "\t.section\t.rodata.cst" << Align << ",\"aM\",@progbits," << Align
       << "\n";
   Str << "\t.align\t" << Align << "\n";
-  for (ConstantList::const_iterator I = Pool.begin(), E = Pool.end(); I != E;
-       ++I) {
-    typename T::IceType *Const = llvm::cast<typename T::IceType>(*I);
+  for (auto &I : Pool) {
+    typename T::IceType *Const = llvm::cast<typename T::IceType>(I);
     typename T::PrimitiveFpType Value = Const->getValue();
     // Use memcpy() to copy bits from Value into RawValue in a way
     // that avoids breaking strict-aliasing rules.
     typename T::PrimitiveIntType RawValue;
     memcpy(&RawValue, &Value, sizeof(Value));
     char buf[30];
     int CharsPrinted =
         snprintf(buf, llvm::array_lengthof(buf), T::PrintfString, RawValue);
     assert(CharsPrinted >= 0 &&
            (size_t)CharsPrinted < llvm::array_lengthof(buf));
@@ skipping 3331 matching lines @@
     RegExclude |= RegSet_FramePointer;
   llvm::SmallBitVector WhiteList = getRegisterSet(RegInclude, RegExclude);
   // Make one pass to black-list pre-colored registers.  TODO: If
   // there was some prior register allocation pass that made register
   // assignments, those registers need to be black-listed here as
   // well.
   llvm::DenseMap<const Variable *, const Inst *> LastUses;
   // The first pass also keeps track of which instruction is the last
   // use for each infinite-weight variable.  After the last use, the
   // variable is released to the free list.
-  for (InstList::iterator I = Context.getCur(), E = Context.getEnd(); I != E;
-       ++I) {
+  for (auto I = Context.getCur(), E = Context.getEnd(); I != E; ++I) {
     const Inst *Inst = *I;
     if (Inst->isDeleted())
       continue;
     // Don't consider a FakeKill instruction, because (currently) it
     // is only used to kill all scratch registers at a call site, and
     // we don't want to black-list all scratch registers during the
     // call lowering.  This could become a problem since it relies on
     // the lowering sequence not keeping any infinite-weight variables
     // live across a call.  TODO(stichnot): Consider replacing this
     // whole postLower() implementation with a robust local register
@@ skipping 12 matching lines @@
         LastUses[Var] = Inst;
         if (!Var->hasReg())
           continue;
         WhiteList[Var->getRegNum()] = false;
       }
     }
   }
   // The second pass colors infinite-weight variables.
   llvm::SmallBitVector AvailableRegisters = WhiteList;
   llvm::SmallBitVector FreedRegisters(WhiteList.size());
-  for (InstList::iterator I = Context.getCur(), E = Context.getEnd(); I != E;
-       ++I) {
+  for (auto I = Context.getCur(), E = Context.getEnd(); I != E; ++I) {
     FreedRegisters.reset();
     const Inst *Inst = *I;
     if (Inst->isDeleted())
       continue;
     // Skip FakeKill instructions like above.
     if (llvm::isa<InstFakeKill>(Inst))
       continue;
     // Iterate over all variables referenced in the instruction,
     // including the Dest variable (if any).  If the variable is
     // marked as infinite-weight, find it a register.  If this
@@ skipping 154 matching lines @@
     Str << "\t.align\t" << Align << "\n";
     Str << MangledName << ":\n";
     for (SizeT i = 0; i < Size; ++i) {
       Str << "\t.byte\t" << (((unsigned)Data[i]) & 0xff) << "\n";
     }
     Str << "\t.size\t" << MangledName << ", " << Size << "\n";
   }
 }
 
 } // end of namespace Ice