[trace][intel-pt] Create basic SB API

This adds a basic SB API for creating and stopping traces.
Note: This doesn't add any APIs for inspecting individual instructions. That'd be a more complicated change and it might be better to enhande the dump functionality to output the data in binary format. I'll leave that for a later diff.

This also enhances the existing tests so that they test the same flow using both the command interface and the SB API.

I also did some cleanup of legacy code.

Differential Revision: https://reviews.llvm.org/D103500

lldb/source/API/SBTrace.cpp

@@ -9,112 +9,88 @@
 #include "SBReproducerPrivate.h"
 #include "lldb/Target/Process.h"
 
+#include "lldb/API/SBStructuredData.h"
+#include "lldb/API/SBThread.h"
 #include "lldb/API/SBTrace.h"
-#include "lldb/API/SBTraceOptions.h"
+
+#include "lldb/Core/StructuredDataImpl.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
-class TraceImpl {
-public:
-  lldb::user_id_t uid;
-};
+SBTrace::SBTrace() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTrace); }
 
-lldb::ProcessSP SBTrace::GetSP() const { return m_opaque_wp.lock(); }
+SBTrace::SBTrace(const lldb::TraceSP &trace_sp) : m_opaque_sp(trace_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBTrace, (const lldb::TraceSP &), trace_sp);
+}
 
-size_t SBTrace::GetTraceData(SBError &error, void *buf, size_t size,
-                             size_t offset, lldb::tid_t thread_id) {
-  LLDB_RECORD_DUMMY(size_t, SBTrace, GetTraceData,
-                    (lldb::SBError &, void *, size_t, size_t, lldb::tid_t),
-                    error, buf, size, offset, thread_id);
+const char *SBTrace::GetStartConfigurationHelp() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTrace, GetStartConfigurationHelp);
+  return LLDB_RECORD_RESULT(
+      m_opaque_sp ? m_opaque_sp->GetStartConfigurationHelp() : nullptr);
+}
 
-  ProcessSP process_sp(GetSP());
-  llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size);
-  error.Clear();
+SBError SBTrace::Start(const SBStructuredData &configuration) {
+  LLDB_RECORD_METHOD(SBError, SBTrace, Start, (const SBStructuredData &),
+                     configuration);
+  SBError error;
+  if (!m_opaque_sp)
+    error.SetErrorString("error: invalid trace");
+  else if (llvm::Error err =
+               m_opaque_sp->Start(configuration.m_impl_up->GetObjectSP()))
+    error.SetErrorString(llvm::toString(std::move(err)).c_str());
+  return LLDB_RECORD_RESULT(error);
+}
 
