Report fatal translator errors to the browser

tools/pnacl-llc/pnacl-llc.cpp

 //===-- pnacl-llc.cpp - PNaCl-specific llc: pexe ---> nexe  ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // pnacl-llc: the core of the PNaCl translator, compiling a pexe into a nexe.
@@ skipping 10 matching lines @@
 #include "llvm/CodeGen/LinkAllCodegenComponents.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Pass.h"
 #include "llvm/PassManager.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Target/TargetLibraryInfo.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/NaCl.h"
 #include <memory>
 
 
 using namespace llvm;
 
 // NOTE: When __native_client__ is defined it means pnacl-llc is built as a
 // sandboxed translator (from pnacl-llc.pexe to pnacl-llc.nexe). In this mode
 // it uses SRPC operations instead of direct OS intefaces.
 #if defined(__native_client__)
 int srpc_main(int argc, char **argv);
 int getObjectFileFD();
 DataStreamer *getNaClBitcodeStreamer();
+fatal_error_handler_t getSRPCErrorHandler();
 #endif
 
 cl::opt<NaClFileFormat>
 InputFileFormat(
     "bitcode-format",
     cl::desc("Define format of input file:"),
     cl::values(
         clEnumValN(LLVMFormat, "llvm", "LLVM file (default)"),
         clEnumValN(PNaClFormat, "pnacl", "PNaCl bitcode file"),
         clEnumValEnd),
@@ skipping 143 matching lines @@
 int llc_main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
 
   // Enable debug stream buffering.
   EnableDebugBuffering = true;
 
   LLVMContext &Context = getGlobalContext();
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 
+#if defined(__native_client__)
+  install_fatal_error_handler(getSRPCErrorHandler(), NULL);
+#endif
+
   // Initialize targets first, so that --version shows registered targets.
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
 #if !defined(__native_client__)
   // Prune asm parsing from sandboxed translator.
   // Do not prune "AsmPrinters" because that includes
   // the direct object emission.
   InitializeAllAsmParsers();
 #endif
@@ skipping 17 matching lines @@
 #endif
 
   cl::ParseCommandLineOptions(argc, argv, "pnacl-llc\n");
 
   return compileModule(argv[0], Context);
 }
 
 static void CheckABIVerifyErrors(PNaClABIErrorReporter &Reporter,
                                  const Twine &Name) {
   if (PNaClABIVerify && Reporter.getErrorCount() > 0) {
-    errs() << (PNaClABIVerifyFatalErrors ? "ERROR: " : "WARNING: ");
-    errs() << Name << " is not valid PNaCl bitcode:\n";
-    Reporter.printErrors(errs());
-    if (PNaClABIVerifyFatalErrors)
-      exit(1);
+    std::string errors;
+    raw_string_ostream os(errors);
+    os << (PNaClABIVerifyFatalErrors ? "ERROR: " : "WARNING: ");
+    os << Name << " is not valid PNaCl bitcode:\n";
+    Reporter.printErrors(os);
+    if (PNaClABIVerifyFatalErrors) {
+      report_fatal_error(os.str());
+    }
+    errs() << os.str();
   }
   Reporter.reset();
 }
 
 static int compileModule(StringRef ProgramName, LLVMContext &Context) {
   // Load the module to be compiled...
   SMDiagnostic Err;
   std::auto_ptr<Module> M;
   Module *mod = 0;
   Triple TheTriple;
 
   PNaClABIErrorReporter ABIErrorReporter;
 
 #if defined(__native_client__)
   if (LazyBitcode) {
     std::string StrError;
+    std::string DisplayFilename("<PNaCl-translated pexe>");
     M.reset(getNaClStreamedBitcodeModule(
-        std::string("<SRPC stream>"),
+        DisplayFilename,
         getNaClBitcodeStreamer(), Context, &StrError));
     if (!StrError.empty())
-      Err = SMDiagnostic(InputFilename, SourceMgr::DK_Error, StrError);
+      Err = SMDiagnostic(DisplayFilename, SourceMgr::DK_Error, StrError);
   } else {
     llvm_unreachable("native client SRPC only supports streaming");
   }
 #else
   M.reset(NaClParseIRFile(InputFilename, InputFileFormat, Err, Context));
 #endif // __native_client__
 
   mod = M.get();
   if (mod == 0) {
+#if defined(__native_client__)
+    report_fatal_error(Err.getMessage());
+#else
+    // Err.print is prettier, so use it for the non-sandboxed translator.
     Err.print(ProgramName.data(), errs());
     return 1;
+#endif
   }
 
   if (PNaClABIVerify) {
     // Verify the module (but not the functions yet)
     ModulePass *VerifyPass = createPNaClABIVerifyModulePass(&ABIErrorReporter,
                                                             LazyBitcode);
     VerifyPass->runOnModule(*mod);
     CheckABIVerifyErrors(ABIErrorReporter, "Module");
   }
 
@@ skipping 175 matching lines @@
   return 0;
 }
 
 int main(int argc, char **argv) {
 #if defined(__native_client__)
   return srpc_main(argc, argv);
 #else
   return llc_main(argc, argv);
 #endif // __native_client__
 }