[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

109 ↗

(On Diff #240038)

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

27 ↗

(On Diff #240038)

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.

33 ↗

(On Diff #240038)

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

25 ↗

(On Diff #240038)

Why does this need to return a ConstString?

35 ↗

(On Diff #240038)

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

51 ↗

(On Diff #240038)

Same comments as the previous method.

81 ↗

(On Diff #240038)

Magic value? Why 10?

[friss]

lldb/source/Target/AbortRecognizer.cpp

126–127 ↗

(On Diff #240038)

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.

946

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()?

947

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

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

29 ↗

(On Diff #240038)

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

lldb/source/Target/AbortRecognizer.cpp

1 ↗

(On Diff #240038)

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

85 ↗

(On Diff #240038)

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.

99 ↗

(On Diff #240038)

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

101 ↗

(On Diff #240038)

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

104 ↗

(On Diff #240038)

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

1 ↗

(On Diff #240038)

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

25 ↗

(On Diff #240038)

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

And also SymbolContext::GetFunctionName returns a ConstString.

81 ↗

(On Diff #240038)

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

81 ↗

(On Diff #240038)

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

81 ↗

(On Diff #240038)

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

81 ↗

(On Diff #240038)

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

81 ↗

(On Diff #240038)

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

81 ↗

(On Diff #240038)

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–139

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

33 ↗

(On Diff #240543)

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

48 ↗

(On Diff #240543)

Doxygen comment?

lldb/source/Core/FormatEntity.cpp

1277–1278

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

42 ↗

(On Diff #240543)

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

67 ↗

(On Diff #240543)

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));

107 ↗

(On Diff #240543)

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–139

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

67 ↗

(On Diff #240543)

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

156

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

156

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

118

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).

197

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.

lldb/source/Target/AssertFrameRecognizer.cpp

111–113

Can you move this with the other AssertRecognizedStackFrame methods?

lldb/source/Target/StackFrameRecognizer.cpp

95–96

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–96

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

64–66

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

327–332

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/docs/use/formatting.rst

 | ``thread.id``                                     | The thread identifier for the current thread                                                                                                                                                                                                                                                |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``thread.index``                                  | The unique one based thread index ID which is guaranteed to be unique as threads come and go.                                                                                                                                                                                               |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``thread.name``                                   | The name of the thread if the target OS supports naming threads                                                                                                                                                                                                                             |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``thread.queue``                                  | The queue name of the thread if the target OS supports dispatch queues                                                                                                                                                                                                                      |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
-| ``thread.stop-reason``                            | A textual reason each thread stopped                                                                                                                                                                                                                                                        |
+| ``thread.stop-reason``                            | A textual reason why the thread stopped. If the thread have a recognized frame, this displays its recognized stop reason. Otherwise, gets the stop info description.                                                                                                                        |
++---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``thread.stop-reason-raw``                        | A textual reason why the thread stopped. Always returns stop info description.                                                                                                                                                                                                              |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``thread.return-value``                           | The return value of the latest step operation (currently only for step-out.)                                                                                                                                                                                                                |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``thread.completed-expression``                   | The expression result for a thread that just finished an interrupted expression evaluation.                                                                                                                                                                                                 |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``target.arch``                                   | The architecture of the current target                                                                                                                                                                                                                                                      |
 +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 | ``script.target:python_func``                     | Use a Python function to generate a piece of textual output                                                                                                                                                                                                                                 |

lldb/include/lldb/Core/FormatEntity.h

enum class Type {
       ProcessFile,
       ScriptProcess,
       ThreadID,
       ThreadProtocolID,
       ThreadIndexID,
       ThreadName,
       ThreadQueue,
       ThreadStopReason,
+      ThreadStopReasonRaw,
       ThreadReturnValue,
       ThreadCompletedExpression,
       ScriptThread,
       ThreadInfo,
       TargetArch,
       ScriptTarget,
       ModuleFile,
       File,

lldb/include/lldb/Target/AssertFrameRecognizer.h

+//===-- AssertFrameRecognizer.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_AssertFrameRecognizer_h_
+#define liblldb_AssertFrameRecognizer_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 {
+
+/// Registers the assert stack frame recognizer.
+///
+/// \param[in] process
+///    The process that is currently asserting. This will give us information on
+///    the target and the platform.
+void RegisterAssertFrameRecognizer(Process *process);
+
+/// \class AssertRecognizedStackFrame
+///
+/// Holds the stack frame where the assert is called from.
+class AssertRecognizedStackFrame : public RecognizedStackFrame {
+public:
+  AssertRecognizedStackFrame(lldb::StackFrameSP most_relevant_frame_sp);
+  lldb::StackFrameSP GetMostRelevantFrame() override;
+
+private:
+  lldb::StackFrameSP m_most_relevant_frame;
+};
+
+/// \class AssertFrameRecognizer
+///
+/// When a thread stops, it 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.
+class AssertFrameRecognizer : public StackFrameRecognizer {
+public:
+  std::string GetName() override { return "Assert StackFrame Recognizer"; }
+  lldb::RecognizedStackFrameSP
+  RecognizeFrame(lldb::StackFrameSP frame_sp) override;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_AssertFrameRecognizer_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 ~RecognizedStackFrame(){};
 
+  std::string GetStopDescription() { return m_stop_desc; }
+
 protected:
   lldb::ValueObjectListSP m_arguments;
+  std::string m_stop_desc;
 };
 
 /// \class StackFrameRecognizer
 ///
 /// A base class for frame recognizers. Subclasses (actual frame recognizers)
 /// should implement RecognizeFrame to provide a RecognizedStackFrame for a
 /// given stack frame.
 

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();
+
+  std::string GetStopDescription();
+
+  std::string GetStopDescriptionRaw();
+
   void WillStop();
 
   bool ShouldStop(Event *event_ptr);
 
   Vote ShouldReportStop(Event *event_ptr);
 
   Vote ShouldReportRun(Event *event_ptr);
 

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

def set_breakpoint(self, line):
             self, "main.c", line, num_expected_locations=1, loc_exact=True)
 
     def check_stop_reason(self):
         matched = lldbplatformutil.match_android_device(
             self.getArchitecture(), valid_api_levels=list(range(1, 16 + 1)))
         if matched:
             # On android until API-16 the abort() call ended in a sigsegv
             # instead of in a sigabrt
-            stop_reason = 'stop reason = signal SIGSEGV'
+            stop_reason = 'signal SIGSEGV'
         else:
-            stop_reason = 'stop reason = signal SIGABRT'
+            stop_reason = 'signal SIGABRT'
+
+        target = self.dbg.GetTargetAtIndex(0)
+        process = target.GetProcess()
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
+
+        pattern = "stop reason = (" + stop_reason + "|hit program assert)"
 
         # The stop reason of the thread should be an abort signal or exception.
         self.expect("thread list", STOPPED_DUE_TO_ASSERT,
-                    substrs=['stopped',
-                             stop_reason])
+                    patterns=[pattern],
+                    substrs=['stopped'])
 
-        return stop_reason
+        return pattern
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number of the call to assert.
         self.line = line_number('main.c', '// Assert here.')
 
     def inferior_asserting(self):
         """Inferior asserts upon launching; lldb should catch the event and stop."""
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         stop_reason = self.check_stop_reason()
 
         # And it should report a backtrace that includes the assert site.
         self.expect("thread backtrace all",
-                    substrs=[stop_reason, 'main', 'argc', 'argv'])
+                    patterns=[stop_reason],
+                    substrs=['main', 'argc', 'argv'])
 
         # And it should report the correct line number.
         self.expect("thread backtrace all",
-                    substrs=[stop_reason,
-                             'main.c:%d' % self.line])
+                    patterns=[stop_reason],
+                    substrs=['main.c:%d' % self.line])
 
     def inferior_asserting_python(self):
         """Inferior asserts upon launching; lldb should catch the event and stop."""
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
class AssertingInferiorTestCase(TestBase):
     def inferior_asserting_registers(self):
         """Test that lldb can read registers after asserting."""
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
 
+        # change current frame to frame 0, since recognizer might have selected
+        # different frame.
+        self.runCmd("frame select 0", RUN_SUCCEEDED)
+
         # lldb should be able to read from registers from the inferior after
         # asserting.
         lldbplatformutil.check_first_register_readable(self)
 
     def inferior_asserting_disassemble(self):
         """Test that lldb can disassemble frames after asserting."""
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Launch the process, and do not stop at the entry point.
         target.LaunchSimple(None, None, self.get_process_working_directory())
         self.check_stop_reason()
 
         process = target.GetProcess()
         self.assertTrue(process.IsValid(), "current process is valid")
 
def inferior_asserting_step(self):
         # The lldb expression interpreter should be able to read from addresses
         # of the inferior after a call to assert().
         self.assertTrue(
             self.check_expr_in_main(thread),
             "cannot find 'main' in the backtrace")
 
         # And it should report the correct line number.
         self.expect("thread backtrace all",
-                    substrs=[stop_reason,
-                             'main.c:%d' % self.line])
+                    patterns=[stop_reason],
+                    substrs=['main.c:%d' % self.line])

lldb/packages/Python/lldbsuite/test/lang/objc/exceptions/TestObjCExceptions.py

def test_objc_exceptions_at_throw(self):
         self.build()
 
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)
 
         launch_info = lldb.SBLaunchInfo(["a.out", "0"])
         lldbutil.run_to_name_breakpoint(self, "objc_exception_throw", launch_info=launch_info)
 
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-                    substrs=['stopped', 'stop reason = breakpoint'])
+        self.expect("thread list",
+            substrs=['stopped', 'stop reason = hit Objective-C exception'])
 
         self.expect('thread exception', substrs=[
                 '(NSException *) exception = ',
                 '"SomeReason"',
             ])
 
         target = self.dbg.GetSelectedTarget()
         thread = target.GetProcess().GetSelectedThread()

lldb/source/API/SBThread.cpp

size_t SBThread::GetStopDescription(char *dst, size_t dst_len) {
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
 
       StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo();
       if (stop_info_sp) {
-        const char *stop_desc = stop_info_sp->GetDescription();
-        if (stop_desc) {
+        std::string thread_stop_desc =
+            exe_ctx.GetThreadPtr()->GetStopDescription();
+        const char *stop_desc = thread_stop_desc.c_str();
+
+        if (stop_desc[0] != '\0') {
           if (dst)
             return ::snprintf(dst, dst_len, "%s", stop_desc);
           else {
             // NULL dst passed in, return the length needed to contain the
             // description
             return ::strlen(stop_desc) + 1; // Include the NULL byte for size
           }
         } else {

lldb/source/Core/FormatEntity.cpp

 static FormatEntity::Entry::Definition g_thread_child_entries[] = {
     ENTRY("id", ThreadID),
     ENTRY("protocol_id", ThreadProtocolID),
     ENTRY("index", ThreadIndexID),
     ENTRY_CHILDREN("info", ThreadInfo, g_string_entry),
     ENTRY("queue", ThreadQueue),
     ENTRY("name", ThreadName),
     ENTRY("stop-reason", ThreadStopReason),
+    ENTRY("stop-reason-raw", ThreadStopReasonRaw),
     ENTRY("return-value", ThreadReturnValue),
     ENTRY("completed-expression", ThreadCompletedExpression),
 };
 
 static FormatEntity::Entry::Definition g_target_child_entries[] = {
     ENTRY("arch", TargetArch),
 };
 
switch (t) {
     ENUM_TO_CSTR(ProcessFile);
     ENUM_TO_CSTR(ScriptProcess);
     ENUM_TO_CSTR(ThreadID);
     ENUM_TO_CSTR(ThreadProtocolID);
     ENUM_TO_CSTR(ThreadIndexID);
     ENUM_TO_CSTR(ThreadName);
     ENUM_TO_CSTR(ThreadQueue);
     ENUM_TO_CSTR(ThreadStopReason);
+    ENUM_TO_CSTR(ThreadStopReasonRaw);
     ENUM_TO_CSTR(ThreadReturnValue);
     ENUM_TO_CSTR(ThreadCompletedExpression);
     ENUM_TO_CSTR(ScriptThread);
     ENUM_TO_CSTR(ThreadInfo);
     ENUM_TO_CSTR(TargetArch);
     ENUM_TO_CSTR(ScriptTarget);
     ENUM_TO_CSTR(ModuleFile);
     ENUM_TO_CSTR(File);
if (exe_ctx) {
           s.PutCString(cstr);
           return true;
         }
       }
     }
     return false;
 
   case Entry::Type::ThreadStopReason:
     if (exe_ctx) {
-      Thread *thread = exe_ctx->GetThreadPtr();
-      if (thread) {
-        StopInfoSP stop_info_sp = thread->GetStopInfo();
-        if (stop_info_sp && stop_info_sp->IsValid()) {
-          const char *cstr = stop_info_sp->GetDescription();
-          if (cstr && cstr[0]) {
-            s.PutCString(cstr);
-            return true;
-          }
-        }
-      }
+      if (Thread *thread = exe_ctx->GetThreadPtr()) {
+        std::string stop_description = thread->GetStopDescription();
+        if (!stop_description.empty()) {
+          s.PutCString(stop_description);
+    return false;
+
+  case Entry::Type::ThreadStopReasonRaw:
+    if (exe_ctx) {
+      if (Thread *thread = exe_ctx->GetThreadPtr()) {
+        std::string stop_description = thread->GetStopDescriptionRaw();
+        if (!stop_description.empty()) {
+          s.PutCString(stop_description);
+          return true;
+        }
+      }
     }
     return false;
 
   case Entry::Type::ThreadReturnValue:
     if (exe_ctx) {
       Thread *thread = exe_ctx->GetThreadPtr();
       if (thread) {
         StopInfoSP stop_info_sp = thread->GetStopInfo();

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

ObjCExceptionRecognizedStackFrame(StackFrameSP frame_sp) {
     exception = ValueObjectConstResult::Create(frame_sp.get(), value,
                                                ConstString("exception"));
     exception = ValueObjectRecognizerSynthesizedValue::Create(
         *exception, eValueTypeVariableArgument);
     exception = exception->GetDynamicValue(eDynamicDontRunTarget);
 
     m_arguments = ValueObjectListSP(new ValueObjectList());
     m_arguments->Append(exception);
+
+    m_stop_desc = "hit Objective-C exception";
   }
 
   ValueObjectSP exception;
 
   lldb::ValueObjectSP GetExceptionObject() override { return exception; }
 };
 
 class ObjCExceptionThrowFrameRecognizer : public StackFrameRecognizer {

lldb/source/Target/AssertFrameRecognizer.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/AssertFrameRecognizer.h"
+
+using namespace llvm;
+using namespace lldb;
+using namespace lldb_private;
+
+namespace lldb_private {
+/// Checkes if the module containing a symbol has debug info.
+///
+/// \param[in] target
+///    The target containing the module.
+/// \param[in] module_spec
+///    The module spec that should contain the symbol.
+/// \param[in] symbol_name
+///    The symbol's name that should be contained in the debug info.
+/// \return
+///    If  \b true the symbol was found, \b false otherwise.
+bool ModuleHasDebugInfo(Target &target, FileSpec &module_spec,
+                        StringRef symbol_name) {
+  ModuleSP module_sp = target.GetImages().FindFirstModule(module_spec);
+
+  if (!module_sp)
+    return false;
+
+  return module_sp->FindFirstSymbolWithNameAndType(ConstString(symbol_name));
+}
+
+/// Fetches the abort frame location depending on the current platform.
+///
+/// \param[in] process_sp
+///    The process that is currently aborting. This will give us information on
+///    the target and the platform.
+/// \return
+///    If the platform is supported, returns an optional tuple containing
+///    the abort module as a \a FileSpec and the symbol name as a \a StringRef.
+///    Otherwise, returns \a llvm::None.
+llvm::Optional<std::tuple<FileSpec, StringRef>>
+GetAbortLocation(Process *process) {
+  Target &target = process->GetTarget();
+
+  FileSpec module_spec;
+  StringRef symbol_name;
+
+  switch (target.GetArchitecture().GetTriple().getOS()) {
+  case llvm::Triple::Darwin:
+  case llvm::Triple::MacOSX:
+    module_spec = FileSpec("libsystem_kernel.dylib");
+    symbol_name = "__pthread_kill";
+    break;
+  case llvm::Triple::Linux:
+    module_spec = FileSpec("libc.so.6");
+    symbol_name = "__GI_raise";
+    if (!ModuleHasDebugInfo(target, module_spec, symbol_name))
+      symbol_name = "raise";
+    break;
+  default:
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
+    LLDB_LOG(log, "AssertFrameRecognizer::GetAbortLocation Unsupported OS");
+    return llvm::None;
+  }
+
+  return std::make_tuple(module_spec, symbol_name);
+}
+
+/// Fetches the assert frame location depending on the current platform.
+///
+/// \param[in] process_sp
+///    The process that is currently asserting. This will give us information on
+///    the target and the platform.
+/// \return
+///    If the platform is supported, returns an optional tuple containing
+///    the asserting frame module as  a \a FileSpec and the symbol name as a \a
+///    StringRef.
+///    Otherwise, returns \a llvm::None.
+llvm::Optional<std::tuple<FileSpec, StringRef>>
+GetAssertLocation(Process *process) {
+  Target &target = process->GetTarget();
+
+  FileSpec module_spec;
+  StringRef symbol_name;
+
+  switch (target.GetArchitecture().GetTriple().getOS()) {
+  case llvm::Triple::Darwin:
+  case llvm::Triple::MacOSX:
+    module_spec = FileSpec("libsystem_c.dylib");
+    symbol_name = "__assert_rtn";
+    break;
+  case llvm::Triple::Linux:
+    module_spec = FileSpec("libc.so.6");
+    symbol_name = "__GI___assert_fail";
+    if (!ModuleHasDebugInfo(target, module_spec, symbol_name))
+      symbol_name = "__assert_fail";
+    break;
+  default:
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
+    LLDB_LOG(log, "AssertFrameRecognizer::GetAssertLocation Unsupported OS");
+    return llvm::None;
+  }
+
+  return std::make_tuple(module_spec, symbol_name);
+}
+
+void RegisterAssertFrameRecognizer(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 AssertFrameRecognizer()),
+        module_spec.GetFilename(), ConstString(function_name), false);
+  });
+}
+
+} // namespace lldb_private
+
+lldb::RecognizedStackFrameSP
+AssertFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame_sp) {
+  ThreadSP thread_sp = frame_sp->GetThread();
+  ProcessSP process_sp = thread_sp->GetProcess();
+
+  auto assert_location = GetAssertLocation(process_sp.get());
+
+  if (!assert_location.hasValue())
+    return RecognizedStackFrameSP();
+
+  FileSpec module_spec;
+  StringRef function_name;
+  std::tie(module_spec, function_name) = *assert_location;
+
+  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)) {
+
+      // We go a frame beyond the assert location because the most relevant
+      // frame for the user is the one in which the assert function was called.
+      // If the assert location is the last frame fetched, then it is set as
+      // the most relevant frame.
+
+      StackFrameSP most_relevant_frame_sp = thread_sp->GetStackFrameAtIndex(
+          std::min(frame_index + 1, last_frame_index));
+
+      // Pass assert location to AbortRecognizedStackFrame to set as most
+      // relevant frame.
+      return lldb::RecognizedStackFrameSP(
+          new AssertRecognizedStackFrame(most_relevant_frame_sp));
+    }
+  }
+
+  return RecognizedStackFrameSP();
+};
+
+AssertRecognizedStackFrame::AssertRecognizedStackFrame(
+    StackFrameSP most_relevant_frame_sp)
+    : m_most_relevant_frame(most_relevant_frame_sp) {
+  m_stop_desc = "hit program assert";
+}
+
+lldb::StackFrameSP AssertRecognizedStackFrame::GetMostRelevantFrame() {
+  return m_most_relevant_frame;
+}

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
+  AssertFrameRecognizer.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/AssertFrameRecognizer.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);
+
+  RegisterAssertFrameRecognizer(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 thread_sp = process_sp->GetThreadList().GetSelectedThread();
+
+          if (!thread_sp || !thread_sp->IsValid())
+            return false;
+
           const bool only_threads_with_stop_reason = true;
-          const uint32_t start_frame = 0;
+          const uint32_t start_frame = thread_sp->GetSelectedFrameIndex();
           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

bool RemoveRecognizerWithID(uint32_t recognizer_id) {
     return true;
   }
 
   void RemoveAllRecognizers() {
     m_recognizers.clear();
   }
 
   StackFrameRecognizerSP GetRecognizerForFrame(StackFrameSP frame) {
-    const SymbolContext &symctx =
-        frame->GetSymbolContext(eSymbolContextModule | eSymbolContextFunction);
+    const SymbolContext &symctx = frame->GetSymbolContext(
+        eSymbolContextModule | eSymbolContextFunction | eSymbolContextSymbol);
     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/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;
 }
 
+std::string Thread::GetStopDescription() {
+  StackFrameSP frame_sp = GetStackFrameAtIndex(0);
+
+  if (!frame_sp)
+    return GetStopDescriptionRaw();
+
+  auto recognized_frame_sp = frame_sp->GetRecognizedFrame();
+
+  if (!recognized_frame_sp)
+    return GetStopDescriptionRaw();
+
+  std::string recognized_stop_description =
+      recognized_frame_sp->GetStopDescription();
+
+  if (!recognized_stop_description.empty())
+    return recognized_stop_description;
+
+  return GetStopDescriptionRaw();
+}
+
+std::string Thread::GetStopDescriptionRaw() {
+  StopInfoSP stop_info_sp = GetStopInfo();
+  std::string raw_stop_description;
+  if (stop_info_sp && stop_info_sp->IsValid())
+    raw_stop_description = stop_info_sp->GetDescription();
+  return raw_stop_description;
+}
+
+void Thread::SelectMostRelevantFrame() {
+  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD);
+
+  auto frames_list_sp = GetStackFrameList();
+
+  // Only the top frame should be recognized.
+  auto frame_sp = frames_list_sp->GetFrameAtIndex(0);
+
+  auto recognized_frame_sp = frame_sp->GetRecognizedFrame();
+
+  if (!recognized_frame_sp) {
+    LLDB_LOG(log, "Frame #0 not recognized");
+    return;
+  }
+
+  if (StackFrameSP most_relevant_frame_sp =
+          recognized_frame_sp->GetMostRelevantFrame()) {
+    LLDB_LOG(log, "Found most relevant frame at index {0}",
+             most_relevant_frame_sp->GetFrameIndex());
+    SetSelectedFrame(most_relevant_frame_sp.get());
+  } else {
+    LLDB_LOG(log, "No relevant 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/assert.c

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

lldb/test/Shell/Recognizer/assert.test

+# UNSUPPORTED: system-windows
+# RUN: %clang_host -g -O0 %S/Inputs/assert.c -o %t.out
+# RUN: %lldb -b -s %s %t.out | FileCheck %s
+run
+# CHECK: thread #{{.*}}stop reason = hit program assert
+frame info
+# CHECK: frame #{{.*}}`main at assert.c
+frame recognizer info 0
+# CHECK: frame 0 is recognized by Assert StackFrame Recognizer
+set set thread-format "{${thread.stop-reason-raw}}\n"
+thread info
+# CHECK: signal SIGABRT
+q