rp2040js 0.19.3 → 1.0.0

package/dist/cjs/clock/clock.d.ts

@@ -1,11 +1,9 @@
-export interface IClockTimer {
-    pause(currentMicros: number): void;
-    resume(currentMicros: number): void;
+export type AlarmCallback = () => void;
+export interface IAlarm {
+    schedule(deltaNanos: number): void;
+    cancel(): void;
 }
 export interface IClock {
-    readonly micros: number;
-    pause(): void;
-    resume(): void;
-    createTimer(deltaMicros: number, callback: () => void): IClockTimer;
-    deleteTimer(timer: IClockTimer): void;
+    readonly nanos: number;
+    createAlarm(callback: AlarmCallback): IAlarm;
 }

package/dist/cjs/clock/mock-clock.d.ts

@@ -1,17 +1,4 @@
-import { IClock, IClockTimer } from './clock.js';
-export declare class MockClockTimer implements IClockTimer {
-    readonly micros: number;
-    readonly callback: () => void;
-    constructor(micros: number, callback: () => void);
-    pause(): void;
-    resume(): void;
-}
-export declare class MockClock implements IClock {
-    micros: number;
-    readonly timers: MockClockTimer[];
-    pause(): void;
-    resume(): void;
+import { SimulationClock } from './simulation-clock.js';
+export declare class MockClock extends SimulationClock {
     advance(deltaMicros: number): void;
-    createTimer(deltaMicros: number, callback: () => void): MockClockTimer;
-    deleteTimer(timer: IClockTimer): void;
 }

package/dist/cjs/clock/mock-clock.js

@@ -1,52 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockClock = exports.MockClockTimer = void 0;
-class MockClockTimer {
-    constructor(micros, callback) {
-        this.micros = micros;
-        this.callback = callback;
-    }
-    pause() {
-        /* intentionally empty */
-    }
-    resume() {
-        /* intentionally empty */
-    }
-}
-exports.MockClockTimer = MockClockTimer;
-class MockClock {
-    constructor() {
-        this.micros = 0;
-        this.timers = [];
-    }
-    pause() {
-        /* intentionally empty */
-    }
-    resume() {
-        /* intentionally empty */
-    }
+exports.MockClock = void 0;
+const simulation_clock_js_1 = require("./simulation-clock.js");
+class MockClock extends simulation_clock_js_1.SimulationClock {
     advance(deltaMicros) {
-        const { timers } = this;
-        const targetTime = this.micros + Math.max(deltaMicros, 0.01);
-        while (timers[0] && timers[0].micros <= targetTime) {
-            const timer = timers.shift();
-            if (timer) {
-                this.micros = timer.micros;
-                timer.callback();
-            }
-        }
-    }
-    createTimer(deltaMicros, callback) {
-        const timer = new MockClockTimer(this.micros + deltaMicros, callback);
-        this.timers.push(timer);
-        this.timers.sort((a, b) => a.micros - b.micros);
-        return timer;
-    }
-    deleteTimer(timer) {
-        const timerIndex = this.timers.indexOf(timer);
-        if (timerIndex >= 0) {
-            this.timers.splice(timerIndex, 1);
-        }
+        this.tick(this.nanos + deltaMicros * 1000);
     }
 }
 exports.MockClock = MockClock;

package/dist/cjs/clock/simulation-clock.d.ts

@@ -0,0 +1,26 @@
+import { AlarmCallback, IAlarm, IClock } from './clock.js';
+type ClockEventCallback = () => void;
+export declare class ClockAlarm implements IAlarm {
+    private readonly clock;
+    readonly callback: AlarmCallback;
+    next: ClockAlarm | null;
+    nanos: number;
+    scheduled: boolean;
+    constructor(clock: SimulationClock, callback: AlarmCallback);
+    schedule(deltaNanos: number): void;
+    cancel(): void;
+}
+export declare class SimulationClock implements IClock {
+    readonly frequency: number;
+    private nextAlarm;
+    private nanosCounter;
+    constructor(frequency?: number);
+    get nanos(): number;
+    get micros(): number;
+    createAlarm(callback: ClockEventCallback): ClockAlarm;
+    linkAlarm(nanos: number, alarm: ClockAlarm): ClockAlarm;
+    unlinkAlarm(alarm: ClockAlarm): boolean;
+    tick(deltaNanos: number): void;
+    get nanosToNextAlarm(): number;
+}
+export {};

package/dist/cjs/clock/simulation-clock.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimulationClock = exports.ClockAlarm = void 0;
+class ClockAlarm {
+    constructor(clock, callback) {
+        this.clock = clock;
+        this.callback = callback;
+        this.next = null;
+        this.nanos = 0;
+        this.scheduled = false;
+    }
+    schedule(deltaNanos) {
+        if (this.scheduled) {
+            this.cancel();
+        }
+        this.clock.linkAlarm(deltaNanos, this);
+    }
+    cancel() {
+        this.clock.unlinkAlarm(this);
+        this.scheduled = false;
+    }
+}
+exports.ClockAlarm = ClockAlarm;
+class SimulationClock {
+    constructor(frequency = 125e6) {
+        this.frequency = frequency;
+        this.nextAlarm = null;
+        this.nanosCounter = 0;
+    }
+    get nanos() {
+        return this.nanosCounter;
+    }
+    get micros() {
+        return this.nanos / 1000;
+    }
+    createAlarm(callback) {
+        return new ClockAlarm(this, callback);
+    }
+    linkAlarm(nanos, alarm) {
+        alarm.nanos = this.nanos + nanos;
+        let alarmListItem = this.nextAlarm;
+        let lastItem = null;
+        while (alarmListItem && alarmListItem.nanos < alarm.nanos) {
+            lastItem = alarmListItem;
+            alarmListItem = alarmListItem.next;
+        }
+        if (lastItem) {
+            lastItem.next = alarm;
+            alarm.next = alarmListItem;
+        }
+        else {
+            this.nextAlarm = alarm;
+            alarm.next = alarmListItem;
+        }
+        alarm.scheduled = true;
+        return alarm;
+    }
+    unlinkAlarm(alarm) {
+        let alarmListItem = this.nextAlarm;
+        if (!alarmListItem) {
+            return false;
+        }
+        let lastItem = null;
+        while (alarmListItem) {
+            if (alarmListItem === alarm) {
+                if (lastItem) {
+                    lastItem.next = alarmListItem.next;
+                }
+                else {
+                    this.nextAlarm = alarmListItem.next;
+                }
+                return true;
+            }
+            lastItem = alarmListItem;
+            alarmListItem = alarmListItem.next;
+        }
+        return false;
+    }
+    tick(deltaNanos) {
+        const targetNanos = this.nanosCounter + deltaNanos;
+        let alarm = this.nextAlarm;
+        while (alarm && alarm.nanos <= targetNanos) {
+            this.nextAlarm = alarm.next;
+            this.nanosCounter = alarm.nanos;
+            alarm.callback();
+            alarm = this.nextAlarm;
+        }
+        this.nanosCounter = targetNanos;
+    }
+    get nanosToNextAlarm() {
+        if (this.nextAlarm) {
+            return this.nextAlarm.nanos - this.nanos;
+        }
+        return 0;
+    }
+}
+exports.SimulationClock = SimulationClock;

package/dist/cjs/cortex-m0-core.d.ts

@@ -82,6 +82,6 @@ export declare class CortexM0Core {
     private substractUpdateFlags;
     private addUpdateFlags;
     cyclesIO(addr: number, write?: boolean): 0 | 1 | 3 | 4;
-    executeInstruction(): void;
+    executeInstruction(): number;
 }
 export {};

package/dist/cjs/cortex-m0-core.js

@@ -529,7 +529,7 @@ class CortexM0Core {
         const wideInstruction = opcode >> 12 === 0b1111 || opcode >> 11 === 0b11101;
         const opcode2 = wideInstruction ? this.readUint16(opcodePC + 2) : 0;
         this.PC += 2;
-        this.cycles++;
+        let deltaCycles = 1;
         // ADCS
         if (opcode >> 6 === 0b0100000101) {
             const Rm = (opcode >> 3) & 0x7;
@@ -579,7 +579,7 @@ class CortexM0Core {
             }
             else if (Rdn === pcRegister) {
                 this.registers[Rdn] = result & ~0x1;
-                this.cycles++;
+                deltaCycles++;
             }
             else if (Rdn === spRegister) {
                 this.registers[Rdn] = result & ~0x3;
@@ -634,7 +634,7 @@ class CortexM0Core {
             }
             if (this.checkCondition(cond)) {
                 this.PC += imm8 + 2;
-                this.cycles++;
+                deltaCycles++;
             }
         }
         // B
@@ -644,7 +644,7 @@ class CortexM0Core {
                 imm11 = (imm11 & 0x7ff) - 0x800;
             }
             this.PC += imm11 + 2;
-            this.cycles++;
+            deltaCycles++;
         }
         // BICS
         else if (opcode >> 6 === 0b0100001110) {
@@ -672,7 +672,7 @@ class CortexM0Core {
             const imm32 = ((S ? 0b11111111 : 0) << 24) | ((I1 << 23) | (I2 << 22) | (imm10 << 12) | (imm11 << 1));
             this.LR = (this.PC + 2) | 0x1;
             this.PC += 2 + imm32;
-            this.cycles += 2;
+            deltaCycles += 2;
             this.blTaken(this, false);
         }
         // BLX
@@ -680,14 +680,14 @@ class CortexM0Core {
             const Rm = (opcode >> 3) & 0xf;
             this.LR = this.PC | 0x1;
             this.PC = this.registers[Rm] & ~1;
-            this.cycles++;
+            deltaCycles++;
             this.blTaken(this, true);
         }
         // BX
         else if (opcode >> 7 === 0b010001110 && (opcode & 0x7) === 0) {
             const Rm = (opcode >> 3) & 0xf;
             this.BXWritePC(this.registers[Rm]);
-            this.cycles++;
+            deltaCycles++;
         }
         // CMN (register)
         else if (opcode >> 6 === 0b0100001011) {
@@ -725,12 +725,12 @@ class CortexM0Core {
         // DMB SY
         else if (opcode === 0xf3bf && (opcode2 & 0xfff0) === 0x8f50) {
             this.PC += 2;
-            this.cycles += 2;
+            deltaCycles += 2;
         }
         // DSB SY
         else if (opcode === 0xf3bf && (opcode2 & 0xfff0) === 0x8f40) {
             this.PC += 2;
-            this.cycles += 2;
+            deltaCycles += 2;
         }
         // EORS
         else if (opcode >> 6 === 0b0100000001) {
@@ -744,7 +744,7 @@ class CortexM0Core {
         // ISB SY
         else if (opcode === 0xf3bf && (opcode2 & 0xfff0) === 0x8f60) {
             this.PC += 2;
-            this.cycles += 2;
+            deltaCycles += 2;
         }
         // LDMIA
         else if (opcode >> 11 === 0b11001) {
@@ -755,7 +755,7 @@ class CortexM0Core {
                 if (registers & (1 << i)) {
                     this.registers[i] = this.readUint32(address);
                     address += 4;
-                    this.cycles++;
+                    deltaCycles++;
                 }
             }
             // Write back
@@ -769,7 +769,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rn] + imm5;
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint32(addr);
         }
         // LDR (sp + immediate)
@@ -777,7 +777,7 @@ class CortexM0Core {
             const Rt = (opcode >> 8) & 0x7;
             const imm8 = opcode & 0xff;
             const addr = this.SP + (imm8 << 2);
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint32(addr);
         }
         // LDR (literal)
@@ -786,7 +786,7 @@ class CortexM0Core {
             const Rt = (opcode >> 8) & 7;
             const nextPC = this.PC + 2;
             const addr = (nextPC & 0xfffffffc) + imm8;
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint32(addr);
         }
         // LDR (register)
@@ -795,7 +795,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint32(addr);
         }
         // LDRB (immediate)
@@ -804,7 +804,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rn] + imm5;
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint8(addr);
         }
         // LDRB (register)
@@ -813,7 +813,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint8(addr);
         }
         // LDRH (immediate)
@@ -822,7 +822,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rn] + (imm5 << 1);
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint16(addr);
         }
         // LDRH (register)
@@ -831,7 +831,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint16(addr);
         }
         // LDRSB
@@ -840,7 +840,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = signExtend8(this.readUint8(addr));
         }
         // LDRSH
@@ -849,7 +849,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = signExtend16(this.readUint16(addr));
         }
         // LSLS (immediate)
@@ -906,7 +906,7 @@ class CortexM0Core {
             const Rd = ((opcode >> 4) & 0x8) | (opcode & 0x7);
             let value = Rm === pcRegister ? this.PC + 2 : this.registers[Rm];
             if (Rd === pcRegister) {
-                this.cycles++;
+                deltaCycles++;
                 value &= ~1;
             }
             else if (Rd === spRegister) {
@@ -928,7 +928,7 @@ class CortexM0Core {
             const Rd = (opcode2 >> 8) & 0xf;
             this.registers[Rd] = this.readSpecialRegister(SYSm);
             this.PC += 2;
-            this.cycles += 2;
+            deltaCycles += 2;
         }
         // MSR
         else if (opcode >> 4 === 0b111100111000 && opcode2 >> 8 == 0b10001000) {
@@ -936,7 +936,7 @@ class CortexM0Core {
             const Rn = opcode & 0xf;
             this.writeSpecialRegister(SYSm, this.registers[Rn]);
             this.PC += 2;
-            this.cycles += 2;
+            deltaCycles += 2;
         }
         // MULS
         else if (opcode >> 6 === 0b0100001101) {
@@ -973,13 +973,13 @@ class CortexM0Core {
                 if (opcode & (1 << i)) {
                     this.registers[i] = this.readUint32(address);
                     address += 4;
-                    this.cycles++;
+                    deltaCycles++;
                 }
             }
             if (P) {
                 this.SP = address + 4;
                 this.BXWritePC(this.readUint32(address));
-                this.cycles += 2;
+                deltaCycles += 2;
             }
             else {
                 this.SP = address;
@@ -997,7 +997,7 @@ class CortexM0Core {
             for (let i = 0; i <= 7; i++) {
                 if (opcode & (1 << i)) {
                     this.writeUint32(address, this.registers[i]);
-                    this.cycles++;
+                    deltaCycles++;
                     address += 4;
                 }
             }
@@ -1076,7 +1076,7 @@ class CortexM0Core {
                 if (registers & (1 << i)) {
                     this.writeUint32(address, this.registers[i]);
                     address += 4;
-                    this.cycles++;
+                    deltaCycles++;
                 }
             }
             // Write back
@@ -1090,7 +1090,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const address = this.registers[Rn] + imm5;
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint32(address, this.registers[Rt]);
         }
         // STR (sp + immediate)
@@ -1098,7 +1098,7 @@ class CortexM0Core {
             const Rt = (opcode >> 8) & 0x7;
             const imm8 = opcode & 0xff;
             const address = this.SP + (imm8 << 2);
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint32(address, this.registers[Rt]);
         }
         // STR (register)
@@ -1107,7 +1107,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const address = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint32(address, this.registers[Rt]);
         }
         // STRB (immediate)
@@ -1116,7 +1116,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const address = this.registers[Rn] + imm5;
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint8(address, this.registers[Rt]);
         }
         // STRB (register)
@@ -1125,7 +1125,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const address = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint8(address, this.registers[Rt]);
         }
         // STRH (immediate)
@@ -1134,7 +1134,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const address = this.registers[Rn] + imm5;
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint16(address, this.registers[Rt]);
         }
         // STRH (register)
@@ -1143,7 +1143,7 @@ class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const address = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint16(address, this.registers[Rt]);
         }
         // SUB (SP minus immediate)
