Fix handling of TYPE_CODE_NUMENTRY record when size large.

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 "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"
 
 #include "IceAPInt.h"
 #include "IceAPFloat.h"
 #include "IceCfg.h"
@@ skipping 148 matching lines @@
   void setBlockParser(BlockParserBaseClass *NewBlockParser) {
     BlockParser = NewBlockParser;
   }
 
   /// Generates error with given Message, occurring at BitPosition
   /// within the bitcode file. Always returns true.
   bool ErrorAt(naclbitc::ErrorLevel Level, uint64_t BitPosition,
                const std::string &Message) final;
 
   /// Generates error message with respect to the current block parser.
-  bool BlockError(const std::string &Message);
+  bool blockError(const std::string &Message);
 
   /// Returns the number of errors found while parsing the bitcode
   /// file.
   unsigned getNumErrors() const { return NumErrors; }
 
   /// Changes the size of the type list to the given size.
-  void resizeTypeIDValues(unsigned NewSize) { TypeIDValues.resize(NewSize); }
+  void resizeTypeIDValues(size_t NewSize) { TypeIDValues.resize(NewSize); }
+
+  size_t getNumTypeIDValues() const { return TypeIDValues.size(); }
 
   /// Returns true if generation of Subzero IR is disabled.
   bool isIRGenerationDisabled() const {
     return Translator.getFlags().getDisableIRGeneration();
   }
 
   /// Returns the undefined type associated with type ID.
   /// Note: Returns extended type ready to be defined.
-  ExtendedType *getTypeByIDForDefining(unsigned ID) {
+  ExtendedType *getTypeByIDForDefining(NaClBcIndexSize_t ID) {
     // Get corresponding element, verifying the value is still undefined
     // (and hence allowed to be defined).
     ExtendedType *Ty = getTypeByIDAsKind(ID, ExtendedType::Undefined);
     if (Ty)
       return Ty;
-    if (ID >= TypeIDValues.size())
+    if (ID >= TypeIDValues.size()) {
+      if (ID >= NaClBcIndexSize_t_Max) {
+        std::string Buffer;
+        raw_string_ostream StrBuf(Buffer);
+        StrBuf << "Can't define more than " << NaClBcIndexSize_t_Max
+               << " types\n";
+        blockError(StrBuf.str());
+        // Recover by using existing type slot.
+        return &TypeIDValues[0];
+      }
       TypeIDValues.resize(ID + 1);
+    }
     return &TypeIDValues[ID];
   }
 
   /// Returns the type associated with the given index.
-  Ice::Type getSimpleTypeByID(unsigned ID) {
+  Ice::Type getSimpleTypeByID(NaClBcIndexSize_t ID) {
     const ExtendedType *Ty = getTypeByIDAsKind(ID, ExtendedType::Simple);
     if (Ty == nullptr)
       // Return error recovery value.
       return Ice::IceType_void;
     return cast<SimpleExtendedType>(Ty)->getType();
   }
 
   /// Returns the type signature associated with the given index.
-  const Ice::FuncSigType &getFuncSigTypeByID(unsigned ID) {
+  const Ice::FuncSigType &getFuncSigTypeByID(NaClBcIndexSize_t ID) {
     const ExtendedType *Ty = getTypeByIDAsKind(ID, ExtendedType::FuncSig);
     if (Ty == nullptr)
       // Return error recovery value.
       return UndefinedFuncSigType;
     return cast<FuncSigExtendedType>(Ty)->getSignature();
   }
 
   /// Sets the next function ID to the given LLVM function.
   void setNextFunctionID(Ice::FunctionDeclaration *Fcn) {
     FunctionDeclarationList.push_back(Fcn);
   }
 
   /// Returns the value id that should be associated with the the
   /// current function block. Increments internal counters during call
   /// so that it will be in correct position for next function block.
-  size_t getNextFunctionBlockValueID() {
+  NaClBcIndexSize_t getNextFunctionBlockValueID() {
     size_t NumDeclaredFunctions = FunctionDeclarationList.size();
     while (NextDefiningFunctionID < NumDeclaredFunctions &&
            FunctionDeclarationList[NextDefiningFunctionID]->isProto())
       ++NextDefiningFunctionID;
     if (NextDefiningFunctionID >= NumDeclaredFunctions)
       Fatal("More function blocks than defined function addresses");
     return NextDefiningFunctionID++;
   }
 
   /// Returns the function associated with ID.
-  Ice::FunctionDeclaration *getFunctionByID(unsigned ID) {
+  Ice::FunctionDeclaration *getFunctionByID(NaClBcIndexSize_t ID) {
     if (ID < FunctionDeclarationList.size())
       return FunctionDeclarationList[ID];
     return reportGetFunctionByIDError(ID);
   }
 
   /// Returns the constant associated with the given global value ID.
-  Ice::Constant *getGlobalConstantByID(unsigned ID) {
+  Ice::Constant *getGlobalConstantByID(NaClBcIndexSize_t ID) {
     assert(ID < ValueIDConstants.size());
     return ValueIDConstants[ID];
   }
 
   /// Install names for all global values without names. Called after
   /// the global value symbol table is processed, but before any
   /// function blocks are processed.
   void installGlobalNames() {
     assert(VariableDeclarations);
     installGlobalVarNames();
     installFunctionNames();
   }
 
   void createValueIDs() {
     assert(VariableDeclarations);
     ValueIDConstants.reserve(VariableDeclarations->size() +
                              FunctionDeclarationList.size());
     createValueIDsForFunctions();
     createValueIDsForGlobalVars();
   }
 
   /// Returns the number of function declarations in the bitcode file.
-  unsigned getNumFunctionIDs() const { return FunctionDeclarationList.size(); }
+  size_t getNumFunctionIDs() const { return FunctionDeclarationList.size(); }
 
   /// Returns the number of global declarations (i.e. IDs) defined in
   /// the bitcode file.
-  unsigned getNumGlobalIDs() const {
+  size_t getNumGlobalIDs() const {
     if (VariableDeclarations) {
       return FunctionDeclarationList.size() + VariableDeclarations->size();
     } else {
       return ValueIDConstants.size();
     }
   }
 
   /// Creates Count global variable declarations.
-  void CreateGlobalVariables(size_t Count) {
+  void createGlobalVariables(NaClBcIndexSize_t Count) {
     assert(VariableDeclarations);
     assert(VariableDeclarations->empty());
     for (size_t i = 0; i < Count; ++i) {
       VariableDeclarations->push_back(
           Ice::VariableDeclaration::create(getTranslator().getContext()));
     }
   }
 
   /// Returns the number of global variable declarations in the
   /// bitcode file.
-  Ice::SizeT getNumGlobalVariables() const {
+  size_t getNumGlobalVariables() const {
     if (VariableDeclarations) {
       return VariableDeclarations->size();
     } else {
       return ValueIDConstants.size() - FunctionDeclarationList.size();
     }
   }
 
   /// Returns the global variable declaration with the given index.
-  Ice::VariableDeclaration *getGlobalVariableByID(unsigned Index) {
+  Ice::VariableDeclaration *getGlobalVariableByID(NaClBcIndexSize_t Index) {
     assert(VariableDeclarations);
     if (Index < VariableDeclarations->size())
       return VariableDeclarations->at(Index);
     return reportGetGlobalVariableByIDError(Index);
   }
 
   /// Returns the global declaration (variable or function) with the
   /// given Index.
-  Ice::GlobalDeclaration *getGlobalDeclarationByID(size_t Index) {
+  Ice::GlobalDeclaration *getGlobalDeclarationByID(NaClBcIndexSize_t Index) {
     size_t NumFunctionIds = FunctionDeclarationList.size();
     if (Index < NumFunctionIds)
       return getFunctionByID(Index);
     else
       return getGlobalVariableByID(Index - NumFunctionIds);
   }
 
   /// Returns the list of parsed global variable
   /// declarations. Releases ownership of the current list of global
   /// variables. Note: only returns non-null pointer on first
@@ skipping 33 matching lines @@
   // The block parser currently being applied. Used for error
   // reporting.
   BlockParserBaseClass *BlockParser = nullptr;
 
   bool ParseBlock(unsigned BlockID) override;
 
   // Gets extended type associated with the given index, assuming the
   // extended type is of the WantedKind. Generates error message if
   // corresponding extended type of WantedKind can't be found, and
   // returns nullptr.
-  ExtendedType *getTypeByIDAsKind(unsigned ID,
+  ExtendedType *getTypeByIDAsKind(NaClBcIndexSize_t ID,
                                   ExtendedType::TypeKind WantedKind) {
     ExtendedType *Ty = nullptr;
     if (ID < TypeIDValues.size()) {
       Ty = &TypeIDValues[ID];
       if (Ty->getKind() == WantedKind)
         return Ty;
     }
     // Generate an error message and set ErrorStatus.
     this->reportBadTypeIDAs(ID, Ty, WantedKind);
     return nullptr;
   }
 
   // Gives Decl a name if it doesn't already have one. Prefix and
   // NameIndex are used to generate the name. NameIndex is
   // automatically incremented if a new name is created.  DeclType is
   // literal text describing the type of name being created. Also
   // generates warning if created names may conflict with named
   // declarations.
   void installDeclarationName(Ice::GlobalDeclaration *Decl,
                               const Ice::IceString &Prefix,
-                              const char *DeclType, uint32_t &NameIndex) {
+                              const char *DeclType,
+                              NaClBcIndexSize_t &NameIndex) {
     if (Decl->hasName()) {
       Translator.checkIfUnnamedNameSafe(Decl->getName(), DeclType, Prefix);
     } else {
       Decl->setName(Translator.createUnnamedName(Prefix, NameIndex));
       ++NameIndex;
     }
   }
 
   // Installs names for global variables without names.
   void installGlobalVarNames() {
     assert(VariableDeclarations);
     const Ice::IceString &GlobalPrefix =
         getTranslator().getFlags().getDefaultGlobalPrefix();
     if (!GlobalPrefix.empty()) {
-      uint32_t NameIndex = 0;
+      NaClBcIndexSize_t NameIndex = 0;
       for (Ice::VariableDeclaration *Var : *VariableDeclarations) {
         installDeclarationName(Var, GlobalPrefix, "global", NameIndex);
       }
     }
   }
 
   // Installs names for functions without names.
   void installFunctionNames() {
     const Ice::IceString &FunctionPrefix =
         getTranslator().getFlags().getDefaultFunctionPrefix();
     if (!FunctionPrefix.empty()) {
-      uint32_t NameIndex = 0;
+      NaClBcIndexSize_t NameIndex = 0;
       for (Ice::FunctionDeclaration *Func : FunctionDeclarationList) {
         installDeclarationName(Func, FunctionPrefix, "function", NameIndex);
       }
     }
   }
 
   // Builds a constant symbol named Name, suppressing name mangling if
   // SuppressMangling.  IsExternal is true iff the symbol is external.
   Ice::Constant *getConstantSym(const Ice::IceString &Name,
                                 bool SuppressMangling, bool IsExternal) const {
@@ skipping 24 matching lines @@
       Ice::Constant *C = nullptr;
       if (!isIRGenerationDisabled()) {
         C = getConstantSym(Decl->getName(), Decl->getSuppressMangling(),
                            !Decl->hasInitializer());
       }
       ValueIDConstants.push_back(C);
     }
   }
 
   // Reports that type ID is undefined, or not of the WantedType.
-  void reportBadTypeIDAs(unsigned ID, const ExtendedType *Ty,
+  void reportBadTypeIDAs(NaClBcIndexSize_t ID, const ExtendedType *Ty,
                          ExtendedType::TypeKind WantedType);
 
   // Reports that there is no function declaration for ID. Returns an
   // error recovery value to use.
-  Ice::FunctionDeclaration *reportGetFunctionByIDError(unsigned ID);
+  Ice::FunctionDeclaration *reportGetFunctionByIDError(NaClBcIndexSize_t ID);
 
   // Reports that there is not global variable declaration for
   // ID. Returns an error recovery value to use.
-  Ice::VariableDeclaration *reportGetGlobalVariableByIDError(unsigned Index);
+  Ice::VariableDeclaration *
+  reportGetGlobalVariableByIDError(NaClBcIndexSize_t Index);
 
   // Reports that there is no corresponding ICE type for LLVMTy, and
-  // returns ICE::IceType_void.
+  // returns Ice::IceType_void.
   Ice::Type convertToIceTypeError(Type *LLVMTy);
 };
 
 bool TopLevelParser::ErrorAt(naclbitc::ErrorLevel Level, uint64_t Bit,
                              const std::string &Message) {
   ErrorStatus.assign(Ice::EC_Bitcode);
   ++NumErrors;
   Ice::GlobalContext *Context = Translator.getContext();
   { // Lock while printing out error message.
     Ice::OstreamLocker L(Context);
     raw_ostream &OldErrStream = setErrStream(Context->getStrError());
     NaClBitcodeParser::ErrorAt(Level, Bit, Message);
     setErrStream(OldErrStream);
   }
   if (Level >= naclbitc::Error &&
       !Translator.getFlags().getAllowErrorRecovery())
     Fatal();
   return true;
 }
 
-void TopLevelParser::reportBadTypeIDAs(unsigned ID, const ExtendedType *Ty,
+void TopLevelParser::reportBadTypeIDAs(NaClBcIndexSize_t ID,
+                                       const ExtendedType *Ty,
                                        ExtendedType::TypeKind WantedType) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   if (Ty == nullptr) {
     StrBuf << "Can't find extended type for type id: " << ID;
   } else {
     StrBuf << "Type id " << ID << " not " << WantedType << ". Found: " << *Ty;
   }
-  BlockError(StrBuf.str());
+  blockError(StrBuf.str());
 }
 
 Ice::FunctionDeclaration *
-TopLevelParser::reportGetFunctionByIDError(unsigned ID) {
+TopLevelParser::reportGetFunctionByIDError(NaClBcIndexSize_t ID) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Function index " << ID
          << " not allowed. Out of range. Must be less than "
          << FunctionDeclarationList.size();
-  BlockError(StrBuf.str());
+  blockError(StrBuf.str());
   // TODO(kschimpf) Remove error recovery once implementation complete.
   if (!FunctionDeclarationList.empty())
     return FunctionDeclarationList[0];
   Fatal();
 }
 
 Ice::VariableDeclaration *
-TopLevelParser::reportGetGlobalVariableByIDError(unsigned Index) {
+TopLevelParser::reportGetGlobalVariableByIDError(NaClBcIndexSize_t Index) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Global index " << Index
          << " not allowed. Out of range. Must be less than "
          << VariableDeclarations->size();
-  BlockError(StrBuf.str());
+  blockError(StrBuf.str());
   // TODO(kschimpf) Remove error recovery once implementation complete.
   if (!VariableDeclarations->empty())
     return VariableDeclarations->at(0);
   Fatal();
 }
 
 Ice::Type TopLevelParser::convertToIceTypeError(Type *LLVMTy) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Invalid LLVM type: " << *LLVMTy;
@@ skipping 50 matching lines @@
   // Default implementation. Reports that block is unknown and skips
   // its contents.
   bool ParseBlock(unsigned BlockID) override;
 
   // Default implementation. Reports that the record is not
   // understood.
   void ProcessRecord() override;
 
   // Checks if the size of the record is Size.  Return true if valid.
   // Otherwise generates an error and returns false.
-  bool isValidRecordSize(unsigned Size, const char *RecordName) {
+  bool isValidRecordSize(size_t Size, const char *RecordName) {
     const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
     if (Values.size() == Size)
       return true;
-    ReportRecordSizeError(Size, RecordName, nullptr);
+    reportRecordSizeError(Size, RecordName, nullptr);
     return false;
   }
 
   // Checks if the size of the record is at least as large as the
   // LowerLimit. Returns true if valid.  Otherwise generates an error
   // and returns false.
-  bool isValidRecordSizeAtLeast(unsigned LowerLimit, const char *RecordName) {
+  bool isValidRecordSizeAtLeast(size_t LowerLimit, const char *RecordName) {
     const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
     if (Values.size() >= LowerLimit)
       return true;
-    ReportRecordSizeError(LowerLimit, RecordName, "at least");
+    reportRecordSizeError(LowerLimit, RecordName, "at least");
     return false;
   }
 
   // Checks if the size of the record is no larger than the
   // UpperLimit.  Returns true if valid.  Otherwise generates an error
   // and returns false.
-  bool isValidRecordSizeAtMost(unsigned UpperLimit, const char *RecordName) {
+  bool isValidRecordSizeAtMost(size_t UpperLimit, const char *RecordName) {
     const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
     if (Values.size() <= UpperLimit)
       return true;
-    ReportRecordSizeError(UpperLimit, RecordName, "no more than");
+    reportRecordSizeError(UpperLimit, RecordName, "no more than");
     return false;
   }
 
   // Checks if the size of the record is at least as large as the
   // LowerLimit, and no larger than the UpperLimit.  Returns true if
   // valid.  Otherwise generates an error and returns false.
-  bool isValidRecordSizeInRange(unsigned LowerLimit, unsigned UpperLimit,
+  bool isValidRecordSizeInRange(size_t LowerLimit, size_t UpperLimit,
                                 const char *RecordName) {
     return isValidRecordSizeAtLeast(LowerLimit, RecordName) ||
            isValidRecordSizeAtMost(UpperLimit, RecordName);
   }
 
 private:
   /// Generates a record size error. ExpectedSize is the number
   /// of elements expected. RecordName is the name of the kind of
   /// record that has incorrect size. ContextMessage (if not nullptr)
   /// is appended to "record expects" to describe how ExpectedSize
   /// should be interpreted.
-  void ReportRecordSizeError(unsigned ExpectedSize, const char *RecordName,
+  void reportRecordSizeError(size_t ExpectedSize, const char *RecordName,
                              const char *ContextMessage);
 };
 
-bool TopLevelParser::BlockError(const std::string &Message) {
+bool TopLevelParser::blockError(const std::string &Message) {
   if (BlockParser)
     return BlockParser->Error(Message);
   else
     return Error(Message);
 }
 
 // Generates an error Message with the bit address prefixed to it.
 bool BlockParserBaseClass::ErrorAt(naclbitc::ErrorLevel Level, uint64_t Bit,
                                    const std::string &Message) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   // Note: If dump routines have been turned off, the error messages
   // will not be readable. Hence, replace with simple error. We also
   // use the simple form for unit tests.
   if (getFlags().getGenerateUnitTestMessages()) {
     StrBuf << "Invalid " << getBlockName() << " record: <" << Record.GetCode();
     for (const uint64_t Val : Record.GetValues()) {
       StrBuf << " " << Val;
     }
     StrBuf << ">";
   } else {
     StrBuf << Message;
   }
   return Context->ErrorAt(Level, Bit, StrBuf.str());
 }
 
-void BlockParserBaseClass::ReportRecordSizeError(unsigned ExpectedSize,
+void BlockParserBaseClass::reportRecordSizeError(size_t ExpectedSize,
                                                  const char *RecordName,
                                                  const char *ContextMessage) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   const char *BlockName = getBlockName();
   const char FirstChar = toupper(*BlockName);
   StrBuf << FirstChar << (BlockName + 1) << " " << RecordName
          << " record expects";
   if (ContextMessage)
     StrBuf << " " << ContextMessage;
@@ skipping 29 matching lines @@
 class TypesParser : public BlockParserBaseClass {
   TypesParser() = delete;
   TypesParser(const TypesParser &) = delete;
   TypesParser &operator=(const TypesParser &) = delete;
 
 public:
   TypesParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Timer(Ice::TimerStack::TT_parseTypes, getTranslator().getContext()) {}
 
-  ~TypesParser() override = default;
+  ~TypesParser() override {
+    if (ExpectedNumTypes != Context->getNumTypeIDValues()) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Types block expected " << ExpectedNumTypes
+             << " types but found: " << NextTypeId;
+      Error(StrBuf.str());
+    }
+  }
 
 private:
   Ice::TimerMarker Timer;
   // The type ID that will be associated with the next type defining
   // record in the types block.
-  unsigned NextTypeId = 0;
+  NaClBcIndexSize_t NextTypeId = 0;
+
+  // The expected number of types, based on record TYPE_CODE_NUMENTRY.
+  NaClBcIndexSize_t ExpectedNumTypes = 0;
 
   void ProcessRecord() override;
 
   const char *getBlockName() const override { return "type"; }
 
   void setNextTypeIDAsSimpleType(Ice::Type Ty) {
     Context->getTypeByIDForDefining(NextTypeId++)->setAsSimpleType(Ty);
   }
 };
 
 void TypesParser::ProcessRecord() {
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   switch (Record.GetCode()) {
-  case naclbitc::TYPE_CODE_NUMENTRY:
+  case naclbitc::TYPE_CODE_NUMENTRY: {
     // NUMENTRY: [numentries]
     if (!isValidRecordSize(1, "count"))
       return;
-    Context->resizeTypeIDValues(Values[0]);
+    uint64_t Size = Values[0];
+    if (Size > NaClBcIndexSize_t_Max) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Size to big for count record: " << Size;
+      Error(StrBuf.str());
+      ExpectedNumTypes = NaClBcIndexSize_t_Max;
+    }
+    // The code double checks that Expected size and the actual size
+    // at the end of the block. To reduce allocations we preallocate
+    // the space.
+    //
+    // However, if the number is large, we suspect that the number
+    // is (possibly) incorrect. In that case, we preallocate a
+    // smaller space.
+    constexpr uint64_t DefaultLargeResizeValue = 1000000;
+    Context->resizeTypeIDValues(std::min(Size, DefaultLargeResizeValue));
+    ExpectedNumTypes = Size;
     return;
+  }
   case naclbitc::TYPE_CODE_VOID:
     // VOID
     if (!isValidRecordSize(0, "void"))
       return;
     setNextTypeIDAsSimpleType(Ice::IceType_void);
     return;
   case naclbitc::TYPE_CODE_FLOAT:
     // FLOAT
     if (!isValidRecordSize(0, "float"))
       return;
@@ skipping 96 matching lines @@
   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);
     FuncTy->setReturnType(Context->getSimpleTypeByID(Values[1]));
-    for (unsigned i = 2, e = Values.size(); i != e; ++i) {
+    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)
                << " not valid. Found: " << ArgTy;
         // TODO(kschimpf) Remove error recovery once implementation complete.
@@ skipping 26 matching lines @@
         CurGlobalVar(DummyGlobalVar) {}
 
   ~GlobalsParser() final = default;
 
   const char *getBlockName() const override { return "globals"; }
 
 private:
   Ice::TimerMarker Timer;
   // Keeps track of how many initializers are expected for the global variable
   // declaration being built.
-  unsigned InitializersNeeded = 0;
+  NaClBcIndexSize_t InitializersNeeded = 0;
 
   // The index of the next global variable declaration.
-  unsigned NextGlobalID = 0;
+  NaClBcIndexSize_t NextGlobalID = 0;
 
   // Dummy global variable declaration to guarantee CurGlobalVar is
   // always defined (allowing code to not need to check if
   // CurGlobalVar is nullptr).
   Ice::VariableDeclaration *DummyGlobalVar;
 
   // Holds the current global variable declaration being built.
   Ice::VariableDeclaration *CurGlobalVar;
 
   void ExitBlock() override {
@@ skipping 35 matching lines @@
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   switch (Record.GetCode()) {
   case naclbitc::GLOBALVAR_COUNT:
     // COUNT: [n]
     if (!isValidRecordSize(1, "count"))
       return;
     if (NextGlobalID != Context->getNumGlobalVariables()) {
       Error("Globals count record not first in block.");
       return;
     }
-    Context->CreateGlobalVariables(Values[0]);
+    Context->createGlobalVariables(Values[0]);
     return;
   case naclbitc::GLOBALVAR_VAR: {
     // VAR: [align, isconst]
     if (!isValidRecordSize(2, "variable"))
       return;
     verifyNoMissingInitializers();
     if (!isIRGenerationDisabled()) {
       InitializersNeeded = 1;
       CurGlobalVar = Context->getGlobalVariableByID(NextGlobalID);
       CurGlobalVar->setAlignment((1 << Values[0]) >> 1);
@@ skipping 42 matching lines @@
         Ice::VariableDeclaration::DataInitializer::create(Values));
     return;
   }
   case naclbitc::GLOBALVAR_RELOC: {
     // RELOC: [val, [addend]]
     if (!isValidRecordSizeInRange(1, 2, "reloc"))
       return;
     if (isIRGenerationDisabled())
       return;
     unsigned Index = Values[0];
-    Ice::SizeT Offset = 0;
-    if (Values.size() == 2)
+    uint64_t Offset = 0;
+    if (Values.size() == 2) {
       Offset = Values[1];
+      if (Offset > std::numeric_limits<uint32_t>::max()) {
+        std::string Buffer;
+        raw_string_ostream StrBuf(Buffer);
+        StrBuf << "Addend of global reloc record too big: " << Offset;
+        Error(StrBuf.str());
+      }
+    }
     CurGlobalVar->addInitializer(
         Ice::VariableDeclaration::RelocInitializer::create(
             Context->getGlobalDeclarationByID(Index), Offset));
     return;
   }
   default:
     BlockParserBaseClass::ProcessRecord();
     return;
   }
 }
 
 /// Base class for parsing a valuesymtab block in the bitcode file.
 class ValuesymtabParser : public BlockParserBaseClass {
   ValuesymtabParser() = delete;
   ValuesymtabParser(const ValuesymtabParser &) = delete;
   void operator=(const ValuesymtabParser &) = delete;
 
 public:
   ValuesymtabParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser) {}
 
   ~ValuesymtabParser() override = default;
 
   const char *getBlockName() const override { return "valuesymtab"; }
 
 protected:
   typedef SmallString<128> StringType;
 
   // Associates Name with the value defined by the given Index.
-  virtual void setValueName(uint64_t Index, StringType &Name) = 0;
+  virtual void setValueName(NaClBcIndexSize_t Index, StringType &Name) = 0;
 
   // Associates Name with the value defined by the given Index;
-  virtual void setBbName(uint64_t Index, StringType &Name) = 0;
+  virtual void setBbName(NaClBcIndexSize_t Index, StringType &Name) = 0;
 
 private:
   void ProcessRecord() override;
 
-  void ConvertToString(StringType &ConvertedName) {
+  void convertToString(StringType &ConvertedName) {
     const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
     for (size_t i = 1, e = Values.size(); i != e; ++i) {
       ConvertedName += static_cast<char>(Values[i]);
     }
   }
 };
 
 void ValuesymtabParser::ProcessRecord() {
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   StringType ConvertedName;
   switch (Record.GetCode()) {
   case naclbitc::VST_CODE_ENTRY: {
     // VST_ENTRY: [ValueId, namechar x N]
     if (!isValidRecordSizeAtLeast(2, "value entry"))
       return;
-    ConvertToString(ConvertedName);
+    convertToString(ConvertedName);
     setValueName(Values[0], ConvertedName);
     return;
   }
   case naclbitc::VST_CODE_BBENTRY: {
     // VST_BBENTRY: [BbId, namechar x N]
     if (!isValidRecordSizeAtLeast(2, "basic block entry"))
       return;
-    ConvertToString(ConvertedName);
+    convertToString(ConvertedName);
     setBbName(Values[0], ConvertedName);
     return;
   }
   default:
     break;
   }
   // If reached, don't know how to handle record.
   BlockParserBaseClass::ProcessRecord();
   return;
 }
@@ skipping 34 matching lines @@
     if (isIRGenerationDisabled()) {
       CurrentNode = nullptr;
       for (Ice::Type ArgType : Signature.getArgList()) {
         (void)ArgType;
         setNextLocalInstIndex(nullptr);
       }
     } else {
       Func->setFunctionName(FuncDecl->getName());
       Func->setReturnType(Signature.getReturnType());
       Func->setInternal(FuncDecl->getLinkage() == GlobalValue::InternalLinkage);
-      CurrentNode = InstallNextBasicBlock();
+      CurrentNode = installNextBasicBlock();
       Func->setEntryNode(CurrentNode);
       for (Ice::Type ArgType : Signature.getArgList()) {
         Func->addArg(getNextInstVar(ArgType));
       }
     }
     bool ParserResult = ParseThisBlock();
 
     // Temporarily end per-function timing, which will be resumed by
     // the translator function.  This is because translation may be
     // done asynchronously in a separate thread.
@@ skipping 14 matching lines @@
 
     return ParserResult;
   }
 
   ~FunctionParser() final = default;
 
   const char *getBlockName() const override { return "function"; }
 
   Ice::Cfg *getFunc() const { return Func.get(); }
 
-  uint32_t getNumGlobalIDs() const { return CachedNumGlobalValueIDs; }
+  size_t getNumGlobalIDs() const { return CachedNumGlobalValueIDs; }
 
   void setNextLocalInstIndex(Ice::Operand *Op) {
     setOperand(NextLocalInstIndex++, Op);
   }
 
   // Set the next constant ID to the given constant C.
   void setNextConstantID(Ice::Constant *C) { setNextLocalInstIndex(C); }
 
   // Returns the value referenced by the given value Index.
-  Ice::Operand *getOperand(uint32_t Index) {
+  Ice::Operand *getOperand(NaClBcIndexSize_t Index) {
     if (Index < CachedNumGlobalValueIDs) {
       return Context->getGlobalConstantByID(Index);
     }
-    uint32_t LocalIndex = Index - CachedNumGlobalValueIDs;
+    NaClBcIndexSize_t LocalIndex = Index - CachedNumGlobalValueIDs;
     if (LocalIndex >= LocalOperands.size()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Value index " << Index << " not defined!";
       Fatal(StrBuf.str());
     }
     Ice::Operand *Op = LocalOperands[LocalIndex];
     if (Op == nullptr) {
       if (isIRGenerationDisabled())
         return nullptr;
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Value index " << Index << " not defined!";
       Fatal(StrBuf.str());
     }
     return Op;
   }
 
 private:
   Ice::TimerMarker Timer;
   // The corresponding ICE function defined by the function block.
   std::unique_ptr<Ice::Cfg> Func;
   // The index to the current basic block being built.
-  uint32_t CurrentBbIndex = 0;
+  NaClBcIndexSize_t CurrentBbIndex = 0;
   // The basic block being built.
   Ice::CfgNode *CurrentNode = nullptr;
   // The ID for the function.
-  unsigned FcnId;
+  NaClBcIndexSize_t FcnId;
   // The corresponding function declaration.
   Ice::FunctionDeclaration *FuncDecl;
   // Holds the dividing point between local and global absolute value indices.
-  uint32_t CachedNumGlobalValueIDs;
+  size_t CachedNumGlobalValueIDs;
   // Holds operands local to the function block, based on indices
   // defined in the bitcode file.
   std::vector<Ice::Operand *> LocalOperands;
   // Holds the index within LocalOperands corresponding to the next
   // instruction that generates a value.
-  uint32_t NextLocalInstIndex;
+  NaClBcIndexSize_t NextLocalInstIndex;
   // True if the last processed instruction was a terminating
   // instruction.
   bool InstIsTerminating = false;
   // Upper limit of alignment power allowed by LLVM
   static const uint32_t AlignPowerLimit = 29;
 
   // Extracts the corresponding Alignment to use, given the AlignPower
   // (i.e. 2**(AlignPower-1), or 0 if AlignPower == 0). InstName is the
   // name of the instruction the alignment appears in.
   void extractAlignment(const char *InstName, uint32_t AlignPower,
@@ skipping 11 matching lines @@
     Alignment = 1;
   }
 
   bool ParseBlock(unsigned BlockID) override;
 
   void ProcessRecord() override;
 
   void ExitBlock() override;
 
   // Creates and appends a new basic block to the list of basic blocks.
-  Ice::CfgNode *InstallNextBasicBlock() {
+  Ice::CfgNode *installNextBasicBlock() {
     assert(!isIRGenerationDisabled());
     return Func->makeNode();
   }
 
   // Returns the Index-th basic block in the list of basic blocks.
-  Ice::CfgNode *getBasicBlock(uint32_t Index) {
+  Ice::CfgNode *getBasicBlock(NaClBcIndexSize_t Index) {
     assert(!isIRGenerationDisabled());
     const Ice::NodeList &Nodes = Func->getNodes();
     if (Index >= Nodes.size()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Reference to basic block " << Index
              << " not found. Must be less than " << Nodes.size();
       Error(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
       Index = 0;
     }
     return Nodes[Index];
   }
 
   // Returns the Index-th basic block in the list of basic blocks.
   // Assumes Index corresponds to a branch instruction. Hence, if
   // the branch references the entry block, it also generates a
   // corresponding error.
-  Ice::CfgNode *getBranchBasicBlock(uint32_t Index) {
+  Ice::CfgNode *getBranchBasicBlock(NaClBcIndexSize_t Index) {
     assert(!isIRGenerationDisabled());
     if (Index == 0) {
       Error("Branch to entry block not allowed");
       // TODO(kschimpf) Remove error recovery once implementation complete.
     }
     return getBasicBlock(Index);
   }
 
   // Generate an instruction variable with type Ty.
   Ice::Variable *createInstVar(Ice::Type Ty) {
     assert(!isIRGenerationDisabled());
     if (Ty == Ice::IceType_void) {
       Error("Can't define instruction value using type void");
       // Recover since we can't throw an exception.
       Ty = Ice::IceType_i32;
     }
     return Func->makeVariable(Ty);
   }
 
   // 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.
-    uint32_t LocalIndex = NextLocalInstIndex - CachedNumGlobalValueIDs;
+    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 (Var->getType() == Ty) {
             ++NextLocalInstIndex;
             return Var;
           }
         }
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Illegal forward referenced instruction ("
                << NextLocalInstIndex << "): " << *Op;
         Error(StrBuf.str());
         // TODO(kschimpf) Remove error recovery once implementation complete.
         ++NextLocalInstIndex;
         return createInstVar(Ty);
       }
     }
     Ice::Variable *Var = createInstVar(Ty);
     setOperand(NextLocalInstIndex++, Var);
     return Var;
   }
 
   // Converts a relative index (wrt to BaseIndex) to an absolute value
   // index.
-  uint32_t convertRelativeToAbsIndex(int32_t Id, int32_t BaseIndex) {
+  NaClBcIndexSize_t convertRelativeToAbsIndex(NaClRelBcIndexSize_t Id,
+                                              NaClRelBcIndexSize_t BaseIndex) {
     if (BaseIndex < Id) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Invalid relative value id: " << Id
              << " (must be <= " << BaseIndex << ")";
       Error(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
       return 0;
     }
     return BaseIndex - Id;
   }
 
   // Sets element Index (in the local operands list) to Op.
-  void setOperand(uint32_t Index, Ice::Operand *Op) {
+  void setOperand(NaClBcIndexSize_t Index, Ice::Operand *Op) {
     assert(Op || isIRGenerationDisabled());
     // Check if simple push works.
-    uint32_t LocalIndex = Index - CachedNumGlobalValueIDs;
+    NaClBcIndexSize_t LocalIndex = Index - CachedNumGlobalValueIDs;
     if (LocalIndex == LocalOperands.size()) {
       LocalOperands.push_back(Op);
       return;
     }
 
     // Must be forward reference, expand vector to accommodate.
     if (LocalIndex >= LocalOperands.size())
       LocalOperands.resize(LocalIndex + 1);
 
     // If element not defined, set it.
@@ skipping 12 matching lines @@
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Multiple definitions for index " << Index << ": " << *Op
            << " and " << *OldOp;
     Error(StrBuf.str());
     // TODO(kschimpf) Remove error recovery once implementation complete.
     LocalOperands[LocalIndex] = Op;
   }
 
   // Returns the relative operand (wrt to BaseIndex) referenced by
   // the given value Index.
-  Ice::Operand *getRelativeOperand(int32_t Index, int32_t BaseIndex) {
+  Ice::Operand *getRelativeOperand(NaClBcIndexSize_t Index,
+                                   NaClBcIndexSize_t BaseIndex) {
     return getOperand(convertRelativeToAbsIndex(Index, BaseIndex));
   }
 
   // Returns the absolute index of the next value generating instruction.
-  uint32_t getNextInstIndex() const { return NextLocalInstIndex; }
+  NaClBcIndexSize_t getNextInstIndex() const { return NextLocalInstIndex; }
 
   // Generates type error message for binary operator Op
   // operating on Type OpTy.
-  void ReportInvalidBinaryOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy);
+  void reportInvalidBinaryOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy);
 
   // Validates if integer logical Op, for type OpTy, is valid.
   // Returns true if valid. Otherwise generates error message and
   // returns false.
   bool isValidIntegerLogicalOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy) {
     if (Ice::isIntegerType(OpTy))
       return true;
-    ReportInvalidBinaryOp(Op, OpTy);
+    reportInvalidBinaryOp(Op, OpTy);
     return false;
   }
 
   // Validates if integer (or vector of integers) arithmetic Op, for type
   // OpTy, is valid.  Returns true if valid. Otherwise generates
   // error message and returns false.
   bool isValidIntegerArithOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy) {
     if (Ice::isIntegerArithmeticType(OpTy))
       return true;
-    ReportInvalidBinaryOp(Op, OpTy);
+    reportInvalidBinaryOp(Op, OpTy);
     return false;
   }
 
   // Checks if floating arithmetic Op, for type OpTy, is valid.
   // Returns true if valid. Otherwise generates an error message and
   // returns false;
   bool isValidFloatingArithOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy) {
     if (Ice::isFloatingType(OpTy))
       return true;
-    ReportInvalidBinaryOp(Op, OpTy);
+    reportInvalidBinaryOp(Op, OpTy);
     return false;
   }
 
   // Checks if the type of operand Op is the valid pointer type, for
   // the given InstructionName. Returns true if valid. Otherwise
   // generates an error message and returns false.
   bool isValidPointerType(Ice::Operand *Op, const char *InstructionName) {
     Ice::Type PtrType = Ice::getPointerType();
     if (Op->getType() == PtrType)
       return true;
@@ skipping 446 matching lines @@
     CurrentNode->appendInst(Ice::InstAssign::create(Func.get(), Var, Var));
   }
 };
 
 void FunctionParser::ExitBlock() {
   if (isIRGenerationDisabled()) {
     return;
   }
   // Before translating, check for blocks without instructions, and
   // insert unreachable. This shouldn't happen, but be safe.
-  unsigned Index = 0;
+  size_t Index = 0;
   for (Ice::CfgNode *Node : Func->getNodes()) {
     if (Node->getInsts().empty()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Basic block " << Index << " contains no instructions";
       Error(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
       Node->appendInst(Ice::InstUnreachable::create(Func.get()));
     }
     ++Index;
   }
   Func->computeInOutEdges();
 }
 
-void FunctionParser::ReportInvalidBinaryOp(Ice::InstArithmetic::OpKind Op,
+void FunctionParser::reportInvalidBinaryOp(Ice::InstArithmetic::OpKind Op,
                                            Ice::Type OpTy) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Invalid operator type for " << Ice::InstArithmetic::getOpName(Op)
          << ". Found " << OpTy;
   Error(StrBuf.str());
 }
 
 void FunctionParser::ProcessRecord() {
   // Note: To better separate parse/IR generation times, when IR generation
   // is disabled we do the following:
   // 1) Delay exiting until after we extract operands.
   // 2) return before we access operands, since all operands will be a nullptr.
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   if (InstIsTerminating) {
     InstIsTerminating = false;
     if (!isIRGenerationDisabled())
       CurrentNode = getBasicBlock(++CurrentBbIndex);
   }
   // The base index for relative indexing.
-  int32_t BaseIndex = getNextInstIndex();
+  NaClBcIndexSize_t BaseIndex = getNextInstIndex();
   switch (Record.GetCode()) {
   case naclbitc::FUNC_CODE_DECLAREBLOCKS: {
     // DECLAREBLOCKS: [n]
     if (!isValidRecordSize(1, "count"))
       return;
-    uint32_t NumBbs = Values[0];
-    if (NumBbs == 0) {
+    uint64_t NumBbsRaw = Values[0];
+    if (NumBbsRaw == 0) {
       Error("Functions must contain at least one basic block.");
       // TODO(kschimpf) Remove error recovery once implementation complete.
-      NumBbs = 1;
+      NumBbsRaw = 1;
+    } else if (NumBbsRaw > NaClBcIndexSize_t_Max) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "To many basic blocks specified: " << NumBbsRaw;
+      Error(StrBuf.str());
+      NumBbsRaw = NaClBcIndexSize_t_Max;
     }
     if (isIRGenerationDisabled())
       return;
     if (Func->getNodes().size() != 1) {
       Error("Duplicate function block count record");
       return;
     }
     // Install the basic blocks, skipping bb0 which was created in the
     // constructor.
-    for (size_t i = 1; i < NumBbs; ++i)
-      InstallNextBasicBlock();
+    for (size_t i = 1, NumBbs = NumBbsRaw; i < NumBbs; ++i)
+      installNextBasicBlock();
     return;
   }
   case naclbitc::FUNC_CODE_INST_BINOP: {
     // BINOP: [opval, opval, opcode]
     if (!isValidRecordSize(3, "binop"))
       return;
     Ice::Operand *Op1 = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Op2 = getRelativeOperand(Values[1], BaseIndex);
     if (isIRGenerationDisabled()) {
       assert(Op1 == nullptr && Op2 == nullptr);
@@ skipping 295 matching lines @@
     } else if (CondTy != Cond->getType()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Case condition expects type " << CondTy
              << ". Found: " << Cond->getType();
       Error(StrBuf.str());
       return;
     }
     Ice::CfgNode *DefaultLabel =
         isIRGenDisabled ? nullptr : getBranchBasicBlock(Values[2]);
-    unsigned NumCases = Values[3];
+    uint64_t NumCasesRaw = Values[3];
+    if (NumCasesRaw > std::numeric_limits<uint32_t>::max()) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Too many cases specified in switch: " << NumCasesRaw;
+      Error(StrBuf.str());
+      NumCasesRaw = std::numeric_limits<uint32_t>::max();
+    }
+    uint32_t NumCases = NumCasesRaw;
 
     // Now recognize each of the cases.
     if (!isValidRecordSize(4 + NumCases * 4, "switch"))
       return;
     Ice::InstSwitch *Switch =
         isIRGenDisabled
             ? nullptr
             : Ice::InstSwitch::create(Func.get(), NumCases, Cond, DefaultLabel);
     unsigned ValCaseIndex = 4; // index to beginning of case entry.
-    for (unsigned CaseIndex = 0; CaseIndex < NumCases;
+    for (uint32_t CaseIndex = 0; CaseIndex < NumCases;
          ++CaseIndex, ValCaseIndex += 4) {
       if (Values[ValCaseIndex] != 1 || Values[ValCaseIndex + 1] != 1) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Sequence [1, 1, value, label] expected for case entry "
                << "in switch record. (at index" << ValCaseIndex << ")";
         Error(StrBuf.str());
         return;
       }
       Ice::APInt Value(BitWidth,
@@ skipping 42 matching lines @@
       for (unsigned i = 1; i < Values.size(); i += 2) {
         assert(getRelativeOperand(NaClDecodeSignRotatedValue(Values[i]),
                                   BaseIndex) == nullptr);
       }
       setNextLocalInstIndex(nullptr);
       return;
     }
     Ice::Variable *Dest = getNextInstVar(Ty);
     Ice::InstPhi *Phi =
         Ice::InstPhi::create(Func.get(), Values.size() >> 1, Dest);
-    for (unsigned i = 1; i < Values.size(); i += 2) {
+    for (size_t i = 1; i < Values.size(); i += 2) {
       Ice::Operand *Op =
           getRelativeOperand(NaClDecodeSignRotatedValue(Values[i]), BaseIndex);
       if (Op->getType() != Ty) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Value " << *Op << " not type " << Ty
                << " in phi instruction. Found: " << Op->getType();
         Error(StrBuf.str());
         appendErrorInstruction(Ty);
         return;
@@ skipping 367 matching lines @@
         Timer(Ice::TimerStack::TT_parseFunctionValuesymtabs,
               getTranslator().getContext()) {}
 
 private:
   Ice::TimerMarker Timer;
   // Returns the enclosing function parser.
   FunctionParser *getFunctionParser() const {
     return reinterpret_cast<FunctionParser *>(GetEnclosingParser());
   }
 
-  void setValueName(uint64_t Index, StringType &Name) override;
-  void setBbName(uint64_t Index, StringType &Name) override;
+  void setValueName(NaClBcIndexSize_t Index, StringType &Name) override;
+  void setBbName(NaClBcIndexSize_t Index, StringType &Name) override;
 
   // Reports that the assignment of Name to the value associated with
   // index is not possible, for the given Context.
-  void reportUnableToAssign(const char *Context, uint64_t Index,
+  void reportUnableToAssign(const char *Context, NaClBcIndexSize_t Index,
                             StringType &Name) {
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Function-local " << Context << " name '" << Name
            << "' can't be associated with index " << Index;
     Error(StrBuf.str());
   }
 };
 
-void FunctionValuesymtabParser::setValueName(uint64_t Index, StringType &Name) {
+void FunctionValuesymtabParser::setValueName(NaClBcIndexSize_t Index,
+                                             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("instruction", Index, Name);
     // TODO(kschimpf) Remove error recovery once implementation complete.
     return;
   }
   if (isIRGenerationDisabled())
     return;
   Ice::Operand *Op = getFunctionParser()->getOperand(Index);
   if (Ice::Variable *V = dyn_cast<Ice::Variable>(Op)) {
     if (ALLOW_DUMP) {
       std::string Nm(Name.data(), Name.size());
       V->setName(getFunctionParser()->getFunc(), Nm);
     }
   } else {
     reportUnableToAssign("variable", Index, Name);
   }
 }
 
-void FunctionValuesymtabParser::setBbName(uint64_t Index, StringType &Name) {
+void FunctionValuesymtabParser::setBbName(NaClBcIndexSize_t Index,
+                                          StringType &Name) {
   if (isIRGenerationDisabled())
     return;
   if (Index >= getFunctionParser()->getFunc()->getNumNodes()) {
     reportUnableToAssign("block", Index, Name);
     return;
   }
   std::string Nm(Name.data(), Name.size());
   if (ALLOW_DUMP)
     getFunctionParser()->getFunc()->getNodes()[Index]->setName(Nm);
 }
@@ skipping 36 matching lines @@
 private:
   Ice::TimerMarker Timer;
   // True if we have already installed names for unnamed global declarations,
   // and have generated global constant initializers.
   bool GlobalDeclarationNamesAndInitializersInstalled = false;
 
   // Generates names for unnamed global addresses (i.e. functions and
   // global variables). Then lowers global variable declaration
   // initializers to the target. May be called multiple times. Only
   // the first call will do the installation.
-  void InstallGlobalNamesAndGlobalVarInitializers() {
+  void installGlobalNamesAndGlobalVarInitializers() {
     if (!GlobalDeclarationNamesAndInitializersInstalled) {
       Context->installGlobalNames();
       Context->createValueIDs();
       getTranslator().lowerGlobals(Context->getGlobalVariables());
       GlobalDeclarationNamesAndInitializersInstalled = true;
     }
   }
   bool ParseBlock(unsigned BlockID) override;
 
-  void ExitBlock() override { InstallGlobalNamesAndGlobalVarInitializers(); }
+  void ExitBlock() override { installGlobalNamesAndGlobalVarInitializers(); }
 
   void ProcessRecord() override;
 };
 
 class ModuleValuesymtabParser : public ValuesymtabParser {
   ModuleValuesymtabParser() = delete;
   ModuleValuesymtabParser(const ModuleValuesymtabParser &) = delete;
   void operator=(const ModuleValuesymtabParser &) = delete;
 
 public:
   ModuleValuesymtabParser(unsigned BlockID, ModuleParser *MP)
       : ValuesymtabParser(BlockID, MP),
         Timer(Ice::TimerStack::TT_parseModuleValuesymtabs,
               getTranslator().getContext()) {}
 
   ~ModuleValuesymtabParser() override = default;
 
 private:
   Ice::TimerMarker Timer;
-  void setValueName(uint64_t Index, StringType &Name) override;
-  void setBbName(uint64_t Index, StringType &Name) override;
+  void setValueName(NaClBcIndexSize_t Index, StringType &Name) override;
+  void setBbName(NaClBcIndexSize_t Index, StringType &Name) override;
 };
 
-void ModuleValuesymtabParser::setValueName(uint64_t Index, StringType &Name) {
+void ModuleValuesymtabParser::setValueName(NaClBcIndexSize_t Index,
+                                           StringType &Name) {
   Context->getGlobalDeclarationByID(Index)
       ->setName(StringRef(Name.data(), Name.size()));
 }
 
-void ModuleValuesymtabParser::setBbName(uint64_t Index, StringType &Name) {
+void ModuleValuesymtabParser::setBbName(NaClBcIndexSize_t Index,
+                                        StringType &Name) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Can't define basic block name at global level: '" << Name
          << "' -> " << Index;
   Error(StrBuf.str());
 }
 
 bool ModuleParser::ParseBlock(unsigned BlockID) {
   switch (BlockID) {
   case naclbitc::BLOCKINFO_BLOCK_ID:
     return NaClBitcodeParser::ParseBlock(BlockID);
   case naclbitc::TYPE_BLOCK_ID_NEW: {
     TypesParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
   case naclbitc::GLOBALVAR_BLOCK_ID: {
     GlobalsParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
   case naclbitc::VALUE_SYMTAB_BLOCK_ID: {
     ModuleValuesymtabParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
   case naclbitc::FUNCTION_BLOCK_ID: {
-    InstallGlobalNamesAndGlobalVarInitializers();
+    installGlobalNamesAndGlobalVarInitializers();
     FunctionParser Parser(BlockID, this);
     return Parser.convertFunction();
   }
   default:
     return BlockParserBaseClass::ParseBlock(BlockID);
   }
 }
 
 void ModuleParser::ProcessRecord() {
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   switch (Record.GetCode()) {
   case naclbitc::MODULE_CODE_VERSION: {
     // VERSION: [version#]
     if (!isValidRecordSize(1, "version"))
       return;
-    unsigned Version = Values[0];
+    uint64_t Version = Values[0];
     if (Version != 1) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Unknown bitstream version: " << Version;
       Error(StrBuf.str());
     }
     return;
   }
   case naclbitc::MODULE_CODE_FUNCTION: {
     // FUNCTION:  [type, callingconv, isproto, linkage]
@@ skipping 95 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