[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

1687–1693

1708

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

178

The id of the thread in question

lldb/source/Commands/Options.td

739

remove this line

748

remove this line

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

28–29

merge into one single line

45–47

delete braces

51–53

same here

61–63

ditto

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

28–33

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

42–46

same here, just delete these lines

52–57

similarly, delete these

69–72

delete

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

27

trace_session_description

34

move line 30 here to avoid that unnecessary out variable

50

json_session_description

58–60

delete braces

77

rename this to json_threads

86

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

94–96

delete braces

114

json_modules

122–124

delete braces

127–129

delete braces

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

19

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

22

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

31

delete this line

33

trace_session_description_json

36

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.

42–45

49

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

51–53

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

53

delete

61

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

62–63

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

69–72

copy the comment from above

75–76

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

78–79

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.

80

delete

89

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

92

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.

106–108

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

75

Saving a trace requires...

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

35–38

delete

45–49

delete

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

60–61

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

31–33

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

40–54

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

43

delete

55

delete

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

38–46

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

75

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

 //===-- 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 <unordered_map>
 
 #include "llvm/Support/JSON.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
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
+  /// \param[in] tid
   ///     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 "

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 {
+
+/// C++ structs representing the JSON trace session.
+/// \{
+struct JSONAddress {
+  JSONAddress() = default;
+
+  JSONAddress(lldb::addr_t value) : value(value){};
+
+  lldb::addr_t value;
+};
+
+struct JSONModule {
+  JSONModule() = default;
+
+  JSONModule(std::string system_path, llvm::Optional<std::string> file,
+             JSONAddress load_address, llvm::Optional<std::string> uuid)
+      : system_path(system_path), file(file), load_address(load_address),
+        uuid(uuid) {}
+
+  std::string system_path;
+  llvm::Optional<std::string> file;
+  JSONAddress load_address;
+  llvm::Optional<std::string> uuid;
+};
+
+struct JSONThread {
+  JSONThread() = default;
+
+  JSONThread(int64_t tid, std::string trace_file)
+      : tid(tid), trace_file(trace_file) {}
+
+  int64_t tid;
+  std::string trace_file;
+};
+
+struct JSONProcess {
+  JSONProcess() = default;
+
+  JSONProcess(int64_t pid, std::string triple, std::vector<JSONThread> threads,
+              std::vector<JSONModule> modules)
+      : pid(pid), triple(triple), threads(threads), modules(modules) {}
+
+  int64_t pid;
+  std::string triple;
+  std::vector<JSONThread> threads;
+  std::vector<JSONModule> modules;
+};
+
+struct JSONTracePluginSettings {
+  std::string type;
+};
+
+struct JSONTraceSessionBase {
+  JSONTraceSessionBase() = default;
+
+  JSONTraceSessionBase(std::vector<JSONProcess> processes)
+      : processes(processes) {}
+  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 result;
+  result["systemPath"] = module.system_path;
+  if (module.file)
+    result["file"] = *module.file;
+  std::ostringstream oss;
+  oss << "0x" << std::hex << module.load_address.value;
+  std::string str(oss.str());
+  result["loadAddress"] = str;
+  if (module.uuid)
+    result["uuid"] = *module.uuid;
+  return std::move(result);
+}
+
+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 result;
+  result["pid"] = process.pid;
+  result["triple"] = process.triple;
+
+  llvm::json::Array threads_arr;
+  for (JSONThread e : process.threads) {
+    threads_arr.push_back(toJSON(e));
+  }
+  result["threads"] = llvm::json::Value(std::move(threads_arr));
+
+  llvm::json::Array modules_arr;
+  for (JSONModule e : process.modules) {
+    modules_arr.push_back(toJSON(e));
+  }
+  result["modules"] = llvm::json::Value(std::move(modules_arr));
+
+  return std::move(result);
+}
+
+llvm::json::Value toJSON(const JSONTraceSessionBase &session_base) {
+  llvm::json::Array arr;
+  for (JSONProcess e : session_base.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's session to a given directory as a JSON file.
+  /// The filename is \a <directory>/trace.json
+  ///
+  /// \param[in] trace_session_jo
+  ///     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_jo,
+                     FileSpec directory);
+
+  /// Build processes section of the trace's session.
+  ///
+  /// \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.
+  ///     return raw trace in bytes if the operation was successful.
+  ///     return an \a llvm::Error if failed at getting raw trace.
+  ///     return \a None if raw trace got is INVALID.
+  ///
+  /// \param[in] directory
+  ///     The directory where the thread files will be saved when building
+  ///     processes section.
+  ///
+  /// \return The processes section to be built. Or an error if we can't build
+  ///     processes section.
+  ///
+  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 threads sub-section inside processes section of the trace's session.
+  /// The raw trace for a thread is written to a file with filename
+  /// \a <directory>/thread_id.trace.
+  ///
+  /// \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.
+  ///     return raw trace in bytes if the operation was successful.
+  ///     return an \a llvm::Error if failed at getting raw trace.
+  ///     return \a None if raw trace got is INVALID.
+  ///
+  /// \param[in] directory
+  ///     The directory where the thread files will be saved when building
+  ///     the threads section.
+  ///
+  /// \return The threads section to be built. Or an error if we can't build
+  ///     threads sections.
+  ///
+  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 inside processes section of the trace's session.
+/// The original modules will be copied over to the \a <directory/modules>
+/// folder. Invalid modules are skipped.
+/// Saving modules have the benifits of making trace saving more
+/// self-contained, as both trace and modules can now be saved on one machine,
+/// then sent over and loaded on another machine.
+///
+/// \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 to be built. Or an error if we can't build
+///     modules section.
+///
+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_jo,
+                                      FileSpec directory) {
+
+  std::string out = formatv("{0:2}", trace_session_jo);
+  FileSpec trace_path = directory;
+  trace_path.AppendPathComponent("trace.json");
+  std::ofstream os(trace_path.GetPath());
+  os << out;
+  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 result;
+  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();
+  }
+
+  JSONProcess json_process(
+      live_process.GetID(),
+      live_process.GetTarget().GetArchitecture().GetTriple().getTriple(),
+      json_threads.get(), json_modules.get());
+
+  result.processes.push_back(json_process);
+  return result;
+}
+
+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> result;
+  for (ThreadSP thread_sp : live_process.Threads()) {
+    JSONThread json_thread;
+    json_thread.tid = thread_sp->GetID();
+    // 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_thread.trace_file = raw_trace_path.GetPath().c_str();
+    result.push_back(json_thread);
+
+    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(json_thread.trace_file, 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}", json_thread.trace_file));
+    }
+  }
+  return result;
+}
+
+llvm::Expected<std::vector<JSONModule>>
+TraceSessionSaver::BuildModulesSection(Process &live_process,
+                                       FileSpec directory) {
+  std::vector<JSONModule> result;
+  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()));
+
+    JSONAddress load_address(load_addr);
+    JSONModule json_module(system_path, path_to_copy_module.GetPath(),
+                           load_address, module_sp->GetUUID().GetAsString());
+    result.push_back(json_module);
+  }
+  return result;
+}

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.
   ///
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();
+  if (!m_live_process)
+    return createStringError(inconvertibleErrorCode(),
+                             "Saving live trace requires a live process.");
+
+  return TraceIntelPTSessionSaver().SaveToDisk(*m_live_process, *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 (!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 {
+  JSONTraceIntelPTTrace() = default;
+
+  JSONTraceIntelPTTrace(std::string type, JSONTraceIntelPTCPUInfo cpuInfo)
+      : type(type), cpuInfo(cpuInfo) {}
+
+  std::string type;
+  JSONTraceIntelPTCPUInfo cpuInfo;
+};
+
+struct JSONTraceIntelPTSession {
+  JSONTraceIntelPTSession() = default;
+
+  JSONTraceIntelPTSession(JSONTraceIntelPTTrace ipt_trace,
+                          JSONTraceSessionBase session_base)
+      : ipt_trace(ipt_trace), session_base(session_base) {}
+
+  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 result;
+  result["type"] = trace.type;
+  result["cpuInfo"] = toJSON(trace.cpuInfo);
+  return std::move(result);
+}
+
+llvm::json::Value toJSON(const JSONTraceIntelPTSession &session) {
+  llvm::json::Object result;
+  result["trace"] = toJSON(session.ipt_trace);
+  result["processes"] = toJSON(session.session_base);
+  return std::move(result);
+}
+
+} // 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 given live process to the specified
+  /// directory, which 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.
+  ///
+  /// \param[in] live_process
+  ///     The process whose trace will be saved to disk.
+  ///
+  /// \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(Process &live_process, TraceIntelPT &trace_ipt,
+                         FileSpec directory);
+
+private:
+  /// Build trace section of the intel-pt tracing session.
+  ///
+  /// \param[in] trace_ipt
+  ///     The Intel PT trace.
+  ///
+  /// \return The trace section to be built. Or an error if we can't build
+  ///     trace section.
+  ///
+  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(Process &live_process,
+                                                 TraceIntelPT &trace_ipt,
+                                                 FileSpec directory) {
+  if (std::error_code ec =
+          sys::fs::create_directories(directory.GetPath().c_str()))
+    return llvm::errorCodeToError(ec);
+
+  llvm::Expected<JSONTraceIntelPTTrace> json_trace_intel_pt_trace =
+      BuildTraceSection(trace_ipt);
+  if (!json_trace_intel_pt_trace)
+    return json_trace_intel_pt_trace.takeError();
+
+  llvm::Expected<JSONTraceSessionBase> json_trace_session_base =
+      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_trace_session_base)
+    return json_trace_session_base.takeError();
+
+  JSONTraceIntelPTSession json_trace_intel_pt_session(
+      json_trace_intel_pt_trace.get(), json_trace_session_base.get());
+
+  llvm::json::Value intel_pt_session_jo =
+      llvm::json::toJSON(json_trace_intel_pt_session);
+  return TraceSessionSaver::WriteSessionToFile(intel_pt_session_jo, 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();
+
+  JSONTraceIntelPTCPUInfo json_trace_intel_pt_cpu_info(cpu_info.get());
+
+  JSONTraceIntelPTTrace result("intel-pt", json_trace_intel_pt_cpu_info);
+  return result;
+}

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 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("n")
+        self.expect("n")
+        self.expect("n")
+        self.expect("n")
+        self.expect("n")
+        self.expect("n")
+        self.expect("n")
+        self.expect("n")
+        self.expect("n")
+
+        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()
+
+        # 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)