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

Adding modules/functions to the debugger.

Browse Source
This commit is contained in:
Ben Vanik
2015-06-08 21:12:40 -07:00
parent 9d7d6df476
commit 573f190a43
47 changed files with 1427 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -25,6 +25,8 @@ union RequestData {
ListModulesRequest,
GetModuleRequest,
ListFunctionsRequest,
GetFunctionRequest,
StopRequest,
BreakRequest,
@@ -47,6 +49,8 @@ union ResponseData {
ListModulesResponse,
GetModuleResponse,
ListFunctionsResponse,
GetFunctionResponse,
StopResponse,
BreakResponse,

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

@@ -48,9 +48,16 @@ namespace debug {
namespace proto {
struct Module;
struct ListModulesRequest;
struct ListModuleEntry;
struct ListModulesResponse;
struct GetModuleRequest;
struct GetModuleResponse;
struct FunctionEntry;
struct Function;
struct ListFunctionsRequest;
struct ListFunctionsResponse;
struct GetFunctionRequest;
struct GetFunctionResponse;
} // namespace proto
} // namespace debug
} // namespace xe
@@ -82,14 +89,24 @@ enum RequestData {
RequestData_RemoveBreakpointsRequest = 5,
RequestData_ListModulesRequest = 6,
RequestData_GetModuleRequest = 7,
RequestData_StopRequest = 8,
RequestData_BreakRequest = 9,
RequestData_ContinueRequest = 10,
RequestData_StepRequest = 11
RequestData_ListFunctionsRequest = 8,
RequestData_GetFunctionRequest = 9,
RequestData_StopRequest = 10,
RequestData_BreakRequest = 11,
RequestData_ContinueRequest = 12,
RequestData_StepRequest = 13
};
inline const char **EnumNamesRequestData() {
static const char *names[] = { "NONE", "AttachRequest", "ListBreakpointsRequest", "AddBreakpointsRequest", "UpdateBreakpointsRequest", "RemoveBreakpointsRequest", "ListModulesRequest", "GetModuleRequest", "StopRequest", "BreakRequest", "ContinueRequest", "StepRequest", nullptr };
static const char *names[] = {
"NONE", "AttachRequest",
"ListBreakpointsRequest", "AddBreakpointsRequest",
"UpdateBreakpointsRequest", "RemoveBreakpointsRequest",
"ListModulesRequest", "GetModuleRequest",
"ListFunctionsRequest", "GetFunctionRequest",
"StopRequest", "BreakRequest",
"ContinueRequest", "StepRequest",
nullptr};
return names;
}
@@ -106,16 +123,27 @@ enum ResponseData {
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
ResponseData_ListFunctionsResponse = 8,
ResponseData_GetFunctionResponse = 9,
ResponseData_StopResponse = 10,
ResponseData_BreakResponse = 11,
ResponseData_ContinueResponse = 12,
ResponseData_StepResponse = 13,
ResponseData_BreakpointEvent = 14,
ResponseData_AccessViolationEvent = 15
};
inline const char **EnumNamesResponseData() {
static const char *names[] = { "NONE", "AttachResponse", "ListBreakpointsResponse", "AddBreakpointsResponse", "UpdateBreakpointsResponse", "RemoveBreakpointsResponse", "ListModulesResponse", "GetModuleResponse", "StopResponse", "BreakResponse", "ContinueResponse", "StepResponse", "BreakpointEvent", "AccessViolationEvent", nullptr };
static const char *names[] = {
"NONE", "AttachResponse",
"ListBreakpointsResponse", "AddBreakpointsResponse",
"UpdateBreakpointsResponse", "RemoveBreakpointsResponse",
"ListModulesResponse", "GetModuleResponse",
"ListFunctionsResponse", "GetFunctionResponse",
"StopResponse", "BreakResponse",
"ContinueResponse", "StepResponse",
"BreakpointEvent", "AccessViolationEvent",
nullptr};
return names;
}
@@ -275,6 +303,14 @@ inline bool VerifyRequestData(flatbuffers::Verifier &verifier, const void *union
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_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));
@@ -293,6 +329,14 @@ inline bool VerifyResponseData(flatbuffers::Verifier &verifier, const void *unio
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_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));

43
src/xenia/debug/proto/modules.fbs
View File

