[trace][intel-pt] Scaffold the 'thread trace start | stop' commands

[wallace]

Summary

Depends on D90490.

The stop command is simple and invokes the new method Trace::StopTracingThread(thread).

On the other hand, the start command works by delegating its implementation to a CommandObject provided by the Trace plugin. This is necessary because each trace plugin needs different options for this command. There's even the chance that a Trace plugin can't support live tracing, but instead supports offline decoding and analysis, which means that "thread trace dump instructions" works but "thread trace start" doest. Because of this and a few other reasons, it's better to have each plugin provide this implementation.

Besides, I'm using the GetSupportedTraceType method introduced in D90490 to quickly infer what's the trace plug-in that works for the current process.

As an implementation note, I moved CommandObjectIterateOverThreads to its header so that I can use it from the IntelPT plugin. Besides, the actual start and stop logic for intel-pt is not part of this diff.

[clayborg]

lldb/include/lldb/Target/Trace.h

187

We need to have StartTracingThread() in this interface as well. I know right now we can just do the work in the command plug-in, but eventually we will need to expose the trace stuff through the SB API, so we need the StartTracingThread in the API here.

lldb/source/Commands/CommandObjectThread.cpp

1984

We should probably create a CommandObjectDelegate in CommandObjectDelegate.cpp and CommandObjectDelegate.h. This class will have one pure virtual function named GetDelegateCommand() which we would override in this class and return GetTracePluginCommand(). Then this class will become much simpler and the next people that will create a similar kind of command that just forwards to another command can use it.

1997

Move to CommandObjectDelegate.cpp

1998–1999

Store as a shared pointer here please and use it:

CommandObjectSP delegate_cmd_sp = GetDelegateCommand();
if (delegate_cmd_sp)
  delegate_cmd_sp->GetOptions();

2004

Move to CommandObjectDelegate.cpp

2005–2006

Store as a shared pointer like above comment.

2011

Move to CommandObjectDelegate.cpp

2012–2013

Store as a shared pointer like above comment.

2018

Move to CommandObjectDelegate.cpp

2019–2020

Store as a shared pointer like above comment.

2028

Why are you taking over execute instead of DoExecute?

2034–2045

If we require that only one tracing mechanism is available in a process, then why do we need this check?

2060

make virtual override of CommandObjectDelegate::GetDelegateCommand()

lldb/source/Commands/CommandObjectThread.h

16 ↗

(On Diff #302710)

This should go in a file on its own near the CommandObject.cpp file. Maybe in CommandObjectThreadUtil.h/.cpp?

lldb/source/Interpreter/CommandObject.cpp

263–266

The command should specify it needs a process with eCommandRequiresProcess. Remove these lines.

[wallace]

lldb/include/lldb/Target/Trace.h

187

l'll add it later when I implement the actual StartTracingThread logic. I want to make sure I can cleanly allow each Trace plug-in to have its own set of tracing options for the StartTracingThread, and I'd rather do that in another diff.

lldb/source/Commands/CommandObjectThread.cpp

1984

Great idea!

2028

because Execute in the delegate configures the ExecutionContext correctly, so I need to invoke Execute in the Trace plug-in command. With the Delegate idea that you mention, this will look cleaner

2034–2045

that's right!

lldb/source/Interpreter/CommandObject.cpp

263–266

sure

[wallace]

address all comments

[clayborg]

So I am not sure I like the caching that we are doing in TracePluginCommandDelegate in the CommandObjectTraceStart class. See inline comments, but it might be better to cache the command object SP in lldb_private::Process and add accessors.

lldb/source/Commands/CommandObjectThread.cpp

2013

See my comment below about TracePluginCommandDelegate.process being a pointer. If we switch to using a weak pointer, then this should need to be:

if (m_delegate.process_wp.expired() || process != m_delegate.process_wp.lock().get())

2014

if we use weak pointer:

m_delegate = {process->shared_from_this(), /*command*/ nullptr, /*error*/ ""};

2034

ProcessWP would be safer here. Theoretically a Process instance could be freed and a new process could be allocated at the same address. So maybe:

ProcessWP process_wp;

The other option, which I think I prefer, would be to cache this in the lldb_private::Process class instead of in a cache in CommandObjectTraceStart

lldb/source/Commands/CommandObjectThreadUtil.cpp

2–3

Fix comment header to be on one line. This must be an auto lint thing?

lldb/source/Commands/CommandObjectThreadUtil.h

2–3

fix comment header to be on one line

lldb/test/API/commands/trace/TestTraceStartStop.py

25

Shouldn't we get a better error message here? Something like "error: can't start tracing on a loaded trace file"? Might be nice to be able to somehow detect that a process or thread comes from a core file. We would need to ask the process something like "process->IsLiveDebugSession()" and return a correct error if it isn't. If it is a live debug session, then the ""error: tracing is not supported for the current process. Not implemented" is better.

[wallace]

Address comments

• I didn't move the caching to Process.h, as creating the start command requires an Interpreter, which I don't know if I can assume as unique. Btw, I'm using weak pointers instead.
• I added an IsLiveDebugSession, as Greg suggested.

[wallace]

nit

[clayborg]

Still wondering if we need to do caching in TracePluginCommandDelegate. How many times do we fetch the command object if we type "thread trace start"? I don't know how much performance is truly needed here at the expense of maintaining the caching code.

lldb/include/lldb/Target/Process.h

1395

This should return true as a default implementation. Then only the ProcessTrace, and the ProcessMachCore, ProcessMinidump, and ProcessELFCore would need to override. We could make a ProcessCore base class that overrides this by returning false and then having all of the mentioned core file classes inherit from ProcessCore. We also need header documentation for this.

Having a default implementation will help make sure the buildbots stay clean for Process plug-ins that are not always built, like ProcessWindows, which we missed in this diff.

lldb/include/lldb/Target/ProcessTrace.h

1

Should ProcessTrace and ThreadTrace be moved to the Process plug-in directory?

lldb/source/Commands/CommandObjectThread.cpp

2039–2040

Should we store the the "command" and "error" as:

llvm::Expected<CommandObjectSP> expected_command;

If so we need a destructor to consume the error, and a method to get the error as a string.

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

128

we can get rid this and make "true" the default implementation. This will help make sure the buildbots stay clean for Process plug-ins that are not always built, like ProcessWindows.

lldb/source/Plugins/Process/mach-core/ProcessMachCore.h

78

It might be nice to create a Process subclass for core files and have ProcessMachCore, ProcessMinidump, ProcessTrace, and ProcessElfCore all inherit. They might have other functions we can refactor.

[wallace]

• After taking a second look I realized I don't need caching. For some reason I thought that autocompletion would be triggered with every keystroke, and that's why caching would be useful. But I was wrong all along! These queries will be rare and there's no need for caching.
• Good idea with the default implementation for IsLiveDebugSession

[wallace]

Address comments:

• Don't cache the command delegate. It was overcomplicating the code for little gain.
• Create a RecordedProcess base class for trace and coredump processes, so that we can put the IsLiveDebugSession method there, and in the future we can add more common methods there.

[wallace]

lldb/include/lldb/Target/ProcessTrace.h

1

can't do that. I think Pavel and other guys warned me of cross-referencing between plugin-folders. It is safer this way, as they are base classes for trace plug-ins.

[clayborg]

lldb/include/lldb/Interpreter/CommandObjectDelegate.h

31–33

So currently you are storing the command object into m_delegate_command_sp in GetDelegateCommand(). This can cause an issue when you have two debuggers (Xcode creates a new debugger for each debug window). If thread A calls this function, and fills in m_delegate_command_sp, then thread B fills in m_delegate_command_sp from another command interpreter, we could end up using the one from thread B. Since the only reason we are storing the value in m_delegate_command_sp is to keep the shared pointer alive, we should just return the shared pointer. So I would suggest removing DoGetDelegateCommand() and just have:

virtual llvm::Expected<lldb::CommandObjectSP> GetDelegateCommand() = 0;

Don't store it. Each function that calls it will keep it around as long as needed. If we use expected then we don't need to store the m_delegate_error later...

lldb/source/Interpreter/CommandObjectDelegate.cpp

17–20

This caching isn't really doing anything. If we have two debuggers, each one has its own command interpreter and this can actually cause things to fail. If thread A calls this, then thread B, then thread A continues to use the one populated by thread B. See inline comment in header file.

[clayborg]

Walter and I discussed some issues offline and came to the conclusion we need to use CommandObjectProxy and get rid of CommandObjectDelegate. This will simplify the patch and use the pre-existing class that already does what we needed CommandObjectDelegate to do...

[wallace]

• Use CommandObjectProxy and delete the Delegate that I created
• I had to add a few methods to the proxy to match with that I need. In any case, the implementation is not more complete.

[wallace]

improve error messages

The diff is ready for review again

[clayborg]

LGTM. A few inline nits, but nothing major. I only question if "RecordedProcess" is the right name for the base class for a core file/trace file, but don't have much of a better name. Maybe SerializedProcess? SavedProcess? Don't we usually have Pavel in on these reviews?

lldb/include/lldb/Target/RecordedProcess.h

18 ↗

(On Diff #304867)

Might want to comment something like "common lldb_private::Process virtual functions overrides that are common between these kinds of processes can have default implementations in this class".

lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp

209 ↗

(On Diff #304867)

undo space only change

246–247 ↗

(On Diff #304867)

undo space only change

766 ↗

(On Diff #304867)

undo space only change

[labath]

I am can't keep up with all the reviews, so don't wait on my account. I checking these out from time to time though, and I will speak up if I see something very out of place.

I like the idea of a common base class for different kinds of "core" processes. The name RecordedProcess also made me think twice, but I am not sure what would be a better name for it. Maybe SavedProcess is slightly better as the name does not carry the notion of "time" (which real core files do not have). Or some variation of PostMortemProcess?

[wallace]

Renamed to SavedProcess

[clayborg]

Thanks for chiming in Pavel. LGTM.

lldb/include/lldb/Core/PluginManager.h

 //===-- PluginManager.h -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_CORE_PLUGINMANAGER_H
 #define LLDB_CORE_PLUGINMANAGER_H
 
 #include "lldb/Core/Architecture.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private-interfaces.h"
 #include "llvm/ADT/StringRef.h"
public:
   static bool UnregisterPlugin(SymbolVendorCreateInstance create_callback);
 
   static SymbolVendorCreateInstance
   GetSymbolVendorCreateCallbackAtIndex(uint32_t idx);
 
   // Trace
   static bool RegisterPlugin(ConstString name, const char *description,
                              TraceCreateInstance create_callback,
-                             llvm::StringRef schema);
+                             llvm::StringRef schema,
+                             TraceGetStartCommand get_start_command);
 
   static bool UnregisterPlugin(TraceCreateInstance create_callback);
 
   static TraceCreateInstance GetTraceCreateCallback(ConstString plugin_name);
 
+  static lldb::CommandObjectSP
+  GetTraceStartCommand(llvm::StringRef plugin_name,
+                       CommandInterpreter &interpreter);
+
   /// Get the JSON schema for a trace session file corresponding to the given
   /// plugin.
   ///
   /// \param[in] plugin_name
   ///     The name of the plugin.
   ///
   /// \return
   ///     An empty \a StringRef if no plugin was found with that plugin name,

lldb/include/lldb/Interpreter/CommandObjectDelegate.h

+//===-- CommandObjectDelegate.h ---------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_INTERPRETER_COMMANDOBJECTDELEGATE_H
+#define LLDB_INTERPRETER_COMMANDOBJECTDELEGATE_H
+
+#include "lldb/Interpreter/CommandObject.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+
+namespace lldb_private {
+
+/// \class CommandObjectDelegate
+///
+/// CommandObject class that delegates its public API to a dynamically generated
+/// subcommand.
+class CommandObjectDelegate : public CommandObject {
+protected:
+  /// Get the \a CommandObject used to delegate the public API. It is invoked
+  /// with every API method call.
+  ///
+  /// It can return null to represent a non-implemented command.
+  ///
+  /// \return
+  ///     The delegate \a CommandObject or null.
+  virtual lldb::CommandObjectSP GetDelegateCommand() = 0;
+
+  /// \return
+  ///     An error message to be displayed when the command is executed and
+  ///     \a GetDelegateCommand returned null.
+  virtual llvm::StringRef GetUnsupportedError() { return "Not supported."; };
+
+public:
+  using CommandObject::CommandObject;
+
+  Options *GetOptions() override;
+
+  llvm::StringRef GetSyntax() override;
+
+  llvm::StringRef GetHelp() override;
+
+  llvm::StringRef GetHelpLong() override;
+
+  bool WantsRawCommandString() override;
+
+  void HandleCompletion(CompletionRequest &request) override;
+
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override;
+
+  const char *GetRepeatCommand(Args &current_command_args,
+                               uint32_t index) override;
+
+  bool Execute(const char *args_string, CommandReturnObject &result) override;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_INTERPRETER_COMMANDOBJECTDELEGATE_H

lldb/include/lldb/Target/Process.h

 //===-- Process.h -----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TARGET_PROCESS_H
 #define LLDB_TARGET_PROCESS_H
 
 #include "lldb/Host/Config.h"
 
 #include <limits.h>
 
 #include <chrono>
 #include <list>
 #include <memory>
 #include <mutex>
 #include <string>
/// \see Process::Notifications
 
   /// Check if a process is still alive.
   ///
   /// \return
   ///     Returns \b true if the process is still valid, \b false
   ///     otherwise.
   virtual bool IsAlive();
 
+  virtual bool IsLiveDebugSession() = 0;
+
   /// Before lldb detaches from a process, it warns the user that they are
   /// about to lose their debug session. In some cases, this warning doesn't
   /// need to be emitted -- for instance, with core file debugging where the
   /// user can reconstruct the "state" by simply re-running the debugger on
   /// the core file.
   ///
   /// \return
   ///     Returns \b true if the user should be warned about detaching from
void PruneThreadPlans();
 
   ///  Get the processor tracing type supported for this process.
   ///  Responses might be different depending on the architecture and
   ///  capabilities of the underlying OS.
   ///
   ///  \return
   ///     The supported trace type or an \a llvm::Error if tracing is
   ///     not supported for the inferior.
-  virtual llvm::Expected<TraceTypeInfo> GetSupportedTraceType() {
-    return llvm::make_error<UnimplementedError>();
-  }
+  virtual llvm::Expected<TraceTypeInfo> GetSupportedTraceType();
 
   // This calls a function of the form "void * (*)(void)".
   bool CallVoidArgVoidPtrReturn(const Address *address,
                                 lldb::addr_t &returned_func,
                                 bool trap_exceptions = false);
 
 protected:
   void SetState(lldb::EventSP &event_sp);

lldb/include/lldb/Target/ProcessTrace.h

 //===-- ProcessTrace.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TARGET_PROCESSTRACE_H
 #define LLDB_TARGET_PROCESSTRACE_H
 
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 
 namespace lldb_private {
 
 class ProcessTrace : public Process {
 public:
   static void Initialize();
public:
   ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
   Status DoDestroy() override;
 
   void RefreshStateAfterStop() override;
 
+  bool IsLiveDebugSession() override { return false; }
+
   Status WillResume() override {
     Status error;
     error.SetErrorStringWithFormat(
         "error: %s does not support resuming processes",
         GetPluginName().GetCString());
     return error;
   }
 

lldb/include/lldb/Target/Trace.h

 //===-- Trace.h -------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TARGET_TRACE_H
 #define LLDB_TARGET_TRACE_H
 
 #include "llvm/Support/JSON.h"
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/UnimplementedError.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 /// \class Trace Trace.h "lldb/Target/Trace.h"
 /// A plug-in interface definition class for trace information.
 ///
 /// Trace plug-ins allow processor trace information to be loaded into LLDB so
public:
   /// \param[in] callback
   ///     The callback to execute on each instruction. If it returns \b false,
   ///     the iteration stops.
   virtual void TraverseInstructions(
       const Thread &thread, size_t position, TraceDirection direction,
       std::function<bool(size_t index, llvm::Expected<lldb::addr_t> load_addr)>
           callback) = 0;
 
+  /// Stop tracing a live thread
+  ///
+  /// \param[in] thread
+  ///     The thread object to stop tracing.
+  ///
+  /// \return
+  ///     An \a llvm::Error if stopping tracing failed, or \b
+  ///     llvm::Error::success() otherwise.
+  virtual llvm::Error StopTracingThread(const Thread &thread) {
+    return llvm::make_error<UnimplementedError>();
+  }
+
   /// Get the number of available instructions in the trace of the given thread.
   ///
   /// \param[in] thread
   ///     The thread whose trace will be inspected.
   ///
   /// \return
   ///     The total number of instructions in the trace.
   virtual size_t GetInstructionCount(const Thread &thread) = 0;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_TRACE_H

lldb/include/lldb/lldb-enumerations.h

FLAGS_ENUM(CommandFlags){
     ///
     /// Verifies that there is a launched process in m_exe_ctx, if there isn't,
     /// the command will fail with an appropriate error message.
     eCommandProcessMustBeLaunched = (1u << 6),
     /// eCommandProcessMustBePaused
     ///
     /// Verifies that there is a paused process in m_exe_ctx, if there isn't,
     /// the command will fail with an appropriate error message.
-    eCommandProcessMustBePaused = (1u << 7)};
+    eCommandProcessMustBePaused = (1u << 7),
+    /// eCommandProcessMustBeTraced
+    ///
+    /// Verifies that the process is being traced by a Trace plug-in, if it
+    /// isn't the command will fail with an appropriate error message.
+    eCommandProcessMustBeTraced = (1u << 8)};
 
 /// Whether a summary should cap how much data it returns to users or not.
 enum TypeSummaryCapping {
   eTypeSummaryCapped = true,
   eTypeSummaryUncapped = false
 };
 
 /// The result from a command interpreter run.

lldb/include/lldb/lldb-private-interfaces.h

 //===-- lldb-private-interfaces.h -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_LLDB_PRIVATE_INTERFACES_H
 #define LLDB_LLDB_PRIVATE_INTERFACES_H
 
 #if defined(__cplusplus)
 
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private-enumerations.h"
 #include "lldb/lldb-types.h"
 #include <memory>
 #include <set>
 
 namespace llvm {
 namespace json {
typedef lldb::REPLSP (*REPLCreateInstance)(Status &error,
                                            lldb::LanguageType language,
                                            Debugger *debugger, Target *target,
                                            const char *repl_options);
 typedef int (*ComparisonFunction)(const void *, const void *);
 typedef void (*DebuggerInitializeCallback)(Debugger &debugger);
 typedef llvm::Expected<lldb::TraceSP> (*TraceCreateInstance)(
     const llvm::json::Value &trace_session_file,
     llvm::StringRef session_file_dir, lldb_private::Debugger &debugger);
+typedef lldb::CommandObjectSP (*TraceGetStartCommand)(
+    CommandInterpreter &interpreter);
 
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 
 #endif // LLDB_LLDB_PRIVATE_INTERFACES_H

lldb/source/Commands/CMakeLists.txt

add_lldb_library(lldbCommands
   CommandObjectReproducer.cpp
   CommandObjectScript.cpp
   CommandObjectSession.cpp
   CommandObjectSettings.cpp
   CommandObjectSource.cpp
   CommandObjectStats.cpp
   CommandObjectTarget.cpp
   CommandObjectThread.cpp
+  CommandObjectThreadUtil.cpp
   CommandObjectTrace.cpp
   CommandObjectType.cpp
   CommandObjectVersion.cpp
   CommandObjectWatchpoint.cpp
   CommandObjectWatchpointCommand.cpp
 
   LINK_LIBS
     lldbBase

lldb/source/Commands/CommandObjectThread.cpp

 //===-- CommandObjectThread.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CommandObjectThread.h"
 
 #include <sstream>
 
+#include "CommandObjectThreadUtil.h"
+#include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/CommandObjectDelegate.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupPythonClassWithDict.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 #include "lldb/Target/ThreadPlanStepInRange.h"
 #include "lldb/Target/Trace.h"
 #include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-// CommandObjectIterateOverThreads
-
-class CommandObjectIterateOverThreads : public CommandObjectParsed {
-
-  class UniqueStack {
-
-  public:
-    UniqueStack(std::stack<lldb::addr_t> stack_frames, uint32_t thread_index_id)
-        : m_stack_frames(stack_frames) {
-      m_thread_index_ids.push_back(thread_index_id);
-    }
-
-    void AddThread(uint32_t thread_index_id) const {
-      m_thread_index_ids.push_back(thread_index_id);
-    }
-
-    const std::vector<uint32_t> &GetUniqueThreadIndexIDs() const {
-      return m_thread_index_ids;
-    }
-
-    lldb::tid_t GetRepresentativeThread() const {
-      return m_thread_index_ids.front();
-    }
-
-    friend bool inline operator<(const UniqueStack &lhs,
-                                 const UniqueStack &rhs) {
-      return lhs.m_stack_frames < rhs.m_stack_frames;
-    }
-
-  protected:
-    // Mark the thread index as mutable, as we don't care about it from a const
-    // perspective, we only care about m_stack_frames so we keep our std::set
-    // sorted.
-    mutable std::vector<uint32_t> m_thread_index_ids;
-    std::stack<lldb::addr_t> m_stack_frames;
-  };
-
-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 all_threads = false;
-    if (command.GetArgumentCount() == 0) {
-      Thread *thread = m_exe_ctx.GetThreadPtr();
-      if (!thread || !HandleOneThread(thread->GetID(), result))
-        return false;
-      return result.Succeeded();
-    } else if (command.GetArgumentCount() == 1) {
-      all_threads = ::strcmp(command.GetArgumentAtIndex(0), "all") == 0;
-      m_unique_stacks = ::strcmp(command.GetArgumentAtIndex(0), "unique") == 0;
-    }
-
-    // Use tids instead of ThreadSPs to prevent deadlocking problems which
-    // result from JIT-ing code while iterating over the (locked) ThreadSP
-    // list.
-    std::vector<lldb::tid_t> tids;
-
-    if (all_threads || m_unique_stacks) {
-      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());
-
-      for (size_t i = 0; i < num_args; i++) {
-        uint32_t thread_idx;
-        if (!llvm::to_integer(command.GetArgumentAtIndex(i), thread_idx)) {
-          result.AppendErrorWithFormat("invalid thread specification: \"%s\"\n",
-                                       command.GetArgumentAtIndex(i));
-          result.SetStatus(eReturnStatusFailed);
-          return false;
-        }
-
-        ThreadSP thread =
-            process->GetThreadList().FindThreadByIndexID(thread_idx);
-
-        if (!thread) {
-          result.AppendErrorWithFormat("no thread with index: \"%s\"\n",
-                                       command.GetArgumentAtIndex(i));
-          result.SetStatus(eReturnStatusFailed);
-          return false;
-        }
-
-        tids.push_back(thread->GetID());
-      }
-    }
-
-    if (m_unique_stacks) {
-      // Iterate over threads, finding unique stack buckets.
-      std::set<UniqueStack> unique_stacks;
-      for (const lldb::tid_t &tid : tids) {
-        if (!BucketThread(tid, unique_stacks, result)) {
-          return false;
-        }
-      }
-
-      // Write the thread id's and unique call stacks to the output stream
-      Stream &strm = result.GetOutputStream();
-      Process *process = m_exe_ctx.GetProcessPtr();
-      for (const UniqueStack &stack : unique_stacks) {
-        // List the common thread ID's
-        const std::vector<uint32_t> &thread_index_ids =
-            stack.GetUniqueThreadIndexIDs();
-        strm.Format("{0} thread(s) ", thread_index_ids.size());
-        for (const uint32_t &thread_index_id : thread_index_ids) {
-          strm.Format("#{0} ", thread_index_id);
-        }
-        strm.EOL();
-
-        // List the shared call stack for this set of threads
-        uint32_t representative_thread_id = stack.GetRepresentativeThread();
-        ThreadSP thread = process->GetThreadList().FindThreadByIndexID(
-            representative_thread_id);
-        if (!HandleOneThread(thread->GetID(), result)) {
-          return false;
-        }
-      }
-    } else {
-      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;
-
-  bool BucketThread(lldb::tid_t tid, std::set<UniqueStack> &unique_stacks,
-                    CommandReturnObject &result) {
-    // Grab the corresponding thread for the given thread id.
-    Process *process = m_exe_ctx.GetProcessPtr();
-    Thread *thread = process->GetThreadList().FindThreadByID(tid).get();
-    if (thread == nullptr) {
-      result.AppendErrorWithFormatv("Failed to process thread #{0}.\n", tid);
-      result.SetStatus(eReturnStatusFailed);
-      return false;
-    }
-
-    // Collect the each frame's address for this call-stack
-    std::stack<lldb::addr_t> stack_frames;
-    const uint32_t frame_count = thread->GetStackFrameCount();
-    for (uint32_t frame_index = 0; frame_index < frame_count; frame_index++) {
-      const lldb::StackFrameSP frame_sp =
-          thread->GetStackFrameAtIndex(frame_index);
-      const lldb::addr_t pc = frame_sp->GetStackID().GetPC();
-      stack_frames.push(pc);
-    }
-
-    uint32_t thread_index_id = thread->GetIndexID();
-    UniqueStack new_unique_stack(stack_frames, thread_index_id);
-
-    // Try to match the threads stack to and existing entry.
-    std::set<UniqueStack>::iterator matching_stack =
-        unique_stacks.find(new_unique_stack);
-    if (matching_stack != unique_stacks.end()) {
-      matching_stack->AddThread(thread_index_id);
-    } else {
-      unique_stacks.insert(new_unique_stack);
-    }
-    return true;
-  }
-
-  ReturnStatus m_success_return = eReturnStatusSuccessFinishResult;
-  bool m_unique_stacks = false;
-  bool m_add_return = true;
-};
-
 // CommandObjectThreadBacktrace
 #define LLDB_OPTIONS_thread_backtrace
 #include "CommandOptions.inc"
 
 class CommandObjectThreadBacktrace : public CommandObjectIterateOverThreads {
 public:
   class CommandOptions : public Options {
   public:
LoadSubCommand(
         CommandObjectSP(new CommandObjectThreadPlanPrune(interpreter)));
   }
 
   ~CommandObjectMultiwordThreadPlan() override = default;
 };
 
 // Next are the subcommands of CommandObjectMultiwordTrace
 
+// CommandObjectTraceStart
+
+/// This class works by delegating the logic to the actual trace plug-in that
+/// can support the current process.
+class CommandObjectTraceStart : public CommandObjectDelegate {
+public:
+  CommandObjectTraceStart(CommandInterpreter &interpreter)
+      : CommandObjectDelegate(
+            interpreter, "thread trace start",
+            "Start tracing threads with the corresponding trace "
+            "plug-in for the current process.",
+            "thread trace start [<trace-options>]",
+            eCommandRequiresProcess | eCommandTryTargetAPILock |
+                eCommandProcessMustBeLaunched | eCommandProcessMustBePaused) {}
+
+protected:
+  struct TracePluginCommandDelegate;
+
+  CommandObjectSP GetDelegateCommand() override {
+    return GetTracePluginCommandDelegate().command;
+  }
+
+  llvm::StringRef GetUnsupportedError() override {
+    TracePluginCommandDelegate &delegate = GetTracePluginCommandDelegate();
+    if (delegate.process_wp.expired() || !delegate.process_wp.lock().get())
+      return "No process available";
+    return GetTracePluginCommandDelegate().error;
+  };
+
+  /// Find the implementation of the "thread trace start" command provided by
+  /// the trace plug-in that supports the current process.
+  ///
+  /// It uses a cached result unless the process has changed.
+  TracePluginCommandDelegate &GetTracePluginCommandDelegate() {
+    Process *process = m_interpreter.GetExecutionContext().GetProcessPtr();
+
+    if (m_delegate.process_wp.expired() ||
+        process != m_delegate.process_wp.lock().get()) {
+      m_delegate = {};
+
+      if (process) {
+        m_delegate.process_wp = process->shared_from_this();
+        if (llvm::Expected<TraceTypeInfo> trace_type =
+                process->GetSupportedTraceType()) {
+          m_delegate.command = PluginManager::GetTraceStartCommand(
+              trace_type->name, m_interpreter);
+        } else {
+          m_delegate.error =
+              "tracing is not supported. " + toString(trace_type.takeError());
+        }
+      }
+    }
+    return m_delegate;
+  }
+
+  /// The last value computed by \a GetTracePluginCommand to avoid
+  /// recalculations.
+  struct TracePluginCommandDelegate {
+    ProcessWP process_wp;
+    CommandObjectSP command;
+    std::string error;
+  } m_delegate = {};
+};
+
+// CommandObjectTraceStop
+
+class CommandObjectTraceStop : public CommandObjectIterateOverThreads {
+public:
+  CommandObjectTraceStop(CommandInterpreter &interpreter)
+      : CommandObjectIterateOverThreads(
+            interpreter, "thread trace stop",
+            "Stop tracing threads. "
+            "Defaults to the current thread. Thread indices can be "
+            "specified as arguments.\n Use the thread-index \"all\" to trace "
+            "all threads.",
+            "thread trace stop [<thread-index> <thread-index> ...]",
+            eCommandRequiresProcess | eCommandTryTargetAPILock |
+                eCommandProcessMustBeLaunched | eCommandProcessMustBePaused |
+                eCommandProcessMustBeTraced) {}
+
+  ~CommandObjectTraceStop() override = default;
+
+  bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
+    const Thread &thread =
+        *m_exe_ctx.GetProcessPtr()->GetThreadList().FindThreadByID(tid);
+    Trace &trace = *m_exe_ctx.GetTargetSP()->GetTrace();
+
+    if (llvm::Error err = trace.StopTracingThread(thread)) {
+      result.AppendErrorWithFormat("failed stopping thread %" PRIu64 ": %s\n",
+                                   tid, toString(std::move(err)).c_str());
+      result.SetStatus(eReturnStatusFailed);
+    }
+
+    // We don't return false on errors to try to stop as many threads as
+    // possible.
+    return true;
+  }
+};
+
 // CommandObjectTraceDumpInstructions
 #define LLDB_OPTIONS_thread_trace_dump_instructions
 #include "CommandOptions.inc"
 
 class CommandObjectTraceDumpInstructions
     : public CommandObjectIterateOverThreads {
 public:
   class CommandOptions : public Options {
public:
   CommandObjectTraceDumpInstructions(CommandInterpreter &interpreter)
       : CommandObjectIterateOverThreads(
             interpreter, "thread trace dump instructions",
             "Dump the traced instructions for one or more threads.  If no "
             "threads are specified, show the current thread.  Use the "
             "thread-index \"all\" to see all threads.",
             nullptr,
             eCommandRequiresProcess | eCommandTryTargetAPILock |
-                eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
+                eCommandProcessMustBeLaunched | eCommandProcessMustBePaused |
+                eCommandProcessMustBeTraced),
         m_options(), m_create_repeat_command_just_invoked(false) {}
 
   ~CommandObjectTraceDumpInstructions() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   const char *GetRepeatCommand(Args &current_command_args,
                                uint32_t index) override {
protected:
   }
 
   bool IsRepeatCommand() {
     return !m_repeat_command.empty() && !m_create_repeat_command_just_invoked;
   }
 
   bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
     const TraceSP &trace_sp = m_exe_ctx.GetTargetSP()->GetTrace();
-    if (!trace_sp) {
-      result.SetError("error: this thread is not being traced");
-      return false;
-    }
-
     ThreadSP thread_sp =
         m_exe_ctx.GetProcessPtr()->GetThreadList().FindThreadByID(tid);
 
     size_t count = m_options.m_count;
     ssize_t position = m_options.m_position.getValueOr(
                            trace_sp->GetCursorPosition(*thread_sp)) -
                        m_consecutive_repetitions * count;
     if (position < 0)
public:
   CommandObjectMultiwordTrace(CommandInterpreter &interpreter)
       : CommandObjectMultiword(
             interpreter, "trace",
             "Commands for operating on traces of the threads in the current "
             "process.",
             "thread trace <subcommand> [<subcommand objects>]") {
     LoadSubCommand("dump", CommandObjectSP(new CommandObjectMultiwordTraceDump(
                                interpreter)));
+    LoadSubCommand("start",
+                   CommandObjectSP(new CommandObjectTraceStart(interpreter)));
+    LoadSubCommand("stop",
+                   CommandObjectSP(new CommandObjectTraceStop(interpreter)));
   }
 
   ~CommandObjectMultiwordTrace() override = default;
 };
 
 // CommandObjectMultiwordThread
 
 CommandObjectMultiwordThread::CommandObjectMultiwordThread(

lldb/source/Commands/CommandObjectThreadUtil.h

+//===-- CommandObjectThreadUtil.h -------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SOURCE_COMMANDS_COMMANDOBJECTTHREADUTIL_H
+#define LLDB_SOURCE_COMMANDS_COMMANDOBJECTTHREADUTIL_H
+
+#include "lldb/Interpreter/CommandObjectMultiword.h"
+
+namespace lldb_private {
+
+class CommandObjectIterateOverThreads : public CommandObjectParsed {
+
+  class UniqueStack {
+  public:
+    UniqueStack(std::stack<lldb::addr_t> stack_frames, uint32_t thread_index_id)
+        : m_stack_frames(stack_frames) {
+      m_thread_index_ids.push_back(thread_index_id);
+    }
+
+    void AddThread(uint32_t thread_index_id) const {
+      m_thread_index_ids.push_back(thread_index_id);
+    }
+
+    const std::vector<uint32_t> &GetUniqueThreadIndexIDs() const {
+      return m_thread_index_ids;
+    }
+
+    lldb::tid_t GetRepresentativeThread() const {
+      return m_thread_index_ids.front();
+    }
+
+    friend bool inline operator<(const UniqueStack &lhs,
+                                 const UniqueStack &rhs) {
+      return lhs.m_stack_frames < rhs.m_stack_frames;
+    }
+
+  protected:
+    // Mark the thread index as mutable, as we don't care about it from a const
+    // perspective, we only care about m_stack_frames so we keep our std::set
+    // sorted.
+    mutable std::vector<uint32_t> m_thread_index_ids;
+    std::stack<lldb::addr_t> m_stack_frames;
+  };
+
+public:
+  CommandObjectIterateOverThreads(CommandInterpreter &interpreter,
+                                  const char *name, const char *help,
+                                  const char *syntax, uint32_t flags);
+
+  ~CommandObjectIterateOverThreads() override = default;
+
+  bool DoExecute(Args &command, CommandReturnObject &result) override;
+
+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;
+
+  bool BucketThread(lldb::tid_t tid, std::set<UniqueStack> &unique_stacks,
+                    CommandReturnObject &result);
+
+  lldb::ReturnStatus m_success_return = lldb::eReturnStatusSuccessFinishResult;
+  bool m_unique_stacks = false;
+  bool m_add_return = true;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_COMMANDS_COMMANDOBJECTTHREADUTIL_H

lldb/source/Commands/CommandObjectThreadUtil.cpp

+//===-- CommandObjectThreadUtil.cpp -----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "CommandObjectThreadUtil.h"
+
+#include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Thread.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace llvm;
+
+CommandObjectIterateOverThreads::CommandObjectIterateOverThreads(
+    CommandInterpreter &interpreter, const char *name, const char *help,
+    const char *syntax, uint32_t flags)
+    : CommandObjectParsed(interpreter, name, help, syntax, flags) {}
+
+bool CommandObjectIterateOverThreads::DoExecute(Args &command,
+                                                CommandReturnObject &result) {
+  result.SetStatus(m_success_return);
+
+  bool all_threads = false;
+  if (command.GetArgumentCount() == 0) {
+    Thread *thread = m_exe_ctx.GetThreadPtr();
+    if (!thread || !HandleOneThread(thread->GetID(), result))
+      return false;
+    return result.Succeeded();
+  } else if (command.GetArgumentCount() == 1) {
+    all_threads = ::strcmp(command.GetArgumentAtIndex(0), "all") == 0;
+    m_unique_stacks = ::strcmp(command.GetArgumentAtIndex(0), "unique") == 0;
+  }
+
+  // Use tids instead of ThreadSPs to prevent deadlocking problems which
+  // result from JIT-ing code while iterating over the (locked) ThreadSP
+  // list.
+  std::vector<lldb::tid_t> tids;
+
+  if (all_threads || m_unique_stacks) {
+    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());
+
+    for (size_t i = 0; i < num_args; i++) {
+      uint32_t thread_idx;
+      if (!llvm::to_integer(command.GetArgumentAtIndex(i), thread_idx)) {
+        result.AppendErrorWithFormat("invalid thread specification: \"%s\"\n",
+                                     command.GetArgumentAtIndex(i));
+        result.SetStatus(eReturnStatusFailed);
+        return false;
+      }
+
+      ThreadSP thread =
+          process->GetThreadList().FindThreadByIndexID(thread_idx);
+
+      if (!thread) {
+        result.AppendErrorWithFormat("no thread with index: \"%s\"\n",
+                                     command.GetArgumentAtIndex(i));
+        result.SetStatus(eReturnStatusFailed);
+        return false;
+      }
+
+      tids.push_back(thread->GetID());
+    }
+  }
+
+  if (m_unique_stacks) {
+    // Iterate over threads, finding unique stack buckets.
+    std::set<UniqueStack> unique_stacks;
+    for (const lldb::tid_t &tid : tids) {
+      if (!BucketThread(tid, unique_stacks, result)) {
+        return false;
+      }
+    }
+
+    // Write the thread id's and unique call stacks to the output stream
+    Stream &strm = result.GetOutputStream();
+    Process *process = m_exe_ctx.GetProcessPtr();
+    for (const UniqueStack &stack : unique_stacks) {
+      // List the common thread ID's
+      const std::vector<uint32_t> &thread_index_ids =
+          stack.GetUniqueThreadIndexIDs();
+      strm.Format("{0} thread(s) ", thread_index_ids.size());
+      for (const uint32_t &thread_index_id : thread_index_ids) {
+        strm.Format("#{0} ", thread_index_id);
+      }
+      strm.EOL();
+
+      // List the shared call stack for this set of threads
+      uint32_t representative_thread_id = stack.GetRepresentativeThread();
+      ThreadSP thread = process->GetThreadList().FindThreadByIndexID(
+          representative_thread_id);
+      if (!HandleOneThread(thread->GetID(), result)) {
+        return false;
+      }
+    }
+  } else {
+    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();
+}
+
+bool CommandObjectIterateOverThreads::BucketThread(
+    lldb::tid_t tid, std::set<UniqueStack> &unique_stacks,
+    CommandReturnObject &result) {
+  // Grab the corresponding thread for the given thread id.
+  Process *process = m_exe_ctx.GetProcessPtr();
+  Thread *thread = process->GetThreadList().FindThreadByID(tid).get();
+  if (thread == nullptr) {
+    result.AppendErrorWithFormatv("Failed to process thread #{0}.\n", tid);
+    result.SetStatus(eReturnStatusFailed);
+    return false;
+  }
+
+  // Collect the each frame's address for this call-stack
+  std::stack<lldb::addr_t> stack_frames;
+  const uint32_t frame_count = thread->GetStackFrameCount();
+  for (uint32_t frame_index = 0; frame_index < frame_count; frame_index++) {
+    const lldb::StackFrameSP frame_sp =
+        thread->GetStackFrameAtIndex(frame_index);
+    const lldb::addr_t pc = frame_sp->GetStackID().GetPC();
+    stack_frames.push(pc);
+  }
+
+  uint32_t thread_index_id = thread->GetIndexID();
+  UniqueStack new_unique_stack(stack_frames, thread_index_id);
+
+  // Try to match the threads stack to and existing entry.
+  std::set<UniqueStack>::iterator matching_stack =
+      unique_stacks.find(new_unique_stack);
+  if (matching_stack != unique_stacks.end()) {
+    matching_stack->AddThread(thread_index_id);
+  } else {
+    unique_stacks.insert(new_unique_stack);
+  }
+  return true;
+}

lldb/source/Core/PluginManager.cpp

 //===-- PluginManager.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/PluginManager.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"

 PluginManager::GetSymbolVendorCreateCallbackAtIndex(uint32_t idx) {
   return GetSymbolVendorInstances().GetCallbackAtIndex(idx);
 }
 
 #pragma mark Trace
 
 struct TraceInstance : public PluginInstance<TraceCreateInstance> {
   TraceInstance(ConstString name, std::string description,
-                CallbackType create_callback, llvm::StringRef schema)
+                CallbackType create_callback, llvm::StringRef schema,
+                TraceGetStartCommand get_start_command)
       : PluginInstance<TraceCreateInstance>(name, std::move(description),
                                             create_callback),
-        schema(schema) {}
+        schema(schema), get_start_command(get_start_command) {}
 
   llvm::StringRef schema;
+  TraceGetStartCommand get_start_command;
 };
 
 typedef PluginInstances<TraceInstance> TraceInstances;
 
-static TraceInstances &GetTraceInstances() {
+static TraceInstances &GetTracePluginInstances() {
   static TraceInstances g_instances;
   return g_instances;
 }
 
 bool PluginManager::RegisterPlugin(ConstString name, const char *description,
                                    TraceCreateInstance create_callback,
-                                   llvm::StringRef schema) {
-  return GetTraceInstances().RegisterPlugin(name, description, create_callback,
-                                            schema);
+                                   llvm::StringRef schema,
+                                   TraceGetStartCommand get_start_command) {
+  return GetTracePluginInstances().RegisterPlugin(
+      name, description, create_callback, schema, get_start_command);
 }
 
 bool PluginManager::UnregisterPlugin(TraceCreateInstance create_callback) {
-  return GetTraceInstances().UnregisterPlugin(create_callback);
+  return GetTracePluginInstances().UnregisterPlugin(create_callback);
 }
 
 TraceCreateInstance
 PluginManager::GetTraceCreateCallback(ConstString plugin_name) {
-  return GetTraceInstances().GetCallbackForName(plugin_name);
+  return GetTracePluginInstances().GetCallbackForName(plugin_name);
 }
 
 llvm::StringRef PluginManager::GetTraceSchema(ConstString plugin_name) {
-  for (const TraceInstance &instance : GetTraceInstances().GetInstances())
+  for (const TraceInstance &instance : GetTracePluginInstances().GetInstances())
     if (instance.name == plugin_name)
       return instance.schema;
   return llvm::StringRef();
 }
 
+CommandObjectSP
+PluginManager::GetTraceStartCommand(llvm::StringRef plugin_name,
+                                    CommandInterpreter &interpreter) {
+  for (const TraceInstance &instance : GetTracePluginInstances().GetInstances())
+    if (instance.name.GetStringRef() == plugin_name)
+      return instance.get_start_command(interpreter);
+  return CommandObjectSP();
+}
+
 llvm::StringRef PluginManager::GetTraceSchema(size_t index) {
-  if (TraceInstance *instance = GetTraceInstances().GetInstanceAtIndex(index))
+  if (TraceInstance *instance =
+          GetTracePluginInstances().GetInstanceAtIndex(index))
     return instance->schema;
   return llvm::StringRef();
 }
 
 #pragma mark UnwindAssembly
 
 typedef PluginInstance<UnwindAssemblyCreateInstance> UnwindAssemblyInstance;
 typedef PluginInstances<UnwindAssemblyInstance> UnwindAssemblyInstances;

 void PluginManager::DebuggerInitialize(Debugger &debugger) {
   GetDynamicLoaderInstances().PerformDebuggerCallback(debugger);
   GetJITLoaderInstances().PerformDebuggerCallback(debugger);
   GetPlatformInstances().PerformDebuggerCallback(debugger);
   GetProcessInstances().PerformDebuggerCallback(debugger);
   GetSymbolFileInstances().PerformDebuggerCallback(debugger);
   GetOperatingSystemInstances().PerformDebuggerCallback(debugger);
   GetStructuredDataPluginInstances().PerformDebuggerCallback(debugger);
+  GetTracePluginInstances().PerformDebuggerCallback(debugger);
 }
 
 // This is the preferred new way to register plugin specific settings.  e.g.
 // This will put a plugin's settings under e.g.
 // "plugin.<plugin_type_name>.<plugin_type_desc>.SETTINGNAME".
 static lldb::OptionValuePropertiesSP
 GetDebuggerPropertyForPlugins(Debugger &debugger, ConstString plugin_type_name,
                               ConstString plugin_type_desc, bool can_create) {

lldb/source/Interpreter/CMakeLists.txt

 lldb_tablegen(InterpreterProperties.inc -gen-lldb-property-defs
   SOURCE InterpreterProperties.td
   TARGET LLDBInterpreterPropertiesGen)
 
 lldb_tablegen(InterpreterPropertiesEnum.inc -gen-lldb-property-enum-defs
   SOURCE InterpreterProperties.td
   TARGET LLDBInterpreterPropertiesEnumGen)
 
 add_lldb_library(lldbInterpreter
   CommandAlias.cpp
   CommandHistory.cpp
   CommandInterpreter.cpp
   CommandObject.cpp
+  CommandObjectDelegate.cpp
   CommandOptionValidators.cpp
   CommandReturnObject.cpp
   OptionArgParser.cpp
   OptionGroupArchitecture.cpp
   OptionGroupBoolean.cpp
   OptionGroupFile.cpp
   OptionGroupFormat.cpp
   OptionGroupPythonClassWithDict.cpp

lldb/source/Interpreter/CommandObject.cpp

 //===-- CommandObject.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/CommandObject.h"
 
 #include <map>
 #include <sstream>
 #include <string>
 
 #include <ctype.h>
 #include <stdlib.h>
 
if (process == nullptr) {
           result.AppendError("Process is running.  Use 'process interrupt' to "
                              "pause execution.");
           result.SetStatus(eReturnStatusFailed);
           return false;
         }
       }
     }
   }
+
+  if (GetFlags().Test(eCommandProcessMustBeTraced)) {
+    Target *target = m_exe_ctx.GetTargetPtr();
+    if (target && !target->GetTrace()) {
+      result.SetError("Process is not being traced.");
+      return false;
+    }
+  }
+
   return true;
 }
 
 void CommandObject::Cleanup() {
   m_exe_ctx.Clear();
   if (m_api_locker.owns_lock())
     m_api_locker.unlock();
 }

lldb/source/Interpreter/CommandObjectDelegate.cpp

+//===-- CommandObjectDelegate.cpp -----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Interpreter/CommandObjectDelegate.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace llvm;
+
+Options *CommandObjectDelegate::GetOptions() {
+  CommandObjectSP delegate_cmd_sp = GetDelegateCommand();
+  if (delegate_cmd_sp)
+    return delegate_cmd_sp->GetOptions();
+  return CommandObject::GetOptions();
+}
+
+StringRef CommandObjectDelegate::GetSyntax() {
+  CommandObjectSP delegate_cmd_sp = GetDelegateCommand();
+  if (delegate_cmd_sp)
+    return delegate_cmd_sp->GetSyntax();
+  return CommandObject::GetSyntax();
+}
+
+StringRef CommandObjectDelegate::GetHelp() {
+  CommandObjectSP delegate_cmd_sp = GetDelegateCommand();
+  if (delegate_cmd_sp)
+    return delegate_cmd_sp->GetHelp();
+  return CommandObject::GetHelp();
+}
+
+StringRef CommandObjectDelegate::GetHelpLong() {
+  CommandObjectSP delegate_cmd_sp = GetDelegateCommand();
+  if (delegate_cmd_sp)
+    return delegate_cmd_sp->GetHelpLong();
+  return CommandObject::GetHelpLong();
+}
+
+bool CommandObjectDelegate::WantsRawCommandString() {
+  CommandObjectSP delegate_cmd_sp = GetDelegateCommand();
+  if (delegate_cmd_sp)
+    return delegate_cmd_sp->WantsRawCommandString();
+  return false;
+}
+
+void CommandObjectDelegate::HandleCompletion(CompletionRequest &request) {
+  CommandObjectSP delegate_cmd_sp = GetDelegateCommand();
+  if (delegate_cmd_sp)
+    delegate_cmd_sp->HandleCompletion(request);
+  else
+    CommandObject::HandleCompletion(request);
+}
+
+void CommandObjectDelegate::HandleArgumentCompletion(
+    CompletionRequest &request, OptionElementVector &opt_element_vector) {
+  CommandObjectSP delegate_cmd_sp = GetDelegateCommand();
+  if (delegate_cmd_sp)
+    delegate_cmd_sp->HandleArgumentCompletion(request, opt_element_vector);
+  else
+    CommandObject::HandleArgumentCompletion(request, opt_element_vector);
+}
+
+const char *CommandObjectDelegate::GetRepeatCommand(Args &current_command_args,
+                                                    uint32_t index) {
+  CommandObjectSP delegate_cmd_sp = GetDelegateCommand();
+  if (delegate_cmd_sp)
+    return delegate_cmd_sp->GetRepeatCommand(current_command_args, index);
+  return CommandObject::GetRepeatCommand(current_command_args, index);
+}
+
+bool CommandObjectDelegate::Execute(const char *args_string,
+                                    CommandReturnObject &result) {
+  CommandObjectSP delegate_cmd_sp = GetDelegateCommand();
+  if (delegate_cmd_sp)
+    return delegate_cmd_sp->Execute(args_string, result);
+
+  result.SetError(GetUnsupportedError());
+  return result.Succeeded();
+}

lldb/source/Plugins/Process/elf-core/ProcessElfCore.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_PROCESS_ELF_CORE_PROCESSELFCORE_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_ELF_CORE_PROCESSELFCORE_H
 
 #include <list>
 #include <vector>
 
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 
 #include "Plugins/ObjectFile/ELF/ELFHeader.h"
 #include "Plugins/Process/elf-core/RegisterUtilities.h"
 
 struct ThreadData;
 
error.SetErrorStringWithFormat(
         "error: %s does not support resuming processes",
         GetPluginName().GetCString());
     return error;
   }
 
   // Process Queries
   bool IsAlive() override;
 
+  bool IsLiveDebugSession() override { return false; }
+
   bool WarnBeforeDetach() const override { return false; }
 
   // Process Memory
   size_t ReadMemory(lldb::addr_t addr, void *buf, size_t size,
                     lldb_private::Status &error) override;
 
   size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                       lldb_private::Status &error) override;

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

 #define LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_PROCESSGDBREMOTE_H
 
 #include <atomic>
 #include <map>
 #include <mutex>
 #include <string>
 #include <vector>
 
 #include "lldb/Core/LoadedModuleInfoList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/ThreadSafeValue.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/ConstString.h"
public:
 
   void RefreshStateAfterStop() override;
 
   void SetUnixSignals(const lldb::UnixSignalsSP &signals_sp);
 
   // Process Queries
   bool IsAlive() override;
 
+  bool IsLiveDebugSession() override { return true; }
+
   lldb::addr_t GetImageInfoAddress() override;
 
   void WillPublicStop() override;
 
   // Process Memory
   size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                       Status &error) override;
 

lldb/source/Plugins/Process/mach-core/ProcessMachCore.h

 //===-- ProcessMachCore.h ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_PROCESS_MACH_CORE_PROCESSMACHCORE_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_MACH_CORE_PROCESSMACHCORE_H
 
 #include <list>
 #include <vector>
 
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 
 class ThreadKDP;
 
 class ProcessMachCore : public lldb_private::Process {
 public:
   // Constructors and Destructors
size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                       lldb_private::Status &error) override;
 
   lldb_private::Status
   GetMemoryRegionInfo(lldb::addr_t load_addr,
                       lldb_private::MemoryRegionInfo &region_info) override;
 
   lldb::addr_t GetImageInfoAddress() override;
 
+  bool IsLiveDebugSession() override { return false; }
+
 protected:
   friend class ThreadMachCore;
 
   void Clear();
 
   bool UpdateThreadList(lldb_private::ThreadList &old_thread_list,
                         lldb_private::ThreadList &new_thread_list) override;
 

lldb/source/Plugins/Process/minidump/ProcessMinidump.h

public:
   Status GetMemoryRegionInfo(lldb::addr_t load_addr,
                              MemoryRegionInfo &range_info) override;
 
   Status GetMemoryRegions(
       lldb_private::MemoryRegionInfos &region_list) override;
 
   bool GetProcessInfo(ProcessInstanceInfo &info) override;
 
+  bool IsLiveDebugSession() override { return false; }
+
   Status WillResume() override {
     Status error;
     error.SetErrorStringWithFormat(
         "error: %s does not support resuming processes",
         GetPluginName().GetCString());
     return error;
   }
 

lldb/source/Plugins/Trace/intel-pt/CMakeLists.txt

 if (NOT LIBIPT_INCLUDE_PATH)
   message (FATAL_ERROR "libipt include path not provided")
 endif()
 
 if (NOT EXISTS "${LIBIPT_INCLUDE_PATH}")
   message (FATAL_ERROR "invalid libipt include path provided")
 endif()
 include_directories(${LIBIPT_INCLUDE_PATH})
 
 find_library(LIBIPT_LIBRARY ipt PATHS ${LIBIPT_LIBRARY_PATH} REQUIRED)
 
+lldb_tablegen(TraceIntelPTCommandOptions.inc -gen-lldb-option-defs
+  SOURCE TraceIntelPTOptions.td
+  TARGET TraceIntelPTOptionsGen)
+
 add_lldb_library(lldbPluginTraceIntelPT PLUGIN
+  CommandObjectTraceStartIntelPT.cpp
   DecodedThread.cpp
   IntelPTDecoder.cpp
   TraceIntelPT.cpp
   TraceIntelPTSessionFileParser.cpp
 
   LINK_LIBS
     lldbCore
     lldbSymbol
     lldbTarget
     ${LIBIPT_LIBRARY}
   LINK_COMPONENTS
     Support
   )
+
+
+add_dependencies(lldbPluginTraceIntelPT TraceIntelPTOptionsGen)

lldb/source/Plugins/Trace/intel-pt/CommandObjectTraceStartIntelPT.h

+//===-- CommandObjectTraceStartIntelPT.h ----------------------*- C++ //-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_COMMANDOBJECTTRACESTARTINTELPT_H
+#define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_COMMANDOBJECTTRACESTARTINTELPT_H
+
+#include "../../../../source/Commands/CommandObjectThreadUtil.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+
+namespace lldb_private {
+namespace trace_intel_pt {
+
+class CommandObjectTraceStartIntelPT : public CommandObjectIterateOverThreads {
+public:
+  class CommandOptions : public Options {
+  public:
+    CommandOptions() : Options() { OptionParsingStarting(nullptr); }
+
+    ~CommandOptions() override = default;
+
+    Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
+                          ExecutionContext *execution_context) override;
+
+    void OptionParsingStarting(ExecutionContext *execution_context) override;
+
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
+
+    size_t m_size_in_kb;
+    uint32_t m_custom_config;
+  };
+
+  CommandObjectTraceStartIntelPT(CommandInterpreter &interpreter)
+      : CommandObjectIterateOverThreads(
+            interpreter, "thread trace start",
+            "Start tracing one or more threads with intel-pt. "
+            "Defaults to the current thread. Thread indices can be "
+            "specified as arguments.\n Use the thread-index \"all\" to trace "
+            "all threads.",
+            "thread trace start [<thread-index> <thread-index> ...] "
+            "[<intel-pt-options>]",
+            lldb::eCommandRequiresProcess | lldb::eCommandTryTargetAPILock |
+                lldb::eCommandProcessMustBeLaunched |
+                lldb::eCommandProcessMustBePaused),
+        m_options() {}
+
+  ~CommandObjectTraceStartIntelPT() override = default;
+
+  Options *GetOptions() override { return &m_options; }
+
+protected:
+  bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override;
+
+  CommandOptions m_options;
+};
+
+} // namespace trace_intel_pt
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_COMMANDOBJECTTRACESTARTINTELPT_H

lldb/source/Plugins/Trace/intel-pt/CommandObjectTraceStartIntelPT.cpp

+//===-- CommandObjectTraceStartIntelPT.cpp --------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "CommandObjectTraceStartIntelPT.h"
+
+#include "lldb/Host/OptionParser.h"
+#include "lldb/Target/Trace.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::trace_intel_pt;
+using namespace llvm;
+
+#define LLDB_OPTIONS_thread_trace_start_intel_pt
+#include "TraceIntelPTCommandOptions.inc"
+
+Status CommandObjectTraceStartIntelPT::CommandOptions::SetOptionValue(
+    uint32_t option_idx, llvm::StringRef option_arg,
+    ExecutionContext *execution_context) {
+  Status error;
+  const int short_option = m_getopt_table[option_idx].val;
+
+  switch (short_option) {
+  case 's': {
+    int32_t size_in_kb;
+    if (option_arg.empty() || option_arg.getAsInteger(0, size_in_kb) ||
+        size_in_kb < 0)
+      error.SetErrorStringWithFormat("invalid integer value for option '%s'",
+                                     option_arg.str().c_str());
+    else
+      m_size_in_kb = size_in_kb;
+    break;
+  }
+  case 'c': {
+    int32_t custom_config;
+    if (option_arg.empty() || option_arg.getAsInteger(0, custom_config) ||
+        custom_config < 0)
+      error.SetErrorStringWithFormat("invalid integer value for option '%s'",
+                                     option_arg.str().c_str());
+    else
+      m_custom_config = custom_config;
+    break;
+  }
+  default:
+    llvm_unreachable("Unimplemented option");
+  }
+  return error;
+}
+
+void CommandObjectTraceStartIntelPT::CommandOptions::OptionParsingStarting(
+    ExecutionContext *execution_context) {
+  m_size_in_kb = 4;
+  m_custom_config = 0;
+}
+
+llvm::ArrayRef<OptionDefinition>
+CommandObjectTraceStartIntelPT::CommandOptions::GetDefinitions() {
+  return llvm::makeArrayRef(g_thread_trace_start_intel_pt_options);
+}
+
+bool CommandObjectTraceStartIntelPT::HandleOneThread(
+    lldb::tid_t tid, CommandReturnObject &result) {
+  result.AppendMessageWithFormat(
+      "would trace tid %" PRIu64 " with size_in_kb %zu and custom_config %d\n",
+      tid, m_options.m_size_in_kb, m_options.m_custom_config);
+  result.SetStatus(eReturnStatusSuccessFinishResult);
+  return result.Succeeded();
+}

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.cpp

 //===-- TraceIntelPT.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "TraceIntelPT.h"
 
+#include "CommandObjectTraceStartIntelPT.h"
 #include "TraceIntelPTSessionFileParser.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadTrace.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
 LLDB_PLUGIN_DEFINE(TraceIntelPT)
 
+CommandObjectSP GetStartCommand(CommandInterpreter &interpreter) {
+  return CommandObjectSP(new CommandObjectTraceStartIntelPT(interpreter));
+}
+
 void TraceIntelPT::Initialize() {
-  PluginManager::RegisterPlugin(GetPluginNameStatic(), "Intel Processor Trace",
-                                CreateInstance,
-                                TraceIntelPTSessionFileParser::GetSchema());
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), "Intel Processor Trace", CreateInstance,
+      TraceIntelPTSessionFileParser::GetSchema(), GetStartCommand);
 }
 
 void TraceIntelPT::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 ConstString TraceIntelPT::GetPluginNameStatic() {
   static ConstString g_name("intel-pt");

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTOptions.td

+include "../../../../source/Commands/OptionsBase.td"
+
+let Command = "thread trace start intel pt" in {
+  def thread_trace_start_intel_pt_size: Option<"size", "s">,
+    Group<1>,
+    Arg<"Value">,
+    Desc<"The size of the trace in KB. The kernel rounds it down to the nearest"
+         " multiple of 4. Defaults to 4.">;
+  def thread_trace_start_intel_pt_custom_config: Option<"custom-config", "c">,
+    Group<1>,
+    Arg<"Value">,
+    Desc<"Low level bitmask configuration for the kernel based on the values "
+         "in `grep -H  /sys/bus/event_source/devices/intel_pt/format/*`. "
+         "See https://github.com/torvalds/linux/blob/master/tools/perf/Documentation/perf-intel-pt.txt"
+         " for more information. Defaults to 0.">;
+}

lldb/source/Target/Process.cpp

 //===-- Process.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <atomic>
 #include <memory>
 #include <mutex>
 
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/DynamicCheckerFunctions.h"
UtilityFunction *Process::GetLoadImageUtilityFunction(
     llvm::function_ref<std::unique_ptr<UtilityFunction>()> factory) {
   if (platform != GetTarget().GetPlatform().get())
     return nullptr;
   llvm::call_once(m_dlopen_utility_func_flag_once,
                   [&] { m_dlopen_utility_func_up = factory(); });
   return m_dlopen_utility_func_up.get();
 }
 
+llvm::Expected<TraceTypeInfo> Process::GetSupportedTraceType() {
+  if (!IsLiveDebugSession())
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Can't trace a non-live process.");
+  return llvm::make_error<UnimplementedError>();
+}
+
 bool Process::CallVoidArgVoidPtrReturn(const Address *address,
                                        addr_t &returned_func,
                                        bool trap_exceptions) {
   Thread *thread = GetThreadList().GetExpressionExecutionThread().get();
   if (thread == nullptr || address == nullptr)
     return false;
 
   EvaluateExpressionOptions options;

lldb/test/API/commands/trace/TestTraceDumpInstructions.py

def testErrorMessages(self):
             substrs=["error: invalid process"],
             error=True)
 
         # Now we check the output when there's a running target without a trace
         self.expect("b main")
         self.expect("run")
 
         self.expect("thread trace dump instructions",
-            substrs=["error: this thread is not being traced"],
+            substrs=["error: Process is not being traced"],
             error=True)
 
     def testRawDumpInstructions(self):
         self.expect("trace load -v " +
             os.path.join(self.getSourceDir(), "intelpt-trace", "trace.json"),
             substrs=["intel-pt"])
 
         self.expect("thread trace dump instructions --raw",

lldb/test/API/commands/trace/TestTraceStartStop.py

+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+from lldbsuite.test.decorators import *
+
+class TestTraceLoad(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def setUp(self):
+        TestBase.setUp(self)
+        if 'intel-pt' not in configuration.enabled_plugins:
+            self.skipTest("The intel-pt test plugin is not enabled")
+
+    def expectGenericHelpMessageForStartCommand(self):
+        self.expect("help thread trace start",
+            substrs=["Syntax: thread trace start [<trace-options>]"])
+
+    def testStartStopSessionFileThreads(self):
+        # it should fail for processes from json session files
+        self.expect("trace load -v " + os.path.join(self.getSourceDir(), "intelpt-trace", "trace.json"))
+        self.expect("thread trace start", error=True,
+            substrs=["error: tracing is not supported. Can't trace a non-live process"])
+
+        # the help command should be the generic one, as it's not a live process
+        self.expectGenericHelpMessageForStartCommand()
+
+        # this should fail because 'trace stop' is not yet implemented
+        self.expect("thread trace stop", error=True,
+            substrs=["error: failed stopping thread 3842849"])
+
+    @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
+    def testStartStopLiveThreads(self):
+        # The help command should be the generic one if there's no process running
+        self.expectGenericHelpMessageForStartCommand()
+
+        self.expect("thread trace start", error=True,
+            substrs=["error: No process available"])
+
+        self.expect("file " + os.path.join(self.getSourceDir(), "intelpt-trace", "a.out"))
+        self.expect("b main")
+
+        self.expect("thread trace start", error=True,
+            substrs=["error: No process available"])
+
+        # The help command should be the generic one if there's still no process running
+        self.expectGenericHelpMessageForStartCommand()
+
+        self.expect("r")
+
+        # the help command should be the intel-pt one now
+        self.expect("help thread trace start",
+            substrs=["Start tracing one or more threads with intel-pt.",
+                     "Syntax: thread trace start [<thread-index> <thread-index> ...] [<intel-pt-options>]"])
+
+        self.expect("thread trace start",
+            patterns=["would trace tid .* with size_in_kb 4 and custom_config 0"])
+
+        self.expect("thread trace start --size 20 --custom-config 1",
+            patterns=["would trace tid .* with size_in_kb 20 and custom_config 1"])
+
+        # This fails because "trace stop" is not yet implemented.
+        self.expect("thread trace stop", error=True,
+            substrs=["error: Process is not being traced"])
+
+        self.expect("c")
+        # Now the process has finished, so the commands should fail
+        self.expect("thread trace start", error=True,
+            substrs=["error: Process must be launched."])
+
+        self.expect("thread trace stop", error=True,
+            substrs=["error: Process must be launched."])