Add ability to test parsing of bitcode records in Subzero.

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 19 matching lines @@
 #include "IceGlobalInits.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "PNaClTranslator.h"
 
 #include <memory>
 
 namespace {
 using namespace llvm;
 
-// TODO(kschimpf) Remove error recovery once implementation complete.
-static cl::opt<bool> AllowErrorRecovery(
-    "allow-pnacl-reader-error-recovery",
-    cl::desc("Allow error recovery when reading PNaCl bitcode."),
-    cl::init(false));
-
 // 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(const ExtendedType &Ty) = delete;
   ExtendedType &operator=(const ExtendedType &Ty) = delete;
 public:
   /// Discriminator for LLVM-style RTTI.
@@ skipping 377 matching lines @@
 
   // 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;
   ++NumErrors;
   NaClBitcodeParser::Error(Message);
-  if (!AllowErrorRecovery)
+  if (!Translator.getFlags().AllowErrorRecovery)
     report_fatal_error("Unable to continue");
   return true;
 }
 
 void TopLevelParser::reportBadTypeIDAs(unsigned ID, const ExtendedType *Ty,
                                        ExtendedType::TypeKind WantedType) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   if (Ty == nullptr) {
     StrBuf << "Can't find extended type for type id: " << ID;
@@ skipping 151 matching lines @@
 }
 
 // Generates an error Message with the bit address prefixed to it.
 bool BlockParserBaseClass::Error(const std::string &Message) {
   uint64_t Bit = Record.GetStartBit() + Context->getHeaderSize() * 8;
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "(" << format("%" PRIu64 ":%u", (Bit / 8),
                           static_cast<unsigned>(Bit % 8)) << ") ";
   // Note: If dump routines have been turned off, the error messages
-  // will not be readable. Hence, replace with simple error.
-  if (ALLOW_DUMP)
+  // will not be readable. Hence, replace with simple error. We also
+  // use the simple form for unit tests.
+  if (ALLOW_DUMP && !getFlags().GenerateUnitTestMessages) {
     StrBuf << Message;
-  else {
+  } else {
     StrBuf << "Invalid " << getBlockName() << " record: <" << Record.GetCode();
     for (const uint64_t Val : Record.GetValues()) {
       StrBuf << " " << Val;
     }
     StrBuf << ">";
   }
   return Context->Error(StrBuf.str());
 }
 
 void BlockParserBaseClass::ReportRecordSizeError(unsigned ExpectedSize,
@@ skipping 2331 matching lines @@
 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;
     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;
     return;
   }
 
   const unsigned char *BufPtr = (const unsigned char *)MemBuf->getBufferStart();
   const unsigned char *EndBufPtr = BufPtr + MemBuf->getBufferSize();
 
@@ skipping 21 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice