Bugpoint support for miscompilations that result in a crash.

This change allows bugpoint to pinpoint the "opt" pass and bitcode
segment responsible for a crash caused by miscompilation. At least it
works well for me now, without having to create any custom execution
wrappers.

llvm-svn: 131186

llvm/include/llvm/Support/Program.h

@@ -96,9 +96,11 @@ namespace sys {
       ///< expires, the child is killed and this call returns. If zero,
       ///< this function will wait until the child finishes or forever if
       ///< it doesn't.
-      std::string* ErrMsg ///< If non-zero, provides a pointer to a string
+      std::string* ErrMsg, ///< If non-zero, provides a pointer to a string
       ///< instance in which error messages will be returned. If the string
       ///< is non-empty upon return an error occurred while waiting.
+      const char *SignalPrefix ///< If non-zero, provides a prefix to be
+      ///< prepended to ErrMsg if the process is terminated abnormally.
       );
 
     /// This function terminates the program.
@@ -137,7 +139,8 @@ namespace sys {
                               const sys::Path** redirects = 0,
                               unsigned secondsToWait = 0,
                               unsigned memoryLimit = 0,
-                              std::string* ErrMsg = 0);
+                              std::string* ErrMsg = 0,
+                              const char *SignalPrefix = 0);
 
     /// A convenience function equivalent to Program prg; prg.Execute(..);
     /// @see Execute

llvm/lib/Support/Program.cpp

@@ -28,10 +28,11 @@ Program::ExecuteAndWait(const Path& path,
                         const Path** redirects,
                         unsigned secondsToWait,
                         unsigned memoryLimit,
-                        std::string* ErrMsg) {
+                        std::string* ErrMsg,
+                        const char* SignalPrefix) {
   Program prg;
   if (prg.Execute(path, args, envp, redirects, memoryLimit, ErrMsg))
-    return prg.Wait(path, secondsToWait, ErrMsg);
+    return prg.Wait(path, secondsToWait, ErrMsg, SignalPrefix);
   else
     return -1;
 }

llvm/lib/Support/Unix/Program.inc

@@ -298,7 +298,8 @@ Program::Execute(const Path &path, const char **args, const char **envp,
 int
 Program::Wait(const sys::Path &path,
               unsigned secondsToWait,
-              std::string* ErrMsg)
+              std::string* ErrMsg,
+              const char* SignalPrefix)
 {
 #ifdef HAVE_SYS_WAIT_H
   struct sigaction Act, Old;
@@ -376,7 +377,9 @@ Program::Wait(const sys::Path &path,
     }
   } else if (WIFSIGNALED(status)) {
     if (ErrMsg) {
-      *ErrMsg = strsignal(WTERMSIG(status));
+      if (SignalPrefix)
+        *ErrMsg = SignalPrefix;
+      *ErrMsg += strsignal(WTERMSIG(status));
 #ifdef WCOREDUMP
       if (WCOREDUMP(status))
         *ErrMsg += " (core dumped)";

llvm/tools/bugpoint/ExecutionDriver.cpp

@@ -475,7 +475,7 @@ bool BugDriver::createReferenceFile(Module *M, const std::string &Filename) {
 /// diffProgram - This method executes the specified module and diffs the
 /// output against the file specified by ReferenceOutputFile.  If the output
 /// is different, 1 is returned.  If there is a problem with the code
-/// generator (e.g., llc crashes), this will return -1 and set Error.
+/// generator (e.g., llc crashes), this will set ErrMsg.
 ///
 bool BugDriver::diffProgram(const Module *Program,
                             const std::string &BitcodeFile,

llvm/tools/bugpoint/Miscompilation.cpp

@@ -624,9 +624,10 @@ DebugAMiscompilation(BugDriver &BD,
   if (!BugpointIsInterrupted)
     ReduceMiscompilingFunctions(BD, TestFn).reduceList(MiscompiledFunctions,
                                                        Error);
-  if (!Error.empty())
+  if (!Error.empty()) {
+    errs() << "\n***Cannot reduce functions: ";
     return MiscompiledFunctions;
-
+  }
   outs() << "\n*** The following function"
          << (MiscompiledFunctions.size() == 1 ? " is" : "s are")
          << " being miscompiled: ";

llvm/tools/bugpoint/ToolRunner.cpp

@@ -50,6 +50,11 @@ namespace {
           cl::desc("Remote execution (rsh/ssh) extra options"));
 }
 
+// Add a prefix to ErrMsg if the program is terminated by a signal to
+// distinguish compiled program crashes from other execution
+// failures. Miscompilation likely to results in SIGSEGV.
+static const char *SignalPrefix = "Signal - ";
+
 /// RunProgramWithTimeout - This function provides an alternate interface
 /// to the sys::Program::ExecuteAndWait interface.
 /// @see sys::Program::ExecuteAndWait
@@ -77,7 +82,7 @@ static int RunProgramWithTimeout(const sys::Path &ProgramPath,
 
   return
     sys::Program::ExecuteAndWait(ProgramPath, Args, 0, redirects,
-                                 NumSeconds, MemoryLimit, ErrMsg);
+                                 NumSeconds, MemoryLimit, ErrMsg, SignalPrefix);
 }
 
 /// RunProgramRemotelyWithTimeout - This function runs the given program
@@ -854,9 +859,18 @@ int GCC::ExecuteProgram(const std::string &ProgramFile,
 
   if (RemoteClientPath.isEmpty()) {
     DEBUG(errs() << "<run locally>");
-    return RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
+    int ExitCode = RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
         sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
         Timeout, MemoryLimit, Error);
+    // Treat a signal (usually SIGSEGV) as part of the program output so that
+    // crash-causing miscompilation is handled seamlessly.
+    if (Error->find(SignalPrefix) == 0) {
+      std::ofstream outFile(OutputFile.c_str(), std::ios_base::app);
+      outFile << *Error << '\n';
+      outFile.close();
+      Error->clear();
+    }
+    return ExitCode;
   } else {
     outs() << "<run remotely>"; outs().flush();
     return RunProgramRemotelyWithTimeout(sys::Path(RemoteClientPath),