Subzero: Use "auto" per (unwritten) auto coding style.

src/IceCfg.cpp

 //===- subzero/src/IceCfg.cpp - Control flow graph implementation ---------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 45 matching lines @@
 
 Cfg::~Cfg() { assert(ICE_TLS_GET_FIELD(CurrentCfg) == nullptr); }
 
 void Cfg::setError(const IceString &Message) {
   HasError = true;
   ErrorMessage = Message;
 }
 
 CfgNode *Cfg::makeNode() {
   SizeT LabelIndex = Nodes.size();
-  CfgNode *Node = CfgNode::create(this, LabelIndex);
+  auto *Node = CfgNode::create(this, LabelIndex);
   Nodes.push_back(Node);
   return Node;
 }
 
 void Cfg::swapNodes(NodeList &NewNodes) {
   assert(Nodes.size() == NewNodes.size());
   Nodes.swap(NewNodes);
   for (SizeT I = 0, NumNodes = getNumNodes(); I < NumNodes; ++I)
     Nodes[I]->resetIndex(I);
 }
@@ skipping 20 matching lines @@
 // Returns whether the stack frame layout has been computed yet. This is used
 // for dumping the stack frame location of Variables.
 bool Cfg::hasComputedFrame() const { return getTarget()->hasComputedFrame(); }
 
 namespace {
 constexpr char BlockNameGlobalPrefix[] = ".L$profiler$block_name$";
 constexpr char BlockStatsGlobalPrefix[] = ".L$profiler$block_info$";
 
 VariableDeclaration *nodeNameDeclaration(GlobalContext *Ctx,
                                          const IceString &NodeAsmName) {
-  VariableDeclaration *Var = VariableDeclaration::create(Ctx);
+  auto *Var = VariableDeclaration::create(Ctx);
   Var->setName(BlockNameGlobalPrefix + NodeAsmName);
   Var->setIsConstant(true);
   Var->addInitializer(VariableDeclaration::DataInitializer::create(
       NodeAsmName.data(), NodeAsmName.size() + 1));
   const SizeT Int64ByteSize = typeWidthInBytes(IceType_i64);
   Var->setAlignment(Int64ByteSize); // Wasteful, 32-bit could use 4 bytes.
   return Var;
 }
 
 VariableDeclaration *
 blockProfilingInfoDeclaration(GlobalContext *Ctx, const IceString &NodeAsmName,
                               VariableDeclaration *NodeNameDeclaration) {
-  VariableDeclaration *Var = VariableDeclaration::create(Ctx);
+  auto *Var = VariableDeclaration::create(Ctx);
   Var->setName(BlockStatsGlobalPrefix + NodeAsmName);
   const SizeT Int64ByteSize = typeWidthInBytes(IceType_i64);
   Var->addInitializer(
       VariableDeclaration::ZeroInitializer::create(Int64ByteSize));
 
   const RelocOffsetT NodeNameDeclarationOffset = 0;
   Var->addInitializer(VariableDeclaration::RelocInitializer::create(
       NodeNameDeclaration, NodeNameDeclarationOffset));
   Var->setAlignment(Int64ByteSize);
   return Var;
@@ skipping 388 matching lines @@
         InstAlloca::create(this, BaseVariable, AllocaSize, CombinedAlignment);
     CombinedAlloca->setKnownFrameOffset();
     Insts.push_front(CombinedAlloca);
   } break;
   case BVT_StackPointer:
   case BVT_FramePointer: {
     for (SizeT i = 0; i < Allocas.size(); ++i) {
       auto *Alloca = llvm::cast<InstAlloca>(Allocas[i]);
       // Emit a fake definition of the rematerializable variable.
       Variable *Dest = Alloca->getDest();
-      InstFakeDef *Def = InstFakeDef::create(this, Dest);
+      auto *Def = InstFakeDef::create(this, Dest);
       if (BaseVariableType == BVT_StackPointer)
         Dest->setRematerializable(getTarget()->getStackReg(), Offsets[i]);
       else
         Dest->setRematerializable(getTarget()->getFrameReg(), Offsets[i]);
       Insts.push_front(Def);
       Alloca->setDeleted();
     }
     // Allocate the fixed area in the function prolog.
     getTarget()->reserveFixedAllocaArea(TotalSize, CombinedAlignment);
   } break;
@@ skipping 556 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice