@theia/debug 1.67.0-next.13 → 1.67.0-next.56

package/README.md

@@ -41,7 +41,7 @@ At the back-end we start a debug adapter using `DebugAdapterFactory` and then a
 
 ## Additional Information
 
-* [API documentation for `@theia/debug`](https://eclipse-theia.github.io/theia/docs/next/modules/debug.html)
+* [API documentation for `@theia/debug`](https://eclipse-theia.github.io/theia/docs/next/modules/_theia_debug.html)
 * [Theia - GitHub](https://github.com/eclipse-theia/theia)
 * [Theia - Website](https://theia-ide.org/)
 * [Debug Adapter Protocol](https://github.com/Microsoft/vscode-debugadapter-node/blob/master/protocol/src/debugProtocol.ts)

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "@theia/debug",
-  "version": "1.67.0-next.13+c409d5d18",
+  "version": "1.67.0-next.56+d8f18cc386c",
   "description": "Theia - Debug Extension",
   "dependencies": {
-    "@theia/console": "1.67.0-next.13+c409d5d18",
-    "@theia/core": "1.67.0-next.13+c409d5d18",
-    "@theia/editor": "1.67.0-next.13+c409d5d18",
-    "@theia/filesystem": "1.67.0-next.13+c409d5d18",
-    "@theia/markers": "1.67.0-next.13+c409d5d18",
-    "@theia/monaco": "1.67.0-next.13+c409d5d18",
+    "@theia/console": "1.67.0-next.56+d8f18cc386c",
+    "@theia/core": "1.67.0-next.56+d8f18cc386c",
+    "@theia/editor": "1.67.0-next.56+d8f18cc386c",
+    "@theia/filesystem": "1.67.0-next.56+d8f18cc386c",
+    "@theia/markers": "1.67.0-next.56+d8f18cc386c",
+    "@theia/monaco": "1.67.0-next.56+d8f18cc386c",
     "@theia/monaco-editor-core": "1.96.302",
-    "@theia/output": "1.67.0-next.13+c409d5d18",
-    "@theia/process": "1.67.0-next.13+c409d5d18",
-    "@theia/task": "1.67.0-next.13+c409d5d18",
-    "@theia/terminal": "1.67.0-next.13+c409d5d18",
-    "@theia/test": "1.67.0-next.13+c409d5d18",
-    "@theia/variable-resolver": "1.67.0-next.13+c409d5d18",
-    "@theia/workspace": "1.67.0-next.13+c409d5d18",
+    "@theia/output": "1.67.0-next.56+d8f18cc386c",
+    "@theia/process": "1.67.0-next.56+d8f18cc386c",
+    "@theia/task": "1.67.0-next.56+d8f18cc386c",
+    "@theia/terminal": "1.67.0-next.56+d8f18cc386c",
+    "@theia/test": "1.67.0-next.56+d8f18cc386c",
+    "@theia/variable-resolver": "1.67.0-next.56+d8f18cc386c",
+    "@theia/workspace": "1.67.0-next.56+d8f18cc386c",
     "@vscode/debugprotocol": "^1.51.0",
     "fast-deep-equal": "^3.1.3",
     "jsonc-parser": "^2.2.0",
@@ -64,5 +64,5 @@
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "c409d5d18d8c4f5a722f87b37ea9d6fd5af47ea8"
+  "gitHead": "d8f18cc386c45a736cd193d42eab02c8f64c6b10"
 }

package/src/browser/breakpoint/breakpoint-manager.ts

@@ -21,7 +21,8 @@ import { StorageService } from '@theia/core/lib/browser';
 import { Marker } from '@theia/markers/lib/common/marker';
 import { MarkerManager } from '@theia/markers/lib/browser/marker-manager';
 import URI from '@theia/core/lib/common/uri';
-import { SourceBreakpoint, BREAKPOINT_KIND, ExceptionBreakpoint, FunctionBreakpoint, BaseBreakpoint, InstructionBreakpoint } from './breakpoint-marker';
+import { SourceBreakpoint, BREAKPOINT_KIND, ExceptionBreakpoint, FunctionBreakpoint, BaseBreakpoint, InstructionBreakpoint, DataBreakpoint } from './breakpoint-marker';
+import { DebugProtocol } from '@vscode/debugprotocol';
 
 export interface BreakpointsChangeEvent<T extends BaseBreakpoint> {
     uri: URI
@@ -32,6 +33,7 @@ export interface BreakpointsChangeEvent<T extends BaseBreakpoint> {
 export type SourceBreakpointsChangeEvent = BreakpointsChangeEvent<SourceBreakpoint>;
 export type FunctionBreakpointsChangeEvent = BreakpointsChangeEvent<FunctionBreakpoint>;
 export type InstructionBreakpointsChangeEvent = BreakpointsChangeEvent<InstructionBreakpoint>;
+export type DataBreakpointsChangeEvent = BreakpointsChangeEvent<DataBreakpoint>;
 
 @injectable()
 export class BreakpointManager extends MarkerManager<SourceBreakpoint> {
@@ -42,6 +44,8 @@ export class BreakpointManager extends MarkerManager<SourceBreakpoint> {
 
     static INSTRUCTION_URI = new URI('debug:instruction://');
 
+    static DATA_URI = new URI('debug:data://');
+
     protected readonly owner = 'breakpoint';
 
     @inject(StorageService)
@@ -60,6 +64,9 @@ export class BreakpointManager extends MarkerManager<SourceBreakpoint> {
     protected readonly onDidChangeInstructionBreakpointsEmitter = new Emitter<InstructionBreakpointsChangeEvent>();
     readonly onDidChangeInstructionBreakpoints = this.onDidChangeInstructionBreakpointsEmitter.event;
 
+    protected readonly onDidChangeDataBreakpointsEmitter = new Emitter<DataBreakpointsChangeEvent>();
+    readonly onDidChangeDataBreakpoints = this.onDidChangeDataBreakpointsEmitter.event;
+
     override setMarkers(uri: URI, owner: string, newMarkers: SourceBreakpoint[]): Marker<SourceBreakpoint>[] {
         const result = this.findMarkers({ uri, owner });
         const added: SourceBreakpoint[] = [];
@@ -254,21 +261,8 @@ export class BreakpointManager extends MarkerManager<SourceBreakpoint> {
     }
 
     protected setInstructionBreakpoints(newBreakpoints: InstructionBreakpoint[]): void {
-        const oldBreakpoints = new Map(this.instructionBreakpoints.map(breakpoint => [breakpoint.id, breakpoint]));
-        const currentBreakpoints = new Map(newBreakpoints.map(breakpoint => [breakpoint.id, breakpoint]));
-        const added = [];
-        const changed = [];
-        for (const [id, breakpoint] of currentBreakpoints.entries()) {
-            const old = oldBreakpoints.get(id);
-            if (old) {
-                changed.push(old);
-            } else {
-                added.push(breakpoint);
-            }
-            oldBreakpoints.delete(id);
-        }
-        const removed = Array.from(oldBreakpoints.values());
-        this.instructionBreakpoints = Array.from(currentBreakpoints.values());
+        const { added, removed, changed } = diff(this.instructionBreakpoints, newBreakpoints, bp => bp.id);
+        this.instructionBreakpoints = newBreakpoints.slice();
         this.fireOnDidChangeMarkers(BreakpointManager.INSTRUCTION_URI);
         this.onDidChangeInstructionBreakpointsEmitter.fire({ uri: BreakpointManager.INSTRUCTION_URI, added, removed, changed });
     }
@@ -307,10 +301,45 @@ export class BreakpointManager extends MarkerManager<SourceBreakpoint> {
         this.setInstructionBreakpoints([]);
     }
 
+    protected dataBreakpoints: DataBreakpoint[] = [];
+
+    getDataBreakpoints(): readonly DataBreakpoint[] {
+        return Object.freeze(this.dataBreakpoints.slice());
+    }
+
+    setDataBreakpoints(breakpoints: DataBreakpoint[]): void {
+        const { added, removed, changed } = diff(this.dataBreakpoints, breakpoints, ({ id }) => id);
+        this.dataBreakpoints = breakpoints.slice();
+        this.fireOnDidChangeMarkers(BreakpointManager.DATA_URI);
+        this.onDidChangeDataBreakpointsEmitter.fire({ uri: BreakpointManager.DATA_URI, added, removed, changed });
+    }
+
+    addDataBreakpoint(breakpoint: DataBreakpoint): void {
+        this.setDataBreakpoints(this.dataBreakpoints.concat(breakpoint));
+    }
+
+    updateDataBreakpoint(id: string, options: { enabled?: boolean; raw?: Partial<Omit<DebugProtocol.DataBreakpoint, 'dataId'>> }): void {
+        const breakpoint = this.dataBreakpoints.find(bp => bp.id === id);
+        if (!breakpoint) { return; }
+        Object.assign(breakpoint.raw, options);
+        breakpoint.enabled = options.enabled ?? breakpoint.enabled;
+        this.fireOnDidChangeMarkers(BreakpointManager.DATA_URI);
+        this.onDidChangeDataBreakpointsEmitter.fire({ uri: BreakpointManager.DATA_URI, added: [], removed: [], changed: [breakpoint] });
+    }
+
+    removeDataBreakpoint(id: string): void {
+        const index = this.dataBreakpoints.findIndex(bp => bp.id === id);
+        if (~index) { return; }
+        const removed = this.dataBreakpoints.splice(index);
+        this.fireOnDidChangeMarkers(BreakpointManager.DATA_URI);
+        this.onDidChangeDataBreakpointsEmitter.fire({ uri: BreakpointManager.DATA_URI, added: [], removed, changed: [] });
+    }
+
     removeBreakpoints(): void {
         this.cleanAllMarkers();
         this.setFunctionBreakpoints([]);
         this.setInstructionBreakpoints([]);
+        this.setDataBreakpoints([]);
     }
 
     async load(): Promise<void> {
@@ -352,6 +381,11 @@ export class BreakpointManager extends MarkerManager<SourceBreakpoint> {
         if (this.instructionBreakpoints.length) {
             data.instructionBreakpoints = this.instructionBreakpoints;
         }
+        const dataBreakpointsToStore = this.dataBreakpoints.filter(candidate => candidate.info.canPersist);
+        if (dataBreakpointsToStore.length) {
+            data.dataBreakpoints = dataBreakpointsToStore;
+        }
+
         this.storage.setData('breakpoints', data);
     }
 
@@ -365,5 +399,24 @@ export namespace BreakpointManager {
         exceptionBreakpoints?: ExceptionBreakpoint[];
         functionBreakpoints?: FunctionBreakpoint[];
         instructionBreakpoints?: InstructionBreakpoint[];
+        dataBreakpoints?: DataBreakpoint[];
+    }
+}
+
+export function diff<T>(prevs: T[], nexts: T[], toKey: (member: T) => string): { added: T[], removed: T[], changed: T[] } {
+    const old = new Map(prevs.map(item => [toKey(item), item]));
+    const current = new Map(nexts.map(item => [toKey(item), item]));
+    const added = [];
+    const changed = [];
+    for (const [id, next] of current.entries()) {
+        const prev = old.get(id);
+        if (prev) {
+            changed.push(prev);
+        } else {
+            added.push(next);
+        }
+        old.delete(id);
     }
+    const removed = Array.from(old.values());
+    return { added, removed, changed };
 }

package/src/browser/breakpoint/breakpoint-marker.ts

@@ -102,3 +102,41 @@ export namespace InstructionBreakpoint {
         return isObject<InstructionBreakpoint>(arg) && isString(arg.instructionReference);
     }
 }
+
+export type DataBreakpointInfo = DebugProtocol.DataBreakpointInfoResponse['body'];
+
+export interface DataBreakpointAddressSource {
+    type: DataBreakpointSourceType.Address;
+    address: string;
+    bytes: number;
+}
+
+export interface DataBreakpointVariableSource {
+    type: DataBreakpointSourceType.Variable;
+    variable: string;
+}
+
+export const enum DataBreakpointSourceType {
+    Variable,
+    Address,
+}
+
+export type DataBreakpointSource = | DataBreakpointAddressSource | DataBreakpointVariableSource;
+
+export interface DataBreakpoint extends BaseBreakpoint {
+    raw: DebugProtocol.DataBreakpoint;
+    info: DataBreakpointInfo;
+    source: DataBreakpointSource;
+}
+
+export namespace DataBreakpoint {
+    export function create(raw: DebugProtocol.DataBreakpoint, info: DataBreakpointInfo, source: DataBreakpointSource, ref?: DataBreakpoint): DataBreakpoint {
+        return {
+            raw,
+            info,
+            id: ref?.id ?? UUID.uuid4(),
+            enabled: ref?.enabled ?? true,
+            source
+        };
+    }
+}

package/src/browser/breakpoint/debug-data-breakpoint-actions.ts

@@ -0,0 +1,170 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { nls, CommandHandler, DisposableCollection, MessageService, QuickInputService, Disposable } from '@theia/core';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { DebugViewModel } from '../view/debug-view-model';
+import { TreeElementNode } from '@theia/core/lib/browser/source-tree';
+import { DebugDataBreakpoint } from '../model/debug-data-breakpoint';
+import { DataBreakpoint, DataBreakpointSource, DataBreakpointSourceType } from './breakpoint-marker';
+import { DebugProtocol } from '@vscode/debugprotocol';
+import { BreakpointManager } from './breakpoint-manager';
+import { TreeNode, Widget } from '@theia/core/lib/browser';
+import { DebugBreakpointsWidget } from '../view/debug-breakpoints-widget';
+
+// Adapted from https://github.com/microsoft/vscode/blob/9c883243a89e7ec3b730d3746fbb1e836d5e4f52/src/vs/workbench/contrib/debug/browser/breakpointsView.ts#L1506-L1625
+
+@injectable()
+export class AddOrEditDataBreakpointAddress implements CommandHandler {
+    @inject(DebugViewModel)
+    protected readonly viewModel: DebugViewModel;
+    @inject(QuickInputService)
+    protected readonly quickInputService: QuickInputService;
+    @inject(MessageService)
+    protected readonly messageService: MessageService;
+    @inject(BreakpointManager)
+    protected readonly breakpointManager: BreakpointManager;
+
+    isEnabled(node?: TreeElementNode): boolean {
+        return !!this.viewModel.currentSession?.capabilities.supportsDataBreakpoints
+            && this.viewModel.currentSession?.capabilities.supportsDataBreakpointBytes !== false
+            && this.isAddressBreakpointOrDebugWidget(node);
+    }
+
+    isVisible(node?: TreeElementNode): boolean {
+        return this.isEnabled(node);
+    }
+
+    protected isAddressBreakpointOrDebugWidget(candidate?: unknown): boolean {
+        return !candidate ? true // Probably command palette
+            : TreeNode.is(candidate) && TreeElementNode.is(candidate)
+                ? candidate.element instanceof DebugDataBreakpoint && candidate.element.origin.source.type === DataBreakpointSourceType.Address
+                : candidate instanceof Widget
+                    ? candidate instanceof DebugBreakpointsWidget
+                    : false;
+    }
+
+    async execute(node?: TreeElementNode): Promise<void> {
+        const existingBreakpoint = TreeElementNode.is(node) && node.element instanceof DebugDataBreakpoint ? node.element : undefined;
+        const session = this.viewModel.currentSession;
+        if (!session) {
+            return;
+        }
+
+        let defaultValue = undefined;
+        if (existingBreakpoint?.origin.source.type === DataBreakpointSourceType.Address) {
+            defaultValue = `${existingBreakpoint.origin.source.address} + ${existingBreakpoint.origin.source.bytes}`;
+        }
+
+        const quickInput = this.quickInputService;
+        const range = await this.getRange(defaultValue);
+        if (!range) {
+            return;
+        }
+
+        const info = await session.sendRequest('dataBreakpointInfo', { asAddress: true, name: range.address, bytes: range.bytes })
+            .then(({ body }) => body)
+            .catch(e => { this.messageService.error(nls.localizeByDefault('Failed to set data breakpoint at {0}: {1}', range.address, e.message)); });
+        if (!info?.dataId) {
+            return;
+        }
+
+        let accessType: DebugProtocol.DataBreakpointAccessType = 'write';
+        if (info.accessTypes && info.accessTypes?.length > 1) {
+            const accessTypes = info.accessTypes.map(type => ({ label: type }));
+            const selectedAccessType = await quickInput.pick(accessTypes, { placeHolder: nls.localizeByDefault('Select the access type to monitor') });
+            if (!selectedAccessType) {
+                return;
+            }
+
+            accessType = selectedAccessType.label;
+        }
+
+        const src: DataBreakpointSource = { type: DataBreakpointSourceType.Address, ...range };
+        if (existingBreakpoint) {
+            this.breakpointManager.removeDataBreakpoint(existingBreakpoint.id);
+        }
+
+        this.breakpointManager.addDataBreakpoint(DataBreakpoint.create({ dataId: info.dataId, accessType }, { ...info, canPersist: true }, src));
+    }
+
+    private getRange(defaultValue?: string): Promise<{ address: string, bytes: number } | undefined> {
+        return new Promise(resolve => {
+            const disposables = new DisposableCollection();
+            const addDisposable = <T extends Disposable>(disposable: T): T => {
+                disposables.push(disposable);
+                return disposable;
+            };
+            const input = addDisposable(this.quickInputService.createInputBox());
+            input.prompt = nls.localizeByDefault('Enter a memory range in which to break');
+            input.placeholder = nls.localizeByDefault('Absolute range (0x1234 - 0x1300) or range of bytes after an address (0x1234 + 0xff)');
+            if (defaultValue) {
+                input.value = defaultValue;
+                input.valueSelection = [0, defaultValue.length];
+            }
+            addDisposable(input.onDidChangeValue(e => {
+                const err = this.parseAddress(e, false);
+                input.validationMessage = err?.error;
+            }));
+            addDisposable(input.onDidAccept(() => {
+                const r = this.parseAddress(input.value ?? '', true);
+                if ('error' in r) {
+                    input.validationMessage = r.error;
+                } else {
+                    resolve(r);
+                }
+                input.dispose();
+            }));
+            addDisposable(input.onDidHide(() => {
+                resolve(undefined);
+                disposables.dispose();
+            }));
+            input.ignoreFocusOut = true;
+            input.show();
+        });
+    }
+
+    private parseAddress(range: string, isFinal: false): { error: string } | undefined;
+    private parseAddress(range: string, isFinal: true): { error: string } | { address: string; bytes: number };
+    private parseAddress(range: string, isFinal: boolean): { error: string } | { address: string; bytes: number } | undefined {
+        const parts = /^(\S+)\s*(?:([+-])\s*(\S+))?/.exec(range);
+        if (!parts) {
+            return { error: nls.localizeByDefault('Address should be a range of numbers the form "[Start] - [End]" or "[Start] + [Bytes]"') };
+        }
+
+        const isNum = (e: string) => isFinal ? /^0x[0-9a-f]*|[0-9]*$/i.test(e) : /^0x[0-9a-f]+|[0-9]+$/i.test(e);
+        const [, startStr, sign = '+', endStr = '1'] = parts;
+
+        for (const n of [startStr, endStr]) {
+            if (!isNum(n)) {
+                return { error: nls.localizeByDefault('Number must be a decimal integer or hex value starting with \"0x\", got {0}', n) };
+            }
+        }
+
+        if (!isFinal) {
+            return;
+        }
+
+        const start = BigInt(startStr);
+        const end = BigInt(endStr);
+        const address = `0x${start.toString(16)}`;
+        if (sign === '-') {
+            return { address, bytes: Number(start - end) };
+        }
+
+        return { address, bytes: Number(end) };
+    }
+}

package/src/browser/console/debug-console-items.tsx

@@ -51,8 +51,12 @@ export class ExpressionContainer implements CompositeConsoleItem {
         return undefined;
     }
 
+    get reference(): number | undefined {
+        return this.variablesReference;
+    }
+
     get hasElements(): boolean {
-        return !!this.variablesReference;
+        return this.variablesReference !== undefined;
     }
 
     protected elements: Promise<ExpressionContainer[]> | undefined;

package/src/browser/debug-frontend-application-contribution.ts

@@ -63,6 +63,7 @@ import { ConsoleContentWidget } from '@theia/console/lib/browser/console-content
 import { ConsoleContextMenu } from '@theia/console/lib/browser/console-contribution';
 import { DebugHoverWidget } from './editor/debug-hover-widget';
 import { DebugExpressionProvider } from './editor/debug-expression-provider';
+import { AddOrEditDataBreakpointAddress } from './breakpoint/debug-data-breakpoint-actions';
 
 export namespace DebugMenus {
     export const DEBUG = [...MAIN_MENU_BAR, '6_debug'];
@@ -198,6 +199,11 @@ export namespace DebugCommands {
         category: DEBUG_CATEGORY,
         label: 'Add Function Breakpoint',
     });
+    export const ADD_DATA_BREAKPOINT = Command.toDefaultLocalizedCommand({
+        id: 'debug.breakpoint.add.data',
+        category: DEBUG_CATEGORY,
+        label: 'Add Data Breakpoint at Address'
+    });
     export const ENABLE_SELECTED_BREAKPOINTS = Command.toLocalizedCommand({
         id: 'debug.breakpoint.enableSelected',
         category: DEBUG_CATEGORY,
@@ -483,6 +489,9 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
     @inject(MessageService)
     protected readonly messageService: MessageService;
 
+    @inject(AddOrEditDataBreakpointAddress)
+    protected readonly AddOrEditDataBreakpointAddress: AddOrEditDataBreakpointAddress;
+
     constructor() {
         super({
             widgetId: DebugWidget.ID,
@@ -612,6 +621,7 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             DebugCommands.INLINE_BREAKPOINT,
             DebugCommands.ADD_FUNCTION_BREAKPOINT,
             DebugCommands.ADD_LOGPOINT,
+            DebugCommands.ADD_DATA_BREAKPOINT
         );
         registerMenuActions(DebugMenus.DEBUG_BREAKPOINTS,
             DebugCommands.ENABLE_ALL_BREAKPOINTS,
@@ -671,6 +681,7 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
 
         registerMenuActions(DebugBreakpointsWidget.EDIT_MENU,
             DebugCommands.EDIT_BREAKPOINT,
+            { ...DebugCommands.ADD_DATA_BREAKPOINT, label: nls.localizeByDefault('Edit Address...'), originalLabel: 'Edit Address...' },
             DebugCommands.EDIT_LOGPOINT,
             DebugCommands.EDIT_BREAKPOINT_CONDITION
         );
@@ -863,6 +874,7 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             isEnabled: widget => !(widget instanceof Widget) || widget instanceof DebugBreakpointsWidget,
             isVisible: widget => !(widget instanceof Widget) || widget instanceof DebugBreakpointsWidget
         });
+        registry.registerCommand(DebugCommands.ADD_DATA_BREAKPOINT, this.AddOrEditDataBreakpointAddress);
         registry.registerCommand(DebugCommands.ENABLE_ALL_BREAKPOINTS, {
             execute: () => this.breakpointManager.enableAllBreakpoints(true),
             isEnabled: () => this.breakpointManager.hasBreakpoints()
@@ -1314,6 +1326,13 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             icon: codicon('add'),
             tooltip: DebugCommands.ADD_FUNCTION_BREAKPOINT.label
         });
+        toolbar.registerItem({
+            id: DebugCommands.ADD_DATA_BREAKPOINT.id,
+            command: DebugCommands.ADD_DATA_BREAKPOINT.id,
+            icon: codicon('variable-group'),
+            tooltip: DebugCommands.ADD_DATA_BREAKPOINT.label,
+            onDidChange: this.manager.onDidStopDebugSession as unknown as Event<void>
+        });
         updateToggleBreakpointsEnabled();
         this.breakpointManager.onDidChangeBreakpoints(updateToggleBreakpointsEnabled);
         toolbar.registerItem(toggleBreakpointsEnabled);

package/src/browser/debug-frontend-module.ts

@@ -64,6 +64,7 @@ import { bindDisassemblyView } from './disassembly-view/disassembly-view-contrib
 import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
 import { ICodeEditorService } from '@theia/monaco-editor-core/esm/vs/editor/browser/services/codeEditorService';
 import { DebugSessionConfigurationLabelProvider } from './debug-session-configuration-label-provider';
+import { AddOrEditDataBreakpointAddress } from './breakpoint/debug-data-breakpoint-actions';
 
 export default new ContainerModule((bind: interfaces.Bind) => {
     bindContributionProvider(bind, DebugContribution);
@@ -135,4 +136,5 @@ export default new ContainerModule((bind: interfaces.Bind) => {
     bindDisassemblyView(bind);
 
     bind(DebugSessionConfigurationLabelProvider).toSelf().inSingletonScope();
+    bind(AddOrEditDataBreakpointAddress).toSelf().inSingletonScope();
 });

package/src/browser/debug-session-manager.ts

@@ -38,6 +38,7 @@ import { DebugFunctionBreakpoint } from './model/debug-function-breakpoint';
 import * as monaco from '@theia/monaco-editor-core';
 import { DebugInstructionBreakpoint } from './model/debug-instruction-breakpoint';
 import { DebugSessionConfigurationLabelProvider } from './debug-session-configuration-label-provider';
+import { DebugDataBreakpoint } from './model/debug-data-breakpoint';
 
 export interface WillStartDebugSession extends WaitUntilEvent {
 }
@@ -449,6 +450,15 @@ export class DebugSessionManager {
     }
 
     protected cleanup(session: DebugSession): void {
+        // Data breakpoints belonging to this session that can't persist and aren't verified by some other session should be removed.
+        const currentDataBreakpoints = this.breakpoints.getDataBreakpoints();
+        const toRemove = currentDataBreakpoints.filter(candidate => !candidate.info.canPersist && this.sessions.every(otherSession => otherSession !== session
+            && otherSession.getDataBreakpoints().every(otherSessionBp => otherSessionBp.id !== candidate.id || !otherSessionBp.verified)))
+            .map(bp => bp.id);
+        const toRetain = this.breakpoints.getDataBreakpoints().filter(candidate => !toRemove.includes(candidate.id));
+        if (currentDataBreakpoints.length !== toRetain.length) {
+            this.breakpoints.setDataBreakpoints(toRetain);
+        }
         if (this.remove(session.id)) {
             this.onDidDestroyDebugSessionEmitter.fire(session);
         }
@@ -604,6 +614,14 @@ export class DebugSessionManager {
         return this.breakpoints.getInstructionBreakpoints().map(origin => new DebugInstructionBreakpoint(origin, { labelProvider, breakpoints, editorManager }));
     }
 
+    getDataBreakpoints(session = this.currentSession): DebugDataBreakpoint[] {
+        if (session && session.state > DebugState.Initializing) {
+            return session.getDataBreakpoints();
+        }
+        const { labelProvider, breakpoints, editorManager } = this;
+        return this.breakpoints.getDataBreakpoints().map(origin => new DebugDataBreakpoint(origin, { labelProvider, breakpoints, editorManager }));
+    }
+
     getBreakpoints(session?: DebugSession): DebugSourceBreakpoint[];
     getBreakpoints(uri: URI, session?: DebugSession): DebugSourceBreakpoint[];
     getBreakpoints(arg?: URI | DebugSession, arg2?: DebugSession): DebugSourceBreakpoint[] {

package/src/browser/debug-session.tsx

@@ -46,6 +46,7 @@ import { DebugInstructionBreakpoint } from './model/debug-instruction-breakpoint
 import { nls } from '@theia/core';
 import { TestService, TestServices } from '@theia/test/lib/browser/test-service';
 import { DebugSessionManager } from './debug-session-manager';
+import { DebugDataBreakpoint } from './model/debug-data-breakpoint';
 
 export enum DebugState {
     Inactive,
@@ -624,6 +625,14 @@ export class DebugSession implements CompositeTreeElement {
         return this.breakpoints.getInstructionBreakpoints().map(origin => new DebugInstructionBreakpoint(origin, this.asDebugBreakpointOptions()));
     }
 
+    getDataBreakpoints(): DebugDataBreakpoint[] {
+        if (this.capabilities.supportsDataBreakpoints) {
+            return this.getBreakpoints(BreakpointManager.DATA_URI)
+                .filter((breakpoint): breakpoint is DebugDataBreakpoint => breakpoint instanceof DebugDataBreakpoint);
+        }
+        return this.breakpoints.getDataBreakpoints().map(origin => new DebugDataBreakpoint(origin, this.asDebugBreakpointOptions()));
+    }
+
     getBreakpoints(uri?: URI): DebugBreakpoint[] {
         if (uri) {
             return this._breakpoints.get(uri.toString()) || [];
@@ -730,6 +739,8 @@ export class DebugSession implements CompositeTreeElement {
                 await this.sendFunctionBreakpoints(affectedUri);
             } else if (affectedUri.toString() === BreakpointManager.INSTRUCTION_URI.toString()) {
                 await this.sendInstructionBreakpoints();
+            } else if (affectedUri.isEqual(BreakpointManager.DATA_URI)) {
+                await this.sendDataBreakpoints();
             } else {
                 await this.sendSourceBreakpoints(affectedUri, sourceModified);
             }
@@ -855,6 +866,25 @@ export class DebugSession implements CompositeTreeElement {
         this.setBreakpoints(BreakpointManager.INSTRUCTION_URI, all);
     }
 
+    protected async sendDataBreakpoints(): Promise<void> {
+        if (!this.capabilities.supportsDataBreakpoints) { return; }
+        const known = this._breakpoints.get(BreakpointManager.DATA_URI.toString());
+        const all = this.breakpoints.getDataBreakpoints().map<DebugDataBreakpoint>(bp =>
+            known?.find((candidate): candidate is DebugDataBreakpoint => candidate instanceof DebugDataBreakpoint && candidate.id === bp.id)
+            ?? new DebugDataBreakpoint(bp, this.asDebugBreakpointOptions())
+        );
+        const enabled = all.filter(bp => bp.enabled);
+        try {
+            const response = await this.sendRequest('setDataBreakpoints', {
+                breakpoints: enabled.map(({ origin }) => origin.raw)
+            });
+            response.body.breakpoints.forEach((raw, index) => enabled[index].update({ raw }));
+        } catch {
+            enabled.forEach(breakpoint => breakpoint.update({ raw: { verified: false } }));
+        }
+        this.setBreakpoints(BreakpointManager.DATA_URI, all);
+    }
+
     protected setBreakpoints(uri: URI, breakpoints: DebugBreakpoint[]): void {
         this._breakpoints.set(uri.toString(), breakpoints);
         this.fireDidChangeBreakpoints(uri);
@@ -890,6 +920,7 @@ export class DebugSession implements CompositeTreeElement {
             }
             yield BreakpointManager.FUNCTION_URI;
             yield BreakpointManager.EXCEPTION_URI;
+            yield BreakpointManager.DATA_URI;
         }
     }