SBInputReader() = default;
~SBInputReader() = default;
- SBError Initialize(lldb::SBDebugger &,
- unsigned long (*)(void *, lldb::SBInputReader *,
- lldb::InputReaderAction, char const *,
- unsigned long),
- void *, lldb::InputReaderGranularity, char const *,
- char const *, bool);
+ SBError Initialize(lldb::SBDebugger &sb_debugger,
+ unsigned long (*callback)(void *, lldb::SBInputReader *,
+ lldb::InputReaderAction,
+ char const *, unsigned long),
+ void *a, lldb::InputReaderGranularity b, char const *c,
+ char const *d, bool e);
void SetIsDone(bool);
bool IsActive() const;
};
return LLDB_RECORD_RESULT(error);
}
-void SBBreakpoint
- ::SetCallback(SBBreakpointHitCallback callback,
- void *baton) {
+void SBBreakpoint ::SetCallback(SBBreakpointHitCallback callback, void *baton) {
+ LLDB_RECORD_DUMMY(void, SBBreakpoint, SetCallback,
+ (lldb::SBBreakpointHitCallback, void *), callback, baton);
+
BreakpointSP bkpt_sp = GetSP();
if (bkpt_sp) {
void SBBreakpointName::SetCallback(SBBreakpointHitCallback callback,
void *baton) {
+ LLDB_RECORD_DUMMY(void, SBBreakpointName, SetCallback,
+ (lldb::SBBreakpointHitCallback, void *), callback, baton);
+
BreakpointName *bp_name = GetBreakpointName();
if (!bp_name)
return;
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);
+
if (command_name && command_name[0] && IsValid()) {
llvm::StringRef command_name_str = command_name;
CommandObject *cmd_obj =
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);
+
size_t bytes_read = 0;
Timeout<std::micro> timeout = timeout_usec == UINT32_MAX
? Timeout<std::micro>(llvm::None)
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);
+
size_t bytes_written = 0;
if (m_opaque)
bytes_written = m_opaque->Write(src, src_len, status, NULL);
bool SBCommunication::SetReadThreadBytesReceivedCallback(
ReadThreadBytesReceived callback, void *callback_baton) {
+ LLDB_RECORD_DUMMY(bool, SBCommunication, SetReadThreadBytesReceivedCallback,
+ (lldb::SBCommunication::ReadThreadBytesReceived, void *),
+ callback, callback_baton);
+
bool result = false;
if (m_opaque) {
m_opaque->SetReadThreadBytesReceivedCallback(callback, callback_baton);
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);
+
void *ok = NULL;
if (!m_opaque_sp.get()) {
error.SetErrorString("no value to read from");
void SBData::SetData(lldb::SBError &error, const void *buf, size_t size,
lldb::ByteOrder endian, uint8_t addr_size) {
+ LLDB_RECORD_DUMMY(
+ void, SBData, SetData,
+ (lldb::SBError &, const void *, size_t, lldb::ByteOrder, uint8_t), error,
+ buf, size, endian, addr_size);
+
if (!m_opaque_sp.get())
m_opaque_sp = std::make_shared<DataExtractor>(buf, size, endian, addr_size);
else
m_opaque_sp->SetData(buf, size, endian);
m_opaque_sp->SetAddressByteSize(addr_size);
}
-
}
bool SBData::Append(const SBData &rhs) {
SBError SBInputReader::Initialize(
lldb::SBDebugger &sb_debugger,
- unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction,
- char const *, unsigned long),
- void *, lldb::InputReaderGranularity, char const *, char const *, bool) {
+ unsigned long (*callback)(void *, lldb::SBInputReader *,
+ lldb::InputReaderAction, char const *,
+ 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);
+
return SBError();
}
lldb::LogOutputCallback callback, void *baton)
{
+ LLDB_RECORD_DUMMY(lldb::SBDebugger, SBDebugger, Create,
+ (bool, lldb::LogOutputCallback, void *), source_init_files,
+ callback, baton);
SBDebugger debugger;
}
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);
+
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);
+
// Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
//
// if (log)
void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
void *baton) {
+ LLDB_RECORD_DUMMY(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);
+
m_opaque_up->SetCancelCallback(callback, baton);
}
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);
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);
+
size_t bytes_read = 0;
ProcessSP process_sp(GetSP());
if (process_sp) {
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);
+
size_t bytes_written = 0;
ProcessSP process_sp(GetSP());
size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size,
lldb::SBError &error) {
+ LLDB_RECORD_DUMMY(size_t, SBTarget, ReadMemory,
+ (const lldb::SBAddress, void *, size_t, lldb::SBError &),
+ addr, buf, size, error);
+
SBError sb_error;
size_t bytes_read = 0;
TargetSP target_sp(GetSP());
lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr,
const void *buf,
size_t size) {
+ LLDB_RECORD_DUMMY(lldb::SBInstructionList, SBTarget, GetInstructions,
+ (lldb::SBAddress, const void *, size_t), base_addr, buf,
+ size);
+
return GetInstructionsWithFlavor(base_addr, NULL, buf, size);
}
SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr,
const char *flavor_string, const void *buf,
size_t size) {
+ LLDB_RECORD_DUMMY(lldb::SBInstructionList, SBTarget,
+ GetInstructionsWithFlavor,
+ (lldb::SBAddress, const char *, const void *, size_t),
+ base_addr, flavor_string, buf, size);
+
SBInstructionList sb_instructions;
TargetSP target_sp(GetSP());
lldb::SBInstructionList SBTarget::GetInstructions(lldb::addr_t base_addr,
const void *buf,
size_t size) {
+ LLDB_RECORD_DUMMY(lldb::SBInstructionList, SBTarget, GetInstructions,
+ (lldb::addr_t, const void *, size_t), base_addr, buf, size);
+
return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), NULL, buf,
size);
}
SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr,
const char *flavor_string, const void *buf,
size_t size) {
+ LLDB_RECORD_DUMMY(lldb::SBInstructionList, SBTarget,
+ GetInstructionsWithFlavor,
+ (lldb::addr_t, const char *, const void *, size_t),
+ base_addr, flavor_string, buf, size);
+
return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), flavor_string,
buf, size);
}
size_t SBTrace::GetTraceData(SBError &error, void *buf, size_t size,
size_t offset, lldb::tid_t thread_id) {
+ LLDB_RECORD_DUMMY(size_t, SBTrace, GetTraceData,
+ (lldb::SBError &, void *, size_t, size_t, lldb::tid_t),
+ error, buf, size, offset, thread_id);
+
ProcessSP process_sp(GetSP());
llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size);
error.Clear();
size_t SBTrace::GetMetaData(SBError &error, void *buf, size_t size,
size_t offset, lldb::tid_t thread_id) {
+ LLDB_RECORD_DUMMY(size_t, SBTrace, GetMetaData,
+ (lldb::SBError &, void *, size_t, size_t, lldb::tid_t),
+ error, buf, size, offset, thread_id);
+
ProcessSP process_sp(GetSP());
llvm::MutableArrayRef<uint8_t> buffer(static_cast<uint8_t *>(buf), size);
error.Clear();
SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,
uint32_t options,
const char *description) {
+ LLDB_RECORD_DUMMY(
+ lldb::SBTypeSummary, SBTypeSummary, CreateWithCallback,
+ (lldb::SBTypeSummary::FormatCallback, uint32_t, const char *), cb,
+ options, description);
+
SBTypeSummary retval;
if (cb) {
retval.SetSP(TypeSummaryImplSP(new CXXFunctionSummaryFormat(