Fix the NaCl bitstream reader to report fatal errors.

lib/Bitcode/NaCl/Analysis/NaClObjDump.cpp

 //===-- NaClObjDump.cpp - Dump PNaCl bitcode contents ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
@@ skipping 537 matching lines @@
 }
 
 /// Top-level class to parse bitcode file and transform to
 /// corresponding disassembled code.
 class NaClDisTopLevelParser : public NaClBitcodeParser {
   NaClDisTopLevelParser(const NaClDisTopLevelParser&) LLVM_DELETED_FUNCTION;
   void operator=(const NaClDisTopLevelParser&) LLVM_DELETED_FUNCTION;
 
 public:
   NaClDisTopLevelParser(NaClBitcodeHeader &Header,
-                        const unsigned char *HeaderBuffer,
                         NaClBitstreamCursor &Cursor,
                         naclbitc::ObjDumpStream &ObjDump)
       : NaClBitcodeParser(Cursor),
         Mod("ObjDump", getGlobalContext()),
         ObjDump(ObjDump),
         AbbrevListener(this),
         DL(&Mod),
         AllowedIntrinsics(&Mod.getContext()),
         AssemblyFormatter(ObjDump),
         Header(Header),
-        HeaderBuffer(HeaderBuffer),
         NumFunctions(0),
         NumGlobals(0),
         ExpectedNumGlobals(0),
         NumParams(0),
         NumConstants(0),
         NumValuedInsts(0),
         UnknownType(Type::getVoidTy(Mod.getContext())),
         PointerType(Type::getInt32Ty(Mod.getContext())),
         ComparisonType(Type::getInt1Ty(Mod.getContext())),
         NumDefinedFunctions(0) {
     SetListener(&AbbrevListener);
   }
 
   ~NaClDisTopLevelParser() override {
     // Be sure to flush any remaining errors.
     ObjDump.Flush();
   }
 
   // Returns the number of errors that were sent to the ObjDump.
   unsigned GetNumErrors() {
     return ObjDump.GetNumErrors();
   }
 
   /// Generates an error with the given message.
-  bool Error(const std::string &Message) override {
+  bool ErrorAt(uint64_t Bit, const std::string &Message) final {
     // Use local error routine so that all errors are treated uniformly.
-    ObjDump.Error() << Message << "\n";
+    ObjDump.Error(Bit) << Message << "\n";
     return true;
   }
 
   /// Flushes out objdump and then exits with fatal error.
+  LLVM_ATTRIBUTE_NORETURN
   void Fatal() {
-    Fatal("");
+    NaClBitcodeParser::Fatal();
   }
 
   /// Flushes out objdump and then exits with fatal error, using
   /// the given message.
-  void Fatal(const std::string &Message) {
-    ObjDump.Fatal(Message);
+  LLVM_ATTRIBUTE_NORETURN
+  void FatalAt(uint64_t Bit, const std::string &Message) final {
+    ObjDump.Fatal(Bit, Message);
   }
 
   /// Parses the top-level module block.
   bool ParseBlock(unsigned BlockID) override;
 
   /// Installs the given type to the next available type index.
   void InstallType(Type *Ty) {
     TypeIdType.push_back(Ty);
   }
 
@@ skipping 494 matching lines @@
   // Listener used to get abbreviations as they are read.
   NaClBitcodeParserListener AbbrevListener;
   // DataLayout to use.
   const DataLayout DL;
   // The set of allowed intrinsics.
   PNaClAllowedIntrinsics AllowedIntrinsics;
   // The formatter to use to format assembly code.
   AssemblyTextFormatter AssemblyFormatter;
   // The header appearing before the beginning of the input stream.
   NaClBitcodeHeader &Header;
-  // Pointer to the buffer containing the header.
-  const unsigned char *HeaderBuffer;
   // The list of known types (index i defines the type associated with
   // type index i).
   std::vector<Type*> TypeIdType;
   // The list of known function signatures (index i defines the type
   // signature associated with function index i).
   std::vector<FunctionType*> FunctionIdType;
   // boolean flag defining if function id is an intrinsic.
   std::vector<bool> FunctionIdIsIntrinsic;
   // The list of record bit addresses associated with corresponding
   // declaration of function IDs.
@@ skipping 229 matching lines @@
   }
 
   raw_ostream &Warnings() {
     return Context->Warnings();
   }
 
   void Fatal() {
     return Context->Fatal();
   }
 
-  void Fatal(const std::string &Message) {
-    return Context->Fatal(Message);
+  void FatalAt(uint64_t Bit, const std::string &Message) override {
+    return Context->FatalAt(Bit, Message);
   }
 
   const std::string &GetAssemblyIndent() const {
     return Context->GetAssemblyIndent();
   }
 
   unsigned GetAssemblyNumTabs() const {
     return Context->GetAssemblyNumTabs();
   }
 
@@ skipping 2095 matching lines @@
     break;
   }
   default:
     Errors() << "Unknown record found in module block\n";
     break;
   }
   ObjDumpWrite(Record.GetStartBit(), Record);
 }
 
 bool NaClDisTopLevelParser::ParseBlock(unsigned BlockID) {
-  // Before parsing top-level module block. Describe header.
-  NaClBitcodeRecordData Record;
+  // Before parsing top-level module block. Describe header by
+  // reconstructing the corresponding header record.
+  NaClBitcodeRecordData HeaderRecord;
   size_t HeaderSize = Header.getHeaderSize();
-  Record.Code = naclbitc::BLK_CODE_HEADER;
+  HeaderRecord.Code = naclbitc::BLK_CODE_HEADER;
+  NaClBitstreamCursor &Cursor = Record.GetCursor();
+  uint64_t CurPos = Cursor.GetCurrentBitNo();
+  Cursor.JumpToBit(0);
   for (size_t i = 0; i < HeaderSize; ++i) {
-    Record.Values.push_back(HeaderBuffer[i]);
+    HeaderRecord.Values.push_back(Cursor.Read(CHAR_BIT));
   }
+  Cursor.JumpToBit(CurPos);
   if (ObjDump.GetDumpRecords() && ObjDump.GetDumpAssembly()) {
     if (HeaderSize >= 4) {
-      const NaClRecordVector &Values = Record.Values;
+      const NaClRecordVector &Values = HeaderRecord.Values;
       Tokens() << "Magic" << Space() << "Number" << Colon()
                << Space() << StartCluster() << StartCluster() << "'"
                << (char) Values[0] << (char) Values[1]
                << (char) Values[2] << (char) Values[3]
                << "'" << FinishCluster() << Space()
                << StartCluster() << OpenParen()
                << Values[0] << Comma() << Space()
                << Values[1] << Comma() << Space()
                << Values[2] << Comma() << Space()
                << Values[3] << CloseParen() << FinishCluster()
                << FinishCluster() << Endline();
     }
     // Show interpretation of header as assembly.
     for (size_t i = 0; i < Header.NumberFields(); ++i) {
       Tokens() << Header.GetField(i)->Contents() << Endline();
     }
   }
-  ObjDump.Write(0, Record);
-  ObjDump.SetStartOffset(HeaderSize * 8);
+  ObjDump.Write(0, HeaderRecord);
 
   if (BlockID != naclbitc::MODULE_BLOCK_ID)
     return Error("Module block expected at top-level, but not found");
 
   // Now parse a module block.
   NaClDisModuleParser Parser(BlockID, this);
   return Parser.ParseThisBlock();
 }
 
 }
