Subzero: Add -Wshadow to the build.

src/IceCfgNode.cpp

 //===- subzero/src/IceCfgNode.cpp - Basic block (node) implementation -----===//
 //
 //                        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 CfgNode class, including the complexities
 // of instruction insertion and in-edge calculation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IceCfgNode.h"
 
 #include "IceAssembler.h"
 #include "IceCfg.h"
 #include "IceGlobalInits.h"
 #include "IceInst.h"
 #include "IceLiveness.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 
 namespace Ice {
 
-CfgNode::CfgNode(Cfg *Func, SizeT LabelNumber)
-    : Func(Func), Number(LabelNumber) {}
+CfgNode::CfgNode(Cfg *MyFunc, SizeT LabelNumber)
+    : Func(MyFunc), Number(LabelNumber) {}
 
 // Returns the name the node was created with.  If no name was given,
 // it synthesizes a (hopefully) unique name.
 IceString CfgNode::getName() const {
   if (NameIndex >= 0)
     return Func->getIdentifierName(NameIndex);
   return "__" + std::to_string(getIndex());
 }
 
 // Adds an instruction to either the Phi list or the regular
@@ skipping 836 matching lines @@
       if (Variable *Src = llvm::dyn_cast<Variable>(I->getSrc(S))) {
         if (!Src->hasReg())
           Func->getContext()->statsUpdateSpills();
       }
     }
   }
 }
 
 } // end of anonymous namespace
 
-void CfgNode::emit(Cfg *Func) const {
+void CfgNode::emit() const {
   if (!BuildDefs::dump())
     return;
   Func->setCurrentNode(this);
   Ostream &Str = Func->getContext()->getStrEmit();
   Liveness *Liveness = Func->getLiveness();
   bool DecorateAsm =
       Liveness && Func->getContext()->getFlags().getDecorateAsm();
   Str << getAsmName() << ":\n";
   // LiveRegCount keeps track of the number of currently live
   // variables that each register is assigned to.  Normally that would
@@ skipping 42 matching lines @@
 }
 
 // Helper class for emitIAS().
 namespace {
 class BundleEmitHelper {
   BundleEmitHelper() = delete;
   BundleEmitHelper(const BundleEmitHelper &) = delete;
   BundleEmitHelper &operator=(const BundleEmitHelper &) = delete;
 
 public:
-  BundleEmitHelper(Assembler *Asm, TargetLowering *Target,
+  BundleEmitHelper(Assembler *MyAsm, TargetLowering *MyTarget,
                    const InstList &Insts)
-      : Asm(Asm), Target(Target), End(Insts.end()), BundleLockStart(End),
+      : Asm(MyAsm), Target(MyTarget), End(Insts.end()), BundleLockStart(End),
         BundleSize(1 << Asm->getBundleAlignLog2Bytes()),
         BundleMaskLo(BundleSize - 1), BundleMaskHi(~BundleMaskLo) {}
   // Check whether we're currently within a bundle_lock region.
   bool isInBundleLockRegion() const { return BundleLockStart != End; }
   // Check whether the current bundle_lock region has the align_to_end
   // option.
   bool isAlignToEnd() const {
     assert(isInBundleLockRegion());
     return llvm::cast<InstBundleLock>(getBundleLockStart())->getOption() ==
            InstBundleLock::Opt_AlignToEnd;
@@ skipping 87 matching lines @@
   // Masking with BundleMaskLo identifies an address's bundle offset.
   const intptr_t BundleMaskLo;
   // Masking with BundleMaskHi identifies an address's bundle.
   const intptr_t BundleMaskHi;
   intptr_t SizeSnapshotPre = 0;
   intptr_t SizeSnapshotPost = 0;
 };
 
 } // end of anonymous namespace
 
-void CfgNode::emitIAS(Cfg *Func) const {
+void CfgNode::emitIAS() const {
   Func->setCurrentNode(this);
   Assembler *Asm = Func->getAssembler<>();
   // TODO(stichnot): When sandboxing, defer binding the node label
   // until just before the first instruction is emitted, to reduce the
   // chance that a padding nop is a branch target.
   Asm->bindCfgNodeLabel(getIndex());
   for (const Inst &I : Phis) {
     if (I.isDeleted())
       continue;
     // Emitting a Phi instruction should cause an error.
@@ skipping 87 matching lines @@
       Helper.leaveBundleLockRegion();
     }
   }
 
   // Don't allow bundle locking across basic blocks, to keep the
   // backtracking mechanism simple.
   assert(!Helper.isInBundleLockRegion());
   assert(!Retrying);
 }
 
-void CfgNode::dump(Cfg *Func) const {
+void CfgNode::dump() const {
   if (!BuildDefs::dump())
     return;
   Func->setCurrentNode(this);
   Ostream &Str = Func->getContext()->getStrDump();
   Liveness *Liveness = Func->getLiveness();
   if (Func->isVerbose(IceV_Instructions)) {
     Str << getName() << ":\n";
   }
   // Dump list of predecessor nodes.
   if (Func->isVerbose(IceV_Preds) && !InEdges.empty()) {
@@ skipping 90 matching lines @@
   InstIntrinsicCall *Inst = InstIntrinsicCall::create(
       Func, 5, Func->makeVariable(IceType_i64), RMWI64Name, Info->Info);
   Inst->addArg(AtomicRMWOp);
   Inst->addArg(Counter);
   Inst->addArg(One);
   Inst->addArg(OrderAcquireRelease);
   Insts.push_front(Inst);
 }
 
 } // end of namespace Ice