Subzero: Add -Wshadow to the build.

src/PNaClTranslator.cpp

 //===- subzero/src/PNaClTranslator.cpp - ICE from bitcode -----------------===//
 //
 //                        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 PNaCl bitcode file to Ice, to machine code
 // translator.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PNaClTranslator.h"
 
 #include "IceAPInt.h"
 #include "IceAPFloat.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceGlobalInits.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wshadow"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeDecoders.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeDefs.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeParser.h"
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #pragma clang diagnostic pop
@@ skipping 121 matching lines @@
 
 // Top-level class to read PNaCl bitcode files, and translate to ICE.
 class TopLevelParser : public NaClBitcodeParser {
   TopLevelParser() = delete;
   TopLevelParser(const TopLevelParser &) = delete;
   TopLevelParser &operator=(const TopLevelParser &) = delete;
 
 public:
   typedef std::vector<Ice::FunctionDeclaration *> FunctionDeclarationListType;
 
-  TopLevelParser(Ice::Translator &Translator, NaClBitstreamCursor &Cursor,
-                 Ice::ErrorCode &ErrorStatus)
-      : NaClBitcodeParser(Cursor), Translator(Translator),
-        ErrorStatus(ErrorStatus),
+  TopLevelParser(Ice::Translator &MyTranslator, NaClBitstreamCursor &Cursor,
+                 Ice::ErrorCode &MyErrorStatus)
+      : NaClBitcodeParser(Cursor), Translator(MyTranslator),
+        ErrorStatus(MyErrorStatus),
         VariableDeclarations(new Ice::VariableDeclarationList()) {}
 
   ~TopLevelParser() override = default;
 
   Ice::Translator &getTranslator() const { return Translator; }
 
   void setBlockParser(BlockParserBaseClass *NewBlockParser) {
     BlockParser = NewBlockParser;
   }
 
@@ skipping 386 matching lines @@
 // Because this is the base class of block parsers, we generate error
 // messages if ParseBlock or ParseRecord is not overridden in derived
 // classes.
 class BlockParserBaseClass : public NaClBitcodeParser {
   BlockParserBaseClass() = delete;
   BlockParserBaseClass(const BlockParserBaseClass &) = delete;
   BlockParserBaseClass &operator=(const BlockParserBaseClass &) = delete;
 
 public:
   // Constructor for the top-level module block parser.
-  BlockParserBaseClass(unsigned BlockID, TopLevelParser *Context)
-      : NaClBitcodeParser(BlockID, Context), Context(Context) {
+  BlockParserBaseClass(unsigned BlockID, TopLevelParser *MyContext)
+      : NaClBitcodeParser(BlockID, MyContext), Context(MyContext) {
     Context->setBlockParser(this);
   }
 
   ~BlockParserBaseClass() override { Context->setBlockParser(nullptr); }
 
   // Returns the printable name of the type of block being parsed.
   virtual const char *getBlockName() const {
     // If this class is used, it is parsing an unknown block.
     return "unknown";
   }
@@ skipping 2081 matching lines @@
   }
 }
 
 /// Parses constants within a function block.
 class ConstantsParser : public BlockParserBaseClass {
   ConstantsParser() = delete;
   ConstantsParser(const ConstantsParser &) = delete;
   ConstantsParser &operator=(const ConstantsParser &) = delete;
 
 public:
-  ConstantsParser(unsigned BlockID, FunctionParser *FuncParser)
-      : BlockParserBaseClass(BlockID, FuncParser),
+  ConstantsParser(unsigned BlockID, FunctionParser *MyFuncParser)
+      : BlockParserBaseClass(BlockID, MyFuncParser),
         Timer(Ice::TimerStack::TT_parseConstants, getTranslator().getContext()),
-        FuncParser(FuncParser) {}
+        FuncParser(MyFuncParser) {}
 
   ~ConstantsParser() override = default;
 
   const char *getBlockName() const override { return "constants"; }
 
 private:
   Ice::TimerMarker Timer;
   // The parser of the function block this constants block appears in.
   FunctionParser *FuncParser;
   // The type to use for succeeding constants.
@@ skipping 410 matching lines @@
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     ErrStream
         << IRFilename
         << ": Bitcode stream should be a multiple of 4 bytes in length.\n";
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice