Create local config file for subzero reader tests.

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
@@ skipping 140 matching lines @@
     break;
   }
   case FuncSig: {
     Stream << " " << Signature;
   }
   default:
     break;
   }
 }
 
+class BlockParserBaseClass;
+
 // Top-level class to read PNaCl bitcode files, and translate to ICE.
 class TopLevelParser : public NaClBitcodeParser {
   TopLevelParser(const TopLevelParser &) = delete;
   TopLevelParser &operator=(const TopLevelParser &) = delete;
+  friend class BlockParserBaseClass;

[Jim Stichnoth, 2014/11/19 19:21:00]

Can we avoid resorting to friend declarations this early in the design?  (Same
argument I made against mutable.)  I'd rather add public getter/setter methods
as needed.

(I realize none of this matters much when none of these classes are declared in
headers, but still.)

(I also see that there are some other friend declarations in the code base that
managed to evade my notice, so they're now on my list...)

[Karl, 2014/11/20 17:32:09]

No longer friendly.

 
 public:
   typedef std::vector<Ice::FunctionDeclaration *> FunctionDeclarationListType;
 
   TopLevelParser(Ice::Translator &Translator, const std::string &InputName,
                  NaClBitcodeHeader &Header, NaClBitstreamCursor &Cursor,
                  bool &ErrorStatus)
       : NaClBitcodeParser(Cursor), Translator(Translator),
         Mod(new Module(InputName, getGlobalContext())), DL(PNaClDataLayout),
         Header(Header), TypeConverter(Mod->getContext()),
         ErrorStatus(ErrorStatus), NumErrors(0), NumFunctionIds(0),
-        NumFunctionBlocks(0) {
+        NumFunctionBlocks(0), BlockParser(nullptr) {
     Mod->setDataLayout(PNaClDataLayout);
     setErrStream(Translator.getContext()->getStrDump());
   }
 
   ~TopLevelParser() override {}
 
   Ice::Translator &getTranslator() { return Translator; }
 
   // Generates error with given Message. Always returns true.
-  bool Error(const std::string &Message) override {
-    ErrorStatus = true;
-    ++NumErrors;
-    NaClBitcodeParser::Error(Message);
-    if (!AllowErrorRecovery)
-      report_fatal_error("Unable to continue");
-    return true;
-  }
+  bool Error(const std::string &Message) override;
+
+  // Generates error message with respect to the current block parser.
+  bool BlockError(const std::string &Message);
 
   /// Returns the number of errors found while parsing the bitcode
   /// file.
   unsigned getNumErrors() const { return NumErrors; }
 
   /// Returns the LLVM module associated with the translation.
   Module *getModule() const { return Mod.get(); }
 
   const DataLayout &getDataLayout() const { return DL; }
 
@@ skipping 108 matching lines @@
     }
     std::string Name;
     bool SuppressMangling;
     if (Decl) {
       Name = Decl->getName();
       SuppressMangling = Decl->getSuppressMangling();
     } else {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Reference to global not defined: " << ID;
-      Error(StrBuf.str());
+      BlockError(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
       Name = "??";
       SuppressMangling = false;
     }
     const Ice::RelocOffsetT Offset = 0;
     C = getTranslator().getContext()->getConstantSym(
         getIcePointerType(), Offset, Name, SuppressMangling);
     ValueIDConstants[ID] = C;
     return C;
   }
@@ skipping 89 matching lines @@
   unsigned NumFunctionIds;
   // The number of function blocks (processed so far).
   unsigned NumFunctionBlocks;
   // The list of function declaration IDs (in the order found) that
   // aren't just proto declarations.
   // TODO(kschimpf): Instead of using this list, just use
   // FunctionDeclarationList, and the isProto member function.
   std::vector<unsigned> DefiningFunctionDeclarationsList;
   // Error recovery value to use when getFuncSigTypeByID fails.
   Ice::FuncSigType UndefinedFuncSigType;
+  // The block parser currently being applied. Used for error
+  // reporting.
+  BlockParserBaseClass *BlockParser;
 
   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::TypeKind WantedKind) {
     ExtendedType *Ty = nullptr;
@@ skipping 17 matching lines @@
 
   // Reports that there is not global variable declaration for
   // ID. Returns an error recovery value to use.
   Ice::VariableDeclaration *reportGetGlobalVariableByIDError(unsigned Index);
 
   // Reports that there is no corresponding ICE type for LLVMTy, and
   // returns ICE::IceType_void.
   Ice::Type convertToIceTypeError(Type *LLVMTy);
 };
 
+bool TopLevelParser::Error(const std::string &Message) {
+  ErrorStatus = true;
+  ++NumErrors;
+  NaClBitcodeParser::Error(Message);
+  if (!AllowErrorRecovery)
+    report_fatal_error("Unable to continue");
+  return true;
+}
+
 void TopLevelParser::reportBadTypeIDAs(unsigned 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;
   }
-  Error(StrBuf.str());
+  BlockError(StrBuf.str());
 }
 
 Ice::FunctionDeclaration *
 TopLevelParser::reportGetFunctionByIDError(unsigned ID) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Function index " << ID
          << " not allowed. Out of range. Must be less than "
          << FunctionDeclarationList.size();