@@ skipping 10 matching lines @@
         << "Bitcode stream should be a multiple of 4 bytes in length.\n";
     return true;
   }
 
   const unsigned char *BufPtr = (const unsigned char *)MemBuf->getBufferStart();
   const unsigned char *EndBufPtr = BufPtr+MemBuf->getBufferSize();
   const unsigned char *HeaderPtr = BufPtr;
 
   // Read header and verify it is good.
   NaClBitcodeHeader Header;
-  if (Header.Read(BufPtr, EndBufPtr) || !Header.IsSupported()) {
+  if (Header.Read(HeaderPtr, EndBufPtr) || !Header.IsSupported()) {
     ObjDump.Error() << "Invalid PNaCl bitcode header.\n";
     return true;
   }
 
   // Create a bitstream reader to read the bitcode file.
-  NaClBitstreamReader InputStreamFile(BufPtr, EndBufPtr);
+  NaClBitstreamReader InputStreamFile(BufPtr, EndBufPtr,
+                                      Header.getHeaderSize());
   NaClBitstreamCursor InputStream(InputStreamFile);
 
   // Parse the the bitcode file.
-  ::NaClDisTopLevelParser Parser(Header, HeaderPtr, InputStream, ObjDump);
+  ::NaClDisTopLevelParser Parser(Header, InputStream, ObjDump);
   int NumBlocksRead = 0;
   bool ErrorsFound = false;
   while (!InputStream.AtEndOfStream()) {
     ++NumBlocksRead;
     if (Parser.Parse()) ErrorsFound = true;
   }
 
   if (NumBlocksRead != 1) {
     ObjDump.Error() << "Expected 1 top level block in bitcode: Found:"
                     << NumBlocksRead << "\n";
     ErrorsFound = true;
   }
 
   ObjDump.Flush();
   return ErrorsFound || Parser.GetNumErrors() > 0;
 }
 
 }