diff --git a/page/src/fb/debugger.ts b/page/src/fb/debugger.ts index ffde813b..babc30f3 100644 --- a/page/src/fb/debugger.ts +++ b/page/src/fb/debugger.ts @@ -7,5 +7,9 @@ export { Event } from './debugger/event.js'; export { GetStateRequest, GetStateRequestT } from './debugger/get-state-request.js'; export { GetStateResponse, GetStateResponseT } from './debugger/get-state-response.js'; export { PauseRequest, PauseRequestT } from './debugger/pause-request.js'; +export { ReadMemoryRequest, ReadMemoryRequestT } from './debugger/read-memory-request.js'; +export { ReadMemoryResponse, ReadMemoryResponseT } from './debugger/read-memory-response.js'; export { RunRequest, RunRequestT } from './debugger/run-request.js'; export { State } from './debugger/state.js'; +export { WriteMemoryRequest, WriteMemoryRequestT } from './debugger/write-memory-request.js'; +export { WriteMemoryResponse, WriteMemoryResponseT } from './debugger/write-memory-response.js'; diff --git a/page/src/fb/debugger/debug-event.ts b/page/src/fb/debugger/debug-event.ts index 96367434..afb57ec2 100644 --- a/page/src/fb/debugger/debug-event.ts +++ b/page/src/fb/debugger/debug-event.ts @@ -8,7 +8,11 @@ import { Event, unionToEvent, unionListToEvent } from '../debugger/event.js'; import { GetStateRequest, GetStateRequestT } from '../debugger/get-state-request.js'; import { GetStateResponse, GetStateResponseT } from '../debugger/get-state-response.js'; import { PauseRequest, PauseRequestT } from '../debugger/pause-request.js'; +import { ReadMemoryRequest, ReadMemoryRequestT } from '../debugger/read-memory-request.js'; +import { ReadMemoryResponse, ReadMemoryResponseT } from '../debugger/read-memory-response.js'; import { RunRequest, RunRequestT } from '../debugger/run-request.js'; +import { WriteMemoryRequest, WriteMemoryRequestT } from '../debugger/write-memory-request.js'; +import { WriteMemoryResponse, WriteMemoryResponseT } from '../debugger/write-memory-response.js'; export class DebugEvent implements flatbuffers.IUnpackableObject { @@ -96,7 +100,7 @@ unpackTo(_o: DebugEventT): void { export class DebugEventT implements flatbuffers.IGeneratedObject { constructor( public eventType: Event = Event.NONE, - public event: GetStateRequestT|GetStateResponseT|PauseRequestT|RunRequestT|null = null + public event: GetStateRequestT|GetStateResponseT|PauseRequestT|ReadMemoryRequestT|ReadMemoryResponseT|RunRequestT|WriteMemoryRequestT|WriteMemoryResponseT|null = null ){} diff --git a/page/src/fb/debugger/event.ts b/page/src/fb/debugger/event.ts index 6d5d0bbb..6b249b2b 100644 --- a/page/src/fb/debugger/event.ts +++ b/page/src/fb/debugger/event.ts @@ -5,7 +5,11 @@ import { GetStateRequest, GetStateRequestT } from '../debugger/get-state-request.js'; import { GetStateResponse, GetStateResponseT } from '../debugger/get-state-response.js'; import { PauseRequest, PauseRequestT } from '../debugger/pause-request.js'; +import { ReadMemoryRequest, ReadMemoryRequestT } from '../debugger/read-memory-request.js'; +import { ReadMemoryResponse, ReadMemoryResponseT } from '../debugger/read-memory-response.js'; import { RunRequest, RunRequestT } from '../debugger/run-request.js'; +import { WriteMemoryRequest, WriteMemoryRequestT } from '../debugger/write-memory-request.js'; +import { WriteMemoryResponse, WriteMemoryResponseT } from '../debugger/write-memory-response.js'; export enum Event { @@ -13,34 +17,46 @@ export enum Event { PauseRequest = 1, RunRequest = 2, GetStateRequest = 3, - GetStateResponse = 4 + GetStateResponse = 4, + WriteMemoryRequest = 5, + WriteMemoryResponse = 6, + ReadMemoryRequest = 7, + ReadMemoryResponse = 8 } export function unionToEvent( type: Event, - accessor: (obj:GetStateRequest|GetStateResponse|PauseRequest|RunRequest) => GetStateRequest|GetStateResponse|PauseRequest|RunRequest|null -): GetStateRequest|GetStateResponse|PauseRequest|RunRequest|null { + accessor: (obj:GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse) => GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|null +): GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|null { switch(Event[type]) { case 'NONE': return null; case 'PauseRequest': return accessor(new PauseRequest())! as PauseRequest; case 'RunRequest': return accessor(new RunRequest())! as RunRequest; case 'GetStateRequest': return accessor(new GetStateRequest())! as GetStateRequest; case 'GetStateResponse': return accessor(new GetStateResponse())! as GetStateResponse; + case 'WriteMemoryRequest': return accessor(new WriteMemoryRequest())! as WriteMemoryRequest; + case 'WriteMemoryResponse': return accessor(new WriteMemoryResponse())! as WriteMemoryResponse; + case 'ReadMemoryRequest': return accessor(new ReadMemoryRequest())! as ReadMemoryRequest; + case 'ReadMemoryResponse': return accessor(new ReadMemoryResponse())! as ReadMemoryResponse; default: return null; } } export function unionListToEvent( type: Event, - accessor: (index: number, obj:GetStateRequest|GetStateResponse|PauseRequest|RunRequest) => GetStateRequest|GetStateResponse|PauseRequest|RunRequest|null, + accessor: (index: number, obj:GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse) => GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|null, index: number -): GetStateRequest|GetStateResponse|PauseRequest|RunRequest|null { +): GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|null { switch(Event[type]) { case 'NONE': return null; case 'PauseRequest': return accessor(index, new PauseRequest())! as PauseRequest; case 'RunRequest': return accessor(index, new RunRequest())! as RunRequest; case 'GetStateRequest': return accessor(index, new GetStateRequest())! as GetStateRequest; case 'GetStateResponse': return accessor(index, new GetStateResponse())! as GetStateResponse; + case 'WriteMemoryRequest': return accessor(index, new WriteMemoryRequest())! as WriteMemoryRequest; + case 'WriteMemoryResponse': return accessor(index, new WriteMemoryResponse())! as WriteMemoryResponse; + case 'ReadMemoryRequest': return accessor(index, new ReadMemoryRequest())! as ReadMemoryRequest; + case 'ReadMemoryResponse': return accessor(index, new ReadMemoryResponse())! as ReadMemoryResponse; default: return null; } } diff --git a/page/src/fb/debugger/read-memory-request.ts b/page/src/fb/debugger/read-memory-request.ts new file mode 100644 index 00000000..5779ac60 --- /dev/null +++ b/page/src/fb/debugger/read-memory-request.ts @@ -0,0 +1,110 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */ + +import * as flatbuffers from 'flatbuffers'; + + + +export class ReadMemoryRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ReadMemoryRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsReadMemoryRequest(bb:flatbuffers.ByteBuffer, obj?:ReadMemoryRequest):ReadMemoryRequest { + return (obj || new ReadMemoryRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsReadMemoryRequest(bb:flatbuffers.ByteBuffer, obj?:ReadMemoryRequest):ReadMemoryRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ReadMemoryRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +address():bigint { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint64(this.bb_pos + offset) : BigInt('0'); +} + +mutate_address(value:bigint):boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb!.writeUint64(this.bb_pos + offset, value); + return true; +} + +size():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; +} + +mutate_size(value:number):boolean { + const offset = this.bb!.__offset(this.bb_pos, 6); + + if (offset === 0) { + return false; + } + + this.bb!.writeUint32(this.bb_pos + offset, value); + return true; +} + +static startReadMemoryRequest(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addAddress(builder:flatbuffers.Builder, address:bigint) { + builder.addFieldInt64(0, address, BigInt('0')); +} + +static addSize(builder:flatbuffers.Builder, size:number) { + builder.addFieldInt32(1, size, 0); +} + +static endReadMemoryRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createReadMemoryRequest(builder:flatbuffers.Builder, address:bigint, size:number):flatbuffers.Offset { + ReadMemoryRequest.startReadMemoryRequest(builder); + ReadMemoryRequest.addAddress(builder, address); + ReadMemoryRequest.addSize(builder, size); + return ReadMemoryRequest.endReadMemoryRequest(builder); +} + +unpack(): ReadMemoryRequestT { + return new ReadMemoryRequestT( + this.address(), + this.size() + ); +} + + +unpackTo(_o: ReadMemoryRequestT): void { + _o.address = this.address(); + _o.size = this.size(); +} +} + +export class ReadMemoryRequestT implements flatbuffers.IGeneratedObject { +constructor( + public address: bigint = BigInt('0'), + public size: number = 0 +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return ReadMemoryRequest.createReadMemoryRequest(builder, + this.address, + this.size + ); +} +} diff --git a/page/src/fb/debugger/read-memory-response.ts b/page/src/fb/debugger/read-memory-response.ts new file mode 100644 index 00000000..9e0b38c1 --- /dev/null +++ b/page/src/fb/debugger/read-memory-response.ts @@ -0,0 +1,123 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */ + +import * as flatbuffers from 'flatbuffers'; + + + +export class ReadMemoryResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ReadMemoryResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsReadMemoryResponse(bb:flatbuffers.ByteBuffer, obj?:ReadMemoryResponse):ReadMemoryResponse { + return (obj || new ReadMemoryResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsReadMemoryResponse(bb:flatbuffers.ByteBuffer, obj?:ReadMemoryResponse):ReadMemoryResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ReadMemoryResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +address():bigint { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint64(this.bb_pos + offset) : BigInt('0'); +} + +mutate_address(value:bigint):boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb!.writeUint64(this.bb_pos + offset, value); + return true; +} + +data(index: number):number|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; +} + +dataLength():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +dataArray():Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; +} + +static startReadMemoryResponse(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addAddress(builder:flatbuffers.Builder, address:bigint) { + builder.addFieldInt64(0, address, BigInt('0')); +} + +static addData(builder:flatbuffers.Builder, dataOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, dataOffset, 0); +} + +static createDataVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]!); + } + return builder.endVector(); +} + +static startDataVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +} + +static endReadMemoryResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createReadMemoryResponse(builder:flatbuffers.Builder, address:bigint, dataOffset:flatbuffers.Offset):flatbuffers.Offset { + ReadMemoryResponse.startReadMemoryResponse(builder); + ReadMemoryResponse.addAddress(builder, address); + ReadMemoryResponse.addData(builder, dataOffset); + return ReadMemoryResponse.endReadMemoryResponse(builder); +} + +unpack(): ReadMemoryResponseT { + return new ReadMemoryResponseT( + this.address(), + this.bb!.createScalarList(this.data.bind(this), this.dataLength()) + ); +} + + +unpackTo(_o: ReadMemoryResponseT): void { + _o.address = this.address(); + _o.data = this.bb!.createScalarList(this.data.bind(this), this.dataLength()); +} +} + +export class ReadMemoryResponseT implements flatbuffers.IGeneratedObject { +constructor( + public address: bigint = BigInt('0'), + public data: (number)[] = [] +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const data = ReadMemoryResponse.createDataVector(builder, this.data); + + return ReadMemoryResponse.createReadMemoryResponse(builder, + this.address, + data + ); +} +} diff --git a/page/src/fb/debugger/write-memory-request.ts b/page/src/fb/debugger/write-memory-request.ts new file mode 100644 index 00000000..3d669553 --- /dev/null +++ b/page/src/fb/debugger/write-memory-request.ts @@ -0,0 +1,123 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */ + +import * as flatbuffers from 'flatbuffers'; + + + +export class WriteMemoryRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):WriteMemoryRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsWriteMemoryRequest(bb:flatbuffers.ByteBuffer, obj?:WriteMemoryRequest):WriteMemoryRequest { + return (obj || new WriteMemoryRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsWriteMemoryRequest(bb:flatbuffers.ByteBuffer, obj?:WriteMemoryRequest):WriteMemoryRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new WriteMemoryRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +address():bigint { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint64(this.bb_pos + offset) : BigInt('0'); +} + +mutate_address(value:bigint):boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb!.writeUint64(this.bb_pos + offset, value); + return true; +} + +data(index: number):number|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; +} + +dataLength():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +dataArray():Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; +} + +static startWriteMemoryRequest(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addAddress(builder:flatbuffers.Builder, address:bigint) { + builder.addFieldInt64(0, address, BigInt('0')); +} + +static addData(builder:flatbuffers.Builder, dataOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, dataOffset, 0); +} + +static createDataVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]!); + } + return builder.endVector(); +} + +static startDataVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +} + +static endWriteMemoryRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createWriteMemoryRequest(builder:flatbuffers.Builder, address:bigint, dataOffset:flatbuffers.Offset):flatbuffers.Offset { + WriteMemoryRequest.startWriteMemoryRequest(builder); + WriteMemoryRequest.addAddress(builder, address); + WriteMemoryRequest.addData(builder, dataOffset); + return WriteMemoryRequest.endWriteMemoryRequest(builder); +} + +unpack(): WriteMemoryRequestT { + return new WriteMemoryRequestT( + this.address(), + this.bb!.createScalarList(this.data.bind(this), this.dataLength()) + ); +} + + +unpackTo(_o: WriteMemoryRequestT): void { + _o.address = this.address(); + _o.data = this.bb!.createScalarList(this.data.bind(this), this.dataLength()); +} +} + +export class WriteMemoryRequestT implements flatbuffers.IGeneratedObject { +constructor( + public address: bigint = BigInt('0'), + public data: (number)[] = [] +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const data = WriteMemoryRequest.createDataVector(builder, this.data); + + return WriteMemoryRequest.createWriteMemoryRequest(builder, + this.address, + data + ); +} +} diff --git a/page/src/fb/debugger/write-memory-response.ts b/page/src/fb/debugger/write-memory-response.ts new file mode 100644 index 00000000..700f9444 --- /dev/null +++ b/page/src/fb/debugger/write-memory-response.ts @@ -0,0 +1,135 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */ + +import * as flatbuffers from 'flatbuffers'; + + + +export class WriteMemoryResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):WriteMemoryResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsWriteMemoryResponse(bb:flatbuffers.ByteBuffer, obj?:WriteMemoryResponse):WriteMemoryResponse { + return (obj || new WriteMemoryResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsWriteMemoryResponse(bb:flatbuffers.ByteBuffer, obj?:WriteMemoryResponse):WriteMemoryResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new WriteMemoryResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +address():bigint { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint64(this.bb_pos + offset) : BigInt('0'); +} + +mutate_address(value:bigint):boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb!.writeUint64(this.bb_pos + offset, value); + return true; +} + +size():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; +} + +mutate_size(value:number):boolean { + const offset = this.bb!.__offset(this.bb_pos, 6); + + if (offset === 0) { + return false; + } + + this.bb!.writeUint32(this.bb_pos + offset, value); + return true; +} + +success():boolean { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +mutate_success(value:boolean):boolean { + const offset = this.bb!.__offset(this.bb_pos, 8); + + if (offset === 0) { + return false; + } + + this.bb!.writeInt8(this.bb_pos + offset, +value); + return true; +} + +static startWriteMemoryResponse(builder:flatbuffers.Builder) { + builder.startObject(3); +} + +static addAddress(builder:flatbuffers.Builder, address:bigint) { + builder.addFieldInt64(0, address, BigInt('0')); +} + +static addSize(builder:flatbuffers.Builder, size:number) { + builder.addFieldInt32(1, size, 0); +} + +static addSuccess(builder:flatbuffers.Builder, success:boolean) { + builder.addFieldInt8(2, +success, +false); +} + +static endWriteMemoryResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createWriteMemoryResponse(builder:flatbuffers.Builder, address:bigint, size:number, success:boolean):flatbuffers.Offset { + WriteMemoryResponse.startWriteMemoryResponse(builder); + WriteMemoryResponse.addAddress(builder, address); + WriteMemoryResponse.addSize(builder, size); + WriteMemoryResponse.addSuccess(builder, success); + return WriteMemoryResponse.endWriteMemoryResponse(builder); +} + +unpack(): WriteMemoryResponseT { + return new WriteMemoryResponseT( + this.address(), + this.size(), + this.success() + ); +} + + +unpackTo(_o: WriteMemoryResponseT): void { + _o.address = this.address(); + _o.size = this.size(); + _o.success = this.success(); +} +} + +export class WriteMemoryResponseT implements flatbuffers.IGeneratedObject { +constructor( + public address: bigint = BigInt('0'), + public size: number = 0, + public success: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return WriteMemoryResponse.createWriteMemoryResponse(builder, + this.address, + this.size, + this.success + ); +} +} diff --git a/src/debugger/event_handler.cpp b/src/debugger/event_handler.cpp index b6d65591..8569078d 100644 --- a/src/debugger/event_handler.cpp +++ b/src/debugger/event_handler.cpp @@ -76,12 +76,51 @@ namespace debugger } } - void handle_get_state_request(const event_context& c) + void handle_get_state(const event_context& c) { - Debugger::GetStateResponseT stateResponse{}; - stateResponse.state = translate_state(c.state); + Debugger::GetStateResponseT response{}; + response.state = translate_state(c.state); - send_event(stateResponse); + send_event(response); + } + + void handle_read_memory(const event_context& c, const Debugger::ReadMemoryRequestT& request) + { + std::vector buffer{}; + buffer.resize(request.size); + const auto res = c.win_emu.memory.try_read_memory(request.address, buffer.data(), buffer.size()); + + Debugger::ReadMemoryResponseT response{}; + response.address = request.address; + + if (res) + { + response.data = std::move(buffer); + } + + send_event(std::move(response)); + } + + void handle_write_memory(const event_context& c, const Debugger::WriteMemoryRequestT& request) + { + bool success{}; + + try + { + c.win_emu.memory.write_memory(request.address, request.data.data(), request.data.size()); + success = true; + } + catch (...) + { + success = false; + } + + Debugger::WriteMemoryResponseT response{}; + response.address = request.address; + response.size = static_cast(request.data.size()); + response.success = success; + + send_event(response); } void handle_event(event_context& c, const Debugger::DebugEventT& e) @@ -97,7 +136,15 @@ namespace debugger break; case Debugger::Event_GetStateRequest: - handle_get_state_request(c); + handle_get_state(c); + break; + + case Debugger::Event_ReadMemoryRequest: + handle_read_memory(c, *e.event.AsReadMemoryRequest()); + break; + + case Debugger::Event_WriteMemoryRequest: + handle_write_memory(c, *e.event.AsWriteMemoryRequest()); break; default: diff --git a/src/debugger/events.fbs b/src/debugger/events.fbs index 76c502ed..d676b441 100644 --- a/src/debugger/events.fbs +++ b/src/debugger/events.fbs @@ -18,11 +18,36 @@ table RunRequest { single_step: bool; } +table WriteMemoryRequest { + address: uint64; + data: [ubyte]; +} + +table WriteMemoryResponse { + address: uint64; + size: uint32; + success: bool; +} + +table ReadMemoryRequest { + address: uint64; + size: uint32; +} + +table ReadMemoryResponse { + address: uint64; + data: [ubyte]; +} + union Event { PauseRequest, RunRequest, GetStateRequest, GetStateResponse, + WriteMemoryRequest, + WriteMemoryResponse, + ReadMemoryRequest, + ReadMemoryResponse, } table DebugEvent { diff --git a/src/debugger/events_generated.hxx b/src/debugger/events_generated.hxx index 82cc1b9f..c2f80331 100644 --- a/src/debugger/events_generated.hxx +++ b/src/debugger/events_generated.hxx @@ -31,6 +31,22 @@ struct RunRequest; struct RunRequestBuilder; struct RunRequestT; +struct WriteMemoryRequest; +struct WriteMemoryRequestBuilder; +struct WriteMemoryRequestT; + +struct WriteMemoryResponse; +struct WriteMemoryResponseBuilder; +struct WriteMemoryResponseT; + +struct ReadMemoryRequest; +struct ReadMemoryRequestBuilder; +struct ReadMemoryRequestT; + +struct ReadMemoryResponse; +struct ReadMemoryResponseBuilder; +struct ReadMemoryResponseT; + struct DebugEvent; struct DebugEventBuilder; struct DebugEventT; @@ -74,35 +90,47 @@ enum Event : uint8_t { Event_RunRequest = 2, Event_GetStateRequest = 3, Event_GetStateResponse = 4, + Event_WriteMemoryRequest = 5, + Event_WriteMemoryResponse = 6, + Event_ReadMemoryRequest = 7, + Event_ReadMemoryResponse = 8, Event_MIN = Event_NONE, - Event_MAX = Event_GetStateResponse + Event_MAX = Event_ReadMemoryResponse }; -inline const Event (&EnumValuesEvent())[5] { +inline const Event (&EnumValuesEvent())[9] { static const Event values[] = { Event_NONE, Event_PauseRequest, Event_RunRequest, Event_GetStateRequest, - Event_GetStateResponse + Event_GetStateResponse, + Event_WriteMemoryRequest, + Event_WriteMemoryResponse, + Event_ReadMemoryRequest, + Event_ReadMemoryResponse }; return values; } inline const char * const *EnumNamesEvent() { - static const char * const names[6] = { + static const char * const names[10] = { "NONE", "PauseRequest", "RunRequest", "GetStateRequest", "GetStateResponse", + "WriteMemoryRequest", + "WriteMemoryResponse", + "ReadMemoryRequest", + "ReadMemoryResponse", nullptr }; return names; } inline const char *EnumNameEvent(Event e) { - if (::flatbuffers::IsOutRange(e, Event_NONE, Event_GetStateResponse)) return ""; + if (::flatbuffers::IsOutRange(e, Event_NONE, Event_ReadMemoryResponse)) return ""; const size_t index = static_cast(e); return EnumNamesEvent()[index]; } @@ -127,6 +155,22 @@ template<> struct EventTraits { static const Event enum_value = Event_GetStateResponse; }; +template<> struct EventTraits { + static const Event enum_value = Event_WriteMemoryRequest; +}; + +template<> struct EventTraits { + static const Event enum_value = Event_WriteMemoryResponse; +}; + +template<> struct EventTraits { + static const Event enum_value = Event_ReadMemoryRequest; +}; + +template<> struct EventTraits { + static const Event enum_value = Event_ReadMemoryResponse; +}; + template struct EventUnionTraits { static const Event enum_value = Event_NONE; }; @@ -147,6 +191,22 @@ template<> struct EventUnionTraits { static const Event enum_value = Event_GetStateResponse; }; +template<> struct EventUnionTraits { + static const Event enum_value = Event_WriteMemoryRequest; +}; + +template<> struct EventUnionTraits { + static const Event enum_value = Event_WriteMemoryResponse; +}; + +template<> struct EventUnionTraits { + static const Event enum_value = Event_ReadMemoryRequest; +}; + +template<> struct EventUnionTraits { + static const Event enum_value = Event_ReadMemoryResponse; +}; + struct EventUnion { Event type; void *value; @@ -209,6 +269,38 @@ struct EventUnion { return type == Event_GetStateResponse ? reinterpret_cast(value) : nullptr; } + Debugger::WriteMemoryRequestT *AsWriteMemoryRequest() { + return type == Event_WriteMemoryRequest ? + reinterpret_cast(value) : nullptr; + } + const Debugger::WriteMemoryRequestT *AsWriteMemoryRequest() const { + return type == Event_WriteMemoryRequest ? + reinterpret_cast(value) : nullptr; + } + Debugger::WriteMemoryResponseT *AsWriteMemoryResponse() { + return type == Event_WriteMemoryResponse ? + reinterpret_cast(value) : nullptr; + } + const Debugger::WriteMemoryResponseT *AsWriteMemoryResponse() const { + return type == Event_WriteMemoryResponse ? + reinterpret_cast(value) : nullptr; + } + Debugger::ReadMemoryRequestT *AsReadMemoryRequest() { + return type == Event_ReadMemoryRequest ? + reinterpret_cast(value) : nullptr; + } + const Debugger::ReadMemoryRequestT *AsReadMemoryRequest() const { + return type == Event_ReadMemoryRequest ? + reinterpret_cast(value) : nullptr; + } + Debugger::ReadMemoryResponseT *AsReadMemoryResponse() { + return type == Event_ReadMemoryResponse ? + reinterpret_cast(value) : nullptr; + } + const Debugger::ReadMemoryResponseT *AsReadMemoryResponse() const { + return type == Event_ReadMemoryResponse ? + reinterpret_cast(value) : nullptr; + } }; bool VerifyEvent(::flatbuffers::Verifier &verifier, const void *obj, Event type); @@ -402,6 +494,320 @@ inline ::flatbuffers::Offset CreateRunRequest( ::flatbuffers::Offset CreateRunRequest(::flatbuffers::FlatBufferBuilder &_fbb, const RunRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +struct WriteMemoryRequestT : public ::flatbuffers::NativeTable { + typedef WriteMemoryRequest TableType; + uint64_t address = 0; + std::vector data{}; +}; + +struct WriteMemoryRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef WriteMemoryRequestT NativeTableType; + typedef WriteMemoryRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ADDRESS = 4, + VT_DATA = 6 + }; + uint64_t address() const { + return GetField(VT_ADDRESS, 0); + } + bool mutate_address(uint64_t _address = 0) { + return SetField(VT_ADDRESS, _address, 0); + } + const ::flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + ::flatbuffers::Vector *mutable_data() { + return GetPointer<::flatbuffers::Vector *>(VT_DATA); + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ADDRESS, 8) && + VerifyOffset(verifier, VT_DATA) && + verifier.VerifyVector(data()) && + verifier.EndTable(); + } + WriteMemoryRequestT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(WriteMemoryRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteMemoryRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct WriteMemoryRequestBuilder { + typedef WriteMemoryRequest Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_address(uint64_t address) { + fbb_.AddElement(WriteMemoryRequest::VT_ADDRESS, address, 0); + } + void add_data(::flatbuffers::Offset<::flatbuffers::Vector> data) { + fbb_.AddOffset(WriteMemoryRequest::VT_DATA, data); + } + explicit WriteMemoryRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateWriteMemoryRequest( + ::flatbuffers::FlatBufferBuilder &_fbb, + uint64_t address = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> data = 0) { + WriteMemoryRequestBuilder builder_(_fbb); + builder_.add_address(address); + builder_.add_data(data); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateWriteMemoryRequestDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + uint64_t address = 0, + const std::vector *data = nullptr) { + auto data__ = data ? _fbb.CreateVector(*data) : 0; + return Debugger::CreateWriteMemoryRequest( + _fbb, + address, + data__); +} + +::flatbuffers::Offset CreateWriteMemoryRequest(::flatbuffers::FlatBufferBuilder &_fbb, const WriteMemoryRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct WriteMemoryResponseT : public ::flatbuffers::NativeTable { + typedef WriteMemoryResponse TableType; + uint64_t address = 0; + uint32_t size = 0; + bool success = false; +}; + +struct WriteMemoryResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef WriteMemoryResponseT NativeTableType; + typedef WriteMemoryResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ADDRESS = 4, + VT_SIZE = 6, + VT_SUCCESS = 8 + }; + uint64_t address() const { + return GetField(VT_ADDRESS, 0); + } + bool mutate_address(uint64_t _address = 0) { + return SetField(VT_ADDRESS, _address, 0); + } + uint32_t size() const { + return GetField(VT_SIZE, 0); + } + bool mutate_size(uint32_t _size = 0) { + return SetField(VT_SIZE, _size, 0); + } + bool success() const { + return GetField(VT_SUCCESS, 0) != 0; + } + bool mutate_success(bool _success = 0) { + return SetField(VT_SUCCESS, static_cast(_success), 0); + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ADDRESS, 8) && + VerifyField(verifier, VT_SIZE, 4) && + VerifyField(verifier, VT_SUCCESS, 1) && + verifier.EndTable(); + } + WriteMemoryResponseT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(WriteMemoryResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteMemoryResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct WriteMemoryResponseBuilder { + typedef WriteMemoryResponse Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_address(uint64_t address) { + fbb_.AddElement(WriteMemoryResponse::VT_ADDRESS, address, 0); + } + void add_size(uint32_t size) { + fbb_.AddElement(WriteMemoryResponse::VT_SIZE, size, 0); + } + void add_success(bool success) { + fbb_.AddElement(WriteMemoryResponse::VT_SUCCESS, static_cast(success), 0); + } + explicit WriteMemoryResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateWriteMemoryResponse( + ::flatbuffers::FlatBufferBuilder &_fbb, + uint64_t address = 0, + uint32_t size = 0, + bool success = false) { + WriteMemoryResponseBuilder builder_(_fbb); + builder_.add_address(address); + builder_.add_size(size); + builder_.add_success(success); + return builder_.Finish(); +} + +::flatbuffers::Offset CreateWriteMemoryResponse(::flatbuffers::FlatBufferBuilder &_fbb, const WriteMemoryResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ReadMemoryRequestT : public ::flatbuffers::NativeTable { + typedef ReadMemoryRequest TableType; + uint64_t address = 0; + uint32_t size = 0; +}; + +struct ReadMemoryRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef ReadMemoryRequestT NativeTableType; + typedef ReadMemoryRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ADDRESS = 4, + VT_SIZE = 6 + }; + uint64_t address() const { + return GetField(VT_ADDRESS, 0); + } + bool mutate_address(uint64_t _address = 0) { + return SetField(VT_ADDRESS, _address, 0); + } + uint32_t size() const { + return GetField(VT_SIZE, 0); + } + bool mutate_size(uint32_t _size = 0) { + return SetField(VT_SIZE, _size, 0); + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ADDRESS, 8) && + VerifyField(verifier, VT_SIZE, 4) && + verifier.EndTable(); + } + ReadMemoryRequestT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReadMemoryRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadMemoryRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ReadMemoryRequestBuilder { + typedef ReadMemoryRequest Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_address(uint64_t address) { + fbb_.AddElement(ReadMemoryRequest::VT_ADDRESS, address, 0); + } + void add_size(uint32_t size) { + fbb_.AddElement(ReadMemoryRequest::VT_SIZE, size, 0); + } + explicit ReadMemoryRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateReadMemoryRequest( + ::flatbuffers::FlatBufferBuilder &_fbb, + uint64_t address = 0, + uint32_t size = 0) { + ReadMemoryRequestBuilder builder_(_fbb); + builder_.add_address(address); + builder_.add_size(size); + return builder_.Finish(); +} + +::flatbuffers::Offset CreateReadMemoryRequest(::flatbuffers::FlatBufferBuilder &_fbb, const ReadMemoryRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ReadMemoryResponseT : public ::flatbuffers::NativeTable { + typedef ReadMemoryResponse TableType; + uint64_t address = 0; + std::vector data{}; +}; + +struct ReadMemoryResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef ReadMemoryResponseT NativeTableType; + typedef ReadMemoryResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ADDRESS = 4, + VT_DATA = 6 + }; + uint64_t address() const { + return GetField(VT_ADDRESS, 0); + } + bool mutate_address(uint64_t _address = 0) { + return SetField(VT_ADDRESS, _address, 0); + } + const ::flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + ::flatbuffers::Vector *mutable_data() { + return GetPointer<::flatbuffers::Vector *>(VT_DATA); + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ADDRESS, 8) && + VerifyOffset(verifier, VT_DATA) && + verifier.VerifyVector(data()) && + verifier.EndTable(); + } + ReadMemoryResponseT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReadMemoryResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadMemoryResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ReadMemoryResponseBuilder { + typedef ReadMemoryResponse Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_address(uint64_t address) { + fbb_.AddElement(ReadMemoryResponse::VT_ADDRESS, address, 0); + } + void add_data(::flatbuffers::Offset<::flatbuffers::Vector> data) { + fbb_.AddOffset(ReadMemoryResponse::VT_DATA, data); + } + explicit ReadMemoryResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateReadMemoryResponse( + ::flatbuffers::FlatBufferBuilder &_fbb, + uint64_t address = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> data = 0) { + ReadMemoryResponseBuilder builder_(_fbb); + builder_.add_address(address); + builder_.add_data(data); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateReadMemoryResponseDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + uint64_t address = 0, + const std::vector *data = nullptr) { + auto data__ = data ? _fbb.CreateVector(*data) : 0; + return Debugger::CreateReadMemoryResponse( + _fbb, + address, + data__); +} + +::flatbuffers::Offset CreateReadMemoryResponse(::flatbuffers::FlatBufferBuilder &_fbb, const ReadMemoryResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); + struct DebugEventT : public ::flatbuffers::NativeTable { typedef DebugEvent TableType; Debugger::EventUnion event{}; @@ -433,6 +839,18 @@ struct DebugEvent FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { const Debugger::GetStateResponse *event_as_GetStateResponse() const { return event_type() == Debugger::Event_GetStateResponse ? static_cast(event()) : nullptr; } + const Debugger::WriteMemoryRequest *event_as_WriteMemoryRequest() const { + return event_type() == Debugger::Event_WriteMemoryRequest ? static_cast(event()) : nullptr; + } + const Debugger::WriteMemoryResponse *event_as_WriteMemoryResponse() const { + return event_type() == Debugger::Event_WriteMemoryResponse ? static_cast(event()) : nullptr; + } + const Debugger::ReadMemoryRequest *event_as_ReadMemoryRequest() const { + return event_type() == Debugger::Event_ReadMemoryRequest ? static_cast(event()) : nullptr; + } + const Debugger::ReadMemoryResponse *event_as_ReadMemoryResponse() const { + return event_type() == Debugger::Event_ReadMemoryResponse ? static_cast(event()) : nullptr; + } void *mutable_event() { return GetPointer(VT_EVENT); } @@ -464,6 +882,22 @@ template<> inline const Debugger::GetStateResponse *DebugEvent::event_as inline const Debugger::WriteMemoryRequest *DebugEvent::event_as() const { + return event_as_WriteMemoryRequest(); +} + +template<> inline const Debugger::WriteMemoryResponse *DebugEvent::event_as() const { + return event_as_WriteMemoryResponse(); +} + +template<> inline const Debugger::ReadMemoryRequest *DebugEvent::event_as() const { + return event_as_ReadMemoryRequest(); +} + +template<> inline const Debugger::ReadMemoryResponse *DebugEvent::event_as() const { + return event_as_ReadMemoryResponse(); +} + struct DebugEventBuilder { typedef DebugEvent Table; ::flatbuffers::FlatBufferBuilder &fbb_; @@ -595,6 +1029,125 @@ inline ::flatbuffers::Offset CreateRunRequest(::flatbuffers::FlatBuf _single_step); } +inline WriteMemoryRequestT *WriteMemoryRequest::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new WriteMemoryRequestT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void WriteMemoryRequest::UnPackTo(WriteMemoryRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = address(); _o->address = _e; } + { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } } +} + +inline ::flatbuffers::Offset WriteMemoryRequest::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteMemoryRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { + return CreateWriteMemoryRequest(_fbb, _o, _rehasher); +} + +inline ::flatbuffers::Offset CreateWriteMemoryRequest(::flatbuffers::FlatBufferBuilder &_fbb, const WriteMemoryRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const WriteMemoryRequestT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _address = _o->address; + auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0; + return Debugger::CreateWriteMemoryRequest( + _fbb, + _address, + _data); +} + +inline WriteMemoryResponseT *WriteMemoryResponse::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new WriteMemoryResponseT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void WriteMemoryResponse::UnPackTo(WriteMemoryResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = address(); _o->address = _e; } + { auto _e = size(); _o->size = _e; } + { auto _e = success(); _o->success = _e; } +} + +inline ::flatbuffers::Offset WriteMemoryResponse::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteMemoryResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { + return CreateWriteMemoryResponse(_fbb, _o, _rehasher); +} + +inline ::flatbuffers::Offset CreateWriteMemoryResponse(::flatbuffers::FlatBufferBuilder &_fbb, const WriteMemoryResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const WriteMemoryResponseT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _address = _o->address; + auto _size = _o->size; + auto _success = _o->success; + return Debugger::CreateWriteMemoryResponse( + _fbb, + _address, + _size, + _success); +} + +inline ReadMemoryRequestT *ReadMemoryRequest::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ReadMemoryRequestT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void ReadMemoryRequest::UnPackTo(ReadMemoryRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = address(); _o->address = _e; } + { auto _e = size(); _o->size = _e; } +} + +inline ::flatbuffers::Offset ReadMemoryRequest::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadMemoryRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { + return CreateReadMemoryRequest(_fbb, _o, _rehasher); +} + +inline ::flatbuffers::Offset CreateReadMemoryRequest(::flatbuffers::FlatBufferBuilder &_fbb, const ReadMemoryRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReadMemoryRequestT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _address = _o->address; + auto _size = _o->size; + return Debugger::CreateReadMemoryRequest( + _fbb, + _address, + _size); +} + +inline ReadMemoryResponseT *ReadMemoryResponse::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ReadMemoryResponseT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void ReadMemoryResponse::UnPackTo(ReadMemoryResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = address(); _o->address = _e; } + { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } } +} + +inline ::flatbuffers::Offset ReadMemoryResponse::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadMemoryResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { + return CreateReadMemoryResponse(_fbb, _o, _rehasher); +} + +inline ::flatbuffers::Offset CreateReadMemoryResponse(::flatbuffers::FlatBufferBuilder &_fbb, const ReadMemoryResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReadMemoryResponseT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _address = _o->address; + auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0; + return Debugger::CreateReadMemoryResponse( + _fbb, + _address, + _data); +} + inline DebugEventT *DebugEvent::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new DebugEventT()); UnPackTo(_o.get(), _resolver); @@ -645,6 +1198,22 @@ inline bool VerifyEvent(::flatbuffers::Verifier &verifier, const void *obj, Even auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } + case Event_WriteMemoryRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Event_WriteMemoryResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Event_ReadMemoryRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Event_ReadMemoryResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } default: return true; } } @@ -680,6 +1249,22 @@ inline void *EventUnion::UnPack(const void *obj, Event type, const ::flatbuffers auto ptr = reinterpret_cast(obj); return ptr->UnPack(resolver); } + case Event_WriteMemoryRequest: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Event_WriteMemoryResponse: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Event_ReadMemoryRequest: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Event_ReadMemoryResponse: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } default: return nullptr; } } @@ -703,6 +1288,22 @@ inline ::flatbuffers::Offset EventUnion::Pack(::flatbuffers::FlatBufferBui auto ptr = reinterpret_cast(value); return CreateGetStateResponse(_fbb, ptr, _rehasher).Union(); } + case Event_WriteMemoryRequest: { + auto ptr = reinterpret_cast(value); + return CreateWriteMemoryRequest(_fbb, ptr, _rehasher).Union(); + } + case Event_WriteMemoryResponse: { + auto ptr = reinterpret_cast(value); + return CreateWriteMemoryResponse(_fbb, ptr, _rehasher).Union(); + } + case Event_ReadMemoryRequest: { + auto ptr = reinterpret_cast(value); + return CreateReadMemoryRequest(_fbb, ptr, _rehasher).Union(); + } + case Event_ReadMemoryResponse: { + auto ptr = reinterpret_cast(value); + return CreateReadMemoryResponse(_fbb, ptr, _rehasher).Union(); + } default: return 0; } } @@ -725,6 +1326,22 @@ inline EventUnion::EventUnion(const EventUnion &u) : type(u.type), value(nullptr value = new Debugger::GetStateResponseT(*reinterpret_cast(u.value)); break; } + case Event_WriteMemoryRequest: { + value = new Debugger::WriteMemoryRequestT(*reinterpret_cast(u.value)); + break; + } + case Event_WriteMemoryResponse: { + value = new Debugger::WriteMemoryResponseT(*reinterpret_cast(u.value)); + break; + } + case Event_ReadMemoryRequest: { + value = new Debugger::ReadMemoryRequestT(*reinterpret_cast(u.value)); + break; + } + case Event_ReadMemoryResponse: { + value = new Debugger::ReadMemoryResponseT(*reinterpret_cast(u.value)); + break; + } default: break; } @@ -752,6 +1369,26 @@ inline void EventUnion::Reset() { delete ptr; break; } + case Event_WriteMemoryRequest: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Event_WriteMemoryResponse: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Event_ReadMemoryRequest: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Event_ReadMemoryResponse: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } default: break; } value = nullptr;