[intel pt] Refactor parsing

[wallace]

Summary

With the feedback I was getting in different diffs and RFC discussion, I realized that splitting the parsing logic into two classes was not easy to deal with. I do see value in doing that, but I'd rather leave that as a refactor after most of the intel-pt logic is in place. Thus, I'm merging the common parser into the intel pt one, having thus only one that is fully aware of Intel PT during parsing and object creation.

Additionally, now the parser is used to create a Trace instance as output, as @labath suggested, and I was able to remove methods like GetParser(). This makes the code more modular.

Besides, based on the feedback in https://reviews.llvm.org/D88769, I'm creating a ThreadIntelPT class that will be able to orchestrate decoding of its own trace and can handle the stop events correctly.

This leaves the TraceIntelPT class as an initialization class that glues together different components. Right now it can initialize a trace session from a json file, and in the future will be able to initialize a trace session from a live process.

Besides, I'm renaming SettingsParser to SessionParser, which I think is a better name, as the json object represents a trace session of possibly many processes.

With the current set of targets, we have the following

• Trace: main interface for dealing with trace sessions
• TraceIntelPT: plugin Trace for dealing with intel pt sessions
• TraceIntelPTSessionParser: a parser of a json trace session file that can create a corresponding TraceIntelPT instance along with Targets, ProcessTraces (to be created in https://reviews.llvm.org/D88769), and ThreadIntelPT threads.
• ProcessTrace: (to be created in https://reviews.llvm.org/D88769) can handle the correct state of the traces as the user traverses the trace. I don't think there'll be a need an intel-pt specific implementation of this class.
• ThreadIntelPT: a thread implementation that can handle the decoding of its own trace file, along with keeping track of the current position the user is looking at when doing reverse debugging.

[clayborg]

lldb/include/lldb/Target/Trace.h

77–80

Is this the top level object from the JSON file? I think the old name of "settings" was better?

95–96

Maybe some more comments here saying something about the fact that there are common settings required by all plug-ins and where to find this info, and also where this plug-in specific schema must appear within the JSON trace file? Maybe also mention that each trace plug-in can defined their own needed settings and that this information will appear in "bla bla" command if you type it so you can see the information required by each plug-in?

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

52

Can we have different "pt_cpu" values for each thread? Or are we just storing this here because we don't control the Process class that we will use when doing IntelPT when we have a live process? Do we need this in the thread? Could we not just fetch the trace from the target and cast it to TraceIntelPT and call an accessor if we need the pt_cpu?

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

43

I still think "settings" is a better word for this argument.

61

"const llvm::json::Value &" instead of a pointer? This can't ever be NULL and it would be nice to not each plug-in think it might need to check for NULL?

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

31–50 ↗

(On Diff #296240)

This common information should still be parsed by code in Trace.cpp.

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

21–42 ↗

(On Diff #296240)

Seems like we should still parse this in Trace.cpp. Any common information shouldn't be duplicated or represented differently in different trace plug-ins IMHO.

lldb/source/Target/Trace.cpp

58–60

Why have the create_callback take an of these arguments if they are always null?

[labath]

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

21

just =default, or even don't declare it all (as explained in the other thread, these declarations are completely redundant).

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

10–11

Yep, all our header guards have been renamed now. Please don't reintroduce the old style.

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

167 ↗

(On Diff #296240)

std::make_shared

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

21–59 ↗

(On Diff #296240)

How much of this stuff needs to be in the header? If parsing happens completely within this class, I'd expect that these classes (and the relevant fromJSON methods) could be in the cpp file (in an anon namespace).

lldb/source/Target/Trace.cpp

58–60

It seems this is used to implement "trace schema". I think that a better way to implement this functionality would be to have each plugin pass its schema (as a string) when it registers itself (in TraceXXX::Initialize`). Then we can have an entry point like StringRef Trace::GetSchema(StringRef plugin_name) which will return that, and there won't be a need to create a polymorphic object just for the sake of calling it GetSchema on it (you can still have one if you need to get the schema for an existing object for any reason).

[wallace]

Address issues based on this diff's comments and from conversations with Greg.

• I'm still keeping the TraceSessionFile name instead of TraceSettings, as later there'll be actual trace settings (e.g. size of an Intel PT trace buffer, whether to trace in a ring or non-ring buffer, etc.).
• As Greg asked, I'm bringing back the top-level TraceSessionFileParser class, which each plug-in should override to perform parsing. This time the implementation is much cleaner and the implementation class can decide what to reuse from the base class. This will help ensuring that all Trace plug-ins consistently use the same common schema and parsing logic.
• I moved the fromJSON implementations to cpp files.
• Improved comments overall.
• Now, as Pavel suggested, I'm storing the schema in the PluginInstance, which allows fetching schemas without needing to instantiate any class. With this I was able able to simplify and remove several constructors.
• Fixed the header guards
• Some small fixes here are there, following the comments in the diff.

[labath]

I like this. A lot of comments, but they're all cosmetic.

lldb/include/lldb/Target/Trace.h

96–97

delete completely. As this is an abstract class, making the constructor protected does not do anything.

lldb/include/lldb/Target/TraceSessionFileParser.h

10

I think it wants this to be LLDB_TARGET_TRACESESSIONPARSER_H

108

delete. "using namespace" in a header file is a big no-no.

110

delete inline

lldb/source/Commands/CommandObjectTrace.cpp

279

error = schemaOrErr.takeError()

lldb/source/Core/PluginManager.cpp

1044

Return StringRef

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

24–26

no braces on simple if bodies

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

15

btw, (most of) new plugins tend to place themselves in a sub-namespace of lldb_private. That avoids prefixing everything with lldb_private::

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

25

drop data() and have this function take a StringRef ?

51

This could probably also return an Expected<TraceSP>

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

64

const auto &, or potentially even const TargetSP & due to this.

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

19

You're using namespace llvm, but then still prefixing a lot of the stuff with llvm::. Is that because llvm::json:: is a mouthful? namespace json = llvm::json, maybe?

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

81

This demonstrates why the previous "using namespace" is so bad. Now the entirety of lldb is accessible from within the llvm::json namespace. :D

lldb/source/Target/TraceSessionFileParser.cpp

99

End this with a newline ?

[clayborg]

lldb/include/lldb/Core/PluginManager.h

342

This is fine if we have a case where we want the scheme for a given plug-in. We should probably also add a call that takes a "size_t index" as an argument that is the index of the plug-ins. When the index is too big, returns NULL. This will allow us to iterate over all of the installed plug-ins and print out the schemas for each one?

lldb/include/lldb/Target/Trace.h

97

Do we also want a non static version of this to be able to get the schema for the current Trace plugin?

lldb/include/lldb/Target/TraceSessionFileParser.h

108

indeed! I will trickly through to any .cpp file that includes it

lldb/source/Commands/CommandObjectTrace.cpp

243–244

Make <plug-in> optional so we can list all trace plug-in schemas?

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

15

I second this, add a plug-in namespace!

[wallace]

• Added “trace schema all”, following the pattern from "trace <command> all", and added a test for this.
• Created a non-static version of GetSchema in Trace.h
• Cannot delete Trace() {}, as there’s a compilation error. Could be because some constructors have been marked as deleted, so the compiler wants explicit declarations.
• Created the lldb_private::trace_intel_pt namespace
• Deleted all unnecessary namespace and “using namespace” usages.
• Using StringRef more ubiquitously now and other small fixes requested by Pavel

[labath]

Looks good.

In D88841#2320410, @wallace wrote:

• Cannot delete Trace() {}, as there’s a compilation error. Could be because some constructors have been marked as deleted, so the compiler wants explicit declarations.

Right. I was going to say you can delete those too as they are already deleted on the base class. Except, it turns out, PluginInterface did not have them deleted. Well.. after 0610a25a85 it has. :)

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

19

I think LLDB_PLUGIN_DEFINE should work fine. The _ADV version is for (mostly legacy) cases where the plugin name does not match the class name.

lldb/include/lldb/Core/PluginManager.h

public:
 
   static bool UnregisterPlugin(SymbolVendorCreateInstance create_callback);
 
   static SymbolVendorCreateInstance
   GetSymbolVendorCreateCallbackAtIndex(uint32_t idx);
 
   // Trace
   static bool RegisterPlugin(ConstString name, const char *description,
-                             TraceCreateInstance create_callback);
+                             TraceCreateInstance create_callback,
+                             llvm::StringRef schema);
 
   static bool UnregisterPlugin(TraceCreateInstance create_callback);
 
   static TraceCreateInstance GetTraceCreateCallback(ConstString plugin_name);
 
+  /// Get the JSON schema for a trace session file corresponding to the given
+  /// plugin.
+  ///
+  /// \param[in] plugin_name
+  ///     The name of the plugin.
+  ///
+  /// \return
+  ///     An empty \a StringRef if no plugin was found with that plugin name,
+  ///     otherwise the actual schema is returned.
+  static llvm::StringRef GetTraceSchema(ConstString plugin_name);
+
+  /// Get the JSON schema for a trace session file corresponding to the plugin
+  /// given by its index.
+  ///
+  /// \param[in] index
+  ///     The index of the plugin to get the schema of.
+  ///
+  /// \return
+  ///     An empty \a StringRef if the index is greater than or equal to the
+  ///     number plugins, otherwise the actual schema is returned.
+  static llvm::StringRef GetTraceSchema(size_t index);
+
   // UnwindAssembly
   static bool RegisterPlugin(ConstString name, const char *description,
                              UnwindAssemblyCreateInstance create_callback);
 
   static bool UnregisterPlugin(UnwindAssemblyCreateInstance create_callback);
 
   static UnwindAssemblyCreateInstance
   GetUnwindAssemblyCreateCallbackAtIndex(uint32_t idx);

lldb/include/lldb/Target/Trace.h

 //===-- Trace.h -------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TARGET_TRACE_H
 #define LLDB_TARGET_TRACE_H
 
 #include "llvm/Support/JSON.h"
 
 #include "lldb/Core/PluginInterface.h"
-#include "lldb/Target/TraceSettingsParser.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 /// \class Trace Trace.h "lldb/Target/Trace.h"
 /// A plug-in interface definition class for trace information.
 ///
public:
   ///       - path to locally cached file on disk
   ///       - URL to download the file
   ///   - Any information needed to load the trace file
   ///     - CPU information
   ///     - Custom plug-in information needed to decode the trace information
   ///       correctly.
   ///
   /// \param[in] debugger
-  ///     The debugger instance were new Target will be created as part of the
+  ///     The debugger instance where new Targets will be created as part of the
   ///     JSON data parsing.
   ///
-  /// \param[in] settings
-  ///     JSON object describing a trace.
-  ///
-  /// \param[in] settings_dir
-  ///     Path to a directory used to resolve relative paths in the JSON data.
-  ///     If the JSON data is defined in a file, this should be the
-  ///     folder containing it.
+  /// \param[in] trace_session_file
+  ///     The contents of the trace session file describing the trace session.
+  ///     See \a TraceSessionFileParser::BuildSchema for more information about
+  ///     the schema of this JSON file.
+  ///
+  /// \param[in] session_file_dir
+  ///     The path to the directory that contains the session file. It's used to
+  ///     resolved relative paths in the session file.
   static llvm::Expected<lldb::TraceSP>
-  FindPlugin(Debugger &debugger, const llvm::json::Value &settings,
-             llvm::StringRef settings_dir);
+  FindPlugin(Debugger &debugger, const llvm::json::Value &trace_session_file,
+             llvm::StringRef session_file_dir);
 
-  /// Create an instance of trace plug-in by name.
+  /// Get the schema of a Trace plug-in given its name.
   ///
   /// \param[in] plugin_name
   ///     Name of the trace plugin.
-  static llvm::Expected<lldb::TraceSP> FindPlugin(llvm::StringRef plugin_name);
+  static llvm::Expected<llvm::StringRef>
+  FindPluginSchema(llvm::StringRef plugin_name);
 
-  /// Parse the JSON settings and create the corresponding \a Target
-  /// objects. In case of an error, no targets are created.
-  ///
-  /// \param[in] debugger
-  ///   The debugger instance where the targets are created.
-  ///
-  /// \param[in] settings
-  ///     JSON object describing a trace.
-  ///
-  /// \param[in] settings_dir
-  ///     Path to a directory used to resolve relative paths in the JSON data.
-  ///     If the JSON data is defined in a file, this should be the
-  ///     folder containing it.
-  ///
   /// \return
-  ///   An error object containing the reason if there is a failure.
-  llvm::Error ParseSettings(Debugger &debugger,
-                            const llvm::json::Value &settings,
-                            llvm::StringRef settings_dir);
-
-  /// Get the JSON schema of the settings for the trace plug-in.
-  llvm::StringRef GetSchema();
-
-protected:
-  Trace() {}
-
-  /// The actual plug-in should define its own implementation of \a
-  /// TraceSettingsParser for doing any custom parsing.
-  virtual std::unique_ptr<lldb_private::TraceSettingsParser> CreateParser() = 0;
-
-private:
-  Trace(const Trace &) = delete;
-  const Trace &operator=(const Trace &) = delete;
-
-protected:
-  friend class TraceSettingsParser;
-  /// JSON object that holds all settings for this trace session.
-  llvm::json::Object m_settings;
-  /// The directory that contains the settings file.
-  std::string m_settings_dir;
-
-  std::map<lldb::pid_t, std::map<lldb::tid_t, lldb_private::FileSpec>>
-      m_thread_to_trace_file_map;
-  std::vector<lldb::TargetSP> m_targets;
+  ///     The JSON schema of this Trace plug-in.
+  virtual llvm::StringRef GetSchema() = 0;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_TRACE_H

lldb/include/lldb/Target/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 "lldb/lldb-private.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;
+  };
+
+  /// The trace plug-in implementation should provide its own TPluginSettings,
+  /// which corresponds to the "trace" section of the schema.
+  template <class TPluginSettings> struct JSONTraceSession {
+    std::vector<JSONProcess> processes;
+    TPluginSettings trace;
+  };
+  /// \}
+
+  TraceSessionFileParser(llvm::StringRef session_file_dir,
+                         llvm::StringRef schema)
+      : m_session_file_dir(session_file_dir), m_schema(schema) {}
+
+  /// Build the full schema for a Trace plug-in.
+  ///
+  /// \param[in] plugin_schema
+  ///   The subschema that corresponds to the "trace" section of the schema.
+  ///
+  /// \return
+  ///   The full schema containing the common attributes and the plug-in
+  ///   specific attributes.
+  static std::string BuildSchema(llvm::StringRef plugin_schema);
+
+protected:
+  /// Resolve non-absolute paths relative to the session file folder. It
+  /// modifies the given file_spec.
+  void NormalizePath(lldb_private::FileSpec &file_spec);
+
+  llvm::Error ParseModule(lldb::TargetSP &target_sp, const JSONModule &module);
+
+  /// Create a user-friendly error message upon a JSON-parsing failure using the
+  /// \a json::ObjectMapper functionality.
+  ///
+  /// \param[in] root
+  ///   The \a llvm::json::Path::Root used to parse the JSON \a value.
+  ///
+  /// \param[in] value
+  ///   The json value that failed to parse.
+  ///
+  /// \return
+  ///   An \a llvm::Error containing the user-friendly error message.
+  llvm::Error CreateJSONError(llvm::json::Path::Root &root,
+                              const llvm::json::Value &value);
+
+  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);
+
+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) &&
+         o.map("processes", session.processes);
+}
+
+} // namespace json
+} // namespace llvm
+
+#endif // LLDB_TARGET_TRACESESSIONPARSER_H

lldb/include/lldb/Target/TraceSettingsParser.h

-//===-- TraceSettingsParser.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_SETTINGS_PARSER_H
-#define LLDB_TARGET_TRACE_SETTINGS_PARSER_H
-
-#include "llvm/ADT/Optional.h"
-
-#include "lldb/Target/Trace.h"
-#include "lldb/lldb-private.h"
-
-namespace lldb_private {
-
-/// \class TraceSettingsParser TraceSettingsParser.h
-/// A plug-in interface definition class for parsing \a Trace settings.
-///
-/// As \a Trace plug-ins support plug-in specific settings, this class should be
-/// overriden and implement the plug-in specific parsing logic.
-class TraceSettingsParser {
-public:
-  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 JSONTraceSettings {
-    std::vector<JSONProcess> processes;
-    JSONTracePluginSettings trace;
-  };
-
-  TraceSettingsParser(Trace &trace) : m_trace(trace) {}
-
-  virtual ~TraceSettingsParser() = default;
-
-  /// Get the JSON schema of the settings for the trace plug-in.
-  llvm::StringRef GetSchema();
-
-  /// Parse the structured data settings and create the corresponding \a Target
-  /// objects. In case of and error, no targets are created.
-  ///
-  /// \param[in] debugger
-  ///   The debugger instance where the targets are created.
-  ///
-  /// \param[in] settings
-  ///   The settings to parse.
-  ///
-  /// \param[in] settings_dir
-  ///   The directory that contains the settings file used to resolve relative
-  ///   paths.
-  ///
-  /// \return
-  ///   An error object containing the reason if there is a failure.
-  llvm::Error ParseSettings(Debugger &debugger,
-                            const llvm::json::Value &settings,
-                            llvm::StringRef settings_dir);
-
-protected:
-  /// Method that should be overriden by implementations of this class to
-  /// provide the specific plug-in schema inside the "trace" section of the
-  /// global schema.
-  virtual llvm::StringRef GetPluginSchema() = 0;
-
-  /// Method that should be overriden to parse the plug-in specific settings.
-  ///
-  /// \param[in] plugin_settings
-  ///   The settings to parse specific to the plugin.
-  ///
-  /// \return
-  ///   An error object containing the reason if there is a failure.
-  virtual llvm::Error
-  ParsePluginSettings(const llvm::json::Value &plugin_settings) = 0;
-
-  /// Create a user-friendly error message upon a JSON-parsing failure using the
-  /// \a json::ObjectMapper functionality.
-  ///
-  /// \param[in] root
-  ///   The \a llvm::json::Path::Root used to parse the JSON \a value.
-  ///
-  /// \param[in] value
-  ///   The json value that failed to parse.
-  ///
-  /// \return
-  ///   An \a llvm::Error containing the user-friendly error message.
-  llvm::Error CreateJSONError(llvm::json::Path::Root &root,
-                              const llvm::json::Value &value);
-
-private:
-  /// Resolve non-absolute paths relativeto the settings folder
-  void NormalizePath(lldb_private::FileSpec &file_spec);
-
-  llvm::Error ParseProcess(lldb_private::Debugger &debugger,
-                           const JSONProcess &process);
-  void ParseThread(lldb::ProcessSP &process_sp, const JSONThread &thread);
-  llvm::Error ParseModule(lldb::TargetSP &target_sp, const JSONModule &module);
-  llvm::Error ParseSettingsImpl(lldb_private::Debugger &debugger,
-                                const llvm::json::Value &settings);
-
-  Trace &m_trace;
-
-protected:
-  /// Objects created as product of the parsing
-  /// \{
-  /// The directory that contains the settings file.
-  std::string m_settings_dir;
-
-  std::map<lldb::pid_t, std::map<lldb::tid_t, lldb_private::FileSpec>>
-      m_thread_to_trace_file_map;
-  std::vector<lldb::TargetSP> m_targets;
-  /// \}
-};
-
-} // namespace lldb_private
-
-namespace llvm {
-namespace json {
-
-inline bool fromJSON(const llvm::json::Value &value,
-                     lldb_private::TraceSettingsParser::JSONAddress &address,
-                     llvm::json::Path path) {
-  llvm::Optional<llvm::StringRef> s = value.getAsString();
-  if (s.hasValue() && !s->getAsInteger(0, address.value))
-    return true;
-
-  path.report("expected numeric string");
-  return false;
-}
-
-inline bool fromJSON(const llvm::json::Value &value,
-                     lldb_private::TraceSettingsParser::JSONModule &module,
-                     llvm::json::Path path) {
-  llvm::json::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);
-}
-
-inline bool fromJSON(const llvm::json::Value &value,
-                     lldb_private::TraceSettingsParser::JSONThread &thread,
-                     llvm::json::Path path) {
-  llvm::json::ObjectMapper o(value, path);
-  return o && o.map("tid", thread.tid) && o.map("traceFile", thread.trace_file);
-}
-
-inline bool fromJSON(const llvm::json::Value &value,
-                     lldb_private::TraceSettingsParser::JSONProcess &process,
-                     llvm::json::Path path) {
-  llvm::json::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);
-}
-
-inline bool fromJSON(
-    const llvm::json::Value &value,
-    lldb_private::TraceSettingsParser::JSONTracePluginSettings &plugin_settings,
-    llvm::json::Path path) {
-  llvm::json::ObjectMapper o(value, path);
-  return o && o.map("type", plugin_settings.type);
-}
-
-inline bool
-fromJSON(const llvm::json::Value &value,
-         lldb_private::TraceSettingsParser::JSONTraceSettings &settings,
-         llvm::json::Path path) {
-  llvm::json::ObjectMapper o(value, path);
-  return o && o.map("trace", settings.trace) &&
-         o.map("processes", settings.processes);
-}
-
-} // namespace json
-} // namespace llvm
-
-#endif // LLDB_TARGET_TRACE_SETTINGS_PARSER_H

lldb/include/lldb/lldb-forward.h

 class ThreadPlanStepInstruction;
 class ThreadPlanStepOut;
 class ThreadPlanStepOverBreakpoint;
 class ThreadPlanStepRange;
 class ThreadPlanStepThrough;
 class ThreadPlanTracer;
 class ThreadSpec;
 class Trace;
-class TraceSettingsParser;
+class TraceSessionFileParser;
 class TraceOptions;
 class Type;
 class TypeAndOrName;
 class TypeCategoryImpl;
 class TypeCategoryMap;
 class TypeEnumMemberImpl;
 class TypeEnumMemberListImpl;
 class TypeFilterImpl;

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

 #include "lldb/lldb-private-enumerations.h"
 #include "lldb/lldb-types.h"
 #include <memory>
 #include <set>
 
 namespace llvm {
 namespace json {
 class Object;
+class Value;
 }
 } // namespace llvm
 
 namespace lldb_private {
 typedef lldb::ABISP (*ABICreateInstance)(lldb::ProcessSP process_sp,
                                          const ArchSpec &arch);
 typedef std::unique_ptr<Architecture> (*ArchitectureCreateInstance)(
     const ArchSpec &arch);

 typedef lldb::TypeSystemSP (*TypeSystemCreateInstance)(
     lldb::LanguageType language, Module *module, Target *target);
 typedef lldb::REPLSP (*REPLCreateInstance)(Status &error,
                                            lldb::LanguageType language,
                                            Debugger *debugger, Target *target,
                                            const char *repl_options);
 typedef int (*ComparisonFunction)(const void *, const void *);
 typedef void (*DebuggerInitializeCallback)(Debugger &debugger);
-typedef lldb::TraceSP (*TraceCreateInstance)();
+typedef llvm::Expected<lldb::TraceSP> (*TraceCreateInstance)(
+    const llvm::json::Value &trace_session_file,
+    llvm::StringRef session_file_dir, lldb_private::Debugger &debugger);
 
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 
 #endif // LLDB_LLDB_PRIVATE_INTERFACES_H

lldb/source/Commands/CommandObjectTrace.cpp

 //===-- CommandObjectTrace.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 "CommandObjectTrace.h"
 
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include "lldb/Core/Debugger.h"
+#include "lldb/Core/PluginManager.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
 #include "lldb/Interpreter/OptionValueLanguage.h"
ArrayRef<OptionDefinition> GetDefinitions() override {
       return makeArrayRef(g_trace_load_options);
     }
 
     bool m_verbose; // Enable verbose logging for debugging purposes.
   };
 
   CommandObjectTraceLoad(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "trace load",
-                            "Load processor trace data from a JSON file.",
+                            "Load a processor trace session from a JSON file.",
                             "trace load"),
         m_options() {}
 
   ~CommandObjectTraceLoad() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (command.size() != 1) {
-      result.AppendError("a single path to a JSON file containing trace "
-                         "information is required");
+      result.AppendError(
+          "a single path to a JSON file containing a trace session"
+          "is required");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     auto end_with_failure = [&result](llvm::Error err) -> bool {
       result.AppendErrorWithFormat("%s\n",
                                    llvm::toString(std::move(err)).c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;
     };
 
     FileSpec json_file(command[0].ref());
 
     auto buffer_or_error = llvm::MemoryBuffer::getFile(json_file.GetPath());
     if (!buffer_or_error) {
       return end_with_failure(llvm::createStringError(
           std::errc::invalid_argument, "could not open input file: %s - %s.",
           json_file.GetPath().c_str(),
           buffer_or_error.getError().message().c_str()));
     }
 
-    llvm::Expected<json::Value> settings =
+    llvm::Expected<json::Value> session_file =
         json::parse(buffer_or_error.get()->getBuffer().str());
-    if (!settings)
-      return end_with_failure(settings.takeError());
+    if (!session_file)
+      return end_with_failure(session_file.takeError());
 
-    if (Expected<lldb::TraceSP> traceOrErr = Trace::FindPlugin(
-            GetDebugger(), *settings, json_file.GetDirectory().AsCString())) {
+    if (Expected<lldb::TraceSP> traceOrErr =
+            Trace::FindPlugin(GetDebugger(), *session_file,
+                              json_file.GetDirectory().AsCString())) {
       lldb::TraceSP trace_sp = traceOrErr.get();
       if (m_options.m_verbose)
         result.AppendMessageWithFormat("loading trace with plugin %s\n",
                                        trace_sp->GetPluginName().AsCString());
     } else
       return end_with_failure(traceOrErr.takeError());
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
public:
     }
 
     bool m_verbose; // Enable verbose logging for debugging purposes.
   };
 
   CommandObjectTraceSchema(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "trace schema",
                             "Show the schema of the given trace plugin.",
-                            "trace schema <plug-in>"),
+                            "trace schema <plug-in>. Use the plug-in name "
+                            "\"all\" to see all schemas.\n"),
         m_options() {}
 
   ~CommandObjectTraceSchema() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Status error;
     if (command.empty()) {
       result.SetError(
           "trace schema cannot be invoked without a plug-in as argument");
       return false;
     }
 
     StringRef plugin_name(command[0].c_str());
+    if (plugin_name == "all") {
+      size_t index = 0;
+      while (true) {
+        StringRef schema = PluginManager::GetTraceSchema(index++);
+        if (schema.empty())
+          break;
 
-    if (Expected<lldb::TraceSP> traceOrErr = Trace::FindPlugin(plugin_name)) {
-      lldb::TraceSP trace_sp = traceOrErr.get();
-      result.AppendMessage(trace_sp->GetSchema());
+        result.AppendMessage(schema);
+      }
     } else {
-      error.SetErrorString(llvm::toString(traceOrErr.takeError()));
+      if (Expected<StringRef> schemaOrErr =
+              Trace::FindPluginSchema(plugin_name))
+        result.AppendMessage(*schemaOrErr);
+      else
+        error = schemaOrErr.takeError();
     }
 
     if (error.Success()) {
       result.SetStatus(eReturnStatusSuccessFinishResult);
     } else {
       result.AppendErrorWithFormat("%s\n", error.AsCString());
       result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;

lldb/source/Core/PluginManager.cpp

for (auto &instance : m_instances) {
       if (instance.debugger_init_callback)
         instance.debugger_init_callback(debugger);
     }
   }
 
   const std::vector<Instance> &GetInstances() const { return m_instances; }
   std::vector<Instance> &GetInstances() { return m_instances; }
 
-private:
   Instance *GetInstanceAtIndex(uint32_t idx) {
     if (idx < m_instances.size())
       return &m_instances[idx];
     return nullptr;
   }
+
+private:
   std::vector<Instance> m_instances;
 };
 
 #pragma mark ABI
 
 typedef PluginInstance<ABICreateInstance> ABIInstance;
 typedef PluginInstances<ABIInstance> ABIInstances;
 

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

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

 if (NOT LIBIPT_INCLUDE_PATH)
   message (FATAL_ERROR "libipt include path not provided")
 endif()
 
 if (NOT EXISTS "${LIBIPT_INCLUDE_PATH}")
   message (FATAL_ERROR "invalid libipt include path provided")
 endif()
 include_directories(${LIBIPT_INCLUDE_PATH})
 
 find_library(LIBIPT_LIBRARY ipt PATHS ${LIBIPT_LIBRARY_PATH} REQUIRED)
 
 add_lldb_library(lldbPluginTraceIntelPT PLUGIN
   TraceIntelPT.cpp
-  TraceIntelPTSettingsParser.cpp
+  TraceIntelPTSessionFileParser.cpp
+  ThreadIntelPT.cpp
 
   LINK_LIBS
     lldbCore
     lldbSymbol
     lldbTarget
     ${LIBIPT_LIBRARY}
   LINK_COMPONENTS
     Support
   )

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

+//===-- ThreadIntelPT.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_THREADINTELPT_H
+#define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_THREADINTELPT_H
+
+#include "lldb/Target/Thread.h"
+
+namespace lldb_private {
+namespace trace_intel_pt {
+
+class ThreadIntelPT : public Thread {
+public:
+  /// Create an Intel PT-traced thread.
+  ///
+  /// \param[in] process
+  ///     The process that owns this thread.
+  ///
+  /// \param[in] tid
+  ///     The thread id of this thread.
+  ///
+  /// \param[in] trace_file
+  ///     The trace file for this thread.
+  ///
+  /// \param[in] pt_cpu
+  ///     The Intel CPU information required to decode the \a trace_file.
+  ThreadIntelPT(Process &process, lldb::tid_t tid, const FileSpec &trace_file)
+      : Thread(process, tid), m_trace_file(trace_file) {}
+
+  void RefreshStateAfterStop() override;
+
+  lldb::RegisterContextSP GetRegisterContext() override;
+
+  lldb::RegisterContextSP
+  CreateRegisterContextForFrame(StackFrame *frame) override;
+
+protected:
+  bool CalculateStopInfo() override;
+
+  lldb::RegisterContextSP m_thread_reg_ctx_sp;
+
+private:
+  FileSpec m_trace_file;
+};
+
+} // namespace trace_intel_pt
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_THREADINTELPT_H

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

+//===-- ThreadIntelPT.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 "ThreadIntelPT.h"
+
+#include <memory>
+
+#include "Plugins/Process/Utility/RegisterContextHistory.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::trace_intel_pt;
+
+void ThreadIntelPT::RefreshStateAfterStop() {}
+
+RegisterContextSP ThreadIntelPT::GetRegisterContext() {
+  if (!m_reg_context_sp)
+    m_reg_context_sp = CreateRegisterContextForFrame(nullptr);
+
+  return m_reg_context_sp;
+}
+
+RegisterContextSP
+ThreadIntelPT::CreateRegisterContextForFrame(StackFrame *frame) {
+  // Eventually this will calculate the register context based on the current
+  // trace position.
+  return std::make_shared<RegisterContextHistory>(
+      *this, 0, GetProcess()->GetAddressByteSize(), LLDB_INVALID_ADDRESS);
+}
+
+bool ThreadIntelPT::CalculateStopInfo() { return false; }

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 liblldb_TraceIntelPT_h_
-#define liblldb_TraceIntelPT_h_
+#ifndef LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPT_H
+#define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_TRACEINTELPT_H
 
 #include "intel-pt.h"
 #include "llvm/ADT/Optional.h"
 
-#include "TraceIntelPTSettingsParser.h"
+#include "TraceIntelPTSessionFileParser.h"
 #include "lldb/Target/Trace.h"
 #include "lldb/lldb-private.h"
 
-class TraceIntelPT : public lldb_private::Trace {
+namespace lldb_private {
+namespace trace_intel_pt {
+
+class TraceIntelPT : public Trace {
 public:
-  void Dump(lldb_private::Stream *s) const override;
+  void Dump(Stream *s) const override;
 
   ~TraceIntelPT() override = default;
 
   /// PluginInterface protocol
   /// \{
-  lldb_private::ConstString GetPluginName() override;
+  ConstString GetPluginName() override;
 
   static void Initialize();
 
   static void Terminate();
 
-  static lldb::TraceSP CreateInstance();
+  /// Create an instance of this class.
+  ///
+  /// \param[in] trace_session_file
+  ///     The contents of the trace session file. See \a Trace::FindPlugin.
+  ///
+  /// \param[in] session_file_dir
+  ///     The path to the directory that contains the session file. It's used to
+  ///     resolved relative paths in the session file.
+  ///
+  /// \param[in] debugger
+  ///     The debugger instance where new Targets will be created as part of the
+  ///     JSON data parsing.
+  ///
+  /// \return
+  ///     A trace instance or an error in case of failures.
+  static llvm::Expected<lldb::TraceSP>
+  CreateInstance(const llvm::json::Value &trace_session_file,
+                 llvm::StringRef session_file_dir, Debugger &debugger);
 
-  static lldb_private::ConstString GetPluginNameStatic();
+  static ConstString GetPluginNameStatic();
 
   uint32_t GetPluginVersion() override;
   /// \}
 
-protected:
-  TraceIntelPT() : Trace() {}
+  llvm::StringRef GetSchema() override;
 
-  std::unique_ptr<lldb_private::TraceSettingsParser> CreateParser() override;
+  TraceIntelPT(const pt_cpu &pt_cpu, const std::vector<lldb::TargetSP> &targets)
+      : m_pt_cpu(pt_cpu) {
+    for (const lldb::TargetSP &target_sp : targets)
+      m_targets.push_back(target_sp);
+  }
 
 private:
-  friend class TraceIntelPTSettingsParser;
   pt_cpu m_pt_cpu;
+  std::vector<std::weak_ptr<Target>> m_targets;
 };
 
-#endif // liblldb_TraceIntelPT_h_
+} // 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 "TraceIntelPTSettingsParser.h"
+#include "TraceIntelPTSessionFileParser.h"
 #include "lldb/Core/PluginManager.h"
 
 using namespace lldb;
 using namespace lldb_private;
+using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
-LLDB_PLUGIN_DEFINE_ADV(TraceIntelPT, TraceIntelPT)
+LLDB_PLUGIN_DEFINE(TraceIntelPT)
 
 void TraceIntelPT::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(), "Intel Processor Trace",
-                                CreateInstance);
+                                CreateInstance,
+                                TraceIntelPTSessionFileParser::GetSchema());
 }
 
 void TraceIntelPT::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 ConstString TraceIntelPT::GetPluginNameStatic() {
   static ConstString g_name("intel-pt");
   return g_name;
 }
 
-std::unique_ptr<lldb_private::TraceSettingsParser>
-TraceIntelPT::CreateParser() {
-  return std::make_unique<TraceIntelPTSettingsParser>(*this);
+StringRef TraceIntelPT::GetSchema() {
+  return TraceIntelPTSessionFileParser::GetSchema();
 }
 
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 
 ConstString TraceIntelPT::GetPluginName() { return GetPluginNameStatic(); }
 
 uint32_t TraceIntelPT::GetPluginVersion() { return 1; }
 
 void TraceIntelPT::Dump(lldb_private::Stream *s) const {}
 
-lldb::TraceSP TraceIntelPT::CreateInstance() {
-  return lldb::TraceSP(new TraceIntelPT());
+Expected<lldb::TraceSP>
+TraceIntelPT::CreateInstance(const json::Value &trace_session_file,
+                             StringRef session_file_dir, Debugger &debugger) {
+  return TraceIntelPTSessionFileParser(debugger, trace_session_file,
+                                       session_file_dir)
+      .Parse();
 }

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 "intel-pt.h"
+
+#include "TraceIntelPT.h"
+#include "lldb/Target/TraceSessionFileParser.h"
+
+namespace lldb_private {
+namespace trace_intel_pt {
+
+class TraceIntelPT;
+
+class TraceIntelPTSessionFileParser : public TraceSessionFileParser {
+public:
+  struct JSONPTCPU {
+    std::string vendor;
+    int64_t family;
+    int64_t model;
+    int64_t stepping;
+  };
+
+  struct JSONTraceIntelPTSettings
+      : TraceSessionFileParser::JSONTracePluginSettings {
+    JSONPTCPU pt_cpu;
+  };
+
+  /// 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(session_file_dir, GetSchema()),
+        m_debugger(debugger), m_trace_session_file(trace_session_file) {}
+
+  /// \return
+  ///   The JSON schema for the session data.
+  static llvm::StringRef GetSchema();
+
+  /// Parse the structured data trace session and create the corresponding \a
+  /// Target objects. In case of an error, no targets are created.
+  ///
+  /// \return
+  ///   A \a lldb::TraceSP instance with the trace session data. In case of
+  ///   errors, return a null pointer.
+  llvm::Expected<lldb::TraceSP> Parse();
+
+private:
+  llvm::Error ParseImpl();
+
+  llvm::Error ParseProcess(const TraceSessionFileParser::JSONProcess &process);
+
+  void ParseThread(lldb::ProcessSP &process_sp,
+                   const TraceSessionFileParser::JSONThread &thread);
+
+  void ParsePTCPU(const JSONPTCPU &pt_cpu);
+
+  Debugger &m_debugger;
+  const llvm::json::Value &m_trace_session_file;
+
+  /// Objects created as product of the parsing
+  /// \{
+  pt_cpu m_pt_cpu;
+  std::vector<lldb::TargetSP> m_targets;
+  /// \}
+};
+
+} // namespace trace_intel_pt
+} // namespace lldb_private
+
+namespace llvm {
+namespace json {
+
+bool fromJSON(
+    const Value &value,
+    lldb_private::trace_intel_pt::TraceIntelPTSessionFileParser::JSONPTCPU
+        &pt_cpu,
+    Path path);
+
+bool fromJSON(const Value &value,
+              lldb_private::trace_intel_pt::TraceIntelPTSessionFileParser::
+                  JSONTraceIntelPTSettings &plugin_settings,
+              Path path);
+
+} // 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 "ThreadIntelPT.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.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;
+  if (schema.empty()) {
+    schema = TraceSessionFileParser::BuildSchema(R"({
+    "type": "intel-pt",
+    "pt_cpu": {
+      "vendor": "intel" | "unknown",
+      "family": integer,
+      "model": integer,
+      "stepping": integer
+    }
+  })");
+  }
+  return schema;
+}
+
+void TraceIntelPTSessionFileParser::ParseThread(
+    ProcessSP &process_sp, const TraceSessionFileParser::JSONThread &thread) {
+  lldb::tid_t tid = static_cast<lldb::tid_t>(thread.tid);
+
+  FileSpec trace_file(thread.trace_file);
+  NormalizePath(trace_file);
+
+  ThreadSP thread_sp(new ThreadIntelPT(*process_sp, tid, trace_file));
+  process_sp->GetThreadList().AddThread(thread_sp);
+}
+
+Error TraceIntelPTSessionFileParser::ParseProcess(
+    const TraceSessionFileParser::JSONProcess &process) {
+  TargetSP target_sp;
+  Status error = m_debugger.GetTargetList().CreateTarget(
+      m_debugger, /*user_exe_path*/ StringRef(), process.triple,
+      eLoadDependentsNo,
+      /*platform_options*/ nullptr, target_sp);
+
+  if (!target_sp)
+    return error.ToError();
+
+  m_targets.push_back(target_sp);
+  m_debugger.GetTargetList().SetSelectedTarget(target_sp.get());
+
+  ProcessSP process_sp(target_sp->CreateProcess(
+      /*listener*/ nullptr, /*plugin_name*/ StringRef(),
+      /*crash_file*/ nullptr));
+  process_sp->SetID(static_cast<lldb::pid_t>(process.pid));
+
+  for (const TraceSessionFileParser::JSONThread &thread : process.threads)
+    ParseThread(process_sp, thread);
+
+  for (const TraceSessionFileParser::JSONModule &module : process.modules) {
+    if (Error err = ParseModule(target_sp, module))
+      return err;
+  }
+  return Error::success();
+}
+
+void TraceIntelPTSessionFileParser::ParsePTCPU(const JSONPTCPU &pt_cpu) {
+  m_pt_cpu = {pt_cpu.vendor.compare("intel") == 0 ? pcv_intel : pcv_unknown,
+              static_cast<uint16_t>(pt_cpu.family),
+              static_cast<uint8_t>(pt_cpu.model),
+              static_cast<uint8_t>(pt_cpu.stepping)};
+}
+
+Error TraceIntelPTSessionFileParser::ParseImpl() {
+  json::Path::Root root("traceSession");
+  TraceSessionFileParser::JSONTraceSession<JSONTraceIntelPTSettings> session;
+  if (!json::fromJSON(m_trace_session_file, session, root)) {
+    return CreateJSONError(root, m_trace_session_file);
+  }
+
+  ParsePTCPU(session.trace.pt_cpu);
+  for (const TraceSessionFileParser::JSONProcess &process : session.processes) {
+    if (Error err = ParseProcess(process))
+      return err;
+  }
+  return Error::success();
+}
+
+Expected<TraceSP> TraceIntelPTSessionFileParser::Parse() {
+  if (Error err = ParseImpl()) {
+    // Delete all targets that were created
+    for (auto target_sp : m_targets)
+      m_debugger.GetTargetList().DeleteTarget(target_sp);
+    m_targets.clear();
+    return std::move(err);
+  }
+
+  return std::make_shared<TraceIntelPT>(m_pt_cpu, m_targets);
+}
+
+namespace llvm {
+namespace json {
+
+bool fromJSON(const Value &value,
+              TraceIntelPTSessionFileParser::JSONPTCPU &pt_cpu, Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("vendor", pt_cpu.vendor) &&
+         o.map("family", pt_cpu.family) && o.map("model", pt_cpu.model) &&
+         o.map("stepping", pt_cpu.stepping);
+}
+
+bool fromJSON(
+    const Value &value,
+    TraceIntelPTSessionFileParser::JSONTraceIntelPTSettings &plugin_settings,
+    Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("pt_cpu", plugin_settings.pt_cpu) &&
+         fromJSON(
+             value,
+             (TraceSessionFileParser::JSONTracePluginSettings &)plugin_settings,
+             path);
+}
+
+} // namespace json
+} // namespace llvm

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

-//===-- TraceIntelPTSettingsParser.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 liblldb_TraceIntelPTSettingsParser_h_
-#define liblldb_TraceIntelPTSettingsParser_h_
-
-#include "intel-pt.h"
-
-#include "TraceIntelPT.h"
-#include "lldb/Target/TraceSettingsParser.h"
-#include "lldb/Utility/StructuredData.h"
-
-class TraceIntelPT;
-
-class TraceIntelPTSettingsParser : public lldb_private::TraceSettingsParser {
-public:
-  struct JSONPTCPU {
-    std::string vendor;
-    int64_t family;
-    int64_t model;
-    int64_t stepping;
-  };
-
-  struct JSONIntelPTSettings {
-    JSONPTCPU pt_cpu;
-  };
-
-  TraceIntelPTSettingsParser(TraceIntelPT &trace)
-      : lldb_private::TraceSettingsParser((lldb_private::Trace &)trace),
-        m_trace(trace) {}
-
-protected:
-  llvm::StringRef GetPluginSchema() override;
-
-  llvm::Error
-  ParsePluginSettings(const llvm::json::Value &plugin_settings) override;
-
-private:
-  void ParsePTCPU(const JSONPTCPU &pt_cpu);
-
-  TraceIntelPT &m_trace;
-  pt_cpu m_pt_cpu;
-};
-
-namespace llvm {
-namespace json {
-
-inline bool fromJSON(const llvm::json::Value &value,
-                     TraceIntelPTSettingsParser::JSONPTCPU &pt_cpu,
-                     llvm::json::Path path) {
-  llvm::json::ObjectMapper o(value, path);
-  return o && o.map("vendor", pt_cpu.vendor) &&
-         o.map("family", pt_cpu.family) && o.map("model", pt_cpu.model) &&
-         o.map("stepping", pt_cpu.stepping);
-}
-
-inline bool
-fromJSON(const llvm::json::Value &value,
-         TraceIntelPTSettingsParser::JSONIntelPTSettings &intel_pt_settings,
-         llvm::json::Path path) {
-  llvm::json::ObjectMapper o(value, path);
-  return o && o.map("pt_cpu", intel_pt_settings.pt_cpu);
-}
-
-} // namespace json
-} // namespace llvm
-
-#endif // liblldb_TraceIntelPTSettingsParser_h_

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

-//===-- TraceIntelPTSettingsParser.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 "TraceIntelPTSettingsParser.h"
-
-using namespace lldb;
-using namespace lldb_private;
-using namespace llvm;
-
-StringRef TraceIntelPTSettingsParser::GetPluginSchema() {
-  return R"({
-    "type": "intel-pt",
-    "pt_cpu": {
-      "vendor": "intel" | "unknown",
-      "family": integer,
-      "model": integer,
-      "stepping": integer
-    }
-  })";
-}
-
-void TraceIntelPTSettingsParser::ParsePTCPU(const JSONPTCPU &pt_cpu) {
-  m_pt_cpu = {pt_cpu.vendor.compare("intel") == 0 ? pcv_intel : pcv_unknown,
-              static_cast<uint16_t>(pt_cpu.family),
-              static_cast<uint8_t>(pt_cpu.model),
-              static_cast<uint8_t>(pt_cpu.stepping)};
-}
-
-llvm::Error TraceIntelPTSettingsParser::ParsePluginSettings(
-    const llvm::json::Value &plugin_settings) {
-  json::Path::Root root("settings.trace");
-  JSONIntelPTSettings settings;
-  if (!json::fromJSON(plugin_settings, settings, root))
-    return CreateJSONError(root, plugin_settings);
-
-  ParsePTCPU(settings.pt_cpu);
-
-  m_trace.m_pt_cpu = m_pt_cpu;
-  return llvm::Error::success();
-}

lldb/source/Target/CMakeLists.txt

add_lldb_library(lldbTarget
   ThreadPlanStepOverRange.cpp
   ThreadPlanStepRange.cpp
   ThreadPlanStepThrough.cpp
   ThreadPlanStepUntil.cpp
   ThreadPlanTracer.cpp
   ThreadPlanStack.cpp
   ThreadSpec.cpp
   Trace.cpp
-  TraceSettingsParser.cpp
+  TraceSessionFileParser.cpp
   UnixSignals.cpp
   UnwindAssembly.cpp
   UnwindLLDB.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbExpression

lldb/source/Target/Trace.cpp

 #include "llvm/Support/Format.h"
 
 #include "lldb/Core/PluginManager.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm;
 
-// Helper structs used to extract the type of a trace settings json without
+// Helper structs used to extract the type of a trace session json without
 // having to parse the entire object.
 
 struct JSONSimplePluginSettings {
   std::string type;
 };
 
-struct JSONSimpleTraceSettings {
+struct JSONSimpleTraceSession {
   JSONSimplePluginSettings trace;
 };
 
 namespace llvm {
 namespace json {
 
-bool fromJSON(const json::Value &value,
-              JSONSimplePluginSettings &plugin_settings, json::Path path) {
+bool fromJSON(const Value &value, JSONSimplePluginSettings &plugin_settings,
+              Path path) {
   json::ObjectMapper o(value, path);
   return o && o.map("type", plugin_settings.type);
 }
 
-bool fromJSON(const json::Value &value, JSONSimpleTraceSettings &settings,
-              json::Path path) {
+bool fromJSON(const Value &value, JSONSimpleTraceSession &session, Path path) {
   json::ObjectMapper o(value, path);
-  return o && o.map("trace", settings.trace);
+  return o && o.map("trace", session.trace);
 }
 
 } // namespace json
 } // namespace llvm
 
-llvm::Expected<lldb::TraceSP> Trace::FindPlugin(Debugger &debugger,
-                                                const json::Value &settings,
-                                                StringRef info_dir) {
-  JSONSimpleTraceSettings json_settings;
-  json::Path::Root root("settings");
-  if (!json::fromJSON(settings, json_settings, root))
-    return root.getError();
-
-  ConstString plugin_name(json_settings.trace.type);
-  auto create_callback = PluginManager::GetTraceCreateCallback(plugin_name);
-  if (create_callback) {
-    TraceSP instance = create_callback();
-    if (llvm::Error err = instance->ParseSettings(debugger, settings, info_dir))
-      return std::move(err);
-    return instance;
-  }
-
+static Error createInvalidPlugInError(StringRef plugin_name) {
   return createStringError(
       std::errc::invalid_argument,
       "no trace plug-in matches the specified type: \"%s\"",
-      plugin_name.AsCString());
+      plugin_name.data());
 }
 
-llvm::Expected<lldb::TraceSP> Trace::FindPlugin(StringRef name) {
-  ConstString plugin_name(name);
-  auto create_callback = PluginManager::GetTraceCreateCallback(plugin_name);
-  if (create_callback)
-    return create_callback();
+Expected<lldb::TraceSP> Trace::FindPlugin(Debugger &debugger,
+                                          const json::Value &trace_session_file,
+                                          StringRef session_file_dir) {
+  JSONSimpleTraceSession json_session;
+  json::Path::Root root("traceSession");
+  if (!json::fromJSON(trace_session_file, json_session, root))
+    return root.getError();
 
-  return createStringError(
-      std::errc::invalid_argument,
-      "no trace plug-in matches the specified type: \"%s\"",
-      plugin_name.AsCString());
+  ConstString plugin_name(json_session.trace.type);
+  if (auto create_callback = PluginManager::GetTraceCreateCallback(plugin_name))
+    return create_callback(trace_session_file, session_file_dir, debugger);
+
+  return createInvalidPlugInError(json_session.trace.type);
 }
 
-llvm::Error Trace::ParseSettings(Debugger &debugger,
-                                 const llvm::json::Value &settings,
-                                 llvm::StringRef settings_dir) {
-  if (llvm::Error err =
-          CreateParser()->ParseSettings(debugger, settings, settings_dir))
-    return err;
+Expected<StringRef> Trace::FindPluginSchema(StringRef name) {
+  ConstString plugin_name(name);
+  StringRef schema = PluginManager::GetTraceSchema(plugin_name);
+  if (!schema.empty())
+    return schema;
 
-  return llvm::Error::success();
+  return createInvalidPlugInError(name);
 }
-
-llvm::StringRef Trace::GetSchema() { return CreateParser()->GetSchema(); }

lldb/source/Target/TraceSessionFileParser.cpp

+//===-- TraceSessionFileParser.cpp ---------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===/
+
+#include "lldb/Target/TraceSessionFileParser.h"
+
+#include <sstream>
+
+#include "lldb/Core/Module.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace llvm;
+
+void TraceSessionFileParser::NormalizePath(lldb_private::FileSpec &file_spec) {
+  if (file_spec.IsRelative())
+    file_spec.PrependPathComponent(m_session_file_dir);
+}
+
+Error TraceSessionFileParser::ParseModule(lldb::TargetSP &target_sp,
+                                          const JSONModule &module) {
+  FileSpec system_file_spec(module.system_path);
+  NormalizePath(system_file_spec);
+
+  FileSpec local_file_spec(module.file.hasValue() ? *module.file
+                                                  : module.system_path);
+  NormalizePath(local_file_spec);
+
+  ModuleSpec module_spec;
+  module_spec.GetFileSpec() = local_file_spec;
+  module_spec.GetPlatformFileSpec() = system_file_spec;
+  module_spec.SetObjectOffset(module.load_address.value);
+
+  if (module.uuid.hasValue())
+    module_spec.GetUUID().SetFromStringRef(*module.uuid);
+
+  Status error;
+  ModuleSP module_sp =
+      target_sp->GetOrCreateModule(module_spec, /*notify*/ false, &error);
+  return error.ToError();
+}
+
+Error TraceSessionFileParser::CreateJSONError(json::Path::Root &root,
+                                              const json::Value &value) {
+  std::string err;
+  raw_string_ostream os(err);
+  root.printErrorContext(value, os);
+  return createStringError(
+      std::errc::invalid_argument, "%s\n\nContext:\n%s\n\nSchema:\n%s",
+      toString(root.getError()).c_str(), os.str().c_str(), m_schema.data());
+}
+
+std::string TraceSessionFileParser::BuildSchema(StringRef plugin_schema) {
+  std::ostringstream schema_builder;
+  schema_builder << "{\n  \"trace\": ";
+  schema_builder << plugin_schema.data() << ",";
+  schema_builder << R"(
+  "processes": [
+    {
+      "pid": integer,
+      "triple": string, // llvm-triple
+      "threads": [
+        {
+          "tid": integer,
+          "traceFile": string
+        }
+      ],
+      "modules": [
+        {
+          "systemPath": string, // original path of the module at runtime
+          "file"?: string, // copy of the file if not available at "systemPath"
+          "loadAddress": string, // string address in hex or decimal form
+          "uuid"?: string,
+        }
+      ]
+    }
+  ]
+  // Notes:
+  // All paths are either absolute or relative to the session file.
+}
+)";
+  return schema_builder.str();
+}
+
+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);
+}
+
+} // namespace json
+} // namespace llvm

lldb/source/Target/TraceSettingsParser.cpp

-//===-- TraceSettingParser.cpp --------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "lldb/Target/TraceSettingsParser.h"
-
-#include <sstream>
-
-#include "Plugins/Process/Utility/HistoryThread.h"
-#include "lldb/Core/Debugger.h"
-#include "lldb/Target/Process.h"
-
-using namespace lldb;
-using namespace lldb_private;
-using namespace llvm;
-
-StringRef TraceSettingsParser::GetSchema() {
-  static std::string schema;
-  if (schema.empty()) {
-    std::ostringstream schema_builder;
-    schema_builder << "{\n \"trace\": ";
-    schema_builder << GetPluginSchema().str() << ",\n";
-    schema_builder << R"(  "processes": [
-    {
-      "pid": integer,
-      "triple": string, // llvm-triple
-      "threads": [
-        {
-          "tid": integer,
-          "traceFile": string
-        }
-      ],
-      "modules": [
-        {
-          "systemPath": string, // original path of the module at runtime
-          "file"?: string, // copy of the file if not available at "systemPath"
-          "loadAddress": string, // string address in hex or decimal form
-          "uuid"?: string,
-        }
-      ]
-    }
-  ]
-}
-// Notes:
-// All paths are either absolute or relative to the settings file.)";
-    schema = schema_builder.str();
-  }
-  return schema;
-}
-
-void TraceSettingsParser::NormalizePath(FileSpec &file_spec) {
-  if (file_spec.IsRelative())
-    file_spec.PrependPathComponent(m_settings_dir);
-}
-
-void TraceSettingsParser::ParseThread(ProcessSP &process_sp,
-                                      const JSONThread &thread) {
-  lldb::tid_t tid = static_cast<lldb::tid_t>(thread.tid);
-
-  FileSpec spec(thread.trace_file);
-  NormalizePath(spec);
-  m_thread_to_trace_file_map[process_sp->GetID()][tid] = spec;
-
-  ThreadSP thread_sp(new HistoryThread(*process_sp, tid, /*callstack*/ {}));
-  process_sp->GetThreadList().AddThread(thread_sp);
-}
-
-llvm::Error TraceSettingsParser::ParseModule(TargetSP &target_sp,
-                                             const JSONModule &module) {
-  FileSpec system_file_spec(module.system_path);
-  NormalizePath(system_file_spec);
-
-  FileSpec local_file_spec(module.file.hasValue() ? *module.file
-                                                  : module.system_path);
-  NormalizePath(local_file_spec);
-
-  ModuleSpec module_spec;
-  module_spec.GetFileSpec() = local_file_spec;
-  module_spec.GetPlatformFileSpec() = system_file_spec;
-  module_spec.SetObjectOffset(module.load_address.value);
-
-  if (module.uuid.hasValue())
-    module_spec.GetUUID().SetFromStringRef(*module.uuid);
-
-  Status error;
-  ModuleSP module_sp =
-      target_sp->GetOrCreateModule(module_spec, /*notify*/ false, &error);
-  return error.ToError();
-}
-
-llvm::Error TraceSettingsParser::ParseProcess(Debugger &debugger,
-                                              const JSONProcess &process) {
-  TargetSP target_sp;
-  Status error = debugger.GetTargetList().CreateTarget(
-      debugger, /*user_exe_path*/ llvm::StringRef(), process.triple,
-      eLoadDependentsNo,
-      /*platform_options*/ nullptr, target_sp);
-
-  if (!target_sp)
-    return error.ToError();
-
-  m_targets.push_back(target_sp);
-  debugger.GetTargetList().SetSelectedTarget(target_sp.get());
-
-  ProcessSP process_sp(target_sp->CreateProcess(
-      /*listener*/ nullptr, /*plugin_name*/ llvm::StringRef(),
-      /*crash_file*/ nullptr));
-  process_sp->SetID(static_cast<lldb::pid_t>(process.pid));
-
-  for (const JSONThread &thread : process.threads)
-    ParseThread(process_sp, thread);
-
-  for (const JSONModule &module : process.modules) {
-    if (llvm::Error err = ParseModule(target_sp, module))
-      return err;
-  }
-  return llvm::Error::success();
-}
-
-llvm::Error
-TraceSettingsParser::CreateJSONError(json::Path::Root &root,
-                                     const llvm::json::Value &value) {
-  std::string err;
-  raw_string_ostream os(err);
-  root.printErrorContext(value, os);
-  return createStringError(std::errc::invalid_argument,
-                           "%s\n\nContext:\n%s\n\nSchema:\n%s",
-                           llvm::toString(root.getError()).c_str(),
-                           os.str().c_str(), GetSchema().data());
-}
-
-llvm::Error
-TraceSettingsParser::ParseSettingsImpl(Debugger &debugger,
-                                       const llvm::json::Value &raw_settings) {
-  json::Path::Root root("settings");
-  JSONTraceSettings settings;
-  if (!json::fromJSON(raw_settings, settings, root))
-    return CreateJSONError(root, raw_settings);
-
-  for (const JSONProcess &process : settings.processes) {
-    if (llvm::Error err = ParseProcess(debugger, process))
-      return err;
-  }
-
-  json::Object plugin_obj = *raw_settings.getAsObject()->getObject("trace");
-  json::Value plugin_settings(std::move(plugin_obj));
-  return ParsePluginSettings(plugin_settings);
-}
-
-llvm::Error
-TraceSettingsParser::ParseSettings(Debugger &debugger,
-                                   const llvm::json::Value &raw_settings,
-                                   llvm::StringRef settings_dir) {
-  m_settings_dir = settings_dir.str();
-
-  if (llvm::Error err = ParseSettingsImpl(debugger, raw_settings)) {
-    // We clean all the targets that were created internally, which should leave
-    // the debugger unchanged
-    for (auto target_sp : m_targets)
-      debugger.GetTargetList().DeleteTarget(target_sp);
-
-    return err;
-  }
-
-  m_trace.m_settings = *raw_settings.getAsObject();
-  m_trace.m_settings_dir = m_settings_dir;
-  m_trace.m_thread_to_trace_file_map = m_thread_to_trace_file_map;
-  m_trace.m_targets = m_targets;
-
-  return llvm::Error::success();
-}

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

def testLoadTrace(self):
 
         self.assertEqual("6AA9A4E2-6F28-2F33-377D-59FECE874C71-5B41261A", module.GetUUIDString())
 
 
     def testLoadInvalidTraces(self):
         src_dir = self.getSourceDir()
         # We test first an invalid type
         self.expect("trace load -v " + os.path.join(src_dir, "intelpt-trace", "trace_bad.json"), error=True,
-          substrs=['''error: expected object at settings.processes[0]
+          substrs=['''error: expected object at traceSession.processes[0]
 
 Context:
 {
   "processes": [
     /* error: expected object */
     123
   ],
   "trace": { ... }
 }
 
 Schema:
 {
   "trace": {
     "type": "intel-pt",
     "pt_cpu": {
       "vendor": "intel" | "unknown",
       "family": integer,
       "model": integer,
       "stepping": integer
     }
   },'''])
 
-        # Now we test a missing field in the global settings
+        # Now we test a missing field in the global session file
         self.expect("trace load -v " + os.path.join(src_dir, "intelpt-trace", "trace_bad2.json"), error=True,
-            substrs=['error: missing value at settings.processes[1].triple', "Context", "Schema"])
+            substrs=['error: missing value at traceSession.processes[1].triple', "Context", "Schema"])
 
         # Now we test a missing field in the intel-pt settings
         self.expect("trace load -v " + os.path.join(src_dir, "intelpt-trace", "trace_bad4.json"), error=True,
-            substrs=['''error: missing value at settings.trace.pt_cpu.family
+            substrs=['''error: missing value at traceSession.trace.pt_cpu.family
 
 Context:
 {
+  "processes": [],
+  "trace": {
     "pt_cpu": /* error: missing value */ {
       "model": 79,
       "stepping": 1,
       "vendor": "intel"
     },
     "type": "intel-pt"
+  }
 }''', "Schema"])
 
         # Now we test an incorrect load address in the intel-pt settings
         self.expect("trace load -v " + os.path.join(src_dir, "intelpt-trace", "trace_bad5.json"), error=True,
-            substrs=['error: expected numeric string at settings.processes[0].modules[0].loadAddress',
+            substrs=['error: expected numeric string at traceSession.processes[0].modules[0].loadAddress',
                      '"loadAddress": /* error: expected numeric string */ 400000,', "Schema"])
 
         # The following wrong schema will have a valid target and an invalid one. In the case of failure,
         # no targets should be created.
         self.assertEqual(self.dbg.GetNumTargets(), 0)
         self.expect("trace load -v " + os.path.join(src_dir, "intelpt-trace", "trace_bad3.json"), error=True,
-            substrs=['error: missing value at settings.processes[1].pid'])
+            substrs=['error: missing value at traceSession.processes[1].pid'])
         self.assertEqual(self.dbg.GetNumTargets(), 0)

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

class TestTraceLoad(TestBase):
 
 
     def testSchema(self):
         self.expect("trace schema intel-pt", substrs=["trace", "triple", "threads", "traceFile"])
 
     def testInvalidPluginSchema(self):
         self.expect("trace schema invalid-plugin", error=True,
             substrs=['error: no trace plug-in matches the specified type: "invalid-plugin"'])
+
+    def testAllSchemas(self):
+        self.expect("trace schema all", substrs=['''{
+  "trace": {
+    "type": "intel-pt",
+    "pt_cpu": {
+      "vendor": "intel" | "unknown",
+      "family": integer,
+      "model": integer,
+      "stepping": integer
+    }
+  },'''])