Subzero: Add -Wshadow to the build.

src/IceConverter.cpp

 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice  ---------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 10 matching lines @@
 #include "IceGlobalContext.h"
 #include "IceGlobalInits.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 #include "IceTypes.h"
 #include "IceTypeConverter.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wshadow"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #pragma clang diagnostic pop
 
 // TODO(kschimpf): Remove two namespaces being visible at once.
@@ skipping 13 matching lines @@
 // TODO(stichnot): Redesign Converter, LLVM2ICEConverter,
 // LLVM2ICEFunctionConverter, and LLVM2ICEGlobalsConverter with
 // respect to Translator.  In particular, the unique_ptr ownership
 // rules in LLVM2ICEFunctionConverter.
 class LLVM2ICEConverter {
   LLVM2ICEConverter() = delete;
   LLVM2ICEConverter(const LLVM2ICEConverter &) = delete;
   LLVM2ICEConverter &operator=(const LLVM2ICEConverter &) = delete;
 
 public:
-  explicit LLVM2ICEConverter(Ice::Converter &Converter)
-      : Converter(Converter), Ctx(Converter.getContext()),
-        TypeConverter(Converter.getModule()->getContext()) {}
+  explicit LLVM2ICEConverter(Ice::Converter &MyConverter)
+      : Converter(MyConverter), Ctx(MyConverter.getContext()),
+        TypeConverter(MyConverter.getModule()->getContext()) {}
 
   Ice::Converter &getConverter() const { return Converter; }
 
 protected:
   Ice::Converter &Converter;
   Ice::GlobalContext *Ctx;
   const Ice::TypeConverter TypeConverter;
 };
 
 // Converter from LLVM functions to ICE. The entry point is the
@@ skipping 45 matching lines @@
     Converter.translateFcn(std::move(Func));
   }
 
   // convertConstant() does not use Func or require it to be a valid
   // Ice::Cfg pointer.  As such, it's suitable for e.g. constructing
   // global initializers.
   Ice::Constant *convertConstant(const Constant *Const) {
     if (const auto GV = dyn_cast<GlobalValue>(Const)) {
       Ice::GlobalDeclaration *Decl = getConverter().getGlobalDeclaration(GV);
       bool IsUndefined = false;
-      if (const auto *Func = llvm::dyn_cast<Ice::FunctionDeclaration>(Decl))
-        IsUndefined = Func->isProto();
+      if (const auto *MyFunc = llvm::dyn_cast<Ice::FunctionDeclaration>(Decl))
+        IsUndefined = MyFunc->isProto();
       else if (const auto *Var = llvm::dyn_cast<Ice::VariableDeclaration>(Decl))
         IsUndefined = !Var->hasInitializer();
       else
         report_fatal_error("Unhandled GlobalDeclaration type");
       if (IsUndefined)
         return Ctx->getConstantExternSym(Decl->getName());
       else {
         const Ice::RelocOffsetT Offset = 0;
         return Ctx->getConstantSym(Offset, Decl->getName(),
                                    Decl->getSuppressMangling());
@@ skipping 583 matching lines @@
       else {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Global declaration missing initializer: " << GV->getName();
         report_fatal_error(StrBuf.str());
       }
     }
 
     const Constant *Initializer = GV->getInitializer();
     if (const auto CompoundInit = dyn_cast<ConstantStruct>(Initializer)) {
-      for (ConstantStruct::const_op_iterator I = CompoundInit->op_begin(),
-                                             E = CompoundInit->op_end();
-           I != E; ++I) {
-        if (const auto Init = dyn_cast<Constant>(I)) {
+      for (ConstantStruct::const_op_iterator CII = CompoundInit->op_begin(),
+                                             CIE = CompoundInit->op_end();
+           CII != CIE; ++CII) {
+        if (const auto Init = dyn_cast<Constant>(CII)) {
           addGlobalInitializer(*VarDecl, Init);
         }
       }
     } else {
       addGlobalInitializer(*VarDecl, Initializer);
     }
   }
   return std::move(VariableDeclarations);
 }
 
@@ skipping 49 matching lines @@
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Unhandled global initializer: " << Initializer;
   report_fatal_error(StrBuf.str());
 }
 
 } // end of anonymous namespace
 
 namespace Ice {
 
-void Converter::nameUnnamedGlobalVariables(Module *Mod) {
+void Converter::nameUnnamedGlobalVariables(Module *MyMod) {

[jvoung (off chromium), 2015/07/14 01:25:19]

This could probably just use Mod instead of taking a parameter (should be the
same Mod?)?

Similar below?

   const IceString &GlobalPrefix = Ctx->getFlags().getDefaultGlobalPrefix();
   if (GlobalPrefix.empty())
     return;
   uint32_t NameIndex = 0;
-  for (auto V = Mod->global_begin(), E = Mod->global_end(); V != E; ++V) {
+  for (auto V = MyMod->global_begin(), E = MyMod->global_end(); V != E; ++V) {
     if (!V->hasName()) {
       V->setName(createUnnamedName(GlobalPrefix, NameIndex));
       ++NameIndex;
     } else {
       checkIfUnnamedNameSafe(V->getName(), "global", GlobalPrefix);
     }
   }
 }
 
-void Converter::nameUnnamedFunctions(Module *Mod) {
+void Converter::nameUnnamedFunctions(Module *MyMod) {
   const IceString &FunctionPrefix = Ctx->getFlags().getDefaultFunctionPrefix();
   if (FunctionPrefix.empty())
     return;
   uint32_t NameIndex = 0;
-  for (Function &F : *Mod) {
+  for (Function &F : *MyMod) {
     if (!F.hasName()) {
       F.setName(createUnnamedName(FunctionPrefix, NameIndex));
       ++NameIndex;
     } else {
       checkIfUnnamedNameSafe(F.getName(), "function", FunctionPrefix);
     }
   }
 }
 
 void Converter::convertToIce() {
   TimerMarker T(TimerStack::TT_convertToIce, Ctx);
   nameUnnamedGlobalVariables(Mod);
   nameUnnamedFunctions(Mod);
   installGlobalDeclarations(Mod);
   convertGlobals(Mod);
   convertFunctions();
 }
 
 GlobalDeclaration *Converter::getGlobalDeclaration(const GlobalValue *V) {
   GlobalDeclarationMapType::const_iterator Pos = GlobalDeclarationMap.find(V);
   if (Pos == GlobalDeclarationMap.end()) {
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Can't find global declaration for: " << V->getName();
     report_fatal_error(StrBuf.str());
   }
   return Pos->second;
 }
 
-void Converter::installGlobalDeclarations(Module *Mod) {
-  const TypeConverter Converter(Mod->getContext());
+void Converter::installGlobalDeclarations(Module *MyMod) {
+  const TypeConverter Converter(MyMod->getContext());
   // Install function declarations.
-  for (const Function &Func : *Mod) {
+  for (const Function &Func : *MyMod) {
     FuncSigType Signature;
     FunctionType *FuncType = Func.getFunctionType();
     Signature.setReturnType(
         Converter.convertToIceType(FuncType->getReturnType()));
     for (size_t I = 0; I < FuncType->getNumParams(); ++I) {
       Signature.appendArgType(
           Converter.convertToIceType(FuncType->getParamType(I)));
     }
     FunctionDeclaration *IceFunc = FunctionDeclaration::create(
         Ctx, Signature, Func.getCallingConv(), Func.getLinkage(), Func.empty());
     IceFunc->setName(Func.getName());
     GlobalDeclarationMap[&Func] = IceFunc;
   }
   // Install global variable declarations.
-  for (Module::const_global_iterator I = Mod->global_begin(),
-                                     E = Mod->global_end();
+  for (Module::const_global_iterator I = MyMod->global_begin(),
+                                     E = MyMod->global_end();
        I != E; ++I) {
     const GlobalVariable *GV = I;
     VariableDeclaration *Var = VariableDeclaration::create(Ctx);
     Var->setName(GV->getName());
     Var->setAlignment(GV->getAlignment());
     Var->setIsConstant(GV->isConstant());
     Var->setLinkage(GV->getLinkage());
     GlobalDeclarationMap[GV] = Var;
   }
 }
 
-void Converter::convertGlobals(Module *Mod) {
-  lowerGlobals(LLVM2ICEGlobalsConverter(*this).convertGlobalsToIce(Mod));
+void Converter::convertGlobals(Module *MyMod) {
+  lowerGlobals(LLVM2ICEGlobalsConverter(*this).convertGlobalsToIce(MyMod));
 }
 
 void Converter::convertFunctions() {
   const TimerStackIdT StackID = GlobalContext::TSK_Funcs;
   for (const Function &I : *Mod) {
     if (I.empty())
       continue;
 
     TimerIdT TimerID = 0;
     const bool TimeThisFunction = Ctx->getFlags().getTimeEachFunction();
     if (TimeThisFunction) {
       TimerID = Ctx->getTimerID(StackID, I.getName());
       Ctx->pushTimer(TimerID, StackID);
     }
     LLVM2ICEFunctionConverter FunctionConverter(*this);
     FunctionConverter.convertFunction(&I);
     if (TimeThisFunction)
       Ctx->popTimer(TimerID, StackID);
   }
 }
 
 } // end of namespace Ice