fabi/Xenia-Canary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fleshing out debugger types.

Browse Source
This commit is contained in:
Ben Vanik
2015-05-24 13:43:15 -07:00
parent da655d15b3
commit e55be7d2c9
103 changed files with 4008 additions and 2025 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
src/xenia/debug/debugger.cc
View File

@@ -25,7 +25,10 @@
// Autogenerated Flatbuffers files:
#include "xenia/debug/proto/breakpoints_generated.h"
#include "xenia/debug/proto/common_generated.h"
#include "xenia/debug/proto/control_generated.h"
#include "xenia/debug/proto/messages_generated.h"
#include "xenia/debug/proto/modules_generated.h"
DEFINE_string(debug_session_path, "", "Debug output path.");
DEFINE_int32(debug_port, 19000, "Port the debugger listens on.");
@@ -211,21 +214,62 @@ void Debugger::OnMessage(std::vector<uint8_t> buffer) {
//
response_data_offset = response_data.Finish().Union();
} break;
case proto::RequestData_AddBreakpointRequest: {
response_data_type = proto::ResponseData_RemoveBreakpointResponse;
auto response_data = proto::AddBreakpointResponseBuilder(fbb);
case proto::RequestData_AddBreakpointsRequest: {
response_data_type = proto::ResponseData_RemoveBreakpointsResponse;
auto response_data = proto::AddBreakpointsResponseBuilder(fbb);
//
response_data_offset = response_data.Finish().Union();
} break;
case proto::RequestData_UpdateBreakpointRequest: {
response_data_type = proto::ResponseData_UpdateBreakpointResponse;
auto response_data = proto::UpdateBreakpointResponseBuilder(fbb);
case proto::RequestData_UpdateBreakpointsRequest: {
response_data_type = proto::ResponseData_UpdateBreakpointsResponse;
auto response_data = proto::UpdateBreakpointsResponseBuilder(fbb);
//
response_data_offset = response_data.Finish().Union();
} break;
case proto::RequestData_RemoveBreakpointRequest: {
response_data_type = proto::ResponseData_AddBreakpointResponse;
auto response_data = proto::RemoveBreakpointResponseBuilder(fbb);
case proto::RequestData_RemoveBreakpointsRequest: {
response_data_type = proto::ResponseData_AddBreakpointsResponse;
auto response_data = proto::RemoveBreakpointsResponseBuilder(fbb);
//
response_data_offset = response_data.Finish().Union();
} break;
case proto::RequestData_ListModulesRequest: {
response_data_type = proto::ResponseData_ListModulesResponse;
auto response_data = proto::ListModulesResponseBuilder(fbb);
//
response_data_offset = response_data.Finish().Union();
} break;
case proto::RequestData_GetModuleRequest: {
response_data_type = proto::ResponseData_GetModuleResponse;
auto response_data = proto::GetModuleResponseBuilder(fbb);
//
response_data_offset = response_data.Finish().Union();
} break;
case proto::RequestData_StopRequest: {
response_data_type = proto::ResponseData_StopResponse;
auto response_data = proto::StopResponseBuilder(fbb);
// TODO(benvanik): gracefully die?
exit(1);
response_data_offset = response_data.Finish().Union();
} break;
case proto::RequestData_BreakRequest: {
response_data_type = proto::ResponseData_BreakResponse;
auto response_data = proto::BreakResponseBuilder(fbb);
//
SuspendAllThreads();
response_data_offset = response_data.Finish().Union();
} break;
case proto::RequestData_ContinueRequest: {
response_data_type = proto::ResponseData_ContinueResponse;
auto response_data = proto::ContinueResponseBuilder(fbb);
//
ResumeAllThreads();
response_data_offset = response_data.Finish().Union();
} break;
case proto::RequestData_StepRequest: {
response_data_type = proto::ResponseData_StepResponse;
auto response_data = proto::StepResponseBuilder(fbb);
//
response_data_offset = response_data.Finish().Union();
} break;

81
src/xenia/debug/function_data.h
View File

@@ -1,81 +0,0 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2015 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_DEBUG_FUNCTION_DATA_H_
#define XENIA_DEBUG_FUNCTION_DATA_H_
#include <cstdint>
#include "xenia/base/memory.h"
namespace xe {
namespace debug {
class FunctionData {
public:
struct Header {
// Format is used by tooling, changes must be made across all targets.
// + 0 4b (data size)
// + 4 4b start_address
// + 8 4b end_address
// +12 4b type (user, external, etc)
// +16 4b source_map_entry_count
//
// +20 4b source_disasm_length
// +20 4b raw_hir_disasm_length
// +20 4b hir_disasm_length
// +20 4b machine_code_disasm_length
// +20 12b* source_map_entries
uint32_t data_size;
uint32_t start_address;
uint32_t end_address;
uint32_t type;
/*
source_map_count
source_map[] : {ppc_address, hir_offset, code_offset}
raw_hir_disasm_ (len + chars)
hir_disasm_ (len + chars)
machine_code_ (len + bytes) (without tracing? regen?)
*/
};
FunctionData() : header_(nullptr) {}
void Reset(uint8_t* trace_data, size_t trace_data_size,
uint32_t start_address, uint32_t end_address) {
header_ = reinterpret_cast<Header*>(trace_data);
header_->data_size = uint32_t(trace_data_size);
header_->start_address = start_address;
header_->end_address = end_address;
header_->type = 0;
// Clear any remaining.
std::memset(trace_data + sizeof(Header), 0,
trace_data_size - sizeof(Header));
}
bool is_valid() const { return header_ != nullptr; }
uint32_t start_address() const { return header_->start_address; }
uint32_t end_address() const { return header_->end_address; }
uint32_t instruction_count() const {
return (header_->end_address - header_->start_address) / 4 + 1;
}
Header* header() const { return header_; }
static size_t SizeOfHeader() { return sizeof(Header); }
private:
Header* header_;
};
} // namespace debug
} // namespace xe
#endif // XENIA_DEBUG_FUNCTION_DATA_H_

20
src/xenia/debug/proto/breakpoints.fbs
View File

@@ -2,22 +2,30 @@ include "common.fbs";
namespace xe.debug.proto;
struct Breakpoint {
breakpoint_id:uint;
}
table ListBreakpointsRequest {
}
table ListBreakpointsResponse {
breakpoints:[Breakpoint];
}
table AddBreakpointRequest {
table AddBreakpointsRequest {
breakpoints:[Breakpoint];
}
table AddBreakpointResponse {
table AddBreakpointsResponse {
}
table UpdateBreakpointRequest {
table UpdateBreakpointsRequest {
breakpoints:[Breakpoint];
}
table UpdateBreakpointResponse {
table UpdateBreakpointsResponse {
}
table RemoveBreakpointRequest {
table RemoveBreakpointsRequest {
breakpoints:[Breakpoint];
}
table RemoveBreakpointResponse {
table RemoveBreakpointsResponse {
}

246
src/xenia/debug/proto/breakpoints_generated.h
View File

@@ -5,19 +5,39 @@
#include "flatbuffers/flatbuffers.h"
namespace xe {
namespace debug {
namespace proto {
struct XObject;
} // namespace proto
} // namespace debug
} // namespace xe
namespace xe {
namespace debug {
namespace proto {
struct Breakpoint;
struct ListBreakpointsRequest;
struct ListBreakpointsResponse;
struct AddBreakpointRequest;
struct AddBreakpointResponse;
struct UpdateBreakpointRequest;
struct UpdateBreakpointResponse;
struct RemoveBreakpointRequest;
struct RemoveBreakpointResponse;
struct AddBreakpointsRequest;
struct AddBreakpointsResponse;
struct UpdateBreakpointsRequest;
struct UpdateBreakpointsResponse;
struct RemoveBreakpointsRequest;
struct RemoveBreakpointsResponse;
MANUALLY_ALIGNED_STRUCT(4) Breakpoint FLATBUFFERS_FINAL_CLASS {
private:
uint32_t breakpoint_id_;
public:
Breakpoint(uint32_t breakpoint_id)
: breakpoint_id_(flatbuffers::EndianScalar(breakpoint_id)) { }
uint32_t breakpoint_id() const { return flatbuffers::EndianScalar(breakpoint_id_); }
};
STRUCT_END(Breakpoint, 4);
struct ListBreakpointsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
@@ -43,8 +63,11 @@ inline flatbuffers::Offset<ListBreakpointsRequest> CreateListBreakpointsRequest(
}
struct ListBreakpointsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<const Breakpoint *> *breakpoints() const { return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* breakpoints */) &&
verifier.Verify(breakpoints()) &&
verifier.EndTable();
}
};
@@ -52,154 +75,175 @@ struct ListBreakpointsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Ta
struct ListBreakpointsResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_breakpoints(flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints) { fbb_.AddOffset(4, breakpoints); }
ListBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
ListBreakpointsResponseBuilder &operator=(const ListBreakpointsResponseBuilder &);
flatbuffers::Offset<ListBreakpointsResponse> Finish() {
auto o = flatbuffers::Offset<ListBreakpointsResponse>(fbb_.EndTable(start_, 0));
auto o = flatbuffers::Offset<ListBreakpointsResponse>(fbb_.EndTable(start_, 1));
return o;
}
};
inline flatbuffers::Offset<ListBreakpointsResponse> CreateListBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
inline flatbuffers::Offset<ListBreakpointsResponse> CreateListBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints = 0) {
ListBreakpointsResponseBuilder builder_(_fbb);
builder_.add_breakpoints(breakpoints);
return builder_.Finish();
}
struct AddBreakpointRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct AddBreakpointsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<const Breakpoint *> *breakpoints() const { return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* breakpoints */) &&
verifier.Verify(breakpoints()) &&
verifier.EndTable();
}
};
struct AddBreakpointsRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_breakpoints(flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints) { fbb_.AddOffset(4, breakpoints); }
AddBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
AddBreakpointsRequestBuilder &operator=(const AddBreakpointsRequestBuilder &);
flatbuffers::Offset<AddBreakpointsRequest> Finish() {
auto o = flatbuffers::Offset<AddBreakpointsRequest>(fbb_.EndTable(start_, 1));
return o;
}
};
inline flatbuffers::Offset<AddBreakpointsRequest> CreateAddBreakpointsRequest(flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints = 0) {
AddBreakpointsRequestBuilder builder_(_fbb);
builder_.add_breakpoints(breakpoints);
return builder_.Finish();
}
struct AddBreakpointsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct AddBreakpointRequestBuilder {
struct AddBreakpointsResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
AddBreakpointRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
AddBreakpointRequestBuilder &operator=(const AddBreakpointRequestBuilder &);
flatbuffers::Offset<AddBreakpointRequest> Finish() {
auto o = flatbuffers::Offset<AddBreakpointRequest>(fbb_.EndTable(start_, 0));
AddBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
AddBreakpointsResponseBuilder &operator=(const AddBreakpointsResponseBuilder &);
flatbuffers::Offset<AddBreakpointsResponse> Finish() {
auto o = flatbuffers::Offset<AddBreakpointsResponse>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<AddBreakpointRequest> CreateAddBreakpointRequest(flatbuffers::FlatBufferBuilder &_fbb) {
AddBreakpointRequestBuilder builder_(_fbb);
inline flatbuffers::Offset<AddBreakpointsResponse> CreateAddBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
AddBreakpointsResponseBuilder builder_(_fbb);
return builder_.Finish();
}
struct AddBreakpointResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct UpdateBreakpointsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<const Breakpoint *> *breakpoints() const { return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* breakpoints */) &&
verifier.Verify(breakpoints()) &&
verifier.EndTable();
}
};
struct UpdateBreakpointsRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_breakpoints(flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints) { fbb_.AddOffset(4, breakpoints); }
UpdateBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
UpdateBreakpointsRequestBuilder &operator=(const UpdateBreakpointsRequestBuilder &);
flatbuffers::Offset<UpdateBreakpointsRequest> Finish() {
auto o = flatbuffers::Offset<UpdateBreakpointsRequest>(fbb_.EndTable(start_, 1));
return o;
}
};
inline flatbuffers::Offset<UpdateBreakpointsRequest> CreateUpdateBreakpointsRequest(flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints = 0) {
UpdateBreakpointsRequestBuilder builder_(_fbb);
builder_.add_breakpoints(breakpoints);
return builder_.Finish();
}
struct UpdateBreakpointsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct AddBreakpointResponseBuilder {
struct UpdateBreakpointsResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
AddBreakpointResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
AddBreakpointResponseBuilder &operator=(const AddBreakpointResponseBuilder &);
flatbuffers::Offset<AddBreakpointResponse> Finish() {
auto o = flatbuffers::Offset<AddBreakpointResponse>(fbb_.EndTable(start_, 0));
UpdateBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
UpdateBreakpointsResponseBuilder &operator=(const UpdateBreakpointsResponseBuilder &);
flatbuffers::Offset<UpdateBreakpointsResponse> Finish() {
auto o = flatbuffers::Offset<UpdateBreakpointsResponse>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<AddBreakpointResponse> CreateAddBreakpointResponse(flatbuffers::FlatBufferBuilder &_fbb) {
AddBreakpointResponseBuilder builder_(_fbb);
inline flatbuffers::Offset<UpdateBreakpointsResponse> CreateUpdateBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
UpdateBreakpointsResponseBuilder builder_(_fbb);
return builder_.Finish();
}
struct UpdateBreakpointRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct RemoveBreakpointsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<const Breakpoint *> *breakpoints() const { return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* breakpoints */) &&
verifier.Verify(breakpoints()) &&
verifier.EndTable();
}
};
struct RemoveBreakpointsRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_breakpoints(flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints) { fbb_.AddOffset(4, breakpoints); }
RemoveBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
RemoveBreakpointsRequestBuilder &operator=(const RemoveBreakpointsRequestBuilder &);
flatbuffers::Offset<RemoveBreakpointsRequest> Finish() {
auto o = flatbuffers::Offset<RemoveBreakpointsRequest>(fbb_.EndTable(start_, 1));
return o;
}
};
inline flatbuffers::Offset<RemoveBreakpointsRequest> CreateRemoveBreakpointsRequest(flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints = 0) {
RemoveBreakpointsRequestBuilder builder_(_fbb);
builder_.add_breakpoints(breakpoints);
return builder_.Finish();
}
struct RemoveBreakpointsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct UpdateBreakpointRequestBuilder {
struct RemoveBreakpointsResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
UpdateBreakpointRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
UpdateBreakpointRequestBuilder &operator=(const UpdateBreakpointRequestBuilder &);
flatbuffers::Offset<UpdateBreakpointRequest> Finish() {
auto o = flatbuffers::Offset<UpdateBreakpointRequest>(fbb_.EndTable(start_, 0));
RemoveBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
RemoveBreakpointsResponseBuilder &operator=(const RemoveBreakpointsResponseBuilder &);
flatbuffers::Offset<RemoveBreakpointsResponse> Finish() {
auto o = flatbuffers::Offset<RemoveBreakpointsResponse>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<UpdateBreakpointRequest> CreateUpdateBreakpointRequest(flatbuffers::FlatBufferBuilder &_fbb) {
UpdateBreakpointRequestBuilder builder_(_fbb);
return builder_.Finish();
}
struct UpdateBreakpointResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct UpdateBreakpointResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
UpdateBreakpointResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
UpdateBreakpointResponseBuilder &operator=(const UpdateBreakpointResponseBuilder &);
flatbuffers::Offset<UpdateBreakpointResponse> Finish() {
auto o = flatbuffers::Offset<UpdateBreakpointResponse>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<UpdateBreakpointResponse> CreateUpdateBreakpointResponse(flatbuffers::FlatBufferBuilder &_fbb) {
UpdateBreakpointResponseBuilder builder_(_fbb);
return builder_.Finish();
}
struct RemoveBreakpointRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct RemoveBreakpointRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
RemoveBreakpointRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
RemoveBreakpointRequestBuilder &operator=(const RemoveBreakpointRequestBuilder &);
flatbuffers::Offset<RemoveBreakpointRequest> Finish() {
auto o = flatbuffers::Offset<RemoveBreakpointRequest>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<RemoveBreakpointRequest> CreateRemoveBreakpointRequest(flatbuffers::FlatBufferBuilder &_fbb) {
RemoveBreakpointRequestBuilder builder_(_fbb);
return builder_.Finish();
}
struct RemoveBreakpointResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct RemoveBreakpointResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
RemoveBreakpointResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
RemoveBreakpointResponseBuilder &operator=(const RemoveBreakpointResponseBuilder &);
flatbuffers::Offset<RemoveBreakpointResponse> Finish() {
auto o = flatbuffers::Offset<RemoveBreakpointResponse>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<RemoveBreakpointResponse> CreateRemoveBreakpointResponse(flatbuffers::FlatBufferBuilder &_fbb) {
RemoveBreakpointResponseBuilder builder_(_fbb);
inline flatbuffers::Offset<RemoveBreakpointsResponse> CreateRemoveBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
RemoveBreakpointsResponseBuilder builder_(_fbb);
return builder_.Finish();
}

4
src/xenia/debug/proto/common.fbs
View File

@@ -1 +1,5 @@
namespace xe.debug.proto;
struct XObject {
handle:uint;
}

31
src/xenia/debug/proto/common_generated.h Normal file
View File

@@ -0,0 +1,31 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_COMMON_XE_DEBUG_PROTO_H_
#define FLATBUFFERS_GENERATED_COMMON_XE_DEBUG_PROTO_H_
#include "flatbuffers/flatbuffers.h"
namespace xe {
namespace debug {
namespace proto {
struct XObject;
MANUALLY_ALIGNED_STRUCT(4) XObject FLATBUFFERS_FINAL_CLASS {
private:
uint32_t handle_;
public:
XObject(uint32_t handle)
: handle_(flatbuffers::EndianScalar(handle)) { }
uint32_t handle() const { return flatbuffers::EndianScalar(handle_); }
};
STRUCT_END(XObject, 4);
} // namespace proto
} // namespace debug
} // namespace xe
#endif // FLATBUFFERS_GENERATED_COMMON_XE_DEBUG_PROTO_H_

46
src/xenia/debug/proto/control.fbs
View File

@@ -1,3 +1,49 @@
include "common.fbs";
namespace xe.debug.proto;
table StopRequest {
}
table StopResponse {
}
table BreakRequest {
}
table BreakResponse {
}
enum ContinueAction:byte {
Continue,
ContinueTo,
}
table ContinueRequest {
action:ContinueAction;
target_address:uint;
}
table ContinueResponse {
}
enum StepAction:byte {
StepIn,
StepOver,
StepOut,
}
table StepRequest {
action:StepAction;
thread_id:uint;
}
table StepResponse {
}
table BreakpointEvent {
thread_id:uint;
breakpoint_id:uint;
}
table AccessViolationEvent {
thread_id:uint;
target_address:uint;
}

330
src/xenia/debug/proto/control_generated.h Normal file
View File

@@ -0,0 +1,330 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_CONTROL_XE_DEBUG_PROTO_H_
#define FLATBUFFERS_GENERATED_CONTROL_XE_DEBUG_PROTO_H_
#include "flatbuffers/flatbuffers.h"
namespace xe {
namespace debug {
namespace proto {
struct XObject;
} // namespace proto
} // namespace debug
} // namespace xe
namespace xe {
namespace debug {
namespace proto {
struct StopRequest;
struct StopResponse;
struct BreakRequest;
struct BreakResponse;
struct ContinueRequest;
struct ContinueResponse;
struct StepRequest;
struct StepResponse;
struct BreakpointEvent;
struct AccessViolationEvent;
enum ContinueAction {
ContinueAction_Continue = 0,
ContinueAction_ContinueTo = 1
};
inline const char **EnumNamesContinueAction() {
static const char *names[] = { "Continue", "ContinueTo", nullptr };
return names;
}
inline const char *EnumNameContinueAction(ContinueAction e) { return EnumNamesContinueAction()[e]; }
enum StepAction {
StepAction_StepIn = 0,
StepAction_StepOver = 1,
StepAction_StepOut = 2
};
inline const char **EnumNamesStepAction() {
static const char *names[] = { "StepIn", "StepOver", "StepOut", nullptr };
return names;
}
inline const char *EnumNameStepAction(StepAction e) { return EnumNamesStepAction()[e]; }
struct StopRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct StopRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
StopRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
StopRequestBuilder &operator=(const StopRequestBuilder &);
flatbuffers::Offset<StopRequest> Finish() {
auto o = flatbuffers::Offset<StopRequest>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<StopRequest> CreateStopRequest(flatbuffers::FlatBufferBuilder &_fbb) {
StopRequestBuilder builder_(_fbb);
return builder_.Finish();
}
struct StopResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct StopResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
StopResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
StopResponseBuilder &operator=(const StopResponseBuilder &);
flatbuffers::Offset<StopResponse> Finish() {
auto o = flatbuffers::Offset<StopResponse>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<StopResponse> CreateStopResponse(flatbuffers::FlatBufferBuilder &_fbb) {
StopResponseBuilder builder_(_fbb);
return builder_.Finish();
}
struct BreakRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct BreakRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
BreakRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
BreakRequestBuilder &operator=(const BreakRequestBuilder &);
flatbuffers::Offset<BreakRequest> Finish() {
auto o = flatbuffers::Offset<BreakRequest>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<BreakRequest> CreateBreakRequest(flatbuffers::FlatBufferBuilder &_fbb) {
BreakRequestBuilder builder_(_fbb);
return builder_.Finish();
}
struct BreakResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct BreakResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
BreakResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
BreakResponseBuilder &operator=(const BreakResponseBuilder &);
flatbuffers::Offset<BreakResponse> Finish() {
auto o = flatbuffers::Offset<BreakResponse>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<BreakResponse> CreateBreakResponse(flatbuffers::FlatBufferBuilder &_fbb) {
BreakResponseBuilder builder_(_fbb);
return builder_.Finish();
}
struct ContinueRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
ContinueAction action() const { return static_cast<ContinueAction>(GetField<int8_t>(4, 0)); }
uint32_t target_address() const { return GetField<uint32_t>(6, 0); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, 4 /* action */) &&
VerifyField<uint32_t>(verifier, 6 /* target_address */) &&
verifier.EndTable();
}
};
struct ContinueRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_action(ContinueAction action) { fbb_.AddElement<int8_t>(4, static_cast<int8_t>(action), 0); }
void add_target_address(uint32_t target_address) { fbb_.AddElement<uint32_t>(6, target_address, 0); }
ContinueRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
ContinueRequestBuilder &operator=(const ContinueRequestBuilder &);
flatbuffers::Offset<ContinueRequest> Finish() {
auto o = flatbuffers::Offset<ContinueRequest>(fbb_.EndTable(start_, 2));
return o;
}
};
inline flatbuffers::Offset<ContinueRequest> CreateContinueRequest(flatbuffers::FlatBufferBuilder &_fbb,
ContinueAction action = ContinueAction_Continue,
uint32_t target_address = 0) {
ContinueRequestBuilder builder_(_fbb);
builder_.add_target_address(target_address);
builder_.add_action(action);
return builder_.Finish();
}
struct ContinueResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct ContinueResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
ContinueResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
ContinueResponseBuilder &operator=(const ContinueResponseBuilder &);
flatbuffers::Offset<ContinueResponse> Finish() {
auto o = flatbuffers::Offset<ContinueResponse>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<ContinueResponse> CreateContinueResponse(flatbuffers::FlatBufferBuilder &_fbb) {
ContinueResponseBuilder builder_(_fbb);
return builder_.Finish();
}
struct StepRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
StepAction action() const { return static_cast<StepAction>(GetField<int8_t>(4, 0)); }
uint32_t thread_id() const { return GetField<uint32_t>(6, 0); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, 4 /* action */) &&
VerifyField<uint32_t>(verifier, 6 /* thread_id */) &&
verifier.EndTable();
}
};
struct StepRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_action(StepAction action) { fbb_.AddElement<int8_t>(4, static_cast<int8_t>(action), 0); }
void add_thread_id(uint32_t thread_id) { fbb_.AddElement<uint32_t>(6, thread_id, 0); }
StepRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
StepRequestBuilder &operator=(const StepRequestBuilder &);
flatbuffers::Offset<StepRequest> Finish() {
auto o = flatbuffers::Offset<StepRequest>(fbb_.EndTable(start_, 2));
return o;
}
};
inline flatbuffers::Offset<StepRequest> CreateStepRequest(flatbuffers::FlatBufferBuilder &_fbb,
StepAction action = StepAction_StepIn,
uint32_t thread_id = 0) {
StepRequestBuilder builder_(_fbb);
builder_.add_thread_id(thread_id);
builder_.add_action(action);
return builder_.Finish();
}
struct StepResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct StepResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
StepResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
StepResponseBuilder &operator=(const StepResponseBuilder &);
flatbuffers::Offset<StepResponse> Finish() {
auto o = flatbuffers::Offset<StepResponse>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<StepResponse> CreateStepResponse(flatbuffers::FlatBufferBuilder &_fbb) {
StepResponseBuilder builder_(_fbb);
return builder_.Finish();
}
struct BreakpointEvent FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
uint32_t thread_id() const { return GetField<uint32_t>(4, 0); }
uint32_t breakpoint_id() const { return GetField<uint32_t>(6, 0); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, 4 /* thread_id */) &&
VerifyField<uint32_t>(verifier, 6 /* breakpoint_id */) &&
verifier.EndTable();
}
};
struct BreakpointEventBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_thread_id(uint32_t thread_id) { fbb_.AddElement<uint32_t>(4, thread_id, 0); }
void add_breakpoint_id(uint32_t breakpoint_id) { fbb_.AddElement<uint32_t>(6, breakpoint_id, 0); }
BreakpointEventBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
BreakpointEventBuilder &operator=(const BreakpointEventBuilder &);
flatbuffers::Offset<BreakpointEvent> Finish() {
auto o = flatbuffers::Offset<BreakpointEvent>(fbb_.EndTable(start_, 2));
return o;
}
};
inline flatbuffers::Offset<BreakpointEvent> CreateBreakpointEvent(flatbuffers::FlatBufferBuilder &_fbb,
uint32_t thread_id = 0,
uint32_t breakpoint_id = 0) {
BreakpointEventBuilder builder_(_fbb);
builder_.add_breakpoint_id(breakpoint_id);
builder_.add_thread_id(thread_id);
return builder_.Finish();
}
struct AccessViolationEvent FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
uint32_t thread_id() const { return GetField<uint32_t>(4, 0); }
uint32_t target_address() const { return GetField<uint32_t>(6, 0); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, 4 /* thread_id */) &&
VerifyField<uint32_t>(verifier, 6 /* target_address */) &&
verifier.EndTable();
}
};
struct AccessViolationEventBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_thread_id(uint32_t thread_id) { fbb_.AddElement<uint32_t>(4, thread_id, 0); }
void add_target_address(uint32_t target_address) { fbb_.AddElement<uint32_t>(6, target_address, 0); }
AccessViolationEventBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
AccessViolationEventBuilder &operator=(const AccessViolationEventBuilder &);
flatbuffers::Offset<AccessViolationEvent> Finish() {
auto o = flatbuffers::Offset<AccessViolationEvent>(fbb_.EndTable(start_, 2));
return o;
}
};
inline flatbuffers::Offset<AccessViolationEvent> CreateAccessViolationEvent(flatbuffers::FlatBufferBuilder &_fbb,
uint32_t thread_id = 0,
uint32_t target_address = 0) {
AccessViolationEventBuilder builder_(_fbb);
builder_.add_target_address(target_address);
builder_.add_thread_id(thread_id);
return builder_.Finish();
}
} // namespace proto
} // namespace debug
} // namespace xe
#endif // FLATBUFFERS_GENERATED_CONTROL_XE_DEBUG_PROTO_H_

51
src/xenia/debug/proto/messages.fbs
View File

@@ -1,27 +1,11 @@
include "breakpoints.fbs";
include "common.fbs";
include "control.fbs";
include "modules.fbs";
include "threads.fbs";
namespace xe.debug.proto;
enum Foo:byte (bit_flags) {
A,
B,
}
struct StructTest {
a:short;
b:byte;
c:Foo;
}
table TableTest {
st:StructTest;
iv:[ubyte];
name:string (required);
id:uint (key);
}
table AttachRequest {
//
}
@@ -35,9 +19,17 @@ union RequestData {
AttachRequest,
ListBreakpointsRequest,
AddBreakpointRequest,
UpdateBreakpointRequest,
RemoveBreakpointRequest,
AddBreakpointsRequest,
UpdateBreakpointsRequest,
RemoveBreakpointsRequest,
ListModulesRequest,
GetModuleRequest,
StopRequest,
BreakRequest,
ContinueRequest,
StepRequest,
}
table Request {
@@ -49,9 +41,20 @@ union ResponseData {
AttachResponse,
ListBreakpointsResponse,
AddBreakpointResponse,
UpdateBreakpointResponse,
RemoveBreakpointResponse,
AddBreakpointsResponse,
UpdateBreakpointsResponse,
RemoveBreakpointsResponse,
ListModulesResponse,
GetModuleResponse,
StopResponse,
BreakResponse,
ContinueResponse,
StepResponse,
BreakpointEvent,
AccessViolationEvent,
}
table Response {

190
src/xenia/debug/proto/messages_generated.h
View File

@@ -8,14 +8,58 @@
namespace xe {
namespace debug {
namespace proto {
struct XObject;
} // namespace proto
} // namespace debug
} // namespace xe
namespace xe {
namespace debug {
namespace proto {
struct Breakpoint;
struct ListBreakpointsRequest;
struct ListBreakpointsResponse;
struct AddBreakpointRequest;
struct AddBreakpointResponse;
struct UpdateBreakpointRequest;
struct UpdateBreakpointResponse;
struct RemoveBreakpointRequest;
struct RemoveBreakpointResponse;
struct AddBreakpointsRequest;
struct AddBreakpointsResponse;
struct UpdateBreakpointsRequest;
struct UpdateBreakpointsResponse;
struct RemoveBreakpointsRequest;
struct RemoveBreakpointsResponse;
} // namespace proto
} // namespace debug
} // namespace xe
namespace xe {
namespace debug {
namespace proto {
struct StopRequest;
struct StopResponse;
struct BreakRequest;
struct BreakResponse;
struct ContinueRequest;
struct ContinueResponse;
struct StepRequest;
struct StepResponse;
struct BreakpointEvent;
struct AccessViolationEvent;
} // namespace proto
} // namespace debug
} // namespace xe
namespace xe {
namespace debug {
namespace proto {
struct Module;
struct ListModulesRequest;
struct ListModulesResponse;
struct GetModuleRequest;
struct GetModuleResponse;
} // namespace proto
} // namespace debug
} // namespace xe
namespace xe {
namespace debug {
namespace proto {
struct Thread;
struct ListThreadsRequest;
struct ListThreadsResponse;
} // namespace proto
} // namespace debug
} // namespace xe
@@ -24,36 +68,28 @@ namespace xe {
namespace debug {
namespace proto {
struct StructTest;
struct TableTest;
struct AttachRequest;
struct AttachResponse;
struct Request;
struct Response;
enum Foo {
Foo_A = 1,
Foo_B = 2
};
inline const char **EnumNamesFoo() {
static const char *names[] = { "A", "B", nullptr };
return names;
}
inline const char *EnumNameFoo(Foo e) { return EnumNamesFoo()[e - Foo_A]; }
enum RequestData {
RequestData_NONE = 0,
RequestData_AttachRequest = 1,
RequestData_ListBreakpointsRequest = 2,
RequestData_AddBreakpointRequest = 3,
RequestData_UpdateBreakpointRequest = 4,
RequestData_RemoveBreakpointRequest = 5
RequestData_AddBreakpointsRequest = 3,
RequestData_UpdateBreakpointsRequest = 4,
RequestData_RemoveBreakpointsRequest = 5,
RequestData_ListModulesRequest = 6,
RequestData_GetModuleRequest = 7,
RequestData_StopRequest = 8,
RequestData_BreakRequest = 9,
RequestData_ContinueRequest = 10,
RequestData_StepRequest = 11
};
inline const char **EnumNamesRequestData() {
static const char *names[] = { "NONE", "AttachRequest", "ListBreakpointsRequest", "AddBreakpointRequest", "UpdateBreakpointRequest", "RemoveBreakpointRequest", nullptr };
static const char *names[] = { "NONE", "AttachRequest", "ListBreakpointsRequest", "AddBreakpointsRequest", "UpdateBreakpointsRequest", "RemoveBreakpointsRequest", "ListModulesRequest", "GetModuleRequest", "StopRequest", "BreakRequest", "ContinueRequest", "StepRequest", nullptr };
return names;
}
@@ -65,13 +101,21 @@ enum ResponseData {
ResponseData_NONE = 0,
ResponseData_AttachResponse = 1,
ResponseData_ListBreakpointsResponse = 2,
ResponseData_AddBreakpointResponse = 3,
ResponseData_UpdateBreakpointResponse = 4,
ResponseData_RemoveBreakpointResponse = 5
ResponseData_AddBreakpointsResponse = 3,
ResponseData_UpdateBreakpointsResponse = 4,
ResponseData_RemoveBreakpointsResponse = 5,
ResponseData_ListModulesResponse = 6,
ResponseData_GetModuleResponse = 7,
ResponseData_StopResponse = 8,
ResponseData_BreakResponse = 9,
ResponseData_ContinueResponse = 10,
ResponseData_StepResponse = 11,
ResponseData_BreakpointEvent = 12,
ResponseData_AccessViolationEvent = 13
};
inline const char **EnumNamesResponseData() {
static const char *names[] = { "NONE", "AttachResponse", "ListBreakpointsResponse", "AddBreakpointResponse", "UpdateBreakpointResponse", "RemoveBreakpointResponse", nullptr };
static const char *names[] = { "NONE", "AttachResponse", "ListBreakpointsResponse", "AddBreakpointsResponse", "UpdateBreakpointsResponse", "RemoveBreakpointsResponse", "ListModulesResponse", "GetModuleResponse", "StopResponse", "BreakResponse", "ContinueResponse", "StepResponse", "BreakpointEvent", "AccessViolationEvent", nullptr };
return names;
}
@@ -79,70 +123,6 @@ inline const char *EnumNameResponseData(ResponseData e) { return EnumNamesRespon
inline bool VerifyResponseData(flatbuffers::Verifier &verifier, const void *union_obj, ResponseData type);
MANUALLY_ALIGNED_STRUCT(2) StructTest FLATBUFFERS_FINAL_CLASS {
private:
int16_t a_;
int8_t b_;
int8_t c_;
public:
StructTest(int16_t a, int8_t b, Foo c)
: a_(flatbuffers::EndianScalar(a)), b_(flatbuffers::EndianScalar(b)), c_(flatbuffers::EndianScalar(static_cast<int8_t>(c))) { }
int16_t a() const { return flatbuffers::EndianScalar(a_); }
int8_t b() const { return flatbuffers::EndianScalar(b_); }
Foo c() const { return static_cast<Foo>(flatbuffers::EndianScalar(c_)); }
};
STRUCT_END(StructTest, 4);
struct TableTest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const StructTest *st() const { return GetStruct<const StructTest *>(4); }
const flatbuffers::Vector<uint8_t> *iv() const { return GetPointer<const flatbuffers::Vector<uint8_t> *>(6); }
const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(8); }
uint32_t id() const { return GetField<uint32_t>(10, 0); }
bool KeyCompareLessThan(const TableTest *o) const { return id() < o->id(); }
int KeyCompareWithValue(uint32_t val) const { return id() < val ? -1 : id() > val; }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<StructTest>(verifier, 4 /* st */) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* iv */) &&
verifier.Verify(iv()) &&
VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, 8 /* name */) &&
verifier.Verify(name()) &&
VerifyField<uint32_t>(verifier, 10 /* id */) &&
verifier.EndTable();
}
};
struct TableTestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_st(const StructTest *st) { fbb_.AddStruct(4, st); }
void add_iv(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> iv) { fbb_.AddOffset(6, iv); }
void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(8, name); }
void add_id(uint32_t id) { fbb_.AddElement<uint32_t>(10, id, 0); }
TableTestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
TableTestBuilder &operator=(const TableTestBuilder &);
flatbuffers::Offset<TableTest> Finish() {
auto o = flatbuffers::Offset<TableTest>(fbb_.EndTable(start_, 4));
fbb_.Required(o, 8); // name
return o;
}
};
inline flatbuffers::Offset<TableTest> CreateTableTest(flatbuffers::FlatBufferBuilder &_fbb,
const StructTest *st = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> iv = 0,
flatbuffers::Offset<flatbuffers::String> name = 0,
uint32_t id = 0) {
TableTestBuilder builder_(_fbb);
builder_.add_id(id);
builder_.add_name(name);
builder_.add_iv(iv);
builder_.add_st(st);
return builder_.Finish();
}
struct AttachRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
@@ -290,9 +270,15 @@ inline bool VerifyRequestData(flatbuffers::Verifier &verifier, const void *union
case RequestData_NONE: return true;
case RequestData_AttachRequest: return verifier.VerifyTable(reinterpret_cast<const AttachRequest *>(union_obj));
case RequestData_ListBreakpointsRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::ListBreakpointsRequest *>(union_obj));
case RequestData_AddBreakpointRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::AddBreakpointRequest *>(union_obj));
case RequestData_UpdateBreakpointRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::UpdateBreakpointRequest *>(union_obj));
case RequestData_RemoveBreakpointRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::RemoveBreakpointRequest *>(union_obj));
case RequestData_AddBreakpointsRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::AddBreakpointsRequest *>(union_obj));
case RequestData_UpdateBreakpointsRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::UpdateBreakpointsRequest *>(union_obj));
case RequestData_RemoveBreakpointsRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::RemoveBreakpointsRequest *>(union_obj));
case RequestData_ListModulesRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::ListModulesRequest *>(union_obj));
case RequestData_GetModuleRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::GetModuleRequest *>(union_obj));
case RequestData_StopRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::StopRequest *>(union_obj));
case RequestData_BreakRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::BreakRequest *>(union_obj));
case RequestData_ContinueRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::ContinueRequest *>(union_obj));
case RequestData_StepRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::StepRequest *>(union_obj));
default: return false;
}
}
@@ -302,9 +288,17 @@ inline bool VerifyResponseData(flatbuffers::Verifier &verifier, const void *unio
case ResponseData_NONE: return true;
case ResponseData_AttachResponse: return verifier.VerifyTable(reinterpret_cast<const AttachResponse *>(union_obj));
case ResponseData_ListBreakpointsResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::ListBreakpointsResponse *>(union_obj));
case ResponseData_AddBreakpointResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::AddBreakpointResponse *>(union_obj));
case ResponseData_UpdateBreakpointResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::UpdateBreakpointResponse *>(union_obj));
case ResponseData_RemoveBreakpointResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::RemoveBreakpointResponse *>(union_obj));
case ResponseData_AddBreakpointsResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::AddBreakpointsResponse *>(union_obj));
case ResponseData_UpdateBreakpointsResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::UpdateBreakpointsResponse *>(union_obj));
case ResponseData_RemoveBreakpointsResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::RemoveBreakpointsResponse *>(union_obj));
case ResponseData_ListModulesResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::ListModulesResponse *>(union_obj));
case ResponseData_GetModuleResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::GetModuleResponse *>(union_obj));
case ResponseData_StopResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::StopResponse *>(union_obj));
case ResponseData_BreakResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::BreakResponse *>(union_obj));
case ResponseData_ContinueResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::ContinueResponse *>(union_obj));
case ResponseData_StepResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::StepResponse *>(union_obj));
case ResponseData_BreakpointEvent: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::BreakpointEvent *>(union_obj));
case ResponseData_AccessViolationEvent: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::AccessViolationEvent *>(union_obj));
default: return false;
}
}

31
src/xenia/debug/proto/modules.fbs Normal file
View File

@@ -0,0 +1,31 @@
include "common.fbs";
namespace xe.debug.proto;
enum ModuleType:byte {
Kernel,
User,
}
table Module {
object:XObject;
type:ModuleType;
name:string;
path:string;
// TODO(benvanik): xex info/etc?
}
table ListModulesRequest {
}
table ListModulesResponse {
module_ids:[uint];
}
table GetModuleRequest {
module_id:uint;
}
table GetModuleResponse {
module:Module;
}

196
src/xenia/debug/proto/modules_generated.h Normal file
View File

@@ -0,0 +1,196 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_MODULES_XE_DEBUG_PROTO_H_
#define FLATBUFFERS_GENERATED_MODULES_XE_DEBUG_PROTO_H_
#include "flatbuffers/flatbuffers.h"
namespace xe {
namespace debug {
namespace proto {
struct XObject;
} // namespace proto
} // namespace debug
} // namespace xe
namespace xe {
namespace debug {
namespace proto {
struct Module;
struct ListModulesRequest;
struct ListModulesResponse;
struct GetModuleRequest;
struct GetModuleResponse;
enum ModuleType {
ModuleType_Kernel = 0,
ModuleType_User = 1
};
inline const char **EnumNamesModuleType() {
static const char *names[] = { "Kernel", "User", nullptr };
return names;
}
inline const char *EnumNameModuleType(ModuleType e) { return EnumNamesModuleType()[e]; }
struct Module FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const xe::debug::proto::XObject *object() const { return GetStruct<const xe::debug::proto::XObject *>(4); }
ModuleType type() const { return static_cast<ModuleType>(GetField<int8_t>(6, 0)); }
const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(8); }
const flatbuffers::String *path() const { return GetPointer<const flatbuffers::String *>(10); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<xe::debug::proto::XObject>(verifier, 4 /* object */) &&
VerifyField<int8_t>(verifier, 6 /* type */) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* name */) &&
verifier.Verify(name()) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* path */) &&
verifier.Verify(path()) &&
verifier.EndTable();
}
};
struct ModuleBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_object(const xe::debug::proto::XObject *object) { fbb_.AddStruct(4, object); }
void add_type(ModuleType type) { fbb_.AddElement<int8_t>(6, static_cast<int8_t>(type), 0); }
void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(8, name); }
void add_path(flatbuffers::Offset<flatbuffers::String> path) { fbb_.AddOffset(10, path); }
ModuleBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
ModuleBuilder &operator=(const ModuleBuilder &);
flatbuffers::Offset<Module> Finish() {
auto o = flatbuffers::Offset<Module>(fbb_.EndTable(start_, 4));
return o;
}
};
inline flatbuffers::Offset<Module> CreateModule(flatbuffers::FlatBufferBuilder &_fbb,
const xe::debug::proto::XObject *object = 0,
ModuleType type = ModuleType_Kernel,
flatbuffers::Offset<flatbuffers::String> name = 0,
flatbuffers::Offset<flatbuffers::String> path = 0) {
ModuleBuilder builder_(_fbb);
builder_.add_path(path);
builder_.add_name(name);
builder_.add_object(object);
builder_.add_type(type);
return builder_.Finish();
}
struct ListModulesRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct ListModulesRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
ListModulesRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
ListModulesRequestBuilder &operator=(const ListModulesRequestBuilder &);
flatbuffers::Offset<ListModulesRequest> Finish() {
auto o = flatbuffers::Offset<ListModulesRequest>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<ListModulesRequest> CreateListModulesRequest(flatbuffers::FlatBufferBuilder &_fbb) {
ListModulesRequestBuilder builder_(_fbb);
return builder_.Finish();
}
struct ListModulesResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<uint32_t> *module_ids() const { return GetPointer<const flatbuffers::Vector<uint32_t> *>(4); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* module_ids */) &&
verifier.Verify(module_ids()) &&
verifier.EndTable();
}
};
struct ListModulesResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_module_ids(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> module_ids) { fbb_.AddOffset(4, module_ids); }
ListModulesResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
ListModulesResponseBuilder &operator=(const ListModulesResponseBuilder &);
flatbuffers::Offset<ListModulesResponse> Finish() {
auto o = flatbuffers::Offset<ListModulesResponse>(fbb_.EndTable(start_, 1));
return o;
}
};
inline flatbuffers::Offset<ListModulesResponse> CreateListModulesResponse(flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint32_t>> module_ids = 0) {
ListModulesResponseBuilder builder_(_fbb);
builder_.add_module_ids(module_ids);
return builder_.Finish();
}
struct GetModuleRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
uint32_t module_id() const { return GetField<uint32_t>(4, 0); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, 4 /* module_id */) &&
verifier.EndTable();
}
};
struct GetModuleRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_module_id(uint32_t module_id) { fbb_.AddElement<uint32_t>(4, module_id, 0); }
GetModuleRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
GetModuleRequestBuilder &operator=(const GetModuleRequestBuilder &);
flatbuffers::Offset<GetModuleRequest> Finish() {
auto o = flatbuffers::Offset<GetModuleRequest>(fbb_.EndTable(start_, 1));
return o;
}
};
inline flatbuffers::Offset<GetModuleRequest> CreateGetModuleRequest(flatbuffers::FlatBufferBuilder &_fbb,
uint32_t module_id = 0) {
GetModuleRequestBuilder builder_(_fbb);
builder_.add_module_id(module_id);
return builder_.Finish();
}
struct GetModuleResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const Module *module() const { return GetPointer<const Module *>(4); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* module */) &&
verifier.VerifyTable(module()) &&
verifier.EndTable();
}
};
struct GetModuleResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_module(flatbuffers::Offset<Module> module) { fbb_.AddOffset(4, module); }
GetModuleResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
GetModuleResponseBuilder &operator=(const GetModuleResponseBuilder &);
flatbuffers::Offset<GetModuleResponse> Finish() {
auto o = flatbuffers::Offset<GetModuleResponse>(fbb_.EndTable(start_, 1));
return o;
}
};
inline flatbuffers::Offset<GetModuleResponse> CreateGetModuleResponse(flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<Module> module = 0) {
GetModuleResponseBuilder builder_(_fbb);
builder_.add_module(module);
return builder_.Finish();
}
} // namespace proto
} // namespace debug
} // namespace xe
#endif // FLATBUFFERS_GENERATED_MODULES_XE_DEBUG_PROTO_H_

21
src/xenia/debug/proto/threads.fbs Normal file
View File

@@ -0,0 +1,21 @@
include "common.fbs";
namespace xe.debug.proto;
enum ThreadType:byte {
Kernel,
User,
}
table Thread {
object:XObject;
type:ThreadType;
// module_id:uint;
// creation callstack
}
table ListThreadsRequest {
}
table ListThreadsResponse {
}

119
src/xenia/debug/proto/threads_generated.h Normal file
View File

@@ -0,0 +1,119 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_THREADS_XE_DEBUG_PROTO_H_
#define FLATBUFFERS_GENERATED_THREADS_XE_DEBUG_PROTO_H_
#include "flatbuffers/flatbuffers.h"
namespace xe {
namespace debug {
namespace proto {
struct XObject;
} // namespace proto
} // namespace debug
} // namespace xe
namespace xe {
namespace debug {
namespace proto {
struct Thread;
struct ListThreadsRequest;
struct ListThreadsResponse;
enum ThreadType {
ThreadType_Kernel = 0,
ThreadType_User = 1
};
inline const char **EnumNamesThreadType() {
static const char *names[] = { "Kernel", "User", nullptr };
return names;
}
inline const char *EnumNameThreadType(ThreadType e) { return EnumNamesThreadType()[e]; }
struct Thread FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const xe::debug::proto::XObject *object() const { return GetStruct<const xe::debug::proto::XObject *>(4); }
ThreadType type() const { return static_cast<ThreadType>(GetField<int8_t>(6, 0)); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<xe::debug::proto::XObject>(verifier, 4 /* object */) &&
VerifyField<int8_t>(verifier, 6 /* type */) &&
verifier.EndTable();
}
};
struct ThreadBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_object(const xe::debug::proto::XObject *object) { fbb_.AddStruct(4, object); }
void add_type(ThreadType type) { fbb_.AddElement<int8_t>(6, static_cast<int8_t>(type), 0); }
ThreadBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
ThreadBuilder &operator=(const ThreadBuilder &);
flatbuffers::Offset<Thread> Finish() {
auto o = flatbuffers::Offset<Thread>(fbb_.EndTable(start_, 2));
return o;
}
};
inline flatbuffers::Offset<Thread> CreateThread(flatbuffers::FlatBufferBuilder &_fbb,
const xe::debug::proto::XObject *object = 0,
ThreadType type = ThreadType_Kernel) {
ThreadBuilder builder_(_fbb);
builder_.add_object(object);
builder_.add_type(type);
return builder_.Finish();
}
struct ListThreadsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct ListThreadsRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
ListThreadsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
ListThreadsRequestBuilder &operator=(const ListThreadsRequestBuilder &);
flatbuffers::Offset<ListThreadsRequest> Finish() {
auto o = flatbuffers::Offset<ListThreadsRequest>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<ListThreadsRequest> CreateListThreadsRequest(flatbuffers::FlatBufferBuilder &_fbb) {
ListThreadsRequestBuilder builder_(_fbb);
return builder_.Finish();
}
struct ListThreadsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
}
};
struct ListThreadsResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
ListThreadsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
ListThreadsResponseBuilder &operator=(const ListThreadsResponseBuilder &);
flatbuffers::Offset<ListThreadsResponse> Finish() {
auto o = flatbuffers::Offset<ListThreadsResponse>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<ListThreadsResponse> CreateListThreadsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
ListThreadsResponseBuilder builder_(_fbb);
return builder_.Finish();
}
} // namespace proto
} // namespace debug
} // namespace xe
#endif // FLATBUFFERS_GENERATED_THREADS_XE_DEBUG_PROTO_H_