Clean up the default stop messages for thread and frame

[jingham]

Summary

The stop information you get when lldb stops is noisy and redundant. Part of this was because we had only one thread stop format, which was getting used in "thread list" where it's quite useful to see where the thread is stopped, and in the normal stop message, where we're going to print the frame info immediately below, so the function information is not relevant.

It's also a little noisy to print the PC in a frame that has debug information. So I added a thread-stop-format which gets used in the stop message. The one used in "thread-list" will stay the same.

The old stop record looks like:

• thread #1: tid = 0x29428a, 0x0000000100018fe7 Sketch`main(argc=1, argv=0x00007fff5fbff5a0) + 55 at SKTMain.m:19, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1 frame #0: 0x0000000100018fe7 Sketch`main(argc=1, argv=0x00007fff5fbff5a0) + 55 at SKTMain.m:19

With this diff, the default form will be:

• thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1 frame #0: Sketch`main(argc=1, argv=0x00007fff5fbff618) at SKTMain.m:19

If you stop in a frame with no debug info, you will still see the PC & offset:

• thread #1, name = 'A_Cool_Thread', stop reason = trace frame #0: 0x000000010004c85e dyld`gdb_image_notifier(dyld_image_mode, unsigned int, dyld_image_info const*) + 1

I haven't gone through the test suite consequences of this change. Should be none, but I wouldn't be surprised if somebody is scraping stop output when they shouldn't be... I'll do that before committing, I just wanted to get this out there in case the form of the new output bugs people.

[jingham]

Pasting the text into the description auto-wrapped, which masks the difference... This looks better:

Old:

* thread #1: tid = 0x29428a, 0x0000000100018fe7 Sketch`main(argc=1, argv=0x00007fff5fbff5a0) + 55 at SKTMain.m:19, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
    frame #0: 0x0000000100018fe7 Sketch`main(argc=1, argv=0x00007fff5fbff5a0) + 55 at SKTMain.m:19

New:

* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
    frame #0: Sketch`main(argc=1, argv=0x00007fff5fbff618) at SKTMain.m:19

[clayborg]

Looks fine to me. If we don't agree on the default format that should be used, then we can do that in a separate patch.

[jingham]

Committed as r286288.

include/lldb/API/SBThread.h

public:
   const lldb::SBThread &operator=(const lldb::SBThread &rhs);
 
   bool operator==(const lldb::SBThread &rhs) const;
 
   bool operator!=(const lldb::SBThread &rhs) const;
 
   bool GetDescription(lldb::SBStream &description) const;
 
+  bool GetDescription(lldb::SBStream &description, bool stop_format) const;
+
   bool GetStatus(lldb::SBStream &status) const;
 
   SBThread GetExtendedBacktraceThread(const char *type);
 
   uint32_t GetExtendedBacktraceOriginatingIndexID();
 
   bool SafeToCallFunctions();
 

include/lldb/Core/Debugger.h

public:
   bool GetAutoConfirm() const;
 
   const FormatEntity::Entry *GetDisassemblyFormat() const;
 
   const FormatEntity::Entry *GetFrameFormat() const;
 
   const FormatEntity::Entry *GetThreadFormat() const;
 
+  const FormatEntity::Entry *GetThreadStopFormat() const;
+
   lldb::ScriptLanguage GetScriptLanguage() const;
 
   bool SetScriptLanguage(lldb::ScriptLanguage script_lang);
 
   uint32_t GetTerminalWidth() const;
 
   bool SetTerminalWidth(uint32_t term_width);
 

include/lldb/Core/FormatEntity.h

enum class Type {
       ScriptThread,
       ThreadInfo,
       TargetArch,
       ScriptTarget,
       ModuleFile,
       File,
       Lang,
       FrameIndex,
+      FrameNoDebug,
       FrameRegisterPC,
       FrameRegisterSP,
       FrameRegisterFP,
       FrameRegisterFlags,
       FrameRegisterByName,
       ScriptFrame,
       FunctionID,
       FunctionDidChange,

include/lldb/Target/Process.h

RunThreadPlan(ExecutionContext &exe_ctx, lldb::ThreadPlanSP &thread_plan_sp,
                 DiagnosticManager &diagnostic_manager);
 
   static const char *ExecutionResultAsCString(lldb::ExpressionResults result);
 
   void GetStatus(Stream &ostrm);
 
   size_t GetThreadStatus(Stream &ostrm, bool only_threads_with_stop_reason,
                          uint32_t start_frame, uint32_t num_frames,
-                         uint32_t num_frames_with_source);
+                         uint32_t num_frames_with_source,
+                         bool stop_format);
 
   void SendAsyncInterrupt();
 
   //------------------------------------------------------------------
   // Notify this process class that modules got loaded.
   //
   // If subclasses override this method, they must call this version
   // before doing anything in the subclass version of the function.

include/lldb/Target/Thread.h

virtual void ClearBackingThread() {
     // where they might have a thread that is in memory, yet its registers
     // are available through the lldb_private::Thread subclass for the current
     // lldb_private::Process class. Since each time the process stops the
     // backing
     // threads for memory threads can change, we need a way to clear the backing
     // thread for all memory threads each time we stop.
   }
 
-  void DumpUsingSettingsFormat(Stream &strm, uint32_t frame_idx);
+  // If stop_format is true, this will be the form used when we print stop info.
+  // If false, it will be the form we use for thread list and co.
+  void DumpUsingSettingsFormat(Stream &strm, uint32_t frame_idx, 
+                               bool stop_format);
  
   bool GetDescription(Stream &s, lldb::DescriptionLevel level,
                       bool print_json_thread, bool print_json_stopinfo);
 
   //------------------------------------------------------------------
   /// Default implementation for stepping into.
   ///
   /// This function is designed to be used by commands where the
   /// process is publicly stopped.

   lldb::StackFrameSP CalculateStackFrame() override;
 
   void CalculateExecutionContext(ExecutionContext &exe_ctx) override;
 
   lldb::StackFrameSP
   GetStackFrameSPForStackFramePtr(StackFrame *stack_frame_ptr);
 
   size_t GetStatus(Stream &strm, uint32_t start_frame, uint32_t num_frames,
-                   uint32_t num_frames_with_source);
+                   uint32_t num_frames_with_source,
+                   bool stop_format);
 
   size_t GetStackFrameStatus(Stream &strm, uint32_t first_frame,
                              uint32_t num_frames, bool show_frame_info,
                              uint32_t num_frames_with_source);
 
   // We need a way to verify that even though we have a thread in a shared
   // pointer that the object itself is still valid. Currently this won't be
   // the case if DestroyThread() was called. DestroyThread is called when

scripts/interface/SBThread.i

~SBThread();
     SetSelectedFrame (uint32_t frame_idx);
 
     lldb::SBProcess
     GetProcess ();
 
     bool
     GetDescription (lldb::SBStream &description) const;
     
+    %feature("docstring", "
+    //--------------------------------------------------------------------------
+    /// Get the description strings for this thread that match what the 
+    /// lldb driver will present, using the thread-format (stop_format==false)
+    /// or thread-stop-format (stop_format = true).␓ 
+    //--------------------------------------------------------------------------
+    ") GetDescription;
+    bool GetDescription(lldb::SBStream &description, bool stop_format) const;
+
     bool
     GetStatus (lldb::SBStream &status) const;
     
     bool
     operator == (const lldb::SBThread &rhs) const;
 
     bool
     operator != (const lldb::SBThread &rhs) const;

source/API/SBThread.cpp

 
 bool SBThread::GetStatus(SBStream &status) const {
   Stream &strm = status.ref();
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
-    exe_ctx.GetThreadPtr()->GetStatus(strm, 0, 1, 1);
+    exe_ctx.GetThreadPtr()->GetStatus(strm, 0, 1, 1, true);
   } else
     strm.PutCString("No status");
 
   return true;
 }
 
 bool SBThread::GetDescription(SBStream &description) const {
+    return GetDescription(description, false);
+}
+
+bool SBThread::GetDescription(SBStream &description, bool stop_format) const {
   Stream &strm = description.ref();
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (exe_ctx.HasThreadScope()) {
     exe_ctx.GetThreadPtr()->DumpUsingSettingsFormat(strm,
-                                                    LLDB_INVALID_THREAD_ID);
+                                                    LLDB_INVALID_THREAD_ID,
+                                                    stop_format);
     // strm.Printf("SBThread: tid = 0x%4.4" PRIx64,
     // exe_ctx.GetThreadPtr()->GetID());
   } else
     strm.PutCString("No value");
 
   return true;
 }
 

source/Commands/CommandObjectMemory.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (!memory_history) {
       result.AppendError("no available memory history provider");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     HistoryThreads thread_list = memory_history->GetHistoryThreads(addr);
 
+    const bool stop_format = false;
     for (auto thread : thread_list) {
-      thread->GetStatus(*output_stream, 0, UINT32_MAX, 0);
+      thread->GetStatus(*output_stream, 0, UINT32_MAX, 0, stop_format);
     }
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
 
     return true;
   }
 };
 

source/Commands/CommandObjectProcess.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     // No need to check "process" for validity as eCommandRequiresProcess
     // ensures it is valid
     Process *process = m_exe_ctx.GetProcessPtr();
     const bool only_threads_with_stop_reason = true;
     const uint32_t start_frame = 0;
     const uint32_t num_frames = 1;
     const uint32_t num_frames_with_source = 1;
+    const bool     stop_format = true;
     process->GetStatus(strm);
     process->GetThreadStatus(strm, only_threads_with_stop_reason, start_frame,
-                             num_frames, num_frames_with_source);
+                             num_frames, num_frames_with_source, stop_format);
     return result.Succeeded();
   }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectProcessHandle
 //-------------------------------------------------------------------------
 

source/Commands/CommandObjectTarget.cpp

if (properties > 0)
     strm.PutCString(" )\n");
   else
     strm.EOL();
   if (show_process_status) {
     const bool only_threads_with_stop_reason = true;
     const uint32_t start_frame = 0;
     const uint32_t num_frames = 1;
     const uint32_t num_frames_with_source = 1;
+    const bool     stop_format = false;
     process_sp->GetStatus(strm);
     process_sp->GetThreadStatus(strm, only_threads_with_stop_reason,
                                 start_frame, num_frames,
-                                num_frames_with_source);
+                                num_frames_with_source, stop_format);
   }
 }
 
 static uint32_t DumpTargetList(TargetList &target_list,
                                bool show_stopped_process_status, Stream &strm) {
   const uint32_t num_targets = target_list.GetNumTargets();
   if (num_targets) {
     TargetSP selected_target_sp(target_list.GetSelectedTarget());

source/Commands/CommandObjectThread.cpp

if (runtime) {
       Stream &strm = result.GetOutputStream();
       const std::vector<ConstString> &types =
           runtime->GetExtendedBacktraceTypes();
       for (auto type : types) {
         ThreadSP ext_thread_sp = runtime->GetExtendedBacktraceThread(
             thread->shared_from_this(), type);
         if (ext_thread_sp && ext_thread_sp->IsValid()) {
           const uint32_t num_frames_with_source = 0;
+          const bool stop_format = false;
           if (ext_thread_sp->GetStatus(strm, m_options.m_start,
                                        m_options.m_count,
-                                       num_frames_with_source)) {
+                                       num_frames_with_source,
+                                       stop_format)) {
             DoExtendedBacktrace(ext_thread_sp.get(), result);
           }
         }
       }
     }
   }
 
   bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
     Thread *thread = thread_sp.get();
 
     Stream &strm = result.GetOutputStream();
 
     // Don't show source context when doing backtraces.
     const uint32_t num_frames_with_source = 0;
 
     if (!thread->GetStatus(strm, m_options.m_start, m_options.m_count,
-                           num_frames_with_source)) {
+                           num_frames_with_source, false)) {
       result.AppendErrorWithFormat(
           "error displaying backtrace for thread: \"0x%4.4x\"\n",
           thread->GetIndexID());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
     if (m_options.m_extended_backtrace) {
       DoExtendedBacktrace(thread, result);
bool DoExecute(Args &command, CommandReturnObject &result) override {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     Process *process = m_exe_ctx.GetProcessPtr();
     const bool only_threads_with_stop_reason = false;
     const uint32_t start_frame = 0;
     const uint32_t num_frames = 0;
     const uint32_t num_frames_with_source = 0;
     process->GetStatus(strm);
     process->GetThreadStatus(strm, only_threads_with_stop_reason, start_frame,
-                             num_frames, num_frames_with_source);
+                             num_frames, num_frames_with_source, false);
     return result.Succeeded();
   }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectThreadInfo
 //-------------------------------------------------------------------------
 

source/Core/Debugger.cpp

OptionEnumValueElement g_language_enumerators[] = {
     {eScriptLanguagePython, "python",
      "Select python as the default scripting language."},
     {eScriptLanguageDefault, "default",
      "Select the lldb default as the default scripting language."},
     {0, nullptr, nullptr}};
 
 #define MODULE_WITH_FUNC                                                       \
   "{ "                                                                         \
-  "${module.file.basename}{`${function.name-with-args}${function.pc-offset}}}"
+  "${module.file.basename}{`${function.name-with-args}"                        \
+  "{${frame.no-debug}${function.pc-offset}}}}"
 #define FILE_AND_LINE "{ at ${line.file.basename}:${line.number}}"
 #define IS_OPTIMIZED "{${function.is-optimized} [opt]}"
 
 #define DEFAULT_THREAD_FORMAT                                                  \
   "thread #${thread.index}: tid = ${thread.id%tid}"                            \
   "{, ${frame.pc}}" MODULE_WITH_FUNC FILE_AND_LINE                             \
   "{, name = '${thread.name}'}"                                                \
   "{, queue = '${thread.queue}'}"                                              \
   "{, activity = '${thread.info.activity.name}'}"                              \
   "{, ${thread.info.trace_messages} messages}"                                 \
   "{, stop reason = ${thread.stop-reason}}"                                    \
   "{\\nReturn value: ${thread.return-value}}"                                  \
   "{\\nCompleted expression: ${thread.completed-expression}}"                  \
   "\\n"
 
+#define DEFAULT_THREAD_STOP_FORMAT                                             \
+  "thread #${thread.index}{, name = '${thread.name}'}"                         \
+  "{, queue = '${thread.queue}'}"                                              \
+  "{, activity = '${thread.info.activity.name}'}"                              \
+  "{, ${thread.info.trace_messages} messages}"                                 \
+  "{, stop reason = ${thread.stop-reason}}"                                    \
+  "{\\nReturn value: ${thread.return-value}}"                                  \
+  "{\\nCompleted expression: ${thread.completed-expression}}"                  \
+  "\\n"
+
 #define DEFAULT_FRAME_FORMAT                                                   \
-  "frame #${frame.index}: ${frame.pc}" MODULE_WITH_FUNC FILE_AND_LINE          \
+  "frame #${frame.index}:{ ${frame.no-debug}${frame.pc}}" MODULE_WITH_FUNC FILE_AND_LINE          \
       IS_OPTIMIZED "\\n"
 
 // Three parts to this disassembly format specification:
 //   1. If this is a new function/symbol (no previous symbol/function), print
 //      dylib`funcname:\n
 //   2. If this is a symbol context change (different from previous
 //   symbol/function), print
 //      dylib`funcname:\n
static PropertyDefinition g_properties[] = {
      "When displaying the column marker in a color-enabled (i.e. ANSI) "
      "terminal, use the ANSI terminal code specified in this format "
      "immediately after the column to be marked."},
     {"term-width", OptionValue::eTypeSInt64, true, 80, nullptr, nullptr,
      "The maximum number of columns to use for displaying text."},
     {"thread-format", OptionValue::eTypeFormatEntity, true, 0,
      DEFAULT_THREAD_FORMAT, nullptr, "The default thread format string to use "
                                      "when displaying thread information."},
+    {"thread-stop-format", OptionValue::eTypeFormatEntity, true, 0,
+     DEFAULT_THREAD_STOP_FORMAT, nullptr, "The default thread format  "
+                                     "string to usewhen displaying thread "
+                                     "information as part of the stop display."},
     {"use-external-editor", OptionValue::eTypeBoolean, true, false, nullptr,
      nullptr, "Whether to use an external editor or not."},
     {"use-color", OptionValue::eTypeBoolean, true, true, nullptr, nullptr,
      "Whether to use Ansi color codes or not."},
     {"auto-one-line-summaries", OptionValue::eTypeBoolean, true, true, nullptr,
      nullptr, "If true, LLDB will automatically display small structs in "
               "one-liner format (default: true)."},
     {"auto-indent", OptionValue::eTypeBoolean, true, true, nullptr, nullptr,
enum {
   ePropertyStopDisassemblyDisplay,
   ePropertyStopLineCountAfter,
   ePropertyStopLineCountBefore,
   ePropertyStopShowColumn,
   ePropertyStopShowColumnAnsiPrefix,
   ePropertyStopShowColumnAnsiSuffix,
   ePropertyTerminalWidth,
   ePropertyThreadFormat,
+  ePropertyThreadStopFormat,
   ePropertyUseExternalEditor,
   ePropertyUseColor,
   ePropertyAutoOneLineSummaries,
   ePropertyAutoIndent,
   ePropertyPrintDecls,
   ePropertyTabSize,
   ePropertyEscapeNonPrintables
 };
void Debugger::SetPrompt(llvm::StringRef p) {
   GetCommandInterpreter().UpdatePrompt(new_prompt);
 }
 
 const FormatEntity::Entry *Debugger::GetThreadFormat() const {
   const uint32_t idx = ePropertyThreadFormat;
   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 }
 
+const FormatEntity::Entry *Debugger::GetThreadStopFormat() const {
+  const uint32_t idx = ePropertyThreadStopFormat;
+  return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
+}
+
 lldb::ScriptLanguage Debugger::GetScriptLanguage() const {
   const uint32_t idx = ePropertyScriptLanguage;
   return (lldb::ScriptLanguage)m_collection_sp->GetPropertyAtIndexAsEnumeration(
       nullptr, idx, g_properties[idx].default_uint_value);
 }
 
 bool Debugger::SetScriptLanguage(lldb::ScriptLanguage script_lang) {
   const uint32_t idx = ePropertyScriptLanguage;
void Debugger::HandleProcessEvent(const EventSP &event_sp) {
   }
 }
 
 void Debugger::HandleThreadEvent(const EventSP &event_sp) {
   // At present the only thread event we handle is the Frame Changed event,
   // and all we do for that is just reprint the thread status for that thread.
   using namespace lldb;
   const uint32_t event_type = event_sp->GetType();
+  const bool stop_format = true;
   if (event_type == Thread::eBroadcastBitStackChanged ||
       event_type == Thread::eBroadcastBitThreadSelected) {
     ThreadSP thread_sp(
         Thread::ThreadEventData::GetThreadFromEvent(event_sp.get()));
     if (thread_sp) {
-      thread_sp->GetStatus(*GetAsyncOutputStream(), 0, 1, 1);
+      thread_sp->GetStatus(*GetAsyncOutputStream(), 0, 1, 1, stop_format);
     }
   }
 }
 
 bool Debugger::IsForwardingEvents() { return (bool)m_forward_listener_sp; }
 
 void Debugger::EnableForwardEvents(const ListenerSP &listener_sp) {
   m_forward_listener_sp = listener_sp;

source/Core/FormatEntity.cpp

static FormatEntity::Entry::Definition g_file_child_entries[] = {
     ENTRY_VALUE("fullpath", ParentNumber, CString, FileKind::Fullpath)};
 
 static FormatEntity::Entry::Definition g_frame_child_entries[] = {
     ENTRY("index", FrameIndex, UInt32),
     ENTRY("pc", FrameRegisterPC, UInt64),
     ENTRY("fp", FrameRegisterFP, UInt64),
     ENTRY("sp", FrameRegisterSP, UInt64),
     ENTRY("flags", FrameRegisterFlags, UInt64),
+    ENTRY("no-debug", FrameNoDebug, None),
     ENTRY_CHILDREN("reg", FrameRegisterByName, UInt64, g_string_entry),
 };
 
 static FormatEntity::Entry::Definition g_function_child_entries[] = {
     ENTRY("id", FunctionID, UInt64), ENTRY("name", FunctionName, CString),
     ENTRY("name-without-args", FunctionNameNoArgs, CString),
     ENTRY("name-with-args", FunctionNameWithArgs, CString),
     ENTRY("addr-offset", FunctionAddrOffset, UInt64),
switch (t) {
     ENUM_TO_CSTR(ScriptThread);
     ENUM_TO_CSTR(ThreadInfo);
     ENUM_TO_CSTR(TargetArch);
     ENUM_TO_CSTR(ScriptTarget);
     ENUM_TO_CSTR(ModuleFile);
     ENUM_TO_CSTR(File);
     ENUM_TO_CSTR(Lang);
     ENUM_TO_CSTR(FrameIndex);
+    ENUM_TO_CSTR(FrameNoDebug);
     ENUM_TO_CSTR(FrameRegisterPC);
     ENUM_TO_CSTR(FrameRegisterSP);
     ENUM_TO_CSTR(FrameRegisterFP);
     ENUM_TO_CSTR(FrameRegisterFlags);
     ENUM_TO_CSTR(FrameRegisterByName);
     ENUM_TO_CSTR(ScriptFrame);
     ENUM_TO_CSTR(FunctionID);
     ENUM_TO_CSTR(FunctionDidChange);
if (exe_ctx) {
       if (frame) {
         if (DumpRegister(s, frame, eRegisterKindGeneric,
                          LLDB_REGNUM_GENERIC_FLAGS, (lldb::Format)entry.number))
           return true;
       }
     }
     return false;
 
+  case Entry::Type::FrameNoDebug:
+    if (exe_ctx) {
+      StackFrame *frame = exe_ctx->GetFramePtr();
+      if (frame) {
+        return !frame->HasDebugInformation();
+      }
+    }
+    return true;
+
   case Entry::Type::FrameRegisterByName:
     if (exe_ctx) {
       StackFrame *frame = exe_ctx->GetFramePtr();
       if (frame) {
         if (DumpRegister(s, frame, entry.string.c_str(),
                          (lldb::Format)entry.number))
           return true;
       }

source/Target/Process.cpp

if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get())) {
       if (stream) {
         Debugger &debugger = process_sp->GetTarget().GetDebugger();
         if (debugger.GetTargetList().GetSelectedTarget().get() ==
             &process_sp->GetTarget()) {
           const bool only_threads_with_stop_reason = true;
           const uint32_t start_frame = 0;
           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);
+                                      num_frames_with_source,
+                                      stop_format);
           if (curr_thread_stop_info_sp) {
             lldb::addr_t crashing_address;
             ValueObjectSP valobj_sp = StopInfo::GetCrashingDereference(
                 curr_thread_stop_info_sp, &crashing_address);
             if (valobj_sp) {
               const bool qualify_cxx_base_classes = false;
 
               const ValueObject::GetExpressionPathFormat format =
void Process::GetStatus(Stream &strm) {
   } else {
     strm.Printf("Process %" PRIu64 " is running.\n", GetID());
   }
 }
 
 size_t Process::GetThreadStatus(Stream &strm,
                                 bool only_threads_with_stop_reason,
                                 uint32_t start_frame, uint32_t num_frames,
-                                uint32_t num_frames_with_source) {
+                                uint32_t num_frames_with_source,
+                                bool stop_format) {
   size_t num_thread_infos_dumped = 0;
 
   // You can't hold the thread list lock while calling Thread::GetStatus.  That
   // very well might run code (e.g. if we need it
   // to get return values or arguments.)  For that to work the process has to be
   // able to acquire it.  So instead copy the thread
   // ID's, and look them up one by one:
 
for (uint32_t i = 0; i < num_threads; i++) {
     ThreadSP thread_sp(GetThreadList().FindThreadByID(thread_id_array[i]));
     if (thread_sp) {
       if (only_threads_with_stop_reason) {
         StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
         if (!stop_info_sp || !stop_info_sp->IsValid())
           continue;
       }
       thread_sp->GetStatus(strm, start_frame, num_frames,
-                           num_frames_with_source);
+                           num_frames_with_source,
+                           stop_format);
       ++num_thread_infos_dumped;
     } else {
       Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
       if (log)
         log->Printf("Process::GetThreadStatus - thread 0x" PRIu64
                     " vanished while running Thread::GetStatus.");
     }
   }

source/Target/Thread.cpp

Error Thread::JumpToLine(const FileSpec &file, uint32_t line,
   }
 
   if (!reg_ctx->SetPC(dest))
     return Error("Cannot change PC to target address.");
 
   return Error();
 }
 
-void Thread::DumpUsingSettingsFormat(Stream &strm, uint32_t frame_idx) {
+void Thread::DumpUsingSettingsFormat(Stream &strm, uint32_t frame_idx,
+                                     bool stop_format) {
   ExecutionContext exe_ctx(shared_from_this());
   Process *process = exe_ctx.GetProcessPtr();
   if (process == nullptr)
     return;
 
   StackFrameSP frame_sp;
   SymbolContext frame_sc;
   if (frame_idx != LLDB_INVALID_FRAME_ID) {
     frame_sp = GetStackFrameAtIndex(frame_idx);
     if (frame_sp) {
       exe_ctx.SetFrameSP(frame_sp);
       frame_sc = frame_sp->GetSymbolContext(eSymbolContextEverything);
     }
   }
 
-  const FormatEntity::Entry *thread_format =
-      exe_ctx.GetTargetRef().GetDebugger().GetThreadFormat();
+  const FormatEntity::Entry *thread_format;
+  if (stop_format)
+    thread_format = exe_ctx.GetTargetRef().GetDebugger().GetThreadStopFormat();
+  else
+    thread_format = exe_ctx.GetTargetRef().GetDebugger().GetThreadFormat();
+
   assert(thread_format);
 
   FormatEntity::Format(*thread_format, strm, frame_sp ? &frame_sc : nullptr,
                        &exe_ctx, nullptr, nullptr, false, false);
 }
 
 void Thread::SettingsInitialize() {}
 
const char *Thread::RunModeAsCString(lldb::RunMode mode) {
 
   static char unknown_state_string[64];
   snprintf(unknown_state_string, sizeof(unknown_state_string), "RunMode = %i",
            mode);
   return unknown_state_string;
 }
 
 size_t Thread::GetStatus(Stream &strm, uint32_t start_frame,
-                         uint32_t num_frames, uint32_t num_frames_with_source) {
+                         uint32_t num_frames, uint32_t num_frames_with_source,
+                         bool stop_format) {
   ExecutionContext exe_ctx(shared_from_this());
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   size_t num_frames_shown = 0;
   strm.Indent();
   bool is_selected = false;
   if (process) {
     if (process->GetThreadList().GetSelectedThread().get() == this)
       is_selected = true;
   }
   strm.Printf("%c ", is_selected ? '*' : ' ');
   if (target && target->GetDebugger().GetUseExternalEditor()) {
     StackFrameSP frame_sp = GetStackFrameAtIndex(start_frame);
     if (frame_sp) {
       SymbolContext frame_sc(
           frame_sp->GetSymbolContext(eSymbolContextLineEntry));
       if (frame_sc.line_entry.line != 0 && frame_sc.line_entry.file) {
         Host::OpenFileInExternalEditor(frame_sc.line_entry.file,
                                        frame_sc.line_entry.line);
       }
     }
   }
 
-  DumpUsingSettingsFormat(strm, start_frame);
+  DumpUsingSettingsFormat(strm, start_frame, stop_format);
 
   if (num_frames > 0) {
     strm.IndentMore();
 
     const bool show_frame_info = true;
 
     const char *selected_frame_marker = nullptr;
     if (num_frames == 1 ||
if (num_frames == 1)
       strm.IndentLess();
     strm.IndentLess();
   }
   return num_frames_shown;
 }
 
 bool Thread::GetDescription(Stream &strm, lldb::DescriptionLevel level,
                             bool print_json_thread, bool print_json_stopinfo) {
-  DumpUsingSettingsFormat(strm, 0);
+  const bool stop_format = false;
+  DumpUsingSettingsFormat(strm, 0, stop_format);
   strm.Printf("\n");
 
   StructuredData::ObjectSP thread_info = GetExtendedInfo();
 
   if (print_json_thread || print_json_stopinfo) {
     if (thread_info && print_json_thread) {
       thread_info->Dump(strm);
       strm.Printf("\n");

www/formats.html

<div id="middle">
                    <p>A complete list of currently supported format string variables is listed below:</p>
 
                    <table border="1">
                     <tr valign=top><td><b>Variable Name</b></td><td><b>Description</b></td></tr>
                     <tr valign=top><td><b>file.basename</b></td><td>The current compile unit file basename for the current frame.</td></tr>
                     <tr valign=top><td><b>file.fullpath</b></td><td>The current compile unit file fullpath for the current frame.</td></tr>
                     <tr valign=top><td><b>language</b></td><td>The current compile unit language for the current frame.</td></tr>
                     <tr valign=top><td><b>frame.index</b></td><td>The frame index (0, 1, 2, 3...)</td></tr>
+                    <tr valign=top><td><b>frame.no-debug</b></td><td>Evaluates to true if the frame has no debug info.</td></tr>
                     <tr valign=top><td><b>frame.pc</b></td><td>The generic frame register for the program counter.</td></tr>
                     <tr valign=top><td><b>frame.sp</b></td><td>The generic frame register for the stack pointer.</td></tr>
                     <tr valign=top><td><b>frame.fp</b></td><td>The generic frame register for the frame pointer.</td></tr>
                     <tr valign=top><td><b>frame.flags</b></td><td>The generic frame register for the flags register.</td></tr>
                     <tr valign=top><td><b>frame.reg.NAME</b></td><td>Access to any platform specific register by name (replace <b>NAME</b> with the name of the desired register).</td></tr>
                     <tr valign=top><td><b>function.name</b></td><td>The name of the current function or symbol.</td></tr>
                     <tr valign=top><td><b>function.name-with-args</b></td><td>The name of the current function with arguments and values or the symbol name.</td></tr>
                     <tr valign=top><td><b>function.name-without-args</b></td><td>The name of the current function without arguments and values (used to include a function name in-line in the <tt>disassembly-format</tt>)</td></tr>