diff options
Diffstat (limited to 'lldb/source/API/SBTarget.cpp')
| -rw-r--r-- | lldb/source/API/SBTarget.cpp | 999 |
1 files changed, 276 insertions, 723 deletions
diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp index dc79c77fee9e..75534b2343d4 100644 --- a/lldb/source/API/SBTarget.cpp +++ b/lldb/source/API/SBTarget.cpp @@ -7,7 +7,7 @@ //===----------------------------------------------------------------------===// #include "lldb/API/SBTarget.h" -#include "SBReproducerPrivate.h" +#include "lldb/Utility/Instrumentation.h" #include "lldb/lldb-public.h" @@ -93,48 +93,41 @@ static Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) { } // SBTarget constructor -SBTarget::SBTarget() : m_opaque_sp() { - LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTarget); -} +SBTarget::SBTarget() { LLDB_INSTRUMENT_VA(this); } SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &), rhs); + LLDB_INSTRUMENT_VA(this, rhs); } SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) { - LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &), target_sp); + LLDB_INSTRUMENT_VA(this, target_sp); } const SBTarget &SBTarget::operator=(const SBTarget &rhs) { - LLDB_RECORD_METHOD(const lldb::SBTarget &, - SBTarget, operator=,(const lldb::SBTarget &), rhs); + LLDB_INSTRUMENT_VA(this, rhs); if (this != &rhs) m_opaque_sp = rhs.m_opaque_sp; - return LLDB_RECORD_RESULT(*this); + return *this; } // Destructor SBTarget::~SBTarget() = default; bool SBTarget::EventIsTargetEvent(const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_VA(event); return Target::TargetEventData::GetEventDataFromEvent(event.get()) != nullptr; } SBTarget SBTarget::GetTargetFromEvent(const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_VA(event); - return LLDB_RECORD_RESULT( - Target::TargetEventData::GetTargetFromEvent(event.get())); + return Target::TargetEventData::GetTargetFromEvent(event.get()); } uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent, - (const lldb::SBEvent &), event); + LLDB_INSTRUMENT_VA(event); const ModuleList module_list = Target::TargetEventData::GetModuleListFromEvent(event.get()); @@ -143,34 +136,31 @@ uint32_t SBTarget::GetNumModulesFromEvent(const SBEvent &event) { SBModule SBTarget::GetModuleAtIndexFromEvent(const uint32_t idx, const SBEvent &event) { - LLDB_RECORD_STATIC_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndexFromEvent, - (const uint32_t, const lldb::SBEvent &), idx, - event); + LLDB_INSTRUMENT_VA(idx, event); const ModuleList module_list = Target::TargetEventData::GetModuleListFromEvent(event.get()); - return LLDB_RECORD_RESULT(SBModule(module_list.GetModuleAtIndex(idx))); + return SBModule(module_list.GetModuleAtIndex(idx)); } const char *SBTarget::GetBroadcasterClassName() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBTarget, - GetBroadcasterClassName); + LLDB_INSTRUMENT(); return Target::GetStaticBroadcasterClass().AsCString(); } bool SBTarget::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, IsValid); + LLDB_INSTRUMENT_VA(this); return this->operator bool(); } SBTarget::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, operator bool); + LLDB_INSTRUMENT_VA(this); return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid(); } SBProcess SBTarget::GetProcess() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBTarget, GetProcess); + LLDB_INSTRUMENT_VA(this); SBProcess sb_process; ProcessSP process_sp; @@ -180,49 +170,49 @@ SBProcess SBTarget::GetProcess() { sb_process.SetSP(process_sp); } - return LLDB_RECORD_RESULT(sb_process); + return sb_process; } SBPlatform SBTarget::GetPlatform() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (!target_sp) - return LLDB_RECORD_RESULT(SBPlatform()); + return SBPlatform(); SBPlatform platform; platform.m_opaque_sp = target_sp->GetPlatform(); - return LLDB_RECORD_RESULT(platform); + return platform; } SBDebugger SBTarget::GetDebugger() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBDebugger, SBTarget, GetDebugger); + LLDB_INSTRUMENT_VA(this); SBDebugger debugger; TargetSP target_sp(GetSP()); if (target_sp) debugger.reset(target_sp->GetDebugger().shared_from_this()); - return LLDB_RECORD_RESULT(debugger); + return debugger; } SBStructuredData SBTarget::GetStatistics() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics); + LLDB_INSTRUMENT_VA(this); SBStructuredData data; TargetSP target_sp(GetSP()); if (!target_sp) - return LLDB_RECORD_RESULT(data); + return data; std::string json_str = llvm::formatv("{0:2}", DebuggerStats::ReportStatistics(target_sp->GetDebugger(), target_sp.get())).str(); data.m_impl_up->SetObjectSP(StructuredData::ParseJSON(json_str)); - return LLDB_RECORD_RESULT(data); + return data; } void SBTarget::SetCollectingStats(bool v) { - LLDB_RECORD_METHOD(void, SBTarget, SetCollectingStats, (bool), v); + LLDB_INSTRUMENT_VA(this, v); TargetSP target_sp(GetSP()); if (!target_sp) @@ -231,7 +221,7 @@ void SBTarget::SetCollectingStats(bool v) { } bool SBTarget::GetCollectingStats() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, GetCollectingStats); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (!target_sp) @@ -240,16 +230,14 @@ bool SBTarget::GetCollectingStats() { } SBProcess SBTarget::LoadCore(const char *core_file) { - LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *), - core_file); + LLDB_INSTRUMENT_VA(this, core_file); lldb::SBError error; // Ignored - return LLDB_RECORD_RESULT(LoadCore(core_file, error)); + return LoadCore(core_file, error); } SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) { - LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LoadCore, - (const char *, lldb::SBError &), core_file, error); + LLDB_INSTRUMENT_VA(this, core_file, error); SBProcess sb_process; TargetSP target_sp(GetSP()); @@ -268,18 +256,16 @@ SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) { } else { error.SetErrorString("SBTarget is invalid"); } - return LLDB_RECORD_RESULT(sb_process); + return sb_process; } SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp, const char *working_directory) { - LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, LaunchSimple, - (const char **, const char **, const char *), argv, envp, - working_directory); + LLDB_INSTRUMENT_VA(this, argv, envp, working_directory); TargetSP target_sp = GetSP(); if (!target_sp) - return LLDB_RECORD_RESULT(SBProcess()); + return SBProcess(); SBLaunchInfo launch_info = GetLaunchInfo(); @@ -294,11 +280,11 @@ SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp, launch_info.SetWorkingDirectory(working_directory); SBError error; - return LLDB_RECORD_RESULT(Launch(launch_info, error)); + return Launch(launch_info, error); } SBError SBTarget::Install() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBTarget, Install); + LLDB_INSTRUMENT_VA(this); SBError sb_error; TargetSP target_sp(GetSP()); @@ -306,7 +292,7 @@ SBError SBTarget::Install() { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); sb_error.ref() = target_sp->Install(nullptr); } - return LLDB_RECORD_RESULT(sb_error); + return sb_error; } SBProcess SBTarget::Launch(SBListener &listener, char const **argv, @@ -315,12 +301,9 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv, const char *working_directory, uint32_t launch_flags, // See LaunchFlags bool stop_at_entry, lldb::SBError &error) { - LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch, - (lldb::SBListener &, const char **, const char **, - const char *, const char *, const char *, const char *, - uint32_t, bool, lldb::SBError &), - listener, argv, envp, stdin_path, stdout_path, stderr_path, - working_directory, launch_flags, stop_at_entry, error); + LLDB_INSTRUMENT_VA(this, listener, argv, envp, stdin_path, stdout_path, + stderr_path, working_directory, launch_flags, + stop_at_entry, error); SBProcess sb_process; ProcessSP process_sp; @@ -345,7 +328,7 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv, error.SetErrorString("process attach is in progress"); else error.SetErrorString("a process is already being debugged"); - return LLDB_RECORD_RESULT(sb_process); + return sb_process; } } @@ -356,7 +339,7 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv, if (listener.IsValid()) { error.SetErrorString("process is connected and already has a listener, " "pass empty listener"); - return LLDB_RECORD_RESULT(sb_process); + return sb_process; } } @@ -394,14 +377,11 @@ SBProcess SBTarget::Launch(SBListener &listener, char const **argv, error.SetErrorString("SBTarget is invalid"); } - return LLDB_RECORD_RESULT(sb_process); + return sb_process; } SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) { - LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Launch, - (lldb::SBLaunchInfo &, lldb::SBError &), sb_launch_info, - error); - + LLDB_INSTRUMENT_VA(this, sb_launch_info, error); SBProcess sb_process; TargetSP target_sp(GetSP()); @@ -419,7 +399,7 @@ SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) { error.SetErrorString("process attach is in progress"); else error.SetErrorString("a process is already being debugged"); - return LLDB_RECORD_RESULT(sb_process); + return sb_process; } } } @@ -443,13 +423,11 @@ SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) { error.SetErrorString("SBTarget is invalid"); } - return LLDB_RECORD_RESULT(sb_process); + return sb_process; } lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) { - LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, Attach, - (lldb::SBAttachInfo &, lldb::SBError &), sb_attach_info, - error); + LLDB_INSTRUMENT_VA(this, sb_attach_info, error); SBProcess sb_process; TargetSP target_sp(GetSP()); @@ -467,7 +445,7 @@ lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) { } else { error.ref().SetErrorStringWithFormat( "no process found with process ID %" PRIu64, attach_pid); - return LLDB_RECORD_RESULT(sb_process); + return sb_process; } } } @@ -478,7 +456,7 @@ lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) { error.SetErrorString("SBTarget is invalid"); } - return LLDB_RECORD_RESULT(sb_process); + return sb_process; } lldb::SBProcess SBTarget::AttachToProcessWithID( @@ -486,9 +464,7 @@ lldb::SBProcess SBTarget::AttachToProcessWithID( lldb::pid_t pid, // The process ID to attach to SBError &error // An error explaining what went wrong if attach fails ) { - LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID, - (lldb::SBListener &, lldb::pid_t, lldb::SBError &), - listener, pid, error); + LLDB_INSTRUMENT_VA(this, listener, pid, error); SBProcess sb_process; TargetSP target_sp(GetSP()); @@ -509,7 +485,7 @@ lldb::SBProcess SBTarget::AttachToProcessWithID( } else error.SetErrorString("SBTarget is invalid"); - return LLDB_RECORD_RESULT(sb_process); + return sb_process; } lldb::SBProcess SBTarget::AttachToProcessWithName( @@ -518,9 +494,7 @@ lldb::SBProcess SBTarget::AttachToProcessWithName( bool wait_for, // if true wait for a new instance of "name" to be launched SBError &error // An error explaining what went wrong if attach fails ) { - LLDB_RECORD_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithName, - (lldb::SBListener &, const char *, bool, lldb::SBError &), - listener, name, wait_for, error); + LLDB_INSTRUMENT_VA(this, listener, name, wait_for, error); SBProcess sb_process; TargetSP target_sp(GetSP()); @@ -538,16 +512,13 @@ lldb::SBProcess SBTarget::AttachToProcessWithName( } else error.SetErrorString("SBTarget is invalid"); - return LLDB_RECORD_RESULT(sb_process); + return sb_process; } lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url, const char *plugin_name, SBError &error) { - LLDB_RECORD_METHOD( - lldb::SBProcess, SBTarget, ConnectRemote, - (lldb::SBListener &, const char *, const char *, lldb::SBError &), - listener, url, plugin_name, error); + LLDB_INSTRUMENT_VA(this, listener, url, plugin_name, error); SBProcess sb_process; ProcessSP process_sp; @@ -573,11 +544,11 @@ lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url, error.SetErrorString("SBTarget is invalid"); } - return LLDB_RECORD_RESULT(sb_process); + return sb_process; } SBFileSpec SBTarget::GetExecutable() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBTarget, GetExecutable); + LLDB_INSTRUMENT_VA(this); SBFileSpec exe_file_spec; TargetSP target_sp(GetSP()); @@ -587,19 +558,17 @@ SBFileSpec SBTarget::GetExecutable() { exe_file_spec.SetFileSpec(exe_module->GetFileSpec()); } - return LLDB_RECORD_RESULT(exe_file_spec); + return exe_file_spec; } bool SBTarget::operator==(const SBTarget &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator==,(const lldb::SBTarget &), - rhs); + LLDB_INSTRUMENT_VA(this, rhs); return m_opaque_sp.get() == rhs.m_opaque_sp.get(); } bool SBTarget::operator!=(const SBTarget &rhs) const { - LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator!=,(const lldb::SBTarget &), - rhs); + LLDB_INSTRUMENT_VA(this, rhs); return m_opaque_sp.get() != rhs.m_opaque_sp.get(); } @@ -611,8 +580,7 @@ void SBTarget::SetSP(const lldb::TargetSP &target_sp) { } lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) { - LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress, - (lldb::addr_t), vm_addr); + LLDB_INSTRUMENT_VA(this, vm_addr); lldb::SBAddress sb_addr; Address &addr = sb_addr.ref(); @@ -620,18 +588,17 @@ lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) { if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); if (target_sp->ResolveLoadAddress(vm_addr, addr)) - return LLDB_RECORD_RESULT(sb_addr); + return sb_addr; } // We have a load address that isn't in a section, just return an address // with the offset filled in (the address) and the section set to NULL addr.SetRawAddress(vm_addr); - return LLDB_RECORD_RESULT(sb_addr); + return sb_addr; } lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) { - LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress, - (lldb::addr_t), file_addr); + LLDB_INSTRUMENT_VA(this, file_addr); lldb::SBAddress sb_addr; Address &addr = sb_addr.ref(); @@ -639,17 +606,16 @@ lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) { if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); if (target_sp->ResolveFileAddress(file_addr, addr)) - return LLDB_RECORD_RESULT(sb_addr); + return sb_addr; } addr.SetRawAddress(file_addr); - return LLDB_RECORD_RESULT(sb_addr); + return sb_addr; } lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id, lldb::addr_t vm_addr) { - LLDB_RECORD_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress, - (uint32_t, lldb::addr_t), stop_id, vm_addr); + LLDB_INSTRUMENT_VA(this, stop_id, vm_addr); lldb::SBAddress sb_addr; Address &addr = sb_addr.ref(); @@ -657,21 +623,19 @@ lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id, if (target_sp) { std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); if (target_sp->ResolveLoadAddress(vm_addr, addr)) - return LLDB_RECORD_RESULT(sb_addr); + return sb_addr; } // We have a load address that isn't in a section, just return an address // with the offset filled in (the address) and the section set to NULL addr.SetRawAddress(vm_addr); - return LLDB_RECORD_RESULT(sb_addr); + return sb_addr; } SBSymbolContext SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr, uint32_t resolve_scope) { - LLDB_RECORD_METHOD(lldb::SBSymbolContext, SBTarget, - ResolveSymbolContextForAddress, - (const lldb::SBAddress &, uint32_t), addr, resolve_scope); + LLDB_INSTRUMENT_VA(this, addr, resolve_scope); SBSymbolContext sc; SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope); @@ -681,14 +645,12 @@ SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr, target_sp->GetImages().ResolveSymbolContextForAddress(addr.ref(), scope, sc.ref()); } - return LLDB_RECORD_RESULT(sc); + return sc; } size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size, lldb::SBError &error) { - LLDB_RECORD_METHOD(size_t, SBTarget, ReadMemory, - (const lldb::SBAddress, void *, size_t, lldb::SBError &), - addr, buf, size, error); + LLDB_INSTRUMENT_VA(this, addr, buf, size, error); SBError sb_error; size_t bytes_read = 0; @@ -706,54 +668,43 @@ size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size, SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file, uint32_t line) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, - (const char *, uint32_t), file, line); + LLDB_INSTRUMENT_VA(this, file, line); - return LLDB_RECORD_RESULT( - SBBreakpoint(BreakpointCreateByLocation(SBFileSpec(file, false), line))); + return SBBreakpoint( + BreakpointCreateByLocation(SBFileSpec(file, false), line)); } SBBreakpoint SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, uint32_t line) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, - (const lldb::SBFileSpec &, uint32_t), sb_file_spec, line); + LLDB_INSTRUMENT_VA(this, sb_file_spec, line); - return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0)); + return BreakpointCreateByLocation(sb_file_spec, line, 0); } SBBreakpoint SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, uint32_t line, lldb::addr_t offset) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, - (const lldb::SBFileSpec &, uint32_t, lldb::addr_t), - sb_file_spec, line, offset); + LLDB_INSTRUMENT_VA(this, sb_file_spec, line, offset); SBFileSpecList empty_list; - return LLDB_RECORD_RESULT( - BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list)); + return BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list); } SBBreakpoint SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec, uint32_t line, lldb::addr_t offset, SBFileSpecList &sb_module_list) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, - (const lldb::SBFileSpec &, uint32_t, lldb::addr_t, - lldb::SBFileSpecList &), - sb_file_spec, line, offset, sb_module_list); + LLDB_INSTRUMENT_VA(this, sb_file_spec, line, offset, sb_module_list); - return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0, - offset, sb_module_list)); + return BreakpointCreateByLocation(sb_file_spec, line, 0, offset, + sb_module_list); } SBBreakpoint SBTarget::BreakpointCreateByLocation( const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column, lldb::addr_t offset, SBFileSpecList &sb_module_list) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, - (const lldb::SBFileSpec &, uint32_t, uint32_t, - lldb::addr_t, lldb::SBFileSpecList &), - sb_file_spec, line, column, offset, sb_module_list); + LLDB_INSTRUMENT_VA(this, sb_file_spec, line, column, offset, sb_module_list); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -774,17 +725,14 @@ SBBreakpoint SBTarget::BreakpointCreateByLocation( skip_prologue, internal, hardware, move_to_nearest_code); } - return LLDB_RECORD_RESULT(sb_bp); + return sb_bp; } SBBreakpoint SBTarget::BreakpointCreateByLocation( const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column, lldb::addr_t offset, SBFileSpecList &sb_module_list, bool move_to_nearest_code) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, - (const lldb::SBFileSpec &, uint32_t, uint32_t, - lldb::addr_t, lldb::SBFileSpecList &, bool), - sb_file_spec, line, column, offset, sb_module_list, + LLDB_INSTRUMENT_VA(this, sb_file_spec, line, column, offset, sb_module_list, move_to_nearest_code); SBBreakpoint sb_bp; @@ -806,13 +754,12 @@ SBBreakpoint SBTarget::BreakpointCreateByLocation( move_to_nearest_code ? eLazyBoolYes : eLazyBoolNo); } - return LLDB_RECORD_RESULT(sb_bp); + return sb_bp; } SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, const char *module_name) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, - (const char *, const char *), symbol_name, module_name); + LLDB_INSTRUMENT_VA(this, symbol_name, module_name); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -836,47 +783,38 @@ SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, } } - return LLDB_RECORD_RESULT(sb_bp); + return sb_bp; } lldb::SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, - (const char *, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &), - symbol_name, module_list, comp_unit_list); + LLDB_INSTRUMENT_VA(this, symbol_name, module_list, comp_unit_list); lldb::FunctionNameType name_type_mask = eFunctionNameTypeAuto; - return LLDB_RECORD_RESULT( - BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown, - module_list, comp_unit_list)); + return BreakpointCreateByName(symbol_name, name_type_mask, + eLanguageTypeUnknown, module_list, + comp_unit_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateByName( const char *symbol_name, uint32_t name_type_mask, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, - (const char *, uint32_t, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &), - symbol_name, name_type_mask, module_list, comp_unit_list); + LLDB_INSTRUMENT_VA(this, symbol_name, name_type_mask, module_list, + comp_unit_list); - return LLDB_RECORD_RESULT( - BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown, - module_list, comp_unit_list)); + return BreakpointCreateByName(symbol_name, name_type_mask, + eLanguageTypeUnknown, module_list, + comp_unit_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateByName( const char *symbol_name, uint32_t name_type_mask, LanguageType symbol_language, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, - (const char *, uint32_t, lldb::LanguageType, - const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &), - symbol_name, name_type_mask, symbol_language, module_list, - comp_unit_list); + LLDB_INSTRUMENT_VA(this, symbol_name, name_type_mask, symbol_language, + module_list, comp_unit_list); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -891,49 +829,38 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByName( skip_prologue, internal, hardware); } - return LLDB_RECORD_RESULT(sb_bp); + return sb_bp; } lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { - LLDB_RECORD_METHOD( - lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, - (const char **, uint32_t, uint32_t, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &), - symbol_names, num_names, name_type_mask, module_list, comp_unit_list); + LLDB_INSTRUMENT_VA(this, symbol_names, num_names, name_type_mask, module_list, + comp_unit_list); - return LLDB_RECORD_RESULT(BreakpointCreateByNames( - symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, - module_list, comp_unit_list)); + return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, + eLanguageTypeUnknown, module_list, + comp_unit_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, LanguageType symbol_language, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, - (const char **, uint32_t, uint32_t, lldb::LanguageType, - const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &), - symbol_names, num_names, name_type_mask, symbol_language, - module_list, comp_unit_list); + LLDB_INSTRUMENT_VA(this, symbol_names, num_names, name_type_mask, + symbol_language, module_list, comp_unit_list); - return LLDB_RECORD_RESULT(BreakpointCreateByNames( - symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, 0, - module_list, comp_unit_list)); + return BreakpointCreateByNames(symbol_names, num_names, name_type_mask, + eLanguageTypeUnknown, 0, module_list, + comp_unit_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask, LanguageType symbol_language, lldb::addr_t offset, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, - (const char **, uint32_t, uint32_t, lldb::LanguageType, - lldb::addr_t, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &), - symbol_names, num_names, name_type_mask, symbol_language, - offset, module_list, comp_unit_list); + LLDB_INSTRUMENT_VA(this, symbol_names, num_names, name_type_mask, + symbol_language, offset, module_list, comp_unit_list); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -948,47 +875,37 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByNames( symbol_language, offset, skip_prologue, internal, hardware); } - return LLDB_RECORD_RESULT(sb_bp); + return sb_bp; } SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, const char *module_name) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, - (const char *, const char *), symbol_name_regex, - module_name); + LLDB_INSTRUMENT_VA(this, symbol_name_regex, module_name); SBFileSpecList module_spec_list; SBFileSpecList comp_unit_list; if (module_name && module_name[0]) { module_spec_list.Append(FileSpec(module_name)); } - return LLDB_RECORD_RESULT( - BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, - module_spec_list, comp_unit_list)); + return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, + module_spec_list, comp_unit_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, - (const char *, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &), - symbol_name_regex, module_list, comp_unit_list); + LLDB_INSTRUMENT_VA(this, symbol_name_regex, module_list, comp_unit_list); - return LLDB_RECORD_RESULT(BreakpointCreateByRegex( - symbol_name_regex, eLanguageTypeUnknown, module_list, comp_unit_list)); + return BreakpointCreateByRegex(symbol_name_regex, eLanguageTypeUnknown, + module_list, comp_unit_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex( const char *symbol_name_regex, LanguageType symbol_language, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) { - LLDB_RECORD_METHOD( - lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, - (const char *, lldb::LanguageType, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &), - symbol_name_regex, symbol_language, module_list, comp_unit_list); - + LLDB_INSTRUMENT_VA(this, symbol_name_regex, symbol_language, module_list, + comp_unit_list); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -1004,12 +921,11 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex( symbol_language, skip_prologue, internal, hardware); } - return LLDB_RECORD_RESULT(sb_bp); + return sb_bp; } SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByAddress, - (lldb::addr_t), address); + LLDB_INSTRUMENT_VA(this, address); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -1019,17 +935,16 @@ SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) { sb_bp = target_sp->CreateBreakpoint(address, false, hardware); } - return LLDB_RECORD_RESULT(sb_bp); + return sb_bp; } SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateBySBAddress, - (lldb::SBAddress &), sb_address); + LLDB_INSTRUMENT_VA(this, sb_address); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); if (!sb_address.IsValid()) { - return LLDB_RECORD_RESULT(sb_bp); + return sb_bp; } if (target_sp) { @@ -1038,17 +953,14 @@ SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) { sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware); } - return LLDB_RECORD_RESULT(sb_bp); + return sb_bp; } lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(const char *source_regex, const lldb::SBFileSpec &source_file, const char *module_name) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, - BreakpointCreateBySourceRegex, - (const char *, const lldb::SBFileSpec &, const char *), - source_regex, source_file, module_name); + LLDB_INSTRUMENT_VA(this, source_regex, source_file, module_name); SBFileSpecList module_spec_list; @@ -1061,32 +973,25 @@ SBTarget::BreakpointCreateBySourceRegex(const char *source_regex, source_file_list.Append(source_file); } - return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex( - source_regex, module_spec_list, source_file_list)); + return BreakpointCreateBySourceRegex(source_regex, module_spec_list, + source_file_list); } lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( const char *source_regex, const SBFileSpecList &module_list, const lldb::SBFileSpecList &source_file_list) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, - BreakpointCreateBySourceRegex, - (const char *, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &), - source_regex, module_list, source_file_list); + LLDB_INSTRUMENT_VA(this, source_regex, module_list, source_file_list); - return LLDB_RECORD_RESULT(BreakpointCreateBySourceRegex( - source_regex, module_list, source_file_list, SBStringList())); + return BreakpointCreateBySourceRegex(source_regex, module_list, + source_file_list, SBStringList()); } lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( const char *source_regex, const SBFileSpecList &module_list, const lldb::SBFileSpecList &source_file_list, const SBStringList &func_names) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, - BreakpointCreateBySourceRegex, - (const char *, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &, const lldb::SBStringList &), - source_regex, module_list, source_file_list, func_names); + LLDB_INSTRUMENT_VA(this, source_regex, module_list, source_file_list, + func_names); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -1105,15 +1010,13 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex( std::move(regexp), false, hardware, move_to_nearest_code); } - return LLDB_RECORD_RESULT(sb_bp); + return sb_bp; } lldb::SBBreakpoint SBTarget::BreakpointCreateForException(lldb::LanguageType language, bool catch_bp, bool throw_bp) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateForException, - (lldb::LanguageType, bool, bool), language, catch_bp, - throw_bp); + LLDB_INSTRUMENT_VA(this, language, catch_bp, throw_bp); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -1124,18 +1027,15 @@ SBTarget::BreakpointCreateForException(lldb::LanguageType language, hardware); } - return LLDB_RECORD_RESULT(sb_bp); + return sb_bp; } lldb::SBBreakpoint SBTarget::BreakpointCreateFromScript( const char *class_name, SBStructuredData &extra_args, const SBFileSpecList &module_list, const SBFileSpecList &file_list, bool request_hardware) { - LLDB_RECORD_METHOD( - lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript, - (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &, bool), - class_name, extra_args, module_list, file_list, request_hardware); + LLDB_INSTRUMENT_VA(this, class_name, extra_args, module_list, file_list, + request_hardware); SBBreakpoint sb_bp; TargetSP target_sp(GetSP()); @@ -1154,11 +1054,11 @@ lldb::SBBreakpoint SBTarget::BreakpointCreateFromScript( &error); } - return LLDB_RECORD_RESULT(sb_bp); + return sb_bp; } uint32_t SBTarget::GetNumBreakpoints() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumBreakpoints); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1169,8 +1069,7 @@ uint32_t SBTarget::GetNumBreakpoints() const { } SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const { - LLDB_RECORD_METHOD_CONST(lldb::SBBreakpoint, SBTarget, GetBreakpointAtIndex, - (uint32_t), idx); + LLDB_INSTRUMENT_VA(this, idx); SBBreakpoint sb_breakpoint; TargetSP target_sp(GetSP()); @@ -1178,12 +1077,11 @@ SBBreakpoint SBTarget::GetBreakpointAtIndex(uint32_t idx) const { // The breakpoint list is thread safe, no need to lock sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx); } - return LLDB_RECORD_RESULT(sb_breakpoint); + return sb_breakpoint; } bool SBTarget::BreakpointDelete(break_id_t bp_id) { - LLDB_RECORD_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t), - bp_id); + LLDB_INSTRUMENT_VA(this, bp_id); bool result = false; TargetSP target_sp(GetSP()); @@ -1196,8 +1094,7 @@ bool SBTarget::BreakpointDelete(break_id_t bp_id) { } SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) { - LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID, - (lldb::break_id_t), bp_id); + LLDB_INSTRUMENT_VA(this, bp_id); SBBreakpoint sb_breakpoint; TargetSP target_sp(GetSP()); @@ -1206,13 +1103,12 @@ SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) { sb_breakpoint = target_sp->GetBreakpointByID(bp_id); } - return LLDB_RECORD_RESULT(sb_breakpoint); + return sb_breakpoint; } bool SBTarget::FindBreakpointsByName(const char *name, SBBreakpointList &bkpts) { - LLDB_RECORD_METHOD(bool, SBTarget, FindBreakpointsByName, - (const char *, lldb::SBBreakpointList &), name, bkpts); + LLDB_INSTRUMENT_VA(this, name, bkpts); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1233,8 +1129,7 @@ bool SBTarget::FindBreakpointsByName(const char *name, } void SBTarget::GetBreakpointNames(SBStringList &names) { - LLDB_RECORD_METHOD(void, SBTarget, GetBreakpointNames, (lldb::SBStringList &), - names); + LLDB_INSTRUMENT_VA(this, names); names.Clear(); @@ -1250,8 +1145,7 @@ void SBTarget::GetBreakpointNames(SBStringList &names) { } void SBTarget::DeleteBreakpointName(const char *name) { - LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *), - name); + LLDB_INSTRUMENT_VA(this, name); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1261,7 +1155,7 @@ void SBTarget::DeleteBreakpointName(const char *name) { } bool SBTarget::EnableAllBreakpoints() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllBreakpoints); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1273,7 +1167,7 @@ bool SBTarget::EnableAllBreakpoints() { } bool SBTarget::DisableAllBreakpoints() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllBreakpoints); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1285,7 +1179,7 @@ bool SBTarget::DisableAllBreakpoints() { } bool SBTarget::DeleteAllBreakpoints() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllBreakpoints); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1298,29 +1192,23 @@ bool SBTarget::DeleteAllBreakpoints() { lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, SBBreakpointList &new_bps) { - LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile, - (lldb::SBFileSpec &, lldb::SBBreakpointList &), - source_file, new_bps); + LLDB_INSTRUMENT_VA(this, source_file, new_bps); SBStringList empty_name_list; - return LLDB_RECORD_RESULT( - BreakpointsCreateFromFile(source_file, empty_name_list, new_bps)); + return BreakpointsCreateFromFile(source_file, empty_name_list, new_bps); } lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, SBStringList &matching_names, SBBreakpointList &new_bps) { - LLDB_RECORD_METHOD( - lldb::SBError, SBTarget, BreakpointsCreateFromFile, - (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &), - source_file, matching_names, new_bps); + LLDB_INSTRUMENT_VA(this, source_file, matching_names, new_bps); SBError sberr; TargetSP target_sp(GetSP()); if (!target_sp) { sberr.SetErrorString( "BreakpointCreateFromFile called with invalid target."); - return LLDB_RECORD_RESULT(sberr); + return sberr; } std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -1334,42 +1222,39 @@ lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file, sberr.ref() = target_sp->CreateBreakpointsFromFile(source_file.ref(), name_vector, bp_ids); if (sberr.Fail()) - return LLDB_RECORD_RESULT(sberr); + return sberr; size_t num_bkpts = bp_ids.GetSize(); for (size_t i = 0; i < num_bkpts; i++) { BreakpointID bp_id = bp_ids.GetBreakpointIDAtIndex(i); new_bps.AppendByID(bp_id.GetBreakpointID()); } - return LLDB_RECORD_RESULT(sberr); + return sberr; } lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) { - LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, - (lldb::SBFileSpec &), dest_file); + LLDB_INSTRUMENT_VA(this, dest_file); SBError sberr; TargetSP target_sp(GetSP()); if (!target_sp) { sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); - return LLDB_RECORD_RESULT(sberr); + return sberr; } SBBreakpointList bkpt_list(*this); - return LLDB_RECORD_RESULT(BreakpointsWriteToFile(dest_file, bkpt_list)); + return BreakpointsWriteToFile(dest_file, bkpt_list); } lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file, SBBreakpointList &bkpt_list, bool append) { - LLDB_RECORD_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, - (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool), - dest_file, bkpt_list, append); + LLDB_INSTRUMENT_VA(this, dest_file, bkpt_list, append); SBError sberr; TargetSP target_sp(GetSP()); if (!target_sp) { sberr.SetErrorString("BreakpointWriteToFile called with invalid target."); - return LLDB_RECORD_RESULT(sberr); + return sberr; } std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -1377,11 +1262,11 @@ lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file, bkpt_list.CopyToBreakpointIDList(bp_id_list); sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(), bp_id_list, append); - return LLDB_RECORD_RESULT(sberr); + return sberr; } uint32_t SBTarget::GetNumWatchpoints() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumWatchpoints); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1392,8 +1277,7 @@ uint32_t SBTarget::GetNumWatchpoints() const { } SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const { - LLDB_RECORD_METHOD_CONST(lldb::SBWatchpoint, SBTarget, GetWatchpointAtIndex, - (uint32_t), idx); + LLDB_INSTRUMENT_VA(this, idx); SBWatchpoint sb_watchpoint; TargetSP target_sp(GetSP()); @@ -1401,13 +1285,11 @@ SBWatchpoint SBTarget::GetWatchpointAtIndex(uint32_t idx) const { // The watchpoint list is thread safe, no need to lock sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx)); } - return LLDB_RECORD_RESULT(sb_watchpoint); + return sb_watchpoint; } bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) { - LLDB_RECORD_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t), - wp_id); - + LLDB_INSTRUMENT_VA(this, wp_id); bool result = false; TargetSP target_sp(GetSP()); @@ -1422,9 +1304,7 @@ bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) { } SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) { - LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID, - (lldb::watch_id_t), wp_id); - + LLDB_INSTRUMENT_VA(this, wp_id); SBWatchpoint sb_watchpoint; lldb::WatchpointSP watchpoint_sp; @@ -1437,15 +1317,13 @@ SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) { sb_watchpoint.SetSP(watchpoint_sp); } - return LLDB_RECORD_RESULT(sb_watchpoint); + return sb_watchpoint; } lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size, bool read, bool write, SBError &error) { - LLDB_RECORD_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress, - (lldb::addr_t, size_t, bool, bool, lldb::SBError &), addr, - size, read, write, error); + LLDB_INSTRUMENT_VA(this, addr, size, read, write, error); SBWatchpoint sb_watchpoint; lldb::WatchpointSP watchpoint_sp; @@ -1461,7 +1339,7 @@ lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size, if (watch_type == 0) { error.SetErrorString( "Can't create a watchpoint that is neither read nor write."); - return LLDB_RECORD_RESULT(sb_watchpoint); + return sb_watchpoint; } // Target::CreateWatchpoint() is thread safe. @@ -1474,11 +1352,11 @@ lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size, sb_watchpoint.SetSP(watchpoint_sp); } - return LLDB_RECORD_RESULT(sb_watchpoint); + return sb_watchpoint; } bool SBTarget::EnableAllWatchpoints() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, EnableAllWatchpoints); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1492,7 +1370,7 @@ bool SBTarget::EnableAllWatchpoints() { } bool SBTarget::DisableAllWatchpoints() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DisableAllWatchpoints); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1507,9 +1385,7 @@ bool SBTarget::DisableAllWatchpoints() { SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr, SBType type) { - LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress, - (const char *, lldb::SBAddress, lldb::SBType), name, addr, - type); + LLDB_INSTRUMENT_VA(this, name, addr, type); SBValue sb_value; lldb::ValueObjectSP new_value_sp; @@ -1522,14 +1398,12 @@ SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr, exe_ctx, ast_type); } sb_value.SetSP(new_value_sp); - return LLDB_RECORD_RESULT(sb_value); + return sb_value; } lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data, lldb::SBType type) { - LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromData, - (const char *, lldb::SBData, lldb::SBType), name, data, - type); + LLDB_INSTRUMENT_VA(this, name, data, type); SBValue sb_value; lldb::ValueObjectSP new_value_sp; @@ -1542,13 +1416,12 @@ lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data, exe_ctx, ast_type); } sb_value.SetSP(new_value_sp); - return LLDB_RECORD_RESULT(sb_value); + return sb_value; } lldb::SBValue SBTarget::CreateValueFromExpression(const char *name, const char *expr) { - LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression, - (const char *, const char *), name, expr); + LLDB_INSTRUMENT_VA(this, name, expr); SBValue sb_value; lldb::ValueObjectSP new_value_sp; @@ -1559,11 +1432,11 @@ lldb::SBValue SBTarget::CreateValueFromExpression(const char *name, ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx); } sb_value.SetSP(new_value_sp); - return LLDB_RECORD_RESULT(sb_value); + return sb_value; } bool SBTarget::DeleteAllWatchpoints() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBTarget, DeleteAllWatchpoints); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1578,9 +1451,7 @@ bool SBTarget::DeleteAllWatchpoints() { void SBTarget::AppendImageSearchPath(const char *from, const char *to, lldb::SBError &error) { - LLDB_RECORD_METHOD(void, SBTarget, AppendImageSearchPath, - (const char *, const char *, lldb::SBError &), from, to, - error); + LLDB_INSTRUMENT_VA(this, from, to, error); TargetSP target_sp(GetSP()); if (!target_sp) @@ -1597,18 +1468,14 @@ void SBTarget::AppendImageSearchPath(const char *from, const char *to, lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, const char *uuid_cstr) { - LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, - (const char *, const char *, const char *), path, triple, - uuid_cstr); + LLDB_INSTRUMENT_VA(this, path, triple, uuid_cstr); - return LLDB_RECORD_RESULT(AddModule(path, triple, uuid_cstr, nullptr)); + return AddModule(path, triple, uuid_cstr, nullptr); } lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, const char *uuid_cstr, const char *symfile) { - LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, - (const char *, const char *, const char *, const char *), - path, triple, uuid_cstr, symfile); + LLDB_INSTRUMENT_VA(this, path, triple, uuid_cstr, symfile); lldb::SBModule sb_module; TargetSP target_sp(GetSP()); @@ -1631,23 +1498,22 @@ lldb::SBModule SBTarget::AddModule(const char *path, const char *triple, sb_module.SetSP(target_sp->GetOrCreateModule(module_spec, true /* notify */)); } - return LLDB_RECORD_RESULT(sb_module); + return sb_module; } lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) { - LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule, - (const lldb::SBModuleSpec &), module_spec); + LLDB_INSTRUMENT_VA(this, module_spec); lldb::SBModule sb_module; TargetSP target_sp(GetSP()); if (target_sp) sb_module.SetSP(target_sp->GetOrCreateModule(*module_spec.m_opaque_up, true /* notify */)); - return LLDB_RECORD_RESULT(sb_module); + return sb_module; } bool SBTarget::AddModule(lldb::SBModule &module) { - LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module); + LLDB_INSTRUMENT_VA(this, module); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1658,7 +1524,7 @@ bool SBTarget::AddModule(lldb::SBModule &module) { } uint32_t SBTarget::GetNumModules() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetNumModules); + LLDB_INSTRUMENT_VA(this); uint32_t num = 0; TargetSP target_sp(GetSP()); @@ -1671,14 +1537,13 @@ uint32_t SBTarget::GetNumModules() const { } void SBTarget::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBTarget, Clear); + LLDB_INSTRUMENT_VA(this); m_opaque_sp.reset(); } SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) { - LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, FindModule, - (const lldb::SBFileSpec &), sb_file_spec); + LLDB_INSTRUMENT_VA(this, sb_file_spec); SBModule sb_module; TargetSP target_sp(GetSP()); @@ -1687,22 +1552,21 @@ SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) { // The module list is thread safe, no need to lock sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec)); } - return LLDB_RECORD_RESULT(sb_module); + return sb_module; } SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) { - LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits, - (const lldb::SBFileSpec &), sb_file_spec); + LLDB_INSTRUMENT_VA(this, sb_file_spec); SBSymbolContextList sb_sc_list; const TargetSP target_sp(GetSP()); if (target_sp && sb_file_spec.IsValid()) target_sp->GetImages().FindCompileUnits(*sb_file_spec, *sb_sc_list); - return LLDB_RECORD_RESULT(sb_sc_list); + return sb_sc_list; } lldb::ByteOrder SBTarget::GetByteOrder() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::ByteOrder, SBTarget, GetByteOrder); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) @@ -1711,7 +1575,7 @@ lldb::ByteOrder SBTarget::GetByteOrder() { } const char *SBTarget::GetTriple() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTarget, GetTriple); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1726,7 +1590,7 @@ const char *SBTarget::GetTriple() { } uint32_t SBTarget::GetDataByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetDataByteSize); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1736,7 +1600,7 @@ uint32_t SBTarget::GetDataByteSize() { } uint32_t SBTarget::GetCodeByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetCodeByteSize); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) { @@ -1746,7 +1610,7 @@ uint32_t SBTarget::GetCodeByteSize() { } uint32_t SBTarget::GetMaximumNumberOfChildrenToDisplay() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetMaximumNumberOfChildrenToDisplay); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if(target_sp){ @@ -1756,7 +1620,7 @@ uint32_t SBTarget::GetMaximumNumberOfChildrenToDisplay() const { } uint32_t SBTarget::GetAddressByteSize() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTarget, GetAddressByteSize); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) @@ -1765,8 +1629,7 @@ uint32_t SBTarget::GetAddressByteSize() { } SBModule SBTarget::GetModuleAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, (uint32_t), - idx); + LLDB_INSTRUMENT_VA(this, idx); SBModule sb_module; ModuleSP module_sp; @@ -1777,11 +1640,11 @@ SBModule SBTarget::GetModuleAtIndex(uint32_t idx) { sb_module.SetSP(module_sp); } - return LLDB_RECORD_RESULT(sb_module); + return sb_module; } bool SBTarget::RemoveModule(lldb::SBModule module) { - LLDB_RECORD_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule), module); + LLDB_INSTRUMENT_VA(this, module); TargetSP target_sp(GetSP()); if (target_sp) @@ -1790,22 +1653,17 @@ bool SBTarget::RemoveModule(lldb::SBModule module) { } SBBroadcaster SBTarget::GetBroadcaster() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBTarget, - GetBroadcaster); - + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); SBBroadcaster broadcaster(target_sp.get(), false); - - return LLDB_RECORD_RESULT(broadcaster); + return broadcaster; } bool SBTarget::GetDescription(SBStream &description, lldb::DescriptionLevel description_level) { - LLDB_RECORD_METHOD(bool, SBTarget, GetDescription, - (lldb::SBStream &, lldb::DescriptionLevel), description, - description_level); + LLDB_INSTRUMENT_VA(this, description, description_level); Stream &strm = description.ref(); @@ -1820,16 +1678,15 @@ bool SBTarget::GetDescription(SBStream &description, lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name, uint32_t name_type_mask) { - LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions, - (const char *, uint32_t), name, name_type_mask); + LLDB_INSTRUMENT_VA(this, name, name_type_mask); lldb::SBSymbolContextList sb_sc_list; if (!name || !name[0]) - return LLDB_RECORD_RESULT(sb_sc_list); + return sb_sc_list; TargetSP target_sp(GetSP()); if (!target_sp) - return LLDB_RECORD_RESULT(sb_sc_list); + return sb_sc_list; ModuleFunctionSearchOptions function_options; function_options.include_symbols = true; @@ -1838,15 +1695,13 @@ lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name, FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask); target_sp->GetImages().FindFunctions(ConstString(name), mask, function_options, *sb_sc_list); - return LLDB_RECORD_RESULT(sb_sc_list); + return sb_sc_list; } lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name, uint32_t max_matches, MatchType matchtype) { - LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindGlobalFunctions, - (const char *, uint32_t, lldb::MatchType), name, - max_matches, matchtype); + LLDB_INSTRUMENT_VA(this, name, max_matches, matchtype); lldb::SBSymbolContextList sb_sc_list; if (name && name[0]) { @@ -1876,12 +1731,11 @@ lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name, } } } - return LLDB_RECORD_RESULT(sb_sc_list); + return sb_sc_list; } lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { - LLDB_RECORD_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *), - typename_cstr); + LLDB_INSTRUMENT_VA(this, typename_cstr); TargetSP target_sp(GetSP()); if (typename_cstr && typename_cstr[0] && target_sp) { @@ -1897,7 +1751,7 @@ lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { TypeSP type_sp( module_sp->FindFirstType(sc, const_typename, exact_match)); if (type_sp) - return LLDB_RECORD_RESULT(SBType(type_sp)); + return SBType(type_sp); } } @@ -1907,7 +1761,7 @@ lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { if (auto vendor = runtime->GetDeclVendor()) { auto types = vendor->FindTypes(const_typename, /*max_matches*/ 1); if (!types.empty()) - return LLDB_RECORD_RESULT(SBType(types.front())); + return SBType(types.front()); } } } @@ -1915,28 +1769,26 @@ lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) { // No matches, search for basic typename matches for (auto *type_system : target_sp->GetScratchTypeSystems()) if (auto type = type_system->GetBuiltinTypeByName(const_typename)) - return LLDB_RECORD_RESULT(SBType(type)); + return SBType(type); } - return LLDB_RECORD_RESULT(SBType()); + return SBType(); } SBType SBTarget::GetBasicType(lldb::BasicType type) { - LLDB_RECORD_METHOD(lldb::SBType, SBTarget, GetBasicType, (lldb::BasicType), - type); + LLDB_INSTRUMENT_VA(this, type); TargetSP target_sp(GetSP()); if (target_sp) { for (auto *type_system : target_sp->GetScratchTypeSystems()) if (auto compiler_type = type_system->GetBasicTypeFromAST(type)) - return LLDB_RECORD_RESULT(SBType(compiler_type)); + return SBType(compiler_type); } - return LLDB_RECORD_RESULT(SBType()); + return SBType(); } lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) { - LLDB_RECORD_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *), - typename_cstr); + LLDB_INSTRUMENT_VA(this, typename_cstr); SBTypeList sb_type_list; TargetSP target_sp(GetSP()); @@ -1975,13 +1827,12 @@ lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) { sb_type_list.Append(SBType(compiler_type)); } } - return LLDB_RECORD_RESULT(sb_type_list); + return sb_type_list; } SBValueList SBTarget::FindGlobalVariables(const char *name, uint32_t max_matches) { - LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, - (const char *, uint32_t), name, max_matches); + LLDB_INSTRUMENT_VA(this, name, max_matches); SBValueList sb_value_list; @@ -2003,15 +1854,13 @@ SBValueList SBTarget::FindGlobalVariables(const char *name, } } - return LLDB_RECORD_RESULT(sb_value_list); + return sb_value_list; } SBValueList SBTarget::FindGlobalVariables(const char *name, uint32_t max_matches, MatchType matchtype) { - LLDB_RECORD_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, - (const char *, uint32_t, lldb::MatchType), name, - max_matches, matchtype); + LLDB_INSTRUMENT_VA(this, name, max_matches, matchtype); SBValueList sb_value_list; @@ -2049,40 +1898,36 @@ SBValueList SBTarget::FindGlobalVariables(const char *name, } } - return LLDB_RECORD_RESULT(sb_value_list); + return sb_value_list; } lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) { - LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable, - (const char *), name); + LLDB_INSTRUMENT_VA(this, name); SBValueList sb_value_list(FindGlobalVariables(name, 1)); if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0) - return LLDB_RECORD_RESULT(sb_value_list.GetValueAtIndex(0)); - return LLDB_RECORD_RESULT(SBValue()); + return sb_value_list.GetValueAtIndex(0); + return SBValue(); } SBSourceManager SBTarget::GetSourceManager() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBTarget, GetSourceManager); + LLDB_INSTRUMENT_VA(this); SBSourceManager source_manager(*this); - return LLDB_RECORD_RESULT(source_manager); + return source_manager; } lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, uint32_t count) { - LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, - (lldb::SBAddress, uint32_t), base_addr, count); + LLDB_INSTRUMENT_VA(this, base_addr, count); - return LLDB_RECORD_RESULT(ReadInstructions(base_addr, count, nullptr)); + return ReadInstructions(base_addr, count, nullptr); } lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, uint32_t count, const char *flavor_string) { - LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, - (lldb::SBAddress, uint32_t, const char *), base_addr, - count, flavor_string); + LLDB_INSTRUMENT_VA(this, base_addr, count, flavor_string); SBInstructionList sb_instructions; @@ -2106,28 +1951,22 @@ lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr, } } - return LLDB_RECORD_RESULT(sb_instructions); + return sb_instructions; } lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr, const void *buf, size_t size) { - LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, - (lldb::SBAddress, const void *, size_t), base_addr, buf, - size); + LLDB_INSTRUMENT_VA(this, base_addr, buf, size); - return LLDB_RECORD_RESULT( - GetInstructionsWithFlavor(base_addr, nullptr, buf, size)); + return GetInstructionsWithFlavor(base_addr, nullptr, buf, size); } lldb::SBInstructionList SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr, const char *flavor_string, const void *buf, size_t size) { - LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, - GetInstructionsWithFlavor, - (lldb::SBAddress, const char *, const void *, size_t), - base_addr, flavor_string, buf, size); + LLDB_INSTRUMENT_VA(this, base_addr, flavor_string, buf, size); SBInstructionList sb_instructions; @@ -2145,38 +1984,31 @@ SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr, UINT32_MAX, data_from_file)); } - return LLDB_RECORD_RESULT(sb_instructions); + return sb_instructions; } lldb::SBInstructionList SBTarget::GetInstructions(lldb::addr_t base_addr, const void *buf, size_t size) { - LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, - (lldb::addr_t, const void *, size_t), base_addr, buf, - size); + LLDB_INSTRUMENT_VA(this, base_addr, buf, size); - return LLDB_RECORD_RESULT(GetInstructionsWithFlavor( - ResolveLoadAddress(base_addr), nullptr, buf, size)); + return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), nullptr, buf, + size); } lldb::SBInstructionList SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr, const char *flavor_string, const void *buf, size_t size) { - LLDB_RECORD_METHOD(lldb::SBInstructionList, SBTarget, - GetInstructionsWithFlavor, - (lldb::addr_t, const char *, const void *, size_t), - base_addr, flavor_string, buf, size); + LLDB_INSTRUMENT_VA(this, base_addr, flavor_string, buf, size); - return LLDB_RECORD_RESULT(GetInstructionsWithFlavor( - ResolveLoadAddress(base_addr), flavor_string, buf, size)); + return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), flavor_string, + buf, size); } SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section, lldb::addr_t section_base_addr) { - LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress, - (lldb::SBSection, lldb::addr_t), section, - section_base_addr); + LLDB_INSTRUMENT_VA(this, section, section_base_addr); SBError sb_error; TargetSP target_sp(GetSP()); @@ -2208,12 +2040,11 @@ SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section, } else { sb_error.SetErrorString("invalid target"); } - return LLDB_RECORD_RESULT(sb_error); + return sb_error; } SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) { - LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress, - (lldb::SBSection), section); + LLDB_INSTRUMENT_VA(this, section); SBError sb_error; @@ -2243,13 +2074,12 @@ SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) { } else { sb_error.SetErrorStringWithFormat("invalid target"); } - return LLDB_RECORD_RESULT(sb_error); + return sb_error; } SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module, int64_t slide_offset) { - LLDB_RECORD_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress, - (lldb::SBModule, int64_t), module, slide_offset); + LLDB_INSTRUMENT_VA(this, module, slide_offset); SBError sb_error; @@ -2278,12 +2108,11 @@ SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module, } else { sb_error.SetErrorStringWithFormat("invalid target"); } - return LLDB_RECORD_RESULT(sb_error); + return sb_error; } SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) { - LLDB_RECORD_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress, - (lldb::SBModule), module); + LLDB_INSTRUMENT_VA(this, module); SBError sb_error; @@ -2330,13 +2159,12 @@ SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) { } else { sb_error.SetErrorStringWithFormat("invalid target"); } - return LLDB_RECORD_RESULT(sb_error); + return sb_error; } lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name, lldb::SymbolType symbol_type) { - LLDB_RECORD_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols, - (const char *, lldb::SymbolType), name, symbol_type); + LLDB_INSTRUMENT_VA(this, name, symbol_type); SBSymbolContextList sb_sc_list; if (name && name[0]) { @@ -2345,30 +2173,27 @@ lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name, target_sp->GetImages().FindSymbolsWithNameAndType( ConstString(name), symbol_type, *sb_sc_list); } - return LLDB_RECORD_RESULT(sb_sc_list); + return sb_sc_list; } lldb::SBValue SBTarget::EvaluateExpression(const char *expr) { - LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, - (const char *), expr); + LLDB_INSTRUMENT_VA(this, expr); TargetSP target_sp(GetSP()); if (!target_sp) - return LLDB_RECORD_RESULT(SBValue()); + return SBValue(); SBExpressionOptions options; lldb::DynamicValueType fetch_dynamic_value = target_sp->GetPreferDynamicValue(); options.SetFetchDynamicValue(fetch_dynamic_value); options.SetUnwindOnError(true); - return LLDB_RECORD_RESULT(EvaluateExpression(expr, options)); + return EvaluateExpression(expr, options); } lldb::SBValue SBTarget::EvaluateExpression(const char *expr, const SBExpressionOptions &options) { - LLDB_RECORD_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, - (const char *, const lldb::SBExpressionOptions &), expr, - options); + LLDB_INSTRUMENT_VA(this, expr, options); Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); SBValue expr_result; @@ -2377,7 +2202,7 @@ lldb::SBValue SBTarget::EvaluateExpression(const char *expr, StackFrame *frame = nullptr; if (target_sp) { if (expr == nullptr || expr[0] == '\0') { - return LLDB_RECORD_RESULT(expr_result); + return expr_result; } std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex()); @@ -2397,11 +2222,11 @@ lldb::SBValue SBTarget::EvaluateExpression(const char *expr, "** [SBTarget::EvaluateExpression] Expression result is " "%s, summary %s **", expr_result.GetValue(), expr_result.GetSummary()); - return LLDB_RECORD_RESULT(expr_result); + return expr_result; } lldb::addr_t SBTarget::GetStackRedZoneSize() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBTarget, GetStackRedZoneSize); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) { @@ -2418,8 +2243,7 @@ lldb::addr_t SBTarget::GetStackRedZoneSize() { } bool SBTarget::IsLoaded(const SBModule &module) const { - LLDB_RECORD_METHOD_CONST(bool, SBTarget, IsLoaded, (const lldb::SBModule &), - module); + LLDB_INSTRUMENT_VA(this, module); TargetSP target_sp(GetSP()); if (!target_sp) @@ -2433,18 +2257,17 @@ bool SBTarget::IsLoaded(const SBModule &module) const { } lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo); + LLDB_INSTRUMENT_VA(this); lldb::SBLaunchInfo launch_info(nullptr); TargetSP target_sp(GetSP()); if (target_sp) launch_info.set_ref(m_opaque_sp->GetProcessLaunchInfo()); - return LLDB_RECORD_RESULT(launch_info); + return launch_info; } void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) { - LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo, - (const lldb::SBLaunchInfo &), launch_info); + LLDB_INSTRUMENT_VA(this, launch_info); TargetSP target_sp(GetSP()); if (target_sp) @@ -2452,309 +2275,39 @@ void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) { } SBEnvironment SBTarget::GetEnvironment() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBTarget, GetEnvironment); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) { - return LLDB_RECORD_RESULT(SBEnvironment(target_sp->GetEnvironment())); + return SBEnvironment(target_sp->GetEnvironment()); } - return LLDB_RECORD_RESULT(SBEnvironment()); + return SBEnvironment(); } lldb::SBTrace SBTarget::GetTrace() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTrace, SBTarget, GetTrace); + LLDB_INSTRUMENT_VA(this); TargetSP target_sp(GetSP()); if (target_sp) - return LLDB_RECORD_RESULT(SBTrace(target_sp->GetTrace())); + return SBTrace(target_sp->GetTrace()); - return LLDB_RECORD_RESULT(SBTrace()); + return SBTrace(); } lldb::SBTrace SBTarget::CreateTrace(lldb::SBError &error) { - LLDB_RECORD_METHOD(lldb::SBTrace, SBTarget, CreateTrace, (lldb::SBError &), - error); + LLDB_INSTRUMENT_VA(this, error); TargetSP target_sp(GetSP()); error.Clear(); if (target_sp) { if (llvm::Expected<lldb::TraceSP> trace_sp = target_sp->CreateTrace()) { - return LLDB_RECORD_RESULT(SBTrace(*trace_sp)); + return SBTrace(*trace_sp); } else { error.SetErrorString(llvm::toString(trace_sp.takeError()).c_str()); } } else { error.SetErrorString("missing target"); } - return LLDB_RECORD_RESULT(SBTrace()); -} - -namespace lldb_private { -namespace repro { - -template <> -void RegisterMethods<SBTarget>(Registry &R) { - LLDB_REGISTER_CONSTRUCTOR(SBTarget, ()); - LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &)); - LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &)); - LLDB_REGISTER_METHOD(const lldb::SBTarget &, - SBTarget, operator=,(const lldb::SBTarget &)); - LLDB_REGISTER_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent, - (const lldb::SBEvent &)); - LLDB_REGISTER_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent, - (const lldb::SBEvent &)); - LLDB_REGISTER_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent, - (const lldb::SBEvent &)); - LLDB_REGISTER_STATIC_METHOD(lldb::SBModule, SBTarget, - GetModuleAtIndexFromEvent, - (const uint32_t, const lldb::SBEvent &)); - LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName, - ()); - LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ()); - LLDB_REGISTER_METHOD_CONST(bool, SBTarget, operator bool, ()); - LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ()); - LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ()); - LLDB_REGISTER_METHOD_CONST(lldb::SBDebugger, SBTarget, GetDebugger, ()); - LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget, GetStatistics, ()); - LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool)); - LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ()); - LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *)); - LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, - (const char *, lldb::SBError &)); - LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LaunchSimple, - (const char **, const char **, const char *)); - LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, Install, ()); - LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch, - (lldb::SBListener &, const char **, const char **, - const char *, const char *, const char *, - const char *, uint32_t, bool, lldb::SBError &)); - LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Launch, - (lldb::SBLaunchInfo &, lldb::SBError &)); - LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, Attach, - (lldb::SBAttachInfo &, lldb::SBError &)); - LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID, - (lldb::SBListener &, lldb::pid_t, lldb::SBError &)); - LLDB_REGISTER_METHOD( - lldb::SBProcess, SBTarget, AttachToProcessWithName, - (lldb::SBListener &, const char *, bool, lldb::SBError &)); - LLDB_REGISTER_METHOD( - lldb::SBProcess, SBTarget, ConnectRemote, - (lldb::SBListener &, const char *, const char *, lldb::SBError &)); - LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBTarget, GetExecutable, ()); - LLDB_REGISTER_METHOD_CONST(bool, - SBTarget, operator==,(const lldb::SBTarget &)); - LLDB_REGISTER_METHOD_CONST(bool, - SBTarget, operator!=,(const lldb::SBTarget &)); - LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress, - (lldb::addr_t)); - LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress, - (lldb::addr_t)); - LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress, - (uint32_t, lldb::addr_t)); - LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBTarget, - ResolveSymbolContextForAddress, - (const lldb::SBAddress &, uint32_t)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, - BreakpointCreateByLocation, (const char *, uint32_t)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, - BreakpointCreateByLocation, - (const lldb::SBFileSpec &, uint32_t)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, - BreakpointCreateByLocation, - (const lldb::SBFileSpec &, uint32_t, lldb::addr_t)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, - BreakpointCreateByLocation, - (const lldb::SBFileSpec &, uint32_t, lldb::addr_t, - lldb::SBFileSpecList &)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, - BreakpointCreateByLocation, - (const lldb::SBFileSpec &, uint32_t, uint32_t, - lldb::addr_t, lldb::SBFileSpecList &)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation, - (const lldb::SBFileSpec &, uint32_t, uint32_t, - lldb::addr_t, lldb::SBFileSpecList &, bool)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, - (const char *, const char *)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, - (const char *, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, - (const char *, uint32_t, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName, - (const char *, uint32_t, lldb::LanguageType, - const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, - (const char **, uint32_t, uint32_t, - const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, - (const char **, uint32_t, uint32_t, lldb::LanguageType, - const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames, - (const char **, uint32_t, uint32_t, lldb::LanguageType, - lldb::addr_t, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, - (const char *, const char *)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, - (const char *, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex, - (const char *, lldb::LanguageType, - const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, - BreakpointCreateByAddress, (lldb::addr_t)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, - BreakpointCreateBySBAddress, (lldb::SBAddress &)); - LLDB_REGISTER_METHOD( - lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex, - (const char *, const lldb::SBFileSpec &, const char *)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, - BreakpointCreateBySourceRegex, - (const char *, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &)); - LLDB_REGISTER_METHOD( - lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex, - (const char *, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &, const lldb::SBStringList &)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, - BreakpointCreateForException, - (lldb::LanguageType, bool, bool)); - LLDB_REGISTER_METHOD( - lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript, - (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &, - const lldb::SBFileSpecList &, bool)); - LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumBreakpoints, ()); - LLDB_REGISTER_METHOD_CONST(lldb::SBBreakpoint, SBTarget, - GetBreakpointAtIndex, (uint32_t)); - LLDB_REGISTER_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t)); - LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID, - (lldb::break_id_t)); - LLDB_REGISTER_METHOD(bool, SBTarget, FindBreakpointsByName, - (const char *, lldb::SBBreakpointList &)); - LLDB_REGISTER_METHOD(void, SBTarget, GetBreakpointNames, - (lldb::SBStringList &)); - LLDB_REGISTER_METHOD(void, SBTarget, DeleteBreakpointName, (const char *)); - LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllBreakpoints, ()); - LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllBreakpoints, ()); - LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllBreakpoints, ()); - LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile, - (lldb::SBFileSpec &, lldb::SBBreakpointList &)); - LLDB_REGISTER_METHOD( - lldb::SBError, SBTarget, BreakpointsCreateFromFile, - (lldb::SBFileSpec &, lldb::SBStringList &, lldb::SBBreakpointList &)); - LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, - (lldb::SBFileSpec &)); - LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile, - (lldb::SBFileSpec &, lldb::SBBreakpointList &, bool)); - LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumWatchpoints, ()); - LLDB_REGISTER_METHOD_CONST(lldb::SBWatchpoint, SBTarget, - GetWatchpointAtIndex, (uint32_t)); - LLDB_REGISTER_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t)); - LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID, - (lldb::watch_id_t)); - LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, WatchAddress, - (lldb::addr_t, size_t, bool, bool, lldb::SBError &)); - LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllWatchpoints, ()); - LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllWatchpoints, ()); - LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress, - (const char *, lldb::SBAddress, lldb::SBType)); - LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromData, - (const char *, lldb::SBData, lldb::SBType)); - LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression, - (const char *, const char *)); - LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllWatchpoints, ()); - LLDB_REGISTER_METHOD(void, SBTarget, AppendImageSearchPath, - (const char *, const char *, lldb::SBError &)); - LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule, - (const char *, const char *, const char *)); - LLDB_REGISTER_METHOD( - lldb::SBModule, SBTarget, AddModule, - (const char *, const char *, const char *, const char *)); - LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, AddModule, - (const lldb::SBModuleSpec &)); - LLDB_REGISTER_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &)); - LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumModules, ()); - LLDB_REGISTER_METHOD(void, SBTarget, Clear, ()); - LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, FindModule, - (const lldb::SBFileSpec &)); - LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindCompileUnits, - (const lldb::SBFileSpec &)); - LLDB_REGISTER_METHOD(lldb::ByteOrder, SBTarget, GetByteOrder, ()); - LLDB_REGISTER_METHOD(const char *, SBTarget, GetTriple, ()); - LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetDataByteSize, ()); - LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetCodeByteSize, ()); - LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetMaximumNumberOfChildrenToDisplay,()); - LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetAddressByteSize, ()); - LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex, - (uint32_t)); - LLDB_REGISTER_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule)); - LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBTarget, GetBroadcaster, - ()); - LLDB_REGISTER_METHOD(bool, SBTarget, GetDescription, - (lldb::SBStream &, lldb::DescriptionLevel)); - LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindFunctions, - (const char *, uint32_t)); - LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, - FindGlobalFunctions, - (const char *, uint32_t, lldb::MatchType)); - LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *)); - LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, GetBasicType, - (lldb::BasicType)); - LLDB_REGISTER_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *)); - LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, - (const char *, uint32_t)); - LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables, - (const char *, uint32_t, lldb::MatchType)); - LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable, - (const char *)); - LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBTarget, GetSourceManager, ()); - LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, - (lldb::SBAddress, uint32_t)); - LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, ReadInstructions, - (lldb::SBAddress, uint32_t, const char *)); - LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress, - (lldb::SBSection, lldb::addr_t)); - LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress, - (lldb::SBSection)); - LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress, - (lldb::SBModule, int64_t)); - LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress, - (lldb::SBModule)); - LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols, - (const char *, lldb::SymbolType)); - LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, - (const char *)); - LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression, - (const char *, const lldb::SBExpressionOptions &)); - LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ()); - LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsLoaded, - (const lldb::SBModule &)); - LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ()); - LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo, - (const lldb::SBLaunchInfo &)); - LLDB_REGISTER_METHOD( - size_t, SBTarget, ReadMemory, - (const lldb::SBAddress, void *, size_t, lldb::SBError &)); - LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, - (lldb::SBAddress, const void *, size_t)); - LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, - GetInstructionsWithFlavor, - (lldb::SBAddress, const char *, const void *, size_t)); - LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions, - (lldb::addr_t, const void *, size_t)); - LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, - GetInstructionsWithFlavor, - (lldb::addr_t, const char *, const void *, size_t)); - LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBTarget, GetEnvironment, ()); - LLDB_REGISTER_METHOD(lldb::SBTrace, SBTarget, GetTrace, ()); - LLDB_REGISTER_METHOD(lldb::SBTrace, SBTarget, CreateTrace, (lldb::SBError &)); -} - -} + return SBTrace(); } |