intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-14 11:57:39 +08:00
Code Issues Packages Projects Releases Wiki Activity

[lldb] Decouple instrumentation from the reproducers

Browse Source 
Remove the last remaining references to the reproducers from the
instrumentation. This patch renames the relevant files and macros.

Differential revision: https://reviews.llvm.org/D117712
This commit is contained in:
Jonas Devlieghere
2022-01-19 11:38:26 -08:00
parent f811cb82a6
commit 1755f5b1d7
74 changed files with 2230 additions and 3674 deletions
Download Patch File Download Diff File Expand all files Collapse all files

245
lldb/source/API/SBProcess.cpp
View File

@@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/API/SBProcess.h"
#include "lldb/Utility/ReproducerInstrumentation.h"
#include "lldb/Utility/Instrumentation.h"
#include <cinttypes>
@@ -49,22 +49,21 @@
using namespace lldb;
using namespace lldb_private;
SBProcess::SBProcess() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcess); }
SBProcess::SBProcess() { LLDB_INSTRUMENT_VA(this); }
// SBProcess constructor
SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) {
LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
}
SBProcess::SBProcess(const lldb::ProcessSP &process_sp)
: m_opaque_wp(process_sp) {
LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp);
LLDB_INSTRUMENT_VA(this, process_sp);
}
const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
LLDB_RECORD_METHOD(const lldb::SBProcess &,
SBProcess, operator=,(const lldb::SBProcess &), rhs);
LLDB_INSTRUMENT_VA(this, rhs);
if (this != &rhs)
m_opaque_wp = rhs.m_opaque_wp;
@@ -75,14 +74,13 @@ const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
SBProcess::~SBProcess() = default;
const char *SBProcess::GetBroadcasterClassName() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
GetBroadcasterClassName);
LLDB_INSTRUMENT();
return Process::GetStaticBroadcasterClass().AsCString();
}
const char *SBProcess::GetPluginName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName);
LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -92,7 +90,7 @@ const char *SBProcess::GetPluginName() {
}
const char *SBProcess::GetShortPluginName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName);
LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -106,17 +104,17 @@ lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); }
void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
void SBProcess::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear);
LLDB_INSTRUMENT_VA(this);
m_opaque_wp.reset();
}
bool SBProcess::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid);
LLDB_INSTRUMENT_VA(this);
return this->operator bool();
}
SBProcess::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, operator bool);
LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(m_opaque_wp.lock());
return ((bool)process_sp && process_sp->IsValid());
@@ -128,11 +126,7 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
const char *working_directory,
uint32_t launch_flags, bool stop_at_entry,
lldb::SBError &error) {
LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch,
(const char **, const char **, const char *, const char *,
const char *, const char *, uint32_t, bool,
lldb::SBError &),
argv, envp, stdin_path, stdout_path, stderr_path,
LLDB_INSTRUMENT_VA(this, argv, envp, stdin_path, stdout_path, stderr_path,
working_directory, launch_flags, stop_at_entry, error);
ProcessSP process_sp(GetSP());
@@ -165,8 +159,7 @@ bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
lldb::SBError &error) {
LLDB_RECORD_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
(lldb::pid_t, lldb::SBError &), pid, error);
LLDB_INSTRUMENT_VA(this, pid, error);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -188,7 +181,7 @@ bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
}
uint32_t SBProcess::GetNumThreads() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads);
LLDB_INSTRUMENT_VA(this);
uint32_t num_threads = 0;
ProcessSP process_sp(GetSP());
@@ -205,8 +198,7 @@ uint32_t SBProcess::GetNumThreads() {
}
SBThread SBProcess::GetSelectedThread() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess,
GetSelectedThread);
LLDB_INSTRUMENT_VA(this);
SBThread sb_thread;
ThreadSP thread_sp;
@@ -223,8 +215,7 @@ SBThread SBProcess::GetSelectedThread() const {
SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
lldb::addr_t context) {
LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread,
(lldb::tid_t, lldb::addr_t), tid, context);
LLDB_INSTRUMENT_VA(this, tid, context);
SBThread sb_thread;
ThreadSP thread_sp;
@@ -240,7 +231,7 @@ SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
}
SBTarget SBProcess::GetTarget() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget);
LLDB_INSTRUMENT_VA(this);
SBTarget sb_target;
TargetSP target_sp;
@@ -254,8 +245,7 @@ SBTarget SBProcess::GetTarget() const {
}
size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src,
src_len);
LLDB_INSTRUMENT_VA(this, src, src_len);
size_t ret_val = 0;
ProcessSP process_sp(GetSP());
@@ -268,8 +258,7 @@ size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
}
size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t), dst,
"", dst_len);
LLDB_INSTRUMENT_VA(this, dst, dst_len);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
@@ -282,8 +271,7 @@ size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const {
}
size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t), dst,
"", dst_len);
LLDB_INSTRUMENT_VA(this, dst, dst_len);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
@@ -296,8 +284,7 @@ size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const {
}
size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData,
(char *, size_t), dst, "", dst_len);
LLDB_INSTRUMENT_VA(this, dst, dst_len);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
@@ -310,23 +297,20 @@ size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const {
}
void SBProcess::ReportEventState(const SBEvent &event, SBFile out) const {
LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
(const SBEvent &, SBFile), event, out);
LLDB_INSTRUMENT_VA(this, event, out);
return ReportEventState(event, out.m_opaque_sp);
}
void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const {
LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
(const lldb::SBEvent &, FILE *), event, out);
LLDB_INSTRUMENT_VA(this, event, out);
FileSP outfile = std::make_shared<NativeFile>(out, false);
return ReportEventState(event, outfile);
}
void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const {
LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState,
(const SBEvent &, FileSP), event, out);
LLDB_INSTRUMENT_VA(this, event, out);
if (!out || !out->IsValid())
return;
@@ -342,9 +326,7 @@ void SBProcess::ReportEventState(const SBEvent &event, FileSP out) const {
void SBProcess::AppendEventStateReport(const SBEvent &event,
SBCommandReturnObject &result) {
LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport,
(const lldb::SBEvent &, lldb::SBCommandReturnObject &),
event, result);
LLDB_INSTRUMENT_VA(this, event, result);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -358,8 +340,7 @@ void SBProcess::AppendEventStateReport(const SBEvent &event,
}
bool SBProcess::SetSelectedThread(const SBThread &thread) {
LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread,
(const lldb::SBThread &), thread);
LLDB_INSTRUMENT_VA(this, thread);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -372,9 +353,7 @@ bool SBProcess::SetSelectedThread(const SBThread &thread) {
}
bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t),
tid);
LLDB_INSTRUMENT_VA(this, tid);
bool ret_val = false;
ProcessSP process_sp(GetSP());
@@ -388,8 +367,7 @@ bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
}
bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t),
index_id);
LLDB_INSTRUMENT_VA(this, index_id);
bool ret_val = false;
ProcessSP process_sp(GetSP());
@@ -404,8 +382,7 @@ bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
}
SBThread SBProcess::GetThreadAtIndex(size_t index) {
LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t),
index);
LLDB_INSTRUMENT_VA(this, index);
SBThread sb_thread;
ThreadSP thread_sp;
@@ -423,7 +400,7 @@ SBThread SBProcess::GetThreadAtIndex(size_t index) {
}
uint32_t SBProcess::GetNumQueues() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues);
LLDB_INSTRUMENT_VA(this);
uint32_t num_queues = 0;
ProcessSP process_sp(GetSP());
@@ -440,8 +417,7 @@ uint32_t SBProcess::GetNumQueues() {
}
SBQueue SBProcess::GetQueueAtIndex(size_t index) {
LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t),
index);
LLDB_INSTRUMENT_VA(this, index);
SBQueue sb_queue;
QueueSP queue_sp;
@@ -460,8 +436,7 @@ SBQueue SBProcess::GetQueueAtIndex(size_t index) {
}
uint32_t SBProcess::GetStopID(bool include_expression_stops) {
LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool),
include_expression_stops);
LLDB_INSTRUMENT_VA(this, include_expression_stops);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -476,8 +451,7 @@ uint32_t SBProcess::GetStopID(bool include_expression_stops) {
}
SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID,
(uint32_t), stop_id);
LLDB_INSTRUMENT_VA(this, stop_id);
SBEvent sb_event;
EventSP event_sp;
@@ -493,7 +467,7 @@ SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
}
StateType SBProcess::GetState() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState);
LLDB_INSTRUMENT_VA(this);
StateType ret_val = eStateInvalid;
ProcessSP process_sp(GetSP());
@@ -507,7 +481,7 @@ StateType SBProcess::GetState() {
}
int SBProcess::GetExitStatus() {
LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus);
LLDB_INSTRUMENT_VA(this);
int exit_status = 0;
ProcessSP process_sp(GetSP());
@@ -521,7 +495,7 @@ int SBProcess::GetExitStatus() {
}
const char *SBProcess::GetExitDescription() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription);
LLDB_INSTRUMENT_VA(this);
const char *exit_desc = nullptr;
ProcessSP process_sp(GetSP());
@@ -534,7 +508,7 @@ const char *SBProcess::GetExitDescription() {
}
lldb::pid_t SBProcess::GetProcessID() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID);
LLDB_INSTRUMENT_VA(this);
lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID;
ProcessSP process_sp(GetSP());
@@ -545,7 +519,7 @@ lldb::pid_t SBProcess::GetProcessID() {
}
uint32_t SBProcess::GetUniqueID() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID);
LLDB_INSTRUMENT_VA(this);
uint32_t ret_val = 0;
ProcessSP process_sp(GetSP());
@@ -555,7 +529,7 @@ uint32_t SBProcess::GetUniqueID() {
}
ByteOrder SBProcess::GetByteOrder() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder);
LLDB_INSTRUMENT_VA(this);
ByteOrder byteOrder = eByteOrderInvalid;
ProcessSP process_sp(GetSP());
@@ -567,7 +541,7 @@ ByteOrder SBProcess::GetByteOrder() const {
}
uint32_t SBProcess::GetAddressByteSize() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize);
LLDB_INSTRUMENT_VA(this);
uint32_t size = 0;
ProcessSP process_sp(GetSP());
@@ -579,7 +553,7 @@ uint32_t SBProcess::GetAddressByteSize() const {
}
SBError SBProcess::Continue() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue);
LLDB_INSTRUMENT_VA(this);
SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -599,7 +573,7 @@ SBError SBProcess::Continue() {
}
SBError SBProcess::Destroy() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy);
LLDB_INSTRUMENT_VA(this);
SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -614,7 +588,7 @@ SBError SBProcess::Destroy() {
}
SBError SBProcess::Stop() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop);
LLDB_INSTRUMENT_VA(this);
SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -629,7 +603,7 @@ SBError SBProcess::Stop() {
}
SBError SBProcess::Kill() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill);
LLDB_INSTRUMENT_VA(this);
SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -644,7 +618,7 @@ SBError SBProcess::Kill() {
}
SBError SBProcess::Detach() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach);
LLDB_INSTRUMENT_VA(this);
// FIXME: This should come from a process default.
bool keep_stopped = false;
@@ -652,7 +626,7 @@ SBError SBProcess::Detach() {
}
SBError SBProcess::Detach(bool keep_stopped) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped);
LLDB_INSTRUMENT_VA(this, keep_stopped);
SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -667,7 +641,7 @@ SBError SBProcess::Detach(bool keep_stopped) {
}
SBError SBProcess::Signal(int signo) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo);
LLDB_INSTRUMENT_VA(this, signo);
SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -682,7 +656,7 @@ SBError SBProcess::Signal(int signo) {
}
SBUnixSignals SBProcess::GetUnixSignals() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals);
LLDB_INSTRUMENT_VA(this);
if (auto process_sp = GetSP())
return SBUnixSignals{process_sp};
@@ -691,7 +665,7 @@ SBUnixSignals SBProcess::GetUnixSignals() {
}
void SBProcess::SendAsyncInterrupt() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt);
LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -700,8 +674,7 @@ void SBProcess::SendAsyncInterrupt() {
}
SBThread SBProcess::GetThreadByID(tid_t tid) {
LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t),
tid);
LLDB_INSTRUMENT_VA(this, tid);
SBThread sb_thread;
ThreadSP thread_sp;
@@ -719,8 +692,7 @@ SBThread SBProcess::GetThreadByID(tid_t tid) {
}
SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t),
index_id);
LLDB_INSTRUMENT_VA(this, index_id);
SBThread sb_thread;
ThreadSP thread_sp;
@@ -739,8 +711,7 @@ SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
}
StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get());
@@ -748,8 +719,7 @@ StateType SBProcess::GetStateFromEvent(const SBEvent &event) {
}
bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get());
@@ -757,8 +727,7 @@ bool SBProcess::GetRestartedFromEvent(const SBEvent &event) {
}
size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(size_t, SBProcess, GetNumRestartedReasonsFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
return Process::ProcessEventData::GetNumRestartedReasons(event.get());
}
@@ -766,16 +735,13 @@ size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) {
const char *
SBProcess::GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event,
size_t idx) {
LLDB_RECORD_STATIC_METHOD(const char *, SBProcess,
GetRestartedReasonAtIndexFromEvent,
(const lldb::SBEvent &, size_t), event, idx);
LLDB_INSTRUMENT_VA(event, idx);
return Process::ProcessEventData::GetRestartedReasonAtIndex(event.get(), idx);
}
SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
ProcessSP process_sp =
Process::ProcessEventData::GetProcessFromEvent(event.get());
@@ -788,32 +754,27 @@ SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) {
}
bool SBProcess::GetInterruptedFromEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
return Process::ProcessEventData::GetInterruptedFromEvent(event.get());
}
lldb::SBStructuredData
SBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(lldb::SBStructuredData, SBProcess,
GetStructuredDataFromEvent, (const lldb::SBEvent &),
event);
LLDB_INSTRUMENT_VA(event);
return SBStructuredData(event.GetSP());
}
bool SBProcess::EventIsProcessEvent(const SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) &&
!EventIsStructuredDataEvent(event);
}
bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent,
(const lldb::SBEvent &), event);
LLDB_INSTRUMENT_VA(event);
EventSP event_sp = event.GetSP();
EventData *event_data = event_sp ? event_sp->GetData() : nullptr;
@@ -822,9 +783,7 @@ bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
}
SBBroadcaster SBProcess::GetBroadcaster() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess,
GetBroadcaster);
LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
@@ -834,17 +793,14 @@ SBBroadcaster SBProcess::GetBroadcaster() const {
}
const char *SBProcess::GetBroadcasterClass() {
LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess,
GetBroadcasterClass);
LLDB_INSTRUMENT();
return Process::GetStaticBroadcasterClass().AsCString();
}
size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
SBError &sb_error) {
LLDB_RECORD_METHOD(size_t, SBProcess, ReadMemory,
(lldb::addr_t, void *, size_t, lldb::SBError &), addr, dst,
dst_len, sb_error);
LLDB_INSTRUMENT_VA(this, addr, dst, dst_len, sb_error);
size_t bytes_read = 0;
@@ -869,9 +825,7 @@ size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(size_t, SBProcess, ReadCStringFromMemory,
(lldb::addr_t, void *, size_t, lldb::SBError &), addr, buf,
size, sb_error);
LLDB_INSTRUMENT_VA(this, addr, buf, size, sb_error);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
@@ -893,9 +847,7 @@ size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory,
(lldb::addr_t, uint32_t, lldb::SBError &), addr, byte_size,
sb_error);
LLDB_INSTRUMENT_VA(this, addr, byte_size, sb_error);
uint64_t value = 0;
ProcessSP process_sp(GetSP());
@@ -917,8 +869,7 @@ uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory,
(lldb::addr_t, lldb::SBError &), addr, sb_error);
LLDB_INSTRUMENT_VA(this, addr, sb_error);
lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
ProcessSP process_sp(GetSP());
@@ -939,9 +890,7 @@ lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
SBError &sb_error) {
LLDB_RECORD_METHOD(size_t, SBProcess, WriteMemory,
(lldb::addr_t, const void *, size_t, lldb::SBError &),
addr, src, src_len, sb_error);
LLDB_INSTRUMENT_VA(this, addr, src, src_len, sb_error);
size_t bytes_written = 0;
@@ -963,8 +912,7 @@ size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
}
bool SBProcess::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &),
description);
LLDB_INSTRUMENT_VA(this, description);
Stream &strm = description.ref();
@@ -988,8 +936,7 @@ bool SBProcess::GetDescription(SBStream &description) {
}
SBStructuredData SBProcess::GetExtendedCrashInformation() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBProcess,
GetExtendedCrashInformation);
LLDB_INSTRUMENT_VA(this);
SBStructuredData data;
ProcessSP process_sp(GetSP());
if (!process_sp)
@@ -1013,9 +960,7 @@ SBStructuredData SBProcess::GetExtendedCrashInformation() {
uint32_t
SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess,
GetNumSupportedHardwareWatchpoints,
(lldb::SBError &), sb_error);
LLDB_INSTRUMENT_VA(this, sb_error);
uint32_t num = 0;
ProcessSP process_sp(GetSP());
@@ -1031,9 +976,7 @@ SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const {
uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImage,
(lldb::SBFileSpec &, lldb::SBError &),
sb_remote_image_spec, sb_error);
LLDB_INSTRUMENT_VA(this, sb_remote_image_spec, sb_error);
return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error);
}
@@ -1041,10 +984,7 @@ uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec,
const lldb::SBFileSpec &sb_remote_image_spec,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(
uint32_t, SBProcess, LoadImage,
(const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &),
sb_local_image_spec, sb_remote_image_spec, sb_error);
LLDB_INSTRUMENT_VA(this, sb_local_image_spec, sb_remote_image_spec, sb_error);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -1068,10 +1008,7 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
SBStringList &paths,
lldb::SBFileSpec &loaded_path,
lldb::SBError &error) {
LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths,
(const lldb::SBFileSpec &, lldb::SBStringList &,
lldb::SBFileSpec &, lldb::SBError &),
image_spec, paths, loaded_path, error);
LLDB_INSTRUMENT_VA(this, image_spec, paths, loaded_path, error);
ProcessSP process_sp(GetSP());
if (process_sp) {
@@ -1103,8 +1040,7 @@ uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
}
lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t),
image_token);
LLDB_INSTRUMENT_VA(this, image_token);
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -1125,8 +1061,7 @@ lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
}
lldb::SBError SBProcess::SendEventData(const char *event_data) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *),
event_data);
LLDB_INSTRUMENT_VA(this, event_data);
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -1145,7 +1080,7 @@ lldb::SBError SBProcess::SendEventData(const char *event_data) {
}
uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes);
LLDB_INSTRUMENT_VA(this);
ProcessSP process_sp(GetSP());
if (process_sp && process_sp->GetSystemRuntime()) {
@@ -1156,8 +1091,7 @@ uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
}
const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex,
(uint32_t), idx);
LLDB_INSTRUMENT_VA(this, idx);
ProcessSP process_sp(GetSP());
if (process_sp && process_sp->GetSystemRuntime()) {
@@ -1172,8 +1106,7 @@ const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
}
SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads,
(lldb::addr_t), addr);
LLDB_INSTRUMENT_VA(this, addr);
ProcessSP process_sp(GetSP());
SBThreadCollection threads;
@@ -1185,8 +1118,7 @@ SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
bool SBProcess::IsInstrumentationRuntimePresent(
InstrumentationRuntimeType type) {
LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent,
(lldb::InstrumentationRuntimeType), type);
LLDB_INSTRUMENT_VA(this, type);
ProcessSP process_sp(GetSP());
if (!process_sp)
@@ -1205,8 +1137,7 @@ bool SBProcess::IsInstrumentationRuntimePresent(
}
lldb::SBError SBProcess::SaveCore(const char *file_name) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *),
file_name);
LLDB_INSTRUMENT_VA(this, file_name);
lldb::SBError error;
ProcessSP process_sp(GetSP());
@@ -1232,9 +1163,7 @@ lldb::SBError SBProcess::SaveCore(const char *file_name) {
lldb::SBError
SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
SBMemoryRegionInfo &sb_region_info) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
(lldb::addr_t, lldb::SBMemoryRegionInfo &), load_addr,
sb_region_info);
LLDB_INSTRUMENT_VA(this, load_addr, sb_region_info);
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());
@@ -1256,8 +1185,7 @@ SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
}
lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess,
GetMemoryRegions);
LLDB_INSTRUMENT_VA(this);
lldb::SBMemoryRegionInfoList sb_region_list;
@@ -1274,7 +1202,7 @@ lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
}
lldb::SBProcessInfo SBProcess::GetProcessInfo() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo);
LLDB_INSTRUMENT_VA(this);
lldb::SBProcessInfo sb_proc_info;
ProcessSP process_sp(GetSP());
@@ -1287,9 +1215,7 @@ lldb::SBProcessInfo SBProcess::GetProcessInfo() {
lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions,
lldb::SBError &sb_error) {
LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, AllocateMemory,
(size_t, uint32_t, lldb::SBError &), size, permissions,
sb_error);
LLDB_INSTRUMENT_VA(this, size, permissions, sb_error);
lldb::addr_t addr = LLDB_INVALID_ADDRESS;
ProcessSP process_sp(GetSP());
@@ -1309,8 +1235,7 @@ lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions,
}
lldb::SBError SBProcess::DeallocateMemory(lldb::addr_t ptr) {
LLDB_RECORD_METHOD(lldb::SBError, SBProcess, DeallocateMemory, (lldb::addr_t),
ptr);
LLDB_INSTRUMENT_VA(this, ptr);
lldb::SBError sb_error;
ProcessSP process_sp(GetSP());