Fix error reporting in the PNaCl bitcode reader.

lib/Bitcode/NaCl/TestUtils/NaClBitcodeMunge.cpp

 //===--- Bitcode/NaCl/TestUtils/NaClBitcodeMunge.cpp - Bitcode Munger -----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Bitcode writer/munger implementation for testing.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Bitcode/NaCl/NaClBitcodeMunge.h"
 
 #include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeParser.h"
 #include "llvm/Bitcode/NaCl/NaClBitstreamWriter.h"
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <memory>
 
 using namespace llvm;
 
 // For debugging. When true, shows each PNaCl record that is
 // emitted to the bitcode file.
 static bool DebugEmitRecord = false;
 
-bool NaClBitcodeMunger::runTestWithFlags(
-    const char *Name, const uint64_t Munges[], size_t MungesSize,
-    bool AddHeader, bool NoRecords, bool NoAssembly) {
-  assert(DumpStream == NULL && "Test run with DumpStream already defined");
+void NaClBitcodeMunger::setupTest(
+    const char *TestName, const uint64_t Munges[], size_t MungesSize,
+    bool AddHeader) {
+  assert(DumpStream == nullptr && "Test run with DumpStream already defined");
+  assert(MungedInput == nullptr && "Test run with MungedInput already defined");
   FoundErrors = false;
   DumpResults.clear(); // Throw away any previous results.
   std::string DumpBuffer;
-  raw_string_ostream MungedDumpStream(DumpResults);
-  DumpStream = &MungedDumpStream;
+  DumpStream = new raw_string_ostream(DumpResults);
   SmallVector<char, 0> StreamBuffer;
   StreamBuffer.reserve(256*1024);
   NaClBitstreamWriter OutStream(StreamBuffer);
   Writer = &OutStream;
 
   if (DebugEmitRecord) {
-    errs() << "*** Run test: " << Name << "\n";
+    errs() << "*** Run test: " << TestName << "\n";
   }
 
   WriteBlockID = -1;
   SetBID = -1;
   writeMungedData(Munges, MungesSize, AddHeader);
 
   std::string OutBuffer;
   raw_string_ostream BitcodeStrm(OutBuffer);
   for (SmallVectorImpl<char>::const_iterator
            Iter = StreamBuffer.begin(), IterEnd = StreamBuffer.end();
        Iter != IterEnd; ++Iter) {
     BitcodeStrm << *Iter;
   }
+  MungedInput = MemoryBuffer::getMemBufferCopy(BitcodeStrm.str(), TestName);
+}
 
-  std::unique_ptr<MemoryBuffer> Input(
-      MemoryBuffer::getMemBufferCopy(BitcodeStrm.str(), Name));
-  if (NaClObjDump(Input.get(), *DumpStream, NoRecords, NoAssembly))
-    FoundErrors = true;
-  DumpStream = NULL;
-  Writer = NULL;
-  MungedDumpStream.flush();
-  return !FoundErrors;
+void NaClBitcodeMunger::cleanupTest() {
+  delete MungedInput;
+  MungedInput = nullptr;
+  assert(DumpStream && "Dump stream removed before cleanup!");
+  DumpStream->flush();
+  delete DumpStream;
+  DumpStream = nullptr;
+  Writer = nullptr;
 }
 
 // Return the next line of input (including eoln), starting from
 // Pos. Then increment Pos past the end of that line.
 static std::string getLine(const std::string &Input, size_t &Pos) {
   std::string Line;
   if (Pos >= Input.size()) {
     Pos = std::string::npos;
     return Line;
   }
@@ skipping 252 matching lines @@
       break;
     }
     default:
       Fatal() << "Error: Bad literal flag in abbreviation. Found: "
               << Values[Index];
       ReportFatalError();
     }
   }
   return Abbrev;
 }
+
+bool NaClObjDumpMunger::runTestWithFlags(
+    const char *Name, const uint64_t Munges[], size_t MungesSize,
+    bool AddHeader, bool NoRecords, bool NoAssembly) {
+  setupTest(Name, Munges, MungesSize, AddHeader);
+  if (NaClObjDump(MungedInput, *DumpStream, NoRecords, NoAssembly))
+    FoundErrors = true;
+  cleanupTest();
+  return !FoundErrors;
+}
+
+bool NaClParseBitcodeMunger::runTest(
+    const char *Name, const uint64_t Munges[], size_t MungesSize,
+    bool VerboseErrors) {
+  bool AddHeader = true;
+  setupTest(Name, Munges, MungesSize, AddHeader);
+  LLVMContext &Context = getGlobalContext();
+  raw_ostream *VerboseStrm = VerboseErrors ? DumpStream : nullptr;
+  ErrorOr<Module *> ModuleOrError =
+      NaClParseBitcodeFile(MungedInput, Context, VerboseStrm);
+  if (ModuleOrError) {
+    delete ModuleOrError.get();
+    if (VerboseErrors)
+      *DumpStream << "Successful parse!\n";
+    // If there was a successful parse, MungedInput was deleted by the
+    // parser. Hence, we null it out here so that cleanupTest doesn't
+    // double delete it.
+    MungedInput = nullptr;
+  } else {
+    Error() << ModuleOrError.getError().message() << "\n";
+  }
+  cleanupTest();
+  return !FoundErrors;
+}