[lldb/Target] Add Assert StackFrame Recognizer

[mib]

Summary

When a thread stops, this checks depending on the platform if the top frame is
an abort stack frame. If so, it looks for an assert stack frame in the upper
frames and set it as the most relavant frame when found.

To do so, the StackFrameRecognizer class holds a "Most Relevant Frame" and a
"cooked" stop reason description. When the thread is about to stop, it checks
if the current frame is recognized, and if so, it fetches the recognized frame's
attributes and applies them.

rdar://58528686

Signed-off-by: Med Ismail Bennani <[e-mail]>

[mib]

I'm sending this first implementation looking for feedbacks, it is not passing all the tests and will probably change in the near future.

[mib]

lldb/source/Target/AbortRecognizer.cpp

110

The tests failures happen because instead of returning a StopInfoUnixSignal for the abort, I changed it to StopInfoRecognizedFrame (inherited from StopInfoException) making the stop reason description not match with the previous tests.

Most of those tests check the stop reason against the command interpreter output rather than using the SBAPI, so they'll probably need to be rewritten anyway.

I'm already working on a new way to handle this while causing the least amount of failures, but all suggestions are welcome.

[JDevlieghere]

lldb/include/lldb/Target/AbortRecognizer.h

28

This doesn't really look much like a class with just two static member functions. Assuming that the Process is going to be the same for both, maybe store that as a member? Otherwise you might be better off having them as static functions in the implementation.

34

Although LLDB already has a lot of these markers, I don't think we want to add more of them. They're very specific to a single IDE available on a single platform :-)

lldb/include/lldb/Target/Thread.h

219

What does it mean to "apply" a frame? I think this needs a comment with some explanation or a better name.

lldb/source/Target/AbortRecognizer.cpp

26

Why does this need to return a ConstString?

36

Personally I'd return here:

return std::make_tuple(FileSpec(module_name), symbol_name);

which would make it possible to...

• get rid of the temporary std::strings,
• make the second element of the tuple just a StringRef.

[JDevlieghere]

lldb/source/Target/AbortRecognizer.cpp

52

Same comments as the previous method.

82

Magic value? Why 10?

[friss]

lldb/source/Target/AbortRecognizer.cpp

127–128

Why do you even check the abort location? The recognizer has been registered for this specific module and function, so you're never going to get here with a different top frame.

lldb/source/Target/Process.cpp

543

We need to find a better place to register this.

945

This variable name just looks weird. I know what it is in the context of this patch, but I would never get it re-reading this code a year from now. Just hoist the start_frame variable from bellow and use it.

947

No point in using the variable here. You want the top frame, let the code reflect this and just use 0.

956

Huh, reading further down the patch, it feels pretty wrong that you have to compute the "most relevant frame" here and in WillStop(). Should this just be something like start_frame = cur_thread->GetSelectedFrame()->GetIndex()?

lldb/source/Target/Thread.cpp

576

Why does this function name use a plural form? Wouldn't SelectMostRelevantFrame be a more explicit name?

581

Unused variable?

[teemperor]

lldb/include/lldb/Target/AbortRecognizer.h

30

This function (especially the return types) deserve some documentation.

lldb/source/Target/AbortRecognizer.cpp

2

Please remove the -*- C++ -*- as that's only for header files.

86

Could we make this frame_index instead of just I. I was confused that I isn't just an index into a vector when you later interpret it as a stack frame index.

100

You can just do sym_ctx.module_sp->GetFileSpec().FileEquals(module_spec) which also handles case insensitive file systems IIRC.

102

Maybe add a comment why you need to skip one frame.

105

Maybe something like this? Just a suggestion though.

uint32_t last_frame_index = frames_to_fetch - 1;
m_most_relevant_frame = thread_sp->GetStackFrameAtIndex(std::min(i + 1, last_frame_index));

[mib]

lldb/source/Target/AbortRecognizer.cpp

2

I saw this on a bunch of source files (StopInfo.cpp / Breakpoint.cpp / SymbolContext.cpp ...). I'm not sure what you mean by that.

26

I use ConstString because StackFrameRecognizerManager::AddRecognizer takes a ConstString.

And also SymbolContext::GetFunctionName returns a ConstString.

82

Pretty much. In the beginning I was unwinding the entire stack. But if there is too much frames (i.e. recursion) this would take too much time. We agreed with @friss and @jingham to unwind up to 10 frames at most.

Can you think of a better way to do it ?

lldb/source/Target/Process.cpp

543

