Subzero: Add -Wshadow to the build.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 68 matching lines @@
     assert(Func);
     dump(Func, Func->getContext()->getStrDump());
   }
   void dump(Ostream &Str) const {
     if (BuildDefs::dump())
       dump(nullptr, Str);
   }
   /// @}
 
 protected:
-  Operand(OperandKind Kind, Type Ty) : Ty(Ty), Kind(Kind) {}
+  Operand(OperandKind MyKind, Type MyTy) : Ty(MyTy), Kind(MyKind) {}
   virtual ~Operand() = default;
 
   const Type Ty;
   const OperandKind Kind;
   /// Vars and NumVars are initialized by the derived class.
   SizeT NumVars = 0;
   Variable **Vars = nullptr;
 };
 
 template <class StreamType>
@@ skipping 27 matching lines @@
   virtual bool shouldBeRandomizedOrPooled(const GlobalContext *Ctx) {
     (void)Ctx;
     return false;
   }
 
   void setShouldBePooled(bool R) { shouldBePooled = R; }
 
   bool getShouldBePooled() const { return shouldBePooled; }
 
 protected:
-  Constant(OperandKind Kind, Type Ty, uint32_t PoolEntryID)
-      : Operand(Kind, Ty), PoolEntryID(PoolEntryID), shouldBePooled(false) {
+  Constant(OperandKind Kind, Type Ty, uint32_t MyPoolEntryID)
+      : Operand(Kind, Ty), PoolEntryID(MyPoolEntryID), shouldBePooled(false) {
     Vars = nullptr;
     NumVars = 0;
   }
   /// PoolEntryID is an integer that uniquely identifies the constant
   /// within its constant pool.  It is used for building the constant
   /// pool in the object code and for referencing its entries.
   const uint32_t PoolEntryID;
   /// Whether we should pool this constant. Usually Float/Double and pooled
   /// Integers should be flagged true.
   bool shouldBePooled;
@@ skipping 28 matching lines @@
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == K;
   }
 
   virtual bool shouldBeRandomizedOrPooled(const GlobalContext *Ctx) override {
     (void)Ctx;
     return false;
   }
 
 private:
-  ConstantPrimitive(Type Ty, PrimType Value, uint32_t PoolEntryID)
-      : Constant(K, Ty, PoolEntryID), Value(Value) {}
+  ConstantPrimitive(Type Ty, PrimType MyValue, uint32_t PoolEntryID)
+      : Constant(K, Ty, PoolEntryID), Value(MyValue) {}
   const PrimType Value;
 };
 
 typedef ConstantPrimitive<int32_t, Operand::kConstInteger32> ConstantInteger32;
 typedef ConstantPrimitive<int64_t, Operand::kConstInteger64> ConstantInteger64;
 typedef ConstantPrimitive<float, Operand::kConstFloat> ConstantFloat;
 typedef ConstantPrimitive<double, Operand::kConstDouble> ConstantDouble;
 
 template <>
 inline void ConstantInteger32::dump(const Cfg *, Ostream &Str) const {
@@ skipping 19 matching lines @@
 
 /// RelocatableTuple bundles the parameters that are used to
 /// construct an ConstantRelocatable.  It is done this way so that
 /// ConstantRelocatable can fit into the global constant pool
 /// template mechanism.
 class RelocatableTuple {
   RelocatableTuple() = delete;
   RelocatableTuple &operator=(const RelocatableTuple &) = delete;
 
 public:
-  RelocatableTuple(const RelocOffsetT Offset, const IceString &Name,
-                   bool SuppressMangling)
-      : Offset(Offset), Name(Name), SuppressMangling(SuppressMangling) {}
+  RelocatableTuple(const RelocOffsetT MyOffset, const IceString &MyName,
+                   bool MySuppressMangling)
+      : Offset(MyOffset), Name(MyName), SuppressMangling(MySuppressMangling) {}
   RelocatableTuple(const RelocatableTuple &) = default;
 
   const RelocOffsetT Offset;
   const IceString Name;
   bool SuppressMangling;
 };
 
 bool operator==(const RelocatableTuple &A, const RelocatableTuple &B);
 
 /// ConstantRelocatable represents a symbolic constant combined with
@@ skipping 22 matching lines @@
   void emitWithoutPrefix(TargetLowering *Target) const;
   using Constant::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind == kConstRelocatable;
   }
 
 private:
-  ConstantRelocatable(Type Ty, RelocOffsetT Offset, const IceString &Name,
-                      bool SuppressMangling, uint32_t PoolEntryID)
-      : Constant(kConstRelocatable, Ty, PoolEntryID), Offset(Offset),
-        Name(Name), SuppressMangling(SuppressMangling) {}
+  ConstantRelocatable(Type Ty, RelocOffsetT MyOffset, const IceString &MyName,
+                      bool MySuppressMangling, uint32_t PoolEntryID)
+      : Constant(kConstRelocatable, Ty, PoolEntryID), Offset(MyOffset),
+        Name(MyName), SuppressMangling(MySuppressMangling) {}
   const RelocOffsetT Offset; /// fixed offset to add
   const IceString Name;      /// optional for debug/dump
   bool SuppressMangling;
 };
 
 /// ConstantUndef represents an unspecified bit pattern. Although it is
 /// legal to lower ConstantUndef to any value, backends should try to
 /// make code generation deterministic by lowering ConstantUndefs to 0.
 class ConstantUndef : public Constant {
   ConstantUndef() = delete;
@@ skipping 24 matching lines @@
   ConstantUndef(Type Ty, uint32_t PoolEntryID)
       : Constant(kConstUndef, Ty, PoolEntryID) {}
 };
 
 /// RegWeight is a wrapper for a uint32_t weight value, with a
 /// special value that represents infinite weight, and an addWeight()
 /// method that ensures that W+infinity=infinity.
 class RegWeight {
 public:
   RegWeight() = default;
-  explicit RegWeight(uint32_t Weight) : Weight(Weight) {}
+  explicit RegWeight(uint32_t MyWeight) : Weight(MyWeight) {}
   RegWeight(const RegWeight &) = default;
   RegWeight &operator=(const RegWeight &) = default;
   const static uint32_t Inf = ~0; /// Force regalloc to give a register
   const static uint32_t Zero = 0; /// Force regalloc NOT to give a register
   void addWeight(uint32_t Delta) {
     if (Delta == Inf)
       Weight = Inf;
     else if (Weight != Inf)
       Weight += Delta;
   }
@@ skipping 264 matching lines @@
 };
 
 /// VariablesMetadata analyzes and summarizes the metadata for the
 /// complete set of Variables.
 class VariablesMetadata {
   VariablesMetadata() = delete;
   VariablesMetadata(const VariablesMetadata &) = delete;
   VariablesMetadata &operator=(const VariablesMetadata &) = delete;
 
 public:
-  explicit VariablesMetadata(const Cfg *Func) : Func(Func) {}
+  explicit VariablesMetadata(const Cfg *MyFunc) : Func(MyFunc) {}
   /// Initialize the state by traversing all instructions/variables in
   /// the CFG.
   void init(MetadataKind TrackingKind);
   /// Add a single node.  This is called by init(), and can be called
   /// incrementally from elsewhere, e.g. after edge-splitting.
   void addNode(CfgNode *Node);
   /// Returns whether the given Variable is tracked in this object.  It
   /// should only return false if changes were made to the CFG after
   /// running init(), in which case the state is stale and the results
   /// shouldn't be trusted (but it may be OK e.g. for dumping).
@@ skipping 33 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H