Allow Subzero to parse function blocks in parallel.

src/IceTranslator.cpp

 //===- subzero/src/IceTranslator.cpp - ICE to machine code ------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Defines the general driver class for translating ICE to machine code.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceTranslator.h"
 
 #include "IceDefs.h"
 #include "IceCfg.h"
 #include "IceClFlags.h"
 #include "IceGlobalInits.h"
 #include "IceTargetLowering.h"
 
 #include <utility>
 
 namespace Ice {
 
+class CfgOptWorkItem final : public OptWorkItem {
+  CfgOptWorkItem() = delete;
+  CfgOptWorkItem(const CfgOptWorkItem &) = delete;
+  CfgOptWorkItem &operator=(const CfgOptWorkItem &) = delete;
+
+public:
+  CfgOptWorkItem(std::unique_ptr<Cfg> Func) : Func(std::move(Func)) {}
+  std::unique_ptr<Cfg> getParsedCfg() override { return std::move(Func); }
+  ~CfgOptWorkItem() override = default;
+
+private:
+  std::unique_ptr<Ice::Cfg> Func;
+};
+
 Translator::Translator(GlobalContext *Ctx)
     : Ctx(Ctx), NextSequenceNumber(GlobalContext::getFirstSequenceNumber()),
       ErrorStatus() {}
 
 std::string Translator::createUnnamedName(const std::string &Prefix,
                                           SizeT Index) {
   if (Index == 0)
     return Prefix;
   std::string Buffer;
   llvm::raw_string_ostream StrBuf(Buffer);
@@ skipping 13 matching lines @@
     OstreamLocker L(Ctx);
     Ostream &Stream = Ctx->getStrDump();
     Stream << "Warning : Default " << Kind << " prefix '" << Prefix
            << "' potentially conflicts with name '" << Name << "'.\n";
     return true;
   }
   return false;
 }
 
 void Translator::translateFcn(std::unique_ptr<Cfg> Func) {
-  Ctx->optQueueBlockingPush(std::move(Func));
+  Ctx->optQueueBlockingPush(makeUnique<CfgOptWorkItem>(std::move(Func)));
 }
 
 void Translator::lowerGlobals(
     std::unique_ptr<VariableDeclarationList> VariableDeclarations) {
   Ctx->emitQueueBlockingPush(makeUnique<EmitterWorkItem>(
       getNextSequenceNumber(), std::move(VariableDeclarations)));
 }
 
 } // end of namespace Ice