@@ -1224,7 +1224,7 @@ class CortexM0Core {
         }
         // WFE
         else if (opcode === 0b1011111100100000) {
-            this.cycles++;
+            deltaCycles++;
             if (this.eventRegistered) {
                 this.eventRegistered = false;
             }
@@ -1234,7 +1234,7 @@ class CortexM0Core {
         }
         // WFI
         else if (opcode === 0b1011111100110000) {
-            this.cycles++;
+            deltaCycles++;
             this.waiting = true;
         }
         // YIELD
@@ -1246,6 +1246,8 @@ class CortexM0Core {
             this.logger.warn(LOG_NAME, `Warning: Instruction at ${opcodePC.toString(16)} is not implemented yet!`);
             this.logger.warn(LOG_NAME, `Opcode: 0x${opcode.toString(16)} (0x${opcode2.toString(16)})`);
         }
+        this.cycles += deltaCycles;
+        return deltaCycles;
     }
 }
 exports.CortexM0Core = CortexM0Core;

package/dist/cjs/gdb/gdb-connection.d.ts

@@ -3,7 +3,7 @@ export type GDBResponseHandler = (value: string) => void;
 export declare class GDBConnection {
     private server;
     private onResponse;
-    readonly rp2040: import("../rp2040.js").RP2040;
+    readonly target: import("./gdb-target.js").IGDBTarget;
     private buf;
     constructor(server: GDBServer, onResponse: GDBResponseHandler);
     feedData(data: string): void;

package/dist/cjs/gdb/gdb-connection.js

@@ -7,7 +7,7 @@ class GDBConnection {
     constructor(server, onResponse) {
         this.server = server;
         this.onResponse = onResponse;
-        this.rp2040 = this.server.rp2040;
+        this.target = this.server.target;
         this.buf = '';
         server.addConnection(this);
         onResponse('+');
@@ -16,7 +16,7 @@ class GDBConnection {
         const { onResponse } = this;
         if (data.charCodeAt(0) === 3) {
             this.server.info('BREAK');
-            this.rp2040.stop();
+            this.target.stop();
             onResponse((0, gdb_utils_js_1.gdbMessage)(gdb_server_js_1.STOP_REPLY_SIGINT));
             data = data.slice(1);
         }

package/dist/cjs/gdb/gdb-server.d.ts

@@ -3,16 +3,16 @@
  *
  * Copyright (C) 2021, Uri Shaked
  */
-import { RP2040 } from '../rp2040.js';
 import { Logger } from '../utils/logging.js';
 import { GDBConnection } from './gdb-connection.js';
+import { IGDBTarget } from './gdb-target.js';
 export declare const STOP_REPLY_SIGINT = "S02";
 export declare const STOP_REPLY_TRAP = "S05";
 export declare class GDBServer {
-    readonly rp2040: RP2040;
+    readonly target: IGDBTarget;
     logger: Logger;
     private readonly connections;
-    constructor(rp2040: RP2040);
+    constructor(target: IGDBTarget);
     processGDBMessage(cmd: string): string | undefined;
     addConnection(connection: GDBConnection): void;
     removeConnection(connection: GDBConnection): void;

package/dist/cjs/gdb/gdb-server.js

@@ -66,13 +66,13 @@ const targetXML = `<?xml version="1.0"?>
 </target>`;
 const LOG_NAME = 'GDBServer';
 class GDBServer {
-    constructor(rp2040) {
-        this.rp2040 = rp2040;
+    constructor(target) {
+        this.target = target;
         this.logger = new logging_js_1.ConsoleLogger(logging_js_1.LogLevel.Warn, true);
         this.connections = new Set();
     }
     processGDBMessage(cmd) {
-        const { rp2040 } = this;
+        const { rp2040 } = this.target;
         const { core } = rp2040;
         if (cmd === 'Hg0') {
             return (0, gdb_utils_js_1.gdbMessage)('OK');
@@ -113,8 +113,8 @@ class GDBServer {
                     return (0, gdb_utils_js_1.gdbMessage)('vCont;c;C;s;S');
                 }
                 if (cmd.startsWith('vCont;c')) {
-                    if (!rp2040.executing) {
-                        rp2040.execute();
+                    if (!this.target.executing) {
+                        this.target.execute();
                     }
                     return;
                 }
@@ -129,8 +129,8 @@ class GDBServer {
                 }
                 break;
             case 'c':
-                if (!rp2040.executing) {
-                    rp2040.execute();
+                if (!this.target.executing) {
+                    this.target.execute();
                 }
                 return (0, gdb_utils_js_1.gdbMessage)('OK');
             case 'g': {
@@ -169,7 +169,7 @@ class GDBServer {
             }
             case 'P': {
                 // Write register
-                const params = cmd.substr(1).split('=');
+                const params = cmd.substring(1).split('=');
                 const registerIndex = parseInt(params[0], 16);
                 const registerValue = params[1].trim();
                 const registerBytes = registerIndex > 0x12 ? 1 : 4;
@@ -235,10 +235,11 @@ class GDBServer {
         return (0, gdb_utils_js_1.gdbMessage)('');
     }
     addConnection(connection) {
+        const { rp2040 } = this.target;
         this.connections.add(connection);
-        this.rp2040.onBreak = () => {
-            this.rp2040.stop();
-            this.rp2040.core.PC -= this.rp2040.core.breakRewind;
+        rp2040.onBreak = () => {
+            this.target.stop();
+            rp2040.core.PC -= rp2040.core.breakRewind;
             for (const connection of this.connections) {
                 connection.onBreakpoint();
             }

package/dist/cjs/gdb/gdb-target.d.ts

@@ -0,0 +1,7 @@
+import { RP2040 } from '../rp2040.js';
+export interface IGDBTarget {
+    readonly executing: boolean;
+    rp2040: RP2040;
+    execute(): void;
+    stop(): void;
+}

package/dist/cjs/gdb/gdb-target.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });