Fix+re-enable Assert StackFrame Recognizer on Linux

[jankratochvil]

Summary

D73303 was failing on Fedora Linux and so it was disabled by Skip the AssertFrameRecognizer test for Linux.
I find no easy way how to find out if it gets recognized as __assert_fail or __GI___assert_fail as when ModuleHasDebugInfo gets called libc.so.6 is not yet loaded by the debuggee.
DWARF symbol __GI___assert_fail overrides the ELF symbol __assert_fail.
While external debug info (=DWARF) gets disabled for testsuite (D55859) that sure does not apply for real world usage.

[mib]

Originally, when I implemented the patch and tested it on linux, the symbol on the abort frame was (GI_assert_fail) on my machine.

In D73303#1846281, @labath wrote:

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.

This is why I thought I'd need to support both.

Otherwise, LGTM!

Thanks for investigating the issue.

lldb/source/Target/AssertFrameRecognizer.cpp

19–38

In this case, we can also remove this.

63–64

And also this if global bindings are preferred.

[jankratochvil]

In D74252#1864879, @mib wrote:

Originally, when I implemented the patch and tested it on linux, the symbol on the abort frame was (GI_assert_fail) on my machine.

Maybe you did not have settings set symbols.enable-external-lookup false like the testsuite. Or you used LLDB before Jan 13th (D63540).

Thanks for verifying it, going to land it.

[mib]

I used an apt installed lldb so it was probably a build older than Jan 13th.

[jankratochvil]

I have reverted this change as it fixed the testsuite but real world usage was broken:

(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 12062 stopped
* thread #1, name = 'assert.test.tmp', stop reason = signal SIGABRT
    frame #0: 0x00007ffff7ddee35 libc.so.6`__GI_raise(sig=2) at raise.c:51:1
   48     __libc_signal_restore_set (&set);
   49
   50     return ret;
-> 51   }
   52   libc_hidden_def (raise)
   53   weak_alias (raise, gsignal)

I think it really needs to compare both variants of the function name on Linux.
Both variants get mapped name->address but it is difficult to say which one will get looked up address->name.
Otherwise one could also fix why DWARF resolves the __GI_* variants from:

<4d4b>   DW_AT_linkage_name: (indirect string, offset: 0x1b784): __GI___assert_fail
<4d4f>   DW_AT_name        : (indirect string, offset: 0x1b789): __assert_fail

[mib]

We'd like to avoid registering recognizers multiple times for the same purpose ...

This could cause some issues down the road, since those recognizers can - indirectly - perform an action (change the current frame or the stop reason).

Also, from a usability stand-point, this could be confusing for the user when listing recognizers.

[jankratochvil]

In D74252#1865493, @mib wrote:

We'd like to avoid registering recognizers multiple times for the same purpose ...

OK, then it could be changed to a regex. Is it fine afterwards?

[mib]

In D74252#1865496, @jankratochvil wrote:

OK, then it could be changed to a regex. Is it fine afterwards?

Knowing that this will be called every time a thread stops, it would be better if we could avoid processing a regex every time we try to recognise a frame. But if that's the only way to solve the issue ...

[jankratochvil]

In D74252#1865500, @mib wrote:

Knowing that this will be called every time a thread stops, it would be better if we could avoid processing a regex every time we try to recognise a frame.

Or StackFrameRecognizerManagerImpl::AddRecognizer and its m_recognizers can have ConstString symbol1, symbol2;. What is less bad?

[mib]

In D74252#1865501, @jankratochvil wrote:

In D74252#1865500, @mib wrote:

Knowing that this will be called every time a thread stops, it would be better if we could avoid processing a regex every time we try to recognise a frame.

Or StackFrameRecognizerManagerImpl::AddRecognizer and its m_recognizers can have ConstString symbol1, symbol2;. What is less bad?

This sounds like a good idea, but let's leave symbol as is and add a ConstString alternate_symbol in StackFrameRecognizerManagerImpl::RegisteredEntry defaulting to an empty ConstString

[mib]

LGTM! Thanks for the patch!

[jankratochvil]

In D74252#1865504, @mib wrote:

but let's leave symbol as is and add a ConstString alternate_symbol

FYI this had a purpose. Any code touching symbol should be rechecked if it should not handle also alternate_symbol now. Both in existing codebase and also in any 3rd party patches we do not know.

[mib]

Hello Jan,

Has the latest version of this patch landed yet or does it need some extra work ?

[jankratochvil]

In D74252#1866476, @mib wrote:

Has the latest version of this patch landed yet or does it need some extra work ?

I was giving some time to other reviewers but it is checked-in now.

[JDevlieghere]

lldb/source/Commands/CommandObjectFrame.cpp

966

We should stream to the output stream directly to avoid all these useless conversions.

lldb/source/Target/AssertFrameRecognizer.cpp

29

With two elements in the tuple I was torn between a struct with named fields, but with 3 fields I strongly believe that would be the better choice.

152

I believe someone added an overload for comparing ConstStrings with StringRefs. We shouldn't have to pay the price of creating one here just for comparison. Same below.

[jankratochvil]

@davide Sorry for the revert rG6b2979c12300b90a1e69791d43ee9cff14f4265e - I will find some way to test stuff on OSX, I already made too many OSX breakages recently.

[teemperor]

lldb/source/Target/AssertFrameRecognizer.cpp

152

I really don't want a == overload for StringRef in ConstString. The *only* reason for using ConstString is using less memory for duplicate strings and being fast to compare against other ConstStrings. So if we add an overload for comparing against StringRef then code like this will look really innocent even though it essentially goes against the idea of ConstString. Either both string lists are using ConstString or neither does (which I would prefer). But having a list of normal strings and comparing it against ConstStrings usually means that the design is kinda flawed. Then we have both normal string comparisons but also the whole overhead of ConstString.

Looking at this patch we already construct at one point a ConstString from the function name at one point, so that might as well be a ConstString in the first place. If we had an implicit comparison than the conversion here would look really innocent and no one would notice.

[JDevlieghere]

lldb/source/Target/AssertFrameRecognizer.cpp

152

Hmm, you're totally right, I must be confusing this with something else then.

[aprantl]

lldb/source/Target/AssertFrameRecognizer.cpp

152

The *only* reason for using ConstString is using less memory for duplicate strings and being fast to compare against other ConstStrings.

Just for completeness, a huge use-case for ConstString in LLDB are as keys in DenseMaps and sorted vectors. This avoids redundantly string them in multiple StringMaps.

lldb/include/lldb/Target/StackFrameRecognizer.h

 /// \class StackFrameRecognizerManager
 ///
 /// Static class that provides a registry of known stack frame recognizers.
 /// Has static methods to add, enumerate, remove, query and invoke recognizers.
 
 class StackFrameRecognizerManager {
 public:
   static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
-                            ConstString module,
-                            ConstString symbol,
+                            ConstString module, ConstString symbol,
+                            ConstString alternate_symbol,
                             bool first_instruction_only = true);
 
   static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
                             lldb::RegularExpressionSP module,
                             lldb::RegularExpressionSP symbol,
                             bool first_instruction_only = true);
 
   static void ForEach(
       std::function<void(uint32_t recognizer_id, std::string recognizer_name,
                          std::string module, std::string symbol,
-                         bool regexp)> const &callback);
+                         std::string alternate_symbol, bool regexp)> const
+          &callback);
 
   static bool RemoveRecognizerWithID(uint32_t recognizer_id);
 
   static void RemoveAllRecognizers();
 
   static lldb::StackFrameRecognizerSP GetRecognizerForFrame(
       lldb::StackFrameSP frame);
 

lldb/source/Commands/CommandObjectFrame.cpp

if (m_options.m_regex) {
     auto module =
         RegularExpressionSP(new RegularExpression(m_options.m_module));
     auto func =
         RegularExpressionSP(new RegularExpression(m_options.m_function));
     StackFrameRecognizerManager::AddRecognizer(recognizer_sp, module, func);
   } else {
     auto module = ConstString(m_options.m_module);
     auto func = ConstString(m_options.m_function);
-    StackFrameRecognizerManager::AddRecognizer(recognizer_sp, module, func);
+    StackFrameRecognizerManager::AddRecognizer(recognizer_sp, module, func, {});
   }
 #endif
 
   result.SetStatus(eReturnStatusSuccessFinishNoResult);
   return result.Succeeded();
 }
 
 class CommandObjectFrameRecognizerClear : public CommandObjectParsed {
public:
   ~CommandObjectFrameRecognizerList() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     bool any_printed = false;
     StackFrameRecognizerManager::ForEach(
         [&result, &any_printed](uint32_t recognizer_id, std::string name,
                                 std::string function, std::string symbol,
-                                bool regexp) {
+                                std::string alternate_symbol, bool regexp) {
           if (name == "")
             name = "(internal)";
           result.GetOutputStream().Printf(
-              "%d: %s, module %s, function %s%s\n", recognizer_id, name.c_str(),
-              function.c_str(), symbol.c_str(), regexp ? " (regexp)" : "");
+              "%d: %s, module %s, function %s{%s}%s\n", recognizer_id,
+              name.c_str(), function.c_str(), symbol.c_str(),
+              alternate_symbol.c_str(), regexp ? " (regexp)" : "");
           any_printed = true;
         });
 
     if (any_printed)
       result.SetStatus(eReturnStatusSuccessFinishResult);
     else {
       result.GetOutputStream().PutCString("no matching results found.\n");
       result.SetStatus(eReturnStatusSuccessFinishNoResult);

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

 static void RegisterObjCExceptionRecognizer() {
   static llvm::once_flag g_once_flag;
   llvm::call_once(g_once_flag, []() {
     FileSpec module;
     ConstString function;
     std::tie(module, function) = AppleObjCRuntime::GetExceptionThrowLocation();
     StackFrameRecognizerManager::AddRecognizer(
         StackFrameRecognizerSP(new ObjCExceptionThrowFrameRecognizer()),
-        module.GetFilename(), function, /*first_instruction_only*/ true);
+        module.GetFilename(), function, /*alternate_symbol*/ {},
+        /*first_instruction_only*/ true);
   });
 }

lldb/source/Target/AssertFrameRecognizer.cpp

 
 #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.
+///    the abort module as a \a FileSpec and two symbol names as two \a
+///    StringRef. The second \a StringRef may be empty.
 ///    Otherwise, returns \a llvm::None.
-llvm::Optional<std::tuple<FileSpec, StringRef>>
+llvm::Optional<std::tuple<FileSpec, StringRef, StringRef>>
 GetAbortLocation(Process *process) {
   Target &target = process->GetTarget();
 
   FileSpec module_spec;
-  StringRef symbol_name;
+  StringRef symbol_name, alternate_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";
+    alternate_symbol_name = "__GI_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);
+  return std::make_tuple(module_spec, symbol_name, alternate_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.
+///    the asserting frame module as a \a FileSpec and two possible symbol
+///    names as two \a StringRef. The second \a StringRef may be empty.
 ///    Otherwise, returns \a llvm::None.
-llvm::Optional<std::tuple<FileSpec, StringRef>>
+llvm::Optional<std::tuple<FileSpec, StringRef, StringRef>>
 GetAssertLocation(Process *process) {
   Target &target = process->GetTarget();
 
   FileSpec module_spec;
-  StringRef symbol_name;
+  StringRef symbol_name, alternate_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";
+    alternate_symbol_name = "__GI___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);
+  return std::make_tuple(module_spec, symbol_name, alternate_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;
+    StringRef function_name, alternate_function_name;
+    std::tie(module_spec, function_name, alternate_function_name) =
+        *abort_location;
 
     StackFrameRecognizerManager::AddRecognizer(
         StackFrameRecognizerSP(new AssertFrameRecognizer()),
-        module_spec.GetFilename(), ConstString(function_name), false);
+        module_spec.GetFilename(), ConstString(function_name),
+        ConstString(alternate_function_name), /*first_instruction_only*/ 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;
+  StringRef function_name, alternate_function_name;
+  std::tie(module_spec, function_name, alternate_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)) {
+    if (!sym_ctx.module_sp->GetFileSpec().FileEquals(module_spec))
+      continue;
+
+    ConstString func_name = sym_ctx.GetFunctionName();
+    if (func_name == ConstString(function_name) ||
+        alternate_function_name.empty() ||
+        func_name == ConstString(alternate_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));

lldb/source/Target/StackFrameRecognizer.cpp

ScriptedStackFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame) {
   }
 
   return RecognizedStackFrameSP(
       new ScriptedRecognizedStackFrame(args_synthesized));
 }
 
 class StackFrameRecognizerManagerImpl {
 public:
-  void AddRecognizer(StackFrameRecognizerSP recognizer,
-                     ConstString module, ConstString symbol,
+  void AddRecognizer(StackFrameRecognizerSP recognizer, ConstString module,
+                     ConstString symbol, ConstString alternate_symbol,
                      bool first_instruction_only) {
-    m_recognizers.push_front({(uint32_t)m_recognizers.size(), false, recognizer, false, module, RegularExpressionSP(),
-                              symbol, RegularExpressionSP(),
+    m_recognizers.push_front({(uint32_t)m_recognizers.size(), false, recognizer,
+                              false, module, RegularExpressionSP(), symbol,
+                              alternate_symbol, RegularExpressionSP(),
                               first_instruction_only});
   }
 
   void AddRecognizer(StackFrameRecognizerSP recognizer,
                      RegularExpressionSP module, RegularExpressionSP symbol,
                      bool first_instruction_only) {
-    m_recognizers.push_front({(uint32_t)m_recognizers.size(), false, recognizer, true, ConstString(), module,
+    m_recognizers.push_front({(uint32_t)m_recognizers.size(), false, recognizer,
+                              true, ConstString(), module, ConstString(),
                               ConstString(), symbol, first_instruction_only});
   }
 
   void ForEach(
-      std::function<void(uint32_t recognized_id, std::string recognizer_name, std::string module,
-                         std::string symbol, bool regexp)> const &callback) {
+      std::function<void(uint32_t recognized_id, std::string recognizer_name,
+                         std::string module, std::string symbol,
+                         std::string alternate_symbol, bool regexp)> const
+          &callback) {
     for (auto entry : m_recognizers) {
       if (entry.is_regexp) {
         std::string module_name;
         std::string symbol_name;
 
         if (entry.module_regexp)
           module_name = entry.module_regexp->GetText().str();
         if (entry.symbol_regexp)
           symbol_name = entry.symbol_regexp->GetText().str();
 
         callback(entry.recognizer_id, entry.recognizer->GetName(), module_name,
-                 symbol_name, true);
+                 symbol_name, {}, true);
 
       } else {
-        callback(entry.recognizer_id, entry.recognizer->GetName(), entry.module.GetCString(),
-                 entry.symbol.GetCString(), false);
+        callback(entry.recognizer_id, entry.recognizer->GetName(),
+                 entry.module.GetCString(), entry.symbol.GetCString(),
+                 entry.alternate_symbol.GetCString(), false);
       }
     }
   }
 
   bool RemoveRecognizerWithID(uint32_t recognizer_id) {
     if (recognizer_id >= m_recognizers.size()) return false;
     if (m_recognizers[recognizer_id].deleted) return false;
     m_recognizers[recognizer_id].deleted = true;
for (auto entry : m_recognizers) {
       if (entry.deleted) continue;
       if (entry.module)
         if (entry.module != module_name) continue;
 
       if (entry.module_regexp)
         if (!entry.module_regexp->Execute(module_name.GetStringRef())) continue;
 
       if (entry.symbol)
-        if (entry.symbol != function_name) continue;
+        if (entry.symbol != function_name &&
+            (!entry.alternate_symbol ||
+             entry.alternate_symbol != function_name))
+          continue;
 
       if (entry.symbol_regexp)
         if (!entry.symbol_regexp->Execute(function_name.GetStringRef()))
           continue;
 
       if (entry.first_instruction_only)
         if (start_addr != current_addr) continue;
 
private:
   struct RegisteredEntry {
     uint32_t recognizer_id;
     bool deleted;
     StackFrameRecognizerSP recognizer;
     bool is_regexp;
     ConstString module;
     RegularExpressionSP module_regexp;
     ConstString symbol;
+    ConstString alternate_symbol;
     RegularExpressionSP symbol_regexp;
     bool first_instruction_only;
   };
 
   std::deque<RegisteredEntry> m_recognizers;
 };
 
 StackFrameRecognizerManagerImpl &GetStackFrameRecognizerManagerImpl() {
   static StackFrameRecognizerManagerImpl instance =
       StackFrameRecognizerManagerImpl();
   return instance;
 }
 
 void StackFrameRecognizerManager::AddRecognizer(
-    StackFrameRecognizerSP recognizer, ConstString module,
-    ConstString symbol, bool first_instruction_only) {
-  GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol,
-                                                     first_instruction_only);
+    StackFrameRecognizerSP recognizer, ConstString module, ConstString symbol,
+    ConstString alternate_symbol, bool first_instruction_only) {
+  GetStackFrameRecognizerManagerImpl().AddRecognizer(
+      recognizer, module, symbol, alternate_symbol, first_instruction_only);
 }
 
 void StackFrameRecognizerManager::AddRecognizer(
     StackFrameRecognizerSP recognizer, RegularExpressionSP module,
     RegularExpressionSP symbol, bool first_instruction_only) {
   GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol,
                                                      first_instruction_only);
 }
 
 void StackFrameRecognizerManager::ForEach(
-    std::function<void(uint32_t recognized_id, std::string recognizer_name, std::string module,
-                       std::string symbol, bool regexp)> const &callback) {
+    std::function<void(uint32_t recognized_id, std::string recognizer_name,
+                       std::string module, std::string symbol,
+                       std::string alternate_symbol, bool regexp)> const
+        &callback) {
   GetStackFrameRecognizerManagerImpl().ForEach(callback);
 }
 
 void StackFrameRecognizerManager::RemoveAllRecognizers() {
   GetStackFrameRecognizerManagerImpl().RemoveAllRecognizers();
 }
 
 bool StackFrameRecognizerManager::RemoveRecognizerWithID(uint32_t recognizer_id) {

lldb/test/Shell/Recognizer/assert.test

-# UNSUPPORTED: system-windows, system-linux
+# 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

lldb/unittests/Target/StackFrameRecognizerTest.cpp

TEST_F(StackFrameRecognizerTest, NullModuleRegex) {
   ASSERT_TRUE(debugger_sp);
 
   RegisterDummyStackFrameRecognizer();
 
   bool any_printed = false;
   StackFrameRecognizerManager::ForEach(
       [&any_printed](uint32_t recognizer_id, std::string name,
                      std::string function, std::string symbol,
+                     std::string alternate_symbol,
                      bool regexp) { any_printed = true; });
 
   EXPECT_TRUE(any_printed);
 }