Support reading and writing memory

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';

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<DebugEventT> {
@@ -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
 ){}
 
 

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;
   }
 }

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<ReadMemoryRequestT> {
+  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
+  );
+}
+}

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<ReadMemoryResponseT> {
+  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<number>(this.data.bind(this), this.dataLength())
+  );
+}
+
+
+unpackTo(_o: ReadMemoryResponseT): void {
+  _o.address = this.address();
+  _o.data = this.bb!.createScalarList<number>(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
+  );
+}
+}

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<WriteMemoryRequestT> {
+  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<number>(this.data.bind(this), this.dataLength())
+  );
+}
+
+
+unpackTo(_o: WriteMemoryRequestT): void {
+  _o.address = this.address();
+  _o.data = this.bb!.createScalarList<number>(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
+  );
+}
+}

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<WriteMemoryResponseT> {
+  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
+  );
+}
+}

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<uint8_t> 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<uint32_t>(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:

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 {

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<size_t>(e);
   return EnumNamesEvent()[index];
 }
@@ -127,6 +155,22 @@ template<> struct EventTraits<Debugger::GetStateResponse> {
   static const Event enum_value = Event_GetStateResponse;
 };
 
+template<> struct EventTraits<Debugger::WriteMemoryRequest> {
+  static const Event enum_value = Event_WriteMemoryRequest;
+};
+
+template<> struct EventTraits<Debugger::WriteMemoryResponse> {
+  static const Event enum_value = Event_WriteMemoryResponse;
+};
+
+template<> struct EventTraits<Debugger::ReadMemoryRequest> {
+  static const Event enum_value = Event_ReadMemoryRequest;
+};
+
+template<> struct EventTraits<Debugger::ReadMemoryResponse> {
+  static const Event enum_value = Event_ReadMemoryResponse;
+};
+
 template<typename T> struct EventUnionTraits {
   static const Event enum_value = Event_NONE;
 };
@@ -147,6 +191,22 @@ template<> struct EventUnionTraits<Debugger::GetStateResponseT> {
   static const Event enum_value = Event_GetStateResponse;
 };
 
+template<> struct EventUnionTraits<Debugger::WriteMemoryRequestT> {
+  static const Event enum_value = Event_WriteMemoryRequest;
+};
+
+template<> struct EventUnionTraits<Debugger::WriteMemoryResponseT> {
+  static const Event enum_value = Event_WriteMemoryResponse;
+};
+
+template<> struct EventUnionTraits<Debugger::ReadMemoryRequestT> {
+  static const Event enum_value = Event_ReadMemoryRequest;
+};
+
+template<> struct EventUnionTraits<Debugger::ReadMemoryResponseT> {
+  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<const Debugger::GetStateResponseT *>(value) : nullptr;
   }
+  Debugger::WriteMemoryRequestT *AsWriteMemoryRequest() {
+    return type == Event_WriteMemoryRequest ?
+      reinterpret_cast<Debugger::WriteMemoryRequestT *>(value) : nullptr;
+  }
+  const Debugger::WriteMemoryRequestT *AsWriteMemoryRequest() const {
+    return type == Event_WriteMemoryRequest ?
+      reinterpret_cast<const Debugger::WriteMemoryRequestT *>(value) : nullptr;
+  }
+  Debugger::WriteMemoryResponseT *AsWriteMemoryResponse() {
+    return type == Event_WriteMemoryResponse ?
+      reinterpret_cast<Debugger::WriteMemoryResponseT *>(value) : nullptr;
+  }
+  const Debugger::WriteMemoryResponseT *AsWriteMemoryResponse() const {
+    return type == Event_WriteMemoryResponse ?
+      reinterpret_cast<const Debugger::WriteMemoryResponseT *>(value) : nullptr;
+  }
+  Debugger::ReadMemoryRequestT *AsReadMemoryRequest() {
+    return type == Event_ReadMemoryRequest ?
+      reinterpret_cast<Debugger::ReadMemoryRequestT *>(value) : nullptr;
+  }
+  const Debugger::ReadMemoryRequestT *AsReadMemoryRequest() const {
+    return type == Event_ReadMemoryRequest ?
+      reinterpret_cast<const Debugger::ReadMemoryRequestT *>(value) : nullptr;
+  }
+  Debugger::ReadMemoryResponseT *AsReadMemoryResponse() {
+    return type == Event_ReadMemoryResponse ?
+      reinterpret_cast<Debugger::ReadMemoryResponseT *>(value) : nullptr;
+  }
+  const Debugger::ReadMemoryResponseT *AsReadMemoryResponse() const {
+    return type == Event_ReadMemoryResponse ?
+      reinterpret_cast<const Debugger::ReadMemoryResponseT *>(value) : nullptr;
+  }
 };
 
 bool VerifyEvent(::flatbuffers::Verifier &verifier, const void *obj, Event type);
@@ -402,6 +494,320 @@ inline ::flatbuffers::Offset<RunRequest> CreateRunRequest(
 
 ::flatbuffers::Offset<RunRequest> 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<uint8_t> 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<uint64_t>(VT_ADDRESS, 0);
+  }
+  bool mutate_address(uint64_t _address = 0) {
+    return SetField<uint64_t>(VT_ADDRESS, _address, 0);
+  }
+  const ::flatbuffers::Vector<uint8_t> *data() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
+  }
+  ::flatbuffers::Vector<uint8_t> *mutable_data() {
+    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_DATA);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint64_t>(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<WriteMemoryRequest> 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<uint64_t>(WriteMemoryRequest::VT_ADDRESS, address, 0);
+  }
+  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
+    fbb_.AddOffset(WriteMemoryRequest::VT_DATA, data);
+  }
+  explicit WriteMemoryRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<WriteMemoryRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<WriteMemoryRequest>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<WriteMemoryRequest> CreateWriteMemoryRequest(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint64_t address = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
+  WriteMemoryRequestBuilder builder_(_fbb);
+  builder_.add_address(address);
+  builder_.add_data(data);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<WriteMemoryRequest> CreateWriteMemoryRequestDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint64_t address = 0,
+    const std::vector<uint8_t> *data = nullptr) {
+  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
+  return Debugger::CreateWriteMemoryRequest(
+      _fbb,
+      address,
+      data__);
+}
+
+::flatbuffers::Offset<WriteMemoryRequest> 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<uint64_t>(VT_ADDRESS, 0);
+  }
+  bool mutate_address(uint64_t _address = 0) {
+    return SetField<uint64_t>(VT_ADDRESS, _address, 0);
+  }
+  uint32_t size() const {
+    return GetField<uint32_t>(VT_SIZE, 0);
+  }
+  bool mutate_size(uint32_t _size = 0) {
+    return SetField<uint32_t>(VT_SIZE, _size, 0);
+  }
+  bool success() const {
+    return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
+  }
+  bool mutate_success(bool _success = 0) {
+    return SetField<uint8_t>(VT_SUCCESS, static_cast<uint8_t>(_success), 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint64_t>(verifier, VT_ADDRESS, 8) &&
+           VerifyField<uint32_t>(verifier, VT_SIZE, 4) &&
+           VerifyField<uint8_t>(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<WriteMemoryResponse> 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<uint64_t>(WriteMemoryResponse::VT_ADDRESS, address, 0);
+  }
+  void add_size(uint32_t size) {
+    fbb_.AddElement<uint32_t>(WriteMemoryResponse::VT_SIZE, size, 0);
+  }
+  void add_success(bool success) {
+    fbb_.AddElement<uint8_t>(WriteMemoryResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
+  }
+  explicit WriteMemoryResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<WriteMemoryResponse> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<WriteMemoryResponse>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<WriteMemoryResponse> 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<WriteMemoryResponse> 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<uint64_t>(VT_ADDRESS, 0);
+  }
+  bool mutate_address(uint64_t _address = 0) {
+    return SetField<uint64_t>(VT_ADDRESS, _address, 0);
+  }
+  uint32_t size() const {
+    return GetField<uint32_t>(VT_SIZE, 0);
+  }
+  bool mutate_size(uint32_t _size = 0) {
+    return SetField<uint32_t>(VT_SIZE, _size, 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint64_t>(verifier, VT_ADDRESS, 8) &&
+           VerifyField<uint32_t>(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<ReadMemoryRequest> 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<uint64_t>(ReadMemoryRequest::VT_ADDRESS, address, 0);
+  }
+  void add_size(uint32_t size) {
+    fbb_.AddElement<uint32_t>(ReadMemoryRequest::VT_SIZE, size, 0);
+  }
+  explicit ReadMemoryRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<ReadMemoryRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<ReadMemoryRequest>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<ReadMemoryRequest> 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<ReadMemoryRequest> 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<uint8_t> 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<uint64_t>(VT_ADDRESS, 0);
+  }
+  bool mutate_address(uint64_t _address = 0) {
+    return SetField<uint64_t>(VT_ADDRESS, _address, 0);
+  }
+  const ::flatbuffers::Vector<uint8_t> *data() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
+  }
+  ::flatbuffers::Vector<uint8_t> *mutable_data() {
+    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_DATA);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint64_t>(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<ReadMemoryResponse> 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<uint64_t>(ReadMemoryResponse::VT_ADDRESS, address, 0);
+  }
+  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
+    fbb_.AddOffset(ReadMemoryResponse::VT_DATA, data);
+  }
+  explicit ReadMemoryResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<ReadMemoryResponse> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<ReadMemoryResponse>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<ReadMemoryResponse> CreateReadMemoryResponse(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint64_t address = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
+  ReadMemoryResponseBuilder builder_(_fbb);
+  builder_.add_address(address);
+  builder_.add_data(data);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<ReadMemoryResponse> CreateReadMemoryResponseDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint64_t address = 0,
+    const std::vector<uint8_t> *data = nullptr) {
+  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
+  return Debugger::CreateReadMemoryResponse(
+      _fbb,
+      address,
+      data__);
+}
+
+::flatbuffers::Offset<ReadMemoryResponse> 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<const Debugger::GetStateResponse *>(event()) : nullptr;
   }
+  const Debugger::WriteMemoryRequest *event_as_WriteMemoryRequest() const {
+    return event_type() == Debugger::Event_WriteMemoryRequest ? static_cast<const Debugger::WriteMemoryRequest *>(event()) : nullptr;
+  }
+  const Debugger::WriteMemoryResponse *event_as_WriteMemoryResponse() const {
+    return event_type() == Debugger::Event_WriteMemoryResponse ? static_cast<const Debugger::WriteMemoryResponse *>(event()) : nullptr;
+  }
+  const Debugger::ReadMemoryRequest *event_as_ReadMemoryRequest() const {
+    return event_type() == Debugger::Event_ReadMemoryRequest ? static_cast<const Debugger::ReadMemoryRequest *>(event()) : nullptr;
+  }
+  const Debugger::ReadMemoryResponse *event_as_ReadMemoryResponse() const {
+    return event_type() == Debugger::Event_ReadMemoryResponse ? static_cast<const Debugger::ReadMemoryResponse *>(event()) : nullptr;
+  }
   void *mutable_event() {
     return GetPointer<void *>(VT_EVENT);
   }
@@ -464,6 +882,22 @@ template<> inline const Debugger::GetStateResponse *DebugEvent::event_as<Debugge
   return event_as_GetStateResponse();
 }
 
+template<> inline const Debugger::WriteMemoryRequest *DebugEvent::event_as<Debugger::WriteMemoryRequest>() const {
+  return event_as_WriteMemoryRequest();
+}
+
+template<> inline const Debugger::WriteMemoryResponse *DebugEvent::event_as<Debugger::WriteMemoryResponse>() const {
+  return event_as_WriteMemoryResponse();
+}
+
+template<> inline const Debugger::ReadMemoryRequest *DebugEvent::event_as<Debugger::ReadMemoryRequest>() const {
+  return event_as_ReadMemoryRequest();
+}
+
+template<> inline const Debugger::ReadMemoryResponse *DebugEvent::event_as<Debugger::ReadMemoryResponse>() const {
+  return event_as_ReadMemoryResponse();
+}
+
 struct DebugEventBuilder {
   typedef DebugEvent Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;
@@ -595,6 +1029,125 @@ inline ::flatbuffers::Offset<RunRequest> CreateRunRequest(::flatbuffers::FlatBuf
       _single_step);
 }
 
+inline WriteMemoryRequestT *WriteMemoryRequest::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::unique_ptr<WriteMemoryRequestT>(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> WriteMemoryRequest::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteMemoryRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateWriteMemoryRequest(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<WriteMemoryRequest> 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<WriteMemoryResponseT>(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> WriteMemoryResponse::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteMemoryResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateWriteMemoryResponse(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<WriteMemoryResponse> 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<ReadMemoryRequestT>(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> ReadMemoryRequest::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadMemoryRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateReadMemoryRequest(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<ReadMemoryRequest> 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<ReadMemoryResponseT>(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> ReadMemoryResponse::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadMemoryResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateReadMemoryResponse(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<ReadMemoryResponse> 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<DebugEventT>(new DebugEventT());
   UnPackTo(_o.get(), _resolver);
@@ -645,6 +1198,22 @@ inline bool VerifyEvent(::flatbuffers::Verifier &verifier, const void *obj, Even
       auto ptr = reinterpret_cast<const Debugger::GetStateResponse *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case Event_WriteMemoryRequest: {
+      auto ptr = reinterpret_cast<const Debugger::WriteMemoryRequest *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Event_WriteMemoryResponse: {
+      auto ptr = reinterpret_cast<const Debugger::WriteMemoryResponse *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Event_ReadMemoryRequest: {
+      auto ptr = reinterpret_cast<const Debugger::ReadMemoryRequest *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Event_ReadMemoryResponse: {
+      auto ptr = reinterpret_cast<const Debugger::ReadMemoryResponse *>(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<const Debugger::GetStateResponse *>(obj);
       return ptr->UnPack(resolver);
     }
+    case Event_WriteMemoryRequest: {
+      auto ptr = reinterpret_cast<const Debugger::WriteMemoryRequest *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    case Event_WriteMemoryResponse: {
+      auto ptr = reinterpret_cast<const Debugger::WriteMemoryResponse *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    case Event_ReadMemoryRequest: {
+      auto ptr = reinterpret_cast<const Debugger::ReadMemoryRequest *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    case Event_ReadMemoryResponse: {
+      auto ptr = reinterpret_cast<const Debugger::ReadMemoryResponse *>(obj);
+      return ptr->UnPack(resolver);
+    }
     default: return nullptr;
   }
 }
@@ -703,6 +1288,22 @@ inline ::flatbuffers::Offset<void> EventUnion::Pack(::flatbuffers::FlatBufferBui
       auto ptr = reinterpret_cast<const Debugger::GetStateResponseT *>(value);
       return CreateGetStateResponse(_fbb, ptr, _rehasher).Union();
     }
+    case Event_WriteMemoryRequest: {
+      auto ptr = reinterpret_cast<const Debugger::WriteMemoryRequestT *>(value);
+      return CreateWriteMemoryRequest(_fbb, ptr, _rehasher).Union();
+    }
+    case Event_WriteMemoryResponse: {
+      auto ptr = reinterpret_cast<const Debugger::WriteMemoryResponseT *>(value);
+      return CreateWriteMemoryResponse(_fbb, ptr, _rehasher).Union();
+    }
+    case Event_ReadMemoryRequest: {
+      auto ptr = reinterpret_cast<const Debugger::ReadMemoryRequestT *>(value);
+      return CreateReadMemoryRequest(_fbb, ptr, _rehasher).Union();
+    }
+    case Event_ReadMemoryResponse: {
+      auto ptr = reinterpret_cast<const Debugger::ReadMemoryResponseT *>(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<Debugger::GetStateResponseT *>(u.value));
       break;
     }
+    case Event_WriteMemoryRequest: {
+      value = new Debugger::WriteMemoryRequestT(*reinterpret_cast<Debugger::WriteMemoryRequestT *>(u.value));
+      break;
+    }
+    case Event_WriteMemoryResponse: {
+      value = new Debugger::WriteMemoryResponseT(*reinterpret_cast<Debugger::WriteMemoryResponseT *>(u.value));
+      break;
+    }
+    case Event_ReadMemoryRequest: {
+      value = new Debugger::ReadMemoryRequestT(*reinterpret_cast<Debugger::ReadMemoryRequestT *>(u.value));
+      break;
+    }
+    case Event_ReadMemoryResponse: {
+      value = new Debugger::ReadMemoryResponseT(*reinterpret_cast<Debugger::ReadMemoryResponseT *>(u.value));
+      break;
+    }
     default:
       break;
   }
@@ -752,6 +1369,26 @@ inline void EventUnion::Reset() {
       delete ptr;
       break;
     }
+    case Event_WriteMemoryRequest: {
+      auto ptr = reinterpret_cast<Debugger::WriteMemoryRequestT *>(value);
+      delete ptr;
+      break;
+    }
+    case Event_WriteMemoryResponse: {
+      auto ptr = reinterpret_cast<Debugger::WriteMemoryResponseT *>(value);
+      delete ptr;
+      break;
+    }
+    case Event_ReadMemoryRequest: {
+      auto ptr = reinterpret_cast<Debugger::ReadMemoryRequestT *>(value);
+      delete ptr;
+      break;
+    }
+    case Event_ReadMemoryResponse: {
+      auto ptr = reinterpret_cast<Debugger::ReadMemoryResponseT *>(value);
+      delete ptr;
+      break;
+    }
     default: break;
   }
   value = nullptr;