[intel-pt] Refactor 3: refactor PTDecoder into SBPTProcess

[wallace]

Summary

Depends on D85070.
I don't think PTDecoder is structured very well, and the name is also misleading,
as it doesn't just "decode". Given that the Python API generation has been
broken for a long time and that one of my recent patches fixes it, I assume
there's no problem in changing the API, as there has been no users.

A first fundamental change I want to do is to stop having PTDecoder as a top
level class that receives an SBProcess for any action it needs to do. The
existing way requires a good amount of boilerplate code here and there with
little to no benefit.
Instead, I'm renaming it into SBPTProcess. I think the SB is consistent with the
LLDB SB API, and this class now directly manages one SBProcess. This means that
whenever you want to trace or decode an SBProcess, you create a SBPTProcess
class, which is easier to reason about in an OOP way.

I've updated the test accordingly, and I've noticed that the code is now much
simpler, with less faiture points and checks.

[wallace]

After syncing up with Greg, we decided to redo this in a different way

lldb/test/API/tools/intel-features/intel-pt/test/TestIntelPTSimpleBinary.py

def test_basic_flow_with_python_api(self):
         """Test collection, decoding, and dumping instructions using the Python API"""
 
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # We will start tracing from main
         lldbutil.run_to_name_breakpoint(self, "main", exe_name=exe)
 
-        decoder = lldbIntelFeatures.PTDecoder(self.dbg)
-
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
         tid = process.GetProcessID()
+        ptprocess = lldbIntelFeatures.SBPTProcess(process)
+
 
         # We configure the tracing options
-        trace_opts = lldbIntelFeatures.PTDecoder.GetDefaultTraceOptions()
+        trace_opts = lldbIntelFeatures.SBPTProcess.GetDefaultTraceOptions()
         trace_opts.setThreadID(tid)
 
         # We start tracing
         error = lldb.SBError()
-        decoder.StartProcessorTrace(process, trace_opts, error)
+        ptprocess.StartProcessorTrace(trace_opts, error)
         self.assertSuccess(error)
 
         # We check the trace after the for loop
         self.runCmd("b " + str(line_number('main.cpp', '// Break 1')))
         self.runCmd("c")
 
         # We'll check repeteadly until the trace is available
         def getInstructions():
             instruction_list = lldbIntelFeatures.PTInstructionList()
-            decoder.GetInstructionLogAtOffset(
-                process, tid, offset=99, count=100, result_list=instruction_list, sberror=error)
+            ptprocess.GetInstructionLogAtOffset(
+                tid, offset=99, count=100, result_list=instruction_list, sberror=error)
             if error.Fail() or instruction_list.GetSize() == 0:
                 return None
             return instruction_list
 
         instruction_list = self.waitUntilNotNone(getInstructions)
 
         # We assert we executed the "fun" function in the trace
         addresses = set()
         for i in range(0, instruction_list.GetSize()):
             insn = instruction_list.GetInstructionAtIndex(i)
             addresses.add(insn.GetInsnAddress())
         self.assertIn(self.find_start_address_of_function(target, "fun"), addresses)
 
         # We assert stopping the trace works
-        decoder.StopProcessorTrace(process, error, tid)
+        ptprocess.StopProcessorTrace(error, tid)
         self.assertSuccess(error)

lldb/tools/intel-features/intel-pt/include/intel-pt/API/SBPTProcess.h

-//===-- PTDecoder.h ---------------------------------------------*- C++ -*-===//
+//===-- SBPTProcess.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_INTEL_PT_API_PT_DECODER_H
-#define LLDB_INTEL_PT_API_PT_DECODER_H
+#ifndef LLDB_INTEL_PT_API_SB_PT_PROCESS_H
+#define LLDB_INTEL_PT_API_SB_PT_PROCESS_H
 
 // C/C++ Includes
 #include <vector>
 
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBTraceOptions.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-types.h"
 
 namespace intelpt_private {
 class Instruction;
 class InstructionList;
 class TraceOptions;
-class Decoder;
+class PTProcess;
 } // namespace intelpt_private
 
 namespace intelpt {
 
 /// \class PTInstruction
 /// Represents an assembly instruction containing raw
 ///     instruction bytes, instruction address along with information
 ///     regarding execution flow context and Intel(R) Processor Trace
public:
   size_t GetSize() const;
 
   // Get instruction at index
   PTInstruction GetInstructionAtIndex(uint32_t idx);
 
   void Clear();
 
 private:
-  friend class PTDecoder;
+  friend class SBPTProcess;
 
   void SetSP(const std::shared_ptr<intelpt_private::InstructionList> &ptr);
 
   std::shared_ptr<intelpt_private::InstructionList> m_opaque_sp;
 };
 
 /// \class PTTraceOptions
 /// Provides configuration options like trace type, trace buffer size,
public:
   /// 64-bit unsigned integer in hex format. For "Name", please refer to
   /// SBProcess::StartTrace API description for setting SBTraceOptions.
   ///
   /// \return
   ///     A string formatted as json text {"Name":Value,"Name":Value}
   lldb::SBStructuredData GetTraceParams(lldb::SBError &error);
 
 private:
-  friend class PTDecoder;
+  friend class SBPTProcess;
 
   void SetSP(const std::shared_ptr<intelpt_private::TraceOptions> &ptr);
 
   std::shared_ptr<intelpt_private::TraceOptions> m_opaque_sp;
 };
 
-/// \class PTDecoder
+/// \class PTProcess
 /// This class makes use of Intel(R) Processor Trace hardware feature
 ///     (implememted inside LLDB) to gather trace data for an inferior (being
 ///     debugged with LLDB) to provide meaningful information out of it.
 ///
 ///     Currently the meaningful information comprises of the execution flow
 ///     of the inferior (in terms of assembly instructions executed). The class
 ///     enables user to:
 ///     - start the trace with configuration options for a thread/process,
 ///     - stop the trace for a thread/process,
 ///     - get the execution flow (assembly instructions) for a thread and
 ///     - get trace specific information for a thread
-class PTDecoder {
+class SBPTProcess {
 public:
-  PTDecoder(lldb::SBDebugger &sbdebugger);
+  SBPTProcess(lldb::SBProcess &process);
+
+  SBPTProcess();
 
   /// Start Intel(R) Processor Trace on a thread or complete process with
   /// Intel(R) Processor Trace specific configuration options
   ///
-  /// \param[in] sbprocess
-  ///     A valid process on which this operation will be performed. An error is
-  ///     returned in case of an invalid process.
-  ///
   /// \param[in] sbtraceoptions
   ///     Contains thread id information and configuration options:
   ///
   ///     For tracing a single thread, provide a valid thread id. If sbprocess
   ///     doesn't contain this thread id, error will be returned. For tracing
   ///     complete process, set it to lldb::LLDB_INVALID_THREAD_ID
   ///     Configuration options comprises of:
   ///     a) trace buffer size, meta data buffer size, TraceType and
public:
   ///     feature may round off invalid values for configuration options.
   ///     Therefore, the configuration options with which the trace was actually
   ///     started, might be different to the ones with which trace was asked to
   ///     be started by user. The actual used configuration options can be
   ///     obtained from GetProcessorTraceInfo() API.
   ///
   /// \param[out] sberror
   ///     An error with the failure reason if API fails. Else success.
-  void StartProcessorTrace(lldb::SBProcess &sbprocess,
-                           lldb::SBTraceOptions &sbtraceoptions,
+  void StartProcessorTrace(lldb::SBTraceOptions &sbtraceoptions,
                            lldb::SBError &sberror);
 
   /// Stop Intel(R) Processor Trace on a thread or complete process.
   ///
-  /// \param[in] sbprocess
-  ///     A valid process on which this operation will be performed. An error is
-  ///     returned in case of an invalid process.
-  ///
   /// \param[in] tid
   ///     Case 1: To stop tracing a single thread, provide a valid thread id. If
   ///     sbprocess doesn't contain the thread tid, error will be returned.
   ///     Case 2: To stop tracing complete process, use
   ///     lldb::LLDB_INVALID_THREAD_ID.
   ///
   /// \param[out] sberror
   ///     An error with the failure reason if API fails. Else success.
-  void StopProcessorTrace(lldb::SBProcess &sbprocess, lldb::SBError &sberror,
+  void StopProcessorTrace(lldb::SBError &sberror,
                           lldb::tid_t tid = LLDB_INVALID_THREAD_ID);
 
   /// Get instruction log containing the execution flow for a thread of a
   /// process in terms of assembly instructions executed.
   ///
-  /// \param[in] sbprocess
-  ///     A valid process on which this operation will be performed. An error is
-  ///     returned in case of an invalid process.
-  ///
   /// \param[in] tid
   ///     A valid thread id of the thread for which instruction log is desired.
   ///     If sbprocess doesn't contain the thread tid, error will be returned.
   ///
   /// \param[in] count
   ///     The number of instructions requested by the user to be returned from
   ///     the complete instruction log. Complete instruction log refers to all
   ///     the assembly instructions obtained after decoding the complete raw
public:
   ///     instruction is at offset 0 (zero)).
   ///
   /// \param[out] result_list
   ///     Depending upon 'count' and 'offset' values, list will be overwritten
   ///     with the new instructions.
   ///
   /// \param[out] sberror
   ///     An error with the failure reason if API fails. Else success.
-  void GetInstructionLogAtOffset(lldb::SBProcess &sbprocess, lldb::tid_t tid,
-                                 uint32_t offset, uint32_t count,
-                                 PTInstructionList &result_list,
+  void GetInstructionLogAtOffset(lldb::tid_t tid, uint32_t offset,
+                                 uint32_t count, PTInstructionList &result_list,
                                  lldb::SBError &sberror);
 
   /// Get Intel(R) Processor Trace specific information for a thread of a
   /// process. The information contains the actual configuration options with
   /// which the trace was started for this thread.
   ///
-  /// \param[in] sbprocess
-  ///     A valid process on which this operation will be performed. An error is
-  ///     returned in case of an invalid process.
-  ///
   /// \param[in] tid
   ///     A valid thread id of the thread for which the trace specific
   ///     information is required. If sbprocess doesn't contain the thread tid,
   ///     an error will be returned.
   ///
   /// \param[out] options
   ///     Contains actual configuration options (they may be different to the
   ///     ones with which tracing was asked to be started for this thread during
   ///     StartProcessorTrace() API call).
   ///
   /// \param[out] sberror
   ///     An error with the failure reason if API fails. Else success.
-  void GetProcessorTraceInfo(lldb::SBProcess &sbprocess, lldb::tid_t tid,
-                             PTTraceOptions &options, lldb::SBError &sberror);
+  void GetProcessorTraceInfo(lldb::tid_t tid, PTTraceOptions &options,
+                             lldb::SBError &sberror);
 
   /// Get an instance of an \a lldb::SBTraceOptions object with a default
   /// configuration for tracing with Intel(R) Processor Trace. This object
-  /// is ready to be passed as argument to \a PTDecoder::StartProcessorTrace.
+  /// is ready to be passed as argument to \a SBPTProcess::StartProcessorTrace.
   ///
   /// The default configuration sets 4096 bytes as trace buffer size per thread.
   /// Besides, this configuration traces all the running threads of the target
   /// process.
   ///
   /// \return
   ///     An \a lldb::SBTraceOptions object with a default tracing
   ///     configuration.
   static lldb::SBTraceOptions GetDefaultTraceOptions();
 
 private:
-  std::shared_ptr<intelpt_private::Decoder> m_opaque_sp;
+  std::shared_ptr<intelpt_private::PTProcess> m_opaque_sp;
 };
 
 } // namespace intelpt
-#endif // LLDB_INTEL_PT_API_PT_DECODER_H
+#endif // LLDB_INTEL_PT_API_SB_PT_PROCESS_H

lldb/tools/intel-features/intel-pt/include/intel-pt/API/cli-wrapper-pt.h

 //===-- cli-wrapper-pt.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
 //
-// CLI Wrapper of PTDecoder Tool to enable it to be used through LLDB's CLI.
+// CLI Wrapper of PTProcess Tool to enable it to be used through LLDB's CLI.
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBDebugger.h"
 
 bool PTPluginInitialize(lldb::SBDebugger &debugger);

lldb/tools/intel-features/intel-pt/include/intel-pt/Core/PTProcess.h

-//===-- Decoder.h -----------------------------------------------*- C++ -*-===//
+//===-- PTProcess.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_INTEL_PT_CORE_DECODER_H
-#define LLDB_INTEL_PT_CORE_DECODER_H
+#ifndef LLDB_INTEL_PT_CORE_PT_PROCESS_H
+#define LLDB_INTEL_PT_CORE_PT_PROCESS_H
 
 // C/C++ Includes
 #include <map>
 #include <mutex>
 #include <string>
 #include <vector>
 
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/API/SBTrace.h"
 #include "lldb/API/SBTraceOptions.h"
 #include "lldb/lldb-enumerations.h"
public:
   /// \param[in] size
   ///     Value to be set.
   void setInstructionLogSize(uint32_t size) { m_insn_log_size = size; }
 
 private:
   uint32_t m_insn_log_size;
 };
 
-/// \class Decoder
+/// \class PTProcess
 /// This class makes use of Intel(R) Processor Trace hardware feature
-///     (implememted inside LLDB) to gather trace data for an inferior (being
+///     (implemented inside LLDB) to gather trace data for an process (being
 ///     debugged with LLDB) to provide meaningful information out of it.
 ///
 ///     Currently the meaningful information comprises of the execution flow
 ///     of the inferior (in terms of assembly instructions executed). The class
 ///     enables user to:
 ///     - start the trace with configuration options for a thread/process,
 ///     - stop the trace for a thread/process,
 ///     - get the execution flow (assembly instructions) for a thread and
 ///     - get trace specific information for a thread
-class Decoder {
+class PTProcess {
 public:
   typedef std::vector<Instruction> Instructions;
 
-  Decoder(lldb::SBDebugger &sbdebugger)
-      : m_mapProcessUID_mapThreadID_TraceInfo_mutex(),
-        m_mapProcessUID_mapThreadID_TraceInfo(),
-        m_debugger_user_id(sbdebugger.GetID()) {}
+  PTProcess(lldb::SBProcess &process)
+      : m_mapThreadID_TraceInfo_mutex(), m_mapThreadID_TraceInfo(),
+        m_process(process) {}
 
-  ~Decoder() {}
+  ~PTProcess() {}
 
-  void StartProcessorTrace(lldb::SBProcess &sbprocess,
-                           lldb::SBTraceOptions &sbtraceoptions,
+  void StartProcessorTrace(lldb::SBTraceOptions &sbtraceoptions,
                            lldb::SBError &sberror);
 
-  void StopProcessorTrace(lldb::SBProcess &sbprocess, lldb::SBError &sberror,
+  void StopProcessorTrace(lldb::SBError &sberror,
                           lldb::tid_t tid = LLDB_INVALID_THREAD_ID);
 
-  void GetInstructionLogAtOffset(lldb::SBProcess &sbprocess, lldb::tid_t tid,
-                                 uint32_t offset, uint32_t count,
-                                 InstructionList &result_list,
+  void GetInstructionLogAtOffset(lldb::tid_t tid, uint32_t offset,
+                                 uint32_t count, InstructionList &result_list,
                                  lldb::SBError &sberror);
 
-  void GetProcessorTraceInfo(lldb::SBProcess &sbprocess, lldb::tid_t tid,
-                             TraceOptions &traceinfo, lldb::SBError &sberror);
+  void GetProcessorTraceInfo(lldb::tid_t tid, TraceOptions &traceinfo,
+                             lldb::SBError &sberror);
 
   static lldb::SBTraceOptions GetDefaultTraceOptions();
 
 private:
   class ThreadTraceInfo;
   typedef std::vector<uint8_t> Buffer;
 
   // internal class to manage inferior's read-execute section information
ReadExecuteSectionInfo(const uint64_t addr, const uint64_t offset,
         : load_address(addr), file_offset(offset), size(sz), image_path(path) {}
 
     ReadExecuteSectionInfo(const ReadExecuteSectionInfo &rxsection) = default;
   };
 
   typedef struct pt_cpu CPUInfo;
   typedef std::vector<ReadExecuteSectionInfo> ReadExecuteSectionInfos;
 
-  // Check whether the provided SBProcess belongs to the same SBDebugger with
-  // which Decoder class instance was constructed.
-  void CheckDebuggerID(lldb::SBProcess &sbprocess, lldb::SBError &sberror);
-
-  // Function to remove entries of finished processes/threads in the class
-  void RemoveDeadProcessesAndThreads(lldb::SBProcess &sbprocess);
+  // Function to remove entries of finished threads in the class
+  void RemoveDeadThreads();
 
   // Parse cpu information from trace configuration received from LLDB
   void ParseCPUInfo(CPUInfo &pt_cpu, lldb::SBStructuredData &s,
                     lldb::SBError &sberror);
 
   /// Function performs following tasks for a given process and thread:
   ///  - Checks if the given thread is registered in the class or not. If not
   ///  then tries to register it if trace was ever started on the entire
   ///  process. Else returns error.
   ///  - fetches trace and other necessary information from LLDB (using
   ///  ReadTraceDataAndImageInfo()) and decodes the trace (using
   ///  DecodeProcessorTrace())
-  void FetchAndDecode(lldb::SBProcess &sbprocess, lldb::tid_t tid,
-                      lldb::SBError &sberror,
+  void FetchAndDecode(lldb::tid_t tid, lldb::SBError &sberror,
                       ThreadTraceInfo **threadTraceInfo);
 
   // Helper function of FetchAndDecode() to get raw trace data and memory image
   // info of inferior from LLDB
-  void ReadTraceDataAndImageInfo(lldb::SBProcess &sbprocess, lldb::tid_t tid,
-                                 lldb::SBError &sberror,
+  void ReadTraceDataAndImageInfo(lldb::tid_t tid, lldb::SBError &sberror,
                                  ThreadTraceInfo &threadTraceInfo);
 
   // Helper function of FetchAndDecode() to initialize raw trace decoder and
   // start trace decoding
-  void DecodeProcessorTrace(lldb::SBProcess &sbprocess, lldb::tid_t tid,
-                            lldb::SBError &sberror,
+  void DecodeProcessorTrace(lldb::tid_t tid, lldb::SBError &sberror,
                             ThreadTraceInfo &threadTraceInfo);
 
   // Helper function of ReadTraceDataAndImageInfo() function for gathering
   // inferior's memory image info along with all dynamic libraries linked with
   // it
-  void GetTargetModulesInfo(lldb::SBTarget &sbtarget,
-                            ReadExecuteSectionInfos &readExecuteSectionInfos,
+  void GetTargetModulesInfo(ReadExecuteSectionInfos &readExecuteSectionInfos,
                             lldb::SBError &sberror);
 
   /// Helper functions of DecodeProcessorTrace() function for:
   ///  - initializing raw trace decoder (provided by Intel(R) Processor Trace
   ///    Decoding library)
   ///  - start trace decoding
   void InitializePTInstDecoder(
       struct pt_insn_decoder **decoder, struct pt_config *config,
public:
     uint32_t GetStopID() const { return m_thread_stop_id; }
 
     void SetStopID(uint32_t stop_id) { m_thread_stop_id = stop_id; }
 
     lldb::SBTrace &GetUniqueTraceInstance() { return m_trace; }
 
     void SetUniqueTraceInstance(lldb::SBTrace &trace) { m_trace = trace; }
 
-    friend class Decoder;
-
   private:
     Buffer m_pt_buffer; // raw trace buffer
     ReadExecuteSectionInfos
         m_readExecuteSectionInfos; // inferior's memory image info
     uint32_t m_thread_stop_id;     // stop id for thread
     lldb::SBTrace m_trace; // unique tracing instance of a thread/process
     CPUInfo m_pt_cpu; // cpu info of the target on which inferior is running
     Instructions m_instruction_log; // complete instruction log
   };
 
-  typedef std::map<lldb::user_id_t, ThreadTraceInfo> MapThreadID_TraceInfo;
-  typedef std::map<uint32_t, MapThreadID_TraceInfo>
-      MapProcessUID_MapThreadID_TraceInfo;
-
-  std::mutex m_mapProcessUID_mapThreadID_TraceInfo_mutex;
-  MapProcessUID_MapThreadID_TraceInfo
-      m_mapProcessUID_mapThreadID_TraceInfo; // to store trace information for
-                                             // each process and its associated
-                                             // threads
-  lldb::user_id_t m_debugger_user_id; // SBDebugger instance which is associated
-                                      // to this Decoder instance
+  // typedef std::map<lldb::user_id_t, ThreadTraceInfo> MapThreadID_TraceInfo;
+  // typedef std::map<uint32_t, MapThreadID_TraceInfo>
+  //    MapProcessUID_MapThreadID_TraceInfo;
+
+  std::mutex m_mapThreadID_TraceInfo_mutex;
+  std::map<lldb::tid_t, ThreadTraceInfo> m_mapThreadID_TraceInfo;
+
+  lldb::SBProcess m_process;
 };
 
 } // namespace intelpt_private
-#endif // LLDB_INTEL_PT_CORE_DECODER_H
+#endif // LLDB_INTEL_PT_CORE_PT_PROCESS_H

lldb/tools/intel-features/intel-pt/interface/SBPTProcess.i

 %include "stdint.i"
 
 %include "lldb/lldb-defines.h"
 %include "lldb/lldb-enumerations.h"
 %include "lldb/lldb-forward.h"
 %include "lldb/lldb-types.h"
 
 %include "lldb/API/SBDefines.h"
 
-%include "intel-pt/API/PTDecoder.h"
+%include "intel-pt/API/SBPTProcess.h"

lldb/tools/intel-features/intel-pt/source/API/CMakeLists.txt

 add_lldb_library(lldbIntelPT
-  PTDecoder.cpp
+  SBPTProcess.cpp
   cli-wrapper-pt.cpp
 
   LINK_LIBS
     lldbIntelPTCore
 )
 
 target_include_directories(lldbIntelPT PUBLIC ${INTEL_PT_INCLUDES})

lldb/tools/intel-features/intel-pt/source/API/SBPTProcess.cpp

-//===-- PTDecoder.cpp -------------------------------------------*- C++ -*-===//
+//===-- SBPTProcess.cpp -----------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "intel-pt/API/PTDecoder.h"
-#include "intel-pt/Core/Decoder.h"
+#include "intel-pt/API/SBPTProcess.h"
+#include "intel-pt/Core/PTProcess.h"
 
 using namespace intelpt;
 using namespace intelpt_private;
 
 // PTInstruction class member functions definitions
 PTInstruction::PTInstruction(
     const std::shared_ptr<intelpt_private::Instruction> &ptr)
     : m_opaque_sp(ptr) {}
return (m_opaque_sp ? m_opaque_sp->getTraceParams(error)
                       : lldb::SBStructuredData());
 }
 
 void PTTraceOptions::SetSP(
     const std::shared_ptr<intelpt_private::TraceOptions> &ptr) {
   m_opaque_sp = ptr;
 }
 
-// PTDecoder class member functions definitions
-PTDecoder::PTDecoder(lldb::SBDebugger &sbdebugger)
-    : m_opaque_sp(new intelpt_private::Decoder(sbdebugger)) {}
+// SBPTProcess class member functions definitions
+SBPTProcess::SBPTProcess(lldb::SBProcess &process)
+    : m_opaque_sp(new intelpt_private::PTProcess(process)) {}
 
-void PTDecoder::StartProcessorTrace(lldb::SBProcess &sbprocess,
-                                    lldb::SBTraceOptions &sbtraceoptions,
+SBPTProcess::SBPTProcess() : m_opaque_sp(nullptr) {}
+
+void SBPTProcess::StartProcessorTrace(lldb::SBTraceOptions &sbtraceoptions,
                                       lldb::SBError &sberror) {
   if (m_opaque_sp == nullptr) {
-    sberror.SetErrorStringWithFormat("invalid PTDecoder instance");
+    sberror.SetErrorStringWithFormat("invalid SBPTProcess instance");
     return;
   }
 
-  m_opaque_sp->StartProcessorTrace(sbprocess, sbtraceoptions, sberror);
+  m_opaque_sp->StartProcessorTrace(sbtraceoptions, sberror);
 }
 
-void PTDecoder::StopProcessorTrace(lldb::SBProcess &sbprocess,
-                                   lldb::SBError &sberror, lldb::tid_t tid) {
+void SBPTProcess::StopProcessorTrace(lldb::SBError &sberror, lldb::tid_t tid) {
   if (m_opaque_sp == nullptr) {
-    sberror.SetErrorStringWithFormat("invalid PTDecoder instance");
+    sberror.SetErrorStringWithFormat("invalid SBPTProcess instance");
     return;
   }
 
-  m_opaque_sp->StopProcessorTrace(sbprocess, sberror, tid);
+  m_opaque_sp->StopProcessorTrace(sberror, tid);
 }
 
-void PTDecoder::GetInstructionLogAtOffset(lldb::SBProcess &sbprocess,
-                                          lldb::tid_t tid, uint32_t offset,
+void SBPTProcess::GetInstructionLogAtOffset(lldb::tid_t tid, uint32_t offset,
                                             uint32_t count,
                                             PTInstructionList &result_list,
                                             lldb::SBError &sberror) {
   if (m_opaque_sp == nullptr) {
-    sberror.SetErrorStringWithFormat("invalid PTDecoder instance");
+    sberror.SetErrorStringWithFormat("invalid SBPTProcess instance");
     return;
   }
 
   std::shared_ptr<intelpt_private::InstructionList> insn_list_ptr(
       new InstructionList());
-  m_opaque_sp->GetInstructionLogAtOffset(sbprocess, tid, offset, count,
-                                         *insn_list_ptr, sberror);
+  m_opaque_sp->GetInstructionLogAtOffset(tid, offset, count, *insn_list_ptr,
+                                         sberror);
   if (!sberror.Success())
     return;
 
   result_list.SetSP(insn_list_ptr);
 }
 
-void PTDecoder::GetProcessorTraceInfo(lldb::SBProcess &sbprocess,
-                                      lldb::tid_t tid, PTTraceOptions &options,
+void SBPTProcess::GetProcessorTraceInfo(lldb::tid_t tid,
+                                        PTTraceOptions &options,
                                         lldb::SBError &sberror) {
   if (m_opaque_sp == nullptr) {
-    sberror.SetErrorStringWithFormat("invalid PTDecoder instance");
+    sberror.SetErrorStringWithFormat("invalid SBPTProcess instance");
     return;
   }
 
   std::shared_ptr<intelpt_private::TraceOptions> trace_options_ptr(
       new TraceOptions());
-  m_opaque_sp->GetProcessorTraceInfo(sbprocess, tid, *trace_options_ptr,
-                                     sberror);
+  m_opaque_sp->GetProcessorTraceInfo(tid, *trace_options_ptr, sberror);
   if (!sberror.Success())
     return;
 
   options.SetSP(trace_options_ptr);
 }
 
-lldb::SBTraceOptions PTDecoder::GetDefaultTraceOptions() {
-  return Decoder::GetDefaultTraceOptions();
+lldb::SBTraceOptions SBPTProcess::GetDefaultTraceOptions() {
+  return PTProcess::GetDefaultTraceOptions();
 }

lldb/tools/intel-features/intel-pt/source/API/cli-wrapper-pt.cpp

 //===-- cli-wrapper-pt.cpp -------------------------------------*- 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
 //
-// CLI Wrapper of PTDecoder Tool to enable it to be used through LLDB's CLI. The
+// CLI Wrapper of PTProcess Tool to enable it to be used through LLDB's CLI. The
 // wrapper provides a new command called processor-trace with 4 child
 // subcommands as follows:
 // processor-trace start
 // processor-trace stop
 // processor-trace show-trace-options
 // processor-trace show-instr-log
 //
 //===----------------------------------------------------------------------===//
 
 #include <cerrno>
 #include <cinttypes>
 #include <cstring>
+#include <map>
 #include <string>
 #include <vector>
 
-#include "intel-pt/API/PTDecoder.h"
+#include "intel-pt/API/SBPTProcess.h"
 #include "intel-pt/API/cli-wrapper-pt.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/API/SBThread.h"
 
-static bool GetProcess(lldb::SBDebugger &debugger,
+static bool GetPTProcess(lldb::SBDebugger &debugger,
                          lldb::SBCommandReturnObject &result,
-                       lldb::SBProcess &process) {
+                         lldb::SBProcess &process,
+                         intelpt::SBPTProcess &ptprocess) {
+  static std::map<uint32_t, intelpt::SBPTProcess> puid_ptprocess_map;
   if (!debugger.IsValid()) {
     result.Printf("error: invalid debugger\n");
     result.SetStatus(lldb::eReturnStatusFailed);
     return false;
   }
 
   lldb::SBTarget target = debugger.GetSelectedTarget();
   if (!target.IsValid()) {
     result.Printf("error: invalid target inside debugger\n");
     result.SetStatus(lldb::eReturnStatusFailed);
     return false;
   }
 
   process = target.GetProcess();
   if (!process.IsValid() ||
       (process.GetState() == lldb::StateType::eStateDetached) ||
       (process.GetState() == lldb::StateType::eStateExited) ||
       (process.GetState() == lldb::StateType::eStateInvalid)) {
     result.Printf("error: invalid process inside debugger's target\n");
     result.SetStatus(lldb::eReturnStatusFailed);
     return false;
   }
+  uint32_t uid = process.GetUniqueID();
+  auto it = puid_ptprocess_map.find(uid);
+  if (it != puid_ptprocess_map.end())
+    ptprocess = it->second;
+  else {
+    ptprocess = intelpt::SBPTProcess(process);
+    puid_ptprocess_map[uid] = ptprocess;
+  }
 
   return true;
 }
 
 static bool ParseCommandOption(char **command,
                                lldb::SBCommandReturnObject &result,
                                uint32_t &index, const std::string &arg,
                                uint32_t &parsed_result) {
else {
     }
     thread_id = thread.GetThreadID();
   }
   return true;
 }
 
 class ProcessorTraceStart : public lldb::SBCommandPluginInterface {
 public:
-  ProcessorTraceStart(std::shared_ptr<intelpt::PTDecoder> &pt_decoder)
-      : SBCommandPluginInterface(), pt_decoder_sp(pt_decoder) {}
+  ProcessorTraceStart() : SBCommandPluginInterface() {}
 
   ~ProcessorTraceStart() {}
 
   virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
                          lldb::SBCommandReturnObject &result) {
     lldb::SBProcess process;
     lldb::SBThread thread;
-    if (!GetProcess(debugger, result, process))
+    intelpt::SBPTProcess ptprocess;
+    if (!GetPTProcess(debugger, result, process, ptprocess))
       return false;
 
     // Default initialize API's arguments
     lldb::SBTraceOptions lldb_SBTraceOptions =
-        intelpt::PTDecoder::GetDefaultTraceOptions();
+        intelpt::SBPTProcess::GetDefaultTraceOptions();
     uint32_t trace_buffer_size = lldb_SBTraceOptions.getTraceBufferSize();
     lldb::tid_t thread_id;
 
     // Parse Command line options
     bool thread_argument_provided = false;
     if (command) {
       for (uint32_t i = 0; command[i]; i++) {
         if (!strcmp(command[i], "-b")) {
if (trace_buffer_size > m_max_trace_buff_size)
       trace_buffer_size = m_max_trace_buff_size;
 
     // Set API's arguments with parsed values
     lldb_SBTraceOptions.setTraceBufferSize(trace_buffer_size);
     lldb_SBTraceOptions.setThreadID(thread_id);
 
     // Start trace
     lldb::SBError error;
-    pt_decoder_sp->StartProcessorTrace(process, lldb_SBTraceOptions, error);
+    ptprocess.StartProcessorTrace(lldb_SBTraceOptions, error);
     if (!error.Success()) {
       result.Printf("error: %s\n", error.GetCString());
       result.SetStatus(lldb::eReturnStatusFailed);
       return false;
     }
     result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
     return true;
   }
 
 private:
-  std::shared_ptr<intelpt::PTDecoder> pt_decoder_sp;
   const uint32_t m_max_trace_buff_size = 0x3fff;
 };
 
 class ProcessorTraceInfo : public lldb::SBCommandPluginInterface {
 public:
-  ProcessorTraceInfo(std::shared_ptr<intelpt::PTDecoder> &pt_decoder)
-      : SBCommandPluginInterface(), pt_decoder_sp(pt_decoder) {}
+  ProcessorTraceInfo() : SBCommandPluginInterface() {}
 
   ~ProcessorTraceInfo() {}
 
   virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
                          lldb::SBCommandReturnObject &result) {
     lldb::SBProcess process;
     lldb::SBThread thread;
-    if (!GetProcess(debugger, result, process))
+    intelpt::SBPTProcess ptprocess;
+    if (!GetPTProcess(debugger, result, process, ptprocess))
       return false;
 
     lldb::tid_t thread_id;
 
     // Parse command line options
     bool thread_argument_provided = false;
     if (command) {
       for (uint32_t i = 0; command[i]; i++) {
for (size_t i = 0; i < loop_count; i++) {
 
       if (entire_process_tracing)
         thread = process.GetThreadAtIndex(i);
       else
         thread = process.GetThreadByID(thread_id);
       thread_id = thread.GetThreadID();
 
       intelpt::PTTraceOptions options;
-      pt_decoder_sp->GetProcessorTraceInfo(process, thread_id, options, error);
+      ptprocess.GetProcessorTraceInfo(thread_id, options, error);
       if (!error.Success()) {
         res.Printf("thread #%" PRIu32 ": tid=%" PRIu64 ", error: %s",
                    thread.GetIndexID(), thread_id, error.GetCString());
         result.AppendMessage(res.GetOutput());
         continue;
       }
 
       lldb::SBStructuredData data = options.GetTraceParams(error);
for (size_t i = 0; i < loop_count; i++) {
                  thread.GetIndexID(), thread_id, options.GetTraceBufferSize(),
                  options.GetMetaDataBufferSize(), options.GetType(),
                  s.GetData());
       result.AppendMessage(res.GetOutput());
     }
     result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
     return true;
   }
-
-private:
-  std::shared_ptr<intelpt::PTDecoder> pt_decoder_sp;
 };
 
 class ProcessorTraceShowInstrLog : public lldb::SBCommandPluginInterface {
 public:
-  ProcessorTraceShowInstrLog(std::shared_ptr<intelpt::PTDecoder> &pt_decoder)
-      : SBCommandPluginInterface(), pt_decoder_sp(pt_decoder) {}
+  ProcessorTraceShowInstrLog() : SBCommandPluginInterface() {}
 
   ~ProcessorTraceShowInstrLog() {}
 
   virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
                          lldb::SBCommandReturnObject &result) {
     lldb::SBProcess process;
     lldb::SBThread thread;
-    if (!GetProcess(debugger, result, process))
+    intelpt::SBPTProcess ptprocess;
+    if (!GetPTProcess(debugger, result, process, ptprocess))
       return false;
 
     // Default initialize API's arguments
     uint32_t offset;
     bool offset_provided = false;
     uint32_t count = m_default_count;
     lldb::tid_t thread_id;
 
for (size_t i = 0; i < loop_count; i++) {
 
       // If offset is not provided then calculate a default offset (to display
       // last 'count' number of instructions)
       if (!offset_provided)
         offset = count - 1;
 
       // Get the instruction log
       intelpt::PTInstructionList insn_list;
-      pt_decoder_sp->GetInstructionLogAtOffset(process, thread_id, offset,
-                                               count, insn_list, error);
+      ptprocess.GetInstructionLogAtOffset(thread_id, offset, count, insn_list,
+                                          error);
       if (!error.Success()) {
         res.Printf("thread #%" PRIu32 ": tid=%" PRIu64 ", error: %s",
                    thread.GetIndexID(), thread_id, error.GetCString());
         result.AppendMessage(res.GetOutput());
         continue;
       }
 
       // Disassemble the instruction log
for (size_t i = 0; i < loop_count; i++) {
       }
       result.AppendMessage(res.GetOutput());
     }
     result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
     return true;
   }
 
 private:
-  std::shared_ptr<intelpt::PTDecoder> pt_decoder_sp;
   const uint32_t m_default_count = 10;
 };
 
 class ProcessorTraceStop : public lldb::SBCommandPluginInterface {
 public:
-  ProcessorTraceStop(std::shared_ptr<intelpt::PTDecoder> &pt_decoder)
-      : SBCommandPluginInterface(), pt_decoder_sp(pt_decoder) {}
+  ProcessorTraceStop() : SBCommandPluginInterface() {}
 
   ~ProcessorTraceStop() {}
 
   virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
                          lldb::SBCommandReturnObject &result) {
     lldb::SBProcess process;
     lldb::SBThread thread;
-    if (!GetProcess(debugger, result, process))
+    intelpt::SBPTProcess ptprocess;
+    if (!GetPTProcess(debugger, result, process, ptprocess))
       return false;
 
     lldb::tid_t thread_id;
 
     // Parse command line options
     bool thread_argument_provided = false;
     if (command) {
       for (uint32_t i = 0; command[i]; i++) {
if (!thread_argument_provided) {
         result.SetStatus(lldb::eReturnStatusFailed);
         return false;
       }
       thread_id = thread.GetThreadID();
     }
 
     // Stop trace
     lldb::SBError error;
-    pt_decoder_sp->StopProcessorTrace(process, error, thread_id);
+    ptprocess.StopProcessorTrace(error, thread_id);
     if (!error.Success()) {
       result.Printf("error: %s\n", error.GetCString());
       result.SetStatus(lldb::eReturnStatusFailed);
       return false;
     }
     result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
     return true;
   }
-
-private:
-  std::shared_ptr<intelpt::PTDecoder> pt_decoder_sp;
 };
 
 bool PTPluginInitialize(lldb::SBDebugger &debugger) {
   lldb::SBCommandInterpreter interpreter = debugger.GetCommandInterpreter();
   lldb::SBCommand proc_trace = interpreter.AddMultiwordCommand(
       "processor-trace", "Intel(R) Processor Trace for thread/process");
 
-  std::shared_ptr<intelpt::PTDecoder> PTDecoderSP(
-      new intelpt::PTDecoder(debugger));
-
-  lldb::SBCommandPluginInterface *proc_trace_start =
-      new ProcessorTraceStart(PTDecoderSP);
+  lldb::SBCommandPluginInterface *proc_trace_start = new ProcessorTraceStart();
   const char *help_proc_trace_start = "start Intel(R) Processor Trace on a "
                                       "specific thread or on the whole process";
   const char *syntax_proc_trace_start =
       "processor-trace start  <cmd-options>\n\n"
       "\rcmd-options Usage:\n"
       "\r  processor-trace start [-b <buffer-size>] [<thread-index>]\n\n"
       "\t\b-b <buffer-size>\n"
       "\t    size of the trace buffer to store the trace data. If not "
       "specified then a default value will be taken\n\n"
       "\t\b<thread-index>\n"
       "\t    thread index of the thread. If no threads are specified, "
       "currently selected thread is taken.\n"
       "\t    Use the thread-index 'all' to start tracing the whole process\n";
   proc_trace.AddCommand("start", proc_trace_start, help_proc_trace_start,
                         syntax_proc_trace_start);
 
-  lldb::SBCommandPluginInterface *proc_trace_stop =
-      new ProcessorTraceStop(PTDecoderSP);
+  lldb::SBCommandPluginInterface *proc_trace_stop = new ProcessorTraceStop();
   const char *help_proc_trace_stop =
       "stop Intel(R) Processor Trace on a specific thread or on whole process";
   const char *syntax_proc_trace_stop =
       "processor-trace stop  <cmd-options>\n\n"
       "\rcmd-options Usage:\n"
       "\r  processor-trace stop [<thread-index>]\n\n"
       "\t\b<thread-index>\n"
       "\t    thread index of the thread. If no threads are specified, "
       "currently selected thread is taken.\n"
       "\t    Use the thread-index 'all' to stop tracing the whole process\n";
   proc_trace.AddCommand("stop", proc_trace_stop, help_proc_trace_stop,
                         syntax_proc_trace_stop);
 
   lldb::SBCommandPluginInterface *proc_trace_show_instr_log =
-      new ProcessorTraceShowInstrLog(PTDecoderSP);
+      new ProcessorTraceShowInstrLog();
   const char *help_proc_trace_show_instr_log =
       "display a log of assembly instructions executed for a specific thread "
       "or for the whole process.\n"
       "The length of the log to be displayed and the offset in the whole "
       "instruction log from where the log needs to be displayed can also be "
       "provided. The offset is counted from the end of this whole "
       "instruction log which means the last executed instruction is at offset "
       "0 (zero)";
const char *syntax_proc_trace_show_instr_log =
       "\t    thread index of the thread. If no threads are specified, "
       "currently selected thread is taken.\n"
       "\t    Use the thread-index 'all' to show instruction log for all the "
       "threads of the process\n";
   proc_trace.AddCommand("show-instr-log", proc_trace_show_instr_log,
                         help_proc_trace_show_instr_log,
                         syntax_proc_trace_show_instr_log);
 
-  lldb::SBCommandPluginInterface *proc_trace_options =
-      new ProcessorTraceInfo(PTDecoderSP);
+  lldb::SBCommandPluginInterface *proc_trace_options = new ProcessorTraceInfo();
   const char *help_proc_trace_show_options =
       "display all the information regarding Intel(R) Processor Trace for a "
       "specific thread or for the whole process.\n"
       "The information contains trace buffer size and configuration options"
       " of Intel(R) Processor Trace.";
   const char *syntax_proc_trace_show_options =
       "processor-trace show-options <cmd-options>\n\n"
       "\rcmd-options Usage:\n"

lldb/tools/intel-features/intel-pt/source/Core/CMakeLists.txt

else()
   find_library(LIBIPT_LIBRARY ipt PATHS ${LIBIPT_LIBRARY_PATH})
 endif()
 
 if (NOT LIBIPT_LIBRARY)
   message (FATAL_ERROR "libipt library not found")
 endif()
 
 add_lldb_library(lldbIntelPTCore
-  Decoder.cpp
+  PTProcess.cpp
 
   LINK_LIBS
     ${LIBIPT_LIBRARY}
     liblldb
 )
 
 target_include_directories(lldbIntelPTCore PRIVATE ${INTEL_PT_INCLUDES})

lldb/tools/intel-features/intel-pt/source/Core/PTProcess.cpp

-//===-- Decoder.cpp ---------------------------------------------*- C++ -*-===//
+//===-- PTProcess.cpp -------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "intel-pt/Core/Decoder.h"
+#include "intel-pt/Core/PTProcess.h"
 
 // C/C++ Includes
 #include <cinttypes>
 #include <cstring>
 
 #include "lldb/API/SBModule.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBThread.h"
 
 using namespace intelpt_private;
 
-// This function removes entries of all the processes/threads which were once
+// This function removes entries of all the threads which were once
 // registered in the class but are not alive anymore because they died or
 // finished executing.
-void Decoder::RemoveDeadProcessesAndThreads(lldb::SBProcess &sbprocess) {
-  lldb::SBTarget sbtarget = sbprocess.GetTarget();
-  lldb::SBDebugger sbdebugger = sbtarget.GetDebugger();
-  uint32_t num_targets = sbdebugger.GetNumTargets();
-
-  auto itr_process = m_mapProcessUID_mapThreadID_TraceInfo.begin();
-  while (itr_process != m_mapProcessUID_mapThreadID_TraceInfo.end()) {
-    bool process_found = false;
-    lldb::SBTarget target;
-    lldb::SBProcess process;
-    for (uint32_t i = 0; i < num_targets; i++) {
-      target = sbdebugger.GetTargetAtIndex(i);
-      process = target.GetProcess();
-      if (process.GetUniqueID() == itr_process->first) {
-        process_found = true;
-        break;
-      }
-    }
-
-    // Remove the process's entry if it was not found in SBDebugger
-    if (!process_found) {
-      itr_process = m_mapProcessUID_mapThreadID_TraceInfo.erase(itr_process);
-      continue;
-    }
-
-    // If the state of the process is exited or detached then remove process's
-    // entry. If not then remove entry for all those registered threads of this
-    // process that are not alive anymore.
-    lldb::StateType state = process.GetState();
-    if ((state == lldb::StateType::eStateDetached) ||
-        (state == lldb::StateType::eStateExited))
-      itr_process = m_mapProcessUID_mapThreadID_TraceInfo.erase(itr_process);
-    else {
-      auto itr_thread = itr_process->second.begin();
-      while (itr_thread != itr_process->second.end()) {
-        if (itr_thread->first == LLDB_INVALID_THREAD_ID) {
-          ++itr_thread;
-          continue;
-        }
+void PTProcess::RemoveDeadThreads() {
+  auto itr_thread = m_mapThreadID_TraceInfo.begin();
+  while (itr_thread != m_mapThreadID_TraceInfo.end()) {
 
-        lldb::SBThread thread = process.GetThreadByID(itr_thread->first);
-        if (!thread.IsValid())
-          itr_thread = itr_process->second.erase(itr_thread);
-        else
-          ++itr_thread;
-      }
-      ++itr_process;
-    }
-  }
+    lldb::SBThread thread = m_process.GetThreadByID(itr_thread->first);
+      itr_thread = m_mapThreadID_TraceInfo.erase(itr_thread);
 }
 
-void Decoder::StartProcessorTrace(lldb::SBProcess &sbprocess,
-                                  lldb::SBTraceOptions &sbtraceoptions,
+void PTProcess::StartProcessorTrace(lldb::SBTraceOptions &sbtraceoptions,
                                     lldb::SBError &sberror) {
   sberror.Clear();
-  CheckDebuggerID(sbprocess, sberror);
-  if (!sberror.Success())
-    return;
 
-  std::lock_guard<std::mutex> guard(
-      m_mapProcessUID_mapThreadID_TraceInfo_mutex);
-  RemoveDeadProcessesAndThreads(sbprocess);
+  std::lock_guard<std::mutex> guard(m_mapThreadID_TraceInfo_mutex);
+  RemoveDeadThreads();
 
   if (sbtraceoptions.getType() != lldb::TraceType::eTraceTypeProcessorTrace) {
     sberror.SetErrorStringWithFormat("SBTraceOptions::TraceType not set to "
                                      "eTraceTypeProcessorTrace; ProcessID = "
                                      "%" PRIu64,
-                                     sbprocess.GetProcessID());
+                                     m_process.GetProcessID());
     return;
   }
   lldb::SBStructuredData sbstructdata = sbtraceoptions.getTraceParams(sberror);
   if (!sberror.Success())
     return;
 
   const char *trace_tech_key = "trace-tech";
   std::string trace_tech_value("intel-pt");
if (!bytes_written ||
       (bytes_written > (sizeof(string_value) / sizeof(*string_value)))) {
     sberror.SetErrorStringWithFormat(
         "key \"%s\" not set in custom trace parameters", trace_tech_key);
     return;
   }
 
   std::size_t pos =
       trace_tech_value.find((const char *)string_value, 0, bytes_written);
-  if ((pos == std::string::npos)) {
+  if (pos == std::string::npos) {
     sberror.SetErrorStringWithFormat(
         "key \"%s\" not set to \"%s\" in custom trace parameters",
         trace_tech_key, trace_tech_value.c_str());
     return;
   }
 
   // Start Tracing
   lldb::SBError error;
-  uint32_t unique_id = sbprocess.GetUniqueID();
   lldb::tid_t tid = sbtraceoptions.getThreadID();
-  lldb::SBTrace trace = sbprocess.StartTrace(sbtraceoptions, error);
+  lldb::SBTrace trace = m_process.StartTrace(sbtraceoptions, error);
   if (!error.Success()) {
     if (tid == LLDB_INVALID_THREAD_ID)
       sberror.SetErrorStringWithFormat("%s; ProcessID = %" PRIu64,
                                        error.GetCString(),
-                                       sbprocess.GetProcessID());
+                                       m_process.GetProcessID());
     else
       sberror.SetErrorStringWithFormat(
           "%s; thread_id = %" PRIu64 ", ProcessID = %" PRIu64,
-          error.GetCString(), tid, sbprocess.GetProcessID());
+          error.GetCString(), tid, m_process.GetProcessID());
     return;
   }
 
-  MapThreadID_TraceInfo &mapThreadID_TraceInfo =
-      m_mapProcessUID_mapThreadID_TraceInfo[unique_id];
-  ThreadTraceInfo &trace_info = mapThreadID_TraceInfo[tid];
+  ThreadTraceInfo &trace_info = m_mapThreadID_TraceInfo[tid];
   trace_info.SetUniqueTraceInstance(trace);
-  trace_info.SetStopID(sbprocess.GetStopID());
+  trace_info.SetStopID(m_process.GetStopID());
 }
 
-void Decoder::StopProcessorTrace(lldb::SBProcess &sbprocess,
-                                 lldb::SBError &sberror, lldb::tid_t tid) {
+void PTProcess::StopProcessorTrace(lldb::SBError &sberror, lldb::tid_t tid) {
   sberror.Clear();
-  CheckDebuggerID(sbprocess, sberror);
   if (!sberror.Success()) {
     return;
   }
 
-  std::lock_guard<std::mutex> guard(
-      m_mapProcessUID_mapThreadID_TraceInfo_mutex);
-  RemoveDeadProcessesAndThreads(sbprocess);
-
-  uint32_t unique_id = sbprocess.GetUniqueID();
-  auto itr_process = m_mapProcessUID_mapThreadID_TraceInfo.find(unique_id);
-  if (itr_process == m_mapProcessUID_mapThreadID_TraceInfo.end()) {
-    sberror.SetErrorStringWithFormat(
-        "tracing not active for this process; ProcessID = %" PRIu64,
-        sbprocess.GetProcessID());
-    return;
-  }
+  std::lock_guard<std::mutex> guard(m_mapThreadID_TraceInfo_mutex);
+  RemoveDeadThreads();
 
   lldb::SBError error;
   if (tid == LLDB_INVALID_THREAD_ID) {
     // This implies to stop tracing on the whole process
     lldb::user_id_t id_to_be_ignored = LLDB_INVALID_UID;
-    auto itr_thread = itr_process->second.begin();
-    while (itr_thread != itr_process->second.end()) {
+    auto itr_thread = m_mapThreadID_TraceInfo.begin();
+    while (itr_thread != m_mapThreadID_TraceInfo.end()) {
       // In the case when user started trace on the entire process and then
       // registered newly spawned threads of this process in the class later,
       // these newly spawned threads will have same trace id. If we stopped
       // trace on the entire process then tracing stops automatically for these
       // newly spawned registered threads. Stopping trace on them again will
       // return error and therefore we need to skip stopping trace on them
       // again.
       lldb::SBTrace &trace = itr_thread->second.GetUniqueTraceInstance();
       lldb::user_id_t lldb_pt_user_id = trace.GetTraceUID();
       if (lldb_pt_user_id != id_to_be_ignored) {
         trace.StopTrace(error, itr_thread->first);
         if (!error.Success()) {
           std::string error_string(error.GetCString());
           if ((error_string.find("tracing not active for this process") ==
                std::string::npos) &&
               (error_string.find("tracing not active for this thread") ==
                std::string::npos)) {
             sberror.SetErrorStringWithFormat(
                 "%s; thread id=%" PRIu64 ", ProcessID = %" PRIu64,
                 error_string.c_str(), itr_thread->first,
-                sbprocess.GetProcessID());
+                m_process.GetProcessID());
             return;
           }
         }
 
         if (itr_thread->first == LLDB_INVALID_THREAD_ID)
           id_to_be_ignored = lldb_pt_user_id;
       }
-      itr_thread = itr_process->second.erase(itr_thread);
+      itr_thread = m_mapThreadID_TraceInfo.erase(itr_thread);
     }
-    m_mapProcessUID_mapThreadID_TraceInfo.erase(itr_process);
   } else {
     // This implies to stop tracing on a single thread.
     // if 'tid' is registered in the class then get the trace id and stop trace
     // on it. If it is not then check if tracing was ever started on the entire
     // process (because there is a possibility that trace is still running for
     // 'tid' but it was not registered in the class because user had started
     // trace on the whole process and 'tid' spawned later). In that case, get
     // the trace id of the process trace instance and stop trace on this thread.
     // If tracing was never started on the entire process then return error
     // because there is no way tracing is active on 'tid'.
-    MapThreadID_TraceInfo &mapThreadID_TraceInfo = itr_process->second;
     lldb::SBTrace trace;
-    auto itr = mapThreadID_TraceInfo.find(tid);
-    if (itr != mapThreadID_TraceInfo.end()) {
+    auto itr = m_mapThreadID_TraceInfo.find(tid);
+    if (itr != m_mapThreadID_TraceInfo.end()) {
       trace = itr->second.GetUniqueTraceInstance();
     } else {
-      auto itr = mapThreadID_TraceInfo.find(LLDB_INVALID_THREAD_ID);
-      if (itr != mapThreadID_TraceInfo.end()) {
+      auto itr = m_mapThreadID_TraceInfo.find(LLDB_INVALID_THREAD_ID);
+      if (itr != m_mapThreadID_TraceInfo.end()) {
         trace = itr->second.GetUniqueTraceInstance();
       } else {
         sberror.SetErrorStringWithFormat(
             "tracing not active for this thread; thread id=%" PRIu64
             ", ProcessID = %" PRIu64,
-            tid, sbprocess.GetProcessID());
+            tid, m_process.GetProcessID());
         return;
       }
     }
 
     // Stop Tracing
     trace.StopTrace(error, tid);
     if (!error.Success()) {
       std::string error_string(error.GetCString());
       sberror.SetErrorStringWithFormat(
           "%s; thread id=%" PRIu64 ", ProcessID = %" PRIu64,
-          error_string.c_str(), tid, sbprocess.GetProcessID());
+          error_string.c_str(), tid, m_process.GetProcessID());
       if (error_string.find("tracing not active") == std::string::npos)
         return;
     }
     // Delete the entry of 'tid' from this class (if any)
-    mapThreadID_TraceInfo.erase(tid);
+    m_mapThreadID_TraceInfo.erase(tid);
   }
 }
 
-void Decoder::ReadTraceDataAndImageInfo(lldb::SBProcess &sbprocess,
-                                        lldb::tid_t tid, lldb::SBError &sberror,
+void PTProcess::ReadTraceDataAndImageInfo(lldb::tid_t tid,
+                                          lldb::SBError &sberror,
                                           ThreadTraceInfo &threadTraceInfo) {
   // Allocate trace data buffer and parse cpu info for 'tid' if it is registered
   // for the first time in class
   lldb::SBTrace &trace = threadTraceInfo.GetUniqueTraceInstance();
   Buffer &pt_buffer = threadTraceInfo.GetPTBuffer();
   lldb::SBError error;
   if (pt_buffer.size() == 0) {
     lldb::SBTraceOptions traceoptions;
     traceoptions.setThreadID(tid);
     trace.GetTraceConfig(traceoptions, error);
     if (!error.Success()) {
       sberror.SetErrorStringWithFormat("%s; ProcessID = %" PRIu64,
                                        error.GetCString(),
-                                       sbprocess.GetProcessID());
+                                       m_process.GetProcessID());
       return;
     }
     if (traceoptions.getType() != lldb::TraceType::eTraceTypeProcessorTrace) {
       sberror.SetErrorStringWithFormat("invalid TraceType received from LLDB "
                                        "for this thread; thread id=%" PRIu64
                                        ", ProcessID = %" PRIu64,
-                                       tid, sbprocess.GetProcessID());
+                                       tid, m_process.GetProcessID());
       return;
     }
 
     threadTraceInfo.AllocatePTBuffer(traceoptions.getTraceBufferSize());
     lldb::SBStructuredData sbstructdata = traceoptions.getTraceParams(sberror);
     if (!sberror.Success())
       return;
     CPUInfo &pt_cpu = threadTraceInfo.GetCPUInfo();
     ParseCPUInfo(pt_cpu, sbstructdata, sberror);
     if (!sberror.Success())
       return;
   }
 
   // Call LLDB API to get raw trace data for this thread
   size_t bytes_written = trace.GetTraceData(error, (void *)pt_buffer.data(),
                                             pt_buffer.size(), 0, tid);
   if (!error.Success()) {
     sberror.SetErrorStringWithFormat(
         "%s; thread_id = %" PRIu64 ",  ProcessID = %" PRIu64,
-        error.GetCString(), tid, sbprocess.GetProcessID());
+        error.GetCString(), tid, m_process.GetProcessID());
     return;
   }
   std::fill(pt_buffer.begin() + bytes_written, pt_buffer.end(), 0);
 
   // Get information of all the modules of the inferior
-  lldb::SBTarget sbtarget = sbprocess.GetTarget();
   ReadExecuteSectionInfos &readExecuteSectionInfos =
       threadTraceInfo.GetReadExecuteSectionInfos();
-  GetTargetModulesInfo(sbtarget, readExecuteSectionInfos, sberror);
+  GetTargetModulesInfo(readExecuteSectionInfos, sberror);
   if (!sberror.Success())
     return;
 }
 
-void Decoder::DecodeProcessorTrace(lldb::SBProcess &sbprocess, lldb::tid_t tid,
-                                   lldb::SBError &sberror,
+void PTProcess::DecodeProcessorTrace(lldb::tid_t tid, lldb::SBError &sberror,
                                      ThreadTraceInfo &threadTraceInfo) {
   // Initialize instruction decoder
   struct pt_insn_decoder *decoder = nullptr;
   struct pt_config config;
   Buffer &pt_buffer = threadTraceInfo.GetPTBuffer();
   CPUInfo &pt_cpu = threadTraceInfo.GetCPUInfo();
   ReadExecuteSectionInfos &readExecuteSectionInfos =
       threadTraceInfo.GetReadExecuteSectionInfos();
 
   InitializePTInstDecoder(&decoder, &config, pt_cpu, pt_buffer,
                           readExecuteSectionInfos, sberror);
   if (!sberror.Success())
     return;
 
   // Start raw trace decoding
   Instructions &instruction_list = threadTraceInfo.GetInstructionLog();
   instruction_list.clear();
   DecodeTrace(decoder, instruction_list, sberror);
 }
 
 // Raw trace decoding requires information of Read & Execute sections of each
 // module of the inferior. This function updates internal state of the class to
 // store this information.
-void Decoder::GetTargetModulesInfo(
-    lldb::SBTarget &sbtarget, ReadExecuteSectionInfos &readExecuteSectionInfos,
-    lldb::SBError &sberror) {
-  if (!sbtarget.IsValid()) {
-    sberror.SetErrorStringWithFormat("Can't get target's modules info from "
-                                     "LLDB; process has an invalid target");
-    return;
-  }
-
+void PTProcess::GetTargetModulesInfo(
+    ReadExecuteSectionInfos &readExecuteSectionInfos, lldb::SBError &sberror) {
+  lldb::SBTarget sbtarget = m_process.GetTarget();
   lldb::SBFileSpec target_file_spec = sbtarget.GetExecutable();
   if (!target_file_spec.IsValid()) {
     sberror.SetErrorStringWithFormat("Target has an invalid file spec");
     return;
   }
 
   uint32_t num_modules = sbtarget.GetNumModules();
   readExecuteSectionInfos.clear();
for (uint32_t i = 0; i < num_modules; i++) {
     }
   }
 }
 
 // Raw trace decoding requires information of the target cpu on which inferior
 // is running. This function gets the Trace Configuration from LLDB, parses it
 // for cpu model, family, stepping and vendor id info and updates the internal
 // state of the class to store this information.
-void Decoder::ParseCPUInfo(CPUInfo &pt_cpu, lldb::SBStructuredData &s,
+void PTProcess::ParseCPUInfo(CPUInfo &pt_cpu, lldb::SBStructuredData &s,
                              lldb::SBError &sberror) {
   lldb::SBStructuredData custom_trace_params = s.GetValueForKey("intel-pt");
   if (!custom_trace_params.IsValid()) {
     sberror.SetErrorStringWithFormat("lldb couldn't provide cpuinfo");
     return;
   }
 
   uint64_t family = 0, model = 0, stepping = 0;
   char vendor[32];
void PTProcess::ParseCPUInfo(CPUInfo &pt_cpu, lldb::SBStructuredData &s,
   if (length && strstr(vendor, "GenuineIntel"))
     pt_cpu.vendor = pcv_intel;
 }
 
 // Initialize trace decoder with pt_config structure and populate its image
 // structure with inferior's memory image information. pt_config structure is
 // initialized with trace buffer and cpu info of the inferior before storing it
 // in trace decoder.
-void Decoder::InitializePTInstDecoder(
+void PTProcess::InitializePTInstDecoder(
     struct pt_insn_decoder **decoder, struct pt_config *config,
     const CPUInfo &pt_cpu, Buffer &pt_buffer,
     const ReadExecuteSectionInfos &readExecuteSectionInfos,
     lldb::SBError &sberror) const {
   if (!decoder || !config) {
     sberror.SetErrorStringWithFormat("internal error");
     return;
   }
if (errcode < 0) {
                                        "\"%s\"",
                                        pt_errstr(pt_errcode(errcode)));
       pt_insn_free_decoder(*decoder);
       return;
     }
   }
 }
 
-void Decoder::AppendErrorWithOffsetToInstructionList(
+void PTProcess::AppendErrorWithOffsetToInstructionList(
     int errcode, uint64_t decoder_offset, Instructions &instruction_list,
     lldb::SBError &sberror) {
   sberror.SetErrorStringWithFormat(
       "processor trace decoding library: \"%s\"  [decoder_offset] => "
       "[0x%" PRIu64 "]",
       pt_errstr(pt_errcode(errcode)), decoder_offset);
   instruction_list.emplace_back(sberror.GetCString());
 }
 
-void Decoder::AppendErrorWithoutOffsetToInstructionList(
+void PTProcess::AppendErrorWithoutOffsetToInstructionList(
     int errcode, Instructions &instruction_list, lldb::SBError &sberror) {
   sberror.SetErrorStringWithFormat("processor trace decoding library: \"%s\"",
                                    pt_errstr(pt_errcode(errcode)));
   instruction_list.emplace_back(sberror.GetCString());
 }
 
-int Decoder::AppendErrorToInstructionList(int errcode, pt_insn_decoder *decoder,
+int PTProcess::AppendErrorToInstructionList(int errcode,
+                                            pt_insn_decoder *decoder,
                                             Instructions &instruction_list,
                                             lldb::SBError &sberror) {
   uint64_t decoder_offset = 0;
   int errcode_off = pt_insn_get_offset(decoder, &decoder_offset);
   if (errcode_off < 0) {
     AppendErrorWithoutOffsetToInstructionList(errcode, instruction_list,
                                               sberror);
     return errcode_off;
   }
   AppendErrorWithOffsetToInstructionList(errcode, decoder_offset,
                                          instruction_list, sberror);
   return 0;
 }
 
-int Decoder::HandlePTInstructionEvents(pt_insn_decoder *decoder, int errcode,
+int PTProcess::HandlePTInstructionEvents(pt_insn_decoder *decoder, int errcode,
                                          Instructions &instruction_list,
                                          lldb::SBError &sberror) {
   while (errcode & pts_event_pending) {
     pt_event event;
     errcode = pt_insn_event(decoder, &event, sizeof(event));
     if (errcode < 0)
       return errcode;
 
     // The list of events are in
     // https://github.com/intel/libipt/blob/master/doc/man/pt_qry_event.3.md
     if (event.type == ptev_overflow) {
       int append_errcode = AppendErrorToInstructionList(
           errcode, decoder, instruction_list, sberror);
       if (append_errcode < 0)
         return append_errcode;
     }
     // Other events don't signal stream errors
   }
 
   return 0;
 }
 
 // Start actual decoding of raw trace
-void Decoder::DecodeTrace(struct pt_insn_decoder *decoder,
+void PTProcess::DecodeTrace(struct pt_insn_decoder *decoder,
                             Instructions &instruction_list,
                             lldb::SBError &sberror) {
   uint64_t decoder_offset = 0;
 
   while (1) {
     struct pt_insn insn;
 
     // Try to sync the decoder. If it fails then get the decoder_offset and try
     // to sync again. If the new_decoder_offset is same as decoder_offset then
     // we will not succeed in syncing for any number of pt_insn_sync_forward()
while (1) {
       instruction_list.emplace_back(insn);
       if (errcode & pts_eos)
         return;
     }
   }
 }
 
 // Function to diagnose and indicate errors during raw trace decoding
-void Decoder::Diagnose(struct pt_insn_decoder *decoder, int decode_error,
+void PTProcess::Diagnose(struct pt_insn_decoder *decoder, int decode_error,
                          lldb::SBError &sberror, const struct pt_insn *insn) {
   int errcode;
   uint64_t offset;
 
   errcode = pt_insn_get_offset(decoder, &offset);
   if (insn) {
     if (errcode < 0)
       sberror.SetErrorStringWithFormat(
           "processor trace decoding library: \"%s\"  [decoder_offset, "
if (insn) {
     else
       sberror.SetErrorStringWithFormat(
           "processor trace decoding library: \"%s\"  [decoder_offset] => "
           "[0x%" PRIu64 "]",
           pt_errstr(pt_errcode(decode_error)), offset);
   }
 }
 
-void Decoder::GetInstructionLogAtOffset(lldb::SBProcess &sbprocess,
-                                        lldb::tid_t tid, uint32_t offset,
+void PTProcess::GetInstructionLogAtOffset(lldb::tid_t tid, uint32_t offset,
                                           uint32_t count,
                                           InstructionList &result_list,
                                           lldb::SBError &sberror) {
   sberror.Clear();
-  CheckDebuggerID(sbprocess, sberror);
-  if (!sberror.Success()) {
-    return;
-  }
-
-  std::lock_guard<std::mutex> guard(
-      m_mapProcessUID_mapThreadID_TraceInfo_mutex);
-  RemoveDeadProcessesAndThreads(sbprocess);
+  std::lock_guard<std::mutex> guard(m_mapThreadID_TraceInfo_mutex);
+  RemoveDeadThreads();
 
   ThreadTraceInfo *threadTraceInfo = nullptr;
-  FetchAndDecode(sbprocess, tid, sberror, &threadTraceInfo);
+  FetchAndDecode(tid, sberror, &threadTraceInfo);
   if (!sberror.Success()) {
     return;
   }
   if (threadTraceInfo == nullptr) {
     sberror.SetErrorStringWithFormat("internal error");
     return;
   }
 
   // Return instruction log by populating 'result_list'
   Instructions &insn_list = threadTraceInfo->GetInstructionLog();
   uint64_t sum = (uint64_t)offset + 1;
   if (((insn_list.size() <= offset) && (count <= sum) &&
        ((sum - count) >= insn_list.size())) ||
       (count < 1)) {
     sberror.SetErrorStringWithFormat(
         "Instruction Log not available for offset=%" PRIu32
         " and count=%" PRIu32 ", ProcessID = %" PRIu64,
-        offset, count, sbprocess.GetProcessID());
+        offset, count, m_process.GetProcessID());
     return;
   }
 
   Instructions::iterator itr_first =
       (insn_list.size() <= offset) ? insn_list.begin()
                                    : insn_list.begin() + insn_list.size() - sum;
   Instructions::iterator itr_last =
       (count <= sum) ? insn_list.begin() + insn_list.size() - (sum - count)
                      : insn_list.end();
   Instructions::iterator itr = itr_first;
   while (itr != itr_last) {
     result_list.AppendInstruction(*itr);
     ++itr;
   }
 }
 
-void Decoder::GetProcessorTraceInfo(lldb::SBProcess &sbprocess, lldb::tid_t tid,
-                                    TraceOptions &options,
+void PTProcess::GetProcessorTraceInfo(lldb::tid_t tid, TraceOptions &options,
                                       lldb::SBError &sberror) {
   sberror.Clear();
-  CheckDebuggerID(sbprocess, sberror);
   if (!sberror.Success()) {
     return;
   }
 
-  std::lock_guard<std::mutex> guard(
-      m_mapProcessUID_mapThreadID_TraceInfo_mutex);
-  RemoveDeadProcessesAndThreads(sbprocess);
+  std::lock_guard<std::mutex> guard(m_mapThreadID_TraceInfo_mutex);
+  RemoveDeadThreads();
 
   ThreadTraceInfo *threadTraceInfo = nullptr;
-  FetchAndDecode(sbprocess, tid, sberror, &threadTraceInfo);
+  FetchAndDecode(tid, sberror, &threadTraceInfo);
   if (!sberror.Success()) {
     return;
   }
   if (threadTraceInfo == nullptr) {
     sberror.SetErrorStringWithFormat("internal error");
     return;
   }
 
   // Get SBTraceOptions from LLDB for 'tid', populate 'traceoptions' with it
   lldb::SBTrace &trace = threadTraceInfo->GetUniqueTraceInstance();
   lldb::SBTraceOptions traceoptions;
   lldb::SBError error;
   traceoptions.setThreadID(tid);
   trace.GetTraceConfig(traceoptions, error);
   if (!error.Success()) {
     std::string error_string(error.GetCString());
     if (error_string.find("tracing not active") != std::string::npos) {
-      uint32_t unique_id = sbprocess.GetUniqueID();
-      auto itr_process = m_mapProcessUID_mapThreadID_TraceInfo.find(unique_id);
-      if (itr_process == m_mapProcessUID_mapThreadID_TraceInfo.end())
-        return;
-      itr_process->second.erase(tid);
+      m_mapThreadID_TraceInfo.erase(tid);
     }
     sberror.SetErrorStringWithFormat("%s; ProcessID = %" PRIu64,
                                      error_string.c_str(),
-                                     sbprocess.GetProcessID());
+                                     m_process.GetProcessID());
     return;
   }
   if (traceoptions.getType() != lldb::TraceType::eTraceTypeProcessorTrace) {
     sberror.SetErrorStringWithFormat("invalid TraceType received from LLDB "
                                      "for this thread; thread id=%" PRIu64
                                      ", ProcessID = %" PRIu64,
-                                     tid, sbprocess.GetProcessID());
+                                     tid, m_process.GetProcessID());
     return;
   }
   options.setType(traceoptions.getType());
   options.setTraceBufferSize(traceoptions.getTraceBufferSize());
   options.setMetaDataBufferSize(traceoptions.getMetaDataBufferSize());
   lldb::SBStructuredData sbstructdata = traceoptions.getTraceParams(sberror);
   if (!sberror.Success())
     return;
   options.setTraceParams(sbstructdata);
   options.setInstructionLogSize(threadTraceInfo->GetInstructionLog().size());
 }
 
-void Decoder::FetchAndDecode(lldb::SBProcess &sbprocess, lldb::tid_t tid,
-                             lldb::SBError &sberror,
+void PTProcess::FetchAndDecode(lldb::tid_t tid, lldb::SBError &sberror,
                                ThreadTraceInfo **threadTraceInfo) {
-  // Return with error if 'sbprocess' is not registered in the class
-  uint32_t unique_id = sbprocess.GetUniqueID();
-  auto itr_process = m_mapProcessUID_mapThreadID_TraceInfo.find(unique_id);
-  if (itr_process == m_mapProcessUID_mapThreadID_TraceInfo.end()) {
-    sberror.SetErrorStringWithFormat(
-        "tracing not active for this process; ProcessID = %" PRIu64,
-        sbprocess.GetProcessID());
-    return;
-  }
-
   if (tid == LLDB_INVALID_THREAD_ID) {
     sberror.SetErrorStringWithFormat(
         "invalid thread id provided; thread_id = %" PRIu64
         ", ProcessID = %" PRIu64,
-        tid, sbprocess.GetProcessID());
+        tid, m_process.GetProcessID());
     return;
   }
 
   // Check whether 'tid' thread is registered in the class. If it is then in
   // case StopID didn't change then return without doing anything (no need to
   // read and decode trace data then). Otherwise, save new StopID and proceed
   // with reading and decoding trace.
   if (threadTraceInfo == nullptr) {
     sberror.SetErrorStringWithFormat("internal error");
     return;
   }
 
-  MapThreadID_TraceInfo &mapThreadID_TraceInfo = itr_process->second;
-  auto itr_thread = mapThreadID_TraceInfo.find(tid);
-  if (itr_thread != mapThreadID_TraceInfo.end()) {
-    if (itr_thread->second.GetStopID() == sbprocess.GetStopID()) {
+  auto itr_thread = m_mapThreadID_TraceInfo.find(tid);
+  if (itr_thread != m_mapThreadID_TraceInfo.end()) {
+    if (itr_thread->second.GetStopID() == m_process.GetStopID()) {
       *threadTraceInfo = &(itr_thread->second);
       return;
     }
-    itr_thread->second.SetStopID(sbprocess.GetStopID());
+    itr_thread->second.SetStopID(m_process.GetStopID());
   } else {
     // Implies 'tid' is not registered in the class. If tracing was never
     // started on the entire process then return an error. Else try to register
     // this thread and proceed with reading and decoding trace.
     lldb::SBError error;
-    itr_thread = mapThreadID_TraceInfo.find(LLDB_INVALID_THREAD_ID);
-    if (itr_thread == mapThreadID_TraceInfo.end()) {
+    itr_thread = m_mapThreadID_TraceInfo.find(LLDB_INVALID_THREAD_ID);
+    if (itr_thread == m_mapThreadID_TraceInfo.end()) {
       sberror.SetErrorStringWithFormat(
           "tracing not active for this thread; ProcessID = %" PRIu64,
-          sbprocess.GetProcessID());
+          m_process.GetProcessID());
       return;
     }
 
     lldb::SBTrace &trace = itr_thread->second.GetUniqueTraceInstance();
-    ThreadTraceInfo &trace_info = mapThreadID_TraceInfo[tid];
+    ThreadTraceInfo &trace_info = m_mapThreadID_TraceInfo[tid];
     trace_info.SetUniqueTraceInstance(trace);
-    trace_info.SetStopID(sbprocess.GetStopID());
-    itr_thread = mapThreadID_TraceInfo.find(tid);
+    trace_info.SetStopID(m_process.GetStopID());
+    itr_thread = m_mapThreadID_TraceInfo.find(tid);
   }
 
   // Get raw trace data and inferior image from LLDB for the registered thread
-  ReadTraceDataAndImageInfo(sbprocess, tid, sberror, itr_thread->second);
+  ReadTraceDataAndImageInfo(tid, sberror, itr_thread->second);
   if (!sberror.Success()) {
     std::string error_string(sberror.GetCString());
     if (error_string.find("tracing not active") != std::string::npos)
-      mapThreadID_TraceInfo.erase(itr_thread);
+      m_mapThreadID_TraceInfo.erase(itr_thread);
     return;
   }
   // Decode raw trace data
-  DecodeProcessorTrace(sbprocess, tid, sberror, itr_thread->second);
+  DecodeProcessorTrace(tid, sberror, itr_thread->second);
   if (!sberror.Success()) {
     return;
   }
   *threadTraceInfo = &(itr_thread->second);
 }
 
-// This function checks whether the provided SBProcess instance belongs to same
-// SBDebugger with which this tool instance is associated.
-void Decoder::CheckDebuggerID(lldb::SBProcess &sbprocess,
-                              lldb::SBError &sberror) {
-  if (!sbprocess.IsValid()) {
-    sberror.SetErrorStringWithFormat("invalid process instance");
-    return;
-  }
-
-  lldb::SBTarget sbtarget = sbprocess.GetTarget();
-  if (!sbtarget.IsValid()) {
-    sberror.SetErrorStringWithFormat(
-        "process contains an invalid target; ProcessID = %" PRIu64,
-        sbprocess.GetProcessID());
-    return;
-  }
-
-  lldb::SBDebugger sbdebugger = sbtarget.GetDebugger();
-  if (!sbdebugger.IsValid()) {
-    sberror.SetErrorStringWithFormat("process's target contains an invalid "
-                                     "debugger instance; ProcessID = %" PRIu64,
-                                     sbprocess.GetProcessID());
-    return;
-  }
-
-  if (sbdebugger.GetID() != m_debugger_user_id) {
-    sberror.SetErrorStringWithFormat(
-        "process belongs to a different SBDebugger instance than the one for "
-        "which the tool is instantiated; ProcessID = %" PRIu64,
-        sbprocess.GetProcessID());
-    return;
-  }
-}
-
-lldb::SBTraceOptions Decoder::GetDefaultTraceOptions() {
+lldb::SBTraceOptions PTProcess::GetDefaultTraceOptions() {
   lldb::SBTraceOptions trace_opts;
   trace_opts.setThreadID(LLDB_INVALID_THREAD_ID);
   trace_opts.setType(lldb::TraceType::eTraceTypeProcessorTrace);
   trace_opts.setTraceBufferSize(4096); // 1 page
   trace_opts.setMetaDataBufferSize(0);
 
   lldb::SBStream sb_stream;
   sb_stream.Printf("{\"trace-tech\":\"intel-pt\"}");
   lldb::SBStructuredData custom_params;
   custom_params.SetFromJSON(sb_stream);
   trace_opts.setTraceParams(custom_params);
 
   return trace_opts;
 }

lldb/tools/intel-features/scripts/lldb-intel-features.swig

 #if SWIG_VERSION >= 0x030009 && SWIG_VERSION < 0x030011
 #error Swig versions 3.0.9 and 3.0.10 are incompatible with lldb.
 #endif
 
 %module(moduleimport=MODULEIMPORT) lldbIntelFeatures
 
 %{
 #include "lldb/lldb-public.h"
-#include "intel-pt/API/PTDecoder.h"
+#include "intel-pt/API/SBPTProcess.h"
 using namespace intelpt;
 %}
 
 /* Undefine GCC keyword to make Swig happy when processing glibc's stdint.h */
 #define __extension__
 
 /* Combined python typemap for all features */
 %include "python-typemaps.txt"
 
 /* Feature specific python interface files*/
-%include "../intel-pt/interface/PTDecoder.i"
+%include "../intel-pt/interface/SBPTProcess.i"