Subzero: Add -Wshadow to the build.

src/IceGlobalInits.h

 //===- subzero/src/IceGlobalInits.h - Global declarations -------*- 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 declares the representation of function declarations,
 /// global variable declarations, and the corresponding variable
 /// initializers in Subzero. Global variable initializers are
 /// represented as a sequence of simple initializers.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEGLOBALINITS_H
 #define SUBZERO_SRC_ICEGLOBALINITS_H
 
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
 #include "IceTypes.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wshadow"
 #include "llvm/Bitcode/NaCl/NaClBitcodeParser.h" // for NaClBitcodeRecord.
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/GlobalValue.h" // for GlobalValue::LinkageTypes.
 #pragma clang diagnostic pop
 
 #include <memory>
 #include <utility>
 
 // TODO(kschimpf): Remove ourselves from using LLVM representation for calling
 // conventions and linkage types.
@@ skipping 43 matching lines @@
   /// Returns true if when emitting names, we should suppress mangling.
   virtual bool getSuppressMangling() const = 0;
 
   /// Mangles name for cross tests, unless external and not defined locally
   /// (so that relocations accross pnacl-sz and pnacl-llc will work).
   virtual IceString mangleName(GlobalContext *Ctx) const {
     return getSuppressMangling() ? Name : Ctx->mangleName(Name);
   }
 
 protected:
-  GlobalDeclaration(GlobalDeclarationKind Kind,
-                    llvm::GlobalValue::LinkageTypes Linkage)
-      : Kind(Kind), Linkage(Linkage) {}
+  GlobalDeclaration(GlobalDeclarationKind MyKind,
+                    llvm::GlobalValue::LinkageTypes MyLinkage)
+      : Kind(MyKind), Linkage(MyLinkage) {}
 
   const GlobalDeclarationKind Kind;
   IceString Name;
   llvm::GlobalValue::LinkageTypes Linkage;
 };
 
 /// Models a function declaration. This includes the type signature of
 /// the function, its calling conventions, and its linkage.
 class FunctionDeclaration : public GlobalDeclaration {
   FunctionDeclaration() = delete;
@@ skipping 18 matching lines @@
   }
   void dumpType(Ostream &Stream) const final;
   void dump(GlobalContext *Ctx, Ostream &Stream) const final;
   bool getSuppressMangling() const final { return isExternal() && IsProto; }
 
 private:
   const Ice::FuncSigType Signature;
   llvm::CallingConv::ID CallingConv;
   bool IsProto;
 
-  FunctionDeclaration(const FuncSigType &Signature,
-                      llvm::CallingConv::ID CallingConv,
-                      llvm::GlobalValue::LinkageTypes Linkage, bool IsProto)
+  FunctionDeclaration(const FuncSigType &MySignature,
+                      llvm::CallingConv::ID MyCallingConv,
+                      llvm::GlobalValue::LinkageTypes Linkage, bool MyIsProto)
       : GlobalDeclaration(FunctionDeclarationKind, Linkage),
-        Signature(Signature), CallingConv(CallingConv), IsProto(IsProto) {}
+        Signature(MySignature), CallingConv(MyCallingConv), IsProto(MyIsProto) {
+  }
 };
 
 /// Models a global variable declaration, and its initializers.
 class VariableDeclaration : public GlobalDeclaration {
   VariableDeclaration(const VariableDeclaration &) = delete;
   VariableDeclaration &operator=(const VariableDeclaration &) = delete;
 
 public:
   /// Base class for a global variable initializer.
   class Initializer {
@@ skipping 11 matching lines @@
     virtual ~Initializer() = default;
     virtual SizeT getNumBytes() const = 0;
     virtual void dump(GlobalContext *Ctx, Ostream &Stream) const = 0;
     void dump(Ostream &Stream) const {
       if (BuildDefs::dump())
         dump(nullptr, Stream);
     }
     virtual void dumpType(Ostream &Stream) const;
 
   protected:
-    explicit Initializer(InitializerKind Kind) : Kind(Kind) {}
+    explicit Initializer(InitializerKind MyKind) : Kind(MyKind) {}
 
   private:
     const InitializerKind Kind;
   };
 
   /// Models the data in a data initializer.
   typedef std::vector<char> DataVecType;
 
   /// Defines a sequence of byte values as a data initializer.
   class DataInitializer : public Initializer {
@@ skipping 43 matching lines @@
     }
     SizeT getNumBytes() const final { return Size; }
     void dump(GlobalContext *Ctx, Ostream &Stream) const final;
     static bool classof(const Initializer *Z) {
       return Z->getKind() == ZeroInitializerKind;
     }
 
   private:
     ENABLE_MAKE_UNIQUE;
 
-    explicit ZeroInitializer(SizeT Size)
-        : Initializer(ZeroInitializerKind), Size(Size) {}
+    explicit ZeroInitializer(SizeT MySize)
+        : Initializer(ZeroInitializerKind), Size(MySize) {}
 
     /// The number of bytes to be zero initialized.
     SizeT Size;
   };
 
   /// Defines the relocation value of another global declaration.
   class RelocInitializer : public Initializer {
     RelocInitializer(const RelocInitializer &) = delete;
     RelocInitializer &operator=(const RelocInitializer &) = delete;
 
   public:
     static std::unique_ptr<RelocInitializer>
     create(const GlobalDeclaration *Declaration, RelocOffsetT Offset) {
       return makeUnique<RelocInitializer>(Declaration, Offset);
     }
 
     RelocOffsetT getOffset() const { return Offset; }
     const GlobalDeclaration *getDeclaration() const { return Declaration; }
     SizeT getNumBytes() const final { return RelocAddrSize; }
     void dump(GlobalContext *Ctx, Ostream &Stream) const final;
     void dumpType(Ostream &Stream) const final;
     static bool classof(const Initializer *R) {
       return R->getKind() == RelocInitializerKind;
     }
 
   private:
     ENABLE_MAKE_UNIQUE;
 
-    RelocInitializer(const GlobalDeclaration *Declaration, RelocOffsetT Offset)
-        : Initializer(RelocInitializerKind), Declaration(Declaration),
-          Offset(Offset) {} // The global declaration used in the relocation.
+    RelocInitializer(const GlobalDeclaration *MyDeclaration,
+                     RelocOffsetT MyOffset)
+        : Initializer(RelocInitializerKind), Declaration(MyDeclaration),
+          Offset(MyOffset) {} // The global declaration used in the relocation.
 
     const GlobalDeclaration *Declaration;
     /// The offset to add to the relocation.
     const RelocOffsetT Offset;
   };
 
   /// Models the list of initializers.
   typedef std::vector<std::unique_ptr<Initializer>> InitializerListType;
 
   static VariableDeclaration *create(GlobalContext *Context) {
@@ skipping 78 matching lines @@
 template <class StreamType>
 inline StreamType &operator<<(StreamType &Stream,
                               const GlobalDeclaration &Addr) {
   Addr.dump(Stream);
   return Stream;
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALINITS_H