[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.

89–103

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

77

No terminate?

lldb/source/Plugins/Process/Trace/ProcessTrace.cpp

40

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/Plugins/Process/Trace/ProcessTrace.cpp

40

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

35

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

35

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

35

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

[vsk]

lldb/include/lldb/Target/ThreadTrace.h

35

Got it, thanks.

lldb/include/lldb/Target/ProcessTrace.h

 //===-- ProcessTrace.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLDB_SOURCE_PLUGINS_PROCESS_TRACE_PROCESSTRACE_H
-#define LLDB_SOURCE_PLUGINS_PROCESS_TRACE_PROCESSTRACE_H
+#ifndef LLDB_TARGET_PROCESSTRACE_H
+#define LLDB_TARGET_PROCESSTRACE_H
 
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 
 namespace lldb_private {
-namespace process_trace {
 
 class ProcessTrace : public Process {
 public:
-  static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
-                                        lldb::ListenerSP listener_sp,
-                                        const FileSpec *crash_file_path);
-
   static void Initialize();
 
   static void Terminate();
 
   static ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
public:
 
   bool GetProcessInfo(ProcessInstanceInfo &info) override;
 
 protected:
   void Clear();
 
   bool UpdateThreadList(ThreadList &old_thread_list,
                         ThreadList &new_thread_list) override;
+
+private:
+  static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
+                                        lldb::ListenerSP listener_sp,
+                                        const FileSpec *crash_file_path);
 };
 
-} // namespace process_trace
 } // namespace lldb_private
 
-#endif // LLDB_SOURCE_PLUGINS_PROCESS_TRACE_PROCESSTRACE_H
+#endif // LLDB_TARGET_PROCESSTRACE_H

lldb/include/lldb/Target/ThreadTrace.h

+//===-- ThreadTrace.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_THREADTRACE_H
+#define LLDB_TARGET_THREADTRACE_H
+
+#include "lldb/Target/Thread.h"
+
+namespace lldb_private {
+
+/// \class ThreadTrace ThreadTrace.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 ThreadTrace : 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.
+  ThreadTrace(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;
+};
+
+typedef std::shared_ptr<ThreadTrace> ThreadTraceSP;
+
+} // namespace lldb_private
+
+#endif // LLDB_TARGET_THREADTRACE_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"
+#include "lldb/Target/ThreadTrace.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:
struct JSONProcess {
     std::vector<JSONThread> threads;
     std::vector<JSONModule> modules;
   };
 
   struct JSONTracePluginSettings {
     std::string type;
   };
 
+  struct JSONTraceSessionBase {
+    std::vector<JSONProcess> processes;
+  };
+
   /// The trace plug-in implementation should provide its own TPluginSettings,
   /// which corresponds to the "trace" section of the schema.
-  template <class TPluginSettings> struct JSONTraceSession {
-    std::vector<JSONProcess> processes;
+  template <class TPluginSettings>
+  struct JSONTraceSession : JSONTraceSessionBase {
     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<ThreadTraceSP> 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.
+  llvm::Expected<std::vector<ParsedProcess>>
+  ParseCommonSessionFile(const JSONTraceSessionBase &session);
+
 protected:
   /// Resolve non-absolute paths relative to the session file folder. It
   /// modifies the given file_spec.
   void NormalizePath(lldb_private::FileSpec &file_spec);
 
+  ThreadTraceSP ParseThread(lldb::ProcessSP &process_sp,
+                            const JSONThread &thread);
+
+  llvm::Expected<ParsedProcess> ParseProcess(const JSONProcess &process);
+
   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 {
 
bool fromJSON(const Value &value,
               lldb_private::TraceSessionFileParser::JSONProcess &process,
               Path path);
 
 bool fromJSON(const Value &value,
               lldb_private::TraceSessionFileParser::JSONTracePluginSettings
                   &plugin_settings,
               Path path);
 
+bool fromJSON(
+    const Value &value,
+    lldb_private::TraceSessionFileParser::JSONTraceSessionBase &session,
+    Path path);
+
 template <class TPluginSettings>
 bool fromJSON(
     const Value &value,
     lldb_private::TraceSessionFileParser::JSONTraceSession<TPluginSettings>
         &session,
     Path path) {
   ObjectMapper o(value, path);
   return o && o.map("trace", session.trace) &&
-         o.map("processes", session.processes);
+         fromJSON(value,
+                  (lldb_private::TraceSessionFileParser::JSONTraceSessionBase &)
+                      session,
+                  path);
 }
 
 } // namespace json
 } // namespace llvm
 
 #endif // LLDB_TARGET_TRACESESSIONPARSER_H

lldb/include/lldb/lldb-forward.h

 class ThreadPlanRunToAddress;
 class ThreadPlanStepInstruction;
 class ThreadPlanStepOut;
 class ThreadPlanStepOverBreakpoint;
 class ThreadPlanStepRange;
 class ThreadPlanStepThrough;
 class ThreadPlanTracer;
 class ThreadSpec;
+class ThreadTrace;
 class Trace;
 class TraceSessionFileParser;
 class TraceOptions;
 class Type;
 class TypeAndOrName;
 class TypeCategoryImpl;
 class TypeCategoryMap;
 class TypeEnumMemberImpl;

lldb/source/API/SystemInitializerFull.cpp

 //===-- SystemInitializerFull.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 "SystemInitializerFull.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Initialization/SystemInitializerCommon.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Target/ProcessTrace.h"
 #include "lldb/Utility/Timer.h"
 #include "llvm/Support/TargetSelect.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wglobal-constructors"
 #include "llvm/ExecutionEngine/MCJIT.h"
 #pragma clang diagnostic pop
 
llvm::Error SystemInitializerFull::Initialize() {
   llvm::InitializeAllTargets();
   llvm::InitializeAllAsmPrinters();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllDisassemblers();
 
 #define LLDB_PLUGIN(p) LLDB_PLUGIN_INITIALIZE(p);
 #include "Plugins/Plugins.def"
 
+  // Initialize plug-ins in core LLDB
+  ProcessTrace::Initialize();
+
   // Scan for any system or user LLDB plug-ins
   PluginManager::Initialize();
 
   // The process settings need to know about installed plug-ins, so the
   // Settings must be initialized AFTER PluginManager::Initialize is called.
   Debugger::SettingsInitialize();
 
   return llvm::Error::success();
 }
 
 void SystemInitializerFull::Terminate() {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
 
   Debugger::SettingsTerminate();
 
+  // Terminate plug-ins in core LLDB
+  ProcessTrace::Terminate();
+
   // Terminate and unload and loaded system or user LLDB plug-ins
   PluginManager::Terminate();
 
 #define LLDB_PLUGIN(p) LLDB_PLUGIN_TERMINATE(p);
 #include "Plugins/Plugins.def"
 
   // Now shutdown the common parts, in reverse order.
   SystemInitializerCommon::Terminate();
 }

lldb/source/Plugins/Process/CMakeLists.txt

 elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   add_subdirectory(MacOSX-Kernel)
 endif()
 add_subdirectory(gdb-remote)
 add_subdirectory(Utility)
 add_subdirectory(elf-core)
 add_subdirectory(mach-core)
 add_subdirectory(minidump)
-add_subdirectory(Trace)

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

-add_lldb_library(lldbPluginProcessTrace PLUGIN
-  ProcessTrace.cpp
-
-  LINK_LIBS
-    lldbCore
-    lldbTarget
-    lldbUtility
-    lldbPluginProcessUtility
-  LINK_COMPONENTS
-    BinaryFormat
-    Object
-    Support
-  )

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

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
+  ///     ThreadTrace instances, which are not live-processes and whose trace
+  ///     files are fixed.
+  TraceIntelPT(const pt_cpu &pt_cpu,
+               const std::vector<std::shared_ptr<ThreadTrace>> &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<ThreadTrace>>
+      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/ThreadTrace.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<ThreadTrace>> &traced_threads)
+    : m_pt_cpu(pt_cpu) {
+  for (const std::shared_ptr<ThreadTrace> &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/ThreadTrace.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<ThreadTraceSP> 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 =
+          ParseCommonSessionFile(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
   Memory.cpp
   MemoryHistory.cpp
   MemoryRegionInfo.cpp
   ModuleCache.cpp
   OperatingSystem.cpp
   PathMappingList.cpp
   Platform.cpp
   Process.cpp
+  ProcessTrace.cpp
   Queue.cpp
   QueueItem.cpp
   QueueList.cpp
   RegisterContext.cpp
   RegisterContextUnwind.cpp
   RegisterNumber.cpp
   RemoteAwarePlatform.cpp
   SectionLoadHistory.cpp
add_lldb_library(lldbTarget
   ThreadPlanStepOverBreakpoint.cpp
   ThreadPlanStepOverRange.cpp
   ThreadPlanStepRange.cpp
   ThreadPlanStepThrough.cpp
   ThreadPlanStepUntil.cpp
   ThreadPlanTracer.cpp
   ThreadPlanStack.cpp
   ThreadSpec.cpp
+  ThreadTrace.cpp
   Trace.cpp
   TraceSessionFileParser.cpp
   UnixSignals.cpp
   UnwindAssembly.cpp
   UnwindLLDB.cpp
 
   LINK_LIBS
     lldbBreakpoint

lldb/source/Target/ProcessTrace.cpp

 //===-- ProcessTrace.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 "ProcessTrace.h"
+#include "lldb/Target/ProcessTrace.h"
 
 #include <memory>
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
-using namespace lldb_private::process_trace;
-
-LLDB_PLUGIN_DEFINE(ProcessTrace)
 
 ConstString ProcessTrace::GetPluginNameStatic() {
   static ConstString g_name("trace");
   return g_name;
 }
 
 const char *ProcessTrace::GetPluginDescriptionStatic() {
   return "Trace process plug-in.";
 }
 
 void ProcessTrace::Terminate() {
   PluginManager::UnregisterPlugin(ProcessTrace::CreateInstance);
 }
 
 ProcessSP ProcessTrace::CreateInstance(TargetSP target_sp,
                                        ListenerSP listener_sp,
                                        const FileSpec *crash_file) {
   return std::make_shared<ProcessTrace>(target_sp, listener_sp);
 }
 
 bool ProcessTrace::CanDebug(TargetSP target_sp, bool plugin_specified_by_name) {
   return plugin_specified_by_name;
 }
 
 ProcessTrace::ProcessTrace(TargetSP target_sp, ListenerSP listener_sp)
     : Process(target_sp, listener_sp) {}
 
 ProcessTrace::~ProcessTrace() {
   Clear();
   // We need to call finalize on the process before destroying ourselves to

lldb/source/Target/ThreadTrace.cpp

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

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/ThreadTrace.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);
std::string TraceSessionFileParser::BuildSchema(StringRef plugin_schema) {
   ]
   // Notes:
   // All paths are either absolute or relative to the session file.
 }
 )";
   return schema_builder.str();
 }
 
+ThreadTraceSP 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);
+
+  ThreadTraceSP thread_sp =
+      std::make_shared<ThreadTrace>(*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::ParseCommonSessionFile(
+    const JSONTraceSessionBase &session) {
+  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 : session.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;

 
 bool fromJSON(const Value &value,
               TraceSessionFileParser::JSONTracePluginSettings &plugin_settings,
               Path path) {
   ObjectMapper o(value, path);
   return o && o.map("type", plugin_settings.type);
 }
 
+bool fromJSON(const Value &value,
+              TraceSessionFileParser::JSONTraceSessionBase &session,
+              Path path) {
+  ObjectMapper o(value, path);
+  return o && o.map("processes", session.processes);
+}
+
 } // namespace json
 } // namespace llvm