-  if (!process_sp) {
-    error.SetErrorString("invalid process");
-  } else {
-    error.SetError(
-        process_sp->GetData(GetTraceUID(), thread_id, buffer, offset));
+SBError SBTrace::Start(const SBThread &thread,
+                       const SBStructuredData &configuration) {
+  LLDB_RECORD_METHOD(SBError, SBTrace, Start,
+                     (const SBThread &, const SBStructuredData &), thread,
+                     configuration);
+
+  SBError error;
+  if (!m_opaque_sp)
+    error.SetErrorString("error: invalid trace");
+  else {
+    if (llvm::Error err =
+            m_opaque_sp->Start(std::vector<lldb::tid_t>{thread.GetThreadID()},
+                               configuration.m_impl_up->GetObjectSP()))
+      error.SetErrorString(llvm::toString(std::move(err)).c_str());
   }
-  return buffer.size();
+
+  return LLDB_RECORD_RESULT(error);
 }
 
-size_t SBTrace::GetMetaData(SBError &error, void *buf, size_t size,
-                            size_t offset, lldb::tid_t thread_id) {
-  LLDB_RECORD_DUMMY(size_t, SBTrace, GetMetaData,
-                    (lldb::SBError &, void *, size_t, size_t, lldb::tid_t),
-                    error, buf, size, offset, thread_id);
-
-  ProcessSP process_sp(GetSP());
-  llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size);
-  error.Clear();
-
-  if (!process_sp) {
-    error.SetErrorString("invalid process");
-  } else {
-    error.SetError(
-        process_sp->GetMetaData(GetTraceUID(), thread_id, buffer, offset));
-  }
-  return buffer.size();
+SBError SBTrace::Stop() {
+  LLDB_RECORD_METHOD_NO_ARGS(SBError, SBTrace, Stop);
+  SBError error;
+  if (!m_opaque_sp)
+    error.SetErrorString("error: invalid trace");
+  else if (llvm::Error err = m_opaque_sp->Stop())
+    error.SetErrorString(llvm::toString(std::move(err)).c_str());
+  return LLDB_RECORD_RESULT(error);
 }
 
-void SBTrace::StopTrace(SBError &error, lldb::tid_t thread_id) {
-  LLDB_RECORD_METHOD(void, SBTrace, StopTrace, (lldb::SBError &, lldb::tid_t),
-                     error, thread_id);
-
-  ProcessSP process_sp(GetSP());
-  error.Clear();
-
-  if (!process_sp) {
-    error.SetErrorString("invalid process");
-    return;
-  }
-  error.SetError(process_sp->StopTrace(GetTraceUID(), thread_id));
+SBError SBTrace::Stop(const SBThread &thread) {
+  LLDB_RECORD_METHOD(SBError, SBTrace, Stop, (const SBThread &), thread);
+  SBError error;
+  if (!m_opaque_sp)
+    error.SetErrorString("error: invalid trace");
+  else if (llvm::Error err = m_opaque_sp->Stop({thread.GetThreadID()}))
+    error.SetErrorString(llvm::toString(std::move(err)).c_str());
+  return LLDB_RECORD_RESULT(error);
 }
 
-void SBTrace::GetTraceConfig(SBTraceOptions &options, SBError &error) {
-  error.SetErrorString("deprecated");
-}
-
-lldb::user_id_t SBTrace::GetTraceUID() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBTrace, GetTraceUID);
-
-  if (m_trace_impl_sp)
-    return m_trace_impl_sp->uid;
-  return LLDB_INVALID_UID;
-}
-
-void SBTrace::SetTraceUID(lldb::user_id_t uid) {
-  if (m_trace_impl_sp)
-    m_trace_impl_sp->uid = uid;
-}
-
-SBTrace::SBTrace() {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTrace);
-
-  m_trace_impl_sp = std::make_shared<TraceImpl>();
-  if (m_trace_impl_sp)
-    m_trace_impl_sp->uid = LLDB_INVALID_UID;
-}
-
-void SBTrace::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
-
 bool SBTrace::IsValid() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTrace, IsValid);
   return this->operator bool();
 }
+
 SBTrace::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTrace, operator bool);
-
-  if (!m_trace_impl_sp)
-    return false;
-  if (!GetSP())
-    return false;
-  return true;
+  return (bool)m_opaque_sp;
 }
 
 namespace lldb_private {
@@ -122,13 +98,15 @@ namespace repro {
 
 template <>
 void RegisterMethods<SBTrace>(Registry &R) {
-  LLDB_REGISTER_METHOD(void, SBTrace, StopTrace,
-                       (lldb::SBError &, lldb::tid_t));
-  LLDB_REGISTER_METHOD(void, SBTrace, GetTraceConfig,
-                       (lldb::SBTraceOptions &, lldb::SBError &));
-  LLDB_REGISTER_METHOD(lldb::user_id_t, SBTrace, GetTraceUID, ());
   LLDB_REGISTER_CONSTRUCTOR(SBTrace, ());
+  LLDB_REGISTER_CONSTRUCTOR(SBTrace, (const lldb::TraceSP &));
+  LLDB_REGISTER_METHOD(SBError, SBTrace, Start, (const SBStructuredData &));
+  LLDB_REGISTER_METHOD(SBError, SBTrace, Start,
+                       (const SBThread &, const SBStructuredData &));
+  LLDB_REGISTER_METHOD(SBError, SBTrace, Stop, (const SBThread &));
+  LLDB_REGISTER_METHOD(SBError, SBTrace, Stop, ());
   LLDB_REGISTER_METHOD(bool, SBTrace, IsValid, ());
+  LLDB_REGISTER_METHOD(const char *, SBTrace, GetStartConfigurationHelp, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBTrace, operator bool, ());
 }