Install notion of diagnostic handler into PNaCl bitcode readers.

lib/IRReader/IRReader.cpp

 //===---- IRReader.cpp - Reader for LLVM IR files -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IRReader/IRReader.h"
@@ skipping 86 matching lines @@
 static NaClFileFormat NaClDoAutodetectFileFormat(
     NaClFileFormat Format, const char unsigned *StartBuffer,
     const char unsigned *EndBuffer) {
   if (Format != AutodetectFileFormat)
     return Format;
   if (isNaClBitcode(StartBuffer, EndBuffer))
     return PNaClFormat;
   return LLVMFormat;
 }
 
-std::unique_ptr<Module> llvm::NaClParseIR(MemoryBufferRef Buffer,
-                                          NaClFileFormat Format,
-                                          SMDiagnostic &Err,
-                                          raw_ostream *Verbose,
-                                          LLVMContext &Context) {
+std::unique_ptr<Module>
+llvm::NaClParseIR(MemoryBufferRef Buffer, NaClFileFormat Format,
+                  SMDiagnostic &Err, LLVMContext &Context,
+                  DiagnosticHandlerFunction DiagnosticHandler) {
   NamedRegionTimer T(TimeIRParsingName, TimeIRParsingGroupName,
                      TimePassesIsEnabled);
   Format = NaClDoAutodetectFileFormat(
       Format, (const unsigned char *)Buffer.getBufferStart(),
       (const unsigned char *)Buffer.getBufferEnd());
   if ((Format == PNaClFormat) &&
       isNaClBitcode((const unsigned char *)Buffer.getBufferStart(),
                     (const unsigned char *)Buffer.getBufferEnd())) {
     ErrorOr<Module *> ModuleOrErr =
-        NaClParseBitcodeFile(Buffer, Context, Verbose);
+        NaClParseBitcodeFile(Buffer, Context, DiagnosticHandler);
     if (std::error_code EC = ModuleOrErr.getError()) {
       Err = SMDiagnostic(Buffer.getBufferIdentifier(), SourceMgr::DK_Error,
                          EC.message());
       return nullptr;
     }
     return std::unique_ptr<Module>(ModuleOrErr.get());
   } else if (Format == LLVMFormat) {
     if (isBitcode((const unsigned char *)Buffer.getBufferStart(),
                   (const unsigned char *)Buffer.getBufferEnd())) {
-      ErrorOr<Module *> ModuleOrErr = parseBitcodeFile(Buffer, Context);
+      ErrorOr<Module *> ModuleOrErr =
+          parseBitcodeFile(Buffer, Context, DiagnosticHandler);
       if (std::error_code EC = ModuleOrErr.getError()) {
         Err = SMDiagnostic(Buffer.getBufferIdentifier(), SourceMgr::DK_Error,
                            EC.message());
         return nullptr;
       }
       return std::unique_ptr<Module>(ModuleOrErr.get());
     }
 
     return parseAssembly(Buffer, Err, Context);
   } else {
     Err = SMDiagnostic(Buffer.getBufferIdentifier(), SourceMgr::DK_Error,
                        "Did not specify correct format for file");
     return nullptr;
   }
 }
 
-std::unique_ptr<Module> llvm::NaClParseIRFile(StringRef Filename,
-                                              NaClFileFormat Format,
-                                              SMDiagnostic &Err,
-                                              raw_ostream *Verbose,
-                                              LLVMContext &Context) {
+std::unique_ptr<Module>
+llvm::NaClParseIRFile(StringRef Filename, NaClFileFormat Format,
+                      SMDiagnostic &Err, LLVMContext &Context,
+                      DiagnosticHandlerFunction DiagnosticHandler) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
   if (std::error_code EC = FileOrErr.getError()) {
     Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
                        "Could not open input file: " + EC.message());
     return nullptr;
   }
 
-  return NaClParseIR(FileOrErr.get()->getMemBufferRef(), Format, Err, Verbose,
-                     Context);
+  return NaClParseIR(FileOrErr.get()->getMemBufferRef(), Format, Err, Context,
+                     DiagnosticHandler);
 }
 
 // @LOCALMOD-END
 
 //===----------------------------------------------------------------------===//
 // C API.
 //===----------------------------------------------------------------------===//
 
 LLVMBool LLVMParseIRInContext(LLVMContextRef ContextRef,
                               LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM,
@@ skipping 12 matching lines @@
       Diag.print(nullptr, os, false);
       os.flush();
 
       *OutMessage = strdup(buf.c_str());
     }
     return 1;
   }
 
   return 0;
 }