Subzero: Initial implementation of multithreaded translation.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the PNaCl bitcode file to Ice, to machine code
@@ skipping 14 matching lines @@
 #include "IceAPFloat.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceGlobalInits.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "PNaClTranslator.h"
 
-#include <memory>
-
 namespace {
 using namespace llvm;
 
 // Models elements in the list of types defined in the types block.
 // These elements can be undefined, a (simple) type, or a function type
 // signature. Note that an extended type is undefined on construction.
 // Use methods setAsSimpleType and setAsFuncSigType to define
 // the extended type.
 class ExtendedType {
   ExtendedType &operator=(const ExtendedType &Ty) = delete;
@@ skipping 108 matching lines @@
 
 // Top-level class to read PNaCl bitcode files, and translate to ICE.
 class TopLevelParser : public NaClBitcodeParser {
   TopLevelParser(const TopLevelParser &) = delete;
   TopLevelParser &operator=(const TopLevelParser &) = delete;
 
 public:
   typedef std::vector<Ice::FunctionDeclaration *> FunctionDeclarationListType;
 
   TopLevelParser(Ice::Translator &Translator, NaClBitcodeHeader &Header,
-                 NaClBitstreamCursor &Cursor, bool &ErrorStatus)
+                 NaClBitstreamCursor &Cursor, std::error_code &ErrorStatus)
       : NaClBitcodeParser(Cursor), Translator(Translator), Header(Header),
         ErrorStatus(ErrorStatus), NumErrors(0), NumFunctionIds(0),
         NumFunctionBlocks(0), BlockParser(nullptr) {}
 
   ~TopLevelParser() override {}
 
   Ice::Translator &getTranslator() { return Translator; }
 
   void setBlockParser(BlockParserBaseClass *NewBlockParser) {
     BlockParser = NewBlockParser;
@@ skipping 182 matching lines @@
   const Ice::Translator::VariableDeclarationListType &getGlobalVariables() {
     return VariableDeclarations;
   }
 
 private:
   // The translator associated with the parser.
   Ice::Translator &Translator;
   // The bitcode header.
   NaClBitcodeHeader &Header;
   // The exit status that should be set to true if an error occurs.
-  bool &ErrorStatus;
+  std::error_code &ErrorStatus;
   // The number of errors reported.
   unsigned NumErrors;
   // The types associated with each type ID.
   std::vector<ExtendedType> TypeIDValues;
   // The set of functions.
   FunctionDeclarationListType FunctionDeclarationList;
   // The set of global variables.
   Ice::Translator::VariableDeclarationListType VariableDeclarations;
   // Relocatable constants associated with global declarations.
   std::vector<Ice::Constant *> ValueIDConstants;
@@ skipping 42 matching lines @@
   // Reports that there is not global variable declaration for
   // ID. Returns an error recovery value to use.
   Ice::VariableDeclaration *reportGetGlobalVariableByIDError(unsigned Index);
 
   // Reports that there is no corresponding ICE type for LLVMTy, and
   // returns ICE::IceType_void.
   Ice::Type convertToIceTypeError(Type *LLVMTy);
 };
 
 bool TopLevelParser::Error(const std::string &Message) {
-  ErrorStatus = true;
+  ErrorStatus.assign(1, std::generic_category());
   ++NumErrors;
   Ice::GlobalContext *Context = Translator.getContext();
   Ice::OstreamLocker L(Context);
   raw_ostream &OldErrStream = setErrStream(Context->getStrDump());
   NaClBitcodeParser::Error(Message);
   setErrStream(OldErrStream);
   if (!Translator.getFlags().AllowErrorRecovery)
     report_fatal_error("Unable to continue");
   return true;
 }
@@ skipping 2373 matching lines @@
       ++NameIndex;
     } else {
       Trans.checkIfUnnamedNameSafe(Decl->getName(), Context, Prefix);
     }
   }
 
   bool ParseBlock(unsigned BlockID) override;
 
   void ExitBlock() override {
     InstallGlobalNamesAndGlobalVarInitializers();
-    getTranslator().emitConstants();
   }
 
   void ProcessRecord() override;
 };
 
 class ModuleValuesymtabParser : public ValuesymtabParser {
   ModuleValuesymtabParser(const ModuleValuesymtabParser &) = delete;
   void operator=(const ModuleValuesymtabParser &) = delete;
 
 public:
@@ skipping 112 matching lines @@
 
 } // end of anonymous namespace
 
 namespace Ice {
 
 void PNaClTranslator::translate(const std::string &IRFilename) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> ErrOrFile =
       MemoryBuffer::getFileOrSTDIN(IRFilename);
   if (std::error_code EC = ErrOrFile.getError()) {
     errs() << "Error reading '" << IRFilename << "': " << EC.message() << "\n";
-    ErrorStatus = true;
+    ErrorStatus.assign(1, std::generic_category());
     return;
   }
 
   std::unique_ptr<MemoryBuffer> MemBuf(ErrOrFile.get().release());
   translateBuffer(IRFilename, MemBuf.get());
 }
 
 void PNaClTranslator::translateBuffer(const std::string &IRFilename,
                                       MemoryBuffer *MemBuf) {
   if (MemBuf->getBufferSize() % 4 != 0) {
     errs() << IRFilename
            << ": Bitcode stream should be a multiple of 4 bytes in length.\n";
-    ErrorStatus = true;
+    ErrorStatus.assign(1, std::generic_category());
     return;
   }
 
   const unsigned char *BufPtr = (const unsigned char *)MemBuf->getBufferStart();
   const unsigned char *EndBufPtr = BufPtr + MemBuf->getBufferSize();
 
   // Read header and verify it is good.
   NaClBitcodeHeader Header;
   if (Header.Read(BufPtr, EndBufPtr) || !Header.IsSupported()) {
     errs() << "Invalid PNaCl bitcode header.\n";
-    ErrorStatus = true;
+    ErrorStatus.assign(1, std::generic_category());
     return;
   }
 
   // Create a bitstream reader to read the bitcode file.
   NaClBitstreamReader InputStreamFile(BufPtr, EndBufPtr);
   NaClBitstreamCursor InputStream(InputStreamFile);
 
   TopLevelParser Parser(*this, Header, InputStream, ErrorStatus);
   int TopLevelBlocks = 0;
   while (!InputStream.AtEndOfStream()) {
     if (Parser.Parse()) {
-      ErrorStatus = true;
+      ErrorStatus.assign(1, std::generic_category());
       return;
     }
     ++TopLevelBlocks;
   }
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
-    ErrorStatus = true;
+    ErrorStatus.assign(1, std::generic_category());
   }
 }
 
 } // end of namespace Ice