[trace][intelpt] Rename IntelPTManager and change TraceCursor::GetTimestampCounter API to general trace counter API

[jj10306]

Summary

Minor refactor and renaming:

• Rename IntelPTManager class and files to IntelPTCollector
• Change TraceCursor::GetTimestampCounter API to general trace counter API, GetCounter

First of a series of smaller diffs that split https://reviews.llvm.org/D120595 up.

[wallace]

just fix these two simple comments and good to go

lldb/include/lldb/Target/TraceCursor.h

189–190

lldb/include/lldb/lldb-enumerations.h

1144

[jj10306]

Fix minor comment issues

[jj10306]

rebase

lldb/include/lldb/Target/TraceCursor.h

public:
   virtual llvm::Error GetError() = 0;
 
   /// \return
   ///     The load address of the instruction the cursor is pointing at. If the
   ///     cursor points to an error in the trace, return \b
   ///     LLDB_INVALID_ADDRESS.
   virtual lldb::addr_t GetLoadAddress() = 0;
 
-  /// Get the timestamp counter associated with the current instruction.
-  /// Modern Intel, ARM and AMD processors support this counter. However, a
-  /// trace plugin might decide to use a different time unit instead of an
-  /// actual TSC.
+  /// Get the hardware counter of a given type associated with the current
+  /// instruction. Each architecture might support different counters. It might
+  /// happen that only some instructions of an entire trace have a given counter
+  /// associated with them.
   ///
+  /// \param[in] counter_type
+  ///    The counter type.
   /// \return
-  ///     The timestamp or \b llvm::None if not available.
-  virtual llvm::Optional<uint64_t> GetTimestampCounter() = 0;
+  ///     The value of the counter or \b llvm::None if not available.
+  virtual llvm::Optional<uint64_t> GetCounter(lldb::TraceCounter counter_type) = 0;
 
   /// \return
   ///     The \a lldb::TraceInstructionControlFlowType categories the
   ///     instruction the cursor is pointing at falls into. If the cursor points
   ///     to an error in the trace, return \b 0.
   virtual lldb::TraceInstructionControlFlowType
   GetInstructionControlFlowType() = 0;
   /// \}

lldb/include/lldb/lldb-enumerations.h

 // Style of core file to create when calling SaveCore.
 enum SaveCoreStyle {
   eSaveCoreUnspecified = 0,
   eSaveCoreFull = 1,
   eSaveCoreDirtyOnly = 2,
   eSaveCoreStackOnly = 3,
 };
 
+// Type of counter values associated with instructions in a trace.
+enum TraceCounter {
+  // Timestamp counter, like the one offered by Intel CPUs (TSC).
+  eTraceCounterTSC,
+};
+
 } // namespace lldb
 
 #endif // LLDB_LLDB_ENUMERATIONS_H

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

 add_lldb_library(lldbPluginProcessLinux
-  IntelPTManager.cpp
+  IntelPTCollector.cpp
   NativeProcessLinux.cpp
   NativeRegisterContextLinux.cpp
   NativeRegisterContextLinux_arm.cpp
   NativeRegisterContextLinux_arm64.cpp
   NativeRegisterContextLinux_ppc64le.cpp
   NativeRegisterContextLinux_s390x.cpp
   NativeRegisterContextLinux_x86_64.cpp
   NativeThreadLinux.cpp

lldb/source/Plugins/Process/Linux/IntelPTCollector.h

-//===-- IntelPTManager.h -------------------------------------- -*- C++ -*-===//
+//===-- IntelPTCollector.h -------------------------------------- -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_IntelPTManager_H_
-#define liblldb_IntelPTManager_H_
+#ifndef liblldb_IntelPTCollector_H_
+#define liblldb_IntelPTCollector_H_
 
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 
 #include <linux/perf_event.h>

 
 private:
   IntelPTThreadTraceCollection m_thread_traces;
   /// Params used to trace threads when the user started "process tracing".
   TraceIntelPTStartRequest m_tracing_params;
 };
 
 /// Main class that manages intel-pt process and thread tracing.
-class IntelPTManager {
+class IntelPTCollector {
 public:
-  IntelPTManager(lldb::pid_t pid) : m_pid(pid), m_thread_traces(pid) {}
+  IntelPTCollector(lldb::pid_t pid) : m_pid(pid), m_thread_traces(pid) {}
 
   static bool IsSupported();
 
   /// If "process tracing" is enabled, then trace the given thread.
   llvm::Error OnThreadCreated(lldb::tid_t tid);
 
   /// Stops tracing a tracing upon a destroy event.
   llvm::Error OnThreadDestroyed(lldb::tid_t tid);
private:
   /// Threads traced due to "process tracing". Only one active "process tracing"
   /// instance is assumed for a single process.
   llvm::Optional<IntelPTProcessTrace> m_process_trace;
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
-#endif // liblldb_IntelPTManager_H_
+#endif // liblldb_IntelPTCollector_H_

lldb/source/Plugins/Process/Linux/IntelPTCollector.cpp

-//===-- IntelPTManager.cpp ------------------------------------------------===//
+//===-- IntelPTCollector.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 <algorithm>
 #include <fstream>
 #include <sstream>
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MathExtras.h"
 
-#include "IntelPTManager.h"
+#include "IntelPTCollector.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "lldb/Host/linux/Support.h"
 #include "lldb/Utility/StreamString.h"
 
 #include <sys/ioctl.h>
 #include <sys/syscall.h>
 
 using namespace lldb;
Error IntelPTProcessTrace::TraceStart(lldb::tid_t tid) {
   return m_thread_traces.TraceStart(tid, m_tracing_params);
 }
 
 const IntelPTThreadTraceCollection &
 IntelPTProcessTrace::GetThreadTraces() const {
   return m_thread_traces;
 }
 
-/// IntelPTManager
+/// IntelPTCollector
 
-Error IntelPTManager::TraceStop(lldb::tid_t tid) {
+Error IntelPTCollector::TraceStop(lldb::tid_t tid) {
   if (IsProcessTracingEnabled() && m_process_trace->TracesThread(tid))
     return m_process_trace->TraceStop(tid);
   return m_thread_traces.TraceStop(tid);
 }
 
-Error IntelPTManager::TraceStop(const TraceStopRequest &request) {
+Error IntelPTCollector::TraceStop(const TraceStopRequest &request) {
   if (request.IsProcessTracing()) {
     Clear();
     return Error::success();
   } else {
     Error error = Error::success();
     for (int64_t tid : *request.tids)
       error = joinErrors(std::move(error),
                          TraceStop(static_cast<lldb::tid_t>(tid)));
     return error;
   }
 }
 
-Error IntelPTManager::TraceStart(
+Error IntelPTCollector::TraceStart(
     const TraceIntelPTStartRequest &request,
     const std::vector<lldb::tid_t> &process_threads) {
   if (request.IsProcessTracing()) {
     if (IsProcessTracingEnabled()) {
       return createStringError(
           inconvertibleErrorCode(),
           "Process currently traced. Stop process tracing first");
     }
     m_process_trace = IntelPTProcessTrace(m_pid, request);
 
     Error error = Error::success();
     for (lldb::tid_t tid : process_threads)
       error = joinErrors(std::move(error), m_process_trace->TraceStart(tid));
     return error;
   } else {
     Error error = Error::success();
     for (int64_t tid : *request.tids)
       error = joinErrors(std::move(error),
                          m_thread_traces.TraceStart(tid, request));
     return error;
   }
 }
 
-Error IntelPTManager::OnThreadCreated(lldb::tid_t tid) {
+Error IntelPTCollector::OnThreadCreated(lldb::tid_t tid) {
   if (!IsProcessTracingEnabled())
     return Error::success();
   return m_process_trace->TraceStart(tid);
 }
 
-Error IntelPTManager::OnThreadDestroyed(lldb::tid_t tid) {
+Error IntelPTCollector::OnThreadDestroyed(lldb::tid_t tid) {
   if (IsProcessTracingEnabled() && m_process_trace->TracesThread(tid))
     return m_process_trace->TraceStop(tid);
   else if (m_thread_traces.TracesThread(tid))
     return m_thread_traces.TraceStop(tid);
   return Error::success();
 }
 
-Expected<json::Value> IntelPTManager::GetState() const {
+Expected<json::Value> IntelPTCollector::GetState() const {
   Expected<ArrayRef<uint8_t>> cpu_info = IntelPTThreadTrace::GetCPUInfo();
   if (!cpu_info)
     return cpu_info.takeError();
 
   TraceGetStateResponse state;
   state.processBinaryData.push_back(
       {"cpuInfo", static_cast<int64_t>(cpu_info->size())});
 
   std::vector<TraceThreadState> thread_states =
       m_thread_traces.GetThreadStates();
   state.tracedThreads.insert(state.tracedThreads.end(), thread_states.begin(),
                              thread_states.end());
 
   if (IsProcessTracingEnabled()) {
     thread_states = m_process_trace->GetThreadTraces().GetThreadStates();
     state.tracedThreads.insert(state.tracedThreads.end(), thread_states.begin(),
                                thread_states.end());
   }
   return toJSON(state);
 }
 
 Expected<const IntelPTThreadTrace &>
-IntelPTManager::GetTracedThread(lldb::tid_t tid) const {
+IntelPTCollector::GetTracedThread(lldb::tid_t tid) const {
   if (IsProcessTracingEnabled() && m_process_trace->TracesThread(tid))
     return m_process_trace->GetThreadTraces().GetTracedThread(tid);
   return m_thread_traces.GetTracedThread(tid);
 }
 
 Expected<std::vector<uint8_t>>
-IntelPTManager::GetBinaryData(const TraceGetBinaryDataRequest &request) const {
+IntelPTCollector::GetBinaryData(const TraceGetBinaryDataRequest &request) const {
   if (request.kind == "threadTraceBuffer") {
     if (Expected<const IntelPTThreadTrace &> trace =
             GetTracedThread(*request.tid))
       return trace->GetIntelPTBuffer(request.offset, request.size);
     else
       return trace.takeError();
   } else if (request.kind == "cpuInfo") {
     return IntelPTThreadTrace::GetCPUInfo();
   }
   return createStringError(inconvertibleErrorCode(),
                            "Unsuported trace binary data kind: %s",
                            request.kind.c_str());
 }
 
-void IntelPTManager::ClearProcessTracing() { m_process_trace = None; }
+void IntelPTCollector::ClearProcessTracing() { m_process_trace = None; }
 
-bool IntelPTManager::IsSupported() {
+bool IntelPTCollector::IsSupported() {
   Expected<uint32_t> intel_pt_type = GetOSEventType();
   if (!intel_pt_type) {
     llvm::consumeError(intel_pt_type.takeError());
     return false;
   }
   return true;
 }
 
-bool IntelPTManager::IsProcessTracingEnabled() const {
+bool IntelPTCollector::IsProcessTracingEnabled() const {
   return (bool)m_process_trace;
 }
 
-void IntelPTManager::Clear() {
+void IntelPTCollector::Clear() {
   ClearProcessTracing();
   m_thread_traces.Clear();
 }

lldb/source/Plugins/Process/Linux/NativeProcessLinux.h

 #include "lldb/Host/Debug.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/linux/Support.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-types.h"
 
-#include "IntelPTManager.h"
+#include "IntelPTCollector.h"
 #include "NativeThreadLinux.h"
 #include "Plugins/Process/POSIX/NativeProcessELF.h"
 #include "Plugins/Process/Utility/NativeProcessSoftwareSingleStep.h"
 
 namespace lldb_private {
 class Status;
 class Scalar;
 
private:
 
   void ThreadWasCreated(NativeThreadLinux &thread);
 
   void SigchldHandler();
 
   Status PopulateMemoryRegionCache();
 
   /// Manages Intel PT process and thread traces.
-  IntelPTManager m_intel_pt_manager;
+  IntelPTCollector m_intel_pt_collector;
 
   // Handle a clone()-like event.
   bool MonitorClone(NativeThreadLinux &parent, lldb::pid_t child_pid,
                     int event);
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessLinux_H_

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

 
 // Public Instance Methods
 
 NativeProcessLinux::NativeProcessLinux(::pid_t pid, int terminal_fd,
                                        NativeDelegate &delegate,
                                        const ArchSpec &arch, MainLoop &mainloop,
                                        llvm::ArrayRef<::pid_t> tids)
     : NativeProcessELF(pid, terminal_fd, delegate), m_arch(arch),
-      m_main_loop(mainloop), m_intel_pt_manager(pid) {
+      m_main_loop(mainloop), m_intel_pt_collector(pid) {
   if (m_terminal_fd != -1) {
     Status status = EnsureFDFlags(m_terminal_fd, O_NONBLOCK);
     assert(status.Success());
   }
 
   Status status;
   m_sigchld_handle = mainloop.RegisterSignal(
       SIGCHLD, [this](MainLoopBase &) { SigchldHandler(); }, status);
Status NativeProcessLinux::Detach() {
 
   for (const auto &thread : m_threads) {
     Status e = Detach(thread->GetID());
     if (e.Fail())
       error =
           e; // Save the error, but still attempt to detach from other threads.
   }
 
-  m_intel_pt_manager.Clear();
+  m_intel_pt_collector.Clear();
 
   return error;
 }
 
 Status NativeProcessLinux::Signal(int signo) {
   Status error;
 
   Log *log = GetLog(POSIXLog::Process);
void NativeProcessLinux::StopTrackingThread(NativeThreadLinux &thread) {
   m_threads.erase(it);
 
   NotifyTracersOfThreadDestroyed(thread_id);
   SignalIfAllThreadsStopped();
 }
 
 Status NativeProcessLinux::NotifyTracersOfNewThread(lldb::tid_t tid) {
   Log *log = GetLog(POSIXLog::Thread);
-  Status error(m_intel_pt_manager.OnThreadCreated(tid));
+  Status error(m_intel_pt_collector.OnThreadCreated(tid));
   if (error.Fail())
     LLDB_LOG(log, "Failed to trace a new thread with intel-pt, tid = {0}. {1}",
              tid, error.AsCString());
   return error;
 }
 
 Status NativeProcessLinux::NotifyTracersOfThreadDestroyed(lldb::tid_t tid) {
   Log *log = GetLog(POSIXLog::Thread);
-  Status error(m_intel_pt_manager.OnThreadDestroyed(tid));
+  Status error(m_intel_pt_collector.OnThreadDestroyed(tid));
   if (error.Fail())
     LLDB_LOG(log,
              "Failed to stop a destroyed thread with intel-pt, tid = {0}. {1}",
              tid, error.AsCString());
   return error;
 }
 
 NativeThreadLinux &NativeProcessLinux::AddThread(lldb::tid_t thread_id,
Status NativeProcessLinux::PtraceWrapper(int req, lldb::pid_t pid, void *addr,
 
   if (error.Fail())
     LLDB_LOG(log, "ptrace() failed: {0}", error);
 
   return error;
 }
 
 llvm::Expected<TraceSupportedResponse> NativeProcessLinux::TraceSupported() {
-  if (IntelPTManager::IsSupported())
+  if (IntelPTCollector::IsSupported())
     return TraceSupportedResponse{"intel-pt", "Intel Processor Trace"};
   return NativeProcessProtocol::TraceSupported();
 }
 
 Error NativeProcessLinux::TraceStart(StringRef json_request, StringRef type) {
   if (type == "intel-pt") {
     if (Expected<TraceIntelPTStartRequest> request =
             json::parse<TraceIntelPTStartRequest>(json_request,
                                                   "TraceIntelPTStartRequest")) {
       std::vector<lldb::tid_t> process_threads;
       for (auto &thread : m_threads)
         process_threads.push_back(thread->GetID());
-      return m_intel_pt_manager.TraceStart(*request, process_threads);
+      return m_intel_pt_collector.TraceStart(*request, process_threads);
     } else
       return request.takeError();
   }
 
   return NativeProcessProtocol::TraceStart(json_request, type);
 }
 
 Error NativeProcessLinux::TraceStop(const TraceStopRequest &request) {
   if (request.type == "intel-pt")
-    return m_intel_pt_manager.TraceStop(request);
+    return m_intel_pt_collector.TraceStop(request);
   return NativeProcessProtocol::TraceStop(request);
 }
 
 Expected<json::Value> NativeProcessLinux::TraceGetState(StringRef type) {
   if (type == "intel-pt")
-    return m_intel_pt_manager.GetState();
+    return m_intel_pt_collector.GetState();
   return NativeProcessProtocol::TraceGetState(type);
 }
 
 Expected<std::vector<uint8_t>> NativeProcessLinux::TraceGetBinaryData(
     const TraceGetBinaryDataRequest &request) {
   if (request.type == "intel-pt")
-    return m_intel_pt_manager.GetBinaryData(request);
+    return m_intel_pt_collector.GetBinaryData(request);
   return NativeProcessProtocol::TraceGetBinaryData(request);
 }

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

public:
   size_t Seek(int64_t offset, SeekType origin) override;
 
   virtual bool Next() override;
 
   llvm::Error GetError() override;
 
   lldb::addr_t GetLoadAddress() override;
 
-  llvm::Optional<uint64_t> GetTimestampCounter() override;
+  llvm::Optional<uint64_t> GetCounter(lldb::TraceCounter counter_type) override;
 
   lldb::TraceInstructionControlFlowType
   GetInstructionControlFlowType() override;
 
   bool IsError() override;
 
 private:
   size_t GetInternalInstructionSize();

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

 Error TraceCursorIntelPT::GetError() {
   return m_decoded_thread_sp->GetInstructions()[m_pos].ToError();
 }
 
 lldb::addr_t TraceCursorIntelPT::GetLoadAddress() {
   return m_decoded_thread_sp->GetInstructions()[m_pos].GetLoadAddress();
 }
 
-Optional<uint64_t> TraceCursorIntelPT::GetTimestampCounter() {
+Optional<uint64_t> TraceCursorIntelPT::GetCounter(lldb::TraceCounter counter_type) {
+  switch (counter_type) {
+    case lldb::eTraceCounterTSC:
       return m_decoded_thread_sp->GetInstructions()[m_pos].GetTimestampCounter();
   }
+}
 
 TraceInstructionControlFlowType
 TraceCursorIntelPT::GetInstructionControlFlowType() {
   lldb::addr_t next_load_address =
       m_pos + 1 < GetInternalInstructionSize()
           ? m_decoded_thread_sp->GetInstructions()[m_pos + 1].GetLoadAddress()
           : LLDB_INVALID_ADDRESS;
   return m_decoded_thread_sp->GetInstructions()[m_pos].GetControlFlowType(
       next_load_address);
 }

lldb/source/Target/TraceInstructionDumper.cpp

void TraceInstructionDumper::DumpInstructions(Stream &s, size_t count) {
   };
 
   auto printInstructionIndex = [&]() {
     s.Printf("    [%*d] ", digits_count, m_index);
 
     if (m_show_tsc) {
       s.Printf("[tsc=");
 
-      if (Optional<uint64_t> timestamp = m_cursor_up->GetTimestampCounter())
+      if (Optional<uint64_t> timestamp = m_cursor_up->GetCounter(lldb::eTraceCounterTSC))
         s.Printf("0x%016" PRIx64, *timestamp);
       else
         s.Printf("unavailable");
 
       s.Printf("] ");
     }
   };
 

lldb/unittests/Process/Linux/CMakeLists.txt

 add_lldb_unittest(TraceIntelPTTests
-  IntelPTManagerTests.cpp
+  IntelPTCollectorTests.cpp
 
   LINK_LIBS
     lldbPluginProcessLinux
   )
 
 target_include_directories(TraceIntelPTTests PRIVATE
   ${LLDB_SOURCE_DIR}/source/Plugins/Process/Linux)

lldb/unittests/Process/Linux/IntelPTCollectorTests.cpp

-//===-- IntelPTManagerTests.cpp -------------------------------------------===//
+//===-- IntelPTCollectorTests.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 "gtest/gtest.h"
 
-#include "IntelPTManager.h"
+#include "IntelPTCollector.h"
 #include "llvm/ADT/ArrayRef.h"
 
 
 using namespace lldb_private;
 using namespace process_linux;
 
 size_t ReadCylicBufferWrapper(void *buf, size_t buf_size, void *cyc_buf,
                               size_t cyc_buf_size, size_t cyc_start,