}
void SBBreakpoint::SetCallback(SBBreakpointHitCallback callback, void *baton) {
- LLDB_RECORD_DUMMY(void, SBBreakpoint, SetCallback,
- (lldb::SBBreakpointHitCallback, void *), callback, baton);
+ LLDB_RECORD_METHOD(void, SBBreakpoint, SetCallback,
+ (lldb::SBBreakpointHitCallback, void *), callback, baton);
BreakpointSP bkpt_sp = GetSP();
void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
void *baton) {
- LLDB_RECORD_DUMMY(void, SBBreakpointName, SetCallback,
- (lldb::SBBreakpointHitCallback, void *), callback, baton);
+ LLDB_RECORD_METHOD(void, SBBreakpointName, SetCallback,
+ (lldb::SBBreakpointHitCallback, void *), callback, baton);
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
bool SBCommandInterpreter::SetCommandOverrideCallback(
const char *command_name, lldb::CommandOverrideCallback callback,
void *baton) {
- LLDB_RECORD_DUMMY(bool, SBCommandInterpreter, SetCommandOverrideCallback,
- (const char *, lldb::CommandOverrideCallback, void *),
- command_name, callback, baton);
+ LLDB_RECORD_METHOD(bool, SBCommandInterpreter, SetCommandOverrideCallback,
+ (const char *, lldb::CommandOverrideCallback, void *),
+ command_name, callback, baton);
if (command_name && command_name[0] && IsValid()) {
llvm::StringRef command_name_str = command_name;
}
size_t SBCommandReturnObject::PutOutput(FILE *fh) {
- LLDB_RECORD_DUMMY(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh);
+ LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh);
if (fh) {
size_t num_bytes = GetOutputSize();
if (num_bytes)
}
size_t SBCommandReturnObject::PutError(FILE *fh) {
- LLDB_RECORD_DUMMY(size_t, SBCommandReturnObject, PutError, (FILE *), fh);
+ LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *), fh);
if (fh) {
size_t num_bytes = GetErrorSize();
if (num_bytes)
}
void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) {
- LLDB_RECORD_DUMMY(void, SBCommandReturnObject, SetImmediateOutputFile,
- (FILE *), fh);
+ LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+ (FILE *), fh);
SetImmediateOutputFile(fh, false);
}
void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) {
- LLDB_RECORD_DUMMY(void, SBCommandReturnObject, SetImmediateErrorFile,
- (FILE *), fh);
+ LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+ (FILE *), fh);
SetImmediateErrorFile(fh, false);
}
void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh,
bool transfer_ownership) {
- LLDB_RECORD_DUMMY(void, SBCommandReturnObject, SetImmediateOutputFile,
- (FILE *, bool), fh, transfer_ownership);
+ LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
+ (FILE *, bool), fh, transfer_ownership);
FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership);
ref().SetImmediateOutputFile(file);
}
void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh,
bool transfer_ownership) {
- LLDB_RECORD_DUMMY(void, SBCommandReturnObject, SetImmediateErrorFile,
- (FILE *, bool), fh, transfer_ownership);
+ LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
+ (FILE *, bool), fh, transfer_ownership);
FileSP file = std::make_shared<NativeFile>(fh, transfer_ownership);
ref().SetImmediateErrorFile(file);
}
size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
ConnectionStatus &status) {
- LLDB_RECORD_DUMMY(size_t, SBCommunication, Read,
- (void *, size_t, uint32_t, lldb::ConnectionStatus &), dst,
- dst_len, timeout_usec, status);
+ LLDB_RECORD_METHOD(size_t, SBCommunication, Read,
+ (void *, size_t, uint32_t, lldb::ConnectionStatus &), dst,
+ dst_len, timeout_usec, status);
size_t bytes_read = 0;
Timeout<std::micro> timeout = timeout_usec == UINT32_MAX
size_t SBCommunication::Write(const void *src, size_t src_len,
ConnectionStatus &status) {
- LLDB_RECORD_DUMMY(size_t, SBCommunication, Write,
- (const void *, size_t, lldb::ConnectionStatus &), src,
- src_len, status);
+ LLDB_RECORD_METHOD(size_t, SBCommunication, Write,
+ (const void *, size_t, lldb::ConnectionStatus &), src,
+ src_len, status);
size_t bytes_written = 0;
if (m_opaque)
bool SBCommunication::SetReadThreadBytesReceivedCallback(
ReadThreadBytesReceived callback, void *callback_baton) {
- LLDB_RECORD_DUMMY(bool, SBCommunication, SetReadThreadBytesReceivedCallback,
- (lldb::SBCommunication::ReadThreadBytesReceived, void *),
- callback, callback_baton);
+ LLDB_RECORD_METHOD(bool, SBCommunication, SetReadThreadBytesReceivedCallback,
+ (lldb::SBCommunication::ReadThreadBytesReceived, void *),
+ callback, callback_baton);
bool result = false;
if (m_opaque) {
size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset,
void *buf, size_t size) {
- LLDB_RECORD_DUMMY(size_t, SBData, ReadRawData,
- (lldb::SBError &, lldb::offset_t, void *, size_t), error,
- offset, buf, size);
+ LLDB_RECORD_METHOD(size_t, SBData, ReadRawData,
+ (lldb::SBError &, lldb::offset_t, void *, size_t), error,
+ offset, buf, size);
void *ok = nullptr;
if (!m_opaque_sp.get()) {
void SBData::SetData(lldb::SBError &error, const void *buf, size_t size,
lldb::ByteOrder endian, uint8_t addr_size) {
- LLDB_RECORD_DUMMY(
+ LLDB_RECORD_METHOD(
void, SBData, SetData,
(lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t), error,
buf, size, endian, addr_size);
void SBData::SetDataWithOwnership(lldb::SBError &error, const void *buf,
size_t size, lldb::ByteOrder endian,
uint8_t addr_size) {
- LLDB_RECORD_DUMMY(
+ LLDB_RECORD_METHOD(
void, SBData, SetData,
(lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t, bool),
- error, buf, size, endian, addr_size, copy);
+ error, buf, size, endian, addr_size);
lldb::DataBufferSP buffer_sp = std::make_shared<DataBufferHeap>(buf, size);
unsigned long),
void *a, lldb::InputReaderGranularity b, char const *c, char const *d,
bool e) {
- LLDB_RECORD_DUMMY(
+ LLDB_RECORD_METHOD(
lldb::SBError, SBInputReader, Initialize,
(lldb::SBDebugger &,
unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction,
lldb::LogOutputCallback callback, void *baton)
{
- LLDB_RECORD_DUMMY(lldb::SBDebugger, SBDebugger, Create,
- (bool, lldb::LogOutputCallback, void *), source_init_files,
- callback, baton);
+ LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create,
+ (bool, lldb::LogOutputCallback, void *),
+ source_init_files, callback, baton);
SBDebugger debugger;
}
void SBDebugger::SaveInputTerminalState() {
- LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, SaveInputTerminalState);
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, SaveInputTerminalState);
if (m_opaque_sp)
m_opaque_sp->SaveInputTerminalState();
}
void SBDebugger::RestoreInputTerminalState() {
- LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, RestoreInputTerminalState);
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, RestoreInputTerminalState);
if (m_opaque_sp)
m_opaque_sp->RestoreInputTerminalState();
}
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_RECORD_METHOD(void, SBDebugger, DispatchInput,
+ (void *, const void *, size_t), 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_RECORD_METHOD(void, SBDebugger, DispatchInput, (const void *, size_t),
+ data, data_len);
// Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
//
}
void SBDebugger::DispatchInputInterrupt() {
- LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, DispatchInputInterrupt);
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputInterrupt);
if (m_opaque_sp)
m_opaque_sp->DispatchInputInterrupt();
}
void SBDebugger::SetTerminalWidth(uint32_t term_width) {
- LLDB_RECORD_DUMMY(void, SBDebugger, SetTerminalWidth, (uint32_t), term_width);
+ LLDB_RECORD_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t),
+ term_width);
if (m_opaque_sp)
m_opaque_sp->SetTerminalWidth(term_width);
void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
void *baton) {
- LLDB_RECORD_DUMMY(void, SBDebugger, SetLoggingCallback,
- (lldb::LogOutputCallback, void *), log_callback, baton);
+ LLDB_RECORD_METHOD(void, SBDebugger, SetLoggingCallback,
+ (lldb::LogOutputCallback, void *), log_callback, baton);
if (m_opaque_sp) {
return m_opaque_sp->SetLoggingCallback(log_callback, baton);
void SBExpressionOptions::SetCancelCallback(
lldb::ExpressionCancelCallback callback, void *baton) {
- LLDB_RECORD_DUMMY(void, SBExpressionOptions, SetCancelCallback,
- (lldb::ExpressionCancelCallback, void *), callback, baton);
+ LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCancelCallback,
+ (lldb::ExpressionCancelCallback, void *), callback, baton);
m_opaque_up->SetCancelCallback(callback, baton);
}
lldb::thread_t SBHostOS::ThreadCreate(const char *name,
lldb::thread_func_t thread_function,
void *thread_arg, SBError *error_ptr) {
- LLDB_RECORD_DUMMY(lldb::thread_t, SBHostOS, ThreadCreate,
- (lldb::thread_func_t, void *, SBError *), name,
- thread_function, thread_arg, error_ptr);
+ LLDB_RECORD_STATIC_METHOD(lldb::thread_t, SBHostOS, ThreadCreate,
+ (lldb::thread_func_t, void *, SBError *), name,
+ thread_function, thread_arg, error_ptr);
llvm::Expected<HostThread> thread =
ThreadLauncher::LaunchThread(name, thread_function, thread_arg);
if (!thread) {
}
bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) {
- LLDB_RECORD_DUMMY(bool, SBHostOS, ThreadCancel,
+ LLDB_RECORD_STATIC_METHOD(bool, SBHostOS, ThreadCancel,
(lldb::thread_t, lldb::SBError *), thread,
error_ptr);
}
bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) {
- LLDB_RECORD_DUMMY(bool, SBHostOS, ThreadDetach,
+ LLDB_RECORD_STATIC_METHOD(bool, SBHostOS, ThreadDetach,
(lldb::thread_t, lldb::SBError *), thread,
error_ptr);
bool SBHostOS::ThreadJoin(lldb::thread_t thread, lldb::thread_result_t *result,
SBError *error_ptr) {
- LLDB_RECORD_DUMMY(
+ LLDB_RECORD_STATIC_METHOD(
bool, SBHostOS, ThreadJoin,
(lldb::thread_t, lldb::thread_result_t *, lldb::SBError *), thread,
result, error_ptr);
size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len,
SBError &sb_error) {
- LLDB_RECORD_DUMMY(size_t, SBProcess, ReadMemory,
- (lldb::addr_t, void *, size_t, lldb::SBError &), addr, dst,
- dst_len, sb_error);
+ LLDB_RECORD_METHOD(size_t, SBProcess, ReadMemory,
+ (lldb::addr_t, void *, size_t, lldb::SBError &), addr, dst,
+ dst_len, sb_error);
size_t bytes_read = 0;
size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size,
lldb::SBError &sb_error) {
- LLDB_RECORD_DUMMY(size_t, SBProcess, ReadCStringFromMemory,
- (lldb::addr_t, void *, size_t, lldb::SBError &), addr, buf,
- size, sb_error);
+ LLDB_RECORD_METHOD(size_t, SBProcess, ReadCStringFromMemory,
+ (lldb::addr_t, void *, size_t, lldb::SBError &), addr, buf,
+ size, sb_error);
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len,
SBError &sb_error) {
- LLDB_RECORD_DUMMY(size_t, SBProcess, WriteMemory,
- (lldb::addr_t, const void *, size_t, lldb::SBError &), addr,
- src, src_len, sb_error);
+ LLDB_RECORD_METHOD(size_t, SBProcess, WriteMemory,
+ (lldb::addr_t, const void *, size_t, lldb::SBError &),
+ addr, src, src_len, sb_error);
size_t bytes_written = 0;
SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,
uint32_t options,
const char *description) {
- LLDB_RECORD_DUMMY(
+ LLDB_RECORD_STATIC_METHOD(
lldb::SBTypeSummary, SBTypeSummary, CreateWithCallback,
(lldb::SBTypeSummary::FormatCallback, uint32_t, const char *), cb,
options, description);