Added watchpoints

Author: haneefdm

CHANGELOG.md

@@ -1,7 +1,8 @@
 # ChangeLog
 
 # V1.13.0-pre8
-* Added `hardwareBreakpoints: {required: boolean, limit: numer}` to debug configuration. You can force all breakpoints to use hardware breakpoints. You can also ask cortex-debug to limit the number such breakpoints or you can let gdb or your gdb-server enforce a limit. Please use `hardwareBreakpoints` with caution as in most cases it is better to let gdb decide which type of breakpoint to use based on memory types while making sure you are not over the limit -- this is especially true for devices with large SRAMs where you can have near inifite breakpoints and not even have a performance penalty. HW breakpoints are not inherently better than SW breakpoints so long as GDB can read/write to memory locations.
+* Added `hardwareBreakpoints: {require: boolean, limit: numer}` to debug configuration. You can force all breakpoints to use hardware breakpoints. You can also ask cortex-debug to limit the number such breakpoints or you can let gdb or your gdb-server enforce a limit. Please use `hardwareBreakpoints` with caution as in most cases it is better to let gdb decide which type of breakpoint to use based on memory types while making sure you are not over the limit -- this is especially true for devices with large SRAMs where you can have near inifite breakpoints and not even have a performance penalty. HW breakpoints are not inherently better than SW breakpoints so long as GDB can read/write to memory locations.
+* Also added `hardwareWatchpoints` similar to `hardwareBreakpoints`. Note however that GDB always prefers to use hardware resources for this as doing it in software, while possible, is super slow and unusable.
 
 # V1.13.0-pre7
 * Added `overridePreEndSessionCommands` to control how a session ends. If the session does not end your way, we sill end the session the normal way

README.md

@@ -2,8 +2,9 @@
 
 ![Visual Studio Code with Cortex-Debug Installed](./images/vs-code-screenshot.png)
 
-Debugging support for ARM Cortex-M Microcontrollers with the following features:
+Debugging support for ARM Cortex-M (and others) Microcontrollers with the following features:
 
+* While we cannot change the extension name due to VSCode Marketplace rules, this extension can be used by non Cortex-M devices and non ARM devices. People have reported using it with Cortex-R/A, Xtensa, RISC-V and even x86. Your mileage may vary.
 * Highly configurable. See https://github.com/Marus/cortex-debug/blob/master/debug_attributes.md
 * Support J-Link, OpenOCD GDB Server, STMicroelectronic's ST-LINK GDB server, pyOCD and the Black Magic Probe
 * Partial support textane/stlink (st-util) GDB Servers (SWO can only be captured via a serial port)

debug_attributes.md

@@ -38,7 +38,10 @@ If the type is marked as `{...}` it means that it is a complex item can have mul
 | graphConfig | {object} | Both | Description of how graphing can be done. See our Wiki for details |
 | hardwareBreakpoints | object | Both | WARNING: Force only HW breakpoints to be used. By default GDB will use HW or SW  breakpoints depending on memory type. Use this only in rare circumstances to work around issues in your gdb-server or hardware. This setting is NOT recommended for general use. |
 | hardwareBreakpoints<br>.limit | number | Both | If limit > 0, enforce a limit on the number of hardware breakpoints that can be used |
-| hardwareBreakpoints<br>.required | boolean | Both | If true, forces the use of hardware breakpoints |
+| hardwareBreakpoints<br>.require | boolean | Both | If true, forces the use of hardware breakpoints |
+| hardwareWatchpoints | object | Both | WARNING: Force only HW watchpoints to be used. By default GDB will use HW or SW  watchpoints depending on memory type. Use this only in rare circumstances |
+| hardwareWatchpoints<br>.limit | number | Both | If limit > 0, enforce a limit on the number of hardware watchpoints that can be used |
+| hardwareWatchpoints<br>.require | boolean | Both | If true, forces the use of hardware watchpoints |
 | interface | string | Both | Debug Interface type to use for connections (defaults to SWD) - Used for J-Link, ST-LINK and BMP probes. |
 | ipAddress | string | Both | IP Address for networked J-Link Adapter |
 | jlinkscript | string | Both | J-Link script file - optional input file for customizing J-Link actions. |

package.json

@@ -804,7 +804,7 @@
                                 "description": "WARNING: Force only HW breakpoints to be used. By default GDB will use HW or SW  breakpoints depending on memory type. Use this only in rare circumstances to work around issues in your gdb-server or hardware. This setting is NOT recommended for general use.",
                                 "type": "object",
                                 "properties": {
-                                    "required": {
+                                    "require": {
                                         "type": "boolean",
                                         "default": false,
                                         "description": "If true, forces the use of hardware breakpoints"
@@ -818,6 +818,24 @@
                                     }
                                 }
                             },
+                            "hardwareWatchpoints": {
+                                "description": "WARNING: Force only HW watchpoints to be used. By default GDB will use HW or SW  watchpoints depending on memory type. Use this only in rare circumstances",
+                                "type": "object",
+                                "properties": {
+                                    "require": {
+                                        "type": "boolean",
+                                        "default": false,
+                                        "description": "If true, forces the use of hardware watchpoints"
+                                    },
+                                    "limit": {
+                                        "type": "number",
+                                        "minimum": 0,
+                                        "multipleOf": 1,
+                                        "default": 0,
+                                        "description": "If limit > 0, enforce a limit on the number of hardware watchpoints that can be used"
+                                    }
+                                }
+                            },
                             "liveWatch": {
                                 "description": "An object with parameters for Live Watch",
                                 "properties": {
@@ -1972,7 +1990,7 @@
                                 "description": "WARNING: Force only HW breakpoints to be used. By default GDB will use HW or SW  breakpoints depending on memory type. Use this only in rare circumstances to work around issues in your gdb-server or hardware. This setting is NOT recommended for general use.",
                                 "type": "object",
                                 "properties": {
-                                    "required": {
+                                    "require": {
                                         "type": "boolean",
                                         "default": false,
                                         "description": "If true, forces the use of hardware breakpoints"
@@ -1986,6 +2004,24 @@
                                     }
                                 }
                             },
+                            "hardwareWatchpoints": {
+                                "description": "WARNING: Force only HW watchpoints to be used. By default GDB will use HW or SW  watchpoints depending on memory type. Use this only in rare circumstances",
+                                "type": "object",
+                                "properties": {
+                                    "require": {
+                                        "type": "boolean",
+                                        "default": false,
+                                        "description": "If true, forces the use of hardware watchpoints"
+                                    },
+                                    "limit": {
+                                        "type": "number",
+                                        "minimum": 0,
+                                        "multipleOf": 1,
+                                        "default": 0,
+                                        "description": "If limit > 0, enforce a limit on the number of hardware watchpoints that can be used"
+                                    }
+                                }
+                            },
                             "liveWatch": {
                                 "description": "An object with parameters for Live Watch",
                                 "properties": {

src/backend/symbols.ts

@@ -487,15 +487,15 @@ export class SymbolTable {
                     });
                     this.objdumpReader.on('exit', (code, signal) => {
                         if (code !== 0) {
-                            this.gdbSession.handleMsg('log', `'objdump' exited with a nonzero exit status ${code}, ${signal}\n`);
+                            this.gdbSession.handleMsg('log', `'objdump' exited with a nonzero exit status ${code}, ${signal}. File: ${executable}\n`);
                         }
                     });
                     this.objdumpReader.on('close', (code, signal) => {
                         this.objdumpReader = undefined;
                         this.currentObjDumpFile = null;
                         if (trace || this.gdbSession.args.showDevDebugOutput) {
                             const ms = Date.now() - objdumpStart;
-                            this.gdbSession.handleMsg('log', `Finished reading symbols from objdump: Time: ${ms} ms\n`);
+                            this.gdbSession.handleMsg('log', `Finished reading symbols from objdump: Time: ${ms} ms. File: ${executable}\n`);
                         }
                     });
 
@@ -531,13 +531,13 @@ export class SymbolTable {
                     });
                     nmReader.on('exit', (code, signal) => {
                         if (code !== 0) {
-                            this.gdbSession.handleMsg('log', `'nm' exited with a nonzero exit status ${code}, ${signal}\n`);
+                            this.gdbSession.handleMsg('log', `'nm' exited with a nonzero exit status ${code}, ${signal}. File: ${executable}\n`);
                         }
                     });
                     nmReader.on('close', () => {
                         if (trace || this.gdbSession.args.showDevDebugOutput) {
                             const ms = Date.now() - nmStart;
-                            this.gdbSession.handleMsg('log', `Finished reading symbols from nm: Time: ${ms} ms\n`);
+                            this.gdbSession.handleMsg('log', `Finished reading symbols from nm: Time: ${ms} ms. File: ${executable}\n`);
                         }
                     });
 

src/common.ts

@@ -253,9 +253,15 @@ export function defSymbolFile(file: string): SymbolFile {
 }
 
 export interface HWBreakpointInfo {
-    required: boolean;
-    limit: number;
+    require: boolean;
+    limit?: number;
 }
+
+export interface HWWatchpointInfo {
+    require: boolean;
+    limit?: number;
+}
+
 export interface ConfigurationArguments extends DebugProtocol.LaunchRequestArguments {
     name: string;
     request: string;
@@ -312,7 +318,7 @@ export interface ConfigurationArguments extends DebugProtocol.LaunchRequestArgum
     variableUseNaturalFormat: boolean;
     chainedConfigurations: ChainedConfigurations;
     hardwareBreakpoints: HWBreakpointInfo;
-
+    hardwareWatchpoints: HWWatchpointInfo;
     pvtIsReset: boolean;
     pvtPorts: { [name: string]: number };
     pvtParent: ConfigurationArguments;

src/gdb.ts

@@ -65,7 +65,7 @@ export class HWBreakpointMgr {
         private readonly forceHwBreakpoints: boolean = false) {
     }
 
-    areHwBreakpointsForced(): boolean {
+    isHWForced(): boolean {
         return this.forceHwBreakpoints;
     }
 
@@ -99,9 +99,8 @@ export class HWBreakpointMgr {
         this.breakpointSet.clear();
     }
 
-    // This should only be called when the limiter has not been reached
     getGdbMiArg(bptType: HWBreakpointType): string {
-        if (this.forceHwBreakpoints && !this.limitReached()) {
+        if (this.forceHwBreakpoints) {
             return (bptType === 'data') ? '' : '-h';
         }
         return '';
@@ -278,6 +277,7 @@ export class GDBDebugSession extends LoggingDebugSession {
     protected currentThreadId: number = 0;
     protected activeThreadIds = new Set<number>();      // Used for consistency check
     protected hwBreakpointMgr: HWBreakpointMgr;
+    protected hwWatchpointMgr: HWBreakpointMgr;
 
     /**
      * If we are requested a major switch like restart/disconnect/detach we may have to interrupt the
@@ -419,17 +419,12 @@ export class GDBDebugSession extends LoggingDebugSession {
             args.showDevDebugOutput = ADAPTER_DEBUG_MODE.RAW;
         }
         this.args = this.normalizeArguments(args);
-        const forceHW = this.args.hardwareBreakpoints?.required || false;
-        const limit = this.args.hardwareBreakpoints?.limit || 0;
-        this.hwBreakpointMgr = new HWBreakpointMgr(limit, forceHW);
 
         this.handleMsg('stdout',
             `Cortex-Debug: VSCode debugger extension version ${args.pvtVersion} git(${__COMMIT_HASH__}). `
             + 'Usage info: https://github.com/Marus/cortex-debug#usage');
-        if (forceHW) {
-            const limitMsg = (limit > 0) ? `Limit of ${limit} breakpoints will be enforced by cortex-debug` : 'GDB enforces any limits you may have configured';
-            this.handleMsg('stderr', `INFO: All breakpoints will be requested as hardware breakpoints. ${limitMsg}\n`);
-        }
+
+        this.setHWBreakpointInfo();
 
         if (this.args.showDevDebugOutput) {
             this.handleMsg('log', '"configuration": ' + JSON.stringify(args, undefined, 4) + '\n');
@@ -461,6 +456,23 @@ export class GDBDebugSession extends LoggingDebugSession {
         }
     }
 
+    private setHWBreakpointInfo() {
+        let forceHW = this.args.hardwareBreakpoints?.require || false;
+        let limit = this.args.hardwareBreakpoints?.limit || 0;
+        this.hwBreakpointMgr = new HWBreakpointMgr(limit, forceHW);
+        if (forceHW) {
+            const limitMsg = (limit > 0) ? `Limit of ${limit} breakpoints will be enforced by cortex-debug` : 'GDB enforces any limits you may have configured';
+            this.handleMsg('stderr', `INFO: All breakpoints will be requested as hardware breakpoints. ${limitMsg}\n`);
+        }
+        forceHW = this.args.hardwareWatchpoints?.require || false;
+        limit = this.args.hardwareWatchpoints?.limit || 0;
+        this.hwWatchpointMgr = new HWBreakpointMgr(limit, forceHW);
+        if (forceHW && (limit > 0)) {
+            const limitMsg = `Limit of ${limit} watchpoints will be enforced by cortex-debug`;
+            this.handleMsg('stderr', `INFO: All watchpoints are done by GDB as hardware watchpoints (default). ${limitMsg}\n`);
+        }
+    }
+
     public isDebugLoggingAvailable() {
         return (this.debugLogFd >= 0);
     }
@@ -728,7 +740,7 @@ export class GDBDebugSession extends LoggingDebugSession {
                 let feedbackTimer = setInterval(() => {
                     const svrName = this.serverController.name || this.args.servertype;
                     elapsed += 5;
-                    this.handleMsg('stdout', `Still waiting for ${svrName} GDB Server to be ready, ${elapsed} seconds...\n`);
+                    this.handleMsg('stdout', `Still waiting for ${svrName} GDB Server to be ready, ${elapsed} seconds...looking for '${initMatch}'\n`);
                 }, 5 * 1000);
 
                 this.serverController.serverLaunchStarted();
@@ -2188,23 +2200,24 @@ export class GDBDebugSession extends LoggingDebugSession {
         resolve: (value: any) => void;
     }[] = [];
 
-    protected async addBptSync<T>(func: () => Promise<T>, obj: any): Promise<T | MIError> {
+    protected async addBptSync<T>(func: () => Promise<T>, obj: any, isData: boolean = false): Promise<T | MIError> {
         return new Promise<T | MIError>(async (resolve) => {
+            const mgr = isData ? this.hwWatchpointMgr : this.hwBreakpointMgr;
             this.addBptSyncQueue.push({ func: func, obj: obj, resolve: resolve });
             while (this.addBptSyncRunning) {
                 await new Promise((resolve) => setTimeout(resolve, 0));
             }
             this.addBptSyncRunning = true;
             while (this.addBptSyncQueue.length > 0) {
                 const item = this.addBptSyncQueue.shift();
-                if (this.hwBreakpointMgr.limitReached()) {
+                if (mgr.limitReached()) {
                     item.resolve(this.reportHwBreakptLimit(obj));
                 } else {
                     try {
                         const ret = await item.func() as T;
                         if (ret && !(ret instanceof MIError)) {
                             const brk = ret as { number: number };
-                            this.hwBreakpointMgr.addBreakpoint(brk?.number || -1);
+                            mgr.addBreakpoint(brk?.number || -1);
                         }
                         item.resolve(ret);
                     } catch (err) {
@@ -2556,7 +2569,7 @@ export class GDBDebugSession extends LoggingDebugSession {
                 const createBreakpoints = async () => {
                     try {
                         const currentBreakpoints = Array.from(this.dataBreakpointMap.keys());
-                        this.hwBreakpointMgr.removeBreakpoints(currentBreakpoints);
+                        this.hwWatchpointMgr.removeBreakpoints(currentBreakpoints);
                         this.dataBreakpointMap.clear();
 
                         // It is not clear how gdb implements. It has to use the DWT in the Cortex-M for hardware data
@@ -2572,7 +2585,7 @@ export class GDBDebugSession extends LoggingDebugSession {
                             const bkp: OurDataBreakpoint = { ...brk };
                             all.push(this.addBptSync<OurDataBreakpoint | MIError>(() => {
                                 return this.miDebugger.addDataBreakPoint(bkp);
-                            }, bkp));
+                            }, bkp, true));
                         });
 
                         const brkpoints = await Promise.all(all);

src/pyocd.ts

@@ -130,7 +130,7 @@ export class PyOCDServerController extends EventEmitter implements GDBServerCont
     }
 
     public initMatch(): RegExp {
-        return /GDB server started (at|on) port/;
+        return /GDB server (listening|started) (at|on) port/;
     }
 
     public serverLaunchStarted(): void {}