[llvm-exegesis] Add explicit error for segmenetation faults

[aidengrossman]

Summary

When benchmarking certain snippets that access memory, segmentation
faults are a very real possibility if the memory annotations are not
perfect. These situtations are currently difficult to debug as there is
no indication of which addresses need to be mapped. This patch adds in
support for printing the address a segmentation fault occurred at to
make it easier to gather this information.

[aidengrossman]

I've structured this as a different class of error rather than as a SnippetCrash with the address inside a string as I intend to use this in a downstream basic block annotator application and need programatic access to the address at which the segmentation fault occurred.

[aidengrossman]

Bump on this when reviewers have a chance. Thanks!

[courbet]

It looks like we'll have to implement such an escape for any crash type that client code wants to handle. Have you considered keeping only SnipetCrash, but storing si_signo and si_addr there ?

[courbet]

Or maybe even the whole siginfo_t actually.

[aidengrossman]

Closed in favor of https://github.com/llvm/llvm-project/pull/72774.

llvm/test/tools/llvm-exegesis/X86/latency/subprocess-segfault.s

 # REQUIRES: exegesis-can-measure-latency, x86_64-linux
 
 # RUN: llvm-exegesis -mtriple=x86_64-unknown-unknown -mode=latency -snippets-file=%s -execution-mode=subprocess | FileCheck %s
 
-# CHECK: error:           'The benchmarking subprocess sent unexpected signal: Segmentation fault'
+# CHECK: error:           A segmentation fault occurred at address 20000
 
-# LLVM-EXEGESIS-DEFREG RBX 0
+# LLVM-EXEGESIS-DEFREG RBX 20000
 movq (%rbx), %rax

llvm/tools/llvm-exegesis/lib/BenchmarkRunner.cpp

 //===-- BenchmarkRunner.cpp -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
Error createSubProcessAndRunBenchmark(
     // An error was encountered running the snippet, process it
     siginfo_t ChildSignalInfo;
     if (ptrace(PTRACE_GETSIGINFO, ParentOrChildPID, NULL, &ChildSignalInfo) ==
         -1) {
       return make_error<Failure>("Getting signal info from the child failed: " +
                                  Twine(strerror(errno)));
     }
 
+    if (ChildSignalInfo.si_signo == SIGSEGV)
+      return make_error<SnippetSegfaultCrash>(ChildSignalInfo.si_addr);
+
     return make_error<SnippetCrash>(
         "The benchmarking subprocess sent unexpected signal: " +
         Twine(strsignal(ChildSignalInfo.si_signo)));
   }
 
   [[noreturn]] void prepareAndRunBenchmark(int Pipe,
                                            const BenchmarkKey &Key) const {
     // The following occurs within the benchmarking subprocess
Expected<Benchmark> BenchmarkRunner::runConfiguration(
 
   Expected<std::unique_ptr<BenchmarkRunner::FunctionExecutor>> Executor =
       createFunctionExecutor(std::move(ObjectFile), RC.InstrBenchmark.Key);
   if (!Executor)
     return Executor.takeError();
   auto NewMeasurements = runMeasurements(**Executor);
 
   if (Error E = NewMeasurements.takeError()) {
-    if (!E.isA<SnippetCrash>())
+    if (!E.isA<SnippetCrash>() && !E.isA<SnippetSegfaultCrash>())
       return std::move(E);
     InstrBenchmark.Error = toString(std::move(E));
     return std::move(InstrBenchmark);
   }
   assert(InstrBenchmark.NumRepetitions > 0 && "invalid NumRepetitions");
   for (BenchmarkMeasure &BM : *NewMeasurements) {
     // Scale the measurements by instruction.
     BM.PerInstructionValue /= InstrBenchmark.NumRepetitions;

llvm/tools/llvm-exegesis/lib/Error.h

 //===-- Error.h -------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
public:
   void log(raw_ostream &OS) const override;
 
   std::error_code convertToErrorCode() const override;
 
 private:
   std::string Msg;
 };
 
+// A class representing segmentation faults specifically. Holds information
+// about where specifically the segmentation fault occurred.
+class SnippetSegfaultCrash : public ErrorInfo<SnippetSegfaultCrash> {
+public:
+  static char ID;
+  SnippetSegfaultCrash(const void *Addr) : Address((intptr_t)Addr) {}
+
+  void log(raw_ostream &OS) const override;
+
+  std::error_code convertToErrorCode() const override;
+
+private:
+  intptr_t Address;
+};
+
 } // namespace exegesis
 } // namespace llvm
 
 #endif

llvm/tools/llvm-exegesis/lib/Error.cpp

 //===-- Error.cpp -----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 char SnippetCrash::ID;
 
 void SnippetCrash::log(raw_ostream &OS) const { OS << Msg; }
 
 std::error_code SnippetCrash::convertToErrorCode() const {
   return inconvertibleErrorCode();
 }
 
+char SnippetSegfaultCrash::ID;
+
+void SnippetSegfaultCrash::log(raw_ostream &OS) const {
+  OS << "A segmentation fault occurred at address " + Twine::utohexstr(Address);
+}
+
+std::error_code SnippetSegfaultCrash::convertToErrorCode() const {
+  return inconvertibleErrorCode();
+}
+
 } // namespace exegesis
 } // namespace llvm