Support reading registers

page/src/fb/debugger.ts

@@ -9,7 +9,11 @@ export { GetStateResponse, GetStateResponseT } from './debugger/get-state-respon
 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 { ReadRegisterRequest, ReadRegisterRequestT } from './debugger/read-register-request.js';
+export { ReadRegisterResponse, ReadRegisterResponseT } from './debugger/read-register-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';
+export { WriteRegisterRequest, WriteRegisterRequestT } from './debugger/write-register-request.js';
+export { WriteRegisterResponse, WriteRegisterResponseT } from './debugger/write-register-response.js';

page/src/fb/debugger/debug-event.ts

@@ -10,9 +10,13 @@ import { GetStateResponse, GetStateResponseT } from '../debugger/get-state-respo
 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 { ReadRegisterRequest, ReadRegisterRequestT } from '../debugger/read-register-request.js';
+import { ReadRegisterResponse, ReadRegisterResponseT } from '../debugger/read-register-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';
+import { WriteRegisterRequest, WriteRegisterRequestT } from '../debugger/write-register-request.js';
+import { WriteRegisterResponse, WriteRegisterResponseT } from '../debugger/write-register-response.js';
 
 
 export class DebugEvent implements flatbuffers.IUnpackableObject<DebugEventT> {
@@ -100,7 +104,7 @@ unpackTo(_o: DebugEventT): void {
 export class DebugEventT implements flatbuffers.IGeneratedObject {
 constructor(
   public eventType: Event = Event.NONE,
-  public event: GetStateRequestT|GetStateResponseT|PauseRequestT|ReadMemoryRequestT|ReadMemoryResponseT|RunRequestT|WriteMemoryRequestT|WriteMemoryResponseT|null = null
+  public event: GetStateRequestT|GetStateResponseT|PauseRequestT|ReadMemoryRequestT|ReadMemoryResponseT|ReadRegisterRequestT|ReadRegisterResponseT|RunRequestT|WriteMemoryRequestT|WriteMemoryResponseT|WriteRegisterRequestT|WriteRegisterResponseT|null = null
 ){}
 
 

page/src/fb/debugger/event.ts

@@ -7,9 +7,13 @@ import { GetStateResponse, GetStateResponseT } from '../debugger/get-state-respo
 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 { ReadRegisterRequest, ReadRegisterRequestT } from '../debugger/read-register-request.js';
+import { ReadRegisterResponse, ReadRegisterResponseT } from '../debugger/read-register-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';
+import { WriteRegisterRequest, WriteRegisterRequestT } from '../debugger/write-register-request.js';
+import { WriteRegisterResponse, WriteRegisterResponseT } from '../debugger/write-register-response.js';
 
 
 export enum Event {
@@ -21,13 +25,17 @@ export enum Event {
   WriteMemoryRequest = 5,
   WriteMemoryResponse = 6,
   ReadMemoryRequest = 7,
-  ReadMemoryResponse = 8
+  ReadMemoryResponse = 8,
+  WriteRegisterRequest = 9,
+  WriteRegisterResponse = 10,
+  ReadRegisterRequest = 11,
+  ReadRegisterResponse = 12
 }
 
 export function unionToEvent(
   type: Event,
-  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 {
+  accessor: (obj:GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|ReadRegisterRequest|ReadRegisterResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|WriteRegisterRequest|WriteRegisterResponse) => GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|ReadRegisterRequest|ReadRegisterResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|WriteRegisterRequest|WriteRegisterResponse|null
+): GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|ReadRegisterRequest|ReadRegisterResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|WriteRegisterRequest|WriteRegisterResponse|null {
   switch(Event[type]) {
     case 'NONE': return null; 
     case 'PauseRequest': return accessor(new PauseRequest())! as PauseRequest;
@@ -38,15 +46,19 @@ export function unionToEvent(
     case 'WriteMemoryResponse': return accessor(new WriteMemoryResponse())! as WriteMemoryResponse;
     case 'ReadMemoryRequest': return accessor(new ReadMemoryRequest())! as ReadMemoryRequest;
     case 'ReadMemoryResponse': return accessor(new ReadMemoryResponse())! as ReadMemoryResponse;
+    case 'WriteRegisterRequest': return accessor(new WriteRegisterRequest())! as WriteRegisterRequest;
+    case 'WriteRegisterResponse': return accessor(new WriteRegisterResponse())! as WriteRegisterResponse;
+    case 'ReadRegisterRequest': return accessor(new ReadRegisterRequest())! as ReadRegisterRequest;
+    case 'ReadRegisterResponse': return accessor(new ReadRegisterResponse())! as ReadRegisterResponse;
     default: return null;
   }
 }
 
 export function unionListToEvent(
   type: Event, 
-  accessor: (index: number, obj:GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse) => GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|null, 
+  accessor: (index: number, obj:GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|ReadRegisterRequest|ReadRegisterResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|WriteRegisterRequest|WriteRegisterResponse) => GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|ReadRegisterRequest|ReadRegisterResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|WriteRegisterRequest|WriteRegisterResponse|null, 
   index: number
-): GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|null {
+): GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|ReadRegisterRequest|ReadRegisterResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|WriteRegisterRequest|WriteRegisterResponse|null {
   switch(Event[type]) {
     case 'NONE': return null; 
     case 'PauseRequest': return accessor(index, new PauseRequest())! as PauseRequest;
@@ -57,6 +69,10 @@ export function unionListToEvent(
     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;
+    case 'WriteRegisterRequest': return accessor(index, new WriteRegisterRequest())! as WriteRegisterRequest;
+    case 'WriteRegisterResponse': return accessor(index, new WriteRegisterResponse())! as WriteRegisterResponse;
+    case 'ReadRegisterRequest': return accessor(index, new ReadRegisterRequest())! as ReadRegisterRequest;
+    case 'ReadRegisterResponse': return accessor(index, new ReadRegisterResponse())! as ReadRegisterResponse;
     default: return null;
   }
 }

page/src/fb/debugger/read-register-request.ts

@@ -0,0 +1,85 @@
+// 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 ReadRegisterRequest implements flatbuffers.IUnpackableObject<ReadRegisterRequestT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):ReadRegisterRequest {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsReadRegisterRequest(bb:flatbuffers.ByteBuffer, obj?:ReadRegisterRequest):ReadRegisterRequest {
+  return (obj || new ReadRegisterRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsReadRegisterRequest(bb:flatbuffers.ByteBuffer, obj?:ReadRegisterRequest):ReadRegisterRequest {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new ReadRegisterRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+register():number {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;
+}
+
+mutate_register(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeUint32(this.bb_pos + offset, value);
+  return true;
+}
+
+static startReadRegisterRequest(builder:flatbuffers.Builder) {
+  builder.startObject(1);
+}
+
+static addRegister(builder:flatbuffers.Builder, register:number) {
+  builder.addFieldInt32(0, register, 0);
+}
+
+static endReadRegisterRequest(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createReadRegisterRequest(builder:flatbuffers.Builder, register:number):flatbuffers.Offset {
+  ReadRegisterRequest.startReadRegisterRequest(builder);
+  ReadRegisterRequest.addRegister(builder, register);
+  return ReadRegisterRequest.endReadRegisterRequest(builder);
+}
+
+unpack(): ReadRegisterRequestT {
+  return new ReadRegisterRequestT(
+    this.register()
+  );
+}
+
+
+unpackTo(_o: ReadRegisterRequestT): void {
+  _o.register = this.register();
+}
+}
+
+export class ReadRegisterRequestT implements flatbuffers.IGeneratedObject {
+constructor(
+  public register: number = 0
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  return ReadRegisterRequest.createReadRegisterRequest(builder,
+    this.register
+  );
+}
+}

page/src/fb/debugger/read-register-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 ReadRegisterResponse implements flatbuffers.IUnpackableObject<ReadRegisterResponseT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):ReadRegisterResponse {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsReadRegisterResponse(bb:flatbuffers.ByteBuffer, obj?:ReadRegisterResponse):ReadRegisterResponse {
+  return (obj || new ReadRegisterResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsReadRegisterResponse(bb:flatbuffers.ByteBuffer, obj?:ReadRegisterResponse):ReadRegisterResponse {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new ReadRegisterResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+register():number {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;
+}
+
+mutate_register(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeUint32(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 startReadRegisterResponse(builder:flatbuffers.Builder) {
+  builder.startObject(2);
+}
+
+static addRegister(builder:flatbuffers.Builder, register:number) {
+  builder.addFieldInt32(0, register, 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 endReadRegisterResponse(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createReadRegisterResponse(builder:flatbuffers.Builder, register:number, dataOffset:flatbuffers.Offset):flatbuffers.Offset {
+  ReadRegisterResponse.startReadRegisterResponse(builder);
+  ReadRegisterResponse.addRegister(builder, register);
+  ReadRegisterResponse.addData(builder, dataOffset);
+  return ReadRegisterResponse.endReadRegisterResponse(builder);
+}
+
+unpack(): ReadRegisterResponseT {
+  return new ReadRegisterResponseT(
+    this.register(),
+    this.bb!.createScalarList<number>(this.data.bind(this), this.dataLength())
+  );
+}
+
+
+unpackTo(_o: ReadRegisterResponseT): void {
+  _o.register = this.register();
+  _o.data = this.bb!.createScalarList<number>(this.data.bind(this), this.dataLength());
+}
+}
+
+export class ReadRegisterResponseT implements flatbuffers.IGeneratedObject {
+constructor(
+  public register: number = 0,
+  public data: (number)[] = []
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  const data = ReadRegisterResponse.createDataVector(builder, this.data);
+
+  return ReadRegisterResponse.createReadRegisterResponse(builder,
+    this.register,
+    data
+  );
+}
+}

page/src/fb/debugger/write-register-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 WriteRegisterRequest implements flatbuffers.IUnpackableObject<WriteRegisterRequestT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):WriteRegisterRequest {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsWriteRegisterRequest(bb:flatbuffers.ByteBuffer, obj?:WriteRegisterRequest):WriteRegisterRequest {
+  return (obj || new WriteRegisterRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsWriteRegisterRequest(bb:flatbuffers.ByteBuffer, obj?:WriteRegisterRequest):WriteRegisterRequest {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new WriteRegisterRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+register():number {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;
+}
+
+mutate_register(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeUint32(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 startWriteRegisterRequest(builder:flatbuffers.Builder) {
+  builder.startObject(2);
+}
+
+static addRegister(builder:flatbuffers.Builder, register:number) {
+  builder.addFieldInt32(0, register, 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 endWriteRegisterRequest(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createWriteRegisterRequest(builder:flatbuffers.Builder, register:number, dataOffset:flatbuffers.Offset):flatbuffers.Offset {
+  WriteRegisterRequest.startWriteRegisterRequest(builder);
+  WriteRegisterRequest.addRegister(builder, register);
+  WriteRegisterRequest.addData(builder, dataOffset);
+  return WriteRegisterRequest.endWriteRegisterRequest(builder);
+}
+
+unpack(): WriteRegisterRequestT {
+  return new WriteRegisterRequestT(
+    this.register(),
+    this.bb!.createScalarList<number>(this.data.bind(this), this.dataLength())
+  );
+}
+
+
+unpackTo(_o: WriteRegisterRequestT): void {
+  _o.register = this.register();
+  _o.data = this.bb!.createScalarList<number>(this.data.bind(this), this.dataLength());
+}
+}
+
+export class WriteRegisterRequestT implements flatbuffers.IGeneratedObject {
+constructor(
+  public register: number = 0,
+  public data: (number)[] = []
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  const data = WriteRegisterRequest.createDataVector(builder, this.data);
+
+  return WriteRegisterRequest.createWriteRegisterRequest(builder,
+    this.register,
+    data
+  );
+}
+}

page/src/fb/debugger/write-register-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 WriteRegisterResponse implements flatbuffers.IUnpackableObject<WriteRegisterResponseT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):WriteRegisterResponse {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsWriteRegisterResponse(bb:flatbuffers.ByteBuffer, obj?:WriteRegisterResponse):WriteRegisterResponse {
+  return (obj || new WriteRegisterResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsWriteRegisterResponse(bb:flatbuffers.ByteBuffer, obj?:WriteRegisterResponse):WriteRegisterResponse {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new WriteRegisterResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+register():number {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;
+}
+
+mutate_register(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeUint32(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 startWriteRegisterResponse(builder:flatbuffers.Builder) {
+  builder.startObject(3);
+}
+
+static addRegister(builder:flatbuffers.Builder, register:number) {
+  builder.addFieldInt32(0, register, 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 endWriteRegisterResponse(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createWriteRegisterResponse(builder:flatbuffers.Builder, register:number, size:number, success:boolean):flatbuffers.Offset {
+  WriteRegisterResponse.startWriteRegisterResponse(builder);
+  WriteRegisterResponse.addRegister(builder, register);
+  WriteRegisterResponse.addSize(builder, size);
+  WriteRegisterResponse.addSuccess(builder, success);
+  return WriteRegisterResponse.endWriteRegisterResponse(builder);
+}
+
+unpack(): WriteRegisterResponseT {
+  return new WriteRegisterResponseT(
+    this.register(),
+    this.size(),
+    this.success()
+  );
+}
+
+
+unpackTo(_o: WriteRegisterResponseT): void {
+  _o.register = this.register();
+  _o.size = this.size();
+  _o.success = this.success();
+}
+}
+
+export class WriteRegisterResponseT implements flatbuffers.IGeneratedObject {
+constructor(
+  public register: number = 0,
+  public size: number = 0,
+  public success: boolean = false
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  return WriteRegisterResponse.createWriteRegisterResponse(builder,
+    this.register,
+    this.size,
+    this.success
+  );
+}
+}

src/debugger/event_handler.cpp

@@ -123,6 +123,45 @@ namespace debugger
             send_event(response);
         }
 
+        void handle_read_register(const event_context& c, const Debugger::ReadRegisterRequestT& request)
+        {
+            uint8_t buffer[512]{};
+            const auto res =
+                c.win_emu.emu().read_register(static_cast<x86_register>(request.register_), buffer, sizeof(buffer));
+
+            const auto size = std::min(sizeof(buffer), res);
+
+            Debugger::ReadRegisterResponseT response{};
+            response.register_ = request.register_;
+            response.data.assign(buffer, buffer + size);
+
+            send_event(std::move(response));
+        }
+
+        void handle_write_register(const event_context& c, const Debugger::WriteRegisterRequestT& request)
+        {
+            bool success{};
+            size_t size = request.data.size();
+
+            try
+            {
+                size = c.win_emu.emu().write_register(static_cast<x86_register>(request.register_), request.data.data(),
+                                                      request.data.size());
+                success = true;
+            }
+            catch (...)
+            {
+                success = false;
+            }
+
+            Debugger::WriteRegisterResponseT response{};
+            response.register_ = request.register_;
+            response.size = static_cast<uint32_t>(size);
+            response.success = success;
+
+            send_event(response);
+        }
+
         void handle_event(event_context& c, const Debugger::DebugEventT& e)
         {
             switch (e.event.type)
@@ -147,6 +186,14 @@ namespace debugger
                 handle_write_memory(c, *e.event.AsWriteMemoryRequest());
                 break;
 
+            case Debugger::Event_ReadRegisterRequest:
+                handle_read_register(c, *e.event.AsReadRegisterRequest());
+                break;
+
+            case Debugger::Event_WriteRegisterRequest:
+                handle_write_register(c, *e.event.AsWriteRegisterRequest());
+                break;
+
             default:
                 break;
             }

src/debugger/events.fbs

@@ -39,6 +39,26 @@ table ReadMemoryResponse {
     data: [ubyte];
 }
 
+table WriteRegisterRequest {
+    register: uint32;
+    data: [ubyte];
+}
+
+table WriteRegisterResponse {
+    register: uint32;
+    size: uint32;
+    success: bool;
+}
+
+table ReadRegisterRequest {
+    register: uint32;
+}
+
+table ReadRegisterResponse {
+    register: uint32;
+    data: [ubyte];
+}
+
 union Event { 
     PauseRequest, 
     RunRequest,
@@ -48,6 +68,10 @@ union Event {
     WriteMemoryResponse,
     ReadMemoryRequest,
     ReadMemoryResponse,
+    WriteRegisterRequest,
+    WriteRegisterResponse,
+    ReadRegisterRequest,
+    ReadRegisterResponse,
 }
 
 table DebugEvent {

src/debugger/events_generated.hxx

@@ -47,6 +47,22 @@ struct ReadMemoryResponse;
 struct ReadMemoryResponseBuilder;
 struct ReadMemoryResponseT;
 
+struct WriteRegisterRequest;
+struct WriteRegisterRequestBuilder;
+struct WriteRegisterRequestT;
+
+struct WriteRegisterResponse;
+struct WriteRegisterResponseBuilder;
+struct WriteRegisterResponseT;
+
+struct ReadRegisterRequest;
+struct ReadRegisterRequestBuilder;
+struct ReadRegisterRequestT;
+
+struct ReadRegisterResponse;
+struct ReadRegisterResponseBuilder;
+struct ReadRegisterResponseT;
+
 struct DebugEvent;
 struct DebugEventBuilder;
 struct DebugEventT;
@@ -94,11 +110,15 @@ enum Event : uint8_t {
   Event_WriteMemoryResponse = 6,
   Event_ReadMemoryRequest = 7,
   Event_ReadMemoryResponse = 8,
+  Event_WriteRegisterRequest = 9,
+  Event_WriteRegisterResponse = 10,
+  Event_ReadRegisterRequest = 11,
+  Event_ReadRegisterResponse = 12,
   Event_MIN = Event_NONE,
-  Event_MAX = Event_ReadMemoryResponse
+  Event_MAX = Event_ReadRegisterResponse
 };
 
-inline const Event (&EnumValuesEvent())[9] {
+inline const Event (&EnumValuesEvent())[13] {
   static const Event values[] = {
     Event_NONE,
     Event_PauseRequest,
@@ -108,13 +128,17 @@ inline const Event (&EnumValuesEvent())[9] {
     Event_WriteMemoryRequest,
     Event_WriteMemoryResponse,
     Event_ReadMemoryRequest,
-    Event_ReadMemoryResponse
+    Event_ReadMemoryResponse,
+    Event_WriteRegisterRequest,
+    Event_WriteRegisterResponse,
+    Event_ReadRegisterRequest,
+    Event_ReadRegisterResponse
   };
   return values;
 }
 
 inline const char * const *EnumNamesEvent() {
-  static const char * const names[10] = {
+  static const char * const names[14] = {
     "NONE",
     "PauseRequest",
     "RunRequest",
@@ -124,13 +148,17 @@ inline const char * const *EnumNamesEvent() {
     "WriteMemoryResponse",
     "ReadMemoryRequest",
     "ReadMemoryResponse",
+    "WriteRegisterRequest",
+    "WriteRegisterResponse",
+    "ReadRegisterRequest",
+    "ReadRegisterResponse",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameEvent(Event e) {
-  if (::flatbuffers::IsOutRange(e, Event_NONE, Event_ReadMemoryResponse)) return "";
+  if (::flatbuffers::IsOutRange(e, Event_NONE, Event_ReadRegisterResponse)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesEvent()[index];
 }
@@ -171,6 +199,22 @@ template<> struct EventTraits<Debugger::ReadMemoryResponse> {
   static const Event enum_value = Event_ReadMemoryResponse;
 };
 
+template<> struct EventTraits<Debugger::WriteRegisterRequest> {
+  static const Event enum_value = Event_WriteRegisterRequest;
+};
+
+template<> struct EventTraits<Debugger::WriteRegisterResponse> {
+  static const Event enum_value = Event_WriteRegisterResponse;
+};
+
+template<> struct EventTraits<Debugger::ReadRegisterRequest> {
+  static const Event enum_value = Event_ReadRegisterRequest;
+};
+
+template<> struct EventTraits<Debugger::ReadRegisterResponse> {
+  static const Event enum_value = Event_ReadRegisterResponse;
+};
+
 template<typename T> struct EventUnionTraits {
   static const Event enum_value = Event_NONE;
 };
@@ -207,6 +251,22 @@ template<> struct EventUnionTraits<Debugger::ReadMemoryResponseT> {
   static const Event enum_value = Event_ReadMemoryResponse;
 };
 
+template<> struct EventUnionTraits<Debugger::WriteRegisterRequestT> {
+  static const Event enum_value = Event_WriteRegisterRequest;
+};
+
+template<> struct EventUnionTraits<Debugger::WriteRegisterResponseT> {
+  static const Event enum_value = Event_WriteRegisterResponse;
+};
+
+template<> struct EventUnionTraits<Debugger::ReadRegisterRequestT> {
+  static const Event enum_value = Event_ReadRegisterRequest;
+};
+
+template<> struct EventUnionTraits<Debugger::ReadRegisterResponseT> {
+  static const Event enum_value = Event_ReadRegisterResponse;
+};
+
 struct EventUnion {
   Event type;
   void *value;
@@ -301,6 +361,38 @@ struct EventUnion {
     return type == Event_ReadMemoryResponse ?
       reinterpret_cast<const Debugger::ReadMemoryResponseT *>(value) : nullptr;
   }
+  Debugger::WriteRegisterRequestT *AsWriteRegisterRequest() {
+    return type == Event_WriteRegisterRequest ?
+      reinterpret_cast<Debugger::WriteRegisterRequestT *>(value) : nullptr;
+  }
+  const Debugger::WriteRegisterRequestT *AsWriteRegisterRequest() const {
+    return type == Event_WriteRegisterRequest ?
+      reinterpret_cast<const Debugger::WriteRegisterRequestT *>(value) : nullptr;
+  }
+  Debugger::WriteRegisterResponseT *AsWriteRegisterResponse() {
+    return type == Event_WriteRegisterResponse ?
+      reinterpret_cast<Debugger::WriteRegisterResponseT *>(value) : nullptr;
+  }
+  const Debugger::WriteRegisterResponseT *AsWriteRegisterResponse() const {
+    return type == Event_WriteRegisterResponse ?
+      reinterpret_cast<const Debugger::WriteRegisterResponseT *>(value) : nullptr;
+  }
+  Debugger::ReadRegisterRequestT *AsReadRegisterRequest() {
+    return type == Event_ReadRegisterRequest ?
+      reinterpret_cast<Debugger::ReadRegisterRequestT *>(value) : nullptr;
+  }
+  const Debugger::ReadRegisterRequestT *AsReadRegisterRequest() const {
+    return type == Event_ReadRegisterRequest ?
+      reinterpret_cast<const Debugger::ReadRegisterRequestT *>(value) : nullptr;
+  }
+  Debugger::ReadRegisterResponseT *AsReadRegisterResponse() {
+    return type == Event_ReadRegisterResponse ?
+      reinterpret_cast<Debugger::ReadRegisterResponseT *>(value) : nullptr;
+  }
+  const Debugger::ReadRegisterResponseT *AsReadRegisterResponse() const {
+    return type == Event_ReadRegisterResponse ?
+      reinterpret_cast<const Debugger::ReadRegisterResponseT *>(value) : nullptr;
+  }
 };
 
 bool VerifyEvent(::flatbuffers::Verifier &verifier, const void *obj, Event type);
@@ -808,6 +900,306 @@ inline ::flatbuffers::Offset<ReadMemoryResponse> CreateReadMemoryResponseDirect(
 
 ::flatbuffers::Offset<ReadMemoryResponse> CreateReadMemoryResponse(::flatbuffers::FlatBufferBuilder &_fbb, const ReadMemoryResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
 
+struct WriteRegisterRequestT : public ::flatbuffers::NativeTable {
+  typedef WriteRegisterRequest TableType;
+  uint32_t register_ = 0;
+  std::vector<uint8_t> data{};
+};
+
+struct WriteRegisterRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef WriteRegisterRequestT NativeTableType;
+  typedef WriteRegisterRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_REGISTER_ = 4,
+    VT_DATA = 6
+  };
+  uint32_t register_() const {
+    return GetField<uint32_t>(VT_REGISTER_, 0);
+  }
+  bool mutate_register_(uint32_t _register_ = 0) {
+    return SetField<uint32_t>(VT_REGISTER_, _register_, 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<uint32_t>(verifier, VT_REGISTER_, 4) &&
+           VerifyOffset(verifier, VT_DATA) &&
+           verifier.VerifyVector(data()) &&
+           verifier.EndTable();
+  }
+  WriteRegisterRequestT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(WriteRegisterRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static ::flatbuffers::Offset<WriteRegisterRequest> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct WriteRegisterRequestBuilder {
+  typedef WriteRegisterRequest Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_register_(uint32_t register_) {
+    fbb_.AddElement<uint32_t>(WriteRegisterRequest::VT_REGISTER_, register_, 0);
+  }
+  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
+    fbb_.AddOffset(WriteRegisterRequest::VT_DATA, data);
+  }
+  explicit WriteRegisterRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<WriteRegisterRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<WriteRegisterRequest>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<WriteRegisterRequest> CreateWriteRegisterRequest(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t register_ = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
+  WriteRegisterRequestBuilder builder_(_fbb);
+  builder_.add_data(data);
+  builder_.add_register_(register_);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<WriteRegisterRequest> CreateWriteRegisterRequestDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t register_ = 0,
+    const std::vector<uint8_t> *data = nullptr) {
+  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
+  return Debugger::CreateWriteRegisterRequest(
+      _fbb,
+      register_,
+      data__);
+}
+
+::flatbuffers::Offset<WriteRegisterRequest> CreateWriteRegisterRequest(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct WriteRegisterResponseT : public ::flatbuffers::NativeTable {
+  typedef WriteRegisterResponse TableType;
+  uint32_t register_ = 0;
+  uint32_t size = 0;
+  bool success = false;
+};
+
+struct WriteRegisterResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef WriteRegisterResponseT NativeTableType;
+  typedef WriteRegisterResponseBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_REGISTER_ = 4,
+    VT_SIZE = 6,
+    VT_SUCCESS = 8
+  };
+  uint32_t register_() const {
+    return GetField<uint32_t>(VT_REGISTER_, 0);
+  }
+  bool mutate_register_(uint32_t _register_ = 0) {
+    return SetField<uint32_t>(VT_REGISTER_, _register_, 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<uint32_t>(verifier, VT_REGISTER_, 4) &&
+           VerifyField<uint32_t>(verifier, VT_SIZE, 4) &&
+           VerifyField<uint8_t>(verifier, VT_SUCCESS, 1) &&
+           verifier.EndTable();
+  }
+  WriteRegisterResponseT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(WriteRegisterResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static ::flatbuffers::Offset<WriteRegisterResponse> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct WriteRegisterResponseBuilder {
+  typedef WriteRegisterResponse Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_register_(uint32_t register_) {
+    fbb_.AddElement<uint32_t>(WriteRegisterResponse::VT_REGISTER_, register_, 0);
+  }
+  void add_size(uint32_t size) {
+    fbb_.AddElement<uint32_t>(WriteRegisterResponse::VT_SIZE, size, 0);
+  }
+  void add_success(bool success) {
+    fbb_.AddElement<uint8_t>(WriteRegisterResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
+  }
+  explicit WriteRegisterResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<WriteRegisterResponse> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<WriteRegisterResponse>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<WriteRegisterResponse> CreateWriteRegisterResponse(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t register_ = 0,
+    uint32_t size = 0,
+    bool success = false) {
+  WriteRegisterResponseBuilder builder_(_fbb);
+  builder_.add_size(size);
+  builder_.add_register_(register_);
+  builder_.add_success(success);
+  return builder_.Finish();
+}
+
+::flatbuffers::Offset<WriteRegisterResponse> CreateWriteRegisterResponse(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct ReadRegisterRequestT : public ::flatbuffers::NativeTable {
+  typedef ReadRegisterRequest TableType;
+  uint32_t register_ = 0;
+};
+
+struct ReadRegisterRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ReadRegisterRequestT NativeTableType;
+  typedef ReadRegisterRequestBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_REGISTER_ = 4
+  };
+  uint32_t register_() const {
+    return GetField<uint32_t>(VT_REGISTER_, 0);
+  }
+  bool mutate_register_(uint32_t _register_ = 0) {
+    return SetField<uint32_t>(VT_REGISTER_, _register_, 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_REGISTER_, 4) &&
+           verifier.EndTable();
+  }
+  ReadRegisterRequestT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(ReadRegisterRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static ::flatbuffers::Offset<ReadRegisterRequest> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct ReadRegisterRequestBuilder {
+  typedef ReadRegisterRequest Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_register_(uint32_t register_) {
+    fbb_.AddElement<uint32_t>(ReadRegisterRequest::VT_REGISTER_, register_, 0);
+  }
+  explicit ReadRegisterRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<ReadRegisterRequest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<ReadRegisterRequest>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<ReadRegisterRequest> CreateReadRegisterRequest(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t register_ = 0) {
+  ReadRegisterRequestBuilder builder_(_fbb);
+  builder_.add_register_(register_);
+  return builder_.Finish();
+}
+
+::flatbuffers::Offset<ReadRegisterRequest> CreateReadRegisterRequest(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct ReadRegisterResponseT : public ::flatbuffers::NativeTable {
+  typedef ReadRegisterResponse TableType;
+  uint32_t register_ = 0;
+  std::vector<uint8_t> data{};
+};
+
+struct ReadRegisterResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ReadRegisterResponseT NativeTableType;
+  typedef ReadRegisterResponseBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_REGISTER_ = 4,
+    VT_DATA = 6
+  };
+  uint32_t register_() const {
+    return GetField<uint32_t>(VT_REGISTER_, 0);
+  }
+  bool mutate_register_(uint32_t _register_ = 0) {
+    return SetField<uint32_t>(VT_REGISTER_, _register_, 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<uint32_t>(verifier, VT_REGISTER_, 4) &&
+           VerifyOffset(verifier, VT_DATA) &&
+           verifier.VerifyVector(data()) &&
+           verifier.EndTable();
+  }
+  ReadRegisterResponseT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(ReadRegisterResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static ::flatbuffers::Offset<ReadRegisterResponse> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct ReadRegisterResponseBuilder {
+  typedef ReadRegisterResponse Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_register_(uint32_t register_) {
+    fbb_.AddElement<uint32_t>(ReadRegisterResponse::VT_REGISTER_, register_, 0);
+  }
+  void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
+    fbb_.AddOffset(ReadRegisterResponse::VT_DATA, data);
+  }
+  explicit ReadRegisterResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<ReadRegisterResponse> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<ReadRegisterResponse>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<ReadRegisterResponse> CreateReadRegisterResponse(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t register_ = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
+  ReadRegisterResponseBuilder builder_(_fbb);
+  builder_.add_data(data);
+  builder_.add_register_(register_);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<ReadRegisterResponse> CreateReadRegisterResponseDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t register_ = 0,
+    const std::vector<uint8_t> *data = nullptr) {
+  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
+  return Debugger::CreateReadRegisterResponse(
+      _fbb,
+      register_,
+      data__);
+}
+
+::flatbuffers::Offset<ReadRegisterResponse> CreateReadRegisterResponse(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
 struct DebugEventT : public ::flatbuffers::NativeTable {
   typedef DebugEvent TableType;
   Debugger::EventUnion event{};
@@ -851,6 +1243,18 @@ struct DebugEvent FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const Debugger::ReadMemoryResponse *event_as_ReadMemoryResponse() const {
     return event_type() == Debugger::Event_ReadMemoryResponse ? static_cast<const Debugger::ReadMemoryResponse *>(event()) : nullptr;
   }
+  const Debugger::WriteRegisterRequest *event_as_WriteRegisterRequest() const {
+    return event_type() == Debugger::Event_WriteRegisterRequest ? static_cast<const Debugger::WriteRegisterRequest *>(event()) : nullptr;
+  }
+  const Debugger::WriteRegisterResponse *event_as_WriteRegisterResponse() const {
+    return event_type() == Debugger::Event_WriteRegisterResponse ? static_cast<const Debugger::WriteRegisterResponse *>(event()) : nullptr;
+  }
+  const Debugger::ReadRegisterRequest *event_as_ReadRegisterRequest() const {
+    return event_type() == Debugger::Event_ReadRegisterRequest ? static_cast<const Debugger::ReadRegisterRequest *>(event()) : nullptr;
+  }
+  const Debugger::ReadRegisterResponse *event_as_ReadRegisterResponse() const {
+    return event_type() == Debugger::Event_ReadRegisterResponse ? static_cast<const Debugger::ReadRegisterResponse *>(event()) : nullptr;
+  }
   void *mutable_event() {
     return GetPointer<void *>(VT_EVENT);
   }
@@ -898,6 +1302,22 @@ template<> inline const Debugger::ReadMemoryResponse *DebugEvent::event_as<Debug
   return event_as_ReadMemoryResponse();
 }
 
+template<> inline const Debugger::WriteRegisterRequest *DebugEvent::event_as<Debugger::WriteRegisterRequest>() const {
+  return event_as_WriteRegisterRequest();
+}
+
+template<> inline const Debugger::WriteRegisterResponse *DebugEvent::event_as<Debugger::WriteRegisterResponse>() const {
+  return event_as_WriteRegisterResponse();
+}
+
+template<> inline const Debugger::ReadRegisterRequest *DebugEvent::event_as<Debugger::ReadRegisterRequest>() const {
+  return event_as_ReadRegisterRequest();
+}
+
+template<> inline const Debugger::ReadRegisterResponse *DebugEvent::event_as<Debugger::ReadRegisterResponse>() const {
+  return event_as_ReadRegisterResponse();
+}
+
 struct DebugEventBuilder {
   typedef DebugEvent Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;
@@ -1148,6 +1568,122 @@ inline ::flatbuffers::Offset<ReadMemoryResponse> CreateReadMemoryResponse(::flat
       _data);
 }
 
+inline WriteRegisterRequestT *WriteRegisterRequest::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::unique_ptr<WriteRegisterRequestT>(new WriteRegisterRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void WriteRegisterRequest::UnPackTo(WriteRegisterRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = register_(); _o->register_ = _e; }
+  { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } }
+}
+
+inline ::flatbuffers::Offset<WriteRegisterRequest> WriteRegisterRequest::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateWriteRegisterRequest(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<WriteRegisterRequest> CreateWriteRegisterRequest(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const WriteRegisterRequestT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _register_ = _o->register_;
+  auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0;
+  return Debugger::CreateWriteRegisterRequest(
+      _fbb,
+      _register_,
+      _data);
+}
+
+inline WriteRegisterResponseT *WriteRegisterResponse::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::unique_ptr<WriteRegisterResponseT>(new WriteRegisterResponseT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void WriteRegisterResponse::UnPackTo(WriteRegisterResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = register_(); _o->register_ = _e; }
+  { auto _e = size(); _o->size = _e; }
+  { auto _e = success(); _o->success = _e; }
+}
+
+inline ::flatbuffers::Offset<WriteRegisterResponse> WriteRegisterResponse::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateWriteRegisterResponse(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<WriteRegisterResponse> CreateWriteRegisterResponse(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const WriteRegisterResponseT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _register_ = _o->register_;
+  auto _size = _o->size;
+  auto _success = _o->success;
+  return Debugger::CreateWriteRegisterResponse(
+      _fbb,
+      _register_,
+      _size,
+      _success);
+}
+
+inline ReadRegisterRequestT *ReadRegisterRequest::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::unique_ptr<ReadRegisterRequestT>(new ReadRegisterRequestT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void ReadRegisterRequest::UnPackTo(ReadRegisterRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = register_(); _o->register_ = _e; }
+}
+
+inline ::flatbuffers::Offset<ReadRegisterRequest> ReadRegisterRequest::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateReadRegisterRequest(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<ReadRegisterRequest> CreateReadRegisterRequest(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReadRegisterRequestT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _register_ = _o->register_;
+  return Debugger::CreateReadRegisterRequest(
+      _fbb,
+      _register_);
+}
+
+inline ReadRegisterResponseT *ReadRegisterResponse::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::unique_ptr<ReadRegisterResponseT>(new ReadRegisterResponseT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void ReadRegisterResponse::UnPackTo(ReadRegisterResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = register_(); _o->register_ = _e; }
+  { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } }
+}
+
+inline ::flatbuffers::Offset<ReadRegisterResponse> ReadRegisterResponse::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateReadRegisterResponse(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<ReadRegisterResponse> CreateReadRegisterResponse(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReadRegisterResponseT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _register_ = _o->register_;
+  auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0;
+  return Debugger::CreateReadRegisterResponse(
+      _fbb,
+      _register_,
+      _data);
+}
+
 inline DebugEventT *DebugEvent::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
   auto _o = std::unique_ptr<DebugEventT>(new DebugEventT());
   UnPackTo(_o.get(), _resolver);
@@ -1214,6 +1750,22 @@ inline bool VerifyEvent(::flatbuffers::Verifier &verifier, const void *obj, Even
       auto ptr = reinterpret_cast<const Debugger::ReadMemoryResponse *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case Event_WriteRegisterRequest: {
+      auto ptr = reinterpret_cast<const Debugger::WriteRegisterRequest *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Event_WriteRegisterResponse: {
+      auto ptr = reinterpret_cast<const Debugger::WriteRegisterResponse *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Event_ReadRegisterRequest: {
+      auto ptr = reinterpret_cast<const Debugger::ReadRegisterRequest *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Event_ReadRegisterResponse: {
+      auto ptr = reinterpret_cast<const Debugger::ReadRegisterResponse *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
     default: return true;
   }
 }
@@ -1265,6 +1817,22 @@ inline void *EventUnion::UnPack(const void *obj, Event type, const ::flatbuffers
       auto ptr = reinterpret_cast<const Debugger::ReadMemoryResponse *>(obj);
       return ptr->UnPack(resolver);
     }
+    case Event_WriteRegisterRequest: {
+      auto ptr = reinterpret_cast<const Debugger::WriteRegisterRequest *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    case Event_WriteRegisterResponse: {
+      auto ptr = reinterpret_cast<const Debugger::WriteRegisterResponse *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    case Event_ReadRegisterRequest: {
+      auto ptr = reinterpret_cast<const Debugger::ReadRegisterRequest *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    case Event_ReadRegisterResponse: {
+      auto ptr = reinterpret_cast<const Debugger::ReadRegisterResponse *>(obj);
+      return ptr->UnPack(resolver);
+    }
     default: return nullptr;
   }
 }
@@ -1304,6 +1872,22 @@ inline ::flatbuffers::Offset<void> EventUnion::Pack(::flatbuffers::FlatBufferBui
       auto ptr = reinterpret_cast<const Debugger::ReadMemoryResponseT *>(value);
       return CreateReadMemoryResponse(_fbb, ptr, _rehasher).Union();
     }
+    case Event_WriteRegisterRequest: {
+      auto ptr = reinterpret_cast<const Debugger::WriteRegisterRequestT *>(value);
+      return CreateWriteRegisterRequest(_fbb, ptr, _rehasher).Union();
+    }
+    case Event_WriteRegisterResponse: {
+      auto ptr = reinterpret_cast<const Debugger::WriteRegisterResponseT *>(value);
+      return CreateWriteRegisterResponse(_fbb, ptr, _rehasher).Union();
+    }
+    case Event_ReadRegisterRequest: {
+      auto ptr = reinterpret_cast<const Debugger::ReadRegisterRequestT *>(value);
+      return CreateReadRegisterRequest(_fbb, ptr, _rehasher).Union();
+    }
+    case Event_ReadRegisterResponse: {
+      auto ptr = reinterpret_cast<const Debugger::ReadRegisterResponseT *>(value);
+      return CreateReadRegisterResponse(_fbb, ptr, _rehasher).Union();
+    }
     default: return 0;
   }
 }
@@ -1342,6 +1926,22 @@ inline EventUnion::EventUnion(const EventUnion &u) : type(u.type), value(nullptr
       value = new Debugger::ReadMemoryResponseT(*reinterpret_cast<Debugger::ReadMemoryResponseT *>(u.value));
       break;
     }
+    case Event_WriteRegisterRequest: {
+      value = new Debugger::WriteRegisterRequestT(*reinterpret_cast<Debugger::WriteRegisterRequestT *>(u.value));
+      break;
+    }
+    case Event_WriteRegisterResponse: {
+      value = new Debugger::WriteRegisterResponseT(*reinterpret_cast<Debugger::WriteRegisterResponseT *>(u.value));
+      break;
+    }
+    case Event_ReadRegisterRequest: {
+      value = new Debugger::ReadRegisterRequestT(*reinterpret_cast<Debugger::ReadRegisterRequestT *>(u.value));
+      break;
+    }
+    case Event_ReadRegisterResponse: {
+      value = new Debugger::ReadRegisterResponseT(*reinterpret_cast<Debugger::ReadRegisterResponseT *>(u.value));
+      break;
+    }
     default:
       break;
   }
@@ -1389,6 +1989,26 @@ inline void EventUnion::Reset() {
       delete ptr;
       break;
     }
+    case Event_WriteRegisterRequest: {
+      auto ptr = reinterpret_cast<Debugger::WriteRegisterRequestT *>(value);
+      delete ptr;
+      break;
+    }
+    case Event_WriteRegisterResponse: {
+      auto ptr = reinterpret_cast<Debugger::WriteRegisterResponseT *>(value);
+      delete ptr;
+      break;
+    }
+    case Event_ReadRegisterRequest: {
+      auto ptr = reinterpret_cast<Debugger::ReadRegisterRequestT *>(value);
+      delete ptr;
+      break;
+    }
+    case Event_ReadRegisterResponse: {
+      auto ptr = reinterpret_cast<Debugger::ReadRegisterResponseT *>(value);
+      delete ptr;
+      break;
+    }
     default: break;
   }
   value = nullptr;