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

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 966 matching lines @@
     return;
   }
   case naclbitc::TYPE_CODE_FUNCTION: {
     // FUNCTION: [vararg, retty, paramty x N]
     if (!isValidRecordSizeAtLeast(2, "signature"))
       return;
     if (Values[0])
       Error("Function type can't define varargs");
     ExtendedType *Ty = Context->getTypeByIDForDefining(NextTypeId++);
     Ty->setAsFunctionType();
-    FuncSigExtendedType *FuncTy = cast<FuncSigExtendedType>(Ty);
+    auto *FuncTy = cast<FuncSigExtendedType>(Ty);
     FuncTy->setReturnType(Context->getSimpleTypeByID(Values[1]));
     for (size_t i = 2, e = Values.size(); i != e; ++i) {
       // Check that type void not used as argument type. Note: PNaCl
       // restrictions can't be checked until we know the name, because we have
       // to check for intrinsic signatures.
       Ice::Type ArgTy = Context->getSimpleTypeByID(Values[i]);
       if (ArgTy == Ice::IceType_void) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Type for parameter " << (i - 1)
@@ skipping 525 matching lines @@
 
   // Generates the next available local variable using the given type.
   Ice::Variable *getNextInstVar(Ice::Type Ty) {
     assert(!isIRGenerationDisabled());
     assert(NextLocalInstIndex >= CachedNumGlobalValueIDs);
     // Before creating one, see if a forwardtyperef has already defined it.
     NaClBcIndexSize_t LocalIndex = NextLocalInstIndex - CachedNumGlobalValueIDs;
     if (LocalIndex < LocalOperands.size()) {
       Ice::Operand *Op = LocalOperands[LocalIndex];
       if (Op != nullptr) {
-        if (Ice::Variable *Var = dyn_cast<Ice::Variable>(Op)) {
+        if (auto *Var = dyn_cast<Ice::Variable>(Op)) {
           if (Var->getType() == Ty) {
             ++NextLocalInstIndex;
             return Var;
           }
         }
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Illegal forward referenced instruction ("
                << NextLocalInstIndex << "): " << *Op;
         Error(StrBuf.str());
@@ skipping 1519 matching lines @@
                                              StringType &Name) {
   // Note: We check when Index is too small, so that we can error recover
   // (FP->getOperand will create fatal error).
   if (Index < getFunctionParser()->getNumGlobalIDs()) {
     reportUnableToAssign("Global value", Index, Name);
     return;
   }
   if (isIRGenerationDisabled())
     return;
   Ice::Operand *Op = getFunctionParser()->getOperand(Index);
-  if (Ice::Variable *V = dyn_cast<Ice::Variable>(Op)) {
+  if (auto *V = dyn_cast<Ice::Variable>(Op)) {
     if (Ice::BuildDefs::dump()) {
       std::string Nm(Name.data(), Name.size());
       V->setName(getFunctionParser()->getFunc(), Nm);
     }
   } else {
     reportUnableToAssign("Local value", Index, Name);
   }
 }
 
 void FunctionValuesymtabParser::setBbName(NaClBcIndexSize_t Index,
@@ skipping 175 matching lines @@
     }
     GlobalValue::LinkageTypes Linkage;
     if (!naclbitc::DecodeLinkage(Values[3], Linkage)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Function address has unknown linkage. Found " << Values[3];
       Error(StrBuf.str());
       return;
     }
     bool IsProto = Values[2] == 1;
-    Ice::FunctionDeclaration *Func = Ice::FunctionDeclaration::create(
+    auto *Func = Ice::FunctionDeclaration::create(
         Context->getTranslator().getContext(), Signature, CallingConv, Linkage,
         IsProto);
     Context->setNextFunctionID(Func);
     return;
   }
   default:
     BlockParserBaseClass::ProcessRecord();
     return;
   }
 }
@@ skipping 61 matching lines @@
     raw_string_ostream StrBuf(Buffer);
     StrBuf << IRFilename << ": Does not contain a module!";
     llvm::report_fatal_error(StrBuf.str());
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice