Correct error reporting bit for parallel PNaCl bitcode parses.

include/llvm/Bitcode/NaCl/NaClBitstreamReader.h

 //===- NaClBitstreamReader.h -----------------------------------*- C++ -*-===//
 //     Low-level bitstream reader interface
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ skipping 211 matching lines @@
 private:
   friend class NaClBitstreamCursor;
 
   std::unique_ptr<MemoryObject> BitcodeBytes;
 
   SharedBlockInfoMap BlockInfoRecords;
 
   /// \brief Holds the offset of the first byte after the header.
   size_t InitialAddress;
 
+  // Holds the number of bytes to add to the bitcode position, when
+  // reporting errors. Useful when using parallel parses of function
+  // blocks.
+  size_t ErrorOffset;

[Jim Stichnoth, 2016/04/01 23:52:30]

Consider "size_t ErrorOffset = 0;" and then you can remove ErrorOffset(0) from 3
of the ctors.

Also, reflow comment.

[Karl, 2016/04/02 17:16:50]

Done.

+
   // True if filler should be added to byte align records.
   bool AlignBitcodeRecords = false;
   NaClBitstreamReader(const NaClBitstreamReader&) = delete;
   void operator=(const NaClBitstreamReader&) = delete;
 
 
   void initFromHeader(NaClBitcodeHeader &Header) {
     InitialAddress = Header.getHeaderSize();
     AlignBitcodeRecords = Header.getAlignBitcodeRecords();
   }
 
 public:
   /// Read stream from sequence of bytes [Start .. End) after parsing
   /// the given bitcode header.
   NaClBitstreamReader(const unsigned char *Start, const unsigned char *End,
                       NaClBitcodeHeader &Header)
       : BitcodeBytes(getNonStreamedMemoryObject(Start, End)),
-        BlockInfoRecords(BlockInfoRecordsMap::create()) {
+        BlockInfoRecords(BlockInfoRecordsMap::create()), ErrorOffset(0) {
     initFromHeader(Header);
   }
 
   /// Read stream from Bytes, after parsing the given bitcode header.
   NaClBitstreamReader(MemoryObject *Bytes, NaClBitcodeHeader &Header)
-      : BitcodeBytes(Bytes), BlockInfoRecords(BlockInfoRecordsMap::create()) {
-    initFromHeader(Header);
+      : BitcodeBytes(Bytes), BlockInfoRecords(BlockInfoRecordsMap::create()),
+        ErrorOffset(0) { initFromHeader(Header);
   }
 
   /// Read stream from bytes, starting at the given initial address.
   /// Provides simple API for unit testing.
   NaClBitstreamReader(MemoryObject *Bytes, size_t InitialAddress)
       : BitcodeBytes(Bytes), BlockInfoRecords(BlockInfoRecordsMap::create()),
-        InitialAddress(InitialAddress) {
-  }
+        InitialAddress(InitialAddress),
+        ErrorOffset(0) {}
 
   /// Read stream from sequence of bytes [Start .. End), using the global
   /// abbreviations of the given bitstream reader. Assumes that [Start .. End)
   /// is copied from Reader's memory object.
-  NaClBitstreamReader(const unsigned char *Start,
+  NaClBitstreamReader(size_t StartAddress, const unsigned char *Start,
                       const unsigned char *End, NaClBitstreamReader *Reader)
       : BitcodeBytes(getNonStreamedMemoryObject(Start, End)),
-        BlockInfoRecords(Reader->BlockInfoRecords), InitialAddress(0)
-  { BlockInfoRecords->freeze(); }
+        BlockInfoRecords(Reader->BlockInfoRecords), InitialAddress(0),
+        ErrorOffset(StartAddress) { BlockInfoRecords->freeze(); }
 
   // Returns the memory object that is being read.
   MemoryObject &getBitcodeBytes() { return *BitcodeBytes; }
 
   ~NaClBitstreamReader() {}
 
   /// \brief Returns the initial address (after the header) of the input stream.
   size_t getInitialAddress() const {
     return InitialAddress;
   }
 
+  /// Returns the byte address of the first byte in the bitstream. Used
+  /// for error reporting.
+  size_t getErrorOffset() const { return ErrorOffset; }
+
   //===--------------------------------------------------------------------===//
   // Block Manipulation
   //===--------------------------------------------------------------------===//
 
   BlockInfo *getBlockInfo(unsigned BlockID) {
     return BlockInfoRecords->getBlockInfo(BlockID);
   }
 };
 
 /// When advancing through a bitstream cursor, each advance can discover a few
@@ skipping 233 matching lines @@
   /// Return the number of bits used to encode an abbrev #.
   unsigned getAbbrevIDWidth() const {
     return BlockScope.back().getCodeAbbrev().NumBits;
   }
 
   /// Return the bit # of the bit we are reading.
   uint64_t GetCurrentBitNo() const {
     return NextChar*CHAR_BIT - BitsInCurWord;
   }
 
+  /// Converts the given position into the corresponding Error position.
+  uint64_t getErrorBitNo(uint64_t Position) const {
+    return BitStream->getErrorOffset() * CHAR_BIT + Position;
+  }
+
+  /// Returns the current bit address for reporting errors.
+  uint64_t getErrorBitNo() const {
+    return getErrorBitNo(GetCurrentBitNo());
+  }
+
   NaClBitstreamReader *getBitStreamReader() {
     return BitStream;
   }
   const NaClBitstreamReader *getBitStreamReader() const {
     return BitStream;
   }
 
   /// Returns the current bit address (string) of the bit cursor.
   std::string getCurrentBitAddress() const {
     return naclbitc::getBitAddress(GetCurrentBitNo());
@@ skipping 338 matching lines @@
   // Skips over an abbreviation record. Duplicates code of ReadAbbrevRecord,
   // except that no abbreviation is built.
   void SkipAbbrevRecord();
   
   bool ReadBlockInfoBlock(NaClAbbrevListener *Listener);
 };
 
 } // End llvm namespace
 
 #endif