Subzero: Add -Wshadow to the build.

src/IceInstX86BaseImpl.h

-//===- subzero/src/IceInstX86BaseImpl.h - Generic X86 instructions -*- C++ -*=//
+//==- subzero/src/IceInstX86BaseImpl.h - Generic X86 instructions -*- C++ -*-=//
 //
 //                        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 InstX86Base class and its descendants.
@@ skipping 28 matching lines @@
 }
 
 template <class Machine>
 typename InstX86Base<Machine>::Traits::Cond::BrCond
 InstX86Base<Machine>::getOppositeCondition(typename Traits::Cond::BrCond Cond) {
   return Traits::InstBrAttributes[Cond].Opposite;
 }
 
 template <class Machine>
 InstX86FakeRMW<Machine>::InstX86FakeRMW(Cfg *Func, Operand *Data, Operand *Addr,
-                                        InstArithmetic::OpKind Op,
+                                        InstArithmetic::OpKind MyOp,
                                         Variable *Beacon)
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::FakeRMW, 3, nullptr),
-      Op(Op) {
+      Op(MyOp) {
   this->addSource(Data);
   this->addSource(Addr);
   this->addSource(Beacon);
 }
 
 template <class Machine>
-InstX86AdjustStack<Machine>::InstX86AdjustStack(Cfg *Func, SizeT Amount,
+InstX86AdjustStack<Machine>::InstX86AdjustStack(Cfg *Func, SizeT MyAmount,
                                                 Variable *Esp)
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::Adjuststack, 1, Esp),
-      Amount(Amount) {
+      Amount(MyAmount) {
   this->addSource(Esp);
 }
 
 template <class Machine>
 InstX86Mul<Machine>::InstX86Mul(Cfg *Func, Variable *Dest, Variable *Source1,
                                 Operand *Source2)
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::Mul, 2, Dest) {
   this->addSource(Source1);
   this->addSource(Source2);
 }
@@ skipping 22 matching lines @@
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::Label, 0, nullptr),
       Number(Target->makeNextLabelNumber()) {}
 
 template <class Machine>
 IceString InstX86Label<Machine>::getName(const Cfg *Func) const {
   return ".L" + Func->getFunctionName() + "$local$__" + std::to_string(Number);
 }
 
 template <class Machine>
 InstX86Br<Machine>::InstX86Br(
-    Cfg *Func, const CfgNode *TargetTrue, const CfgNode *TargetFalse,
-    const InstX86Label<Machine> *Label,
-    typename InstX86Base<Machine>::Traits::Cond::BrCond Condition)
+    Cfg *Func, const CfgNode *MyTargetTrue, const CfgNode *MyTargetFalse,
+    const InstX86Label<Machine> *MyLabel,
+    typename InstX86Base<Machine>::Traits::Cond::BrCond MyCondition)
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::Br, 0, nullptr),
-      Condition(Condition), TargetTrue(TargetTrue), TargetFalse(TargetFalse),
-      Label(Label) {}
+      Condition(MyCondition), TargetTrue(MyTargetTrue),
+      TargetFalse(MyTargetFalse), Label(MyLabel) {}
 
 template <class Machine>
 bool InstX86Br<Machine>::optimizeBranch(const CfgNode *NextNode) {
   // If there is no next block, then there can be no fallthrough to
   // optimize.
   if (NextNode == nullptr)
     return false;
   // Intra-block conditional branches can't be optimized.
   if (Label)
     return false;
@@ skipping 51 matching lines @@
 InstX86Call<Machine>::InstX86Call(Cfg *Func, Variable *Dest,
                                   Operand *CallTarget)
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::Call, 1, Dest) {
   this->HasSideEffects = true;
   this->addSource(CallTarget);
 }
 
 template <class Machine>
 InstX86Cmov<Machine>::InstX86Cmov(
     Cfg *Func, Variable *Dest, Operand *Source,
-    typename InstX86Base<Machine>::Traits::Cond::BrCond Condition)
+    typename InstX86Base<Machine>::Traits::Cond::BrCond MyCondition)
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::Cmov, 2, Dest),
-      Condition(Condition) {
+      Condition(MyCondition) {
   // The final result is either the original Dest, or Source, so mark
   // both as sources.
   this->addSource(Dest);
   this->addSource(Source);
 }
 
 template <class Machine>
 InstX86Cmpps<Machine>::InstX86Cmpps(
     Cfg *Func, Variable *Dest, Operand *Source,
-    typename InstX86Base<Machine>::Traits::Cond::CmppsCond Condition)
+    typename InstX86Base<Machine>::Traits::Cond::CmppsCond MyCondition)
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::Cmpps, 2, Dest),
-      Condition(Condition) {
+      Condition(MyCondition) {
   this->addSource(Dest);
   this->addSource(Source);
 }
 
 template <class Machine>
 InstX86Cmpxchg<Machine>::InstX86Cmpxchg(Cfg *Func, Operand *DestOrAddr,
                                         Variable *Eax, Variable *Desired,
                                         bool Locked)
     : InstX86BaseLockable<Machine>(Func, InstX86Base<Machine>::Cmpxchg, 3,
                                    llvm::dyn_cast<Variable>(DestOrAddr),
@@ skipping 21 matching lines @@
          InstX86Base<Machine>::Traits::RegisterSet::Reg_ebx);
   this->addSource(Addr);
   this->addSource(Edx);
   this->addSource(Eax);
   this->addSource(Ecx);
   this->addSource(Ebx);
 }
 
 template <class Machine>
 InstX86Cvt<Machine>::InstX86Cvt(Cfg *Func, Variable *Dest, Operand *Source,
-                                CvtVariant Variant)
+                                CvtVariant MyVariant)
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::Cvt, 1, Dest),
-      Variant(Variant) {
+      Variant(MyVariant) {
   this->addSource(Source);
 }
 
 template <class Machine>
 InstX86Icmp<Machine>::InstX86Icmp(Cfg *Func, Operand *Src0, Operand *Src1)
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::Icmp, 2, nullptr) {
   this->addSource(Src0);
   this->addSource(Src1);
 }
 
@@ skipping 42 matching lines @@
 template <class Machine>
 InstX86StoreQ<Machine>::InstX86StoreQ(
     Cfg *Func, Variable *Value,
     typename InstX86Base<Machine>::Traits::X86OperandMem *Mem)
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::StoreQ, 2, nullptr) {
   this->addSource(Value);
   this->addSource(Mem);
 }
 
 template <class Machine>
-InstX86Nop<Machine>::InstX86Nop(Cfg *Func, InstX86Nop::NopVariant Variant)
+InstX86Nop<Machine>::InstX86Nop(Cfg *Func, InstX86Nop::NopVariant MyVariant)
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::Nop, 0, nullptr),
-      Variant(Variant) {}
+      Variant(MyVariant) {}
 
 template <class Machine>
 InstX86Fld<Machine>::InstX86Fld(Cfg *Func, Operand *Src)
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::Fld, 1, nullptr) {
   this->addSource(Src);
 }
 
 template <class Machine>
 InstX86Fstp<Machine>::InstX86Fstp(Cfg *Func, Variable *Dest)
     : InstX86Base<Machine>(Func, InstX86Base<Machine>::Fstp, 0, Dest) {}
@@ skipping 2836 matching lines @@
   Type Ty = this->getSrc(0)->getType();
   Str << "xchg." << Ty << " ";
   this->dumpSources(Func);
 }
 
 } // end of namespace X86Internal
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX86BASEIMPL_H