Subzero: Add -Wshadow to the build.

src/IceRegAlloc.cpp

 //===- subzero/src/IceRegAlloc.cpp - Linear-scan implementation -----------===//
 //
 //                        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 LinearScan class, which performs the
@@ skipping 159 matching lines @@
       if (const Variable *Var = Inst.getDest()) {
         if (Var->hasReg() || Var->getWeight().isInf()) {
           if (LRBegin[Var->getIndex()] == Inst::NumberSentinel) {
             LRBegin[Var->getIndex()] = Inst.getNumber();
             ++NumVars;
           }
         }
       }
       for (SizeT I = 0; I < Inst.getSrcSize(); ++I) {
         Operand *Src = Inst.getSrc(I);
-        SizeT NumVars = Src->getNumVars();
-        for (SizeT J = 0; J < NumVars; ++J) {
+        SizeT NVars = Src->getNumVars();
+        for (SizeT J = 0; J < NVars; ++J) {
           const Variable *Var = Src->getVar(J);
           if (Var->hasReg() || Var->getWeight().isInf())
             LREnd[Var->getIndex()] = Inst.getNumber();
         }
       }
     }
   }
 
   Unhandled.reserve(NumVars);
   UnhandledPrecolored.reserve(NumVars);
@@ skipping 475 matching lines @@
         ++RegUses[MinWeightIndex];
         Active.push_back(Cur);
         if (Verbose) {
           Ostream &Str = Ctx->getStrDump();
           Str << "Allocating   ";
           dumpLiveRange(Cur, Func);
           Str << "\n";
         }
       }
     }
-    dump(Func);
+    dump();
   }
   // Move anything Active or Inactive to Handled for easier handling.
   for (Variable *I : Active)
     Handled.push_back(I);
   Active.clear();
   for (Variable *I : Inactive)
     Handled.push_back(I);
   Inactive.clear();
-  dump(Func);
+  dump();
 
   llvm::SmallVector<int32_t, REGS_SIZE> Permutation(NumRegisters);
   if (Randomized) {
     Func->getTarget()->makeRandomRegisterPermutation(
         Permutation, PreDefinedRegisters | ~RegMaskFull);
   }
 
   // Finish up by assigning RegNumTmp->RegNum (or a random permutation
   // thereof) for each Variable.
   for (Variable *Item : Handled) {
@@ skipping 31 matching lines @@
   // Another idea for coalescing stack slots is to initialize the
   // Unhandled list with just the unallocated variables, saving time
   // but not offering second-chance opportunities.
 
   if (Verbose)
     Ctx->unlockStr();
 }
 
 // ======================== Dump routines ======================== //
 
-void LinearScan::dump(Cfg *Func) const {
+void LinearScan::dump() const {
   if (!BuildDefs::dump())
     return;
   if (!Func->isVerbose(IceV_LinearScan))
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Func->resetCurrentNode();
   Str << "**** Current regalloc state:\n";
   Str << "++++++ Handled:\n";
   for (const Variable *Item : Handled) {
     dumpLiveRange(Item, Func);
@@ skipping 10 matching lines @@
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice