Introduce new command: thread backtrace unique

[bgianfo]

Summary

This patch introduces a new thread backtrace command "unique".
The command is based off of "thread backtrace all" but will instead
find all threads which share matching call stacks and de-duplicate
their output, listing call stack and all the threads which share it.
This is especially useful for apps which use thread/task pools
sitting around waiting for work and cause excessive duplicate output.
I needed this behavior recently when debugging a core with 700+ threads.

[jingham]

The idea is great. I think it is a little confusing that you would do:

(lldb) thread backtrace all

to get all threads but

(lldb) thread unique-stacks

to backtrace the unique stacks. Wouldn't it be more logical to do:

(lldb) thread backtrace unique

It's really just another specification of the threads you are backtracing.

A few inline comments, we use '_' word separators for locals.

source/Commands/CommandObjectThread.cpp

344

uniqueStacks -> unique_stacks

384–385

We do local variables as: word_other_word, not camel-case.

393

found_match

[bgianfo]

This iteration addresses Jim's feedback.

I've updated all of the code to match the surrounding style where
I missed it originally. (branches/variable names)

I also moved the command under "thread backtrace unique".
This required refactoring the thread iterator command object.
I've tried to reuse as much as code possible in the thread iterator
so that we actually use HandleOneThread to push the rending of
of the call stack down to the BackTrace command.

The bucketing has been moved directly into the command iterator
when he user passes in the "unique" option.

[labath]

Sounds like an awesome feature.

Could you please add a test for it as well?

[jingham]

Pavel's right, it would be good to add a test case. You could modify the test case in packages/Python/lldbsuite/test/functionalities/thread/num_threads/ to this end. Note this Test Case used to be sitting mixed with the directories in the thread directory, but I just moved it into its own directory - so update before doing this. You could just make a few more thread 3's and break at the lock.unlock line. Then you should have a bunch of threads with the same stack, and your 'unique' listing would coalesce them. If you do this, please add it as a separate test (so make a new method 'test_unique' and redo the setup. That way the tests will remain independent.

There's a "functionalities/thread/backtrace_all" test that looks tempting to modify, but it doesn't actually look that amenable to modification for your purposes. The TestBacktraceAll.py there does show an example of running a command-line command, and looking for patterns in the result, which is what you'll need to add.

source/Commands/CommandObjectThread.cpp

225

Maybe "to see threads grouped by unique call stacks"? As written it sounds like you're going to show me the really cool call stacks.

[clayborg]

Add a test and fix the minor things as suggested and this will be good to go.

[bgianfo]

Address Pavel/Jim/Greg's feedback with the addition of a new test.

I followed Jim's advice and extended the existing num_threads suite
so that we start more thread3's. The new test_unique_stacks test case
was added to verify that we correct bucketing of the multiple thread3
call stacks executing across threads.

Thanks for the feedback thus far!

[labath]

Thanks for writing the test. We just need to make sure it runs in a stable manner.

packages/Python/lldbsuite/test/functionalities/thread/num_threads/TestNumThreads.py

91 ↗

(On Diff #100047)

I am afraid this is going to be very flaky. There's no guarantee that the threads will have had enough time to block in the lock call by the time you reach the breakpoint. The simplest solution would be to insert a sufficiently long (a couple of seconds) sleep in the inferior, but smarter positions are possible as well. For example, we could iterate through all SBThreads in the process and manually issue a Continue on all of them who haven't hit our predefined breakpoints yet.

packages/Python/lldbsuite/test/functionalities/thread/num_threads/main.cpp

52 ↗

(On Diff #100047)

I'd find for(auto &t: thread_3s) t.join() more understandable than this.

[bgianfo]

Address Pavel's feedback, made the unit test more robust.

This update increases the robustness of the new test I added.
We ensure synchronization, and force the threads into the state
we want them to be in by manually stepping them into place.

[labath]

thanks for the effort. I found the logic of the test quite difficult to follow, with multiple breakpoints and notify_calls(). Instead of trying to point out each problem, I figured it will be easier to write my take on how the test could look like: https://paste.ubuntu.com/24665770/. Besides making the logic flow nicer (I hope), it also avoids a couple of other potentially problematic spots in your test (reliance on the exact way we number threads, potentially infinite loop in the thread.StepInstruction calls, etc).

Let me know what you think.

[clayborg]

We should probably store the stacks as lldb::addr_t values that are load addresses for quicker comparisons and searches. Inlined code details things more clearly.

source/Commands/CommandObjectThread.cpp

76

Might be more efficient to store a "std::stack<lldb::addr_t>" where you store the load address of each address. The comparisons would go quicker, not to mention the construction and destruction of stack itself.

119

Add an operator function for UniqueStack that only compares the stack frames:

bool inline operator <(const UniqueStack &lhs, const UniqueStack &rhs) {
  return lhs.m_stack_frames < rhs.m_stack_frames;
}

The comparison will be cheap when m_stack_frames is a std::stack of lldb::addr_t values.

Then store as a std::set for efficient lookup later instead of a linear search.

138

std::set<UniqueSet> &unique_stacks;

154–155

const lldb::addr_t pc = frame_sp->GetStackID().GetPC();
stack_frames.push(pc);

160

use fast std::set.find() so search for the matching value.

[bgianfo]

Address Pavel and Greg's feedback on Diff 100365.

Pavel: I took your suggestions to make the test case more readable,
I really appreciate the guidance. I did have to tweak some of the
functionality to make the test case pass reliably, as there were
still some races possible. I also saw that SBThread.Resume() seems
to occasionally result in a StopReason of eStopReasonNon. So I worked
around that by only including threads int expected output that the Resume
resulted in making it to our breakpoint. I have verified the test is
consistently passes by executing it on repeat 100 times,

Greg: Thanks for the suggestions for using std::set, and lldb:adrr_t.
The code is a lot cleaner now, and as you mentioned should perform faster.
I didn't notice any significant speed up with my 700 thread dump however.

[clayborg]

Much cleaner. After seeing how we must construct a UniqueStack just so we can search for it, an even cleaner solution would be to make unique_stacks into:

std::map<std::vector<lldb::addr_t>

[clayborg]

Clicked submit too early with last comments. After seeing how we previously needed to create a temp UniqueStack just to do the lookup, and also how UniqueStack make its thread index ID list mutable, a better solution is to use a std::map as shown in the inlined comments.

One issue with this fix that we will need to fix is we will need to disable showing variable values in the stack backtrace. The default frame format is:

(lldb) settings show frame-format
frame-format (format-string) = "frame #${frame.index}: ${frame.pc}{ ${module.file.basename}{`${function.name-with-args}{${frame.no-debug}${function.pc-offset}}}}{ at ${line.file.basename}:${line.number}}{${function.is-optimized} [opt]}\n"

The main problem is we have "${function.name-with-args}" in the format string. We must detect we are trying to unique stacks and not try to print any thread variables otherwise we will not be showing the correct information to the user. This would mean piping the fact we are trying to unique stacks into the FormatEntity::Format() function in FormatEntity.h/.cpp and just don't show the variables in this case.

source/Commands/CommandObjectThread.cpp

50

After seeing how we have to create a temp UniqueStack so we can search for it in our set, we can do this a bit cleaner. We can get rid of this class if we use a std::map that maps from the unique stack load addresses to the thread ID list:

std::map<std::vector<lldb::addr_t>, std::vector<uint32_t>> unique_stacks;

So more changes below...

119

Change to:

std::map<std::vector<lldb::addr_t>, std::vector<uint32_t>> unique_stacks;

123

change to:

for (const auto &stacks_tids: unique_stacks) {

125

change to:

const std::vector<uint32_t>& thread_index_ids = stacks_tids.second;

133

change to:

// Since all threads have the same call stack we can just pick the first one.
uint32_t representative_thread_id = thread_index_ids.front();

138

std::map<std::vector<lldb::addr_t>, std::vector<uint32_t>> &unique_stacks

159

Remove this.

162

auto matching_stack = unique_stacks.find(stack_frames);

163–167

Can probably replace the entire if/else with:

unique_stacks[stack_frames].push_back(thread_index_id);

[clayborg]

The other option for fixing the problem with showing the wrong variables in the backtraces would be to make up a new frame-format string that is used for uniqued stack frames and use that format when showing uniqued stack frames:

(lldb) settings show frame-format-unique
frame-format (format-string) = "frame #${frame.index}: ${frame.pc}{ ${module.file.basename}{`${function.name}{${frame.no-debug}${function.pc-offset}}}}{ at ${line.file.basename}:${line.number}}{${function.is-optimized} [opt]}\n"

The only difference in the format string is we use ${function.name} instead of ${function.name-with-args}.

[clayborg]

Zach made some comments via e-mail:

Couple of things:

1. Unless you really really want iteration over this map to be in some deterministic order, better to use unordered_map. And if you do want it to be in some deterministic order, you should provide a comparison function, as the default one is probably not what you want.'

True. The previous solution had the same ordering as this map I proposed.

2. std::map<std::vector<lldb::addr_t>, std::vector<uint32_t>> is pretty horrible to read, and offers no insight into what the keys and values are. At the very least, add some typedefs like:

typedef std::vector<lldb::addr_t> StackID;
typedef std::vector<tid_t> ThreadIDList;
std::unordered_map<StackID, ThreadIDList> TheMap;

Agreed.

3. If performance is a concern here (700+ threads seems like it could exhibit slowdown when uniquing stacks), the best performance would be to use DenseSet<std::unique_ptr<StackInfo>>, where StackInfo contains both the address list and the thread is list as well as a pre-computed hash value, and then use a custom implementation of DenseMapInfo that just returns the hash value directly. See llvm/lib/DebugInfo/CodeView/TypeSerializer.cpp for an example.

Not sure I would go that far. When you include both things in the type (StackInfo here) then you must make one up in order to search for it right? We are mainly trying to create a collection of stacks that we can use to point the the thread IDs. I agreed it doesn't need to be sorted so std::unordered_map would work just fine.

The more I think about it, the previous approach was probably fine with the std::set and with the UniqueStack class. Lets just stick with that for now, but we still need to fix the display to not show variable values and claim that many threads have the same variable values when showing ${function.name-with-args}.

[bgianfo]

Fix bug in "unique" backtrace output that Greg pointed out.

Introduced a new format for unique frames and plumbed that
through the stacks to be able to toggle between them both
depending on the calling arguments.

[labath]

In D33426#766525, @bgianfo wrote:

Address Pavel and Greg's feedback on Diff 100365.

Pavel: I took your suggestions to make the test case more readable,
I really appreciate the guidance. I did have to tweak some of the
functionality to make the test case pass reliably, as there were
still some races possible. I also saw that SBThread.Resume() seems
to occasionally result in a StopReason of eStopReasonNon. So I worked
around that by only including threads int expected output that the Resume
resulted in making it to our breakpoint. I have verified the test is
consistently passes by executing it on repeat 100 times,

Thanks. The fact that we are not able to rely on the operation of Resume in this case sounds like a bug. Obviously we can't condition the acceptance of this patch by fixing that issue, but we should at least track it. Can you create a bug on bugs.llvm.org, and reference it in your workaround. BTW, what's the platform you are testing this on?

[clayborg]

Looks like a good starting point. Thanks for the changes.

[bgianfo]

@jingham @labath do you have any more feedback?

[labath]

In D33426#772174, @bgianfo wrote:

@jingham @labath do you have any more feedback?

As Jim pointed out, the Resume command does not do what I thought it does, so having it in the test makes no sense. One option would be to just leave out the calls to Resume (as they don't do anything anyway) and go with your workaround of testing the threads that happened to stop at the breakpoint on the first run. The other option would be to replace the Resume call with something that does what we intended (one such candidate would be thread.StepOut). I prefer the second one as it gives a more deterministic output, but I think both of them are good enough.

[bgianfo]

Update test to use thread.StepOut() instead of thread.Resume().

[labath]

Cool. Sorry about all the back-and-forth and thanks for the patience.

[jingham]

This looks fine to me.

[bgianfo]

Can someone commit this as I obviously don't have a svn commit bit?

[labath]

Committed as r305197. I needed to tweak the test logic a bit, as not even thread.StepOut() did exactly what we needed there, because it was resuming also all other threads even though it was not necessary. Take a look at the resulting commit if you want to see the differences: (spoiler: the magic command that worked was thread continue #id)

include/lldb/Target/Thread.h

 
   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,
-                   bool stop_format);
+                   bool stop_format, bool only_stacks = false);
 
   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

source/Commands/CommandObjectThread.cpp

 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Target/ThreadPlanStepRange.h"
 #include "lldb/lldb-private.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //-------------------------------------------------------------------------
-// CommandObjectThreadBacktrace
+// CommandObjectIterateOverThreads
 //-------------------------------------------------------------------------
 
 class CommandObjectIterateOverThreads : public CommandObjectParsed {
 public:
   CommandObjectIterateOverThreads(CommandInterpreter &interpreter,
                                   const char *name, const char *help,
                                   const char *syntax, uint32_t flags)
       : CommandObjectParsed(interpreter, name, help, syntax, flags) {}
 
   ~CommandObjectIterateOverThreads() override = default;
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     result.SetStatus(m_success_return);
bool DoExecute(Args &command, CommandReturnObject &result) override {
     // result from JIT-ing
     // code while iterating over the (locked) ThreadSP list.
     std::vector<lldb::tid_t> tids;
 
     if (command.GetArgumentCount() == 1 &&
         ::strcmp(command.GetArgumentAtIndex(0), "all") == 0) {
       Process *process = m_exe_ctx.GetProcessPtr();
 
       for (ThreadSP thread_sp : process->Threads())
         tids.push_back(thread_sp->GetID());
     } else {
       const size_t num_args = command.GetArgumentCount();
       Process *process = m_exe_ctx.GetProcessPtr();
 
       std::lock_guard<std::recursive_mutex> guard(
           process->GetThreadList().GetMutex());
 
bool DoExecute(Args &command, CommandReturnObject &result) override {
     uint32_t idx = 0;
     for (const lldb::tid_t &tid : tids) {
       if (idx != 0 && m_add_return)
         result.AppendMessage("");
 
       if (!HandleOneThread(tid, result))
         return false;
 
       ++idx;
     }
     return result.Succeeded();
   }
 
 protected:
   // Override this to do whatever you need to do for one thread.
   //
   // If you return false, the iteration will stop, otherwise it will proceed.
   // The result is set to m_success_return (defaults to
   // eReturnStatusSuccessFinishResult) before the iteration,
   // so you only need to set the return status in HandleOneThread if you want to
   // indicate an error.
   // If m_add_return is true, a blank line will be inserted between each of the
   // listings (except the last one.)
 
   virtual bool HandleOneThread(lldb::tid_t, CommandReturnObject &result) = 0;
 
   ReturnStatus m_success_return = eReturnStatusSuccessFinishResult;
   bool m_add_return = true;
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectThreadBacktrace
 //-------------------------------------------------------------------------
 
 static OptionDefinition g_thread_backtrace_options[] = {
     // clang-format off
   { LLDB_OPT_SET_1, false, "count",    'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCount,      "How many frames to display (-1 for all)" },
   { LLDB_OPT_SET_1, false, "start",    's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFrameIndex, "Frame in which to start the backtrace" },
   { LLDB_OPT_SET_1, false, "extended", 'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,    "Show the extended backtrace, if available" }
     // clang-format on
 };
 
 class CommandObjectThreadBacktrace : public CommandObjectIterateOverThreads {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
       // ()
       OptionParsingStarting(nullptr);
     }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'c': {
         int32_t input_count = 0;
         if (option_arg.getAsInteger(0, m_count)) {
           m_count = UINT32_MAX;
           error.SetErrorStringWithFormat(
public:
   CommandObjectThreadBacktrace(CommandInterpreter &interpreter)
       : CommandObjectIterateOverThreads(
             interpreter, "thread backtrace",
             "Show thread call stacks.  Defaults to the current thread, thread "
             "indexes can be specified as arguments.  Use the thread-index "
             "\"all\" "
             "to see all threads.",
             nullptr,
             eCommandRequiresProcess | eCommandRequiresThread |
                 eCommandTryTargetAPILock | eCommandProcessMustBeLaunched |
                 eCommandProcessMustBePaused),
         m_options() {}
 
   ~CommandObjectThreadBacktrace() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
     }
 
     return true;
   }
 
   CommandOptions m_options;
 };
 
+//-------------------------------------------------------------------------
+// CommandObjectUniqueThreadStacks
+//-------------------------------------------------------------------------
+
+class CommandObjectUniqueThreadStacks : public CommandObjectParsed {
+
+  class UniqueStack {
+
+  public:
+    UniqueStack(std::stack<Address> stackFrames, Thread* thread)
+      : m_stackFrames(stackFrames) {
+      m_threads.push_back(thread);
+    }
+
+    void AddThread(Thread* thread) {
+      m_threads.push_back(thread);
+    }
+
+    const std::vector<Thread*>& GetUniqueThreads() const { 
+      return m_threads;
+    }
+
+    Thread* GetRepresentativeThread() const {
+      return m_threads.front();
+    }
+
+    bool IsEqual(std::stack<Address> stackFrames) const {
+      return stackFrames == m_stackFrames;
+    }
+
+  protected:
+    std::vector<Thread*> m_threads;
+    std::stack<Address> m_stackFrames;
+  };
+
+public:
+  CommandObjectUniqueThreadStacks(CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "thread unique-stacks",
+            "Show unique call stacks for all threads in the process.",
+            nullptr,
+            eCommandRequiresThread | eCommandTryTargetAPILock |
+            eCommandProcessMustBeLaunched | eCommandProcessMustBePaused)
+    {
+    }
+
+  ~CommandObjectUniqueThreadStacks() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+
+    std::vector<UniqueStack> uniqueStacks;
+    Process *process = m_exe_ctx.GetProcessPtr();
+
+    // Iterate over threads, finding unique stack buckets.
+    for (ThreadSP thread_sp : process->Threads()) {
+      Thread *thread = thread_sp.get();
+      BucketThread(thread, uniqueStacks);
+    }
+
+    const uint32_t start_frame = 0;
+    const uint32_t num_frames = UINT32_MAX;
+    const uint32_t num_frames_with_source = 0;// UINT32_MAX;
+    const bool stop_format = true;
+    const bool just_stack = true;
+
+    // Output all of the unique stack frames.
+    Stream &strm = result.GetOutputStream();
+    strm.IndentMore();
+    for (const UniqueStack& stack: uniqueStacks) {
+      // List the common thread ID's
+      strm.Indent("thread(s) ");
+      for (Thread* thread : stack.GetUniqueThreads()) {
+        strm.Printf("#%lu ", thread->GetID());
+      }
+      strm.EOL();
+
+      // List the shared call stack for this set of threads
+      stack.GetRepresentativeThread()->GetStatus(strm, start_frame,
+                                                 num_frames, num_frames_with_source,
+                                                 stop_format, just_stack);
+    }
+    strm.IndentLess();
+
+    return result.Succeeded();
+  }
+
+protected:
+
+  void BucketThread(Thread* thread, std::vector<UniqueStack>& uniqueStacks) {
+    // Grab each frame's address
+    std::stack<Address> stackFrames;
+    const uint32_t frameCount = thread->GetStackFrameCount();
+    for (uint32_t frameIndex = 0; frameIndex < frameCount; frameIndex++)
+    {
+      const Address stackFrameAddress = thread->GetStackFrameAtIndex(frameIndex)->GetFrameCodeAddress();
+      stackFrames.push(stackFrameAddress);
+    }
+
+    // Try to match the threads stack to and existing thread.
+    bool foundMatch = false;
+    for (UniqueStack& uniqueStack : uniqueStacks)
+    {
+      if (uniqueStack.IsEqual(stackFrames)) {
+        foundMatch = true;
+        uniqueStack.AddThread(thread);
+      }
+    }
+
+    // We failed to find an existing unique stack, so create a new one.
+    if (!foundMatch) {
+      UniqueStack newUniqueStack(stackFrames, thread);
+      uniqueStacks.push_back(newUniqueStack);
+    }
+  }
+};
+
 enum StepScope { eStepScopeSource, eStepScopeInstruction };
 
 static OptionEnumValueElement g_tri_running_mode[] = {
     {eOnlyThisThread, "this-thread", "Run only this thread"},
     {eAllThreads, "all-threads", "Run all threads"},
     {eOnlyDuringStepping, "while-stepping",
      "Run only this thread while stepping"},
     {0, nullptr, nullptr}};

 CommandObjectMultiwordThread::CommandObjectMultiwordThread(
     CommandInterpreter &interpreter)
     : CommandObjectMultiword(interpreter, "thread", "Commands for operating on "
                                                     "one or more threads in "
                                                     "the current process.",
                              "thread <subcommand> [<subcommand-options>]") {
   LoadSubCommand("backtrace", CommandObjectSP(new CommandObjectThreadBacktrace(
                                   interpreter)));
+  LoadSubCommand("unique-stacks",
+                 CommandObjectSP(new CommandObjectUniqueThreadStacks(interpreter)));
   LoadSubCommand("continue",
                  CommandObjectSP(new CommandObjectThreadContinue(interpreter)));
   LoadSubCommand("list",
                  CommandObjectSP(new CommandObjectThreadList(interpreter)));
   LoadSubCommand("return",
                  CommandObjectSP(new CommandObjectThreadReturn(interpreter)));
   LoadSubCommand("jump",
                  CommandObjectSP(new CommandObjectThreadJump(interpreter)));

source/Core/Debugger.cpp

static PropertyDefinition g_properties[] = {
      "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 "
+                                     "string to use when 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)."},

source/Target/Thread.cpp

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,
-                         bool stop_format) {
+                         bool stop_format, bool only_stacks) {
+
+  if (!only_stacks) {
     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, stop_format);
+  }
 
+  size_t num_frames_shown = 0;
   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 || only_stacks ||
         (GetID() != GetProcess()->GetThreadList().GetSelectedThread()->GetID()))
       strm.IndentMore();
     else
       selected_frame_marker = "* ";
 
     num_frames_shown = GetStackFrameList()->GetStatus(
         strm, start_frame, num_frames, show_frame_info, num_frames_with_source,
         selected_frame_marker);