Subzero: Add -Wshadow to the build.

src/IceTargetLoweringX86BaseImpl.h

 //===- subzero/src/IceTargetLoweringX86BaseImpl.h - x86 lowering -*- C++ -*-==//
 //
 //                        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 TargetLoweringX86Base class, which
@@ skipping 11 matching lines @@
 #include "IceDefs.h"
 #include "IceELFObjectWriter.h"
 #include "IceGlobalInits.h"
 #include "IceInstX8632.h"
 #include "IceLiveness.h"
 #include "IceOperand.h"
 #include "IceRegistersX8632.h"
 #include "IceTargetLoweringX8632.def"
 #include "IceTargetLoweringX8632.h"
 #include "IceUtils.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wshadow"
 #include "llvm/Support/MathExtras.h"
+#pragma clang diagnostic pop
 
 namespace Ice {
 namespace X86Internal {
 
 // A helper class to ease the settings of RandomizationPoolingPause
 // to disable constant blinding or pooling for some translation phases.
 class BoolFlagSaver {
   BoolFlagSaver() = delete;
   BoolFlagSaver(const BoolFlagSaver &) = delete;
   BoolFlagSaver &operator=(const BoolFlagSaver &) = delete;
@@ skipping 148 matching lines @@
         && Var             // only instructions with an actual dest var
         && Var->getType() == IceType_i1          // only bool-type dest vars
         && getProducerKind(&Instr) != PK_None) { // white-listed instructions
       Producers[Var->getIndex()] = BoolFoldingEntry<MachineTraits>(&Instr);
     }
     // Check each src variable against the map.
     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);
-        SizeT VarNum = Var->getIndex();
+        const Variable *V = Src->getVar(J);
+        SizeT VarNum = V->getIndex();
         if (containsValid(VarNum)) {
-          if (I != 0 // All valid consumers use Var as the first source operand
+          if (I != 0 // All valid consumers use V as the first source operand
               || getConsumerKind(&Instr) == CK_None // must be white-listed
               || (Producers[VarNum].IsComplex && // complex can't be multi-use
                   Producers[VarNum].NumUses > 0)) {
             setInvalid(VarNum);
             continue;
           }
           ++Producers[VarNum].NumUses;
-          if (Instr.isLastUse(Var)) {
+          if (Instr.isLastUse(V)) {
             Producers[VarNum].IsLiveOut = false;
           }
         }
       }
     }
   }
   for (auto &I : Producers) {
     // Ignore entries previously marked invalid.
     if (I.second.Instr == nullptr)
       continue;
@@ skipping 4500 matching lines @@
   for (Inst &I : Node->getPhis()) {
     auto Phi = llvm::dyn_cast<InstPhi>(&I);
     if (Phi->isDeleted())
       continue;
     Variable *Dest = Phi->getDest();
     if (Dest->getType() == IceType_i64) {
       Variable *DestLo = llvm::cast<Variable>(loOperand(Dest));
       Variable *DestHi = llvm::cast<Variable>(hiOperand(Dest));
       InstPhi *PhiLo = InstPhi::create(Func, Phi->getSrcSize(), DestLo);
       InstPhi *PhiHi = InstPhi::create(Func, Phi->getSrcSize(), DestHi);
-      for (SizeT I = 0; I < Phi->getSrcSize(); ++I) {
-        Operand *Src = Phi->getSrc(I);
-        CfgNode *Label = Phi->getLabel(I);
+      for (SizeT i = 0; i < Phi->getSrcSize(); ++i) {
+        Operand *Src = Phi->getSrc(i);
+        CfgNode *Label = Phi->getLabel(i);
         if (llvm::isa<ConstantUndef>(Src))
           Src = Ctx->getConstantZero(Dest->getType());
         PhiLo->addArgument(loOperand(Src), Label);
         PhiHi->addArgument(hiOperand(Src), Label);
       }
       Node->getPhis().push_back(PhiLo);
       Node->getPhis().push_back(PhiHi);
       Phi->setDeleted();
     }
   }
@@ skipping 750 matching lines @@
   }
   // the offset is not eligible for blinding or pooling, return the original
   // mem operand
   return MemOperand;
 }
 
 } // end of namespace X86Internal
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H