[trace] [intel pt] Create a "process trace save" command

[hanbingwang]

Summary

added new command "process trace save -d <directory>".
-it saves a JSON file as <directory>/trace.json, with the main properties of the trace session.
-it saves binary Intel-pt trace as <directory>/thread_id.trace; each file saves each thread.
-it saves modules to the directory <directory>/modules .
-it only works for live process and it only support Intel-pt right now.

Example:

b main
run
process trace start
n
process trace save -d /tmp/mytrace

A file named trace.json and xxx.trace should be generated in /tmp/mytrace. To load the trace that was just saved:

trace load /tmp/mytrace
thread trace dump instructions

You should see the instructions of the trace got printed.

To run a test:

cd ~/llvm-sand/build/Release/fbcode-x86_64/toolchain
ninja lldb-dotest
./bin/lldb-dotest -p TestTraceSave

[hanbingwang]

fix a typo. change a string "the trace of ..." from "the trace or ..."

[clayborg]

lldb/include/lldb/Target/Trace.h

76

This class will already have a process in "Process *m_live_process" member variable, so no need to pass in the process. This will be NULL if we loaded a trace from disk already, but that should be ok because it was already loaded from something on disk.

lldb/source/Commands/CommandObjectProcess.cpp

1690–1696

1711

No need for the process as mentioned in above inline comment.

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

267 ↗

(On Diff #364893)

llvm::ArrayRef

297 ↗

(On Diff #364893)

llvm::ArrayRef

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

40 ↗

(On Diff #364893)

This data is quite large, can we just get a reference to the data without making a copy by using llvm::ArrayRef?

70 ↗

(On Diff #364893)

llvm::ArrayRef?

88 ↗

(On Diff #364893)

llvm::ArrayRef

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

72

remove process_sp and use "m_live_process"

78

llvm::ArrayRef

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

26

remove process

28

llvm::ArrayRef

[wallace]

lldb/include/lldb/Target/Trace.h

76

Fair enough. Then better rename this method to SaveLiveProcessTraceToDisk or SaveLiveTraceToDisk, and make a comment mentioning that this will return an error if this is not tracing a live process.

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

36 ↗

(On Diff #364893)

thr -> the

40 ↗

(On Diff #364893)

Sadly this can't work. LiveThreadDecoder::GetRawTrace() gets the raw trace from lldb-server and puts it in a vector without any object owning it. So the actual vector will need to be returned because no one wants to own it. It's not that bad though, because Expected just moves the inner data without creating copies.

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

39–44

use self.getBuildDir() instead of self.getSourceDir() for the files were you will store data

70–71

you don't need to do this. Every time the test runs all the previous data will be wiped out

[wallace]

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

267–281 ↗

(On Diff #364893)

Given that now we will just make it work for live processes, you can revert these changes and just invoke TraceIntelPT::GetLiveThreadBuffer directly

277 ↗

(On Diff #364893)

result.reserve(trace_data.size())

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

40 ↗

(On Diff #364893)

Another option is to store the raw trace in the ThreadDecoder itself, though might not be that useful because decoding happens only once and saving to disk as well.

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

2

this shuold have the same length as line 7

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

33–48 ↗

(On Diff #364893)

remove braces for one-line if statements

50 ↗

(On Diff #364893)

remove the word struct

65–66 ↗

(On Diff #364893)

for checking errors while writing, do this:

os << out;
os.close();
if (!os)
  return createStringError(unconvertibleErrorCode(), formatv("couldn't write to the file {0}", trace_path.getPath());
return Error::success();

then you have to make this method return llvm::Error

72–74 ↗

(On Diff #364893)

remove braces

76–82 ↗

(On Diff #364893)

remove the keyword struct. It's very old-style

93–95 ↗

(On Diff #364893)

remove braces for one-liners

99 ↗

(On Diff #364893)

ditto

102 ↗

(On Diff #364893)

invoke BuildModulesSection(process_sp) here directly to avoid an unnecessary copy

[wallace]

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

76 ↗

(On Diff #364893)

it'd be better to create a constructor of JSONTraceIntelPTCPUInfo that receives a pt_cpu object and then does this conversion inside

118–119 ↗

(On Diff #364893)

json_path is a bad name, call it raw_trace_path

126–128 ↗

(On Diff #364893)

braces

132 ↗

(On Diff #364893)

do the same thing here of closing the stream and then checking if it's correct

147–163 ↗

(On Diff #364893)

remove braces for one-liners

164 ↗

(On Diff #364893)

you should copy the file to the directory as well. The reason is that if the original file changes, then decoding will fail, so we need to make this self-contained.
You can use the function https://llvm.org/doxygen/namespacellvm_1_1sys_1_1fs.html#abe768b38d21bfc2bc91a1c1d09cd84de to copy files

You can follow this idea:

If a module exists in the path /usr/lib/foo/libbar.so, then you should copy it to <directory>/modules/usr/lib/foo/libbar.so.

Then the "path" entry is the json file should be "modules/usr/lib/foo/libbar.so", and the "systemPath" entry should be "/usr/lib/foo/libbar.so"

Then, update all the comments mentioning that the original modules will be copied over to the <directory/modules> folder with the goal of making it self-contained. A cool benefit if this is that you could zip this folder, send it over to another person, and they could see the same exact trace as you.

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

11

nice test

35–37

now that we are changing to live processes, this won't work. Instead, trace one of the existing binary files in the test folder, run it, get the first and last 20 instructions, save the contents in strings, then save the trace, then load it and dump the instructions again, finally assert that the outputs are the same

[wallace]

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

19 ↗

(On Diff #364893)

this doesn't seem relevant

22 ↗

(On Diff #364893)

leave a black line before this

31 ↗

(On Diff #364893)

Better rename this class to TraceIntelPTSessionSaver, because this is not just working with a file, it's instead dealing with a directory of many files

56 ↗

(On Diff #364893)

To make these useful functions more generic so that they can be reused by other Trace technologies, you can create a file TraceSessionSaver.h/cpp in Plugins/Trace/common.
Then you can move this function to that file an call it WriteTraceSession(llvm::Value session_json, FileSpec directory)

87 ↗

(On Diff #364893)

you could move BuildProcessesSection, BuildThreadsSection and BuildModulesSection to TraceSessionSaver.h/cpp if you provide a callback that receives a thread_id and returns a raw trace. Then almost all the code would be reusable by other Trace plug-ins

[hanbingwang]

*trace.h:
-rename SaveToDisk() to SaveLiveTraceToDisk()

*IntelPTDecoder.h, IntelPTDecoder.cpp:
-removed GetRawTrace()

*TraceIntelPT.h, TraceIntelPT.cpp:
-removed GetThreadBuffer()
-in function SaveToDisk(), replace "process_sp" with "m_live_process"

*TraceIntelPTSessionFileSaver.h, TraceIntelPTSessionFileSaver.cpp:
-renamed to TraceIntelPTSessionSaver.h and TraceIntelPTSessionSaver.cpp
-the function BuildModulesSection() copies modules inside <directory>/modules
-create new constructors for struct JSONTraceIntelPTCPUInfo
-error checking for writing stream to file

[hanbingwang]

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

87 ↗

(On Diff #364893)

Sorry I did not make changes here. A bit unsure how to "provide a callback that receives a thread_id and returns a raw trace" and how would it work?

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

35–37

I'm not sure how to "save the contents in strings"?

[wallace]

discussed offline of some improvements to make

[hanbingwang]

*TraceSessionSaver.h, TraceSessionSaver.cpp:
-move BuildModulesSection(), BuildThreadsSection(), BuildProcessesSection(), WriteSessionToFile() from TraceIntelPTSessionSaver.cpp to this file. These functions are generic for all trace plug-ins.

*TestTraceSave.py:
-new test case for "process trace save" command

*TraceIntelPT.h, Trace.h

• change IsTraced(const Thread &thread) to IsTraced(lldb::tid_t tid)

*TraceIntelPTJSONStructs.h
-rename JSONTraceIntelPTSchema to JSONTraceIntelPTSession

[wallace]

Almost there. Many cosmetic changes but the logic is all good.

lldb/include/lldb/Target/Trace.h

176–177

The id of the thread in question

lldb/source/Commands/Options.td

747

remove this line

756

remove this line

lldb/source/Plugins/Trace/common/TraceJSONStructs.cpp

29–30

merge into one single line

46–48

delete braces

52–54

same here

62–64

ditto

lldb/source/Plugins/Trace/common/TraceJSONStructs.h

29–34

you can omit these constructors because they don't have anything custom

43–47

same here, just delete these lines

53–58

similarly, delete these

70–73

delete

lldb/source/Plugins/Trace/common/TraceSessionSaver.cpp

28

trace_session_description

35

move line 30 here to avoid that unnecessary out variable

51

json_session_description

59–61

delete braces

78

rename this to json_threads

87

avoid this. Instead of creating first an empty json_thread with invalid values, wait until this moment to create a valid JSONThread

json_threads.push_back(JSONThread { thread_sp->GetID(), raw_trace_path.GetPath().c_str() });

that way all the code that you write is valid at all times

95–97

delete braces

115

json_modules

123–125

delete braces

128–130

delete braces

lldb/source/Plugins/Trace/common/TraceSessionSaver.h

20

Save the trace session description JSON object inside the given directory as a file named \a trace.json.

23

trace_session_description is more readable. Reading 'jo' is not intuitive and confuses a bit

32

delete this line

34

trace_session_description_json

37

Build the processes section of the trace session description file. Besides returning the processes information, this method saves to disk all modules and raw traces corresponding to the traced threads of the given process.

43–46

50

The directory where files will be saved when building the processes section.

52–54

/// \return
///      The processes section or an error in case of failures.

54

delete

62

Build the threads ... of the trace session description file.

63–64

For each traced thread, its raw trace is also written to the file thread_id_.trace inside of the given directory.

70–73

copy the comment from above

76–77

The directory where files will be saved when building the threads section.

79–80

You are making a lot of mistakes at formatting the comments. Make sure to look for existing examples as reference.

/// \return
///      The threads section or an error in case of failures.

81

delete

90

Build the modules sub-section of the trace session description file.

93

Copying the modules has the benefit of making these trace session directories self-contained, as the raw traces and modules are part of the output directory and can be sent to another machine, where lldb can load them and replicate exactly the same trace session.

107–109

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

75

Saving a trace requires...

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

36–39

delete

46–50

delete

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

61–62

Use {} constructors

JSONTraceIntelPTSession json_trace_intel_pt_session {
      json_trace_intel_pt_trace.get(), json_trace_session_base.get() };

that way you don't need to specify your own constructor

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

32–34

you don't need to pass this variable. You should be able to get the live_process directly from trace_ipt. You can create a method in TraceIntelPT for this if needed

41–55

in the first return you are using the correct formatting, but in the second you don't. Try to be more careful

44

delete

56

delete

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

39–47

this a little bit weird, you can instead place a breakpoint at the line that you want and stop just there

76

Also add a test in which you pass an invalid directory

[hanbingwang]

*TraceIntelPT.h, TraceIntelPT.cpp:
-add new function GetLiveProcess()
*TraceIntelPTSessionSaver.h, TraceIntelPTSessionSaver.cpp

• the function SaveToDisk() no longer requires "m_live_process" as input param.

*TestTraceSave.py:
-added new test cases.

[hanbingwang]

merge into one line: "json_module["loadAddress"] = oss.str();"

[wallace]

good job

lldb/include/lldb/Target/Trace.h

 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/TraceCursor.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/TraceGDBRemotePackets.h"
 #include "lldb/Utility/UnimplementedError.h"
 #include "lldb/lldb-private.h"
+#include "lldb/lldb-types.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
 /// that the data can be dumped, used for reverse and forward stepping to allow
public:
   /// This function will dump all of the trace data for all threads in a user
   /// readable format. Options for dumping can be added as this API is iterated
   /// on.
   ///
   /// \param[in] s
   ///     A stream object to dump the information to.
   virtual void Dump(Stream *s) const = 0;
 
+  /// Save the trace of a live process to the specified directory, which
+  /// will be created if needed.
+  /// This will also create a a file \a <directory>/trace.json with the main
+  /// properties of the trace session, along with others files which contain
+  /// the actual trace data. The trace.json file can be used later as input
+  /// for the "trace load" command to load the trace in LLDB.
+  /// The process being trace is not a live process, return an error.
+  ///
+  /// \param[in] directory
+  ///   The directory where the trace files will be saved.
+  ///
+  /// \return
+  ///   \a llvm::success if the operation was successful, or an \a llvm::Error
+  ///   otherwise.
+  virtual llvm::Error SaveLiveTraceToDisk(FileSpec directory) = 0;
+
   /// Find a trace plug-in using JSON data.
   ///
   /// When loading trace data from disk, the information for the trace data
   /// can be contained in multiple files and require plug-in specific
   /// information about the CPU. Using data like JSON provides an
   /// easy way to specify all of the settings and information that we will need
   /// to load trace data into LLDB. This structured data can include:
   ///   - The plug-in name (this allows a specific plug-in to be selected)
   ///   - Architecture or target triple
   ///   - one or more paths to the trace data file on disk
public:
   ///
   /// \param[in] verbose
   ///     If \b true, print detailed info
   ///     If \b false, print compact info
   virtual void DumpTraceInfo(Thread &thread, Stream &s, bool verbose) = 0;
 
   /// Check if a thread is currently traced by this object.
   ///
-  /// \param[in] thread
-  ///     The thread in question.
+  /// \param[in] tid
+  ///     The id of the thread in question.
   ///
   /// \return
   ///     \b true if the thread is traced by this instance, \b false otherwise.
-  virtual bool IsTraced(const Thread &thread) = 0;
+  virtual bool IsTraced(lldb::tid_t tid) = 0;
 
   /// \return
   ///     A description of the parameters to use for the \a Trace::Start method.
   virtual const char *GetStartConfigurationHelp() = 0;
 
   /// Start tracing a live process.
   ///
   /// \param[in] configuration

lldb/source/Commands/CommandObjectProcess.cpp

CommandObjectProcessTraceStart(CommandInterpreter &interpreter)
             "process trace start [<trace-options>]") {}
 
 protected:
   lldb::CommandObjectSP GetDelegateCommand(Trace &trace) override {
     return trace.GetProcessTraceStartCommand(m_interpreter);
   }
 };
 
+// CommandObjectProcessTraceSave
+#define LLDB_OPTIONS_process_trace_save
+#include "CommandOptions.inc"
+
+#pragma mark CommandObjectProcessTraceSave
+
+class CommandObjectProcessTraceSave : public CommandObjectParsed {
+public:
+  class CommandOptions : public Options {
+  public:
+    CommandOptions() : Options() { OptionParsingStarting(nullptr); }
+
+    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 'd': {
+        m_directory.SetFile(option_arg, FileSpec::Style::native);
+        FileSystem::Instance().Resolve(m_directory);
+        break;
+      }
+      default:
+        llvm_unreachable("Unimplemented option");
+      }
+      return error;
+    }
+
+    void OptionParsingStarting(ExecutionContext *execution_context) override{};
+
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return llvm::makeArrayRef(g_process_trace_save_options);
+    };
+
+    FileSpec m_directory;
+  };
+
+  Options *GetOptions() override { return &m_options; }
+  CommandObjectProcessTraceSave(CommandInterpreter &interpreter)
+      : CommandObjectParsed(
+            interpreter, "process trace save",
+            "Save the trace of the current process in the specified directory. "
+            "The directory will be created if needed. "
+            "This will also create a file <directory>/trace.json with the main "
+            "properties of the trace session, along with others files which "
+            "contain the actual trace data. The trace.json file can be used "
+            "later as input for the \"trace load\" command to load the trace "
+            "in LLDB",
+            "process trace save [<cmd-options>]",
+            eCommandRequiresProcess | eCommandTryTargetAPILock |
+                eCommandProcessMustBeLaunched | eCommandProcessMustBePaused |
+                eCommandProcessMustBeTraced) {}
+
+  ~CommandObjectProcessTraceSave() override = default;
+
+protected:
+  bool DoExecute(Args &command, CommandReturnObject &result) override {
+    ProcessSP process_sp = m_exe_ctx.GetProcessSP();
+
+    TraceSP trace_sp = process_sp->GetTarget().GetTrace();
+
+    if (llvm::Error err = trace_sp->SaveLiveTraceToDisk(m_options.m_directory))
+      result.AppendError(toString(std::move(err)));
+    else
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+
+    return result.Succeeded();
+  }
+
+  CommandOptions m_options;
+};
+
 // CommandObjectProcessTraceStop
 class CommandObjectProcessTraceStop : public CommandObjectParsed {
 public:
   CommandObjectProcessTraceStop(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "process trace stop",
                             "Stop tracing this process. This does not affect "
                             "traces started with the "
                             "\"thread trace start\" command.",

 
 // CommandObjectMultiwordProcessTrace
 class CommandObjectMultiwordProcessTrace : public CommandObjectMultiword {
 public:
   CommandObjectMultiwordProcessTrace(CommandInterpreter &interpreter)
       : CommandObjectMultiword(
             interpreter, "trace", "Commands for tracing the current process.",
             "process trace <subcommand> [<subcommand objects>]") {
+    LoadSubCommand("save", CommandObjectSP(
+                               new CommandObjectProcessTraceSave(interpreter)));
     LoadSubCommand("start", CommandObjectSP(new CommandObjectProcessTraceStart(
                                 interpreter)));
     LoadSubCommand("stop", CommandObjectSP(
                                new CommandObjectProcessTraceStop(interpreter)));
   }
 
   ~CommandObjectMultiwordProcessTrace() override = default;
 };

lldb/source/Commands/Options.td

 }
 
 let Command = "process save_core" in {
   def process_save_core_style : Option<"style", "s">, Group<1>,
     EnumArg<"SaveCoreStyle", "SaveCoreStyles()">, Desc<"Request a specific style "
     "of corefile to be saved.">;
 }
 
+let Command = "process trace save" in {
+  def process_trace_save_directory: Option<"directory", "d">,
+    Group<1>,
+    Arg<"Value">, Required,
+    Desc<"The directory where the trace will be saved."
+        "It will be created if it does not exist.">;
+}
+
 let Command = "script import" in {
   def script_import_allow_reload : Option<"allow-reload", "r">, Group<1>,
     Desc<"Allow the script to be loaded even if it was already loaded before. "
     "This argument exists for backwards compatibility, but reloading is always "
     "allowed, whether you specify it or not.">;
   def relative_to_command_file : Option<"relative-to-command-file", "c">,
     Group<1>, Desc<"Resolve non-absolute paths relative to the location of the "
     "current command file. This argument can only be used when the command is "
     "being sourced from a file.">;
   def silent : Option<"silent", "s">, Group<1>,

lldb/source/Plugins/Trace/common/CMakeLists.txt

 add_lldb_library(lldbPluginTraceCommon
   ThreadPostMortemTrace.cpp
+  TraceJSONStructs.cpp
   TraceSessionFileParser.cpp
+  TraceSessionSaver.cpp
 
   LINK_LIBS
     lldbCore
     lldbTarget
   )

lldb/source/Plugins/Trace/common/TraceJSONStructs.h

+//===-- TraceJSONStruct.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_TRACEJSONSTRUCTS_H
+#define LLDB_TARGET_TRACEJSONSTRUCTS_H
+
+#include "lldb/lldb-types.h"
+#include "llvm/Support/JSON.h"
+
+namespace lldb_private {
+
+struct JSONAddress {
+  lldb::addr_t value;
+};
+
+struct JSONModule {
+  std::string system_path;
+  llvm::Optional<std::string> file;
+  JSONAddress load_address;
+  llvm::Optional<std::string> uuid;
+};
+
+struct JSONThread {
+  int64_t tid;
+  std::string trace_file;
+};
+
+struct JSONProcess {
+  int64_t pid;
+  std::string triple;
+  std::vector<JSONThread> threads;
+  std::vector<JSONModule> modules;
+};
+
+struct JSONTracePluginSettings {
+  std::string type;
+};
+
+struct JSONTraceSessionBase {
+  std::vector<JSONProcess> processes;
+};
+
+/// The trace plug-in implementation should provide its own TPluginSettings,
+/// which corresponds to the "trace" section of the schema.
+template <class TPluginSettings>
+struct JSONTraceSession : JSONTraceSessionBase {
+  TPluginSettings trace;
+};
+
+} // namespace lldb_private
+
+namespace llvm {
+namespace json {
+
+llvm::json::Value toJSON(const lldb_private::JSONModule &module);
+
+llvm::json::Value toJSON(const lldb_private::JSONThread &thread);
+
+llvm::json::Value toJSON(const lldb_private::JSONProcess &process);
+
+llvm::json::Value
+toJSON(const lldb_private::JSONTraceSessionBase &session_base);
+
+bool fromJSON(const Value &value, lldb_private::JSONAddress &address,
+              Path path);
+
+bool fromJSON(const Value &value, lldb_private::JSONModule &module, Path path);
+
+bool fromJSON(const Value &value, lldb_private::JSONThread &thread, Path path);
+
+bool fromJSON(const Value &value, lldb_private::JSONProcess &process,
+              Path path);
+
+bool fromJSON(const Value &value,
+              lldb_private::JSONTracePluginSettings &plugin_settings,
+              Path path);
+
+bool fromJSON(const Value &value, lldb_private::JSONTraceSessionBase &session,
+              Path path);
+
+template <class TPluginSettings>
+bool fromJSON(const Value &value,
+              lldb_private::JSONTraceSession<TPluginSettings> &session,
+              Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("trace", session.trace) &&
+         fromJSON(value, (lldb_private::JSONTraceSessionBase &)session, path);
+}
+
+} // namespace json
+} // namespace llvm
+
+#endif // LLDB_TARGET_TRACEJSONSTRUCTS_H

lldb/source/Plugins/Trace/common/TraceJSONStructs.cpp

+//===-- TraceSessionFileStructs.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 "TraceJSONStructs.h"
+#include "ThreadPostMortemTrace.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
+#include <sstream>
+
+using namespace lldb_private;
+namespace llvm {
+namespace json {
+
+llvm::json::Value toJSON(const JSONModule &module) {
+  llvm::json::Object json_module;
+  json_module["systemPath"] = module.system_path;
+  if (module.file)
+    json_module["file"] = *module.file;
+  std::ostringstream oss;
+  oss << "0x" << std::hex << module.load_address.value;
+  json_module["loadAddress"] = oss.str();
+  if (module.uuid)
+    json_module["uuid"] = *module.uuid;
+  return std::move(json_module);
+}
+
+llvm::json::Value toJSON(const JSONThread &thread) {
+  return Value(Object{{"tid", thread.tid}, {"traceFile", thread.trace_file}});
+}
+
+llvm::json::Value toJSON(const JSONProcess &process) {
+  llvm::json::Object json_process;
+  json_process["pid"] = process.pid;
+  json_process["triple"] = process.triple;
+
+  llvm::json::Array threads_arr;
+  for (JSONThread e : process.threads)
+    threads_arr.push_back(toJSON(e));
+
+  json_process["threads"] = llvm::json::Value(std::move(threads_arr));
+
+  llvm::json::Array modules_arr;
+  for (JSONModule e : process.modules)
+    modules_arr.push_back(toJSON(e));
+
+  json_process["modules"] = llvm::json::Value(std::move(modules_arr));
+
+  return std::move(json_process);
+}
+
+llvm::json::Value toJSON(const JSONTraceSessionBase &session) {
+  llvm::json::Array arr;
+  for (JSONProcess e : session.processes)
+    arr.push_back(toJSON(e));
+
+  return std::move(arr);
+}
+
+bool fromJSON(const Value &value, JSONAddress &address, Path path) {
+  Optional<StringRef> s = value.getAsString();
+  if (s.hasValue() && !s->getAsInteger(0, address.value))
+    return true;
+
+  path.report("expected numeric string");
+  return false;
+}
+
+bool fromJSON(const Value &value, JSONModule &module, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("systemPath", module.system_path) &&
+         o.map("file", module.file) &&
+         o.map("loadAddress", module.load_address) &&
+         o.map("uuid", module.uuid);
+}
+
+bool fromJSON(const Value &value, JSONThread &thread, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("tid", thread.tid) && o.map("traceFile", thread.trace_file);
+}
+
+bool fromJSON(const Value &value, JSONProcess &process, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("pid", process.pid) && o.map("triple", process.triple) &&
+         o.map("threads", process.threads) && o.map("modules", process.modules);
+}
+
+bool fromJSON(const Value &value, JSONTracePluginSettings &plugin_settings,
+              Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("type", plugin_settings.type);
+}
+
+bool fromJSON(const Value &value, JSONTraceSessionBase &session, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("processes", session.processes);
+}
+
+} // namespace json
+} // namespace llvm

lldb/source/Plugins/Trace/common/TraceSessionFileParser.h

 //===-- TraceSessionFileParser.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_TRACESESSIONPARSER_H
 #define LLDB_TARGET_TRACESESSIONPARSER_H
 
-#include "llvm/Support/JSON.h"
-
 #include "ThreadPostMortemTrace.h"
+#include "TraceJSONStructs.h"
 
 namespace lldb_private {
 
 /// \class TraceSessionFileParser TraceSessionFileParser.h
 ///
 /// Base class for parsing the common information of JSON trace session files.
 /// Contains the basic C++ structs that represent the JSON data, which include
 /// \a JSONTraceSession as the root object.
 ///
 /// See \a Trace::FindPlugin for more information regarding these JSON files.
 class TraceSessionFileParser {
 public:
-  /// C++ structs representing the JSON trace session.
-  /// \{
-  struct JSONAddress {
-    lldb::addr_t value;
-  };
-
-  struct JSONModule {
-    std::string system_path;
-    llvm::Optional<std::string> file;
-    JSONAddress load_address;
-    llvm::Optional<std::string> uuid;
-  };
-
-  struct JSONThread {
-    int64_t tid;
-    std::string trace_file;
-  };
-
-  struct JSONProcess {
-    int64_t pid;
-    std::string triple;
-    std::vector<JSONThread> threads;
-    std::vector<JSONModule> modules;
-  };
-
-  struct JSONTracePluginSettings {
-    std::string type;
-  };
-
-  struct JSONTraceSessionBase {
-    std::vector<JSONProcess> processes;
-  };
-
-  /// The trace plug-in implementation should provide its own TPluginSettings,
-  /// which corresponds to the "trace" section of the schema.
-  template <class TPluginSettings>
-  struct JSONTraceSession : JSONTraceSessionBase {
-    TPluginSettings trace;
-  };
-  /// \}
 
   /// Helper struct holding the objects created when parsing a process
   struct ParsedProcess {
     lldb::TargetSP target_sp;
     std::vector<lldb::ThreadPostMortemTraceSP> threads;
   };
 
   TraceSessionFileParser(Debugger &debugger, llvm::StringRef session_file_dir,
llvm::Error CreateJSONError(llvm::json::Path::Root &root,
                               const llvm::json::Value &value);
 
   Debugger &m_debugger;
   std::string m_session_file_dir;
   llvm::StringRef m_schema;
 };
 } // namespace lldb_private
 
-namespace llvm {
-namespace json {
-
-bool fromJSON(const Value &value,
-              lldb_private::TraceSessionFileParser::JSONAddress &address,
-              Path path);
-
-bool fromJSON(const Value &value,
-              lldb_private::TraceSessionFileParser::JSONModule &module,
-              Path path);
-
-bool fromJSON(const Value &value,
-              lldb_private::TraceSessionFileParser::JSONThread &thread,
-              Path path);
-
-bool fromJSON(const Value &value,
-              lldb_private::TraceSessionFileParser::JSONProcess &process,
-              Path path);
-
-bool fromJSON(const Value &value,
-              lldb_private::TraceSessionFileParser::JSONTracePluginSettings
-                  &plugin_settings,
-              Path path);
-
-bool fromJSON(
-    const Value &value,
-    lldb_private::TraceSessionFileParser::JSONTraceSessionBase &session,
-    Path path);
-
-template <class TPluginSettings>
-bool fromJSON(
-    const Value &value,
-    lldb_private::TraceSessionFileParser::JSONTraceSession<TPluginSettings>
-        &session,
-    Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("trace", session.trace) &&
-         fromJSON(value,
-                  (lldb_private::TraceSessionFileParser::JSONTraceSessionBase &)
-                      session,
-                  path);
-}
-
-} // namespace json
-} // namespace llvm
 
 #endif // LLDB_TARGET_TRACESESSIONPARSER_H

lldb/source/Plugins/Trace/common/TraceSessionFileParser.cpp

if (Expected<ParsedProcess> parsed_process = ParseProcess(process))
       parsed_processes.push_back(std::move(*parsed_process));
     else {
       onError();
       return parsed_process.takeError();
     }
   }
   return parsed_processes;
 }
-
-namespace llvm {
-namespace json {
-
-bool fromJSON(const Value &value, TraceSessionFileParser::JSONAddress &address,
-              Path path) {
-  Optional<StringRef> s = value.getAsString();
-  if (s.hasValue() && !s->getAsInteger(0, address.value))
-    return true;
-
-  path.report("expected numeric string");
-  return false;
-}
-
-bool fromJSON(const Value &value, TraceSessionFileParser::JSONModule &module,
-              Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("systemPath", module.system_path) &&
-         o.map("file", module.file) &&
-         o.map("loadAddress", module.load_address) &&
-         o.map("uuid", module.uuid);
-}
-
-bool fromJSON(const Value &value, TraceSessionFileParser::JSONThread &thread,
-              Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("tid", thread.tid) && o.map("traceFile", thread.trace_file);
-}
-
-bool fromJSON(const Value &value, TraceSessionFileParser::JSONProcess &process,
-              Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("pid", process.pid) && o.map("triple", process.triple) &&
-         o.map("threads", process.threads) && o.map("modules", process.modules);
-}
-
-bool fromJSON(const Value &value,
-              TraceSessionFileParser::JSONTracePluginSettings &plugin_settings,
-              Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("type", plugin_settings.type);
-}
-
-bool fromJSON(const Value &value,
-              TraceSessionFileParser::JSONTraceSessionBase &session,
-              Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("processes", session.processes);
-}
-
-} // namespace json
-} // namespace llvm

lldb/source/Plugins/Trace/common/TraceSessionSaver.h

+//===-- SessionSaver.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_TRACESESSIONSAVER_H
+#define LLDB_TARGET_TRACESESSIONSAVER_H
+
+#include "TraceJSONStructs.h"
+
+namespace lldb_private {
+
+class TraceSessionSaver {
+
+public:
+  /// Save the trace session description JSON object inside the given directory
+  /// as a file named \a trace.json.
+  ///
+  /// \param[in] trace_session_description
+  ///     The trace's session, as JSON Object.
+  ///
+  /// \param[in] directory
+  ///     The directory where the JSON file will be saved.
+  ///
+  /// \return
+  ///     \a llvm::success if the operation was successful, or an \a llvm::Error
+  ///     otherwise.
+  static llvm::Error
+  WriteSessionToFile(const llvm::json::Value &trace_session_description,
+                     FileSpec directory);
+
+  /// Build the processes section of the trace session description file. Besides
+  /// returning the processes information, this method saves to disk all modules
+  /// and raw traces corresponding to the traced threads of the given process.
+  ///
+  /// \param[in] live_process
+  ///     The process being traced.
+  ///
+  /// \param[in] raw_trace_fetcher
+  ///     Callback function that receives a thread ID and returns its raw trace.
+  ///     This callback should return \a None if the thread is not being traced.
+  ///     Otherwise, it should return the raw trace in bytes or an
+  ///     \a llvm::Error in case of failures.
+  ///
+  /// \param[in] directory
+  ///     The directory where files will be saved when building the processes
+  ///     section.
+  ///
+  /// \return
+  ///     The processes section or \a llvm::Error in case of failures.
+  static llvm::Expected<JSONTraceSessionBase> BuildProcessesSection(
+      Process &live_process,
+      std::function<
+          llvm::Expected<llvm::Optional<std::vector<uint8_t>>>(lldb::tid_t tid)>
+          raw_trace_fetcher,
+      FileSpec directory);
+
+  /// Build the threads sub-section of the trace session description file.
+  /// For each traced thread, its raw trace is also written to the file
+  /// \a thread_id_.trace inside of the given directory.
+  ///
+  /// \param[in] live_process
+  ///     The process being traced.
+  ///
+  /// \param[in] raw_trace_fetcher
+  ///     Callback function that receives a thread ID and returns its raw trace.
+  ///     This callback should return \a None if the thread is not being traced.
+  ///     Otherwise, it should return the raw trace in bytes or an
+  ///     \a llvm::Error in case of failures.
+  ///
+  /// \param[in] directory
+  ///     The directory where files will be saved when building the threads
+  ///     section.
+  ///
+  /// \return
+  ///     The threads section or \a llvm::Error in case of failures.
+  static llvm::Expected<std::vector<JSONThread>> BuildThreadsSection(
+      Process &live_process,
+      std::function<
+          llvm::Expected<llvm::Optional<std::vector<uint8_t>>>(lldb::tid_t tid)>
+          raw_trace_fetcher,
+      FileSpec directory);
+
+  /// Build modules sub-section of the trace's session. The original modules
+  /// will be copied over to the \a <directory/modules> folder. Invalid modules
+  /// are skipped.
+  /// Copying the modules has the benefit of making these trace session
+  /// directories self-contained, as the raw traces and modules are part of the
+  /// output directory and can be sent to another machine, where lldb can load
+  /// them and replicate exactly the same trace session.
+  ///
+  /// \param[in] live_process
+  ///     The process being traced.
+  ///
+  /// \param[in] directory
+  ///     The directory where the modules files will be saved when building
+  ///     the modules section.
+  ///     Example: If a module \a libbar.so exists in the path
+  ///     \a /usr/lib/foo/libbar.so, then it will be copied to
+  ///     \a <directory>/modules/usr/lib/foo/libbar.so.
+  ///
+  /// \return
+  ///     The modules section or \a llvm::Error in case of failures.
+  static llvm::Expected<std::vector<JSONModule>>
+  BuildModulesSection(Process &live_process, FileSpec directory);
+};
+} // namespace lldb_private
+
+#endif // LLDB_TARGET_TRACESESSIONSAVER_H

lldb/source/Plugins/Trace/common/TraceSessionSaver.cpp

+//===-- TraceSessionSaver.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 "TraceSessionSaver.h"
+
+#include "lldb/Core/Module.h"
+#include "lldb/Core/Value.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/SectionLoadList.h"
+#include "lldb/Target/Target.h"
+#include "lldb/lldb-types.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/JSON.h"
+
+#include <fstream>
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace llvm;
+
+llvm::Error TraceSessionSaver::WriteSessionToFile(
+    const llvm::json::Value &trace_session_description, FileSpec directory) {
+
+  FileSpec trace_path = directory;
+  trace_path.AppendPathComponent("trace.json");
+  std::ofstream os(trace_path.GetPath());
+  os << std::string(formatv("{0:2}", trace_session_description));
+  os.close();
+  if (!os)
+    return createStringError(inconvertibleErrorCode(),
+                             formatv("couldn't write to the file {0}",
+                                     trace_path.GetPath().c_str()));
+  return Error::success();
+}
+
+llvm::Expected<JSONTraceSessionBase> TraceSessionSaver::BuildProcessesSection(
+    Process &live_process,
+    std::function<
+        llvm::Expected<llvm::Optional<std::vector<uint8_t>>>(lldb::tid_t tid)>
+        raw_trace_fetcher,
+    FileSpec directory) {
+
+  JSONTraceSessionBase json_session_description;
+  Expected<std::vector<JSONThread>> json_threads =
+      BuildThreadsSection(live_process, raw_trace_fetcher, directory);
+  if (!json_threads)
+    return json_threads.takeError();
+
+  Expected<std::vector<JSONModule>> json_modules =
+      BuildModulesSection(live_process, directory);
+  if (!json_modules)
+    return json_modules.takeError();
+
+  json_session_description.processes.push_back(JSONProcess{
+      static_cast<int64_t>(live_process.GetID()),
+      live_process.GetTarget().GetArchitecture().GetTriple().getTriple(),
+      json_threads.get(), json_modules.get()});
+  return json_session_description;
+}
+
+llvm::Expected<std::vector<JSONThread>> TraceSessionSaver::BuildThreadsSection(
+    Process &live_process,
+    std::function<
+        llvm::Expected<llvm::Optional<std::vector<uint8_t>>>(lldb::tid_t tid)>
+        raw_trace_fetcher,
+    FileSpec directory) {
+  std::vector<JSONThread> json_threads;
+  for (ThreadSP thread_sp : live_process.Threads()) {
+    // resolve the directory just in case
+    FileSystem::Instance().Resolve(directory);
+    FileSpec raw_trace_path = directory;
+    raw_trace_path.AppendPathComponent(std::to_string(thread_sp->GetID()) +
+                                       ".trace");
+    json_threads.push_back(JSONThread{static_cast<int64_t>(thread_sp->GetID()),
+                                      raw_trace_path.GetPath().c_str()});
+
+    llvm::Expected<llvm::Optional<std::vector<uint8_t>>> raw_trace =
+        raw_trace_fetcher(thread_sp->GetID());
+
+    if (!raw_trace)
+      return raw_trace.takeError();
+    if (!raw_trace.get())
+      continue;
+
+    std::basic_fstream<char> raw_trace_fs = std::fstream(
+        raw_trace_path.GetPath().c_str(), std::ios::out | std::ios::binary);
+    raw_trace_fs.write(reinterpret_cast<const char *>(&raw_trace.get()->at(0)),
+                       raw_trace.get()->size() * sizeof(uint8_t));
+    raw_trace_fs.close();
+    if (!raw_trace_fs) {
+      return createStringError(inconvertibleErrorCode(),
+                               formatv("couldn't write to the file {0}",
+                                       raw_trace_path.GetPath().c_str()));
+    }
+  }
+  return json_threads;
+}
+
+llvm::Expected<std::vector<JSONModule>>
+TraceSessionSaver::BuildModulesSection(Process &live_process,
+                                       FileSpec directory) {
+  std::vector<JSONModule> json_modules;
+  ModuleList module_list = live_process.GetTarget().GetImages();
+  for (size_t i = 0; i < module_list.GetSize(); ++i) {
+    ModuleSP module_sp(module_list.GetModuleAtIndex(i));
+    if (!module_sp)
+      continue;
+    std::string system_path = module_sp->GetPlatformFileSpec().GetPath();
+    // TODO: support memory-only libraries like [vdso]
+    if (!module_sp->GetFileSpec().IsAbsolute())
+      continue;
+
+    std::string file = module_sp->GetFileSpec().GetPath();
+    ObjectFile *objfile = module_sp->GetObjectFile();
+    if (objfile == nullptr)
+      continue;
+
+    lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
+    Address base_addr(objfile->GetBaseAddress());
+    if (base_addr.IsValid() &&
+        !live_process.GetTarget().GetSectionLoadList().IsEmpty())
+      load_addr = base_addr.GetLoadAddress(&live_process.GetTarget());
+
+    if (load_addr == LLDB_INVALID_ADDRESS)
+      continue;
+
+    FileSystem::Instance().Resolve(directory);
+    FileSpec path_to_copy_module = directory;
+    path_to_copy_module.AppendPathComponent("modules");
+    path_to_copy_module.AppendPathComponent(system_path);
+    sys::fs::create_directories(path_to_copy_module.GetDirectory().AsCString());
+
+    if (std::error_code ec = llvm::sys::fs::copy_file(
+            system_path, path_to_copy_module.GetPath()))
+      return createStringError(
+          inconvertibleErrorCode(),
+          formatv("couldn't write to the file. {0}", ec.message()));
+
+    json_modules.push_back(
+        JSONModule{system_path, path_to_copy_module.GetPath(),
+                   JSONAddress{load_addr}, module_sp->GetUUID().GetAsString()});
+  }
+  return json_modules;
+}

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

lldb_tablegen(TraceIntelPTCommandOptions.inc -gen-lldb-option-defs
   TARGET TraceIntelPTOptionsGen)
 
 add_lldb_library(lldbPluginTraceIntelPT PLUGIN
   CommandObjectTraceStartIntelPT.cpp
   DecodedThread.cpp
   IntelPTDecoder.cpp
   TraceCursorIntelPT.cpp
   TraceIntelPT.cpp
+  TraceIntelPTJSONStructs.cpp
   TraceIntelPTSessionFileParser.cpp
+  TraceIntelPTSessionSaver.cpp
 
   LINK_LIBS
     lldbCore
     lldbSymbol
     lldbTarget
     lldbPluginTraceCommon
     ${LIBIPT_LIBRARY}
   LINK_COMPONENTS
     Support
   )
 
 
 add_dependencies(lldbPluginTraceIntelPT TraceIntelPTOptionsGen)

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

 //===-- TraceIntelPT.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_TRACEINTELPT_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPT_H
 
 #include "IntelPTDecoder.h"
 #include "TraceIntelPTSessionFileParser.h"
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/lldb-types.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
 class TraceIntelPT : public Trace {
 public:
   void Dump(Stream *s) const override;
 
+  llvm::Error SaveLiveTraceToDisk(FileSpec directory) override;
+
   ~TraceIntelPT() override = default;
 
   /// PluginInterface protocol
   /// \{
   ConstString GetPluginName() override;
 
   static void Initialize();
 
   static void Terminate();
 
public:
 
   void DumpTraceInfo(Thread &thread, Stream &s, bool verbose) override;
 
   llvm::Optional<size_t> GetRawTraceSize(Thread &thread);
 
   void DoRefreshLiveProcessState(
       llvm::Expected<TraceGetStateResponse> state) override;
 
-  bool IsTraced(const Thread &thread) override;
+  bool IsTraced(lldb::tid_t tid) override;
 
   const char *GetStartConfigurationHelp() override;
 
   /// Start tracing a live process.
   ///
   /// \param[in] thread_buffer_size
   ///     Trace size per thread in bytes.
   ///
llvm::Error Start(llvm::ArrayRef<lldb::tid_t> tids,
                     StructuredData::ObjectSP configuration =
                         StructuredData::ObjectSP()) override;
 
   /// Get the thread buffer content for a live thread
   llvm::Expected<std::vector<uint8_t>> GetLiveThreadBuffer(lldb::tid_t tid);
 
   llvm::Expected<pt_cpu> GetCPUInfo();
 
+  /// Get the current traced live process.
+  ///
+  /// \return
+  ///     The current traced live process. If it's not a live process,
+  ///     return \a nullptr.
+  Process *GetLiveProcess();
+
 private:
   friend class TraceIntelPTSessionFileParser;
 
   llvm::Expected<pt_cpu> GetCPUInfoForLiveProcess();
 
   /// \param[in] trace_threads
   ///     ThreadTrace instances, which are not live-processes and whose trace
   ///     files are fixed.
private:
   /// \return
   ///     A \a DecodedThread shared pointer with the decoded instructions. Any
   ///     errors are embedded in the instruction list.
   DecodedThreadSP Decode(Thread &thread);
 
   /// It is provided by either a session file or a live process' "cpuInfo"
   /// binary data.
   llvm::Optional<pt_cpu> m_cpu_info;
-  std::map<const Thread *, std::unique_ptr<ThreadDecoder>> m_thread_decoders;
+  std::map<lldb::tid_t, std::unique_ptr<ThreadDecoder>> m_thread_decoders;
   /// Error gotten after a failed live process update, if any.
   llvm::Optional<std::string> m_live_refresh_error;
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPT_H

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 "../common/ThreadPostMortemTrace.h"
 #include "CommandObjectTraceStartIntelPT.h"
 #include "DecodedThread.h"
 #include "TraceIntelPTConstants.h"
 #include "TraceIntelPTSessionFileParser.h"
+#include "TraceIntelPTSessionSaver.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
+#include "llvm/ADT/None.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
 LLDB_PLUGIN_DEFINE(TraceIntelPT)
 

 //------------------------------------------------------------------
 
 ConstString TraceIntelPT::GetPluginName() { return GetPluginNameStatic(); }
 
 uint32_t TraceIntelPT::GetPluginVersion() { return 1; }
 
 void TraceIntelPT::Dump(Stream *s) const {}
 
+llvm::Error TraceIntelPT::SaveLiveTraceToDisk(FileSpec directory) {
+  RefreshLiveProcessState();
+  return TraceIntelPTSessionSaver().SaveToDisk(*this, directory);
+}
+
 Expected<TraceSP> TraceIntelPT::CreateInstanceForSessionFile(
     const json::Value &trace_session_file, StringRef session_file_dir,
     Debugger &debugger) {
   return TraceIntelPTSessionFileParser(debugger, trace_session_file,
                                        session_file_dir)
       .Parse();
 }
 
 Expected<TraceSP> TraceIntelPT::CreateInstanceForLiveProcess(Process &process) {
   TraceSP instance(new TraceIntelPT(process));
   process.GetTarget().SetTrace(instance);
   return instance;
 }
 
 TraceIntelPT::TraceIntelPT(
     const pt_cpu &cpu_info,
     const std::vector<ThreadPostMortemTraceSP> &traced_threads)
     : m_cpu_info(cpu_info) {
   for (const ThreadPostMortemTraceSP &thread : traced_threads)
     m_thread_decoders.emplace(
-        thread.get(), std::make_unique<PostMortemThreadDecoder>(thread, *this));
+        thread->GetID(),
+        std::make_unique<PostMortemThreadDecoder>(thread, *this));
 }
 
 DecodedThreadSP TraceIntelPT::Decode(Thread &thread) {
   RefreshLiveProcessState();
   if (m_live_refresh_error.hasValue())
     return std::make_shared<DecodedThread>(
         thread.shared_from_this(),
         createStringError(inconvertibleErrorCode(), *m_live_refresh_error));
 
-  auto it = m_thread_decoders.find(&thread);
+  auto it = m_thread_decoders.find(thread.GetID());
   if (it == m_thread_decoders.end())
     return std::make_shared<DecodedThread>(
         thread.shared_from_this(),
         createStringError(inconvertibleErrorCode(), "thread not traced"));
   return it->second->Decode();
 }
 
 lldb::TraceCursorUP TraceIntelPT::GetCursor(Thread &thread) {
   return Decode(thread)->GetCursor();
 }
 
 void TraceIntelPT::DumpTraceInfo(Thread &thread, Stream &s, bool verbose) {
   Optional<size_t> raw_size = GetRawTraceSize(thread);
   s.Printf("\nthread #%u: tid = %" PRIu64, thread.GetIndexID(), thread.GetID());
   if (!raw_size) {
     s.Printf(", not traced\n");
     return;
   }
   s.Printf("\n  Raw trace size: %zu bytes\n", *raw_size);
   return;
 }
 
 Optional<size_t> TraceIntelPT::GetRawTraceSize(Thread &thread) {
-  if (IsTraced(thread))
+  if (IsTraced(thread.GetID()))
     return Decode(thread)->GetRawTraceSize();
   else
     return None;
 }
 
 Expected<pt_cpu> TraceIntelPT::GetCPUInfoForLiveProcess() {
   Expected<std::vector<uint8_t>> cpu_info = GetLiveProcessBinaryData("cpuInfo");
   if (!cpu_info)
if (!m_cpu_info) {
     if (llvm::Expected<pt_cpu> cpu_info = GetCPUInfoForLiveProcess())
       m_cpu_info = *cpu_info;
     else
       return cpu_info.takeError();
   }
   return *m_cpu_info;
 }
 
+Process *TraceIntelPT::GetLiveProcess() { return m_live_process; }
+
 void TraceIntelPT::DoRefreshLiveProcessState(
     Expected<TraceGetStateResponse> state) {
   m_thread_decoders.clear();
 
   if (!state) {
     m_live_refresh_error = toString(state.takeError());
     return;
   }
 
   for (const TraceThreadState &thread_state : state->tracedThreads) {
     Thread &thread =
         *m_live_process->GetThreadList().FindThreadByID(thread_state.tid);
     m_thread_decoders.emplace(
-        &thread, std::make_unique<LiveThreadDecoder>(thread, *this));
+        thread_state.tid, std::make_unique<LiveThreadDecoder>(thread, *this));
   }
 }
 
-bool TraceIntelPT::IsTraced(const Thread &thread) {
+bool TraceIntelPT::IsTraced(lldb::tid_t tid) {
   RefreshLiveProcessState();
-  return m_thread_decoders.count(&thread);
+  return m_thread_decoders.count(tid);
 }
 
 // The information here should match the description of the intel-pt section
 // of the jLLDBTraceStart packet in the lldb/docs/lldb-gdb-remote.txt
 // documentation file. Similarly, it should match the CLI help messages of the
 // TraceIntelPTOptions.td file.
 const char *TraceIntelPT::GetStartConfigurationHelp() {
   return R"(Parameters:

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

+//===-- TraceIntelPTJSONStructs.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_TRACEINTELPTJSONSTRUCTS_H
+#define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTJSONSTRUCTS_H
+
+#include "../common/TraceJSONStructs.h"
+#include <intel-pt.h>
+
+namespace lldb_private {
+namespace trace_intel_pt {
+
+struct JSONTraceIntelPTCPUInfo {
+  JSONTraceIntelPTCPUInfo() = default;
+
+  JSONTraceIntelPTCPUInfo(pt_cpu cpu_info) {
+    family = static_cast<int64_t>(cpu_info.family);
+    model = static_cast<int64_t>(cpu_info.model);
+    stepping = static_cast<int64_t>(cpu_info.stepping);
+    vendor = cpu_info.vendor == pcv_intel ? "intel" : "Unknown";
+  }
+
+  int64_t family;
+  int64_t model;
+  int64_t stepping;
+  std::string vendor;
+};
+
+struct JSONTraceIntelPTTrace {
+  std::string type;
+  JSONTraceIntelPTCPUInfo cpuInfo;
+};
+
+struct JSONTraceIntelPTSession {
+  JSONTraceIntelPTTrace ipt_trace;
+  JSONTraceSessionBase session_base;
+};
+
+struct JSONTraceIntelPTSettings : JSONTracePluginSettings {
+  JSONTraceIntelPTCPUInfo cpuInfo;
+};
+
+} // namespace trace_intel_pt
+} // namespace lldb_private
+
+namespace llvm {
+namespace json {
+
+bool fromJSON(
+    const Value &value,
+    lldb_private::trace_intel_pt::JSONTraceIntelPTSettings &plugin_settings,
+    Path path);
+
+bool fromJSON(const llvm::json::Value &value,
+              lldb_private::trace_intel_pt::JSONTraceIntelPTCPUInfo &packet,
+              llvm::json::Path path);
+
+llvm::json::Value
+toJSON(const lldb_private::trace_intel_pt::JSONTraceIntelPTCPUInfo &cpu_info);
+
+llvm::json::Value
+toJSON(const lldb_private::trace_intel_pt::JSONTraceIntelPTTrace &trace);
+
+llvm::json::Value
+toJSON(const lldb_private::trace_intel_pt::JSONTraceIntelPTSession &session);
+
+} // namespace json
+} // namespace llvm
+
+#endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTJSONSTRUCTS_H

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

+//===-- TraceIntelPTJSONStructs.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 "TraceIntelPTJSONStructs.h"
+
+#include "llvm/Support/JSON.h"
+#include <string>
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::trace_intel_pt;
+using namespace llvm;
+
+namespace llvm {
+namespace json {
+
+bool fromJSON(const Value &value, JSONTraceIntelPTSettings &plugin_settings,
+              Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("cpuInfo", plugin_settings.cpuInfo) &&
+         fromJSON(value, (JSONTracePluginSettings &)plugin_settings, path);
+}
+
+bool fromJSON(const json::Value &value, JSONTraceIntelPTCPUInfo &cpu_info,
+              Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("vendor", cpu_info.vendor) &&
+         o.map("family", cpu_info.family) && o.map("model", cpu_info.model) &&
+         o.map("stepping", cpu_info.stepping);
+}
+
+Value toJSON(const JSONTraceIntelPTCPUInfo &cpu_info) {
+  return Value(Object{{"family", cpu_info.family},
+                      {"model", cpu_info.model},
+                      {"stepping", cpu_info.stepping},
+                      {"vendor", cpu_info.vendor}});
+}
+
+llvm::json::Value toJSON(const JSONTraceIntelPTTrace &trace) {
+  llvm::json::Object json_trace;
+  json_trace["type"] = trace.type;
+  json_trace["cpuInfo"] = toJSON(trace.cpuInfo);
+  return std::move(json_trace);
+}
+
+llvm::json::Value toJSON(const JSONTraceIntelPTSession &session) {
+  llvm::json::Object json_session;
+  json_session["trace"] = toJSON(session.ipt_trace);
+  json_session["processes"] = toJSON(session.session_base);
+  return std::move(json_session);
+}
+
+} // namespace json
+} // namespace llvm

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

Desc<"This value defines the period in which PSB packets will be "
          "values for this period can be found in "
          "/sys/bus/event_source/devices/intel_pt/caps/psb_periods which "
          "contains a hexadecimal number, whose bits represent valid values "
          "e.g. if bit 2 is set, then value 2 is valid. The psb_period value is "
          "converted to the approximate number of raw trace bytes between PSB "
          "packets as: 2 ^ (value + 11), e.g. value 3 means 16KiB between PSB "
          "packets. Defaults to 0 if supported.">;
 }
+
+let Command = "process trace save intel pt" in {
+  def process_trace_save_intel_directory: Option<"directory", "d">,
+    Group<1>,
+    Arg<"Value">, Required,
+    Desc<"This value defines the directory where the trace will be saved."
+        "It will be created if it does not exist. It will also create a "
+        "trace files with the trace data and a trace.json with the main "
+        "properties of the trace session.">;
+}

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

 //===-- TraceIntelPTSessionFileParser.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_TRACEINTELPTSESSIONFILEPARSER_H
 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONFILEPARSER_H
 
-#include "TraceIntelPT.h"
-
 #include "../common/TraceSessionFileParser.h"
+#include "TraceIntelPT.h"
+#include "TraceIntelPTJSONStructs.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
 
 class TraceIntelPT;
 
 class TraceIntelPTSessionFileParser : public TraceSessionFileParser {
 public:
-  struct JSONTraceIntelPTCPUInfo {
-    int64_t family;
-    int64_t model;
-    int64_t stepping;
-    std::string vendor;
-  };
-
-  struct JSONTraceIntelPTSettings
-      : TraceSessionFileParser::JSONTracePluginSettings {
-    JSONTraceIntelPTCPUInfo cpuInfo;
-  };
 
   /// See \a TraceSessionFileParser::TraceSessionFileParser for the description
   /// of these fields.
   TraceIntelPTSessionFileParser(Debugger &debugger,
                                 const llvm::json::Value &trace_session_file,
                                 llvm::StringRef session_file_dir)
       : TraceSessionFileParser(debugger, session_file_dir, GetSchema()),
         m_trace_session_file(trace_session_file) {}
private:
   static pt_cpu ParsePTCPU(const JSONTraceIntelPTCPUInfo &cpu_info);
 
   const llvm::json::Value &m_trace_session_file;
 };
 
 } // namespace trace_intel_pt
 } // namespace lldb_private
 
-namespace llvm {
-namespace json {
-
-bool fromJSON(const Value &value,
-              lldb_private::trace_intel_pt::TraceIntelPTSessionFileParser::
-                  JSONTraceIntelPTSettings &plugin_settings,
-              Path path);
-
-bool fromJSON(const llvm::json::Value &value,
-              lldb_private::trace_intel_pt::TraceIntelPTSessionFileParser::
-                  JSONTraceIntelPTCPUInfo &packet,
-              llvm::json::Path path);
-
-llvm::json::Value
-toJSON(const lldb_private::trace_intel_pt::TraceIntelPTSessionFileParser::
-           JSONTraceIntelPTCPUInfo &packet);
-
-} // namespace json
-} // namespace llvm
 
 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONFILEPARSER_H

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

 //===-- TraceIntelPTSessionFileParser.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 "TraceIntelPTSessionFileParser.h"
 
 #include "../common/ThreadPostMortemTrace.h"
-#include "lldb/Core/Debugger.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Target/Target.h"
-#include "lldb/Target/ThreadList.h"
+#include "TraceIntelPT.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
 StringRef TraceIntelPTSessionFileParser::GetSchema() {
   static std::string schema;
TraceSP TraceIntelPTSessionFileParser::CreateTraceIntelPTInstance(
   for (const ParsedProcess &parsed_process : parsed_processes)
     parsed_process.target_sp->SetTrace(trace_instance);
 
   return trace_instance;
 }
 
 Expected<TraceSP> TraceIntelPTSessionFileParser::Parse() {
   json::Path::Root root("traceSession");
-  TraceSessionFileParser::JSONTraceSession<JSONTraceIntelPTSettings> session;
+  JSONTraceSession<JSONTraceIntelPTSettings> session;
   if (!json::fromJSON(m_trace_session_file, session, root))
     return CreateJSONError(root, m_trace_session_file);
 
   if (Expected<std::vector<ParsedProcess>> parsed_processes =
           ParseCommonSessionFile(session))
     return CreateTraceIntelPTInstance(ParsePTCPU(session.trace.cpuInfo),
                                       *parsed_processes);
   else
     return parsed_processes.takeError();
 }
-
-namespace llvm {
-namespace json {
-
-bool fromJSON(
-    const Value &value,
-    TraceIntelPTSessionFileParser::JSONTraceIntelPTSettings &plugin_settings,
-    Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("cpuInfo", plugin_settings.cpuInfo) &&
-         fromJSON(
-             value,
-             (TraceSessionFileParser::JSONTracePluginSettings &)plugin_settings,
-             path);
-}
-
-bool fromJSON(const json::Value &value,
-              TraceIntelPTSessionFileParser::JSONTraceIntelPTCPUInfo &cpu_info,
-              Path path) {
-  ObjectMapper o(value, path);
-  return o && o.map("vendor", cpu_info.vendor) &&
-         o.map("family", cpu_info.family) && o.map("model", cpu_info.model) &&
-         o.map("stepping", cpu_info.stepping);
-}
-
-Value toJSON(
-    const TraceIntelPTSessionFileParser::JSONTraceIntelPTCPUInfo &cpu_info) {
-  return Value(Object{{"family", cpu_info.family},
-                      {"model", cpu_info.model},
-                      {"stepping", cpu_info.stepping},
-                      {"vendor", cpu_info.vendor}});
-}
-
-} // namespace json
-} // namespace llvm

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

+//===-- TraceIntelPTSessionSaver.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_TRACEINTELPTSESSIONSAVER_H
+#define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONSAVER_H
+
+#include "TraceIntelPT.h"
+
+#include "../common/TraceJSONStructs.h"
+
+namespace lldb_private {
+namespace trace_intel_pt {
+
+class TraceIntelPT;
+
+class TraceIntelPTSessionSaver {
+
+public:
+  /// Save the Intel PT trace of a live process to the specified directory,
+  /// which will be created if needed. This will also create a file
+  /// \a <directory>/trace.json with the main properties of the trace
+  /// session, along with others files which contain the actual trace data.
+  /// The trace.json file can be used later as input for the "trace load"
+  /// command to load the trace in LLDB.
+  ///
+  /// \param[in] trace_ipt
+  ///     The Intel PT trace to be saved to disk.
+  ///
+  /// \param[in] directory
+  ///     The directory where the trace files will be saved.
+  ///
+  /// \return
+  ///     \a llvm::success if the operation was successful, or an \a llvm::Error
+  ///     otherwise.
+  llvm::Error SaveToDisk(TraceIntelPT &trace_ipt, FileSpec directory);
+
+private:
+  /// Build trace section of the intel-pt trace session description file.
+  ///
+  /// \param[in] trace_ipt
+  ///     The Intel PT trace.
+  ///
+  /// \return
+  ///     The trace section  an \a llvm::Error in case of failures.
+  llvm::Expected<JSONTraceIntelPTTrace>
+  BuildTraceSection(TraceIntelPT &trace_ipt);
+};
+
+} // namespace trace_intel_pt
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPTSESSIONSAVER_H

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

+//===-- TraceIntelPTSessionSaver.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 "TraceIntelPTSessionSaver.h"
+#include "../common/TraceSessionSaver.h"
+#include "TraceIntelPT.h"
+#include "TraceIntelPTJSONStructs.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleList.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/SectionLoadList.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/ThreadList.h"
+#include "lldb/lldb-types.h"
+#include "llvm/ADT/None.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/JSON.h"
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::trace_intel_pt;
+using namespace llvm;
+
+llvm::Error TraceIntelPTSessionSaver::SaveToDisk(TraceIntelPT &trace_ipt,
+                                                 FileSpec directory) {
+  Process *live_process = trace_ipt.GetLiveProcess();
+  if (live_process == nullptr)
+    return createStringError(inconvertibleErrorCode(),
+                             "Saving a trace requires a live process.");
+
+  if (std::error_code ec =
+          sys::fs::create_directories(directory.GetPath().c_str()))
+    return llvm::errorCodeToError(ec);
+
+  llvm::Expected<JSONTraceIntelPTTrace> json_intel_pt_trace =
+      BuildTraceSection(trace_ipt);
+  if (!json_intel_pt_trace)
+    return json_intel_pt_trace.takeError();
+
+  llvm::Expected<JSONTraceSessionBase> json_session_description =
+      TraceSessionSaver::BuildProcessesSection(
+          *live_process,
+          [&](lldb::tid_t tid)
+              -> llvm::Expected<llvm::Optional<std::vector<uint8_t>>> {
+            if (!trace_ipt.IsTraced(tid))
+              return None;
+            return trace_ipt.GetLiveThreadBuffer(tid);
+          },
+          directory);
+
+  if (!json_session_description)
+    return json_session_description.takeError();
+
+  JSONTraceIntelPTSession json_intel_pt_session{json_intel_pt_trace.get(),
+                                                json_session_description.get()};
+
+  return TraceSessionSaver::WriteSessionToFile(
+      llvm::json::toJSON(json_intel_pt_session), directory);
+}
+
+llvm::Expected<JSONTraceIntelPTTrace>
+TraceIntelPTSessionSaver::BuildTraceSection(TraceIntelPT &trace_ipt) {
+  llvm::Expected<pt_cpu> cpu_info = trace_ipt.GetCPUInfo();
+  if (!cpu_info)
+    return cpu_info.takeError();
+
+  return JSONTraceIntelPTTrace{"intel-pt",
+                               JSONTraceIntelPTCPUInfo(cpu_info.get())};
+}

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

+import lldb
+from intelpt_testcase import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+from lldbsuite.test.decorators import *
+
+class TestTraceSave(TraceIntelPTTestCaseBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    def testErrorMessages(self):
+        # We first check the output when there are no targets
+        self.expect("process trace save",
+            substrs=["error: invalid target, create a target using the 'target create' command"],
+            error=True)
+
+        # We now check the output when there's a non-running target
+        self.expect("target create " +
+            os.path.join(self.getSourceDir(), "intelpt-trace", "a.out"))
+
+        self.expect("process trace save",
+            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("process trace save",
+            substrs=["error: Process is not being traced"],
+            error=True)
+
+    def testSaveToInvalidDir(self):
+        self.expect("target create " +
+            os.path.join(self.getSourceDir(), "intelpt-trace", "a.out"))
+        self.expect("b main")
+        self.expect("r")
+        self.expect("thread trace start")
+        self.expect("n")
+
+        # Check the output when saving without providing the directory argument
+        self.expect("process trace save -d",
+            substrs=["error: last option requires an argument"],
+            error=True)
+
+        # Check the output when saving to an invalid directory
+        self.expect("process trace save -d /",
+            substrs=["error: couldn't write to the file"],
+            error=True)
+
+    def testSaveWhenNotLiveTrace(self):
+        self.expect("trace load -v " +
+            os.path.join(self.getSourceDir(), "intelpt-trace", "trace.json"),
+            substrs=["intel-pt"])
+
+        # Check the output when not doing live tracing
+        self.expect("process trace save -d " +
+            os.path.join(self.getBuildDir(), "intelpt-trace", "trace_not_live_dir"),
+            substrs=["error: Saving a trace requires a live process."],
+            error=True)
+
+
+    def testSaveTrace(self):
+        self.expect("target create " +
+            os.path.join(self.getSourceDir(), "intelpt-trace", "a.out"))
+        self.expect("b main")
+        self.expect("r")
+        self.expect("thread trace start")
+        self.expect("b 7")
+
+        ci = self.dbg.GetCommandInterpreter()
+        res = lldb.SBCommandReturnObject()
+
+        ci.HandleCommand("thread trace dump instructions -c 10 --forwards", res)
+        self.assertEqual(res.Succeeded(), True)
+        first_ten_instructions = res.GetOutput()
+
+        ci.HandleCommand("thread trace dump instructions -c 10", res)
+        self.assertEqual(res.Succeeded(), True)
+        last_ten_instructions = res.GetOutput()
+
+        # Now, save the trace to <trace_copy_dir>
+        self.expect("process trace save -d " +
+            os.path.join(self.getBuildDir(), "intelpt-trace", "trace_copy_dir"))
+
+        # Load the trace just saved
+        self.expect("trace load -v " +
+            os.path.join(self.getBuildDir(), "intelpt-trace", "trace_copy_dir", "trace.json"),
+            substrs=["intel-pt"])
+
+        # Compare with instructions saved at the first time
+        ci.HandleCommand("thread trace dump instructions -c 10 --forwards", res)
+        self.assertEqual(res.Succeeded(), True)
+        self.assertEqual(res.GetOutput(), first_ten_instructions)
+
+        ci.HandleCommand("thread trace dump instructions -c 10", res)
+        self.assertEqual(res.Succeeded(), True)
+        self.assertEqual(res.GetOutput(), last_ten_instructions)