[trace] rename ThreadIntelPT to ThreadTrace

[wallace]

Summary

Renamed ThreadIntelPT to ThreadTrace, making it a top-level class. I noticed that this class can and should work with any trace plugin and there's nothing intel-pt specific in it.
With that TraceThread change, I was able to move most of the json file parsing logic to the base class TraceSessionFileParser, which makes adding new plug-ins easier.

This originally was part of https://reviews.llvm.org/D89283

[wallace]

some cleanup

[wallace]

nits

[labath]

Making this a separate patch is a good idea, but it does not materially address my objections to having ProcessTrace and ThreadTrace live in two different places. :(

[wallace]

Addressed the issues that @labath pointed out regarding the TraceProcess and TraceThread:

• These classes were not together
• TraceProcess was an optional plug-in, which would break the Trace parsing logic if plugged-out

So I ended up moving TraceProcess and TraceThread next to Trace in LLDB core, guaranteeing that the "trace" process plug-in will always exist and now the source file structure looks better.

Btw, it doesn't seem to me a good idea to not have TraceProcess as a plug-in even inside LLDB core, as the main API for constructing processes in Target assumes that all processes are plug-ins. I'd rather keep one single simple API instead of having two or more.

[labath]

In D89408#2333502, @wallace wrote:

Addressed the issues that @labath pointed out regarding the TraceProcess and TraceThread:

• These classes were not together
• TraceProcess was an optional plug-in, which would break the Trace parsing logic if plugged-out

So I ended up moving TraceProcess and TraceThread next to Trace in LLDB core, guaranteeing that the "trace" process plug-in will always exist and now the source file structure looks better.

Yes, that looks better. My only quibble is about the naming. The prevailing lldb convention is to add a suffix to the subclass name, not prefix. So I think we should standardize on ProcessTrace & ThreadTrace and not the other way around.

Btw, it doesn't seem to me a good idea to not have TraceProcess as a plug-in even inside LLDB core, as the main API for constructing processes in Target assumes that all processes are plug-ins. I'd rather keep one single simple API instead of having two or more.

Yeah, I don't think this is ideal, but it's not that bad either...

lldb/include/lldb/Target/TraceSessionFileParser.h

18

This would be better next to the definition of TraceThread class.

87–101

I don't understand the value of this function. Why couldn't the caller just call ParseProcesses(session.processes)?

Are you expecting this to grow and access other subfields of the session object? In that case, maybe it would be better for all JSONTraceSession<T>s to extend a common (non-templated) base class (JSONTraceSettingsBase?) and then this function could take a reference to that?

lldb/source/API/SystemInitializerFull.cpp

74 ↗

(On Diff #298493)

No terminate?

lldb/source/Target/TraceProcess.cpp

40 ↗

(On Diff #298493)

Maybe this should be just false? I don't think we'd ever want to create this object in response to a normal "launch" request...

[wallace]

lldb/source/Target/TraceProcess.cpp

40 ↗

(On Diff #298493)

This has to be plugin_specified_by_name, which means that this process plug-in is only used if explicitly invoked by plugin-name. A normal "launch" request would have plugin_specified_by_name as false

[wallace]

Address all comments, including the renaming of the classes

[clayborg]

LGTM. Pavel?

[vsk]

lldb/include/lldb/Target/ThreadTrace.h

34 ↗

(On Diff #298671)

const FileSpec &, or just FileSpec might be better here.

34 ↗

(On Diff #298671)

What are the constraints on the format of "trace_file"? Is it a list of PC ranges?

[wallace]

address comment

lldb/include/lldb/Target/ThreadTrace.h

34 ↗

(On Diff #298671)

The basic format is a JSON file with a schema specified in TraceSessionFileParser::BuildSchema

[vsk]

lldb/include/lldb/Target/ThreadTrace.h

34 ↗

(On Diff #298671)

Got it, thanks.

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 {
 
+typedef std::shared_ptr<TraceThread> TraceThreadSP;
+
 /// \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:
   /// 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,
+  /// Helper struct holding the objects created when parsing a process
+  struct ParsedProcess {
+    lldb::TargetSP target_sp;
+    std::vector<TraceThreadSP> threads;
+  };
+
+  TraceSessionFileParser(Debugger &debugger, llvm::StringRef session_file_dir,
                          llvm::StringRef schema)
-      : m_session_file_dir(session_file_dir), m_schema(schema) {}
+      : m_debugger(debugger), 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);
 
+  /// Parse the fields common to all trace session schemas.
+  ///
+  /// \param[in] session
+  ///     The session json objects already deserialized.
+  ///
+  /// \return
+  ////    A list of \a ParsedProcess containing all threads and targets created
+  ///during the parsing, or an error in case of failures. In case of errors, no
+  ///side effects are produced.
+  template <class TPluginSettings>
+  llvm::Expected<std::vector<ParsedProcess>>
+  ParseSessionFile(const JSONTraceSession<TPluginSettings> &session) {
+    return ParseProcesses(session.processes);
+  }
+
 protected:
   /// Resolve non-absolute paths relative to the session file folder. It
   /// modifies the given file_spec.
   void NormalizePath(lldb_private::FileSpec &file_spec);
 
+  TraceThreadSP ParseThread(lldb::ProcessSP &process_sp,
+                            const JSONThread &thread);
+
+  llvm::Expected<ParsedProcess> ParseProcess(const JSONProcess &process);
+
+  llvm::Expected<std::vector<ParsedProcess>>
+  ParseProcesses(const std::vector<JSONProcess> &processes);
+
   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);
 
+  Debugger &m_debugger;
   std::string m_session_file_dir;
   llvm::StringRef m_schema;
 };
 } // namespace lldb_private
 
 namespace llvm {
 namespace json {
 

lldb/include/lldb/Target/TraceThread.h

+//===-- TraceThread.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_TRACETHREAD_H
+#define LLDB_TARGET_TRACETHREAD_H
+
+#include "lldb/Target/Thread.h"
+
+namespace lldb_private {
+
+/// \class TraceThread TraceThread.h
+///
+/// Thread implementation used for representing threads gotten from trace
+/// session files, which are similar to threads from core files.
+///
+/// See \a TraceSessionFileParser for more information regarding trace session
+/// files.
+class TraceThread : public Thread {
+public:
+  /// \param[in] process
+  ///     The process who owns this thread.
+  ///
+  /// \param[in] tid
+  ///     The tid of this thread.
+  ///
+  /// \param[in] trace_file.
+  ///     The file that contains the list of instructions that were traced when
+  ///     this thread was being executed.
+  TraceThread(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;
+
+  /// \return
+  ///   The trace file of this thread.
+  const FileSpec &GetTraceFile() const;
+
+protected:
+  bool CalculateStopInfo() override;
+
+  lldb::RegisterContextSP m_thread_reg_ctx_sp;
+
+private:
+  FileSpec m_trace_file;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_TARGET_TRACETHREAD_H

lldb/include/lldb/lldb-forward.h

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

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
   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/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 "intel-pt.h"
 #include "llvm/ADT/Optional.h"
 
 #include "TraceIntelPTSessionFileParser.h"
 #include "lldb/Target/Trace.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 namespace trace_intel_pt {
public:
   ///     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);
 
-  /// Create an instance of this class.
-  ///
-  /// \param[in] pt_cpu
-  ///     The libipt.h cpu information needed for decoding correctling the
-  ///     traces.
-  ///
-  /// \param[in] targets
-  ///     The list of targets to associate with this trace instance
-  ///
-  /// \return
-  ///     An intel-pt trace instance.
-  static lldb::TraceSP
-  CreateInstance(const pt_cpu &pt_cpu,
-                 const std::vector<lldb::TargetSP> &targets);
-
   static ConstString GetPluginNameStatic();
 
   uint32_t GetPluginVersion() override;
   /// \}
 
   llvm::StringRef GetSchema() override;
 
 private:
-  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);
-  }
+  friend class TraceIntelPTSessionFileParser;
+
+  /// \param[in] trace_threads
+  ///     TraceThread instances, which are not live-processes and whose trace
+  ///     files are fixed.
+  TraceIntelPT(const pt_cpu &pt_cpu,
+               const std::vector<std::shared_ptr<TraceThread>> &traced_threads);
 
   pt_cpu m_pt_cpu;
-  std::vector<std::weak_ptr<Target>> m_targets;
+  std::map<std::pair<lldb::pid_t, lldb::tid_t>, std::shared_ptr<TraceThread>>
+      m_trace_threads;
 };
 
 } // 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 "TraceIntelPTSessionFileParser.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Target/TraceThread.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::trace_intel_pt;
 using namespace llvm;
 
 LLDB_PLUGIN_DEFINE(TraceIntelPT)
 

 Expected<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();
 }
 
-TraceSP TraceIntelPT::CreateInstance(const pt_cpu &pt_cpu,
-                                     const std::vector<TargetSP> &targets) {
-  TraceSP trace_instance(new TraceIntelPT(pt_cpu, targets));
-  for (const TargetSP &target_sp : targets)
-    target_sp->SetTrace(trace_instance);
-
-  return trace_instance;
+TraceIntelPT::TraceIntelPT(
+    const pt_cpu &pt_cpu,
+    const std::vector<std::shared_ptr<TraceThread>> &traced_threads)
+    : m_pt_cpu(pt_cpu) {
+  for (const std::shared_ptr<TraceThread> &thread : traced_threads)
+    m_trace_threads.emplace(
+        std::make_pair(thread->GetProcess()->GetID(), thread->GetID()), thread);
 }

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;
 
struct JSONTraceIntelPTSettings
     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) {}
+      : TraceSessionFileParser(debugger, session_file_dir, GetSchema()),
+        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);
+  lldb::TraceSP
+  CreateTraceIntelPTInstance(const pt_cpu &pt_cpu,
+                             std::vector<ParsedProcess> &parsed_processes);
 
-  void ParseThread(lldb::ProcessSP &process_sp,
-                   const TraceSessionFileParser::JSONThread &thread);
-
-  void ParsePTCPU(const JSONPTCPU &pt_cpu);
+private:
+  pt_cpu 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 {
 

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"
+#include "lldb/Target/ThreadList.h"
+#include "lldb/Target/TraceThread.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 =
-      std::make_shared<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, "trace",
-      /*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;
-  }
-
-  if (!process.threads.empty())
-    process_sp->GetThreadList().SetSelectedThreadByIndexID(0);
-
-  // We invoke DidAttach to create a correct stopped state for the process and
-  // its threads.
-  ArchSpec process_arch;
-  process_sp->DidAttach(process_arch);
-
-  return llvm::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)};
+pt_cpu TraceIntelPTSessionFileParser::ParsePTCPU(const JSONPTCPU &pt_cpu) {
+  return {pt_cpu.vendor.compare("intel") == 0 ? pcv_intel : pcv_unknown,
 }
 
-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);
-  }
+TraceSP TraceIntelPTSessionFileParser::CreateTraceIntelPTInstance(
+    const pt_cpu &pt_cpu, std::vector<ParsedProcess> &parsed_processes) {
+  std::vector<TraceThreadSP> threads;
+  for (const ParsedProcess &parsed_process : parsed_processes)
+    threads.insert(threads.end(), parsed_process.threads.begin(),
+                   parsed_process.threads.end());
+
+  TraceSP trace_instance(new TraceIntelPT(pt_cpu, threads));
+  for (const ParsedProcess &parsed_process : parsed_processes)
+    parsed_process.target_sp->SetTrace(trace_instance);
 
-  ParsePTCPU(session.trace.pt_cpu);
-  for (const TraceSessionFileParser::JSONProcess &process : session.processes) {
-    if (Error err = ParseProcess(process))
-      return err;
-  }
-  return Error::success();
+  return trace_instance;
 }
 
 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);
-  }
+  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);
 
-  return TraceIntelPT::CreateInstance(m_pt_cpu, m_targets);
+  if (Expected<std::vector<ParsedProcess>> parsed_processes =
+          ParseSessionFile(session))
+    return CreateTraceIntelPTInstance(ParsePTCPU(session.trace.pt_cpu),
+                                      *parsed_processes);
+  else
+    return parsed_processes.takeError();
 }
 
 namespace llvm {
 namespace json {
 
 bool fromJSON(const Value &value,
               TraceIntelPTSessionFileParser::JSONPTCPU &pt_cpu, Path path) {
   ObjectMapper o(value, path);

lldb/source/Target/CMakeLists.txt

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

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/Debugger.h"
 #include "lldb/Core/Module.h"
+#include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Target/TraceThread.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);
+
+  if (error.Fail())
     return error.ToError();
+
+  bool load_addr_changed = false;
+  module_sp->SetLoadAddress(*target_sp, module.load_address.value, false,
+                            load_addr_changed);
+  return llvm::Error::success();
 }
 
 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::string TraceSessionFileParser::BuildSchema(StringRef plugin_schema) {
   ]
   // Notes:
   // All paths are either absolute or relative to the session file.
 }
 )";
   return schema_builder.str();
 }
 
+TraceThreadSP TraceSessionFileParser::ParseThread(ProcessSP &process_sp,
+                                                  const JSONThread &thread) {
+  lldb::tid_t tid = static_cast<lldb::tid_t>(thread.tid);
+
+  FileSpec trace_file(thread.trace_file);
+  NormalizePath(trace_file);
+
+  TraceThreadSP thread_sp =
+      std::make_shared<TraceThread>(*process_sp, tid, trace_file);
+  process_sp->GetThreadList().AddThread(thread_sp);
+  return thread_sp;
+}
+
+Expected<TraceSessionFileParser::ParsedProcess>
+TraceSessionFileParser::ParseProcess(const 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();
+
+  ParsedProcess parsed_process;
+  parsed_process.target_sp = target_sp;
+
+  m_debugger.GetTargetList().SetSelectedTarget(target_sp.get());
+
+  ProcessSP process_sp(target_sp->CreateProcess(
+      /*listener*/ nullptr, "trace",
+      /*crash_file*/ nullptr));
+  process_sp->SetID(static_cast<lldb::pid_t>(process.pid));
+
+  for (const JSONThread &thread : process.threads)
+    parsed_process.threads.push_back(ParseThread(process_sp, thread));
+
+  for (const JSONModule &module : process.modules)
+    if (Error err = ParseModule(target_sp, module))
+      return std::move(err);
+
+  if (!process.threads.empty())
+    process_sp->GetThreadList().SetSelectedThreadByIndexID(0);
+
+  // We invoke DidAttach to create a correct stopped state for the process and
+  // its threads.
+  ArchSpec process_arch;
+  process_sp->DidAttach(process_arch);
+
+  return parsed_process;
+}
+
+Expected<std::vector<TraceSessionFileParser::ParsedProcess>>
+TraceSessionFileParser::ParseProcesses(
+    const std::vector<JSONProcess> &processes) {
+  std::vector<ParsedProcess> parsed_processes;
+
+  auto onError = [&]() {
+    // Delete all targets that were created so far in case of failures
+    for (ParsedProcess &parsed_process : parsed_processes)
+      m_debugger.GetTargetList().DeleteTarget(parsed_process.target_sp);
+  };
+
+  for (const JSONProcess &process : processes) {
+    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;

lldb/source/Target/TraceThread.cpp

-//===-- ThreadIntelPT.cpp -------------------------------------------------===//
+//===-- TraceThread.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 "lldb/Target/TraceThread.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() {}
+void TraceThread::RefreshStateAfterStop() {}
 
-RegisterContextSP ThreadIntelPT::GetRegisterContext() {
+RegisterContextSP TraceThread::GetRegisterContext() {
   if (!m_reg_context_sp)
     m_reg_context_sp = CreateRegisterContextForFrame(nullptr);
 
   return m_reg_context_sp;
 }
 
 RegisterContextSP
-ThreadIntelPT::CreateRegisterContextForFrame(StackFrame *frame) {
+TraceThread::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; }
+bool TraceThread::CalculateStopInfo() { return false; }
+
+const FileSpec &TraceThread::GetTraceFile() const { return m_trace_file; }