[lli] Handle SIGSEGV in Jit'ed code more gracefully.

[davide]

Summary

Before, this just crashed lli. Now, instead, SIGSEGV is intercepted and an error message is emitted.
*TODO: test on windows (the signal interface seems to be the same, but I haven't a machine to try on ATM.
Fixes https://llvm.org/bugs/show_bug.cgi?id=30650

[filcab]

Replying to your email:

As the only pieces of code we're interested into are the RunFunction()
bits, we can (maybe) move this logic to ExecutionEngine or delete the
signal handler via SIG_DFL after runFunction() is executed. How does
that feel?

Portability is the thing that will bite us here. If the systems "we care about" support sigaction, then we can save the old one when we install our handler. Then, on a handler call, we:
check if we're in JIT'ed code (is this feasible?)
If so, error and quit(?)
Else: forward to "old" handler (if there wasn't any, we'll probably abort anyway).

But given that this is for JIT'ed code, maybe we should go for less flexible and simpler: Have a way to have llvm *not* install a SEGV handler. If the program doesn't want us to handle, they can avoid it. Otherwise, they'll be stuck with us exiting the program.
Then, if someone files for additional features, we'll think about that and maybe accomodate.

I think the second, simpler, version might be best for now.

tools/lli/lli.cpp

364

SEGV can come from anywhere, not necessarily JIT'ed code.

[rnk]

I don't see much value to installing a signal handler that exits. The kernel does that for you and even gives a helpful exit code that the shell will interprept and print "Segmentation fault" for you. This also fights with LLVM's existing pretty stack trace functionality.

[davide]

In D26809#599063, @rnk wrote:

I don't see much value to installing a signal handler that exits. The kernel does that for you and even gives a helpful exit code that the shell will interprept and print "Segmentation fault" for you. This also fights with LLVM's existing pretty stack trace functionality.

Fair enough. Will close the bug as RESOLVED/WONTFIX.

include/llvm/Support/Process.h

GetArgumentVector(SmallVectorImpl<const char *> &Args,
                     SpecificBumpPtrAllocator<char> &ArgAllocator);
 
   // This functions ensures that the standard file descriptors (input, output,
   // and error) are properly mapped to a file descriptor before we use any of
   // them.  This should only be called by standalone programs, library
   // components should not call this.
   static std::error_code FixupStandardFileDescriptors();
 
+  // This function sets a signal handler for SIGSEGV.
+  static void setSIGSEGVHandler(void (*handler)(int));
+
   // This function safely closes a file descriptor.  It is not safe to retry
   // close(2) when it returns with errno equivalent to EINTR; this is because
   // *nixen cannot agree if the file descriptor is, in fact, closed when this
   // occurs.
   //
   // N.B. Some operating systems, due to thread cancellation, cannot properly
   // guarantee that it will or will not be closed one way or the other!
   static std::error_code SafelyCloseFileDescriptor(int FD);

lib/Support/Unix/Process.inc

for (int StandardFD : StandardFDs) {
     if (NullFD == StandardFD)
       FDC.keepOpen();
     else if (dup2(NullFD, StandardFD) < 0)
       return std::error_code(errno, std::generic_category());
   }
   return std::error_code();
 }
 
+void Process::setSIGSEGVHandler(void (*handler)(int)) {
+  signal(SIGSEGV, handler);
+}
+
 std::error_code Process::SafelyCloseFileDescriptor(int FD) {
   // Create a signal set filled with *all* signals.
   sigset_t FullSet;
   if (sigfillset(&FullSet) < 0)
     return std::error_code(errno, std::generic_category());
   // Atomically swap our current signal mask with a full mask.
   sigset_t SavedSet;
 #if LLVM_ENABLE_THREADS

lib/Support/Windows/Process.inc

Process::GetArgumentVector(SmallVectorImpl<const char *> &Args,
   LocalFree(UnicodeCommandLine);
   return ec;
 }
 
 std::error_code Process::FixupStandardFileDescriptors() {
   return std::error_code();
 }
 
+// FIXME: just a stub for now.
+void Process::setSIGSEGVHandler(void (*handler)(int)) {}
+
 std::error_code Process::SafelyCloseFileDescriptor(int FD) {
   if (::close(FD) < 0)
     return std::error_code(errno, std::generic_category());
   return std::error_code();
 }
 
 bool Process::StandardInIsUserInput() {
   return FileDescriptorIsDisplayed(0);

tools/lli/lli.cpp

CodeGenOpt::Level getOptLevel() {
   case '1': return CodeGenOpt::Less;
   case ' ':
   case '2': return CodeGenOpt::Default;
   case '3': return CodeGenOpt::Aggressive;
   }
   llvm_unreachable("Unrecognized opt level.");
 }
 
+void segfaultHandler(int arg0) {
+  // FIXME: is llvm::errs() signal-safe? If not,
+  // maybe we should just set a flag and return/exit
+  // in the main loop.
+  llvm::errs() << "SIGSEGV in JIT'ed code\n";
+  exit(1);
+}
+
 //===----------------------------------------------------------------------===//
 // main Driver function
 //
 int main(int argc, char **argv, char * const *envp) {
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
 
   atexit(llvm_shutdown); // Call llvm_shutdown() on exit.
 
+  // We can have undefined behaviour in JIT'ed code, e.g.
+  // unreachable, and that causes lli to crash. Try to
+  // instead intercept the signal and output a sane diagnostic.
+  sys::Process::setSIGSEGVHandler(segfaultHandler);
+
   if (argc > 1)
     ExitOnErr.setBanner(std::string(argv[0]) + ": ");
 
   // If we have a native target, initialize it to ensure it is linked in and
   // usable by the JIT.
   InitializeNativeTarget();
   InitializeNativeTargetAsmPrinter();
   InitializeNativeTargetAsmParser();