Allow Subzero to parse function blocks in parallel.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 203 matching lines @@
       return;
 
     // Mask out the high bits.
     Val &= ~static_cast<uint64_t>(0) >> (BITS_PER_WORD - BitWidth);
   }
 };
 
 class BlockParserBaseClass;
 
 // Top-level class to read PNaCl bitcode files, and translate to ICE.
-class TopLevelParser : public NaClBitcodeParser {
+class TopLevelParser final : public NaClBitcodeParser {
   TopLevelParser() = delete;
   TopLevelParser(const TopLevelParser &) = delete;
   TopLevelParser &operator=(const TopLevelParser &) = delete;
 
 public:
   TopLevelParser(Ice::Translator &Translator, NaClBitstreamCursor &Cursor,
                  Ice::ErrorCode &ErrorStatus)
       : NaClBitcodeParser(Cursor), Translator(Translator),
         ErrorStatus(ErrorStatus),
         VariableDeclarations(new Ice::VariableDeclarationList()) {}
 
   ~TopLevelParser() override = default;
 
   Ice::Translator &getTranslator() const { return Translator; }
 
-  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;
+               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; }
-
   /// Changes the size of the type list to the given size.
   void resizeTypeIDValues(size_t NewSize) { TypeIDValues.resize(NewSize); }
 
   size_t getNumTypeIDValues() const { return TypeIDValues.size(); }
 
   /// Returns a pointer to the pool where globals are allocated.
   Ice::VariableDeclarationList *getGlobalVariablesPool() {
     return VariableDeclarations.get();
   }
 
@@ skipping 156 matching lines @@
     StrBuf << Prefix << " alignment greater than 2**" << AlignPowerLimit
            << ". Found: 2**" << (AlignPower - 1);
     Parser->Error(StrBuf.str());
     // Error recover with value that is always acceptable.
     return 1;
   }
 
 private:
   // The translator associated with the parser.
   Ice::Translator &Translator;
+
+  // ErrorStatus should only be updated while this lock is locked.
+  Ice::GlobalLockType ErrorReportingLock;
   // The exit status that should be set to true if an error occurs.
   Ice::ErrorCode &ErrorStatus;
-  // The number of errors reported.
-  unsigned NumErrors = 0;
+
   // The types associated with each type ID.
   std::vector<ExtendedType> TypeIDValues;
   // The set of functions (prototype and defined).
   Ice::FunctionDeclarationList FunctionDeclarations;
   // The ID of the next possible defined function ID in FunctionDeclarations.
   // FunctionDeclarations is filled first. It's the set of functions (either
   // defined or isproto). Then function definitions are encountered/parsed and
   // NextDefiningFunctionID is incremented to track the next actually-defined
   // function.
   size_t NextDefiningFunctionID = 0;
   // The set of global variables.
   std::unique_ptr<Ice::VariableDeclarationList> VariableDeclarations;
   // Relocatable constants associated with global declarations.
   Ice::ConstantList ValueIDConstants;
   // Error recovery value to use when getFuncSigTypeByID fails.
   Ice::FuncSigType UndefinedFuncSigType;
-  // The block parser currently being applied. Used for error reporting.
-  BlockParserBaseClass *BlockParser = nullptr;
   // Defines if a module block has already been parsed.
   bool ParsedModuleBlock = false;
 
   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(NaClBcIndexSize_t ID,
                                   ExtendedType::TypeKind WantedKind) {
@@ skipping 114 matching lines @@
   Ice::VariableDeclaration *
   reportGetGlobalVariableByIDError(NaClBcIndexSize_t Index);
 
   // Reports that there is no corresponding ICE type for LLVMTy, and 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();
+  {
+    std::unique_lock<Ice::GlobalLockType> _(ErrorReportingLock);
+    ErrorStatus.assign(Ice::EC_Bitcode);
+  }
   { // 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;
@@ skipping 58 matching lines @@
 // 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() = delete;
   BlockParserBaseClass(const BlockParserBaseClass &) = delete;
   BlockParserBaseClass &operator=(const BlockParserBaseClass &) = delete;
 
 public:
   // Constructor for the top-level module block parser.
   BlockParserBaseClass(unsigned BlockID, TopLevelParser *Context)
-      : NaClBitcodeParser(BlockID, Context), Context(Context) {
-    Context->setBlockParser(this);
-  }
+      : NaClBitcodeParser(BlockID, Context), Context(Context) {}
 
-  ~BlockParserBaseClass() override { Context->setBlockParser(nullptr); }
+  BlockParserBaseClass(unsigned BlockID, BlockParserBaseClass *EnclosingParser,
+                       NaClBitstreamCursor &Cursor)
+      : NaClBitcodeParser(BlockID, EnclosingParser, Cursor),
+        Context(EnclosingParser->Context) {}
+
+  ~BlockParserBaseClass() override {}
 
   // 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";
   }
 
   // Generates an error Message with the Bit address prefixed to it.
   bool ErrorAt(naclbitc::ErrorLevel Level, uint64_t Bit,
-               const std::string &Message) final;
+               const std::string &Message) override;
 
 protected:
   // The context parser that contains the decoded state.
   TopLevelParser *Context;
+  // True if ErrorAt has been called in this block.
+  bool BlockHasError = false;
 
   // 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(); }
@@ skipping 48 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(size_t ExpectedSize, const char *RecordName,
                              const char *ContextMessage);
 };
 
 bool TopLevelParser::blockError(const std::string &Message) {
-  if (BlockParser)
-    return BlockParser->Error(Message);
-  else
-    return Error(Message);
+  // TODO(kschimpf): Remove this method. This method used to redirect
+  // block-level errors to the block we are in, rather than the top-level
+  // block. This gave better bit location for error messages. However, with
+  // parallel parsing, we can't keep a field to redirect (there could be many
+  // and we don't know which block parser applies). Hence, This redirect can't
+  // be applied anymore.
+  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) {
+  BlockHasError = true;
   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;
     }
@@ skipping 36 matching lines @@
 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 " << getBlockName()
          << " record:" << Record;
   Error(StrBuf.str());
 }
 
 // Class to parse a types block.
-class TypesParser : public BlockParserBaseClass {
+class TypesParser final : 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 {
@@ skipping 183 matching lines @@
   }
   default:
     BlockParserBaseClass::ProcessRecord();
     return;
   }
   llvm_unreachable("Unknown type block record not processed!");
 }
 
 /// Parses the globals block (i.e. global variable declarations and
 /// corresponding initializers).
-class GlobalsParser : public BlockParserBaseClass {
+class GlobalsParser final : public BlockParserBaseClass {
   GlobalsParser() = delete;
   GlobalsParser(const GlobalsParser &) = delete;
   GlobalsParser &operator=(const GlobalsParser &) = delete;
 
 public:
   GlobalsParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Timer(Ice::TimerStack::TT_parseGlobals, getTranslator().getContext()),
         NumFunctionIDs(Context->getNumFunctionIDs()),
         DummyGlobalVar(Ice::VariableDeclaration::create(
             Context->getGlobalVariablesPool())),
         CurGlobalVar(DummyGlobalVar) {
     Context->getGlobalVariablesPool()->willNotBeEmitted(DummyGlobalVar);
   }
 
-  ~GlobalsParser() final = default;
+  ~GlobalsParser() override = default;
 
   const char *getBlockName() const override { return "globals"; }
 
 private:
   using GlobalVarsMapType =
       std::unordered_map<NaClBcIndexSize_t, Ice::VariableDeclaration *>;
 
   Ice::TimerMarker Timer;
 
   // Holds global variables generated/referenced in the global variables block.
@@ skipping 283 matching lines @@
   }
   default:
     break;
   }
   // If reached, don't know how to handle record.
   BlockParserBaseClass::ProcessRecord();
   return;
 }
 
 /// Parses function blocks in the bitcode file.
-class FunctionParser : public BlockParserBaseClass {
+class FunctionParser final : public BlockParserBaseClass {
   FunctionParser() = delete;
   FunctionParser(const FunctionParser &) = delete;
   FunctionParser &operator=(const FunctionParser &) = delete;
 
 public:
-  FunctionParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
+  FunctionParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser,
+                 NaClBcIndexSize_t FcnId)
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Timer(Ice::TimerStack::TT_parseFunctions, getTranslator().getContext()),
-        Func(nullptr), FcnId(Context->getNextFunctionBlockValueID()),
-        FuncDecl(Context->getFunctionByID(FcnId)),
+        Func(nullptr), FuncDecl(Context->getFunctionByID(FcnId)),
         CachedNumGlobalValueIDs(Context->getNumGlobalIDs()),
         NextLocalInstIndex(Context->getNumGlobalIDs()) {}
 
-  bool convertFunction() {
+  FunctionParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser,
+                 NaClBcIndexSize_t FcnId, NaClBitstreamCursor &Cursor)
+      : BlockParserBaseClass(BlockID, EnclosingParser, Cursor),
+        Timer(Ice::TimerStack::TT_parseFunctions, getTranslator().getContext()),
+        Func(nullptr), FuncDecl(Context->getFunctionByID(FcnId)),
+        CachedNumGlobalValueIDs(Context->getNumGlobalIDs()),
+        NextLocalInstIndex(Context->getNumGlobalIDs()) {}
+
+  std::unique_ptr<Ice::Cfg> parseFunction(uint32_t SeqNumber) {
     bool ParserResult;
+    Ice::GlobalContext *Ctx = getTranslator().getContext();
     {
-      Ice::TimerMarker T(getTranslator().getContext(),
-                         FuncDecl->getName().toStringOrEmpty());
+      Ice::TimerMarker T(Ctx, FuncDecl->getName().toStringOrEmpty());
       // Note: The Cfg is created, even when IR generation is disabled. This is
       // done to install a CfgLocalAllocator for various internal containers.
       Ice::GlobalContext *Ctx = getTranslator().getContext();
-      Func = Ice::Cfg::create(Ctx, getTranslator().getNextSequenceNumber());
+      Func = Ice::Cfg::create(Ctx, SeqNumber);
 
       Ice::CfgLocalAllocatorScope _(Func.get());
 
       // TODO(kschimpf) Clean up API to add a function signature to a CFG.
       const Ice::FuncSigType &Signature = FuncDecl->getSignature();
 
       Func->setFunctionName(FuncDecl->getName());
       Func->setReturnType(Signature.getReturnType());
       Func->setInternal(FuncDecl->getLinkage() == GlobalValue::InternalLinkage);
       CurrentNode = installNextBasicBlock();
       Func->setEntryNode(CurrentNode);
       for (Ice::Type ArgType : Signature.getArgList()) {
         Func->addArg(getNextInstVar(ArgType));
       }
 
       ParserResult = ParseThisBlock();
-
-      // Note: Once any errors have been found, we turn off all translation of
-      // all remaining functions. This allows successive parsing errors to be
-      // reported, without adding extra checks to the translator for such
-      // parsing errors.
-    }
-    if (Context->getNumErrors() == 0 && Func) {
-      getTranslator().translateFcn(std::move(Func));
-      // The translator now has ownership of Func.
-    } else {
-      Func.reset();
     }
 
-    return ParserResult;
+    if (ParserResult || BlockHasError)
+      Func->setError("Unable to parse function");
+
+    return std::move(Func);
   }
 
-  ~FunctionParser() final = default;
+  ~FunctionParser() override = default;
 
   const char *getBlockName() const override { return "function"; }
 
   Ice::Cfg *getFunc() const { return Func.get(); }
 
   size_t getNumGlobalIDs() const { return CachedNumGlobalValueIDs; }
 
   void setNextLocalInstIndex(Ice::Operand *Op) {
     setOperand(NextLocalInstIndex++, Op);
   }
@@ skipping 23 matching lines @@
   // the number of bytes defining the function block.
   uint64_t MaxRecordsInBlock = 0;
   // The corresponding ICE function defined by the function block.
   std::unique_ptr<Ice::Cfg> Func;
   // The index to the current basic block being built.
   NaClBcIndexSize_t CurrentBbIndex = 0;
   // The number of basic blocks declared for the function block.
   NaClBcIndexSize_t DeclaredNumberBbs = 0;
   // The basic block being built.
   Ice::CfgNode *CurrentNode = nullptr;
-  // The ID for the function.
-  NaClBcIndexSize_t FcnId;
   // The corresponding function declaration.
   Ice::FunctionDeclaration *FuncDecl;
   // Holds the dividing point between local and global absolute value indices.
   size_t CachedNumGlobalValueIDs;
   // Holds operands local to the function block, based on indices defined in
   // the bitcode file.
   Ice::OperandList LocalOperands;
   // Holds the index within LocalOperands corresponding to the next instruction
   // that generates a value.
   NaClBcIndexSize_t NextLocalInstIndex;
   // True if the last processed instruction was a terminating instruction.
   bool InstIsTerminating = false;
 
   bool ParseBlock(unsigned BlockID) override;
 
   void ProcessRecord() override;
 
-  void EnterBlock(unsigned NumWords) final {
+  void EnterBlock(unsigned NumWords) override {
     // Note: Bitstream defines words as 32-bit values.
     NumBytesDefiningFunction = NumWords * sizeof(uint32_t);
     // We know that all records are minimally defined by a two-bit abreviation.
     MaxRecordsInBlock = NumBytesDefiningFunction * (CHAR_BIT >> 1);
   }
 
   void ExitBlock() override;
 
   // Creates and appends a new basic block to the list of basic blocks.
   Ice::CfgNode *installNextBasicBlock() {
@@ skipping 1300 matching lines @@
     return;
   }
   default:
     // Generate error message!
     BlockParserBaseClass::ProcessRecord();
     return;
   }
 }
 
 /// Parses constants within a function block.
-class ConstantsParser : public BlockParserBaseClass {
+class ConstantsParser final : public BlockParserBaseClass {
   ConstantsParser() = delete;
   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) {}
 
@@ skipping 96 matching lines @@
     }
   }
   default:
     // Generate error message!
     BlockParserBaseClass::ProcessRecord();
     return;
   }
 }
 
 // Parses valuesymtab blocks appearing in a function block.
-class FunctionValuesymtabParser : public ValuesymtabParser {
+class FunctionValuesymtabParser final : public ValuesymtabParser {
   FunctionValuesymtabParser() = delete;
   FunctionValuesymtabParser(const FunctionValuesymtabParser &) = delete;
   void operator=(const FunctionValuesymtabParser &) = delete;
 
 public:
   FunctionValuesymtabParser(unsigned BlockID, FunctionParser *EnclosingParser)
       : ValuesymtabParser(BlockID, EnclosingParser),
         Timer(Ice::TimerStack::TT_parseFunctionValuesymtabs,
               getTranslator().getContext()) {}
 
 private:
   Ice::TimerMarker Timer;
   // Returns the enclosing function parser.
   FunctionParser *getFunctionParser() const {
     return reinterpret_cast<FunctionParser *>(GetEnclosingParser());
   }
 
-  const char *getTableKind() const final { return "Function"; }
+  const char *getTableKind() const override { return "Function"; }
 
-  void setValueName(NaClBcIndexSize_t Index, StringType &Name) final;
-  void setBbName(NaClBcIndexSize_t Index, StringType &Name) final;
+  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, 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());
@@ skipping 45 matching lines @@
     }
     break;
   }
   default:
     break;
   }
   return BlockParserBaseClass::ParseBlock(BlockID);
 }
 
 /// Parses the module block in the bitcode file.
-class ModuleParser : public BlockParserBaseClass {
+class ModuleParser final : public BlockParserBaseClass {
   ModuleParser() = delete;
   ModuleParser(const ModuleParser &) = delete;
   ModuleParser &operator=(const ModuleParser &) = delete;
 
 public:
   ModuleParser(unsigned BlockID, TopLevelParser *Context)
       : BlockParserBaseClass(BlockID, Context),
         Timer(Ice::TimerStack::TT_parseModule,
               Context->getTranslator().getContext()) {}
-
   ~ModuleParser() override = default;
-
   const char *getBlockName() const override { return "module"; }
+  NaClBitstreamCursor &getCursor() const { return Record.GetCursor(); }
 
 private:
   Ice::TimerMarker Timer;
   // True if we have already installed names for unnamed global declarations,
   // and have generated global constant initializers.
   bool GlobalDeclarationNamesAndInitializersInstalled = false;
   // True if we have already processed the symbol table for the module.
   bool FoundValuesymtab = 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() {
     if (!GlobalDeclarationNamesAndInitializersInstalled) {
       Context->installGlobalNames();
       Context->createValueIDs();
       Context->verifyFunctionTypeSignatures();
       std::unique_ptr<Ice::VariableDeclarationList> Globals =
           Context->getGlobalVariables();
       if (Globals)
         getTranslator().lowerGlobals(std::move(Globals));
       GlobalDeclarationNamesAndInitializersInstalled = true;
     }
   }
   bool ParseBlock(unsigned BlockID) override;
 
-  void ExitBlock() override { installGlobalNamesAndGlobalVarInitializers(); }
+  void ExitBlock() override {
+    installGlobalNamesAndGlobalVarInitializers();
+    Context->getTranslator().getContext()->waitForWorkerThreads();
+  }
 
   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;
-  const char *getTableKind() const final { return "Module"; }
-  void setValueName(NaClBcIndexSize_t Index, StringType &Name) final;
-  void setBbName(NaClBcIndexSize_t Index, StringType &Name) final;
+  const char *getTableKind() const override { return "Module"; }
+  void setValueName(NaClBcIndexSize_t Index, StringType &Name) override;
+  void setBbName(NaClBcIndexSize_t Index, StringType &Name) override;
 };
 
 void ModuleValuesymtabParser::setValueName(NaClBcIndexSize_t Index,
                                            StringType &Name) {
   Ice::GlobalDeclaration *Decl = Context->getGlobalDeclarationByID(Index);
   if (llvm::isa<Ice::VariableDeclaration>(Decl) &&
       Decl->isPNaClABIExternalName(Name.str())) {
     // Force linkage of (specific) Global Variables be external for the PNaCl
     // ABI. PNaCl bitcode has a linkage field for Functions, but not for
     // GlobalVariables (because the latter is not needed for pexes, so it has
     // been removed).
     Decl->setLinkage(llvm::GlobalValue::ExternalLinkage);
   }
 
   // Unconditionally capture the name if it is provided in the input file,
   // regardless of whether dump is enabled or whether the symbol is internal vs
   // external.  This fits in well with the lit tests, and most symbols in a
   // conforming pexe are nameless and don't take this path.
   Decl->setName(getTranslator().getContext(),
                 StringRef(Name.data(), Name.size()));
 }
 
 void ModuleValuesymtabParser::setBbName(NaClBcIndexSize_t Index,
                                         StringType &Name) {
   reportUnableToAssign("Basic block", Index, Name);
 }
 
+class CfgParserWorkItem final : public Ice::OptWorkItem {
+  CfgParserWorkItem() = delete;
+  CfgParserWorkItem(const CfgParserWorkItem &) = delete;
+  CfgParserWorkItem &operator=(const CfgParserWorkItem &) = delete;
+
+public:
+  CfgParserWorkItem(unsigned BlockID, NaClBcIndexSize_t FcnId,
+                    ModuleParser *ModParser, std::unique_ptr<uint8_t[]> Buffer,
+                    uintptr_t BufferSize, uint64_t StartBit, uint32_t SeqNumber)
+      : BlockID(BlockID), FcnId(FcnId), ModParser(ModParser),
+        Buffer(std::move(Buffer)), BufferSize(BufferSize), StartBit(StartBit),
+        SeqNumber(SeqNumber) {}
+  std::unique_ptr<Ice::Cfg> getParsedCfg() override;
+  ~CfgParserWorkItem() override = default;
+
+private:
+  const unsigned BlockID;
+  const NaClBcIndexSize_t FcnId;
+  // Note: ModParser can't be const because the function parser needs to
+  // access non-const member functions (of ModuleParser and TopLevelParser).
+  // TODO(kschimpf): Fix this issue.
+  ModuleParser *ModParser;
+  const std::unique_ptr<uint8_t[]> Buffer;
+  const uintptr_t BufferSize;
+  const uint64_t StartBit;
+  const uint32_t SeqNumber;
+};
+
+std::unique_ptr<Ice::Cfg> CfgParserWorkItem::getParsedCfg() {
+  NaClBitstreamCursor &OldCursor(ModParser->getCursor());
+  llvm::NaClBitstreamReader Reader(Buffer.get(), Buffer.get() + BufferSize,
+                                   OldCursor.getBitStreamReader());
+  NaClBitstreamCursor NewCursor(Reader);
+  NewCursor.JumpToBit(NewCursor.getWordBitNo(StartBit));
+  FunctionParser Parser(BlockID, ModParser, FcnId, NewCursor);
+  return Parser.parseFunction(SeqNumber);
+}
+
 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: {
     if (FoundValuesymtab)
       Fatal("Duplicate valuesymtab in module");
 
     // If we have already processed a function block (i.e. we have already
     // installed global names and variable initializers) we can no longer accept
     // the value symbol table. Names have already been generated.
     if (GlobalDeclarationNamesAndInitializersInstalled)
       Fatal("Module valuesymtab not allowed after function blocks");
 
     FoundValuesymtab = true;
     ModuleValuesymtabParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
   case naclbitc::FUNCTION_BLOCK_ID: {
     installGlobalNamesAndGlobalVarInitializers();
-    FunctionParser Parser(BlockID, this);
-    return Parser.convertFunction();
+    Ice::GlobalContext *Ctx = Context->getTranslator().getContext();
+    uint32_t SeqNumber = Context->getTranslator().getNextSequenceNumber();
+    NaClBcIndexSize_t FcnId = Context->getNextFunctionBlockValueID();
+    if (Ctx->getFlags().getParseParallel()) {
+      // Skip the block and copy into a buffer. Note: We copy into a buffer
+      // using the top-level parser to make sure that the underlying
+      // buffer reading from the data streamer is not thread safe.
+      NaClBitstreamCursor &Cursor = Record.GetCursor();
+      uint64_t StartBit = Cursor.GetCurrentBitNo();
+      if (SkipBlock())
+        return true;
+      const uint64_t EndBit = Cursor.GetCurrentBitNo();
+      const uintptr_t StartByte = Cursor.getStartWordByteForBit(StartBit);
+      const uintptr_t EndByte = Cursor.getEndWordByteForBit(EndBit);
+      const uintptr_t BufferSize = EndByte - StartByte;
+      std::unique_ptr<uint8_t[]> Buffer((uint8_t *)(new uint8_t[BufferSize]));
+      for (size_t i = Cursor.fillBuffer(Buffer.get(), BufferSize, StartByte);
+           i < BufferSize; ++i) {
+        Buffer[i] = 0;
+      }
+      Ctx->optQueueBlockingPush(Ice::makeUnique<CfgParserWorkItem>(
+          BlockID, FcnId, this, std::move(Buffer), BufferSize, StartBit,
+          SeqNumber));
+      return false;
+    } else {
+      FunctionParser Parser(BlockID, this, FcnId);
+      std::unique_ptr<Ice::Cfg> Func = Parser.parseFunction(SeqNumber);
+      bool Failed = Func->hasError();
+      getTranslator().translateFcn(std::move(Func));
+      return Failed && !getTranslator().getFlags().getAllowErrorRecovery();
+    }
   }
   default:
     return BlockParserBaseClass::ParseBlock(BlockID);
   }
 }
 
 void ModuleParser::ProcessRecord() {
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   switch (Record.GetCode()) {
   case naclbitc::MODULE_CODE_VERSION: {
@@ skipping 107 matching lines @@
     raw_string_ostream StrBuf(Buffer);
     StrBuf << IRFilename << ": Does not contain a module!";
     llvm::report_fatal_error(StrBuf.str());
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice