Subzero: Add -Wshadow to the build.

src/IceInstX8632.cpp

 //===- subzero/src/IceInstX8632.cpp - X86-32 instruction 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 InstX8632 and OperandX8632 classes,
@@ skipping 71 matching lines @@
 }
 
 const char *InstX8632::getFldString(Type Ty) {
   return TypeX8632Attributes[Ty].FldString;
 }
 
 CondX86::BrCond InstX8632::getOppositeCondition(CondX86::BrCond Cond) {
   return InstX8632BrAttributes[Cond].Opposite;
 }
 
-OperandX8632Mem::OperandX8632Mem(Cfg *Func, Type Ty, Variable *Base,
-                                 Constant *Offset, Variable *Index,
-                                 uint16_t Shift, SegmentRegisters SegmentReg)
-    : OperandX8632(kMem, Ty), Base(Base), Offset(Offset), Index(Index),
-      Shift(Shift), SegmentReg(SegmentReg), Randomized(false) {
+OperandX8632Mem::OperandX8632Mem(Cfg *Func, Type Ty, Variable *MyBase,
+                                 Constant *MyOffset, Variable *MyIndex,
+                                 uint16_t MyShift,
+                                 SegmentRegisters MySegmentReg)
+    : OperandX8632(kMem, Ty), Base(MyBase), Offset(MyOffset), Index(MyIndex),
+      Shift(MyShift), SegmentReg(MySegmentReg), Randomized(false) {
   assert(Shift <= 3);
   Vars = nullptr;
   NumVars = 0;
   if (Base)
     ++NumVars;
   if (Index)
     ++NumVars;
   if (NumVars) {
     Vars = Func->allocateArrayOf<Variable *>(NumVars);
     SizeT I = 0;
     if (Base)
       Vars[I++] = Base;
     if (Index)
       Vars[I++] = Index;
     assert(I == NumVars);
   }
 }
 
 InstX8632FakeRMW::InstX8632FakeRMW(Cfg *Func, Operand *Data, Operand *Addr,
-                                   InstArithmetic::OpKind Op, Variable *Beacon)
-    : InstX8632(Func, InstX8632::FakeRMW, 3, nullptr), Op(Op) {
+                                   InstArithmetic::OpKind MyOp,
+                                   Variable *Beacon)
+    : InstX8632(Func, InstX8632::FakeRMW, 3, nullptr), Op(MyOp) {
   addSource(Data);
   addSource(Addr);
   addSource(Beacon);
 }
 
-InstX8632AdjustStack::InstX8632AdjustStack(Cfg *Func, SizeT Amount,
+InstX8632AdjustStack::InstX8632AdjustStack(Cfg *Func, SizeT MyAmount,
                                            Variable *Esp)
-    : InstX8632(Func, InstX8632::Adjuststack, 1, Esp), Amount(Amount) {
+    : InstX8632(Func, InstX8632::Adjuststack, 1, Esp), Amount(MyAmount) {
   addSource(Esp);
 }
 
 InstX8632Mul::InstX8632Mul(Cfg *Func, Variable *Dest, Variable *Source1,
                            Operand *Source2)
     : InstX8632(Func, InstX8632::Mul, 2, Dest) {
   addSource(Source1);
   addSource(Source2);
 }
 
@@ skipping 14 matching lines @@
 }
 
 InstX8632Label::InstX8632Label(Cfg *Func, TargetX8632 *Target)
     : InstX8632(Func, InstX8632::Label, 0, nullptr),
       Number(Target->makeNextLabelNumber()) {}
 
 IceString InstX8632Label::getName(const Cfg *Func) const {
   return ".L" + Func->getFunctionName() + "$local$__" + std::to_string(Number);
 }
 
-InstX8632Br::InstX8632Br(Cfg *Func, const CfgNode *TargetTrue,
-                         const CfgNode *TargetFalse,
-                         const InstX8632Label *Label, CondX86::BrCond Condition)
-    : InstX8632(Func, InstX8632::Br, 0, nullptr), Condition(Condition),
-      TargetTrue(TargetTrue), TargetFalse(TargetFalse), Label(Label) {}
+InstX8632Br::InstX8632Br(Cfg *Func, const CfgNode *MyTargetTrue,
+                         const CfgNode *MyTargetFalse,
+                         const InstX8632Label *MyLabel,
+                         CondX86::BrCond MyCondition)
+    : InstX8632(Func, InstX8632::Br, 0, nullptr), Condition(MyCondition),
+      TargetTrue(MyTargetTrue), TargetFalse(MyTargetFalse), Label(MyLabel) {}
 
 bool InstX8632Br::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;
   // If there is no fallthrough node, such as a non-default case label
@@ skipping 43 matching lines @@
   addSource(Target);
 }
 
 InstX8632Call::InstX8632Call(Cfg *Func, Variable *Dest, Operand *CallTarget)
     : InstX8632(Func, InstX8632::Call, 1, Dest) {
   HasSideEffects = true;
   addSource(CallTarget);
 }
 
 InstX8632Cmov::InstX8632Cmov(Cfg *Func, Variable *Dest, Operand *Source,
-                             CondX86::BrCond Condition)
-    : InstX8632(Func, InstX8632::Cmov, 2, Dest), Condition(Condition) {
+                             CondX86::BrCond MyCondition)
+    : InstX8632(Func, InstX8632::Cmov, 2, Dest), Condition(MyCondition) {
   // The final result is either the original Dest, or Source, so mark
   // both as sources.
   addSource(Dest);
   addSource(Source);
 }
 
 InstX8632Cmpps::InstX8632Cmpps(Cfg *Func, Variable *Dest, Operand *Source,
-                               CondX86::CmppsCond Condition)
-    : InstX8632(Func, InstX8632::Cmpps, 2, Dest), Condition(Condition) {
+                               CondX86::CmppsCond MyCondition)
+    : InstX8632(Func, InstX8632::Cmpps, 2, Dest), Condition(MyCondition) {
   addSource(Dest);
   addSource(Source);
 }
 
 InstX8632Cmpxchg::InstX8632Cmpxchg(Cfg *Func, Operand *DestOrAddr,
                                    Variable *Eax, Variable *Desired,
                                    bool Locked)
     : InstX8632Lockable(Func, InstX8632::Cmpxchg, 3,
                         llvm::dyn_cast<Variable>(DestOrAddr), Locked) {
   assert(Eax->getRegNum() == RegX8632::Reg_eax);
@@ skipping 12 matching lines @@
   assert(Ecx->getRegNum() == RegX8632::Reg_ecx);
   assert(Ebx->getRegNum() == RegX8632::Reg_ebx);
   addSource(Addr);
   addSource(Edx);
   addSource(Eax);
   addSource(Ecx);
   addSource(Ebx);
 }
 
 InstX8632Cvt::InstX8632Cvt(Cfg *Func, Variable *Dest, Operand *Source,
-                           CvtVariant Variant)
-    : InstX8632(Func, InstX8632::Cvt, 1, Dest), Variant(Variant) {
+                           CvtVariant MyVariant)
+    : InstX8632(Func, InstX8632::Cvt, 1, Dest), Variant(MyVariant) {
   addSource(Source);
 }
 
 InstX8632Icmp::InstX8632Icmp(Cfg *Func, Operand *Src0, Operand *Src1)
     : InstX8632(Func, InstX8632::Icmp, 2, nullptr) {
   addSource(Src0);
   addSource(Src1);
 }
 
 InstX8632Ucomiss::InstX8632Ucomiss(Cfg *Func, Operand *Src0, Operand *Src1)
@@ skipping 29 matching lines @@
   addSource(Mem);
 }
 
 InstX8632StoreQ::InstX8632StoreQ(Cfg *Func, Variable *Value,
                                  OperandX8632Mem *Mem)
     : InstX8632(Func, InstX8632::StoreQ, 2, nullptr) {
   addSource(Value);
   addSource(Mem);
 }
 
-InstX8632Nop::InstX8632Nop(Cfg *Func, InstX8632Nop::NopVariant Variant)
-    : InstX8632(Func, InstX8632::Nop, 0, nullptr), Variant(Variant) {}
+InstX8632Nop::InstX8632Nop(Cfg *Func, InstX8632Nop::NopVariant MyVariant)
+    : InstX8632(Func, InstX8632::Nop, 0, nullptr), Variant(MyVariant) {}
 
 InstX8632Fld::InstX8632Fld(Cfg *Func, Operand *Src)
     : InstX8632(Func, InstX8632::Fld, 1, nullptr) {
   addSource(Src);
 }
 
 InstX8632Fstp::InstX8632Fstp(Cfg *Func, Variable *Dest)
     : InstX8632(Func, InstX8632::Fstp, 0, Dest) {}
 
 InstX8632Pop::InstX8632Pop(Cfg *Func, Variable *Dest)
@@ skipping 1058 matching lines @@
 template <> void InstX8632Imul::emitIAS(const Cfg *Func) const {
   assert(getSrcSize() == 2);
   const Variable *Var = getDest();
   Type Ty = Var->getType();
   const Operand *Src = getSrc(1);
   if (isByteSizedArithType(Ty)) {
     // The 8-bit version of imul only allows the form "imul r/m8".
     const auto Src0Var = llvm::dyn_cast<Variable>(getSrc(0));
     (void)Src0Var;
     assert(Src0Var && Src0Var->getRegNum() == RegX8632::Reg_eax);
-    const X8632::AssemblerX8632::GPREmitterOneOp Emitter = {
+    const X8632::AssemblerX8632::GPREmitterOneOp MyEmitter = {
         &X8632::AssemblerX8632::imul, &X8632::AssemblerX8632::imul};
-    emitIASOpTyGPR(Func, Ty, getSrc(1), Emitter);
+    emitIASOpTyGPR(Func, Ty, getSrc(1), MyEmitter);
   } else {
     // We only use imul as a two-address instruction even though
     // there is a 3 operand version when one of the operands is a constant.
     assert(Var == getSrc(0));
-    const X8632::AssemblerX8632::GPREmitterRegOp Emitter = {
+    const X8632::AssemblerX8632::GPREmitterRegOp MyEmitter = {
         &X8632::AssemblerX8632::imul, &X8632::AssemblerX8632::imul,
         &X8632::AssemblerX8632::imul};
-    emitIASRegOpTyGPR(Func, Ty, Var, Src, Emitter);
+    emitIASRegOpTyGPR(Func, Ty, Var, Src, MyEmitter);
   }
 }
 
 template <> void InstX8632Insertps::emitIAS(const Cfg *Func) const {
   assert(getSrcSize() == 3);
   assert(static_cast<TargetX8632 *>(Func->getTarget())->getInstructionSet() >=
          TargetX8632::SSE4_1);
   const Variable *Dest = getDest();
   assert(Dest == getSrc(0));
   Type Ty = Dest->getType();
@@ skipping 1630 matching lines @@
   }
   Str << "(";
   if (Func)
     Var->dump(Func);
   else
     Var->dump(Str);
   Str << ")";
 }
 
 } // end of namespace Ice