diff options
Diffstat (limited to 'lldb/source/API/SBDebugger.cpp')
| -rw-r--r-- | lldb/source/API/SBDebugger.cpp | 766 |
1 files changed, 233 insertions, 533 deletions
diff --git a/lldb/source/API/SBDebugger.cpp b/lldb/source/API/SBDebugger.cpp index fa5dcb57de7e..8b09d6a8e435 100644 --- a/lldb/source/API/SBDebugger.cpp +++ b/lldb/source/API/SBDebugger.cpp @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#include "SBReproducerPrivate.h" #include "SystemInitializerFull.h" +#include "lldb/Utility/Instrumentation.h" #include "lldb/API/SBDebugger.h" @@ -105,53 +105,43 @@ SBError SBInputReader::Initialize( unsigned long), void *a, lldb::InputReaderGranularity b, char const *c, char const *d, bool e) { - LLDB_RECORD_DUMMY( - lldb::SBError, SBInputReader, Initialize, - (lldb::SBDebugger &, - unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction, - const char *, unsigned long), - void *, lldb::InputReaderGranularity, const char *, const char *, bool), - sb_debugger, callback, a, b, c, d, e); + LLDB_INSTRUMENT_VA(this, sb_debugger, callback, a, b, c, d, e); return SBError(); } -void SBInputReader::SetIsDone(bool b) { - LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b); -} +void SBInputReader::SetIsDone(bool b) { LLDB_INSTRUMENT_VA(this, b); } bool SBInputReader::IsActive() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive); + LLDB_INSTRUMENT_VA(this); return false; } -SBDebugger::SBDebugger() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDebugger); } +SBDebugger::SBDebugger() { LLDB_INSTRUMENT_VA(this); } SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) : m_opaque_sp(debugger_sp) { - LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), debugger_sp); + LLDB_INSTRUMENT_VA(this, debugger_sp); } SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) { - LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &), rhs); + LLDB_INSTRUMENT_VA(this, rhs); } SBDebugger::~SBDebugger() = default; SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) { - LLDB_RECORD_METHOD(lldb::SBDebugger &, - SBDebugger, operator=,(const lldb::SBDebugger &), rhs); + LLDB_INSTRUMENT_VA(this, rhs); if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; } - return LLDB_RECORD_RESULT(*this); + return *this; } const char *SBDebugger::GetBroadcasterClass() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, - GetBroadcasterClass); + LLDB_INSTRUMENT(); return Debugger::GetStaticBroadcasterClass().AsCString(); } @@ -161,6 +151,8 @@ const char *SBDebugger::GetProgressFromEvent(const lldb::SBEvent &event, uint64_t &completed, uint64_t &total, bool &is_debugger_specific) { + LLDB_INSTRUMENT_VA(event, progress_id, completed, total, + is_debugger_specific); const Debugger::ProgressEventData *progress_data = Debugger::ProgressEventData::GetEventDataFromEvent(event.get()); if (progress_data == nullptr) @@ -169,46 +161,39 @@ const char *SBDebugger::GetProgressFromEvent(const lldb::SBEvent &event, completed = progress_data->GetCompleted(); total = progress_data->GetTotal(); is_debugger_specific = progress_data->IsDebuggerSpecific(); - // We must record the static method _after_ the out parameters have been - // filled in. - LLDB_RECORD_STATIC_METHOD( - const char *, SBDebugger, GetProgressFromEvent, - (const lldb::SBEvent &, uint64_t &, uint64_t &, uint64_t &, bool &), - event, progress_id, completed, total, is_debugger_specific); - return LLDB_RECORD_RESULT(progress_data->GetMessage().c_str()) + return progress_data->GetMessage().c_str(); } SBBroadcaster SBDebugger::GetBroadcaster() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBDebugger, GetBroadcaster); + LLDB_INSTRUMENT_VA(this); SBBroadcaster broadcaster(&m_opaque_sp->GetBroadcaster(), false); - return LLDB_RECORD_RESULT(broadcaster); + return broadcaster; } void SBDebugger::Initialize() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize); + LLDB_INSTRUMENT(); SBError ignored = SBDebugger::InitializeWithErrorHandling(); } lldb::SBError SBDebugger::InitializeWithErrorHandling() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBError, SBDebugger, - InitializeWithErrorHandling); + LLDB_INSTRUMENT(); SBError error; if (auto e = g_debugger_lifetime->Initialize( std::make_unique<SystemInitializerFull>(), LoadPlugin)) { error.SetError(Status(std::move(e))); } - return LLDB_RECORD_RESULT(error); + return error; } void SBDebugger::Terminate() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate); + LLDB_INSTRUMENT(); g_debugger_lifetime->Terminate(); } void SBDebugger::Clear() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, Clear); + LLDB_INSTRUMENT_VA(this); if (m_opaque_sp) m_opaque_sp->ClearIOHandlers(); @@ -217,26 +202,22 @@ void SBDebugger::Clear() { } SBDebugger SBDebugger::Create() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBDebugger, SBDebugger, Create); + LLDB_INSTRUMENT(); - return LLDB_RECORD_RESULT(SBDebugger::Create(false, nullptr, nullptr)); + return SBDebugger::Create(false, nullptr, nullptr); } SBDebugger SBDebugger::Create(bool source_init_files) { - LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool), - source_init_files); + LLDB_INSTRUMENT_VA(source_init_files); - return LLDB_RECORD_RESULT( - SBDebugger::Create(source_init_files, nullptr, nullptr)); + return SBDebugger::Create(source_init_files, nullptr, nullptr); } SBDebugger SBDebugger::Create(bool source_init_files, lldb::LogOutputCallback callback, void *baton) { - LLDB_RECORD_DUMMY(lldb::SBDebugger, SBDebugger, Create, - (bool, lldb::LogOutputCallback, void *), source_init_files, - callback, baton); + LLDB_INSTRUMENT_VA(source_init_files, callback, baton); SBDebugger debugger; @@ -264,8 +245,7 @@ SBDebugger SBDebugger::Create(bool source_init_files, } void SBDebugger::Destroy(SBDebugger &debugger) { - LLDB_RECORD_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &), - debugger); + LLDB_INSTRUMENT_VA(debugger); Debugger::Destroy(debugger.m_opaque_sp); @@ -274,7 +254,7 @@ void SBDebugger::Destroy(SBDebugger &debugger) { } void SBDebugger::MemoryPressureDetected() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, MemoryPressureDetected); + LLDB_INSTRUMENT(); // Since this function can be call asynchronously, we allow it to be non- // mandatory. We have seen deadlocks with this function when called so we @@ -287,226 +267,222 @@ void SBDebugger::MemoryPressureDetected() { } bool SBDebugger::IsValid() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid); + LLDB_INSTRUMENT_VA(this); return this->operator bool(); } SBDebugger::operator bool() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, operator bool); + LLDB_INSTRUMENT_VA(this); return m_opaque_sp.get() != nullptr; } void SBDebugger::SetAsync(bool b) { - LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b); + LLDB_INSTRUMENT_VA(this, b); if (m_opaque_sp) m_opaque_sp->SetAsyncExecution(b); } bool SBDebugger::GetAsync() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetAsync); + LLDB_INSTRUMENT_VA(this); return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false); } void SBDebugger::SkipLLDBInitFiles(bool b) { - LLDB_RECORD_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool), b); + LLDB_INSTRUMENT_VA(this, b); if (m_opaque_sp) m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b); } void SBDebugger::SkipAppInitFiles(bool b) { - LLDB_RECORD_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), b); + LLDB_INSTRUMENT_VA(this, b); if (m_opaque_sp) m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b); } void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) { - LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh, - transfer_ownership); + LLDB_INSTRUMENT_VA(this, fh, transfer_ownership); if (m_opaque_sp) m_opaque_sp->SetInputFile( (FileSP)std::make_shared<NativeFile>(fh, transfer_ownership)); } SBError SBDebugger::SetInputString(const char *data) { - LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputString, (const char *), data); + LLDB_INSTRUMENT_VA(this, data); SBError sb_error; if (data == nullptr) { sb_error.SetErrorString("String data is null"); - return LLDB_RECORD_RESULT(sb_error); + return sb_error; } size_t size = strlen(data); if (size == 0) { sb_error.SetErrorString("String data is empty"); - return LLDB_RECORD_RESULT(sb_error); + return sb_error; } if (!m_opaque_sp) { sb_error.SetErrorString("invalid debugger"); - return LLDB_RECORD_RESULT(sb_error); + return sb_error; } sb_error.SetError(m_opaque_sp->SetInputString(data)); - return LLDB_RECORD_RESULT(sb_error); + return sb_error; } // Shouldn't really be settable after initialization as this could cause lots // of problems; don't want users trying to switch modes in the middle of a // debugging session. SBError SBDebugger::SetInputFile(SBFile file) { - LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (SBFile), file); + LLDB_INSTRUMENT_VA(this, file); SBError error; if (!m_opaque_sp) { error.ref().SetErrorString("invalid debugger"); - return LLDB_RECORD_RESULT(error); + return error; } error.SetError(m_opaque_sp->SetInputFile(file.m_opaque_sp)); - return LLDB_RECORD_RESULT(error); + return error; } SBError SBDebugger::SetInputFile(FileSP file_sp) { - LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (FileSP), file_sp); - return LLDB_RECORD_RESULT(SetInputFile(SBFile(file_sp))); + LLDB_INSTRUMENT_VA(this, file_sp); + return SetInputFile(SBFile(file_sp)); } SBError SBDebugger::SetOutputFile(FileSP file_sp) { - LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (FileSP), file_sp); - return LLDB_RECORD_RESULT(SetOutputFile(SBFile(file_sp))); + LLDB_INSTRUMENT_VA(this, file_sp); + return SetOutputFile(SBFile(file_sp)); } void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) { - LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh, - transfer_ownership); + LLDB_INSTRUMENT_VA(this, fh, transfer_ownership); SetOutputFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership)); } SBError SBDebugger::SetOutputFile(SBFile file) { - LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (SBFile file), file); + LLDB_INSTRUMENT_VA(this, file); SBError error; if (!m_opaque_sp) { error.ref().SetErrorString("invalid debugger"); - return LLDB_RECORD_RESULT(error); + return error; } if (!file) { error.ref().SetErrorString("invalid file"); - return LLDB_RECORD_RESULT(error); + return error; } m_opaque_sp->SetOutputFile(file.m_opaque_sp); - return LLDB_RECORD_RESULT(error); + return error; } void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) { - LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh, - transfer_ownership); + LLDB_INSTRUMENT_VA(this, fh, transfer_ownership); SetErrorFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership)); } SBError SBDebugger::SetErrorFile(FileSP file_sp) { - LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (FileSP), file_sp); - return LLDB_RECORD_RESULT(SetErrorFile(SBFile(file_sp))); + LLDB_INSTRUMENT_VA(this, file_sp); + return SetErrorFile(SBFile(file_sp)); } SBError SBDebugger::SetErrorFile(SBFile file) { - LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (SBFile file), file); + LLDB_INSTRUMENT_VA(this, file); SBError error; if (!m_opaque_sp) { error.ref().SetErrorString("invalid debugger"); - return LLDB_RECORD_RESULT(error); + return error; } if (!file) { error.ref().SetErrorString("invalid file"); - return LLDB_RECORD_RESULT(error); + return error; } m_opaque_sp->SetErrorFile(file.m_opaque_sp); - return LLDB_RECORD_RESULT(error); + return error; } FILE *SBDebugger::GetInputFileHandle() { - LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle); + LLDB_INSTRUMENT_VA(this); if (m_opaque_sp) { File &file_sp = m_opaque_sp->GetInputFile(); - return LLDB_RECORD_RESULT(file_sp.GetStream()); + return file_sp.GetStream(); } - return LLDB_RECORD_RESULT(nullptr); + return nullptr; } SBFile SBDebugger::GetInputFile() { - LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetInputFile); + LLDB_INSTRUMENT_VA(this); if (m_opaque_sp) { - return LLDB_RECORD_RESULT(SBFile(m_opaque_sp->GetInputFileSP())); + return SBFile(m_opaque_sp->GetInputFileSP()); } - return LLDB_RECORD_RESULT(SBFile()); + return SBFile(); } FILE *SBDebugger::GetOutputFileHandle() { - LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle); + LLDB_INSTRUMENT_VA(this); if (m_opaque_sp) { StreamFile &stream_file = m_opaque_sp->GetOutputStream(); - return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream()); + return stream_file.GetFile().GetStream(); } - return LLDB_RECORD_RESULT(nullptr); + return nullptr; } SBFile SBDebugger::GetOutputFile() { - LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetOutputFile); + LLDB_INSTRUMENT_VA(this); if (m_opaque_sp) { SBFile file(m_opaque_sp->GetOutputStream().GetFileSP()); - return LLDB_RECORD_RESULT(file); + return file; } - return LLDB_RECORD_RESULT(SBFile()); + return SBFile(); } FILE *SBDebugger::GetErrorFileHandle() { - LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle); + LLDB_INSTRUMENT_VA(this); if (m_opaque_sp) { StreamFile &stream_file = m_opaque_sp->GetErrorStream(); - return LLDB_RECORD_RESULT(stream_file.GetFile().GetStream()); + return stream_file.GetFile().GetStream(); } - return LLDB_RECORD_RESULT(nullptr); + return nullptr; } SBFile SBDebugger::GetErrorFile() { - LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetErrorFile); + LLDB_INSTRUMENT_VA(this); SBFile file; if (m_opaque_sp) { SBFile file(m_opaque_sp->GetErrorStream().GetFileSP()); - return LLDB_RECORD_RESULT(file); + return file; } - return LLDB_RECORD_RESULT(SBFile()); + return SBFile(); } void SBDebugger::SaveInputTerminalState() { - LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, SaveInputTerminalState); + LLDB_INSTRUMENT_VA(this); if (m_opaque_sp) m_opaque_sp->SaveInputTerminalState(); } void SBDebugger::RestoreInputTerminalState() { - LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, RestoreInputTerminalState); + LLDB_INSTRUMENT_VA(this); if (m_opaque_sp) m_opaque_sp->RestoreInputTerminalState(); } SBCommandInterpreter SBDebugger::GetCommandInterpreter() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCommandInterpreter, SBDebugger, - GetCommandInterpreter); + LLDB_INSTRUMENT_VA(this); SBCommandInterpreter sb_interpreter; if (m_opaque_sp) sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter()); - return LLDB_RECORD_RESULT(sb_interpreter); + return sb_interpreter; } void SBDebugger::HandleCommand(const char *command) { - LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command); + LLDB_INSTRUMENT_VA(this, command); if (m_opaque_sp) { TargetSP target_sp(m_opaque_sp->GetSelectedTarget()); @@ -539,22 +515,19 @@ void SBDebugger::HandleCommand(const char *command) { } SBListener SBDebugger::GetListener() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener); + LLDB_INSTRUMENT_VA(this); SBListener sb_listener; if (m_opaque_sp) sb_listener.reset(m_opaque_sp->GetListener()); - return LLDB_RECORD_RESULT(sb_listener); + return sb_listener; } void SBDebugger::HandleProcessEvent(const SBProcess &process, const SBEvent &event, SBFile out, SBFile err) { - LLDB_RECORD_METHOD( - void, SBDebugger, HandleProcessEvent, - (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile), process, - event, out, err); + LLDB_INSTRUMENT_VA(this, process, event, out, err); return HandleProcessEvent(process, event, out.m_opaque_sp, err.m_opaque_sp); } @@ -562,10 +535,7 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process, void SBDebugger::HandleProcessEvent(const SBProcess &process, const SBEvent &event, FILE *out, FILE *err) { - LLDB_RECORD_METHOD( - void, SBDebugger, HandleProcessEvent, - (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *), process, - event, out, err); + LLDB_INSTRUMENT_VA(this, process, event, out, err); FileSP outfile = std::make_shared<NativeFile>(out, false); FileSP errfile = std::make_shared<NativeFile>(err, false); @@ -576,10 +546,7 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process, const SBEvent &event, FileSP out_sp, FileSP err_sp) { - LLDB_RECORD_METHOD( - void, SBDebugger, HandleProcessEvent, - (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP), process, - event, out_sp, err_sp); + LLDB_INSTRUMENT_VA(this, process, event, out_sp, err_sp); if (!process.IsValid()) return; @@ -623,17 +590,14 @@ void SBDebugger::HandleProcessEvent(const SBProcess &process, } SBSourceManager SBDebugger::GetSourceManager() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger, - GetSourceManager); + LLDB_INSTRUMENT_VA(this); SBSourceManager sb_source_manager(*this); - return LLDB_RECORD_RESULT(sb_source_manager); + return sb_source_manager; } bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) { - LLDB_RECORD_CHAR_PTR_STATIC_METHOD(bool, SBDebugger, GetDefaultArchitecture, - (char *, size_t), arch_name, "", - arch_name_len); + LLDB_INSTRUMENT_VA(arch_name, arch_name_len); if (arch_name && arch_name_len) { ArchSpec default_arch = Target::GetDefaultArchitecture(); @@ -654,8 +618,7 @@ bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) { } bool SBDebugger::SetDefaultArchitecture(const char *arch_name) { - LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture, - (const char *), arch_name); + LLDB_INSTRUMENT_VA(arch_name); if (arch_name) { ArchSpec arch(arch_name); @@ -669,8 +632,7 @@ bool SBDebugger::SetDefaultArchitecture(const char *arch_name) { ScriptLanguage SBDebugger::GetScriptingLanguage(const char *script_language_name) { - LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage, - (const char *), script_language_name); + LLDB_INSTRUMENT_VA(this, script_language_name); if (!script_language_name) return eScriptLanguageDefault; @@ -680,8 +642,7 @@ SBDebugger::GetScriptingLanguage(const char *script_language_name) { SBStructuredData SBDebugger::GetScriptInterpreterInfo(lldb::ScriptLanguage language) { - LLDB_RECORD_METHOD(SBStructuredData, SBDebugger, GetScriptInterpreterInfo, - (lldb::ScriptLanguage), language); + LLDB_INSTRUMENT_VA(this, language); SBStructuredData data; if (m_opaque_sp) { lldb_private::ScriptInterpreter *interp = @@ -690,18 +651,17 @@ SBDebugger::GetScriptInterpreterInfo(lldb::ScriptLanguage language) { data.m_impl_up->SetObjectSP(interp->GetInterpreterInfo()); } } - return LLDB_RECORD_RESULT(data); + return data; } const char *SBDebugger::GetVersionString() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, GetVersionString); + LLDB_INSTRUMENT(); return lldb_private::GetVersion(); } const char *SBDebugger::StateAsCString(StateType state) { - LLDB_RECORD_STATIC_METHOD(const char *, SBDebugger, StateAsCString, - (lldb::StateType), state); + LLDB_INSTRUMENT_VA(state); return lldb_private::StateAsCString(state); } @@ -727,8 +687,7 @@ static void AddLLVMTargets(StructuredData::Dictionary &dict) { } SBStructuredData SBDebugger::GetBuildConfiguration() { - LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger, - GetBuildConfiguration); + LLDB_INSTRUMENT(); auto config_up = std::make_unique<StructuredData::Dictionary>(); AddBoolConfigEntry( @@ -756,12 +715,11 @@ SBStructuredData SBDebugger::GetBuildConfiguration() { SBStructuredData data; data.m_impl_up->SetObjectSP(std::move(config_up)); - return LLDB_RECORD_RESULT(data); + return data; } bool SBDebugger::StateIsRunningState(StateType state) { - LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsRunningState, - (lldb::StateType), state); + LLDB_INSTRUMENT_VA(state); const bool result = lldb_private::StateIsRunningState(state); @@ -769,8 +727,7 @@ bool SBDebugger::StateIsRunningState(StateType state) { } bool SBDebugger::StateIsStoppedState(StateType state) { - LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState, - (lldb::StateType), state); + LLDB_INSTRUMENT_VA(state); const bool result = lldb_private::StateIsStoppedState(state, false); @@ -782,10 +739,8 @@ lldb::SBTarget SBDebugger::CreateTarget(const char *filename, const char *platform_name, bool add_dependent_modules, lldb::SBError &sb_error) { - LLDB_RECORD_METHOD( - lldb::SBTarget, SBDebugger, CreateTarget, - (const char *, const char *, const char *, bool, lldb::SBError &), - filename, target_triple, platform_name, add_dependent_modules, sb_error); + LLDB_INSTRUMENT_VA(this, filename, target_triple, platform_name, + add_dependent_modules, sb_error); SBTarget sb_target; TargetSP target_sp; @@ -814,15 +769,13 @@ lldb::SBTarget SBDebugger::CreateTarget(const char *filename, platform_name, add_dependent_modules, sb_error.GetCString(), static_cast<void *>(target_sp.get())); - return LLDB_RECORD_RESULT(sb_target); + return sb_target; } SBTarget SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename, const char *target_triple) { - LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, - CreateTargetWithFileAndTargetTriple, - (const char *, const char *), filename, target_triple); + LLDB_INSTRUMENT_VA(this, filename, target_triple); SBTarget sb_target; TargetSP target_sp; @@ -842,13 +795,12 @@ SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename, static_cast<void *>(m_opaque_sp.get()), filename, target_triple, static_cast<void *>(target_sp.get())); - return LLDB_RECORD_RESULT(sb_target); + return sb_target; } SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename, const char *arch_cstr) { - LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch, - (const char *, const char *), filename, arch_cstr); + LLDB_INSTRUMENT_VA(this, filename, arch_cstr); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -860,16 +812,18 @@ SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename, // The version of CreateTarget that takes an ArchSpec won't accept an // empty ArchSpec, so when the arch hasn't been specified, we need to // call the target triple version. - error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename, - arch_cstr, eLoadDependentsYes, nullptr, target_sp); + error = m_opaque_sp->GetTargetList().CreateTarget( + *m_opaque_sp, filename, arch_cstr, eLoadDependentsYes, nullptr, + target_sp); } else { - PlatformSP platform_sp = m_opaque_sp->GetPlatformList() - .GetSelectedPlatform(); - ArchSpec arch = Platform::GetAugmentedArchSpec(platform_sp.get(), - arch_cstr); + PlatformSP platform_sp = + m_opaque_sp->GetPlatformList().GetSelectedPlatform(); + ArchSpec arch = + Platform::GetAugmentedArchSpec(platform_sp.get(), arch_cstr); if (arch.IsValid()) - error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename, - arch, eLoadDependentsYes, platform_sp, target_sp); + error = m_opaque_sp->GetTargetList().CreateTarget( + *m_opaque_sp, filename, arch, eLoadDependentsYes, platform_sp, + target_sp); else error.SetErrorStringWithFormat("invalid arch_cstr: %s", arch_cstr); } @@ -885,12 +839,11 @@ SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename, arch_cstr ? arch_cstr : "<unspecified>", static_cast<void *>(target_sp.get())); - return LLDB_RECORD_RESULT(sb_target); + return sb_target; } SBTarget SBDebugger::CreateTarget(const char *filename) { - LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *), - filename); + LLDB_INSTRUMENT_VA(this, filename); SBTarget sb_target; TargetSP target_sp; @@ -910,11 +863,11 @@ SBTarget SBDebugger::CreateTarget(const char *filename) { "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)", static_cast<void *>(m_opaque_sp.get()), filename, static_cast<void *>(target_sp.get())); - return LLDB_RECORD_RESULT(sb_target); + return sb_target; } SBTarget SBDebugger::GetDummyTarget() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget); + LLDB_INSTRUMENT_VA(this); SBTarget sb_target; if (m_opaque_sp) { @@ -924,12 +877,11 @@ SBTarget SBDebugger::GetDummyTarget() { LLDB_LOGF(log, "SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)", static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(sb_target.GetSP().get())); - return LLDB_RECORD_RESULT(sb_target); + return sb_target; } bool SBDebugger::DeleteTarget(lldb::SBTarget &target) { - LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &), - target); + LLDB_INSTRUMENT_VA(this, target); bool result = false; if (m_opaque_sp) { @@ -951,20 +903,18 @@ bool SBDebugger::DeleteTarget(lldb::SBTarget &target) { } SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t), - idx); + LLDB_INSTRUMENT_VA(this, idx); SBTarget sb_target; if (m_opaque_sp) { // No need to lock, the target list is thread safe sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx)); } - return LLDB_RECORD_RESULT(sb_target); + return sb_target; } uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) { - LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget), - target); + LLDB_INSTRUMENT_VA(this, target); lldb::TargetSP target_sp = target.GetSP(); if (!target_sp) @@ -977,21 +927,19 @@ uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) { } SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) { - LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, - (lldb::pid_t), pid); + LLDB_INSTRUMENT_VA(this, pid); SBTarget sb_target; if (m_opaque_sp) { // No need to lock, the target list is thread safe sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid)); } - return LLDB_RECORD_RESULT(sb_target); + return sb_target; } SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename, const char *arch_name) { - LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch, - (const char *, const char *), filename, arch_name); + LLDB_INSTRUMENT_VA(this, filename, arch_name); SBTarget sb_target; if (m_opaque_sp && filename && filename[0]) { @@ -1003,7 +951,7 @@ SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename, FileSpec(filename), arch_name ? &arch : nullptr)); sb_target.SetSP(target_sp); } - return LLDB_RECORD_RESULT(sb_target); + return sb_target; } SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) { @@ -1017,7 +965,7 @@ SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) { } uint32_t SBDebugger::GetNumTargets() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets); + LLDB_INSTRUMENT_VA(this); if (m_opaque_sp) { // No need to lock, the target list is thread safe @@ -1027,7 +975,7 @@ uint32_t SBDebugger::GetNumTargets() { } SBTarget SBDebugger::GetSelectedTarget() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget); + LLDB_INSTRUMENT_VA(this); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1047,12 +995,11 @@ SBTarget SBDebugger::GetSelectedTarget() { static_cast<void *>(target_sp.get()), sstr.GetData()); } - return LLDB_RECORD_RESULT(sb_target); + return sb_target; } void SBDebugger::SetSelectedTarget(SBTarget &sb_target) { - LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &), - sb_target); + LLDB_INSTRUMENT_VA(this, sb_target); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1070,7 +1017,7 @@ void SBDebugger::SetSelectedTarget(SBTarget &sb_target) { } SBPlatform SBDebugger::GetSelectedPlatform() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform); + LLDB_INSTRUMENT_VA(this); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1083,12 +1030,11 @@ SBPlatform SBDebugger::GetSelectedPlatform() { static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(sb_platform.GetSP().get()), sb_platform.GetName()); - return LLDB_RECORD_RESULT(sb_platform); + return sb_platform; } void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) { - LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform, - (lldb::SBPlatform &), sb_platform); + LLDB_INSTRUMENT_VA(this, sb_platform); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1104,7 +1050,7 @@ void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) { } uint32_t SBDebugger::GetNumPlatforms() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms); + LLDB_INSTRUMENT_VA(this); if (m_opaque_sp) { // No need to lock, the platform list is thread safe @@ -1114,19 +1060,18 @@ uint32_t SBDebugger::GetNumPlatforms() { } SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, - (uint32_t), idx); + LLDB_INSTRUMENT_VA(this, idx); SBPlatform sb_platform; if (m_opaque_sp) { // No need to lock, the platform list is thread safe sb_platform.SetSP(m_opaque_sp->GetPlatformList().GetAtIndex(idx)); } - return LLDB_RECORD_RESULT(sb_platform); + return sb_platform; } uint32_t SBDebugger::GetNumAvailablePlatforms() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms); + LLDB_INSTRUMENT_VA(this); uint32_t idx = 0; while (true) { @@ -1140,8 +1085,7 @@ uint32_t SBDebugger::GetNumAvailablePlatforms() { } SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) { - LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger, - GetAvailablePlatformInfoAtIndex, (uint32_t), idx); + LLDB_INSTRUMENT_VA(this, idx); SBStructuredData data; auto platform_dict = std::make_unique<StructuredData::Dictionary>(); @@ -1156,7 +1100,7 @@ SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) { llvm::StringRef plugin_name = PluginManager::GetPlatformPluginNameAtIndex(idx - 1); if (plugin_name.empty()) { - return LLDB_RECORD_RESULT(data); + return data; } platform_dict->AddStringItem(name_str, llvm::StringRef(plugin_name)); @@ -1167,19 +1111,17 @@ SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) { data.m_impl_up->SetObjectSP( StructuredData::ObjectSP(platform_dict.release())); - return LLDB_RECORD_RESULT(data); + return data; } void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) { - LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput, - (void *, const void *, size_t), baton, data, data_len); + LLDB_INSTRUMENT_VA(this, baton, data, data_len); DispatchInput(data, data_len); } void SBDebugger::DispatchInput(const void *data, size_t data_len) { - LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput, (const void *, size_t), - data, data_len); + LLDB_INSTRUMENT_VA(this, data, data_len); // Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); // @@ -1196,28 +1138,26 @@ void SBDebugger::DispatchInput(const void *data, size_t data_len) { } void SBDebugger::DispatchInputInterrupt() { - LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, DispatchInputInterrupt); + LLDB_INSTRUMENT_VA(this); if (m_opaque_sp) m_opaque_sp->DispatchInputInterrupt(); } void SBDebugger::DispatchInputEndOfFile() { - LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile); + LLDB_INSTRUMENT_VA(this); if (m_opaque_sp) m_opaque_sp->DispatchInputEndOfFile(); } void SBDebugger::PushInputReader(SBInputReader &reader) { - LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &), - reader); + LLDB_INSTRUMENT_VA(this, reader); } void SBDebugger::RunCommandInterpreter(bool auto_handle_events, bool spawn_thread) { - LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool), - auto_handle_events, spawn_thread); + LLDB_INSTRUMENT_VA(this, auto_handle_events, spawn_thread); if (m_opaque_sp) { CommandInterpreterRunOptions options; @@ -1234,11 +1174,8 @@ void SBDebugger::RunCommandInterpreter(bool auto_handle_events, bool &stopped_for_crash) { - LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, - (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &, - bool &, bool &), - auto_handle_events, spawn_thread, options, num_errors, - quit_requested, stopped_for_crash); + LLDB_INSTRUMENT_VA(this, auto_handle_events, spawn_thread, options, + num_errors, quit_requested, stopped_for_crash); if (m_opaque_sp) { options.SetAutoHandleEvents(auto_handle_events); @@ -1256,32 +1193,28 @@ void SBDebugger::RunCommandInterpreter(bool auto_handle_events, SBCommandInterpreterRunResult SBDebugger::RunCommandInterpreter( const SBCommandInterpreterRunOptions &options) { - LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger, - RunCommandInterpreter, - (const lldb::SBCommandInterpreterRunOptions &), options); + LLDB_INSTRUMENT_VA(this, options); if (!m_opaque_sp) - return LLDB_RECORD_RESULT(SBCommandInterpreterRunResult()); + return SBCommandInterpreterRunResult(); CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter(); CommandInterpreterRunResult result = interp.RunCommandInterpreter(options.ref()); - return LLDB_RECORD_RESULT(SBCommandInterpreterRunResult(result)); + return SBCommandInterpreterRunResult(result); } SBError SBDebugger::RunREPL(lldb::LanguageType language, const char *repl_options) { - LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL, - (lldb::LanguageType, const char *), language, - repl_options); + LLDB_INSTRUMENT_VA(this, language, repl_options); SBError error; if (m_opaque_sp) error.ref() = m_opaque_sp->RunREPL(language, repl_options); else error.SetErrorString("invalid debugger"); - return LLDB_RECORD_RESULT(error); + return error; } void SBDebugger::reset(const DebuggerSP &debugger_sp) { @@ -1298,28 +1231,25 @@ Debugger &SBDebugger::ref() const { const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; } SBDebugger SBDebugger::FindDebuggerWithID(int id) { - LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID, - (int), id); + LLDB_INSTRUMENT_VA(id); // No need to lock, the debugger list is thread safe SBDebugger sb_debugger; DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id); if (debugger_sp) sb_debugger.reset(debugger_sp); - return LLDB_RECORD_RESULT(sb_debugger); + return sb_debugger; } const char *SBDebugger::GetInstanceName() { - LLDB_RECORD_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName); + LLDB_INSTRUMENT_VA(this); return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr); } SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value, const char *debugger_instance_name) { - LLDB_RECORD_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable, - (const char *, const char *, const char *), - var_name, value, debugger_instance_name); + LLDB_INSTRUMENT_VA(var_name, value, debugger_instance_name); SBError sb_error; DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName( @@ -1336,15 +1266,13 @@ SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value, } if (error.Fail()) sb_error.SetError(error); - return LLDB_RECORD_RESULT(sb_error); + return sb_error; } SBStringList SBDebugger::GetInternalVariableValue(const char *var_name, const char *debugger_instance_name) { - LLDB_RECORD_STATIC_METHOD( - lldb::SBStringList, SBDebugger, GetInternalVariableValue, - (const char *, const char *), var_name, debugger_instance_name); + LLDB_INSTRUMENT_VA(var_name, debugger_instance_name); DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName( ConstString(debugger_instance_name))); @@ -1361,28 +1289,28 @@ SBDebugger::GetInternalVariableValue(const char *var_name, if (!value_str.empty()) { StringList string_list; string_list.SplitIntoLines(value_str); - return LLDB_RECORD_RESULT(SBStringList(&string_list)); + return SBStringList(&string_list); } } } - return LLDB_RECORD_RESULT(SBStringList()); + return SBStringList(); } uint32_t SBDebugger::GetTerminalWidth() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDebugger, GetTerminalWidth); + LLDB_INSTRUMENT_VA(this); return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0); } void SBDebugger::SetTerminalWidth(uint32_t term_width) { - LLDB_RECORD_DUMMY(void, SBDebugger, SetTerminalWidth, (uint32_t), term_width); + LLDB_INSTRUMENT_VA(this, term_width); if (m_opaque_sp) m_opaque_sp->SetTerminalWidth(term_width); } const char *SBDebugger::GetPrompt() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt); + LLDB_INSTRUMENT_VA(this); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); @@ -1395,14 +1323,14 @@ const char *SBDebugger::GetPrompt() const { } void SBDebugger::SetPrompt(const char *prompt) { - LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt); + LLDB_INSTRUMENT_VA(this, prompt); if (m_opaque_sp) m_opaque_sp->SetPrompt(llvm::StringRef(prompt)); } const char *SBDebugger::GetReproducerPath() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath); + LLDB_INSTRUMENT_VA(this); return (m_opaque_sp ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString() @@ -1410,60 +1338,71 @@ const char *SBDebugger::GetReproducerPath() const { } ScriptLanguage SBDebugger::GetScriptLanguage() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger, - GetScriptLanguage); + LLDB_INSTRUMENT_VA(this); return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone); } void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) { - LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage, - (lldb::ScriptLanguage), script_lang); + LLDB_INSTRUMENT_VA(this, script_lang); if (m_opaque_sp) { m_opaque_sp->SetScriptLanguage(script_lang); } } +LanguageType SBDebugger::GetREPLLanguage() const { + LLDB_INSTRUMENT_VA(this); + + return (m_opaque_sp ? m_opaque_sp->GetREPLLanguage() : eLanguageTypeUnknown); +} + +void SBDebugger::SetREPLLanguage(LanguageType repl_lang) { + LLDB_INSTRUMENT_VA(this, repl_lang); + + if (m_opaque_sp) { + m_opaque_sp->SetREPLLanguage(repl_lang); + } +} + bool SBDebugger::SetUseExternalEditor(bool value) { - LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value); + LLDB_INSTRUMENT_VA(this, value); return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false); } bool SBDebugger::GetUseExternalEditor() { - LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor); + LLDB_INSTRUMENT_VA(this); return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false); } bool SBDebugger::SetUseColor(bool value) { - LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value); + LLDB_INSTRUMENT_VA(this, value); return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false); } bool SBDebugger::GetUseColor() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor); + LLDB_INSTRUMENT_VA(this); return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false); } bool SBDebugger::SetUseSourceCache(bool value) { - LLDB_RECORD_METHOD(bool, SBDebugger, SetUseSourceCache, (bool), value); + LLDB_INSTRUMENT_VA(this, value); return (m_opaque_sp ? m_opaque_sp->SetUseSourceCache(value) : false); } bool SBDebugger::GetUseSourceCache() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseSourceCache); + LLDB_INSTRUMENT_VA(this); return (m_opaque_sp ? m_opaque_sp->GetUseSourceCache() : false); } bool SBDebugger::GetDescription(SBStream &description) { - LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &), - description); + LLDB_INSTRUMENT_VA(this, description); Stream &strm = description.ref(); @@ -1478,14 +1417,13 @@ bool SBDebugger::GetDescription(SBStream &description) { } user_id_t SBDebugger::GetID() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID); + LLDB_INSTRUMENT_VA(this); return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID); } SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) { - LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, - (const char *), platform_name_cstr); + LLDB_INSTRUMENT_VA(this, platform_name_cstr); SBError sb_error; if (m_opaque_sp) { @@ -1511,91 +1449,77 @@ SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) { } else { sb_error.ref().SetErrorString("invalid debugger"); } - return LLDB_RECORD_RESULT(sb_error); + return sb_error; } bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) { - LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, - (const char *), sysroot); + LLDB_INSTRUMENT_VA(this, sysroot); - Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); - if (m_opaque_sp) { - PlatformSP platform_sp( - m_opaque_sp->GetPlatformList().GetSelectedPlatform()); - - if (platform_sp) { - if (log && sysroot) - LLDB_LOGF(log, "SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")", - sysroot); - platform_sp->SetSDKRootDirectory(ConstString(sysroot)); - return true; - } + if (SBPlatform platform = GetSelectedPlatform()) { + platform.SetSDKRoot(sysroot); + return true; } return false; } bool SBDebugger::GetCloseInputOnEOF() const { - LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF); + LLDB_INSTRUMENT_VA(this); return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false); } void SBDebugger::SetCloseInputOnEOF(bool b) { - LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b); + LLDB_INSTRUMENT_VA(this, b); if (m_opaque_sp) m_opaque_sp->SetCloseInputOnEOF(b); } SBTypeCategory SBDebugger::GetCategory(const char *category_name) { - LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, - (const char *), category_name); + LLDB_INSTRUMENT_VA(this, category_name); if (!category_name || *category_name == 0) - return LLDB_RECORD_RESULT(SBTypeCategory()); + return SBTypeCategory(); TypeCategoryImplSP category_sp; if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, false)) { - return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); + return SBTypeCategory(category_sp); } else { - return LLDB_RECORD_RESULT(SBTypeCategory()); + return SBTypeCategory(); } } SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) { - LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, - (lldb::LanguageType), lang_type); + LLDB_INSTRUMENT_VA(this, lang_type); TypeCategoryImplSP category_sp; if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) { - return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); + return SBTypeCategory(category_sp); } else { - return LLDB_RECORD_RESULT(SBTypeCategory()); + return SBTypeCategory(); } } SBTypeCategory SBDebugger::CreateCategory(const char *category_name) { - LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, - (const char *), category_name); + LLDB_INSTRUMENT_VA(this, category_name); if (!category_name || *category_name == 0) - return LLDB_RECORD_RESULT(SBTypeCategory()); + return SBTypeCategory(); TypeCategoryImplSP category_sp; if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, true)) { - return LLDB_RECORD_RESULT(SBTypeCategory(category_sp)); + return SBTypeCategory(category_sp); } else { - return LLDB_RECORD_RESULT(SBTypeCategory()); + return SBTypeCategory(); } } bool SBDebugger::DeleteCategory(const char *category_name) { - LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *), - category_name); + LLDB_INSTRUMENT_VA(this, category_name); if (!category_name || *category_name == 0) return false; @@ -1604,64 +1528,56 @@ bool SBDebugger::DeleteCategory(const char *category_name) { } uint32_t SBDebugger::GetNumCategories() { - LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories); + LLDB_INSTRUMENT_VA(this); return DataVisualization::Categories::GetCount(); } SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) { - LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, - (uint32_t), index); + LLDB_INSTRUMENT_VA(this, index); - return LLDB_RECORD_RESULT( - SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index))); + return SBTypeCategory( + DataVisualization::Categories::GetCategoryAtIndex(index)); } SBTypeCategory SBDebugger::GetDefaultCategory() { - LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger, - GetDefaultCategory); + LLDB_INSTRUMENT_VA(this); - return LLDB_RECORD_RESULT(GetCategory("default")); + return GetCategory("default"); } SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) { - LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, - (lldb::SBTypeNameSpecifier), type_name); + LLDB_INSTRUMENT_VA(this, type_name); SBTypeCategory default_category_sb = GetDefaultCategory(); if (default_category_sb.GetEnabled()) - return LLDB_RECORD_RESULT(default_category_sb.GetFormatForType(type_name)); - return LLDB_RECORD_RESULT(SBTypeFormat()); + return default_category_sb.GetFormatForType(type_name); + return SBTypeFormat(); } SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) { - LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, - (lldb::SBTypeNameSpecifier), type_name); + LLDB_INSTRUMENT_VA(this, type_name); if (!type_name.IsValid()) - return LLDB_RECORD_RESULT(SBTypeSummary()); - return LLDB_RECORD_RESULT( - SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()))); + return SBTypeSummary(); + return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP())); } SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) { - LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, - (lldb::SBTypeNameSpecifier), type_name); + LLDB_INSTRUMENT_VA(this, type_name); if (!type_name.IsValid()) - return LLDB_RECORD_RESULT(SBTypeFilter()); - return LLDB_RECORD_RESULT( - SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()))); + return SBTypeFilter(); + return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP())); } SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) { - LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, - (lldb::SBTypeNameSpecifier), type_name); + LLDB_INSTRUMENT_VA(this, type_name); if (!type_name.IsValid()) - return LLDB_RECORD_RESULT(SBTypeSynthetic()); - return LLDB_RECORD_RESULT(SBTypeSynthetic( - DataVisualization::GetSyntheticForType(type_name.GetSP()))); + return SBTypeSynthetic(); + return SBTypeSynthetic( + DataVisualization::GetSyntheticForType(type_name.GetSP())); } static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) { @@ -1674,8 +1590,7 @@ static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) { } bool SBDebugger::EnableLog(const char *channel, const char **categories) { - LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **), - channel, categories); + LLDB_INSTRUMENT_VA(this, channel, categories); if (m_opaque_sp) { uint32_t log_options = @@ -1690,224 +1605,9 @@ bool SBDebugger::EnableLog(const char *channel, const char **categories) { void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton) { - LLDB_RECORD_DUMMY(void, SBDebugger, SetLoggingCallback, - (lldb::LogOutputCallback, void *), log_callback, baton); + LLDB_INSTRUMENT_VA(this, log_callback, baton); if (m_opaque_sp) { return m_opaque_sp->SetLoggingCallback(log_callback, baton); } } - -namespace lldb_private { -namespace repro { - -template <> void RegisterMethods<SBInputReader>(Registry &R) { - LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool)); - LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ()); -} - -static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) { - // Do nothing. -} - -static SBError SetFileRedirect(SBDebugger *, SBFile file) { return SBError(); } - -static SBError SetFileRedirect(SBDebugger *, FileSP file) { return SBError(); } - -template <> void RegisterMethods<SBDebugger>(Registry &R) { - // Custom implementation. - R.Register(&invoke<void (SBDebugger::*)(FILE *, bool)>::method< - &SBDebugger::SetErrorFileHandle>::record, - &SetFileHandleRedirect); - R.Register(&invoke<void (SBDebugger::*)(FILE *, bool)>::method< - &SBDebugger::SetOutputFileHandle>::record, - &SetFileHandleRedirect); - - R.Register(&invoke<SBError (SBDebugger::*)( - SBFile)>::method<&SBDebugger::SetInputFile>::record, - &SetFileRedirect); - R.Register(&invoke<SBError (SBDebugger::*)( - SBFile)>::method<&SBDebugger::SetOutputFile>::record, - &SetFileRedirect); - R.Register(&invoke<SBError (SBDebugger::*)( - SBFile)>::method<&SBDebugger::SetErrorFile>::record, - &SetFileRedirect); - - R.Register(&invoke<SBError (SBDebugger::*)( - FileSP)>::method<&SBDebugger::SetInputFile>::record, - &SetFileRedirect); - R.Register(&invoke<SBError (SBDebugger::*)( - FileSP)>::method<&SBDebugger::SetOutputFile>::record, - &SetFileRedirect); - R.Register(&invoke<SBError (SBDebugger::*)( - FileSP)>::method<&SBDebugger::SetErrorFile>::record, - &SetFileRedirect); - - LLDB_REGISTER_CHAR_PTR_METHOD_STATIC(bool, SBDebugger, - GetDefaultArchitecture); - - LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ()); - LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &)); - LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &)); - LLDB_REGISTER_METHOD(lldb::SBDebugger &, - SBDebugger, operator=,(const lldb::SBDebugger &)); - LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ()); - LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, - InitializeWithErrorHandling, ()); - LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ()); - LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ()); - LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ()); - LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool)); - LLDB_REGISTER_STATIC_METHOD( - const char *, SBDebugger, GetProgressFromEvent, - (const lldb::SBEvent &, uint64_t &, uint64_t &, uint64_t &, bool &)); - LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetBroadcasterClass, - ()); - LLDB_REGISTER_METHOD(SBBroadcaster, SBDebugger, GetBroadcaster, ()); - LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &)); - LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ()); - LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ()); - LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool,()); - LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool)); - LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ()); - LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool)); - LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool)); - LLDB_REGISTER_METHOD(SBError, SBDebugger, SetInputString, (const char *)); - LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool)); - LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ()); - LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ()); - LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ()); - LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetInputFile, ()); - LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetOutputFile, ()); - LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetErrorFile, ()); - LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ()); - LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ()); - LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger, - GetCommandInterpreter, ()); - LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *)); - LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ()); - LLDB_REGISTER_METHOD( - void, SBDebugger, HandleProcessEvent, - (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *)); - LLDB_REGISTER_METHOD( - void, SBDebugger, HandleProcessEvent, - (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile)); - LLDB_REGISTER_METHOD( - void, SBDebugger, HandleProcessEvent, - (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP)); - LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager, ()); - LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture, - (const char *)); - LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage, - (const char *)); - LLDB_REGISTER_METHOD(SBStructuredData, SBDebugger, GetScriptInterpreterInfo, - (lldb::ScriptLanguage)); - LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ()); - LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString, - (lldb::StateType)); - LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger, - GetBuildConfiguration, ()); - LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState, - (lldb::StateType)); - LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState, - (lldb::StateType)); - LLDB_REGISTER_METHOD( - lldb::SBTarget, SBDebugger, CreateTarget, - (const char *, const char *, const char *, bool, lldb::SBError &)); - LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, - CreateTargetWithFileAndTargetTriple, - (const char *, const char *)); - LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch, - (const char *, const char *)); - LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, - (const char *)); - LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ()); - LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &)); - LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, - (uint32_t)); - LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, - (lldb::SBTarget)); - LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID, - (lldb::pid_t)); - LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch, - (const char *, const char *)); - LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ()); - LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ()); - LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &)); - LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ()); - LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform, - (lldb::SBPlatform &)); - LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ()); - LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex, - (uint32_t)); - LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ()); - LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger, - GetAvailablePlatformInfoAtIndex, (uint32_t)); - LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ()); - LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ()); - LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader, - (lldb::SBInputReader &)); - LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool)); - LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, - (bool, bool, lldb::SBCommandInterpreterRunOptions &, - int &, bool &, bool &)); - LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL, - (lldb::LanguageType, const char *)); - LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID, - (int)); - LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ()); - LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable, - (const char *, const char *, const char *)); - LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger, - GetInternalVariableValue, - (const char *, const char *)); - LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ()); - LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t)); - LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ()); - LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *)); - LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ()); - LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger, - GetScriptLanguage, ()); - LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage, - (lldb::ScriptLanguage)); - LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool)); - LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ()); - LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool)); - LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ()); - LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &)); - LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ()); - LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform, - (const char *)); - LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot, - (const char *)); - LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ()); - LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool)); - LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, - (const char *)); - LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory, - (lldb::LanguageType)); - LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory, - (const char *)); - LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *)); - LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ()); - LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex, - (uint32_t)); - LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory, - ()); - LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType, - (lldb::SBTypeNameSpecifier)); - LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType, - (lldb::SBTypeNameSpecifier)); - LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType, - (lldb::SBTypeNameSpecifier)); - LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType, - (lldb::SBTypeNameSpecifier)); - LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog, - (const char *, const char **)); - LLDB_REGISTER_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger, - RunCommandInterpreter, - (const lldb::SBCommandInterpreterRunOptions &)); -} - -} // namespace repro -} // namespace lldb_private |