lldb/source/API/SBTrace.cpp

   1 //===-- SBTrace.cpp ---------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "SBReproducerPrivate.h"
  10 #include "lldb/Target/Process.h"
  11
  12 #include "lldb/API/SBTrace.h"
  13 #include "lldb/API/SBTraceOptions.h"
  14
  15 #include <memory>
  16
  17 using namespace lldb;
  18 using namespace lldb_private;
  19
  20 class TraceImpl {
  21 public:
  22   lldb::user_id_t uid;
  23 };
  24
  25 lldb::ProcessSP SBTrace::GetSP() const { return m_opaque_wp.lock(); }
  26
  27 size_t SBTrace::GetTraceData(SBError &error, void *buf, size_t size,
  28                              size_t offset, lldb::tid_t thread_id) {
  29   LLDB_RECORD_DUMMY(size_t, SBTrace, GetTraceData,
  30                     (lldb::SBError &, void *, size_t, size_t, lldb::tid_t),
  31                     error, buf, size, offset, thread_id);
  32
  33   ProcessSP process_sp(GetSP());
  34   llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size);
  35   error.Clear();
  36
  37   if (!process_sp) {
  38     error.SetErrorString("invalid process");
  39   } else {
  40     error.SetError(
  41         process_sp->GetData(GetTraceUID(), thread_id, buffer, offset));
  42   }
  43   return buffer.size();
  44 }
  45
  46 size_t SBTrace::GetMetaData(SBError &error, void *buf, size_t size,
  47                             size_t offset, lldb::tid_t thread_id) {
  48   LLDB_RECORD_DUMMY(size_t, SBTrace, GetMetaData,
  49                     (lldb::SBError &, void *, size_t, size_t, lldb::tid_t),
  50                     error, buf, size, offset, thread_id);
  51
  52   ProcessSP process_sp(GetSP());
  53   llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size);
  54   error.Clear();
  55
  56   if (!process_sp) {
  57     error.SetErrorString("invalid process");
  58   } else {
  59     error.SetError(
  60         process_sp->GetMetaData(GetTraceUID(), thread_id, buffer, offset));
  61   }
  62   return buffer.size();
  63 }
  64
  65 void SBTrace::StopTrace(SBError &error, lldb::tid_t thread_id) {
  66   LLDB_RECORD_METHOD(void, SBTrace, StopTrace, (lldb::SBError &, lldb::tid_t),
  67                      error, thread_id);
  68
  69   ProcessSP process_sp(GetSP());
  70   error.Clear();
  71
  72   if (!process_sp) {
  73     error.SetErrorString("invalid process");
  74     return;
  75   }
  76   error.SetError(process_sp->StopTrace(GetTraceUID(), thread_id));
  77 }
  78
  79 void SBTrace::GetTraceConfig(SBTraceOptions &options, SBError &error) {
  80   LLDB_RECORD_METHOD(void, SBTrace, GetTraceConfig,
  81                      (lldb::SBTraceOptions &, lldb::SBError &), options, error);
  82
  83   ProcessSP process_sp(GetSP());
  84   error.Clear();
  85
  86   if (!process_sp) {
  87     error.SetErrorString("invalid process");
  88   } else {
  89     error.SetError(process_sp->GetTraceConfig(GetTraceUID(),
  90                                               *(options.m_traceoptions_sp)));
  91   }
  92 }
  93
  94 lldb::user_id_t SBTrace::GetTraceUID() {
  95   LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBTrace, GetTraceUID);
  96
  97   if (m_trace_impl_sp)
  98     return m_trace_impl_sp->uid;
  99   return LLDB_INVALID_UID;
 100 }
 101
 102 void SBTrace::SetTraceUID(lldb::user_id_t uid) {
 103   if (m_trace_impl_sp)
 104     m_trace_impl_sp->uid = uid;
 105 }
 106
 107 SBTrace::SBTrace() {
 108   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTrace);
 109
 110   m_trace_impl_sp = std::make_shared<TraceImpl>();
 111   if (m_trace_impl_sp)
 112     m_trace_impl_sp->uid = LLDB_INVALID_UID;
 113 }
 114
 115 void SBTrace::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
 116
 117 bool SBTrace::IsValid() {
 118   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTrace, IsValid);
 119   return this->operator bool();
 120 }
 121 SBTrace::operator bool() const {
 122   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTrace, operator bool);
 123
 124   if (!m_trace_impl_sp)
 125     return false;
 126   if (!GetSP())
 127     return false;
 128   return true;
 129 }
 130
 131 namespace lldb_private {
 132 namespace repro {
 133
 134 template <>
 135 void RegisterMethods<SBTrace>(Registry &R) {
 136   LLDB_REGISTER_METHOD(void, SBTrace, StopTrace,
 137                        (lldb::SBError &, lldb::tid_t));
 138   LLDB_REGISTER_METHOD(void, SBTrace, GetTraceConfig,
 139                        (lldb::SBTraceOptions &, lldb::SBError &));
 140   LLDB_REGISTER_METHOD(lldb::user_id_t, SBTrace, GetTraceUID, ());
 141   LLDB_REGISTER_CONSTRUCTOR(SBTrace, ());
 142   LLDB_REGISTER_METHOD(bool, SBTrace, IsValid, ());
 143   LLDB_REGISTER_METHOD_CONST(bool, SBTrace, operator bool, ());
 144 }
 145
 146 }
 147 }