-  Error(StrBuf.str());
+  BlockError(StrBuf.str());
   // TODO(kschimpf) Remove error recovery once implementation complete.
   if (!FunctionDeclarationList.empty())
     return FunctionDeclarationList[0];
   report_fatal_error("Unable to continue");
 }
 
 Ice::VariableDeclaration *
 TopLevelParser::reportGetGlobalVariableByIDError(unsigned Index) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Global index " << Index
          << " not allowed. Out of range. Must be less than "
          << VariableDeclarations.size();
-  Error(StrBuf.str());
+  BlockError(StrBuf.str());
   // TODO(kschimpf) Remove error recovery once implementation complete.
   if (!VariableDeclarations.empty())
     return VariableDeclarations[0];
   report_fatal_error("Unable to continue");
 }
 
 Ice::Type TopLevelParser::convertToIceTypeError(Type *LLVMTy) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Invalid LLVM type: " << *LLVMTy;
   Error(StrBuf.str());
   return Ice::IceType_void;
 }
 
 // Base class for parsing blocks within the bitcode file.  Note:
 // Because this is the base class of block parsers, we generate error
 // messages if ParseBlock or ParseRecord is not overridden in derived
 // classes.
 class BlockParserBaseClass : public NaClBitcodeParser {
+  BlockParserBaseClass(const BlockParserBaseClass &) = delete;
+  BlockParserBaseClass &operator=(const BlockParserBaseClass &) = delete;
+  friend class TopLevelParser;
+
 public:
   // Constructor for the top-level module block parser.
   BlockParserBaseClass(unsigned BlockID, TopLevelParser *Context)
-      : NaClBitcodeParser(BlockID, Context), Context(Context) {}
+      : NaClBitcodeParser(BlockID, Context), Context(Context) {
+    Context->BlockParser = this;
+  }
 
-  ~BlockParserBaseClass() override {}
+  ~BlockParserBaseClass() override { Context->BlockParser = nullptr; }
+
+  // Returns the printable name of the type of block being parsed.
+  virtual const char *getBlockName() const {
+    // If this class is used, it is parsing an unknown block.
+    return "unknown";
+  }
 
 protected:
   // The context parser that contains the decoded state.
   TopLevelParser *Context;
 
   // Constructor for nested block parsers.
   BlockParserBaseClass(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : NaClBitcodeParser(BlockID, EnclosingParser),
         Context(EnclosingParser->Context) {}
 
   // Gets the translator associated with the bitcode parser.
   Ice::Translator &getTranslator() const { return Context->getTranslator(); }
 
   const Ice::ClFlags &getFlags() const { return getTranslator().getFlags(); }
 
   bool isIRGenerationDisabled() const {
     return ALLOW_DISABLE_IR_GEN ? getTranslator().getFlags().DisableIRGeneration
                                 : false;
   }
 
   // Generates an error Message with the bit address prefixed to it.
-  bool Error(const std::string &Message) override {
-    uint64_t Bit = Record.GetStartBit() + Context->getHeaderSize() * 8;
-    std::string Buffer;
-    raw_string_ostream StrBuf(Buffer);
-    StrBuf << "(" << format("%" PRIu64 ":%u", (Bit / 8),
-                            static_cast<unsigned>(Bit % 8)) << ") ";
-    // Note: If dump routines have been turned off, the error messages
-    // will not be readable. Hence, replace with simple error.
-    if (ALLOW_DUMP)
-      StrBuf << Message;
-    else
-      StrBuf << "Invalid input record";
-    return Context->Error(StrBuf.str());
-  }
+  bool Error(const std::string &Message) override;
 
   // 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.
@@ skipping 40 matching lines @@
 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,
                              const char *ContextMessage);
 };
 
+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::Error(const std::string &Message) {
+  uint64_t Bit = Record.GetStartBit() + Context->getHeaderSize() * 8;
+  std::string Buffer;
+  raw_string_ostream StrBuf(Buffer);
+  StrBuf << "(" << format("%" PRIu64 ":%u", (Bit / 8),
+                          static_cast<unsigned>(Bit % 8)) << ") ";
+  // Note: If dump routines have been turned off, the error messages
+  // will not be readable. Hence, replace with simple error.
+  if (ALLOW_DUMP)
+    StrBuf << Message;
+  else {
+    StrBuf << "Invalid " << getBlockName() << " record: <" << Record.GetCode();
+    for (const auto Val : Record.GetValues()) {

[Jim Stichnoth, 2014/11/19 23:30:36]

Probably better not to use auto here, since one has to do some work to track
down the the actual type.

+      StrBuf << " " << Val;
+    }
+    StrBuf << ">";
+  }
+  return Context->Error(StrBuf.str());
+}
+
 void BlockParserBaseClass::ReportRecordSizeError(unsigned ExpectedSize,
                                                  const char *RecordName,
                                                  const char *ContextMessage) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
-  StrBuf << RecordName << " record expects";
+  const char *BlockName = getBlockName();
+  const char FirstChar = toupper(*BlockName);
+  StrBuf << FirstChar << (BlockName + 1) << " " << RecordName
+         << " record expects";
   if (ContextMessage)
     StrBuf << " " << ContextMessage;
   StrBuf << " " << ExpectedSize << " argument";
   if (ExpectedSize > 1)
     StrBuf << "s";
   StrBuf << ". Found: " << Record.GetValues().size();
   Error(StrBuf.str());
 }
 
 bool BlockParserBaseClass::ParseBlock(unsigned BlockID) {
   // If called, derived class doesn't know how to handle block.
   // Report error and skip.
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Don't know how to parse block id: " << BlockID;
   Error(StrBuf.str());
   // TODO(kschimpf) Remove error recovery once implementation complete.
   SkipBlock();
   return false;
 }
 
 void BlockParserBaseClass::ProcessRecord() {
   // If called, derived class doesn't know how to handle.
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
-  StrBuf << "Don't know how to process record: " << Record;
+  StrBuf << "Don't know how to process " << getBlockName()
+         << " record:" << Record;
   Error(StrBuf.str());
 }
 
 // Class to parse a types block.
 class TypesParser : public BlockParserBaseClass {
 public:
   TypesParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Timer(Ice::TimerStack::TT_parseTypes, getTranslator().getContext()),
         NextTypeId(0) {}
 
   ~TypesParser() override {}
 
 private:
   Ice::TimerMarker Timer;
   // The type ID that will be associated with the next type defining
   // record in the types block.
   unsigned NextTypeId;
 
   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:
     // NUMENTRY: [numentries]
-    if (!isValidRecordSize(1, "Type count"))
+    if (!isValidRecordSize(1, "count"))
       return;
     Context->resizeTypeIDValues(Values[0]);
     return;
   case naclbitc::TYPE_CODE_VOID:
     // VOID
-    if (!isValidRecordSize(0, "Type void"))
+    if (!isValidRecordSize(0, "void"))
       return;
     setNextTypeIDAsSimpleType(Ice::IceType_void);
     return;
   case naclbitc::TYPE_CODE_FLOAT:
     // FLOAT
-    if (!isValidRecordSize(0, "Type float"))
+    if (!isValidRecordSize(0, "float"))
       return;
     setNextTypeIDAsSimpleType(Ice::IceType_f32);
     return;
   case naclbitc::TYPE_CODE_DOUBLE:
     // DOUBLE
-    if (!isValidRecordSize(0, "Type double"))
+    if (!isValidRecordSize(0, "double"))
       return;
     setNextTypeIDAsSimpleType(Ice::IceType_f64);
     return;
   case naclbitc::TYPE_CODE_INTEGER:
     // INTEGER: [width]
-    if (!isValidRecordSize(1, "Type integer"))
+    if (!isValidRecordSize(1, "integer"))
       return;
     switch (Values[0]) {
     case 1:
       setNextTypeIDAsSimpleType(Ice::IceType_i1);
       return;
     case 8:
       setNextTypeIDAsSimpleType(Ice::IceType_i8);
       return;
     case 16:
       setNextTypeIDAsSimpleType(Ice::IceType_i16);
       return;
     case 32:
       setNextTypeIDAsSimpleType(Ice::IceType_i32);
       return;
     case 64:
       setNextTypeIDAsSimpleType(Ice::IceType_i64);
       return;
     default:
       break;
     }
     {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Type integer record with invalid bitsize: " << Values[0];
       Error(StrBuf.str());
     }
     return;
   case naclbitc::TYPE_CODE_VECTOR: {
     // VECTOR: [numelts, eltty]
-    if (!isValidRecordSize(2, "Type vector"))
+    if (!isValidRecordSize(2, "vector"))
       return;
     Ice::Type BaseTy = Context->getSimpleTypeByID(Values[1]);
     Ice::SizeT Size = Values[0];
     switch (BaseTy) {
     case Ice::IceType_i1:
       switch (Size) {
       case 4:
         setNextTypeIDAsSimpleType(Ice::IceType_v4i1);
         return;
       case 8:
@@ skipping 37 matching lines @@
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Invalid type vector record: <" << Values[0] << " x " << BaseTy
              << ">";
       Error(StrBuf.str());
     }
     return;
   }
   case naclbitc::TYPE_CODE_FUNCTION: {
     // FUNCTION: [vararg, retty, paramty x N]
-    if (!isValidRecordSizeAtLeast(2, "Type signature"))
+    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) {
       // Check that type void not used as argument type.
       // Note: PNaCl restrictions can't be checked until we
@@ skipping 25 matching lines @@
   GlobalsParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Timer(Ice::TimerStack::TT_parseGlobals, getTranslator().getContext()),
         InitializersNeeded(0), NextGlobalID(0),
         DummyGlobalVar(
             Ice::VariableDeclaration::create(getTranslator().getContext())),
         CurGlobalVar(DummyGlobalVar) {}
 
   ~GlobalsParser() final {}
 
+  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;
 
   // The index of the next global variable declaration.
   unsigned NextGlobalID;
 
   // 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 {
     verifyNoMissingInitializers();
     unsigned NumIDs = Context->getNumGlobalVariables();
     if (NextGlobalID < NumIDs) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Globals block expects " << NumIDs
+      StrBuf << getBlockName() << " block expects " << NumIDs
              << " global variable declarations. Found: " << NextGlobalID;
       Error(StrBuf.str());
     }
     BlockParserBaseClass::ExitBlock();
   }
 
   void ProcessRecord() override;
 
   // Checks if the number of initializers for the CurGlobalVar is the same as
   // the number found in the bitcode file. If different, and error message is
@@ skipping 13 matching lines @@
       InitializersNeeded = NumInits;
     }
   }
 };
 
 void GlobalsParser::ProcessRecord() {
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   switch (Record.GetCode()) {
   case naclbitc::GLOBALVAR_COUNT:
     // COUNT: [n]
-    if (!isValidRecordSize(1, "Globals count"))
+    if (!isValidRecordSize(1, "count"))
       return;
     if (NextGlobalID != Context->getNumGlobalVariables()) {
       Error("Globals count record not first in block.");
       return;
     }
     Context->CreateGlobalVariables(Values[0]);
     return;
   case naclbitc::GLOBALVAR_VAR: {
     // VAR: [align, isconst]
-    if (!isValidRecordSize(2, "Globals variable"))
+    if (!isValidRecordSize(2, "variable"))
       return;
     verifyNoMissingInitializers();
     if (!isIRGenerationDisabled()) {
       InitializersNeeded = 1;
       CurGlobalVar = Context->getGlobalVariableByID(NextGlobalID);
       CurGlobalVar->setAlignment((1 << Values[0]) >> 1);
       CurGlobalVar->setIsConstant(Values[1] != 0);
     }
     ++NextGlobalID;
     return;
   }
   case naclbitc::GLOBALVAR_COMPOUND:
     // COMPOUND: [size]
-    if (!isValidRecordSize(1, "globals compound"))
+    if (!isValidRecordSize(1, "compound"))
       return;
     if (!CurGlobalVar->getInitializers().empty()) {
       Error("Globals compound record not first initializer");
       return;
     }
     if (Values[0] < 2) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Globals compound record size invalid. Found: " << Values[0];
+      StrBuf << getBlockName()
+             << " compound record size invalid. Found: " << Values[0];
       Error(StrBuf.str());
       return;
     }
     if (isIRGenerationDisabled())
       return;
     InitializersNeeded = Values[0];
     return;
   case naclbitc::GLOBALVAR_ZEROFILL: {
     // ZEROFILL: [size]
-    if (!isValidRecordSize(1, "Globals zerofill"))
+    if (!isValidRecordSize(1, "zerofill"))
       return;
     if (isIRGenerationDisabled())
       return;
     CurGlobalVar->addInitializer(
         new Ice::VariableDeclaration::ZeroInitializer(Values[0]));
     return;
   }
   case naclbitc::GLOBALVAR_DATA: {
     // DATA: [b0, b1, ...]
-    if (!isValidRecordSizeAtLeast(1, "Globals data"))
+    if (!isValidRecordSizeAtLeast(1, "data"))
       return;
     if (isIRGenerationDisabled())
       return;
     CurGlobalVar->addInitializer(
         new Ice::VariableDeclaration::DataInitializer(Values));
     return;
   }
   case naclbitc::GLOBALVAR_RELOC: {
     // RELOC: [val, [addend]]
-    if (!isValidRecordSizeInRange(1, 2, "Globals reloc"))
+    if (!isValidRecordSizeInRange(1, 2, "reloc"))
       return;
     if (isIRGenerationDisabled())
       return;
     unsigned Index = Values[0];
     Ice::SizeT Offset = 0;
     if (Values.size() == 2)
       Offset = Values[1];
     CurGlobalVar->addInitializer(new Ice::VariableDeclaration::RelocInitializer(
         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(const ValuesymtabParser &) = delete;
   void operator=(const ValuesymtabParser &) = delete;
 
 public:
   ValuesymtabParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser) {}
 
   ~ValuesymtabParser() override {}
 
+  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;
 
   // Associates Name with the value defined by the given Index;
   virtual void setBbName(uint64_t Index, StringType &Name) = 0;
 
 private:
 
   void ProcessRecord() override;
 
   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, "Valuesymtab value entry"))
+    if (!isValidRecordSizeAtLeast(2, "value entry"))
       return;
     ConvertToString(ConvertedName);
     setValueName(Values[0], ConvertedName);
     return;
   }
   case naclbitc::VST_CODE_BBENTRY: {
     // VST_BBENTRY: [BbId, namechar x N]
-    if (!isValidRecordSizeAtLeast(2, "Valuesymtab basic block entry"))
+    if (!isValidRecordSizeAtLeast(2, "basic block entry"))
       return;
     ConvertToString(ConvertedName);
     setBbName(Values[0], ConvertedName);
     return;
   }
   default:
     break;
   }
   // If reached, don't know how to handle record.
   BlockParserBaseClass::ProcessRecord();
@@ skipping 41 matching lines @@
       CurrentNode = InstallNextBasicBlock();
       Func->setEntryNode(CurrentNode);
       for (Ice::Type ArgType : Signature.getArgList()) {
         Func->addArg(getNextInstVar(ArgType));
       }
     }
   }
 
   ~FunctionParser() final {}
 
+  const char *getBlockName() const override { return "function"; }
+
   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); }
 
 private:
   Ice::TimerMarker Timer;
   // The corresponding ICE function defined by the function block.
@@ skipping 651 matching lines @@
   if (InstIsTerminating) {
     InstIsTerminating = false;
     if (!isIRGenerationDisabled())
       CurrentNode = getBasicBlock(++CurrentBbIndex);
   }
   // The base index for relative indexing.
   int32_t BaseIndex = getNextInstIndex();
   switch (Record.GetCode()) {
   case naclbitc::FUNC_CODE_DECLAREBLOCKS: {
     // DECLAREBLOCKS: [n]
-    if (!isValidRecordSize(1, "function block count"))
+    if (!isValidRecordSize(1, "count"))
       return;
     uint32_t NumBbs = Values[0];
     if (NumBbs == 0) {
       Error("Functions must contain at least one basic block.");
       // TODO(kschimpf) Remove error recovery once implementation complete.
       NumBbs = 1;
     }
     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();
     return;
   }
   case naclbitc::FUNC_CODE_INST_BINOP: {
     // BINOP: [opval, opval, opcode]
-    if (!isValidRecordSize(3, "function block binop"))
+    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);
       setNextLocalInstIndex(nullptr);
       return;
     }
     Ice::Type Type1 = Op1->getType();
     Ice::Type Type2 = Op2->getType();
     if (Type1 != Type2) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Binop argument types differ: " << Type1 << " and " << Type2;
       Error(StrBuf.str());
       appendErrorInstruction(Type1);
       return;
     }
 
     Ice::InstArithmetic::OpKind Opcode;
     if (!convertBinopOpcode(Values[2], Type1, Opcode))
       return;
     CurrentNode->appendInst(Ice::InstArithmetic::create(
         Func, Opcode, getNextInstVar(Type1), Op1, Op2));
     return;
   }
   case naclbitc::FUNC_CODE_INST_CAST: {
     // CAST: [opval, destty, castopc]
-    if (!isValidRecordSize(3, "function block cast"))
+    if (!isValidRecordSize(3, "cast"))
       return;
     Ice::Operand *Src = getRelativeOperand(Values[0], BaseIndex);
     Ice::Type CastType = Context->getSimpleTypeByID(Values[1]);
     Instruction::CastOps LLVMCastOp;
     Ice::InstCast::OpKind CastKind;
     if (!naclbitc::DecodeCastOpcode(Values[2], LLVMCastOp) ||
         !convertLLVMCastOpToIceOp(LLVMCastOp, CastKind)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Cast opcode not understood: " << Values[2];
@@ skipping 16 matching lines @@
       Error(StrBuf.str());
       appendErrorInstruction(CastType);
       return;
     }
     CurrentNode->appendInst(
         Ice::InstCast::create(Func, CastKind, getNextInstVar(CastType), Src));
     return;
   }
   case naclbitc::FUNC_CODE_INST_VSELECT: {
     // VSELECT: [opval, opval, pred]
-    if (!isValidRecordSize(3, "function block select"))
+    if (!isValidRecordSize(3, "select"))
       return;
     Ice::Operand *ThenVal = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *ElseVal = getRelativeOperand(Values[1], BaseIndex);
     Ice::Operand *CondVal = getRelativeOperand(Values[2], BaseIndex);
     if (isIRGenerationDisabled()) {
       assert(ThenVal == nullptr && ElseVal == nullptr && CondVal == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
     Ice::Type ThenType = ThenVal->getType();
@@ skipping 28 matching lines @@
       Error(StrBuf.str());
       appendErrorInstruction(ThenType);
       return;
     }
     CurrentNode->appendInst(Ice::InstSelect::create(
         Func, getNextInstVar(ThenType), CondVal, ThenVal, ElseVal));
     return;
   }
   case naclbitc::FUNC_CODE_INST_EXTRACTELT: {
     // EXTRACTELT: [opval, opval]
-    if (!isValidRecordSize(2, "function block extract element"))
+    if (!isValidRecordSize(2, "extract element"))
       return;
     Ice::Operand *Vec = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Index = getRelativeOperand(Values[1], BaseIndex);
     if (isIRGenerationDisabled()) {
       assert(Vec == nullptr && Index == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
     Ice::Type VecType = Vec->getType();
     VectorIndexCheckValue IndexCheckValue = validateVectorIndex(Vec, Index);
     if (IndexCheckValue != VectorIndexValid) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       dumpVectorIndexCheckValue(StrBuf, IndexCheckValue);
       StrBuf << ": extractelement " << VecType << " " << *Vec << ", "
              << Index->getType() << " " << *Index;
       Error(StrBuf.str());
       appendErrorInstruction(VecType);
       return;
     }
     CurrentNode->appendInst(Ice::InstExtractElement::create(
         Func, getNextInstVar(typeElementType(VecType)), Vec, Index));
     return;
   }
   case naclbitc::FUNC_CODE_INST_INSERTELT: {
     // INSERTELT: [opval, opval, opval]
-    if (!isValidRecordSize(3, "function block insert element"))
+    if (!isValidRecordSize(3, "insert element"))
       return;
     Ice::Operand *Vec = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Elt = getRelativeOperand(Values[1], BaseIndex);
     Ice::Operand *Index = getRelativeOperand(Values[2], BaseIndex);
     if (isIRGenerationDisabled()) {
       assert(Vec == nullptr && Elt == nullptr && Index == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
     Ice::Type VecType = Vec->getType();
     VectorIndexCheckValue IndexCheckValue = validateVectorIndex(Vec, Index);
     if (IndexCheckValue != VectorIndexValid) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       dumpVectorIndexCheckValue(StrBuf, IndexCheckValue);
       StrBuf << ": insertelement " << VecType << " " << *Vec << ", "
              << Elt->getType() << " " << *Elt << ", " << Index->getType() << " "
              << *Index;
       Error(StrBuf.str());
       appendErrorInstruction(Elt->getType());
       return;
     }
     CurrentNode->appendInst(Ice::InstInsertElement::create(
         Func, getNextInstVar(VecType), Vec, Elt, Index));
     return;
   }
   case naclbitc::FUNC_CODE_INST_CMP2: {
     // CMP2: [opval, opval, pred]
-    if (!isValidRecordSize(3, "function block compare"))
+    if (!isValidRecordSize(3, "compare"))
       return;
     Ice::Operand *Op1 = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Op2 = getRelativeOperand(Values[1], BaseIndex);
     if (isIRGenerationDisabled()) {
       assert(Op1 == nullptr && Op2 == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
     Ice::Type Op1Type = Op1->getType();
     Ice::Type Op2Type = Op2->getType();
@@ skipping 45 matching lines @@
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Compare on type not understood: " << Op1Type;
       Error(StrBuf.str());
       appendErrorInstruction(DestType);
       return;
     }
     return;
   }
   case naclbitc::FUNC_CODE_INST_RET: {
     // RET: [opval?]
-    if (!isValidRecordSizeInRange(0, 1, "function block ret"))
+    if (!isValidRecordSizeInRange(0, 1, "return"))
       return;
     if (Values.empty()) {
       if (isIRGenerationDisabled())
         return;
       CurrentNode->appendInst(Ice::InstRet::create(Func));
     } else {
       Ice::Operand *RetVal = getRelativeOperand(Values[0], BaseIndex);
       if (isIRGenerationDisabled()) {
         assert(RetVal == nullptr);
         return;
       }
       CurrentNode->appendInst(Ice::InstRet::create(Func, RetVal));
     }
     InstIsTerminating = true;
     return;
   }
   case naclbitc::FUNC_CODE_INST_BR: {
     if (Values.size() == 1) {
       // BR: [bb#]
       if (isIRGenerationDisabled())
         return;
       Ice::CfgNode *Block = getBranchBasicBlock(Values[0]);
       if (Block == nullptr)
         return;
       CurrentNode->appendInst(Ice::InstBr::create(Func, Block));
     } else {
       // BR: [bb#, bb#, opval]
-      if (!isValidRecordSize(3, "function block branch"))
+      if (!isValidRecordSize(3, "branch"))
         return;
       Ice::Operand *Cond = getRelativeOperand(Values[2], BaseIndex);
       if (isIRGenerationDisabled()) {
         assert(Cond == nullptr);
         return;
       }
       if (Cond->getType() != Ice::IceType_i1) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Branch condition " << *Cond << " not i1. Found: "
@@ skipping 13 matching lines @@
   }
   case naclbitc::FUNC_CODE_INST_SWITCH: {
     // SWITCH: [Condty, Cond, BbIndex, NumCases Case ...]
     // where Case = [1, 1, Value, BbIndex].
     //
     // Note: Unlike most instructions, we don't infer the type of
     // Cond, but provide it as a separate field. There are also
     // unnecesary data fields (i.e. constants 1).  These were not
     // cleaned up in PNaCl bitcode because the bitcode format was
     // already frozen when the problem was noticed.
-    if (!isValidRecordSizeAtLeast(4, "function block switch"))
+    if (!isValidRecordSizeAtLeast(4, "switch"))
       return;
 
     Ice::Type CondTy = Context->getSimpleTypeByID(Values[0]);
     if (!Ice::isScalarIntegerType(CondTy)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Case condition must be non-wide integer. Found: " << CondTy;
       Error(StrBuf.str());
       return;
     }
     Ice::SizeT BitWidth = Ice::getScalarIntBitWidth(CondTy);
     Ice::Operand *Cond = getRelativeOperand(Values[1], BaseIndex);
 
     const bool isIRGenDisabled = isIRGenerationDisabled();
     if (isIRGenDisabled) {
       assert(Cond == nullptr);
     } 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];
 
     // Now recognize each of the cases.
-    if (!isValidRecordSize(4 + NumCases * 4, "Function block switch"))
+    if (!isValidRecordSize(4 + NumCases * 4, "switch"))
       return;
     Ice::InstSwitch *Switch =
         isIRGenDisabled ? nullptr : Ice::InstSwitch::create(Func, NumCases,
                                                             Cond, DefaultLabel);
     unsigned ValCaseIndex = 4;  // index to beginning of case entry.
     for (unsigned CaseIndex = 0; CaseIndex < NumCases;
          ++CaseIndex, ValCaseIndex += 4) {
       if (Values[ValCaseIndex] != 1 || Values[ValCaseIndex+1] != 1) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
@@ skipping 11 matching lines @@
       Switch->addBranch(CaseIndex, Value.getSExtValue(), Label);
     }
     if (isIRGenDisabled)
       return;
     CurrentNode->appendInst(Switch);
     InstIsTerminating = true;
     return;
   }
   case naclbitc::FUNC_CODE_INST_UNREACHABLE: {
     // UNREACHABLE: []
-    if (!isValidRecordSize(0, "function block unreachable"))
+    if (!isValidRecordSize(0, "unreachable"))
       return;
     if (isIRGenerationDisabled())
       return;
     CurrentNode->appendInst(
         Ice::InstUnreachable::create(Func));
     InstIsTerminating = true;
     return;
   }
   case naclbitc::FUNC_CODE_INST_PHI: {
     // PHI: [ty, val1, bb1, ..., valN, bbN] for n >= 2.
-    if (!isValidRecordSizeAtLeast(3, "function block phi"))
+    if (!isValidRecordSizeAtLeast(3, "phi"))
       return;
     Ice::Type Ty = Context->getSimpleTypeByID(Values[0]);
     if ((Values.size() & 0x1) == 0) {
       // Not an odd number of values.
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "function block phi record size not valid: " << Values.size();
       Error(StrBuf.str());
       appendErrorInstruction(Ty);
       return;
@@ skipping 25 matching lines @@
         appendErrorInstruction(Ty);
         return;
       }
       Phi->addArgument(Op, getBasicBlock(Values[i + 1]));
     }
     CurrentNode->appendInst(Phi);
     return;
   }
   case naclbitc::FUNC_CODE_INST_ALLOCA: {
     // ALLOCA: [Size, align]
-    if (!isValidRecordSize(2, "function block alloca"))
+    if (!isValidRecordSize(2, "alloca"))
       return;
     Ice::Operand *ByteCount = getRelativeOperand(Values[0], BaseIndex);
     unsigned Alignment;
     extractAlignment("Alloca", Values[1], Alignment);
     if (isIRGenerationDisabled()) {
       assert(ByteCount == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
     Ice::Type PtrTy = Context->getIcePointerType();
     if (ByteCount->getType() != Ice::IceType_i32) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Alloca on non-i32 value. Found: " << *ByteCount;
       Error(StrBuf.str());
       appendErrorInstruction(PtrTy);
       return;
     }
     CurrentNode->appendInst(Ice::InstAlloca::create(Func, ByteCount, Alignment,
                                                     getNextInstVar(PtrTy)));
     return;
   }
   case naclbitc::FUNC_CODE_INST_LOAD: {
     // LOAD: [address, align, ty]
-    if (!isValidRecordSize(3, "function block load"))
+    if (!isValidRecordSize(3, "load"))
       return;
     Ice::Operand *Address = getRelativeOperand(Values[0], BaseIndex);
     Ice::Type Ty = Context->getSimpleTypeByID(Values[2]);
     unsigned Alignment;
     extractAlignment("Load", Values[1], Alignment);
     if (isIRGenerationDisabled()) {
       assert(Address == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
     if (!isValidPointerType(Address, "Load")) {
       appendErrorInstruction(Ty);
       return;
     }
     if (!isValidLoadStoreAlignment(Alignment, Ty, "Load")) {
       appendErrorInstruction(Ty);
       return;
     }
     CurrentNode->appendInst(
         Ice::InstLoad::create(Func, getNextInstVar(Ty), Address, Alignment));
     return;
   }
   case naclbitc::FUNC_CODE_INST_STORE: {
     // STORE: [address, value, align]
-    if (!isValidRecordSize(3, "function block store"))
+    if (!isValidRecordSize(3, "store"))
       return;
     Ice::Operand *Address = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Value = getRelativeOperand(Values[1], BaseIndex);
     unsigned Alignment;
     extractAlignment("Store", Values[2], Alignment);
     if (isIRGenerationDisabled()) {
       assert(Address == nullptr && Value == nullptr);
       return;
     }
     if (!isValidPointerType(Address, "Store"))
@@ skipping 11 matching lines @@
     //
     // Note: The difference between CALL and CALL_INDIRECT is that
     // CALL has a reference to an explicit function declaration, while
     // the CALL_INDIRECT is just an address. For CALL, we can infer
     // the return type by looking up the type signature associated
     // with the function declaration. For CALL_INDIRECT we can only
     // infer the type signature via argument types, and the
     // corresponding return type stored in CALL_INDIRECT record.
     Ice::SizeT ParamsStartIndex = 2;
     if (Record.GetCode() == naclbitc::FUNC_CODE_INST_CALL) {
-      if (!isValidRecordSizeAtLeast(2, "function block call"))
+      if (!isValidRecordSizeAtLeast(2, "call"))
         return;
     } else {
-      if (!isValidRecordSizeAtLeast(3, "function block call indirect"))
+      if (!isValidRecordSizeAtLeast(3, "call indirect"))
         return;
       ParamsStartIndex = 3;
     }
 
     // Extract out the called function and its return type.
     uint32_t CalleeIndex = convertRelativeToAbsIndex(Values[1], BaseIndex);
     Ice::Operand *Callee = getOperand(CalleeIndex);
     Ice::Type ReturnType = Ice::IceType_void;
     const Ice::Intrinsics::FullIntrinsicInfo *IntrinsicInfo = nullptr;
     if (Record.GetCode() == naclbitc::FUNC_CODE_INST_CALL) {
@@ skipping 108 matching lines @@
         break;
       }
       }
     }
 
     CurrentNode->appendInst(Inst);
     return;
   }
   case naclbitc::FUNC_CODE_INST_FORWARDTYPEREF: {
     // FORWARDTYPEREF: [opval, ty]
-    if (!isValidRecordSize(2, "function block forward type ref"))
+    if (!isValidRecordSize(2, "forward type ref"))
       return;
     Ice::Type OpType = Context->getSimpleTypeByID(Values[1]);
     setOperand(Values[0],
                isIRGenerationDisabled() ? nullptr : createInstVar(OpType));
     return;
   }
   default:
     // Generate error message!
     BlockParserBaseClass::ProcessRecord();
     return;
   }
 }
 
 /// Parses constants within a function block.
 class ConstantsParser : public BlockParserBaseClass {
   ConstantsParser(const ConstantsParser &) = delete;
   ConstantsParser &operator=(const ConstantsParser &) = delete;
 
 public:
   ConstantsParser(unsigned BlockID, FunctionParser *FuncParser)
       : BlockParserBaseClass(BlockID, FuncParser),
         Timer(Ice::TimerStack::TT_parseConstants, getTranslator().getContext()),
         FuncParser(FuncParser), NextConstantType(Ice::IceType_void) {}
 
   ~ConstantsParser() override {}
 
+  const char *getBlockName() const override { return "constants"; }
+
 private:
   Ice::TimerMarker Timer;
   // The parser of the function block this constants block appears in.
   FunctionParser *FuncParser;
   // The type to use for succeeding constants.
   Ice::Type NextConstantType;
 
   void ProcessRecord() override;
 
   Ice::GlobalContext *getContext() { return getTranslator().getContext(); }
@@ skipping 15 matching lines @@
     // SETTYPE: [typeid]
     if (!isValidRecordSize(1, "constants block set type"))
       return;
     NextConstantType = Context->getSimpleTypeByID(Values[0]);
     if (NextConstantType == Ice::IceType_void)
       Error("constants block set type not allowed for void type");
     return;
   }
   case naclbitc::CST_CODE_UNDEF: {
     // UNDEF
-    if (!isValidRecordSize(0, "constants block undef"))
+    if (!isValidRecordSize(0, "undef"))
       return;
     if (!isValidNextConstantType())
       return;
     if (isIRGenerationDisabled()) {
       FuncParser->setNextConstantID(nullptr);
       return;
     }
     FuncParser->setNextConstantID(
         getContext()->getConstantUndef(NextConstantType));
     return;
   }
   case naclbitc::CST_CODE_INTEGER: {
     // INTEGER: [intval]
-    if (!isValidRecordSize(1, "constants block integer"))
+    if (!isValidRecordSize(1, "integer"))
       return;
     if (!isValidNextConstantType())
       return;
     if (isIRGenerationDisabled()) {
       FuncParser->setNextConstantID(nullptr);
       return;
     }
     if (IntegerType *IType = dyn_cast<IntegerType>(
             Context->convertToLLVMType(NextConstantType))) {
       APInt Value(IType->getBitWidth(), NaClDecodeSignRotatedValue(Values[0]));
       Ice::Constant *C = (NextConstantType == Ice::IceType_i64)
                              ? getContext()->getConstantInt64(
                                    NextConstantType, Value.getSExtValue())
                              : getContext()->getConstantInt32(
                                    NextConstantType, Value.getSExtValue());
       FuncParser->setNextConstantID(C);
       return;
     }
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "constant block integer record for non-integer type "
            << NextConstantType;
     Error(StrBuf.str());
     return;
   }
   case naclbitc::CST_CODE_FLOAT: {
     // FLOAT: [fpval]
-    if (!isValidRecordSize(1, "constants block float"))
+    if (!isValidRecordSize(1, "float"))
       return;
     if (!isValidNextConstantType())
       return;
     if (isIRGenerationDisabled()) {
       FuncParser->setNextConstantID(nullptr);
       return;
     }
     switch (NextConstantType) {
     case Ice::IceType_f32: {
       APFloat Value(APFloat::IEEEsingle,
@@ skipping 111 matching lines @@
 class ModuleParser : public BlockParserBaseClass {
 public:
   ModuleParser(unsigned BlockID, TopLevelParser *Context)
       : BlockParserBaseClass(BlockID, Context),
         Timer(Ice::TimerStack::TT_parseModule,
               Context->getTranslator().getContext()),
         GlobalDeclarationNamesAndInitializersInstalled(false) {}
 
   ~ModuleParser() override {}
 
+  const char *getBlockName() const override { return "module"; }
+
 private:
   Ice::TimerMarker Timer;
   // True if we have already installed names for unnamed global declarations,
   // and have generated global constant initializers.
   bool GlobalDeclarationNamesAndInitializersInstalled;
 
   // 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.
@@ skipping 99 matching lines @@
   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, "Module version"))
+    if (!isValidRecordSize(1, "version"))
       return;
     unsigned 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]
-    if (!isValidRecordSize(4, "Function heading"))
+    if (!isValidRecordSize(4, "address"))
       return;
     const Ice::FuncSigType &Signature = Context->getFuncSigTypeByID(Values[0]);
     CallingConv::ID CallingConv;
     if (!naclbitc::DecodeCallingConv(Values[1], CallingConv)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Function heading has unknown calling convention: "
+      StrBuf << "Function address has unknown calling convention: "
              << Values[1];
       Error(StrBuf.str());
       return;
     }
     GlobalValue::LinkageTypes Linkage;
     if (!naclbitc::DecodeLinkage(Values[3], Linkage)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
-      StrBuf << "Function heading has unknown linkage. Found " << Values[3];
+      StrBuf << "Function address has unknown linkage. Found " << Values[3];
       Error(StrBuf.str());
       return;
     }
     Ice::FunctionDeclaration *Func = Ice::FunctionDeclaration::create(
         getTranslator().getContext(), Signature, CallingConv, Linkage,
         Values[2] == 0);
     if (Values[2] == 0)
       Context->setNextValueIDAsImplementedFunction();
     Context->setNextFunctionID(Func);
     return;
@@ skipping 62 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice