[lldb] Add --stack option to `target symbols add` command

[JDevlieghere]

Summary

Currently you can ask the target symbols add command to locate the debug symbols for the current frame. This patch add an options to do that for the whole call stack.

[kastiglione]

lldb/source/Commands/CommandObjectTarget.cpp

4268–4271

Is this missing a return?

4281–4282

we don't have an iterator for this?

[kastiglione]

lldb/source/Commands/CommandObjectTarget.cpp

4301–4302

do you need the separate variable? can it be:

flush |= true;

[JDevlieghere]

lldb/source/Commands/CommandObjectTarget.cpp

4268–4271

Yep!

4281–4282

Not currently, no. I looked at StackFrameList in case it was just a matter of adding a LockingAdaptedIterable, but unsurprisingly, stack frames are computed rather than stored in a list. We'd need to implement a custom iterator that keeps track of the index and calls GetStackFrameAtIndex under the hood, which is definitely something for a separate patch.

4301–4302

I want flush to be true only if at least one frame requires a flush.

[kastiglione]

lldb/source/Commands/CommandObjectTarget.cpp

4301–4302

my suggestion still achieves that.

Instead of:

bool current_frame_flush = false;
if (DownloadObjectAndSymbolFile(module_spec, target, result,
                                current_frame_flush))
  symbols_found = true;

flush |= current_frame_flush;

Inline the current_frame_flush variable:

if (DownloadObjectAndSymbolFile(module_spec, target, result,
                                current_frame_flush))
  flush |= true;

This makes flush only true when one frame needs it.

[kastiglione]

lldb/source/Commands/CommandObjectTarget.cpp

4300

It seems this is call is synchronous? A separate improvement would be to perform the unique downloads in parallel.

[JDevlieghere]

lldb/source/Commands/CommandObjectTarget.cpp

4301–4302

That relies on the assumption that flush is true iff DownloadObjectAndSymbolFilereturn true (and the same for AddModuleSymbols). Looking at the code that does indeed seem to be the case, but then I'd rather see the API refactored to remove the flush output variable instead of relying on an implementation-specific assumption here.

[shafik]

Does it make sense to add a test for this? It looks like we have two basic tests for add-dsym already.

[JDevlieghere]

• Rebase
• Add test

[kastiglione]

lldb/source/Commands/CommandObjectTarget.cpp

4301–4302

thanks, makes sense. I had overlooked that current_frame_flush is also an output parameter.

lldb/source/Commands/CommandObjectTarget.cpp

CommandObjectTargetSymbolsAdd(CommandInterpreter &interpreter)
         m_option_group(),
         m_file_option(
             LLDB_OPT_SET_1, false, "shlib", 's',
             CommandCompletions::eModuleCompletion, eArgTypeShlibName,
             "Locate the debug symbols for the shared library specified by "
             "name."),
         m_current_frame_option(
             LLDB_OPT_SET_2, false, "frame", 'F',
-            "Locate the debug symbols for the currently selected frame.",
+            "Locate the debug symbols for the currently selected frame.", false,
+            true),
+        m_current_stack_option(LLDB_OPT_SET_2, false, "stack", 'S',
+                               "Locate the debug symbols for every frame in "
+                               "the current call stack.",
                                false, true)
 
   {
     m_option_group.Append(&m_uuid_option_group, LLDB_OPT_SET_ALL,
                           LLDB_OPT_SET_1);
     m_option_group.Append(&m_file_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Append(&m_current_frame_option, LLDB_OPT_SET_2,
                           LLDB_OPT_SET_2);
+    m_option_group.Append(&m_current_stack_option, LLDB_OPT_SET_2,
+                          LLDB_OPT_SET_2);
     m_option_group.Finalize();
   }
 
   ~CommandObjectTargetSymbolsAdd() override = default;
 
   void
   HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
bool AddSymbolsForFrame(Target *target, CommandReturnObject &result,
     if (!DownloadObjectAndSymbolFile(module_spec, target, result, flush)) {
       result.AppendError("unable to find debug symbols for the current frame");
       return false;
     }
 
     return true;
   }
 
+  bool AddSymbolsForStack(Target *target, CommandReturnObject &result,
+                          bool &flush) {
+    assert(m_current_stack_option.GetOptionValue().OptionWasSet());
+
+    Process *process = m_exe_ctx.GetProcessPtr();
+    if (!process) {
+      result.AppendError(
+          "a process must exist in order to use the --stack option");
+      return false;
+    }
+
+    const StateType process_state = process->GetState();
+    if (!StateIsStoppedState(process_state, true)) {
+      result.AppendErrorWithFormat("process is not stopped: %s",
+                                   StateAsCString(process_state));
+      return false;
+    }
+
+    Thread *thread = m_exe_ctx.GetThreadPtr();
+    if (!thread) {
+      result.AppendError("invalid current thread");
+      return false;
+    }
+
+    bool symbols_found = false;
+    uint32_t frame_count = thread->GetStackFrameCount();
+    for (uint32_t i = 0; i < frame_count; ++i) {
+      lldb::StackFrameSP frame_sp = thread->GetStackFrameAtIndex(i);
+
+      ModuleSP frame_module_sp(
+          frame_sp->GetSymbolContext(eSymbolContextModule).module_sp);
+      if (!frame_module_sp)
+        continue;
+
+      ModuleSpec module_spec;
+      module_spec.GetUUID() = frame_module_sp->GetUUID();
+
+      if (FileSystem::Instance().Exists(
+              frame_module_sp->GetPlatformFileSpec())) {
+        module_spec.GetArchitecture() = frame_module_sp->GetArchitecture();
+        module_spec.GetFileSpec() = frame_module_sp->GetPlatformFileSpec();
+      }
+
+      bool current_frame_flush = false;
+      if (DownloadObjectAndSymbolFile(module_spec, target, result,
+                                      current_frame_flush))
+        symbols_found = true;
+      flush |= current_frame_flush;
+    }
+
+    if (!symbols_found) {
+      result.AppendError(
+          "unable to find debug symbols in the current call stack");
+      return false;
+    }
+
+    return true;
+  }
+
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     Target *target = m_exe_ctx.GetTargetPtr();
     result.SetStatus(eReturnStatusFailed);
     bool flush = false;
     ModuleSpec module_spec;
     const bool uuid_option_set =
         m_uuid_option_group.GetOptionValue().OptionWasSet();
     const bool file_option_set = m_file_option.GetOptionValue().OptionWasSet();
     const bool frame_option_set =
         m_current_frame_option.GetOptionValue().OptionWasSet();
+    const bool stack_option_set =
+        m_current_stack_option.GetOptionValue().OptionWasSet();
     const size_t argc = args.GetArgumentCount();
 
     if (argc == 0) {
       if (uuid_option_set)
         AddSymbolsForUUID(target, result, flush);
       else if (file_option_set)
         AddSymbolsForFile(target, result, flush);
       else if (frame_option_set)
         AddSymbolsForFrame(target, result, flush);
+      else if (stack_option_set)
+        AddSymbolsForStack(target, result, flush);
       else
         result.AppendError("one or more symbol file paths must be specified, "
                            "or options must be specified");
     } else {
       if (uuid_option_set) {
         result.AppendError("specify either one or more paths to symbol files "
                            "or use the --uuid option without arguments");
       } else if (frame_option_set) {
bool DoExecute(Args &args, CommandReturnObject &result) override {
     }
     return result.Succeeded();
   }
 
   OptionGroupOptions m_option_group;
   OptionGroupUUID m_uuid_option_group;
   OptionGroupFile m_file_option;
   OptionGroupBoolean m_current_frame_option;
+  OptionGroupBoolean m_current_stack_option;
 };
 
 #pragma mark CommandObjectTargetSymbols
 
 // CommandObjectTargetSymbols
 
 class CommandObjectTargetSymbols : public CommandObjectMultiword {
 public: