Add a bitcode parser constructor for parallel parsing.

include/llvm/Bitcode/NaCl/NaClBitcodeParser.h

 //===- NaClBitcodeParser.h -----------------------------------*- C++ -*-===//
 //     Low-level bitcode driver to parse PNaCl bitcode files.
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ skipping 579 matching lines @@
 
   // The current record (within the block) being processed.
   NaClBitcodeRecord Record;
 
   // The listener (if any) to use.
   NaClBitcodeParserListener *Listener;
 
   // The error stream to use if non-null (uses errs() if null).
   raw_ostream *ErrStream;
 
-  // Creates a block parser to parse the block associated with the
-  // bitcode entry that defines the beginning of a block. This
-  // instance actually parses the corresponding block.
+  // Creates a block parser to parse the block associated with the bitcode entry
+  // that defines the beginning of a block. This instance actually parses the
+  // corresponding block. Inherits the bitstream cursor from the
+  // EnclosingParser.
   NaClBitcodeParser(unsigned BlockID, NaClBitcodeParser *EnclosingParser)
       : EnclosingParser(EnclosingParser),
         Block(BlockID, EnclosingParser->Record),
         Record(Block),
         Listener(EnclosingParser->Listener),
         ErrStream(EnclosingParser->ErrStream)
   {}
 
+  // Same as above, but use the given bitstrem cursor (instead of inheriting

[Jim Stichnoth, 2016/03/23 21:20:29]

bitstream

[Jim Stichnoth, 2016/03/23 21:20:29]

maybe s/given/supplied/ ?

[Karl, 2016/03/24 19:29:09]

Done.

+  // from the enclosing parser). This constructor allows parallel parsing of
+  // subblocks, by allowing the caller to generate a different Cursor for each
+  // block to be parsed in parallel.
+  NaClBitcodeParser(unsigned BlockID, NaClBitcodeParser *EnclosingParser,
+                    NaClBitstreamCursor &Cursor)

[Jim Stichnoth, 2016/03/23 21:20:29]

I'm not familiar with this set of data structures, so I'd just ask you to take a
second look at this and make sure passing Cursor by non-const ref is the right
thing here.

[John, 2016/03/24 13:08:16]

It is the right thing as NaClBitcodeData holds a non-const reference to the
cursor -- I just which it held a pointer instead...

[Jim Stichnoth, 2016/03/24 13:09:19]

OK - otherwise LGTM.

[Karl, 2016/03/24 19:29:09]

Acknowledged.

+      : EnclosingParser(EnclosingParser),
+        Block(BlockID, Cursor),
+        Record(Block),
+        Listener(0),

[Jim Stichnoth, 2016/03/23 21:20:29]

Listener(nullptr)

[Karl, 2016/03/24 19:29:09]

Actually, it should have been:

   Listener(EnclosingParser->Listener).

Changing.

+        ErrStream(EnclosingParser->ErrStream)
+  {}
+
   /// Defines the listener for this block, and all enclosing blocks,
   /// to be the given listener. Should be set in the constructor.
   void SetListener(NaClBitcodeParserListener* UseListener) {
     Listener = UseListener;
   }
 
 private:
   // Special constant identifying the top-level instance.
   static const unsigned ILLEGAL_BLOCK_ID = UINT_MAX;
 
@@ skipping 19 matching lines @@
   bool ParseBlockInternal();
 
   void operator=(const NaClBitcodeParser &Parser) = delete;
   NaClBitcodeParser(const NaClBitcodeParser &Parser) = delete;
 
 };
 
 }  // namespace llvm
 
 #endif