Adding support for data breakpoints (#443)

* Added catching errors for the different GDB/MI commands
* Initial support for data breakpoints, supports only data breakpoints for simple global variables
* Adding tests for data breakpoint support
* Editing breakpoint tests to accommodate new source code being used for testing
* Testing for remote and non-stop mode
* Adding support for data breakpoints for addresses given the command palette
* Handle case where address to break at is provided as a decimal
* Accepting receiving addresses as decimals as well

Author: omarArm

src/gdb/GDBDebugSessionBase.ts

@@ -307,6 +307,7 @@ export abstract class GDBDebugSessionBase extends LoggingDebugSession {
         response.body.supportsSteppingGranularity = true;
         response.body.supportsInstructionBreakpoints = true;
         response.body.supportsTerminateRequest = true;
+        response.body.supportsDataBreakpoints = true;
         response.body.breakpointModes = this.getBreakpointModes();
         this.sendResponse(response);
     }
@@ -559,6 +560,64 @@ export abstract class GDBDebugSessionBase extends LoggingDebugSession {
         }
     }
 
+    protected async dataBreakpointInfoRequest(
+        response: DebugProtocol.DataBreakpointInfoResponse,
+        args: DebugProtocol.DataBreakpointInfoArguments
+    ): Promise<void> {
+        // The args.name is the expression to watch
+        let varExpression = args.name;
+        if (args.asAddress && args.bytes) {
+            // Make sure the address is in hex format, if not convert it to hex
+            if (!varExpression.startsWith('0x')) {
+                varExpression = `0x${BigInt(varExpression).toString(16)}`;
+            }
+            // The expression is an address, so we can set a data breakpoint directly withouth checking if it's a global symbol
+            response.body = {
+                dataId:
+                    // Check if bytes to be watched are more than 1, if so add the offset to the expression
+                    args.bytes > 1
+                        ? varExpression + `+0x${args.bytes}`
+                        : varExpression,
+                description: `Data breakpoint for ${varExpression}`,
+                accessTypes: ['read', 'write', 'readWrite'],
+                canPersist: true,
+            };
+        } else {
+            // Send the varExpression as a query to the symbol info variables command
+            try {
+                const symbols = await mi.sendSymbolInfoVars(this.gdb, {
+                    name: `^${varExpression}$`,
+                });
+                /** If there are debug symbols matching the varExpression, then we can set a data breakpoint.
+                 * We are currently supporting primitive expressions only. ie. no pointer dereferencing, no struct members, no arrays.
+                 * The plan for the forseeable future is to expand our support for arrays, struct/union data types, and classes.
+                 * Also a guard should be added to prevent setting data breakpoints on invalid expressions.
+                 */
+
+                if (symbols.symbols.debug.length > 0) {
+                    response.body = {
+                        dataId: varExpression,
+                        description: `Data breakpoint for ${varExpression}`,
+                        accessTypes: ['read', 'write', 'readWrite'],
+                        canPersist: true,
+                    };
+                } else {
+                    response.body = {
+                        dataId: null,
+                        description: `No data breakpoint for ${varExpression}`,
+                    };
+                }
+            } catch {
+                // Silently failing, no data breakpoint can be set for the expression
+                response.body = {
+                    dataId: null,
+                    description: `No data breakpoint for ${varExpression}`,
+                };
+            }
+        }
+        this.sendResponse(response);
+    }
+
     private async getInstructionBreakpointList(): Promise<
         mi.MIBreakpointInfo[]
     > {
@@ -572,6 +631,86 @@ export abstract class GDBDebugSessionBase extends LoggingDebugSession {
         return existingInstBreakpointsList;
     }
 
+    private async getWatchpointList(): Promise<mi.MIBreakpointInfo[]> {
+        // Get a list of existing watchpoints, using gdb-mi command -break-list
+        const fullBreakpointsList = await mi.sendBreakList(this.gdb);
+        // Filter out all watchpoints
+        const existingWatchpointsList =
+            fullBreakpointsList.BreakpointTable.body.filter((bp) =>
+                bp['type'].includes('watchpoint')
+            );
+        return existingWatchpointsList;
+    }
+
+    protected async setDataBreakpointsRequest(
+        response: DebugProtocol.SetDataBreakpointsResponse,
+        args: DebugProtocol.SetDataBreakpointsArguments
+    ): Promise<void> {
+        await this.pauseIfNeeded();
+        // Get existing GDB watchpoints
+        let existingGDBWatchpointsList = await this.getWatchpointList();
+        // Get the list of watchpoints from vscode
+        const vscodeWatchpointsList = args.breakpoints;
+        // Filter out watchpoints to be deleted, vscode is the golden reference
+        const watchpointsToDelete = existingGDBWatchpointsList.filter(
+            (bp) =>
+                !vscodeWatchpointsList.some((vsbp) => {
+                    if (bp.what?.startsWith('*')) {
+                        return (
+                            vsbp.dataId === bp.what.slice(2, bp.what.length - 1)
+                        );
+                    } else {
+                        return vsbp.dataId === bp.what;
+                    }
+                })
+        );
+        // Delete watchpoints to be deleted from GDB
+        if (watchpointsToDelete.length > 0) {
+            await mi.sendBreakDelete(this.gdb, {
+                breakpoints: watchpointsToDelete.map((bp) => bp.number),
+            });
+            // update GDB watchpoint list
+            existingGDBWatchpointsList = await this.getWatchpointList();
+        }
+        // Create a list of watchpoints to be created
+        const watchpointsToBeCreated = vscodeWatchpointsList.filter(
+            (bp) =>
+                !existingGDBWatchpointsList.some((gdbbp) => {
+                    if (gdbbp.what?.startsWith('*')) {
+                        return (
+                            bp.dataId ===
+                            gdbbp.what.slice(2, gdbbp.what.length - 1)
+                        );
+                    } else {
+                        return bp.dataId === gdbbp.what;
+                    }
+                })
+        );
+        // Create watchpoints in GDB
+        for (const bp of watchpointsToBeCreated) {
+            // If the dataId is an address, written in decimal or hex, then add the dereferencing operator before sending it to GDB
+            if (numberRegex.test(bp.dataId) || bp.dataId.startsWith('0x')) {
+                bp.dataId = `*(${bp.dataId})`;
+            }
+            await mi.sendBreakWatchpoint(this.gdb, bp.dataId, bp.accessType);
+        }
+        // Get the updated list of GDB watchpoints
+        const gdbWatchpoints = await this.getWatchpointList();
+        // Prepare response
+        const actual: DebugProtocol.Breakpoint[] = gdbWatchpoints.map((bp) => {
+            const responseBp: DebugProtocol.Breakpoint = {
+                verified: bp.enabled === 'y',
+                id: parseInt(bp.number, 10),
+            };
+            return responseBp;
+        });
+        response.body = {
+            breakpoints: actual,
+        };
+        this.sendResponse(response);
+        await this.continueIfNeeded();
+    }
+
     protected async setInstructionBreakpointsRequest(
         response: DebugProtocol.SetInstructionBreakpointsResponse,
         args: DebugProtocol.SetInstructionBreakpointsArguments

src/integration-tests/breakpoints.spec.ts

@@ -234,6 +234,66 @@ describe('breakpoints', async function () {
         expect(stoppedEvent.body).to.have.property('reason', 'breakpoint');
     });
 
+    it('sets a data breakpoint for a symbol', async function () {
+        const isEligible = await dc.dataBreakpointInfoRequest({
+            name: 'g_variable',
+        });
+        expect(isEligible.body).not.eq(undefined);
+        expect(isEligible.body.dataId).eq('g_variable');
+        const bpResp = await dc.setDataBreakpointsRequest({
+            breakpoints: [
+                {
+                    dataId: 'g_variable',
+                    accessType: 'read',
+                },
+            ],
+        });
+        expect(bpResp.body.breakpoints.length).eq(1);
+    });
+
+    it('sets a data breakpoint for an address', async function () {
+        await dc.setBreakpointsRequest({
+            source: {
+                name: 'count.c',
+                path: path.join(testProgramsDir, 'count.c'),
+            },
+            breakpoints: [
+                {
+                    column: 1,
+                    line: 4,
+                },
+            ],
+        });
+        await Promise.all([
+            dc.waitForEvent('stopped'),
+            dc.configurationDoneRequest(),
+        ]);
+        const scope = await getScopes(dc);
+        const evalRequestOutput = await dc.evaluateRequest({
+            expression: '&g_variable',
+            context: 'repl',
+            frameId: scope.frame.id,
+        });
+        const addr = evalRequestOutput.body.result.split(' ')[0];
+        const isEligible = await dc.dataBreakpointInfoRequest({
+            name: addr,
+            asAddress: true,
+            bytes: 4,
+        });
+        expect(isEligible.body).not.eq(undefined);
+        expect(isEligible.body.dataId).eq(addr + '+0x4');
+        // Now set the data breakpoint
+        const bpResp = await dc.setDataBreakpointsRequest({
+            breakpoints: [
+                {
+                    dataId: addr,
+                    accessType: 'read',
+                },
+            ],
+        });
+        expect(bpResp.body.breakpoints.length).eq(1);
+    });
+
     it('set an instruction breakpoint', async function () {
         if (gdbNonStop && isRemoteTest) {
             this.skip();

src/integration-tests/test-programs/count.c

@@ -7,3 +7,4 @@ int main() {
     }    
     return 0;
 }
+volatile int g_variable = 0xDEADBEEF; 

src/mi/breakpoint.ts

@@ -29,6 +29,15 @@ export interface MIBreakInsertResponse extends MIResponse {
     multiple?: MIBreakpointInfo[];
 }
 
+// Watchpoint response
+export interface MIBreakWatchResponse extends MIResponse {
+    number: string;
+    exp: string;
+}
+
+// Watchpoint options
+type MIWatchpointInsertOptions = 'read' | 'write' | 'readWrite';
+
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface MIBreakDeleteRequest {}
 
@@ -171,6 +180,17 @@ export async function sendBreakpointInsert(
     return clean;
 }
 
+export async function sendBreakWatchpoint(
+    gdb: IGDBBackend,
+    expression: string,
+    options?: MIWatchpointInsertOptions
+): Promise<MIBreakWatchResponse> {
+    const watchPointType =
+        options === 'read' ? '-r ' : options === 'readWrite' ? '-a ' : '';
+    const command = `-break-watch ${watchPointType}${expression}`;
+    return gdb.sendCommand(command);
+}
+
 export function sendBreakDelete(
     gdb: IGDBBackend,
     request: {

src/mi/var.ts

@@ -52,6 +52,8 @@ export interface MIVarUpdateResponse {
         in_scope: string;
         type_changed: string;
         has_more: string;
+        new_type: string;
+        new_num_children: string;
     }>;
 }
 
@@ -67,6 +69,28 @@ export interface MIVarPathInfoResponse {
     path_expr: string;
 }
 
+export interface MIDebugSymbol {
+    line: string;
+    name: string;
+    type: string;
+    description: string;
+}
+
+export interface MINonDebugSymbol {
+    address: string;
+    name: string;
+}
+export interface MISymbolInfoVarsDebug {
+    filename: string;
+    fullname: string;
+    symbols: MIDebugSymbol[];
+}
+export interface MISymbolInfoVarsResponse {
+    symbols: {
+        debug: MISymbolInfoVarsDebug[];
+        nondebug: MINonDebugSymbol[];
+    };
+}
 function quote(expression: string) {
     return `"${expression}"`;
 }
@@ -204,3 +228,30 @@ export function sendVarSetFormatToHex(
     const command = `-var-set-format ${name} hexadecimal`;
     return gdb.sendCommand(command);
 }
+
+export function sendSymbolInfoVars(
+    gdb: IGDBBackend,
+    params?: {
+        name?: string;
+        type?: string;
+        max_result?: string;
+        non_debug?: boolean;
+    }
+): Promise<MISymbolInfoVarsResponse> {
+    let command = '-symbol-info-variables';
+    if (params) {
+        if (params.name) {
+            command += ` --name ${params.name}`;
+        }
+        if (params.type) {
+            command += ` --type ${params.type}`;
+        }
+        if (params.max_result) {
+            command += ` --max-result ${params.max_result}`;
+        }
+        if (params.non_debug) {
+            command += ' --include-nondebug';
+        }
+    }
+    return gdb.sendCommand(command);
+}