@@ -3,8 +3,8 @@ include "common.fbs";
namespace xe.debug.proto;
enum ModuleType:byte {
Kernel,
User,
Kernel = 0,
User = 1,
}
table Module {
@@ -18,8 +18,12 @@ table Module {
table ListModulesRequest {
}
struct ListModuleEntry {
handle:uint;
function_count:uint;
}
table ListModulesResponse {
module_ids:[uint];
entry:[ListModuleEntry];
}
table GetModuleRequest {
@@ -29,3 +33,36 @@ table GetModuleResponse {
module:Module;
}
table FunctionEntry {
identifier:ulong;
address_start:uint;
address_end:uint;
name:string;
}
table Function {
identifier:ulong;
address_start:uint;
address_end:uint;
name:string;
disasm_ppc:string;
disasm_hir_raw:string;
disasm_hir_opt:string;
disasm_machine_code:string;
}
table ListFunctionsRequest {
module_id:uint;
function_index_start:uint;
function_index_end:uint;
}
table ListFunctionsResponse {
entry:[FunctionEntry];
}
table GetFunctionRequest {
identifier:ulong;
}
table GetFunctionResponse {
function:Function;
}

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

@@ -19,9 +19,16 @@ namespace proto {
struct Module;
struct ListModulesRequest;
struct ListModuleEntry;
struct ListModulesResponse;
struct GetModuleRequest;
struct GetModuleResponse;
struct FunctionEntry;
struct Function;
struct ListFunctionsRequest;
struct ListFunctionsResponse;
struct GetFunctionRequest;
struct GetFunctionResponse;
enum ModuleType {
ModuleType_Kernel = 0,
@@ -35,6 +42,23 @@ inline const char **EnumNamesModuleType() {
inline const char *EnumNameModuleType(ModuleType e) { return EnumNamesModuleType()[e]; }
MANUALLY_ALIGNED_STRUCT(4) ListModuleEntry FLATBUFFERS_FINAL_CLASS {
private:
uint32_t handle_;
uint32_t function_count_;
public:
ListModuleEntry(uint32_t handle, uint32_t 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_);
}
};
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)); }
@@ -104,19 +128,23 @@ inline flatbuffers::Offset<ListModulesRequest> CreateListModulesRequest(flatbuff
}
struct ListModulesResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<uint32_t> *module_ids() const { return GetPointer<const flatbuffers::Vector<uint32_t> *>(4); }
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 /* module_ids */) &&
verifier.Verify(module_ids()) &&
verifier.EndTable();
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* entry */) &&
verifier.Verify(entry()) && 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); }
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() {
@@ -125,10 +153,12 @@ struct ListModulesResponseBuilder {
}
};
inline flatbuffers::Offset<ListModulesResponse> CreateListModulesResponse(flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint32_t>> module_ids = 0) {
inline flatbuffers::Offset<ListModulesResponse> CreateListModulesResponse(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<const ListModuleEntry *>> entry =
0) {
ListModulesResponseBuilder builder_(_fbb);
builder_.add_module_ids(module_ids);
builder_.add_entry(entry);
return builder_.Finish();
}
@@ -189,6 +219,317 @@ inline flatbuffers::Offset<GetModuleResponse> CreateGetModuleResponse(flatbuffer
return builder_.Finish();
}
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);
}
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();
}
};
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();
}
FunctionEntryBuilder &operator=(const FunctionEntryBuilder &);
flatbuffers::Offset<FunctionEntry> Finish() {
auto o = flatbuffers::Offset<FunctionEntry>(fbb_.EndTable(start_, 4));
return o;
}
};
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);
builder_.add_address_end(address_end);
builder_.add_address_start(address_start);
return builder_.Finish();
}
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 *disasm_ppc() const {
return GetPointer<const flatbuffers::String *>(12);
}
const flatbuffers::String *disasm_hir_raw() const {
return GetPointer<const flatbuffers::String *>(14);
}
const flatbuffers::String *disasm_hir_opt() const {
return GetPointer<const flatbuffers::String *>(16);
}
const flatbuffers::String *disasm_machine_code() const {
return GetPointer<const flatbuffers::String *>(18);
}
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()) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 12 /* disasm_ppc */) &&
verifier.Verify(disasm_ppc()) &&
VerifyField<flatbuffers::uoffset_t>(verifier,
14 /* disasm_hir_raw */) &&
verifier.Verify(disasm_hir_raw()) &&
VerifyField<flatbuffers::uoffset_t>(verifier,
16 /* disasm_hir_opt */) &&
verifier.Verify(disasm_hir_opt()) &&
VerifyField<flatbuffers::uoffset_t>(verifier,
18 /* disasm_machine_code */) &&
verifier.Verify(disasm_machine_code()) && 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_disasm_ppc(flatbuffers::Offset<flatbuffers::String> disasm_ppc) {
fbb_.AddOffset(12, disasm_ppc);
}
void add_disasm_hir_raw(
flatbuffers::Offset<flatbuffers::String> disasm_hir_raw) {
fbb_.AddOffset(14, disasm_hir_raw);
}
void add_disasm_hir_opt(
flatbuffers::Offset<flatbuffers::String> disasm_hir_opt) {
fbb_.AddOffset(16, disasm_hir_opt);
}
void add_disasm_machine_code(
flatbuffers::Offset<flatbuffers::String> disasm_machine_code) {
fbb_.AddOffset(18, disasm_machine_code);
}
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));
return o;
}
};
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,
flatbuffers::Offset<flatbuffers::String> disasm_ppc = 0,
flatbuffers::Offset<flatbuffers::String> disasm_hir_raw = 0,
flatbuffers::Offset<flatbuffers::String> disasm_hir_opt = 0,
flatbuffers::Offset<flatbuffers::String> disasm_machine_code = 0) {
FunctionBuilder builder_(_fbb);
builder_.add_identifier(identifier);
builder_.add_disasm_machine_code(disasm_machine_code);
builder_.add_disasm_hir_opt(disasm_hir_opt);
builder_.add_disasm_hir_raw(disasm_hir_raw);
builder_.add_disasm_ppc(disasm_ppc);
builder_.add_name(name);
builder_.add_address_end(address_end);
builder_.add_address_start(address_start);
return builder_.Finish();
}
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); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, 4 /* module_id */) &&
VerifyField<uint32_t>(verifier, 6 /* function_index_start */) &&
VerifyField<uint32_t>(verifier, 8 /* function_index_end */) &&
verifier.EndTable();
}
};
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();
}
ListFunctionsRequestBuilder &operator=(const ListFunctionsRequestBuilder &);
flatbuffers::Offset<ListFunctionsRequest> Finish() {
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) {
ListFunctionsRequestBuilder builder_(_fbb);
builder_.add_function_index_end(function_index_end);
builder_.add_function_index_start(function_index_start);
builder_.add_module_id(module_id);
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);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* entry */) &&
verifier.Verify(entry()) && verifier.VerifyVectorOfTables(entry()) &&
verifier.EndTable();
}
};
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();
}
ListFunctionsResponseBuilder &operator=(const ListFunctionsResponseBuilder &);
flatbuffers::Offset<ListFunctionsResponse> Finish() {
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) {
ListFunctionsResponseBuilder builder_(_fbb);
builder_.add_entry(entry);
return builder_.Finish();
}
struct GetFunctionRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
uint64_t identifier() const { return GetField<uint64_t>(4, 0); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, 4 /* identifier */) &&
verifier.EndTable();
}
};
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();
}
GetFunctionRequestBuilder &operator=(const GetFunctionRequestBuilder &);
flatbuffers::Offset<GetFunctionRequest> Finish() {
auto o = flatbuffers::Offset<GetFunctionRequest>(fbb_.EndTable(start_, 1));
return o;
}
};
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 {
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();
}
};
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();
}
GetFunctionResponseBuilder &operator=(const GetFunctionResponseBuilder &);
flatbuffers::Offset<GetFunctionResponse> Finish() {
auto o = flatbuffers::Offset<GetFunctionResponse>(fbb_.EndTable(start_, 1));
return o;
}
};
inline flatbuffers::Offset<GetFunctionResponse> CreateGetFunctionResponse(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<Function> function = 0) {
GetFunctionResponseBuilder builder_(_fbb);
builder_.add_function(function);
return builder_.Finish();
}
} // namespace proto
} // namespace debug
} // namespace xe