Subzero: Add -Wshadow to the build.

src/IceAssembler.h

 //===- subzero/src/IceAssembler.h - Integrated assembler --------*- C++ -*-===//
 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Modified by the Subzero authors.
 //
 //===----------------------------------------------------------------------===//
 //
 //                        The Subzero Code Generator
@@ skipping 58 matching lines @@
   /// hold the emitted instruction. Usage:
   ///
   ///     AssemblerBuffer buffer;
   ///     AssemblerBuffer::EnsureCapacity ensured(&buffer);
   ///     ... emit bytes for single instruction ...
   class EnsureCapacity {
     EnsureCapacity(const EnsureCapacity &) = delete;
     EnsureCapacity &operator=(const EnsureCapacity &) = delete;
 
   public:
-    explicit EnsureCapacity(AssemblerBuffer *Buffer) : Buffer(Buffer) {
+    explicit EnsureCapacity(AssemblerBuffer *MyBuffer) : Buffer(MyBuffer) {
       if (Buffer->cursor() >= Buffer->limit())
         Buffer->extendCapacity();
       if (BuildDefs::asserts())
         validate(Buffer);
     }
     ~EnsureCapacity();
 
   private:
     AssemblerBuffer *Buffer;
     intptr_t Gap = 0;
@@ skipping 98 matching lines @@
   /// (represented by NodeNumber).
   virtual void bindCfgNodeLabel(SizeT NodeNumber) = 0;
 
   virtual bool fixupIsPCRel(FixupKind Kind) const = 0;
 
   // Return a view of all the bytes of code for the current function.
   llvm::StringRef getBufferView() const;
 
   const FixupRefList &fixups() const { return Buffer.fixups(); }
 
-  AssemblerFixup *createFixup(FixupKind Kind, const Constant *Value) {
-    return Buffer.createFixup(Kind, Value);
+  AssemblerFixup *createFixup(FixupKind FKind, const Constant *Value) {
+    return Buffer.createFixup(FKind, Value);
   }
 
   void emitIASBytes(GlobalContext *Ctx) const;
   bool getInternal() const { return IsInternal; }
   void setInternal(bool Internal) { IsInternal = Internal; }
   const IceString &getFunctionName() { return FunctionName; }
   void setFunctionName(const IceString &NewName) { FunctionName = NewName; }
   intptr_t getBufferSize() const { return Buffer.size(); }
   /// Roll back to a (smaller) size.
   void setBufferSize(intptr_t NewSize) { Buffer.setSize(NewSize); }
   void setPreliminary(bool Value) { Preliminary = Value; }
   bool getPreliminary() const { return Preliminary; }
 
   AssemblerKind getKind() const { return Kind; }
 
 protected:
-  explicit Assembler(AssemblerKind Kind)
-      : Kind(Kind), Allocator(), Buffer(*this) {}
+  explicit Assembler(AssemblerKind MyKind)
+      : Kind(MyKind), Allocator(), Buffer(*this) {}
 
 private:
   const AssemblerKind Kind;
 
   ArenaAllocator<32 * 1024> Allocator;
   /// FunctionName and IsInternal are transferred from the original Cfg
   /// object, since the Cfg object may be deleted by the time the
   /// assembler buffer is emitted.
   IceString FunctionName = "";
   bool IsInternal = false;
   /// Preliminary indicates whether a preliminary pass is being made
   /// for calculating bundle padding (Preliminary=true), versus the
   /// final pass where all changes to label bindings, label links, and
   /// relocation fixups are fully committed (Preliminary=false).
   bool Preliminary = false;
 
 protected:
   // Buffer's constructor uses the Allocator, so it needs to appear after it.
   // TODO(jpp): dependencies on construction order are a nice way of shooting
   // yourself in the foot. Fix this.
   AssemblerBuffer Buffer;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEASSEMBLER_H_