Make function readNaClRecordTextAndBuildBitcode public.

lib/Bitcode/NaCl/TestUtils/NaClBitcodeTextReader.cpp

 //===- NaClBitcodeTextReader.cpp - Read texual bitcode record list --------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Implements bitcode reader from textual form.
@@ skipping 207 matching lines @@
           break;
         }
         Records.push_back(make_unique<NaClBitcodeAbbrevRecord>(
             Abbrev, Code, Values));
         return std::error_code();
       }
     }
   }
 }
 
-// Read textual bitcode records from Filename, and fill Buffer with
-// corresponding bitcode. Return error_code describing success of
-// read.  Verbose (if not nullptr) is used to generate more human
-// readable error messages than the text in the returned error
-// message.
-static std::error_code ReadRecordTextAndBuildBitcode(
-    StringRef Filename, SmallVectorImpl<char> &Buffer,
-    raw_ostream *Verbose = nullptr) {
+} // end of anonymous namespace
+
+std::error_code llvm::readNaClRecordTextAndBuildBitcode(
+    StringRef Filename, SmallVectorImpl<char> &Buffer, raw_ostream *Verbose) {
   // Open the input file with text records.
   ErrorOr<std::unique_ptr<MemoryBuffer>>
       MemBuf(MemoryBuffer::getFileOrSTDIN(Filename));
   if (!MemBuf)
     return MemBuf.getError();
 
   // Read in the bitcode text records.
   std::unique_ptr<NaClBitcodeRecordList> Records(new NaClBitcodeRecordList());
   if (std::error_code EC =
       readNaClTextBcRecordList(*Records, std::move(MemBuf.get())))
     return EC;
 
   // Write out the records into Buffer.
   NaClMungedBitcode Bitcode(std::move(Records));
   NaClMungedBitcode::WriteFlags Flags;
   if (Verbose)
     Flags.setErrStream(*Verbose);
   bool AddHeader = true;
   if (!Bitcode.write(Buffer, AddHeader)) {
     return std::error_code(UnableToWriteBitcode,
                            ReaderErrorCategoryType());
   }
   return std::error_code();
 }
 
-} // end of anonymous namespace
-
 std::error_code llvm::readNaClTextBcRecordList(
     NaClBitcodeRecordList &RecordList,
     std::unique_ptr<MemoryBuffer> InputBuffer) {
   TextRecordParser Parser(RecordList, InputBuffer.get());
   return Parser.read();
 }
 
 llvm::ErrorOr<llvm::Module *>
 llvm::parseNaClBitcodeText(const std::string &Filename, LLVMContext &Context,
                            raw_ostream *Verbose) {
   SmallVector<char, 1024> Buffer;
 
   // Fill Buffer with corresponding bitcode records from Filename.
   if (std::error_code EC =
-      ReadRecordTextAndBuildBitcode(Filename, Buffer, Verbose))
+      readNaClRecordTextAndBuildBitcode(Filename, Buffer, Verbose))
     return EC;
 
   // Parse buffer as ordinary binary bitcode file.
   StringRef BitcodeBuffer(Buffer.data(),  Buffer.size());
   MemoryBufferRef MemBufRef(BitcodeBuffer, Filename);
   return NaClParseBitcodeFile(MemBufRef, Context, Verbose);
 }