May be this could go in Target/LanguageRuntime.cpp or Target/SystemRuntime.cpp ?

[friss]

lldb/source/Target/AbortRecognizer.cpp

82

I don't think that's exactly what I said. My opinion was that asserts will have a pretty deterministic layout, and that we should know exactly what to unwind to determine whether we have an assert or not.

In your test, you actually check that the frame with the assert is frame 4. If it is anything other then 4 in any configuration, then the test will fail. You might as well just put 4 in the code here rather than a magical 10.

[mib]

lldb/source/Target/AbortRecognizer.cpp

82

The number of frames to unwind is different depending on the platform. I chose 10 to give us some extra margin but I'll change it to 4 or 5,

[jingham]

lldb/source/Target/AbortRecognizer.cpp

82

We want this as small as will do the job - since we don't want to unwind more than necessary. But we aren't going to do this unwinding on every stop - only when we actually see a thread with frame 0 in __pthread_kill (or whatever the system kill is). So we don't need to over optimize. It would be silly to go have to fix this because some platform added another layer between assert and kill.

I'd go see what it is on all the Unixes we know about and add a couple to future proof it.

The test should definitely not depend on how many frames there are between the assert and the _pthread_kill. It should just check that the currently selected frame has the right file & line number. If you want to keep this a shell test, you could backtrace the thread and make sure the * is on the line with "assert.c", or maybe try:

(lldb) source info
Lines found in module `killme
[0x0000000100000f2e-0x0000000100000f6f): /tmp/assert.c:7:3

If the frame wasn't selected properly this will show:

(lldb) source info
error: No debug info for the selected frame.

[friss]

lldb/source/Target/AbortRecognizer.cpp

82

You say it is 4 or 5, so your test will fail in one of those configurations as you have hardcoded the frame number there.

[jingham]

lldb/source/Target/AbortRecognizer.cpp

82

Actually, the test you have is fine if you just leave out the "4". You really only care about the "assert.c".

[mib]

Changed the RecognizedStackFrame and AbortRecognizedStackFrame to add a StopReasonDescription method instead of a StopInfo instance.

This way, lldb can show a special stop reason description, for recognized frames that override the StopReasonDescription method, while keeping track of the underlying StopInfo. To display the underlying StopInfo, the thread-format token stop-reason-raw can be used.

The stop description can also be retrieved through the SBAPI using SBThread::GetStopDescription. It's either returning the "cooked" or the "raw" stop reason depending if the thread a has recognized frame.

This patch also changes the ObjC exception recognizer to have a special StopReasonDescription and updates its tests.

[JDevlieghere]

lldb/docs/use/formatting.rst

137 ↗

(On Diff #240543)

This change seems somewhat orthogonal to this patch. Is the abort recognizer the only one where these two will be different? If not I would suggest splitting this off into a separate patch.

lldb/include/lldb/Target/AbortRecognizer.h

34

Why is this in the header? If this is only used by the implementation, you should make these static function in the cpp file.

49

Doxygen comment?

lldb/source/Core/FormatEntity.cpp

1279 ↗

(On Diff #240543)

I know you didn't touch this line but since you copied it below...

if(Thread *thread = exe_ctx->GetThreadPtr())

lldb/source/Target/AbortRecognizer.cpp

43

(nit) We usually just use // for block comments.

68

I like std::tie but I wonder if a struct with named fields wouldn't make this more readable with less code. Saves you six lines in this function and the next one in exchange for a 4-line struct definition. Anyway I'll leave this up to you to decide.

return lldb::RecognizedStackFrameSP(
      new AbortRecognizedStackFrame(thread_sp, assert_location->module_spec, assert_location->function_name));

108

Why is this a std::string and not a StringRef? I'm pretty sure FileSpec has ctor that takes a StringRef.

[mib]

lldb/docs/use/formatting.rst

137 ↗

(On Diff #240543)

It wouldn't make sense to split this into different patches since I'm only changing the current thread.stop-reason in this one. And for users who still want the original behaviour, I added thread.stop-reason-raw.

lldb/source/Target/AbortRecognizer.cpp

68

I changed the implementation so I'm only passing 1 parameter (the most relevant frame) to the constructor.

[mib]

Renamed AbortRecognizer to AssertFrameRecognizer.

Moved the assert frame (aka most relevant frame) lookup from the AssertRecognizedStackFrame constructor to AssertFrameRecognizer::RecognizeFrame(), so if the assert frame is not found, only a base RecognizedStackFrame is returned.

Added doxygen comments.

All tests pass now.

[JDevlieghere]

LGTM with one inline comment, but let's give the other reviewers a chance to take another look before landing this.

lldb/source/Target/AssertFrameRecognizer.cpp

155 ↗

(On Diff #240744)

Why not return here?

StackFrameSP most_relevant_frame_sp = thread_sp->GetStackFrameAtIndex(std::min(frame_index + 1, last_frame_index));
return lldb::RecognizedStackFrameSP(new AssertRecognizedStackFrame(most_relevant_frame_sp));

That way you don't have to check again after you finish the loop and you can just return RecognizedStackFrameSP();.

[mib]

lldb/source/Target/AssertFrameRecognizer.cpp

155 ↗

(On Diff #240744)

Fair.

[mib]

Added early return in AssertFrameRecognizer::RecognizeFrame

[friss]

This generally looks good. I'm still not fond of registering this in the Target itself. But I don't have a immediately better idea as we don't have a C language runtime.

A couple more comments/questions that can be addressed as followups:

lldb/include/lldb/Target/StackFrameRecognizer.h

38

The fact that this returns a StringRef, means it must return a pointer to permanent string storage. In this case, you're returning a constant string, and it's fine, but it means that if you wanted to construct a return value (for example out of data you extract from the inferior), you need to store the string backing the StringRef somewhere. The concrete RecognizedStackFrame instance seems like a good fit, but I have no clue about their lifetime guarantees compared to the lifetime of the StringRef returned here. Maybe we should make this a std::string?

lldb/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py

191 ↗

(On Diff #240904)

as we just did self.runCmd above anyway, I'd replace all of this by self.runCmd('frame select 0'). Or at least just write it as a single line, no need to check for every intermediate result. Such verbosity really distracts from what the test is trying to verify.

113 ↗

(On Diff #240543)

Here, you're now just checking self consistency, I son't think that's valuable. This should check for the actual text of the assert recognizer (and potentially something else on the systems where the recognizer is not supported).

lldb/source/Target/AssertFrameRecognizer.cpp

110–112 ↗

(On Diff #240904)

Can you move this with the other AssertRecognizedStackFrame methods?

lldb/source/Target/StackFrameRecognizer.cpp

95

What's the reason of this change?

[labath]

Since the failure reason was not very obvious from the bot message, I took a quick look, and to save you the trouble of reproducing this, here's what I found:

The reason the new test failed was because the symbols you are searching for (__GI_raise, __GI___assert_fail) are private libc symbols which are only available if you happen to have debug info for the system libc installed. If you don't, these will show up as raise and __assert_fail, respectively.

Also the TestExitDuringStep was failing because of some apparent memory corruption in the stop reason (I am getting output like * thread #2, name = 'a.out', stop reason = P�4��

[mib]

Fixed the corrupted stop reason description.
Fixed linux support for public symbols.

[mib]

lldb/source/Target/StackFrameRecognizer.cpp

95

In line 101, lldb tries to get the symbol from the symbol context. If the symbol was not populated in the SymbolContext before calling GetRecognizerForFrame then it's null and the function returns a StackFrameRecognizerSP.

[max-kudr]

This broke LLDB tests on Windows Build Bot http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/13415

Can you please fix it or revert it? Thank you!

Failing Tests (4):
    lldb-api :: commands/watchpoints/step_over_watchpoint/TestStepOverWatchpoint.py
    lldb-api :: functionalities/postmortem/minidump-new/TestMiniDumpNew.py
    lldb-api :: python_api/thread/TestThreadAPI.py
    lldb-shell :: Driver/TestConvenienceVariables.test

  Expected Passes    : 1381
  Expected Failures  : 10
  Unsupported Tests  : 541
  Unexpected Failures: 4

[labath]

It looks like there is still some memory corruption going on:

lldb) target create --core "../llvm-project/lldb/packages/Python/lldbsuite/test/functionalities/postmortem/minidump/fizzbuzz_no_heap.dmp"
(lldb) bt
* thread #1, stop reason = Exception 0xc0000005 encountered at address 0x164d14
  * frame #0: 0x00164d14 fizzbuzz.exe
    frame #1: 0x00167c79 fizzbuzz.exe
   ...
(lldb) script lldb.thread.GetStopDescription(256)
'\xf0\xfca\x02'

lldb/source/Target/AssertFrameRecognizer.cpp

63–65 ↗

(On Diff #242645)

This part looks pretty kludgy. Maybe the function should just return a list of symbols (and shared libraries) and have this thing be handled at a higher level.

This is going to be needed in order to support other C library implementations (e.g. musl) on linux, and it's not inconceivable that the internal glibc symbol name will change in the future too...

[friss]

lldb/source/API/SBThread.cpp

328–329 ↗

(On Diff #242645)

This is wrong. GetStopDescription() returns a temporary std::string. stop_desc will be a dangling pointer on the next line. Just make stop_desc a std::string and call .data() below.

[mib]

There are still some bugs on Windows and Linux that need to investigated ...

[mib]

Fixing the memory management bug should hopefully solve the Linux and Windows Issues.

[jankratochvil]

Even with the latest variant (commit 7ebe9cc4fc2d97ec0ed2a6038be25b2a7ed1aac2) I am getting on Fedora 30 x86_64:

/home/jkratoch/redhat/llvm-monorepo/lldb/test/Shell/Recognizer/assert.test:5:10: error: CHECK: expected string not found in input
# CHECK: thread #{{.*}}stop reason = hit program assert
         ^
<stdin>:1:1: note: scanning from here
(lldb) command source -s 0 '/home/jkratoch/redhat/llvm-monorepo-clangassert/tools/lldb/test/Shell/lit-lldb-init'
^
<stdin>:15:34: note: possible intended match here
* thread #1, name = 'assert.test.tmp', stop reason = signal SIGABRT
                                 ^

The output is:

(lldb) command source -s 0 '/home/jkratoch/redhat/llvm-monorepo/lldb/test/Shell/Recognizer/assert.test'
Executing commands in '/home/jkratoch/redhat/llvm-monorepo/lldb/test/Shell/Recognizer/assert.test'.
(lldb) run
assert.test.tmp.out: /home/jkratoch/redhat/llvm-monorepo/lldb/test/Shell/Recognizer/Inputs/assert.c:7: int main(): Assertion `a == 42' failed.
Process 29077 stopped
* thread #1, name = 'assert.test.tmp', stop reason = signal SIGABRT
    frame #0: 0x00007ffff7ddee35 libc.so.6`raise + 325
libc.so.6`raise:
->  0x7ffff7ddee35 <+325>: movq   0x108(%rsp), %rax
    0x7ffff7ddee3d <+333>: xorq   %fs:0x28, %rax
    0x7ffff7ddee46 <+342>: jne    0x7ffff7ddee6c            ; <+380>
    0x7ffff7ddee48 <+344>: movl   %r8d, %eax

Process 29077 launched: '/home/jkratoch/redhat/llvm-monorepo-clangassert/tools/lldb/test/Recognizer/Output/assert.test.tmp.out' (x86_64)
(lldb) frame info
frame #0: 0x00007ffff7ddee35 libc.so.6`raise + 325
(lldb) frame recognizer info 0
frame 0 is recognized by Assert StackFrame Recognizer
(lldb) set set thread-format "{${thread.stop-reason-raw}}\n"
(lldb) thread info
signal SIGABRT

(lldb) q

Visible also on (silent) Fedora buildbot.

[mib]

The test seems to fail on certain linux distros (fedora and archlinux) ... Since it's not a breaking change, I sent a patch to skip it on linux, until I can reproduce it on those platform and fix the issue.

lldb/include/lldb/Target/AbortRecognizer.h

+//===-- AbortRecognizer.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_AbortRegognizer_h_
+#define liblldb_AbortRegognizer_h_
+
+#include "lldb/Target/Process.h"
+#include "lldb/Target/StackFrameRecognizer.h"
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/FileSpec.h"
+
+#include <tuple>
+
+namespace lldb_private {
+
+void RegisterAbortRecognizer(Process *process);
+
+llvm::Optional<std::tuple<FileSpec, llvm::StringRef>>
+GetAbortLocation(Process *process_sp);
+
+llvm::Optional<std::tuple<FileSpec, llvm::StringRef>>
+GetAssertLocation(Process *process_sp);
+
+#pragma mark Frame recognizers
+
+class AbortRecognizedStackFrame : public RecognizedStackFrame {
+public:
+  AbortRecognizedStackFrame(lldb::ThreadSP thread_sp, FileSpec module_spec,
+                            llvm::StringRef function_name);
+  lldb::StackFrameSP GetMostRelevantFrame() override;
+  lldb::StopInfoSP GetStopInfo() override;
+
+private:
+  lldb::StackFrameSP m_most_relevant_frame;
+  lldb::StopInfoSP m_stop_info_sp;
+};
+
+class AbortFrameRecognizer : public StackFrameRecognizer {
+public:
+  std::string GetName() override { return "Abort StackFrame Recognizer"; }
+  lldb::RecognizedStackFrameSP
+  RecognizeFrame(lldb::StackFrameSP frame) override;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_AbortRecognizer_h_

lldb/include/lldb/Target/StackFrameRecognizer.h

 //===-- StackFrameRecognizer.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_StackFrameRecognizer_h_
 #define liblldb_StackFrameRecognizer_h_
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Symbol/VariableList.h"
+#include "lldb/Target/StopInfo.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
 
 /// \class RecognizedStackFrame
 ///
 /// This class provides extra information about a stack frame that was
 /// provided by a specific stack frame recognizer. Right now, this class only
 /// holds recognized arguments (via GetRecognizedArguments).
 
 class RecognizedStackFrame
     : public std::enable_shared_from_this<RecognizedStackFrame> {
 public:
   virtual lldb::ValueObjectListSP GetRecognizedArguments() {
     return m_arguments;
   }
   virtual lldb::ValueObjectSP GetExceptionObject() {
     return lldb::ValueObjectSP();
   }
+  virtual lldb::StackFrameSP GetMostRelevantFrame() { return nullptr; };
+  virtual lldb::StopInfoSP GetStopInfo() { return nullptr; }
   virtual ~RecognizedStackFrame(){};
 
 protected:
   lldb::ValueObjectListSP m_arguments;
 };
 
 /// \class StackFrameRecognizer
 ///

lldb/include/lldb/Target/StopInfo.h

public:
   static lldb::StopInfoSP
   CreateStopReasonWithPlan(lldb::ThreadPlanSP &plan,
                            lldb::ValueObjectSP return_valobj_sp,
                            lldb::ExpressionVariableSP expression_variable_sp);
 
   static lldb::StopInfoSP
   CreateStopReasonWithException(Thread &thread, const char *description);
 
+  static lldb::StopInfoSP
+  CreateStopReasonForRecognizedFrame(Thread &thread, const char *description);
+
   static lldb::StopInfoSP CreateStopReasonWithExec(Thread &thread);
 
   static lldb::ValueObjectSP
   GetReturnValueObject(lldb::StopInfoSP &stop_info_sp);
 
   static lldb::ExpressionVariableSP
   GetExpressionVariable(lldb::StopInfoSP &stop_info_sp);
 

lldb/include/lldb/Target/Thread.h

public:
   // sure to call it.
   virtual void DidResume();
 
   // This notifies the thread when a private stop occurs.
   virtual void DidStop();
 
   virtual void RefreshStateAfterStop() = 0;
 
+  void SelectMostRelevantFrame();
+
   void WillStop();
 
   bool ShouldStop(Event *event_ptr);
 
   Vote ShouldReportStop(Event *event_ptr);
 
   Vote ShouldReportRun(Event *event_ptr);
 

lldb/source/Target/AbortRecognizer.cpp

+#include "lldb/Core/Module.h"
+#include "lldb/Symbol/Function.h"
+#include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/StackFrameList.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/Logging.h"
+
+#include "lldb/Target/AbortRecognizer.h"
+
+using namespace llvm;
+using namespace lldb;
+using namespace lldb_private;
+
+AbortRecognizedStackFrame::AbortRecognizedStackFrame(ThreadSP thread_sp,
+                                                     FileSpec module_spec,
+                                                     StringRef function_name) {
+  const uint32_t frames_to_fetch = 5;
+  const uint32_t last_frame_index = frames_to_fetch - 1;
+  StackFrameSP prev_frame_sp = nullptr;
+
+  // Fetch most relevant frame
+  for (uint32_t frame_index = 0; frame_index < frames_to_fetch; frame_index++) {
+    prev_frame_sp = thread_sp->GetStackFrameAtIndex(frame_index);
+
+    if (!prev_frame_sp) {
+      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
+      LLDB_LOG(log, "Abort Recognizer: Hit unwinding bound ({1} frames)!",
+               frames_to_fetch);
+      break;
+    }
+
+    SymbolContext sym_ctx =
+        prev_frame_sp->GetSymbolContext(eSymbolContextEverything);
+
+    if (sym_ctx.module_sp->GetFileSpec().FileEquals(module_spec) &&
+        sym_ctx.GetFunctionName() == ConstString(function_name)) {
+      m_most_relevant_frame = thread_sp->GetStackFrameAtIndex(
+          std::min(frame_index + 1, last_frame_index));
+      break;
+    }
+  }
+
+  // FIXME: This breaks several tests.
+  //  m_stop_info_sp = StopInfo::CreateStopReasonForRecognizedFrame(
+  //      *thread_sp.get(), "hit program assert");
+
+  m_stop_info_sp = nullptr;
+}
+
+lldb::RecognizedStackFrameSP
+AbortFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame) {
+  // Check if called with Frame #0
+  if (frame->GetFrameIndex())
+    return RecognizedStackFrameSP();
+
+  ThreadSP thread_sp = frame->GetThread();
+  ProcessSP process_sp = thread_sp->GetProcess();
+
+  // Fetch abort location
+  auto abort_location = GetAbortLocation(process_sp.get());
+
+  if (!abort_location.hasValue())
+    return RecognizedStackFrameSP();
+
+  FileSpec module_spec;
+  StringRef function_name;
+  std::tie(module_spec, function_name) = *abort_location;
+
+  SymbolContext sc = frame->GetSymbolContext(eSymbolContextModule);
+
+  // Check if frame is in abort module
+  if (!sc.module_sp ||
+      sc.module_sp->GetFileSpec().GetFilename() != module_spec.GetFilename())
+    return RecognizedStackFrameSP();
+
+  // Fetch assert location
+  auto assert_location = GetAssertLocation(process_sp.get());
+
+  if (!assert_location.hasValue())
+    return RecognizedStackFrameSP();
+
+  std::tie(module_spec, function_name) = *assert_location;
+
+  // Pass assert location to AbortRecognizedStackFrame to set as most relevant
+  // frame.
+  return lldb::RecognizedStackFrameSP(
+      new AbortRecognizedStackFrame(thread_sp, module_spec, function_name));
+};
+
+lldb::StackFrameSP AbortRecognizedStackFrame::GetMostRelevantFrame() {
+  return m_most_relevant_frame;
+}
+
+lldb::StopInfoSP AbortRecognizedStackFrame::GetStopInfo() {
+  return m_stop_info_sp;
+}
+
+namespace lldb_private {
+
+void RegisterAbortRecognizer(Process *process) {
+  static llvm::once_flag g_once_flag;
+  llvm::call_once(g_once_flag, [process]() {
+    auto abort_location = GetAbortLocation(process);
+
+    if (!abort_location.hasValue())
+      return;
+
+    FileSpec module_spec;
+    StringRef function_name;
+    std::tie(module_spec, function_name) = *abort_location;
+
+    StackFrameRecognizerManager::AddRecognizer(
+        StackFrameRecognizerSP(new AbortFrameRecognizer()),
+        module_spec.GetFilename(), ConstString(function_name), false);
+  });
+}
+
+llvm::Optional<std::tuple<FileSpec, StringRef>>
+GetAbortLocation(Process *process) {
+  Target &target = process->GetTarget();
+
+  std::string module_name;
+  StringRef symbol_name;
+
+  switch (target.GetArchitecture().GetTriple().getOS()) {
+  case llvm::Triple::Darwin:
+  case llvm::Triple::MacOSX:
+    module_name = "libsystem_kernel.dylib";
+    symbol_name = "__pthread_kill";
+    break;
+  case llvm::Triple::Linux:
+    module_name = "libc.so.6";
+    symbol_name = "__GI_raise";
+    break;
+  default:
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
+    LLDB_LOG(log, "Abort Recognizer::GetAbortLocation Unsupported OS");
+    return llvm::None;
+  }
+
+  return std::make_tuple(FileSpec(module_name), symbol_name);
+}
+
+llvm::Optional<std::tuple<FileSpec, StringRef>>
+GetAssertLocation(Process *process) {
+  Target &target = process->GetTarget();
+
+  std::string module_name;
+  StringRef symbol_name;
+
+  switch (target.GetArchitecture().GetTriple().getOS()) {
+  case llvm::Triple::Darwin:
+  case llvm::Triple::MacOSX:
+    module_name = "libsystem_c.dylib";
+    symbol_name = "__assert_rtn";
+    break;
+  case llvm::Triple::Linux:
+    module_name = "libc.so.6";
+    symbol_name = "__GI___assert_fail";
+    break;
+  default:
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
+    LLDB_LOG(log, "Abort Recognizer::GetAbortLocation Unsupported OS");
+    return llvm::None;
+  }
+
+  return std::make_tuple(FileSpec(module_name), symbol_name);
+}
+
+} // namespace lldb_private

lldb/source/Target/CMakeLists.txt

 lldb_tablegen(TargetProperties.inc -gen-lldb-property-defs
   SOURCE TargetProperties.td
   TARGET LLDBTargetPropertiesGen)
 
 lldb_tablegen(TargetPropertiesEnum.inc -gen-lldb-property-enum-defs
   SOURCE TargetProperties.td
   TARGET LLDBTargetPropertiesEnumGen)
 
 add_lldb_library(lldbTarget
   ABI.cpp
+  AbortRecognizer.cpp
   ExecutionContext.cpp
   InstrumentationRuntime.cpp
   InstrumentationRuntimeStopInfo.cpp
   JITLoader.cpp
   JITLoaderList.cpp
   Language.cpp
   LanguageRuntime.cpp
   Memory.cpp

lldb/source/Target/Process.cpp

 #include "lldb/Host/Terminal.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ABI.h"
+#include "lldb/Target/AbortRecognizer.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/InstrumentationRuntime.h"
 #include "lldb/Target/JITLoader.h"
 #include "lldb/Target/JITLoaderList.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/MemoryHistory.h"
 #include "lldb/Target/MemoryRegionInfo.h"
Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp,
   OptionValueSP value_sp =
       m_collection_sp
           ->GetPropertyAtIndex(nullptr, true, ePropertyMemCacheLineSize)
           ->GetValue();
   uint32_t platform_cache_line_size =
       target_sp->GetPlatform()->GetDefaultMemoryCacheLineSize();
   if (!value_sp->OptionWasSet() && platform_cache_line_size != 0)
     value_sp->SetUInt64Value(platform_cache_line_size);
+
+  RegisterAbortRecognizer(this);
 }
 
 Process::~Process() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
   LLDB_LOGF(log, "%p Process::~Process()", static_cast<void *>(this));
   StopPrivateStateThread();
 
   // ThreadList::Clear() will try to acquire this process's mutex, so
if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) {
       // Drop the ThreadList mutex by here, since GetThreadStatus below might
       // have to run code, e.g. for Data formatters, and if we hold the
       // ThreadList mutex, then the process is going to have a hard time
       // restarting the process.
       if (stream) {
         Debugger &debugger = process_sp->GetTarget().GetDebugger();
         if (debugger.GetTargetList().GetSelectedTarget().get() ==
             &process_sp->GetTarget()) {
+          ThreadSP cur_thread = process_sp->GetThreadList().GetSelectedThread();
+
+          if (!cur_thread || !cur_thread->IsValid())
+            return false;
+
+          uint32_t mrf_idx = 0;
+
+          auto frame_sp = cur_thread->GetStackFrameAtIndex(mrf_idx);
+
+          if (RecognizedStackFrameSP recognized_frame_sp =
+                  frame_sp->GetRecognizedFrame())
+            if (StackFrameSP mrf_sp =
+                    recognized_frame_sp->GetMostRelevantFrame())
+              mrf_idx = mrf_sp->GetFrameIndex();
+
           const bool only_threads_with_stop_reason = true;
-          const uint32_t start_frame = 0;
+          const uint32_t start_frame = mrf_idx;
           const uint32_t num_frames = 1;
           const uint32_t num_frames_with_source = 1;
           const bool stop_format = true;
+
           process_sp->GetStatus(*stream);
           process_sp->GetThreadStatus(*stream, only_threads_with_stop_reason,
                                       start_frame, num_frames,
                                       num_frames_with_source,
                                       stop_format);
           if (curr_thread_stop_info_sp) {
             lldb::addr_t crashing_address;
             ValueObjectSP valobj_sp = StopInfo::GetCrashingDereference(

lldb/source/Target/StackFrameRecognizer.cpp

public:
   }
 
   void RemoveAllRecognizers() {
     m_recognizers.clear();
   }
 
   StackFrameRecognizerSP GetRecognizerForFrame(StackFrameSP frame) {
     const SymbolContext &symctx =
-        frame->GetSymbolContext(eSymbolContextModule | eSymbolContextFunction);
+        frame->GetSymbolContext(eSymbolContextEverything);
     ConstString function_name = symctx.GetFunctionName();
     ModuleSP module_sp = symctx.module_sp;
     if (!module_sp) return StackFrameRecognizerSP();
     ConstString module_name = module_sp->GetFileSpec().GetFilename();
     Symbol *symbol = symctx.symbol;
     if (!symbol) return StackFrameRecognizerSP();
     Address start_addr = symbol->GetAddress();
     Address current_addr = frame->GetFrameCodeAddress();

lldb/source/Target/StopInfo.cpp

public:
   const char *GetDescription() override {
     if (m_description.empty())
       return "exception";
     else
       return m_description.c_str();
   }
 };
 
+// StopInfoRecognizedFrame
+
+class StopInfoRecognizedFrame : public StopInfoException {
+public:
+  StopInfoRecognizedFrame(Thread &thread, const char *description)
+      : StopInfoException(thread, description) {}
+
+  ~StopInfoRecognizedFrame() override = default;
+
+  const char *GetDescription() override {
+    if (m_description.empty())
+      return "recognized frame:";
+    else
+      return m_description.c_str();
+  }
+};
+
 // StopInfoThreadPlan
 
 class StopInfoThreadPlan : public StopInfo {
 public:
   StopInfoThreadPlan(ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp,
                      ExpressionVariableSP &expression_variable_sp)
       : StopInfo(plan_sp->GetThread(), LLDB_INVALID_UID), m_plan_sp(plan_sp),
         m_return_valobj_sp(return_valobj_sp),
return StopInfoSP(new StopInfoThreadPlan(plan_sp, return_valobj_sp,
                                            expression_variable_sp));
 }
 
 StopInfoSP StopInfo::CreateStopReasonWithException(Thread &thread,
                                                    const char *description) {
   return StopInfoSP(new StopInfoException(thread, description));
 }
 
+StopInfoSP
+StopInfo::CreateStopReasonForRecognizedFrame(Thread &thread,
+                                             const char *description) {
+  return StopInfoSP(new StopInfoRecognizedFrame(thread, description));
+}
+
 StopInfoSP StopInfo::CreateStopReasonWithExec(Thread &thread) {
   return StopInfoSP(new StopInfoExec(thread));
 }
 
 ValueObjectSP StopInfo::GetReturnValueObject(StopInfoSP &stop_info_sp) {
   if (stop_info_sp &&
       stop_info_sp->GetStopReason() == eStopReasonPlanComplete) {
     StopInfoThreadPlan *plan_stop_info =

lldb/source/Target/Thread.cpp

StateType Thread::GetState() const {
   return m_state;
 }
 
 void Thread::SetState(StateType state) {
   std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
   m_state = state;
 }
 
+void Thread::SelectMostRelevantFrame() {
+  if (!m_curr_frames_sp)
+    return;
+
+  auto cur_frame = m_curr_frames_sp->GetFrameAtIndex(0);
+
+  auto recognized_frame_sp = cur_frame->GetRecognizedFrame();
+
+  if (!recognized_frame_sp)
+    return;
+
+  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_TARGET);
+
+  if (StackFrameSP most_relevant_frame_sp =
+          recognized_frame_sp->GetMostRelevantFrame()) {
+    LLDB_LOG(log, "Found most relevant frame {0}",
+             most_relevant_frame_sp->GetFrameIndex());
+    SetSelectedFrame(most_relevant_frame_sp.get());
+  } else {
+    LLDB_LOG(log, "No relevant frame!");
+  }
+
+  if (StopInfoSP stop_info_sp = recognized_frame_sp->GetStopInfo()) {
+    LLDB_LOG(log, "Found stop reason {0}", stop_info_sp->GetStopReason());
+    SetStopInfo(stop_info_sp);
+  } else {
+    LLDB_LOG(log, "No stop reason for recognized frame!");
+  }
+}
+
 void Thread::WillStop() {
   ThreadPlan *current_plan = GetCurrentPlan();
 
+  SelectMostRelevantFrame();
+
   // FIXME: I may decide to disallow threads with no plans.  In which
   // case this should go to an assert.
 
   if (!current_plan)
     return;
 
   current_plan->WillStop();
 }

lldb/test/Shell/Recognizer/Inputs/abort.c

+#include <assert.h>
+
+int main() {
+  int a = 42;
+  assert(a == 42);
+  a--;
+  assert(a == 42);
+  return 0;
+}

lldb/test/Shell/Recognizer/abort.test

+# UNSUPPORTED: system-windows
+# RUN: %clang_host -g -O0 %S/Inputs/abort.c -o %t.out
+# RUN: %lldb -b -s %s %t.out | FileCheck %s
+run
+# CHECK: thread #{{.*}}stop reason = signal SIGABRT
+frame info
+# CHECK: frame #4: {{.*}}`main at abort.c
+frame recognizer info 0
+# CHECK: frame 0 is recognized by Abort StackFrame Recognizer
+q