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

xb format --all (we are now format clean). Buildbot will yell at you.

Browse Source
This commit is contained in:
Ben Vanik
2015-06-22 22:26:51 -07:00
parent f902f8b78a
commit fb1f4906d9
87 changed files with 3542 additions and 2938 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -328,26 +328,27 @@ void Debugger::OnMessage(std::vector<uint8_t> buffer) {
request_data->function_index_start() + 1;
std::vector<flatbuffers::Offset<proto::FunctionEntry>> function_list;
function_list.reserve(max_function_count);
processor_module->ForEachSymbol(request_data->function_index_start(),
request_data->function_index_end(),
[&](xe::cpu::SymbolInfo* symbol_info) {
if (symbol_info->type() != xe::cpu::SymbolType::kFunction) {
return;
}
auto function_info =
reinterpret_cast<xe::cpu::FunctionInfo*>(symbol_info);
flatbuffers::Offset<flatbuffers::String> name_offset;
if (!function_info->name().empty()) {
name_offset = fbb.CreateString(function_info->name());
}
auto function_entry = proto::FunctionEntryBuilder(fbb);
function_entry.add_identifier(
reinterpret_cast<uintptr_t>(function_info));
function_entry.add_address_start(function_info->address());
function_entry.add_address_end(function_info->end_address());
function_entry.add_name(name_offset);
function_list.push_back(function_entry.Finish());
});
processor_module->ForEachSymbol(
request_data->function_index_start(),
request_data->function_index_end(),
[&](xe::cpu::SymbolInfo* symbol_info) {
if (symbol_info->type() != xe::cpu::SymbolType::kFunction) {
return;
}
auto function_info =
reinterpret_cast<xe::cpu::FunctionInfo*>(symbol_info);
flatbuffers::Offset<flatbuffers::String> name_offset;
if (!function_info->name().empty()) {
name_offset = fbb.CreateString(function_info->name());
}
auto function_entry = proto::FunctionEntryBuilder(fbb);
function_entry.add_identifier(
reinterpret_cast<uintptr_t>(function_info));
function_entry.add_address_start(function_info->address());
function_entry.add_address_end(function_info->end_address());
function_entry.add_name(name_offset);
function_list.push_back(function_entry.Finish());
});
auto function_list_data = fbb.CreateVector(function_list);
response_data_type = proto::ResponseData_ListFunctionsResponse;
auto response_data = proto::ListFunctionsResponseBuilder(fbb);

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

@@ -33,216 +33,292 @@ MANUALLY_ALIGNED_STRUCT(4) Breakpoint FLATBUFFERS_FINAL_CLASS {
public:
Breakpoint(uint32_t breakpoint_id)
: breakpoint_id_(flatbuffers::EndianScalar(breakpoint_id)) { }
: breakpoint_id_(flatbuffers::EndianScalar(breakpoint_id)) {}
uint32_t breakpoint_id() const { return 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 {
struct ListBreakpointsRequest FLATBUFFERS_FINAL_CLASS
: private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
return VerifyTableStart(verifier) && verifier.EndTable();
}
};
struct ListBreakpointsRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
ListBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
ListBreakpointsRequestBuilder &operator=(const ListBreakpointsRequestBuilder &);
ListBreakpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ListBreakpointsRequestBuilder &operator=(
const ListBreakpointsRequestBuilder &);
flatbuffers::Offset<ListBreakpointsRequest> Finish() {
auto o = flatbuffers::Offset<ListBreakpointsRequest>(fbb_.EndTable(start_, 0));
auto o =
flatbuffers::Offset<ListBreakpointsRequest>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<ListBreakpointsRequest> CreateListBreakpointsRequest(flatbuffers::FlatBufferBuilder &_fbb) {
inline flatbuffers::Offset<ListBreakpointsRequest> CreateListBreakpointsRequest(
flatbuffers::FlatBufferBuilder &_fbb) {
ListBreakpointsRequestBuilder builder_(_fbb);
return builder_.Finish();
}
struct ListBreakpointsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<const Breakpoint *> *breakpoints() const { return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4); }
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();
verifier.Verify(breakpoints()) && verifier.EndTable();
}
};
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 &);
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_, 1));
auto o =
flatbuffers::Offset<ListBreakpointsResponse>(fbb_.EndTable(start_, 1));
return o;
}
};
inline flatbuffers::Offset<ListBreakpointsResponse> CreateListBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<const Breakpoint *>> breakpoints = 0) {
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 AddBreakpointsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<const Breakpoint *> *breakpoints() const { return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4); }
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();
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(); }
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));
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) {
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 {
struct AddBreakpointsResponse FLATBUFFERS_FINAL_CLASS
: private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
return VerifyTableStart(verifier) && verifier.EndTable();
}
};
struct AddBreakpointsResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
AddBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
AddBreakpointsResponseBuilder &operator=(const AddBreakpointsResponseBuilder &);
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));
auto o =
flatbuffers::Offset<AddBreakpointsResponse>(fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<AddBreakpointsResponse> CreateAddBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
inline flatbuffers::Offset<AddBreakpointsResponse> CreateAddBreakpointsResponse(
flatbuffers::FlatBufferBuilder &_fbb) {
AddBreakpointsResponseBuilder builder_(_fbb);
return builder_.Finish();
}
struct UpdateBreakpointsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<const Breakpoint *> *breakpoints() const { return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4); }
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();
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 &);
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));
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) {
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 {
struct UpdateBreakpointsResponse FLATBUFFERS_FINAL_CLASS
: private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
return VerifyTableStart(verifier) && verifier.EndTable();
}
};
struct UpdateBreakpointsResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
UpdateBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
UpdateBreakpointsResponseBuilder &operator=(const UpdateBreakpointsResponseBuilder &);
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));
auto o = flatbuffers::Offset<UpdateBreakpointsResponse>(
fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<UpdateBreakpointsResponse> CreateUpdateBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
inline flatbuffers::Offset<UpdateBreakpointsResponse>
CreateUpdateBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
UpdateBreakpointsResponseBuilder builder_(_fbb);
return builder_.Finish();
}
struct RemoveBreakpointsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<const Breakpoint *> *breakpoints() const { return GetPointer<const flatbuffers::Vector<const Breakpoint *> *>(4); }
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();
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 &);
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));
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) {
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 {
struct RemoveBreakpointsResponse FLATBUFFERS_FINAL_CLASS
: private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
return VerifyTableStart(verifier) && verifier.EndTable();
}
};
struct RemoveBreakpointsResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
RemoveBreakpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
RemoveBreakpointsResponseBuilder &operator=(const RemoveBreakpointsResponseBuilder &);
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));
auto o = flatbuffers::Offset<RemoveBreakpointsResponse>(
fbb_.EndTable(start_, 0));
return o;
}
};
inline flatbuffers::Offset<RemoveBreakpointsResponse> CreateRemoveBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
inline flatbuffers::Offset<RemoveBreakpointsResponse>
CreateRemoveBreakpointsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
RemoveBreakpointsResponseBuilder builder_(_fbb);
return builder_.Finish();
}

4
src/xenia/debug/proto/common_generated.h
View File

@@ -5,7 +5,6 @@
#include "flatbuffers/flatbuffers.h"
namespace xe {
namespace debug {
namespace proto {
@@ -17,8 +16,7 @@ MANUALLY_ALIGNED_STRUCT(4) XObject FLATBUFFERS_FINAL_CLASS {
uint32_t handle_;
public:
XObject(uint32_t handle)
: handle_(flatbuffers::EndianScalar(handle)) { }
XObject(uint32_t handle) : handle_(flatbuffers::EndianScalar(handle)) {}
uint32_t handle() const { return flatbuffers::EndianScalar(handle_); }
};

160
src/xenia/debug/proto/control_generated.h
View File

@@ -34,11 +34,13 @@ enum ContinueAction {
};
inline const char **EnumNamesContinueAction() {
static const char *names[] = { "Continue", "ContinueTo", nullptr };
static const char *names[] = {"Continue", "ContinueTo", nullptr};
return names;
}
inline const char *EnumNameContinueAction(ContinueAction e) { return EnumNamesContinueAction()[e]; }
inline const char *EnumNameContinueAction(ContinueAction e) {
return EnumNamesContinueAction()[e];
}
enum StepAction {
StepAction_StepIn = 0,
@@ -47,23 +49,26 @@ enum StepAction {
};
inline const char **EnumNamesStepAction() {
static const char *names[] = { "StepIn", "StepOver", "StepOut", nullptr };
static const char *names[] = {"StepIn", "StepOver", "StepOut", nullptr};
return names;
}
inline const char *EnumNameStepAction(StepAction e) { return EnumNamesStepAction()[e]; }
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();
return VerifyTableStart(verifier) && verifier.EndTable();
}
};
struct StopRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
StopRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
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));
@@ -71,22 +76,24 @@ struct StopRequestBuilder {
}
};
inline flatbuffers::Offset<StopRequest> CreateStopRequest(flatbuffers::FlatBufferBuilder &_fbb) {
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();
return VerifyTableStart(verifier) && verifier.EndTable();
}
};
struct StopResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
StopResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
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));
@@ -94,22 +101,24 @@ struct StopResponseBuilder {
}
};
inline flatbuffers::Offset<StopResponse> CreateStopResponse(flatbuffers::FlatBufferBuilder &_fbb) {
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();
return VerifyTableStart(verifier) && verifier.EndTable();
}
};
struct BreakRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
BreakRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
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));
@@ -117,22 +126,24 @@ struct BreakRequestBuilder {
}
};
inline flatbuffers::Offset<BreakRequest> CreateBreakRequest(flatbuffers::FlatBufferBuilder &_fbb) {
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();
return VerifyTableStart(verifier) && verifier.EndTable();
}
};
struct BreakResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
BreakResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
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));
@@ -140,13 +151,16 @@ struct BreakResponseBuilder {
}
};
inline flatbuffers::Offset<BreakResponse> CreateBreakResponse(flatbuffers::FlatBufferBuilder &_fbb) {
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)); }
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) &&
@@ -159,9 +173,15 @@ struct ContinueRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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(); }
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));
@@ -169,9 +189,10 @@ struct ContinueRequestBuilder {
}
};
inline flatbuffers::Offset<ContinueRequest> CreateContinueRequest(flatbuffers::FlatBufferBuilder &_fbb,
ContinueAction action = ContinueAction_Continue,
uint32_t target_address = 0) {
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);
@@ -180,15 +201,16 @@ inline flatbuffers::Offset<ContinueRequest> CreateContinueRequest(flatbuffers::F
struct ContinueResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
return VerifyTableStart(verifier) && verifier.EndTable();
}
};
struct ContinueResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
ContinueResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
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));
@@ -196,13 +218,16 @@ struct ContinueResponseBuilder {
}
};
inline flatbuffers::Offset<ContinueResponse> CreateContinueResponse(flatbuffers::FlatBufferBuilder &_fbb) {
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)); }
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) &&
@@ -215,9 +240,15 @@ struct StepRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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(); }
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));
@@ -225,9 +256,9 @@ struct StepRequestBuilder {
}
};
inline flatbuffers::Offset<StepRequest> CreateStepRequest(flatbuffers::FlatBufferBuilder &_fbb,
StepAction action = StepAction_StepIn,
uint32_t thread_id = 0) {
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);
@@ -236,15 +267,16 @@ inline flatbuffers::Offset<StepRequest> CreateStepRequest(flatbuffers::FlatBuffe
struct StepResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
return VerifyTableStart(verifier) && verifier.EndTable();
}
};
struct StepResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
StepResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
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));
@@ -252,7 +284,8 @@ struct StepResponseBuilder {
}
};
inline flatbuffers::Offset<StepResponse> CreateStepResponse(flatbuffers::FlatBufferBuilder &_fbb) {
inline flatbuffers::Offset<StepResponse> CreateStepResponse(
flatbuffers::FlatBufferBuilder &_fbb) {
StepResponseBuilder builder_(_fbb);
return builder_.Finish();
}
@@ -271,9 +304,15 @@ struct BreakpointEvent FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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(); }
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));
@@ -281,16 +320,17 @@ struct BreakpointEventBuilder {
}
};
inline flatbuffers::Offset<BreakpointEvent> CreateBreakpointEvent(flatbuffers::FlatBufferBuilder &_fbb,
uint32_t thread_id = 0,
uint32_t breakpoint_id = 0) {
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 {
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 {
@@ -304,19 +344,27 @@ struct AccessViolationEvent FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
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(); }
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));
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) {
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);

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

@@ -100,20 +100,20 @@ enum RequestData {
inline const char **EnumNamesRequestData() {
static const char *names[] = {
"NONE", "AttachRequest",
"ListBreakpointsRequest", "AddBreakpointsRequest",
"UpdateBreakpointsRequest", "RemoveBreakpointsRequest",
"ListModulesRequest", "GetModuleRequest",
"ListFunctionsRequest", "GetFunctionRequest",
"ListThreadsRequest", "StopRequest",
"BreakRequest", "ContinueRequest",
"StepRequest", nullptr};
"NONE", "AttachRequest", "ListBreakpointsRequest",
"AddBreakpointsRequest", "UpdateBreakpointsRequest",
"RemoveBreakpointsRequest", "ListModulesRequest", "GetModuleRequest",
"ListFunctionsRequest", "GetFunctionRequest", "ListThreadsRequest",
"StopRequest", "BreakRequest", "ContinueRequest", "StepRequest", nullptr};
return names;
}
inline const char *EnumNameRequestData(RequestData e) { return EnumNamesRequestData()[e]; }
inline const char *EnumNameRequestData(RequestData e) {
return EnumNamesRequestData()[e];
}
inline bool VerifyRequestData(flatbuffers::Verifier &verifier, const void *union_obj, RequestData type);
inline bool VerifyRequestData(flatbuffers::Verifier &verifier,
const void *union_obj, RequestData type);
enum ResponseData {
ResponseData_NONE = 0,
@@ -137,33 +137,34 @@ enum ResponseData {
inline const char **EnumNamesResponseData() {
static const char *names[] = {
"NONE", "AttachResponse",
"ListBreakpointsResponse", "AddBreakpointsResponse",
"UpdateBreakpointsResponse", "RemoveBreakpointsResponse",
"ListModulesResponse", "GetModuleResponse",
"ListFunctionsResponse", "GetFunctionResponse",
"ListThreadsResponse", "StopResponse",
"BreakResponse", "ContinueResponse",
"StepResponse", "BreakpointEvent",
"AccessViolationEvent", nullptr};
"NONE", "AttachResponse", "ListBreakpointsResponse",
"AddBreakpointsResponse", "UpdateBreakpointsResponse",
"RemoveBreakpointsResponse", "ListModulesResponse", "GetModuleResponse",
"ListFunctionsResponse", "GetFunctionResponse", "ListThreadsResponse",
"StopResponse", "BreakResponse", "ContinueResponse", "StepResponse",
"BreakpointEvent", "AccessViolationEvent", nullptr};
return names;
}
inline const char *EnumNameResponseData(ResponseData e) { return EnumNamesResponseData()[e]; }
inline const char *EnumNameResponseData(ResponseData e) {
return EnumNamesResponseData()[e];
}
inline bool VerifyResponseData(flatbuffers::Verifier &verifier, const void *union_obj, ResponseData type);
inline bool VerifyResponseData(flatbuffers::Verifier &verifier,
const void *union_obj, ResponseData type);
struct AttachRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
return VerifyTableStart(verifier) && verifier.EndTable();
}
};
struct AttachRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
AttachRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
AttachRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
AttachRequestBuilder &operator=(const AttachRequestBuilder &);
flatbuffers::Offset<AttachRequest> Finish() {
auto o = flatbuffers::Offset<AttachRequest>(fbb_.EndTable(start_, 0));
@@ -171,44 +172,72 @@ struct AttachRequestBuilder {
}
};
inline flatbuffers::Offset<AttachRequest> CreateAttachRequest(flatbuffers::FlatBufferBuilder &_fbb) {
inline flatbuffers::Offset<AttachRequest> CreateAttachRequest(
flatbuffers::FlatBufferBuilder &_fbb) {
AttachRequestBuilder builder_(_fbb);
return builder_.Finish();
}
struct AttachResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::String *memory_file() const { return GetPointer<const flatbuffers::String *>(4); }
const flatbuffers::String *code_cache_file() const { return GetPointer<const flatbuffers::String *>(6); }
const flatbuffers::String *memory_file() const {
return GetPointer<const flatbuffers::String *>(4);
}
const flatbuffers::String *code_cache_file() const {
return GetPointer<const flatbuffers::String *>(6);
}
uint32_t code_cache_base() const { return GetField<uint32_t>(8, 0); }
uint32_t code_cache_size() const { return GetField<uint32_t>(10, 0); }
const flatbuffers::String *functions_file() const { return GetPointer<const flatbuffers::String *>(12); }
const flatbuffers::String *functions_trace_file() const { return GetPointer<const flatbuffers::String *>(14); }
const flatbuffers::String *functions_file() const {
return GetPointer<const flatbuffers::String *>(12);
}
const flatbuffers::String *functions_trace_file() const {
return GetPointer<const flatbuffers::String *>(14);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* memory_file */) &&
verifier.Verify(memory_file()) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* code_cache_file */) &&
VerifyField<flatbuffers::uoffset_t>(verifier,
6 /* code_cache_file */) &&
verifier.Verify(code_cache_file()) &&
VerifyField<uint32_t>(verifier, 8 /* code_cache_base */) &&
VerifyField<uint32_t>(verifier, 10 /* code_cache_size */) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 12 /* functions_file */) &&
VerifyField<flatbuffers::uoffset_t>(verifier,
12 /* functions_file */) &&
verifier.Verify(functions_file()) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 14 /* functions_trace_file */) &&
verifier.Verify(functions_trace_file()) &&
verifier.EndTable();
VerifyField<flatbuffers::uoffset_t>(verifier,
14 /* functions_trace_file */) &&
verifier.Verify(functions_trace_file()) && verifier.EndTable();
}
};
struct AttachResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_memory_file(flatbuffers::Offset<flatbuffers::String> memory_file) { fbb_.AddOffset(4, memory_file); }
void add_code_cache_file(flatbuffers::Offset<flatbuffers::String> code_cache_file) { fbb_.AddOffset(6, code_cache_file); }
void add_code_cache_base(uint32_t code_cache_base) { fbb_.AddElement<uint32_t>(8, code_cache_base, 0); }
void add_code_cache_size(uint32_t code_cache_size) { fbb_.AddElement<uint32_t>(10, code_cache_size, 0); }
void add_functions_file(flatbuffers::Offset<flatbuffers::String> functions_file) { fbb_.AddOffset(12, functions_file); }
void add_functions_trace_file(flatbuffers::Offset<flatbuffers::String> functions_trace_file) { fbb_.AddOffset(14, functions_trace_file); }
AttachResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
void add_memory_file(flatbuffers::Offset<flatbuffers::String> memory_file) {
fbb_.AddOffset(4, memory_file);
}
void add_code_cache_file(
flatbuffers::Offset<flatbuffers::String> code_cache_file) {
fbb_.AddOffset(6, code_cache_file);
}
void add_code_cache_base(uint32_t code_cache_base) {
fbb_.AddElement<uint32_t>(8, code_cache_base, 0);
}
void add_code_cache_size(uint32_t code_cache_size) {
fbb_.AddElement<uint32_t>(10, code_cache_size, 0);
}
void add_functions_file(
flatbuffers::Offset<flatbuffers::String> functions_file) {
fbb_.AddOffset(12, functions_file);
}
void add_functions_trace_file(
flatbuffers::Offset<flatbuffers::String> functions_trace_file) {
fbb_.AddOffset(14, functions_trace_file);
}
AttachResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
AttachResponseBuilder &operator=(const AttachResponseBuilder &);
flatbuffers::Offset<AttachResponse> Finish() {
auto o = flatbuffers::Offset<AttachResponse>(fbb_.EndTable(start_, 6));
@@ -216,13 +245,13 @@ struct AttachResponseBuilder {
}
};
inline flatbuffers::Offset<AttachResponse> CreateAttachResponse(flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::String> memory_file = 0,
flatbuffers::Offset<flatbuffers::String> code_cache_file = 0,
uint32_t code_cache_base = 0,
uint32_t code_cache_size = 0,
flatbuffers::Offset<flatbuffers::String> functions_file = 0,
flatbuffers::Offset<flatbuffers::String> functions_trace_file = 0) {
inline flatbuffers::Offset<AttachResponse> CreateAttachResponse(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::String> memory_file = 0,
flatbuffers::Offset<flatbuffers::String> code_cache_file = 0,
uint32_t code_cache_base = 0, uint32_t code_cache_size = 0,
flatbuffers::Offset<flatbuffers::String> functions_file = 0,
flatbuffers::Offset<flatbuffers::String> functions_trace_file = 0) {
AttachResponseBuilder builder_(_fbb);
builder_.add_functions_trace_file(functions_trace_file);
builder_.add_functions_file(functions_file);
@@ -235,13 +264,16 @@ inline flatbuffers::Offset<AttachResponse> CreateAttachResponse(flatbuffers::Fla
struct Request FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
uint32_t id() const { return GetField<uint32_t>(4, 0); }
RequestData request_data_type() const { return static_cast<RequestData>(GetField<uint8_t>(6, 0)); }
RequestData request_data_type() const {
return static_cast<RequestData>(GetField<uint8_t>(6, 0));
}
const void *request_data() const { return GetPointer<const void *>(8); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, 4 /* id */) &&
VerifyField<uint8_t>(verifier, 6 /* request_data_type */) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* request_data */) &&
VerifyField<flatbuffers::uoffset_t>(verifier,
8 /* request_data */) &&
VerifyRequestData(verifier, request_data(), request_data_type()) &&
verifier.EndTable();
}
@@ -251,9 +283,15 @@ struct RequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_id(uint32_t id) { fbb_.AddElement<uint32_t>(4, id, 0); }
void add_request_data_type(RequestData request_data_type) { fbb_.AddElement<uint8_t>(6, static_cast<uint8_t>(request_data_type), 0); }
void add_request_data(flatbuffers::Offset<void> request_data) { fbb_.AddOffset(8, request_data); }
RequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
void add_request_data_type(RequestData request_data_type) {
fbb_.AddElement<uint8_t>(6, static_cast<uint8_t>(request_data_type), 0);
}
void add_request_data(flatbuffers::Offset<void> request_data) {
fbb_.AddOffset(8, request_data);
}
RequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
RequestBuilder &operator=(const RequestBuilder &);
flatbuffers::Offset<Request> Finish() {
auto o = flatbuffers::Offset<Request>(fbb_.EndTable(start_, 3));
@@ -261,10 +299,10 @@ struct RequestBuilder {
}
};
inline flatbuffers::Offset<Request> CreateRequest(flatbuffers::FlatBufferBuilder &_fbb,
uint32_t id = 0,
RequestData request_data_type = RequestData_NONE,
flatbuffers::Offset<void> request_data = 0) {
inline flatbuffers::Offset<Request> CreateRequest(
flatbuffers::FlatBufferBuilder &_fbb, uint32_t id = 0,
RequestData request_data_type = RequestData_NONE,
flatbuffers::Offset<void> request_data = 0) {
RequestBuilder builder_(_fbb);
builder_.add_request_data(request_data);
builder_.add_id(id);
@@ -274,14 +312,18 @@ inline flatbuffers::Offset<Request> CreateRequest(flatbuffers::FlatBufferBuilder
struct Response FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
uint32_t id() const { return GetField<uint32_t>(4, 0); }
ResponseData response_data_type() const { return static_cast<ResponseData>(GetField<uint8_t>(6, 0)); }
ResponseData response_data_type() const {
return static_cast<ResponseData>(GetField<uint8_t>(6, 0));
}
const void *response_data() const { return GetPointer<const void *>(8); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, 4 /* id */) &&
VerifyField<uint8_t>(verifier, 6 /* response_data_type */) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* response_data */) &&
VerifyResponseData(verifier, response_data(), response_data_type()) &&
VerifyField<flatbuffers::uoffset_t>(verifier,
8 /* response_data */) &&
VerifyResponseData(verifier, response_data(),
response_data_type()) &&
verifier.EndTable();
}
};
@@ -290,9 +332,15 @@ struct ResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_id(uint32_t id) { fbb_.AddElement<uint32_t>(4, id, 0); }
void add_response_data_type(ResponseData response_data_type) { fbb_.AddElement<uint8_t>(6, static_cast<uint8_t>(response_data_type), 0); }
void add_response_data(flatbuffers::Offset<void> response_data) { fbb_.AddOffset(8, response_data); }
ResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
void add_response_data_type(ResponseData response_data_type) {
fbb_.AddElement<uint8_t>(6, static_cast<uint8_t>(response_data_type), 0);
}
void add_response_data(flatbuffers::Offset<void> response_data) {
fbb_.AddOffset(8, response_data);
}
ResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ResponseBuilder &operator=(const ResponseBuilder &);
flatbuffers::Offset<Response> Finish() {
auto o = flatbuffers::Offset<Response>(fbb_.EndTable(start_, 3));
@@ -300,10 +348,10 @@ struct ResponseBuilder {
}
};
inline flatbuffers::Offset<Response> CreateResponse(flatbuffers::FlatBufferBuilder &_fbb,
uint32_t id = 0,
ResponseData response_data_type = ResponseData_NONE,
flatbuffers::Offset<void> response_data = 0) {
inline flatbuffers::Offset<Response> CreateResponse(
flatbuffers::FlatBufferBuilder &_fbb, uint32_t id = 0,
ResponseData response_data_type = ResponseData_NONE,
flatbuffers::Offset<void> response_data = 0) {
ResponseBuilder builder_(_fbb);
builder_.add_response_data(response_data);
builder_.add_id(id);
@@ -311,53 +359,135 @@ inline flatbuffers::Offset<Response> CreateResponse(flatbuffers::FlatBufferBuild
return builder_.Finish();
}
inline bool VerifyRequestData(flatbuffers::Verifier &verifier, const void *union_obj, RequestData type) {
inline bool VerifyRequestData(flatbuffers::Verifier &verifier,
const void *union_obj, RequestData type) {
switch (type) {
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_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_ListFunctionsRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::ListFunctionsRequest *>(union_obj));
case RequestData_GetFunctionRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::GetFunctionRequest *>(union_obj));
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_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_ListFunctionsRequest:
return verifier.VerifyTable(
reinterpret_cast<const xe::debug::proto::ListFunctionsRequest *>(
union_obj));
case RequestData_GetFunctionRequest:
return verifier.VerifyTable(
reinterpret_cast<const xe::debug::proto::GetFunctionRequest *>(
union_obj));
case RequestData_ListThreadsRequest:
return verifier.VerifyTable(
reinterpret_cast<const xe::debug::proto::ListThreadsRequest *>(
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;
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;
}
}
inline bool VerifyResponseData(flatbuffers::Verifier &verifier, const void *union_obj, ResponseData type) {
inline bool VerifyResponseData(flatbuffers::Verifier &verifier,
const void *union_obj, ResponseData type) {
switch (type) {
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_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_ListFunctionsResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::ListFunctionsResponse *>(union_obj));
case ResponseData_GetFunctionResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::GetFunctionResponse *>(union_obj));
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_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_ListFunctionsResponse:
return verifier.VerifyTable(
reinterpret_cast<const xe::debug::proto::ListFunctionsResponse *>(
union_obj));
case ResponseData_GetFunctionResponse:
return verifier.VerifyTable(
reinterpret_cast<const xe::debug::proto::GetFunctionResponse *>(
union_obj));
case ResponseData_ListThreadsResponse:
return verifier.VerifyTable(
reinterpret_cast<const xe::debug::proto::ListThreadsResponse *>(
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;
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;
}
}

335
src/xenia/debug/proto/modules_generated.h
View File

@@ -30,17 +30,16 @@ struct ListFunctionsResponse;
struct GetFunctionRequest;
struct GetFunctionResponse;
enum ModuleType {
ModuleType_Kernel = 0,
ModuleType_User = 1
};
enum ModuleType { ModuleType_Kernel = 0, ModuleType_User = 1 };
inline const char **EnumNamesModuleType() {
static const char *names[] = { "Kernel", "User", nullptr };
static const char *names[] = {"Kernel", "User", nullptr};
return names;
}
inline const char *EnumNameModuleType(ModuleType e) { return EnumNamesModuleType()[e]; }
inline const char *EnumNameModuleType(ModuleType e) {
return EnumNamesModuleType()[e];
}
MANUALLY_ALIGNED_STRUCT(4) ListModuleEntry FLATBUFFERS_FINAL_CLASS {
private:
@@ -49,18 +48,29 @@ MANUALLY_ALIGNED_STRUCT(4) ListModuleEntry FLATBUFFERS_FINAL_CLASS {
public:
ListModuleEntry(uint32_t handle, uint32_t function_count)
: handle_(flatbuffers::EndianScalar(handle)), function_count_(flatbuffers::EndianScalar(function_count)) { }
: handle_(flatbuffers::EndianScalar(handle)),
function_count_(flatbuffers::EndianScalar(function_count)) {}
uint32_t handle() const { return flatbuffers::EndianScalar(handle_); }
uint32_t function_count() const { return flatbuffers::EndianScalar(function_count_); }
uint32_t function_count() const {
return flatbuffers::EndianScalar(function_count_);
}
};
STRUCT_END(ListModuleEntry, 8);
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); }
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 */) &&
@@ -68,19 +78,28 @@ struct Module FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* name */) &&
verifier.Verify(name()) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* path */) &&
verifier.Verify(path()) &&
verifier.EndTable();
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(); }
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));
@@ -88,11 +107,12 @@ struct ModuleBuilder {
}
};
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) {
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);
@@ -103,15 +123,16 @@ inline flatbuffers::Offset<Module> CreateModule(flatbuffers::FlatBufferBuilder &
struct ListModulesRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
return VerifyTableStart(verifier) && verifier.EndTable();
}
};
struct ListModulesRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
ListModulesRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
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));
@@ -119,26 +140,35 @@ struct ListModulesRequestBuilder {
}
};
inline flatbuffers::Offset<ListModulesRequest> CreateListModulesRequest(flatbuffers::FlatBufferBuilder &_fbb) {
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<const ListModuleEntry *> *entry() const { return GetPointer<const flatbuffers::Vector<const ListModuleEntry *> *>(4); }
struct ListModulesResponse FLATBUFFERS_FINAL_CLASS
: private flatbuffers::Table {
const flatbuffers::Vector<const ListModuleEntry *> *entry() const {
return GetPointer<const flatbuffers::Vector<const ListModuleEntry *> *>(4);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* entry */) &&
verifier.Verify(entry()) &&
verifier.EndTable();
verifier.Verify(entry()) && verifier.EndTable();
}
};
struct ListModulesResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_entry(flatbuffers::Offset<flatbuffers::Vector<const ListModuleEntry *>> entry) { fbb_.AddOffset(4, entry); }
ListModulesResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
void add_entry(
flatbuffers::Offset<flatbuffers::Vector<const ListModuleEntry *>> entry) {
fbb_.AddOffset(4, entry);
}
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));
@@ -146,8 +176,10 @@ struct ListModulesResponseBuilder {
}
};
inline flatbuffers::Offset<ListModulesResponse> CreateListModulesResponse(flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<const ListModuleEntry *>> entry = 0) {
inline flatbuffers::Offset<ListModulesResponse> CreateListModulesResponse(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<const ListModuleEntry *>> entry =
0) {
ListModulesResponseBuilder builder_(_fbb);
builder_.add_entry(entry);
return builder_.Finish();
@@ -165,8 +197,12 @@ struct GetModuleRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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(); }
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));
@@ -174,8 +210,8 @@ struct GetModuleRequestBuilder {
}
};
inline flatbuffers::Offset<GetModuleRequest> CreateGetModuleRequest(flatbuffers::FlatBufferBuilder &_fbb,
uint32_t module_id = 0) {
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();
@@ -186,16 +222,19 @@ struct GetModuleResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* module */) &&
verifier.VerifyTable(module()) &&
verifier.EndTable();
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(); }
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));
@@ -203,8 +242,9 @@ struct GetModuleResponseBuilder {
}
};
inline flatbuffers::Offset<GetModuleResponse> CreateGetModuleResponse(flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<Module> module = 0) {
inline flatbuffers::Offset<GetModuleResponse> CreateGetModuleResponse(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<Module> module = 0) {
GetModuleResponseBuilder builder_(_fbb);
builder_.add_module(module);
return builder_.Finish();
@@ -214,26 +254,37 @@ struct FunctionEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
uint64_t identifier() const { return GetField<uint64_t>(4, 0); }
uint32_t address_start() const { return GetField<uint32_t>(6, 0); }
uint32_t address_end() const { return GetField<uint32_t>(8, 0); }
const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(10); }
const flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(10);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, 4 /* identifier */) &&
VerifyField<uint32_t>(verifier, 6 /* address_start */) &&
VerifyField<uint32_t>(verifier, 8 /* address_end */) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* name */) &&
verifier.Verify(name()) &&
verifier.EndTable();
verifier.Verify(name()) && verifier.EndTable();
}
};
struct FunctionEntryBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_identifier(uint64_t identifier) { fbb_.AddElement<uint64_t>(4, identifier, 0); }
void add_address_start(uint32_t address_start) { fbb_.AddElement<uint32_t>(6, address_start, 0); }
void add_address_end(uint32_t address_end) { fbb_.AddElement<uint32_t>(8, address_end, 0); }
void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(10, name); }
FunctionEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
void add_identifier(uint64_t identifier) {
fbb_.AddElement<uint64_t>(4, identifier, 0);
}
void add_address_start(uint32_t address_start) {
fbb_.AddElement<uint32_t>(6, address_start, 0);
}
void add_address_end(uint32_t address_end) {
fbb_.AddElement<uint32_t>(8, address_end, 0);
}
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
fbb_.AddOffset(10, name);
}
FunctionEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
FunctionEntryBuilder &operator=(const FunctionEntryBuilder &);
flatbuffers::Offset<FunctionEntry> Finish() {
auto o = flatbuffers::Offset<FunctionEntry>(fbb_.EndTable(start_, 4));
@@ -241,11 +292,10 @@ struct FunctionEntryBuilder {
}
};
inline flatbuffers::Offset<FunctionEntry> CreateFunctionEntry(flatbuffers::FlatBufferBuilder &_fbb,
uint64_t identifier = 0,
uint32_t address_start = 0,
uint32_t address_end = 0,
flatbuffers::Offset<flatbuffers::String> name = 0) {
inline flatbuffers::Offset<FunctionEntry> CreateFunctionEntry(
flatbuffers::FlatBufferBuilder &_fbb, uint64_t identifier = 0,
uint32_t address_start = 0, uint32_t address_end = 0,
flatbuffers::Offset<flatbuffers::String> name = 0) {
FunctionEntryBuilder builder_(_fbb);
builder_.add_identifier(identifier);
builder_.add_name(name);
@@ -258,11 +308,17 @@ struct Function FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
uint64_t identifier() const { return GetField<uint64_t>(4, 0); }
uint32_t address_start() const { return GetField<uint32_t>(6, 0); }
uint32_t address_end() const { return GetField<uint32_t>(8, 0); }
const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(10); }
const flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(10);
}
uint32_t machine_code_start() const { return GetField<uint32_t>(12, 0); }
uint32_t machine_code_end() const { return GetField<uint32_t>(14, 0); }
const flatbuffers::String *disasm_hir_raw() const { return GetPointer<const flatbuffers::String *>(16); }
const flatbuffers::String *disasm_hir_opt() const { return GetPointer<const flatbuffers::String *>(18); }
const flatbuffers::String *disasm_hir_raw() const {
return GetPointer<const flatbuffers::String *>(16);
}
const flatbuffers::String *disasm_hir_opt() const {
return GetPointer<const flatbuffers::String *>(18);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, 4 /* identifier */) &&
@@ -272,26 +328,47 @@ struct Function FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.Verify(name()) &&
VerifyField<uint32_t>(verifier, 12 /* machine_code_start */) &&
VerifyField<uint32_t>(verifier, 14 /* machine_code_end */) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 16 /* disasm_hir_raw */) &&
VerifyField<flatbuffers::uoffset_t>(verifier,
16 /* disasm_hir_raw */) &&
verifier.Verify(disasm_hir_raw()) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 18 /* disasm_hir_opt */) &&
verifier.Verify(disasm_hir_opt()) &&
verifier.EndTable();
VerifyField<flatbuffers::uoffset_t>(verifier,
18 /* disasm_hir_opt */) &&
verifier.Verify(disasm_hir_opt()) && verifier.EndTable();
}
};
struct FunctionBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_identifier(uint64_t identifier) { fbb_.AddElement<uint64_t>(4, identifier, 0); }
void add_address_start(uint32_t address_start) { fbb_.AddElement<uint32_t>(6, address_start, 0); }
void add_address_end(uint32_t address_end) { fbb_.AddElement<uint32_t>(8, address_end, 0); }
void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(10, name); }
void add_machine_code_start(uint32_t machine_code_start) { fbb_.AddElement<uint32_t>(12, machine_code_start, 0); }
void add_machine_code_end(uint32_t machine_code_end) { fbb_.AddElement<uint32_t>(14, machine_code_end, 0); }
void add_disasm_hir_raw(flatbuffers::Offset<flatbuffers::String> disasm_hir_raw) { fbb_.AddOffset(16, disasm_hir_raw); }
void add_disasm_hir_opt(flatbuffers::Offset<flatbuffers::String> disasm_hir_opt) { fbb_.AddOffset(18, disasm_hir_opt); }
FunctionBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
void add_identifier(uint64_t identifier) {
fbb_.AddElement<uint64_t>(4, identifier, 0);
}
void add_address_start(uint32_t address_start) {
fbb_.AddElement<uint32_t>(6, address_start, 0);
}
void add_address_end(uint32_t address_end) {
fbb_.AddElement<uint32_t>(8, address_end, 0);
}
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
fbb_.AddOffset(10, name);
}
void add_machine_code_start(uint32_t machine_code_start) {
fbb_.AddElement<uint32_t>(12, machine_code_start, 0);
}
void add_machine_code_end(uint32_t machine_code_end) {
fbb_.AddElement<uint32_t>(14, machine_code_end, 0);
}
void add_disasm_hir_raw(
flatbuffers::Offset<flatbuffers::String> disasm_hir_raw) {
fbb_.AddOffset(16, disasm_hir_raw);
}
void add_disasm_hir_opt(
flatbuffers::Offset<flatbuffers::String> disasm_hir_opt) {
fbb_.AddOffset(18, disasm_hir_opt);
}
FunctionBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
FunctionBuilder &operator=(const FunctionBuilder &);
flatbuffers::Offset<Function> Finish() {
auto o = flatbuffers::Offset<Function>(fbb_.EndTable(start_, 8));
@@ -299,15 +376,13 @@ struct FunctionBuilder {
}
};
inline flatbuffers::Offset<Function> CreateFunction(flatbuffers::FlatBufferBuilder &_fbb,
uint64_t identifier = 0,
uint32_t address_start = 0,
uint32_t address_end = 0,
flatbuffers::Offset<flatbuffers::String> name = 0,
uint32_t machine_code_start = 0,
uint32_t machine_code_end = 0,
flatbuffers::Offset<flatbuffers::String> disasm_hir_raw = 0,
flatbuffers::Offset<flatbuffers::String> disasm_hir_opt = 0) {
inline flatbuffers::Offset<Function> CreateFunction(
flatbuffers::FlatBufferBuilder &_fbb, uint64_t identifier = 0,
uint32_t address_start = 0, uint32_t address_end = 0,
flatbuffers::Offset<flatbuffers::String> name = 0,
uint32_t machine_code_start = 0, uint32_t machine_code_end = 0,
flatbuffers::Offset<flatbuffers::String> disasm_hir_raw = 0,
flatbuffers::Offset<flatbuffers::String> disasm_hir_opt = 0) {
FunctionBuilder builder_(_fbb);
builder_.add_identifier(identifier);
builder_.add_disasm_hir_opt(disasm_hir_opt);
@@ -320,7 +395,8 @@ inline flatbuffers::Offset<Function> CreateFunction(flatbuffers::FlatBufferBuild
return builder_.Finish();
}
struct ListFunctionsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct ListFunctionsRequest FLATBUFFERS_FINAL_CLASS
: private flatbuffers::Table {
uint32_t module_id() const { return GetField<uint32_t>(4, 0); }
uint32_t function_index_start() const { return GetField<uint32_t>(6, 0); }
uint32_t function_index_end() const { return GetField<uint32_t>(8, 0); }
@@ -336,21 +412,30 @@ struct ListFunctionsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
struct ListFunctionsRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_module_id(uint32_t module_id) { fbb_.AddElement<uint32_t>(4, module_id, 0); }
void add_function_index_start(uint32_t function_index_start) { fbb_.AddElement<uint32_t>(6, function_index_start, 0); }
void add_function_index_end(uint32_t function_index_end) { fbb_.AddElement<uint32_t>(8, function_index_end, 0); }
ListFunctionsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
void add_module_id(uint32_t module_id) {
fbb_.AddElement<uint32_t>(4, module_id, 0);
}
void add_function_index_start(uint32_t function_index_start) {
fbb_.AddElement<uint32_t>(6, function_index_start, 0);
}
void add_function_index_end(uint32_t function_index_end) {
fbb_.AddElement<uint32_t>(8, function_index_end, 0);
}
ListFunctionsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ListFunctionsRequestBuilder &operator=(const ListFunctionsRequestBuilder &);
flatbuffers::Offset<ListFunctionsRequest> Finish() {
auto o = flatbuffers::Offset<ListFunctionsRequest>(fbb_.EndTable(start_, 3));
auto o =
flatbuffers::Offset<ListFunctionsRequest>(fbb_.EndTable(start_, 3));
return o;
}
};
inline flatbuffers::Offset<ListFunctionsRequest> CreateListFunctionsRequest(flatbuffers::FlatBufferBuilder &_fbb,
uint32_t module_id = 0,
uint32_t function_index_start = 0,
uint32_t function_index_end = 0) {
inline flatbuffers::Offset<ListFunctionsRequest> CreateListFunctionsRequest(
flatbuffers::FlatBufferBuilder &_fbb, uint32_t module_id = 0,
uint32_t function_index_start = 0, uint32_t function_index_end = 0) {
ListFunctionsRequestBuilder builder_(_fbb);
builder_.add_function_index_end(function_index_end);
builder_.add_function_index_start(function_index_start);
@@ -358,13 +443,16 @@ inline flatbuffers::Offset<ListFunctionsRequest> CreateListFunctionsRequest(flat
return builder_.Finish();
}
struct ListFunctionsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>> *entry() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>> *>(4); }
struct ListFunctionsResponse FLATBUFFERS_FINAL_CLASS
: private flatbuffers::Table {
const flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>> *entry() const {
return GetPointer<
const flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>> *>(4);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* entry */) &&
verifier.Verify(entry()) &&
verifier.VerifyVectorOfTables(entry()) &&
verifier.Verify(entry()) && verifier.VerifyVectorOfTables(entry()) &&
verifier.EndTable();
}
};
@@ -372,17 +460,26 @@ struct ListFunctionsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Tabl
struct ListFunctionsResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_entry(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>>> entry) { fbb_.AddOffset(4, entry); }
ListFunctionsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
void add_entry(flatbuffers::Offset<
flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>>> entry) {
fbb_.AddOffset(4, entry);
}
ListFunctionsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ListFunctionsResponseBuilder &operator=(const ListFunctionsResponseBuilder &);
flatbuffers::Offset<ListFunctionsResponse> Finish() {
auto o = flatbuffers::Offset<ListFunctionsResponse>(fbb_.EndTable(start_, 1));
auto o =
flatbuffers::Offset<ListFunctionsResponse>(fbb_.EndTable(start_, 1));
return o;
}
};
inline flatbuffers::Offset<ListFunctionsResponse> CreateListFunctionsResponse(flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>>> entry = 0) {
inline flatbuffers::Offset<ListFunctionsResponse> CreateListFunctionsResponse(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<FunctionEntry>>>
entry = 0) {
ListFunctionsResponseBuilder builder_(_fbb);
builder_.add_entry(entry);
return builder_.Finish();
@@ -400,8 +497,12 @@ struct GetFunctionRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct GetFunctionRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_identifier(uint64_t identifier) { fbb_.AddElement<uint64_t>(4, identifier, 0); }
GetFunctionRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
void add_identifier(uint64_t identifier) {
fbb_.AddElement<uint64_t>(4, identifier, 0);
}
GetFunctionRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
GetFunctionRequestBuilder &operator=(const GetFunctionRequestBuilder &);
flatbuffers::Offset<GetFunctionRequest> Finish() {
auto o = flatbuffers::Offset<GetFunctionRequest>(fbb_.EndTable(start_, 1));
@@ -409,28 +510,33 @@ struct GetFunctionRequestBuilder {
}
};
inline flatbuffers::Offset<GetFunctionRequest> CreateGetFunctionRequest(flatbuffers::FlatBufferBuilder &_fbb,
uint64_t identifier = 0) {
inline flatbuffers::Offset<GetFunctionRequest> CreateGetFunctionRequest(
flatbuffers::FlatBufferBuilder &_fbb, uint64_t identifier = 0) {
GetFunctionRequestBuilder builder_(_fbb);
builder_.add_identifier(identifier);
return builder_.Finish();
}
struct GetFunctionResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct GetFunctionResponse FLATBUFFERS_FINAL_CLASS
: private flatbuffers::Table {
const Function *function() const { return GetPointer<const Function *>(4); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* function */) &&
verifier.VerifyTable(function()) &&
verifier.EndTable();
verifier.VerifyTable(function()) && verifier.EndTable();
}
};
struct GetFunctionResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_function(flatbuffers::Offset<Function> function) { fbb_.AddOffset(4, function); }
GetFunctionResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
void add_function(flatbuffers::Offset<Function> function) {
fbb_.AddOffset(4, function);
}
GetFunctionResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
GetFunctionResponseBuilder &operator=(const GetFunctionResponseBuilder &);
flatbuffers::Offset<GetFunctionResponse> Finish() {
auto o = flatbuffers::Offset<GetFunctionResponse>(fbb_.EndTable(start_, 1));
@@ -438,8 +544,9 @@ struct GetFunctionResponseBuilder {
}
};
inline flatbuffers::Offset<GetFunctionResponse> CreateGetFunctionResponse(flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<Function> function = 0) {
inline flatbuffers::Offset<GetFunctionResponse> CreateGetFunctionResponse(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<Function> function = 0) {
GetFunctionResponseBuilder builder_(_fbb);
builder_.add_function(function);
return builder_.Finish();

49
src/xenia/debug/proto/threads_generated.h
View File

@@ -21,21 +21,24 @@ struct Thread;
struct ListThreadsRequest;
struct ListThreadsResponse;
enum ThreadType {
ThreadType_Kernel = 0,
ThreadType_User = 1
};
enum ThreadType { ThreadType_Kernel = 0, ThreadType_User = 1 };
inline const char **EnumNamesThreadType() {
static const char *names[] = { "Kernel", "User", nullptr };
static const char *names[] = {"Kernel", "User", nullptr};
return names;
}
inline const char *EnumNameThreadType(ThreadType e) { return EnumNamesThreadType()[e]; }
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)); }
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));
}
uint32_t stack_size() const { return GetField<uint32_t>(8, 0); }
uint32_t xapi_thread_startup() const { return GetField<uint32_t>(10, 0); }
uint32_t start_address() const { return GetField<uint32_t>(12, 0); }
@@ -76,8 +79,12 @@ struct Thread FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
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); }
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);
}
void add_stack_size(uint32_t stack_size) {
fbb_.AddElement<uint32_t>(8, stack_size, 0);
}
@@ -115,7 +122,9 @@ struct ThreadBuilder {
fbb_.AddElement<uint32_t>(30, affinity, 0);
}
void add_state(uint32_t state) { fbb_.AddElement<uint32_t>(32, state, 0); }
ThreadBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
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_, 15));
@@ -154,15 +163,16 @@ inline flatbuffers::Offset<Thread> CreateThread(
struct ListThreadsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
return VerifyTableStart(verifier) && verifier.EndTable();
}
};
struct ListThreadsRequestBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
ListThreadsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
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));
@@ -170,12 +180,14 @@ struct ListThreadsRequestBuilder {
}
};
inline flatbuffers::Offset<ListThreadsRequest> CreateListThreadsRequest(flatbuffers::FlatBufferBuilder &_fbb) {
inline flatbuffers::Offset<ListThreadsRequest> CreateListThreadsRequest(
flatbuffers::FlatBufferBuilder &_fbb) {
ListThreadsRequestBuilder builder_(_fbb);
return builder_.Finish();
}
struct ListThreadsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct ListThreadsResponse FLATBUFFERS_FINAL_CLASS
: private flatbuffers::Table {
const flatbuffers::Vector<flatbuffers::Offset<Thread>> *thread() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Thread>> *>(
4);
@@ -195,7 +207,10 @@ struct ListThreadsResponseBuilder {
flatbuffers::Vector<flatbuffers::Offset<Thread>>> thread) {
fbb_.AddOffset(4, thread);
}
ListThreadsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
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_, 1));