@codingame/monaco-vscode-debug-service-override 1.82.6 → 1.83.0-next.0

package/vscode/src/vs/workbench/contrib/debug/browser/disassemblyView.js

@@ -1,47 +1,50 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { PixelRatio } from 'monaco-editor/esm/vs/base/browser/browser.js';
 import { append, $, addStandardDisposableListener } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { binarySearch2 } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { dispose, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { applyFontInfo } from 'monaco-editor/esm/vs/editor/browser/config/domFontInfo.js';
+import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
 import { BareFontInfo } from 'monaco-editor/esm/vs/editor/common/config/fontInfo.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { StringBuilder } from 'monaco-editor/esm/vs/editor/common/core/stringBuilder.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { WorkbenchTable } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
 import { editorBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
 import { EditorPane } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorPane';
-import { DISASSEMBLY_VIEW_ID, CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
-import { breakpoint, debugBreakpointHint, debugStackframe, debugStackframeFocused } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
-import { StringBuilder } from 'monaco-editor/esm/vs/editor/common/core/stringBuilder.js';
-import { dispose, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { topStackFrameColor, focusedStackFrameColor } from './callStackEditorContribution.js';
+import { breakpoint, debugBreakpointHint, debugStackframe, debugStackframeFocused } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
+import { DISASSEMBLY_VIEW_ID, CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { InstructionBreakpoint } from '../common/debugModel.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
 import { getUriFromSource } from '../common/debugSource.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { isUri } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
-import { isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
-import { applyFontInfo } from 'monaco-editor/esm/vs/editor/browser/config/domFontInfo.js';
-import { binarySearch2 } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { isUri, sourcesEqual } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
 
 var DisassemblyView_1, BreakpointRenderer_1, InstructionRenderer_1;
 const disassemblyNotAvailable = {
     allowBreakpoint: false,
     isBreakpointSet: false,
     isBreakpointEnabled: false,
+    instructionReference: '',
+    instructionOffset: 0,
+    instructionReferenceOffset: 0,
+    address: 0n,
     instruction: {
         address: '-1',
         instruction: ( (localize('instructionNotAvailable', "Disassembly not available.")))
     },
-    instructionAddress: BigInt(-1)
 };
 let DisassemblyView = class DisassemblyView extends EditorPane {
     static { DisassemblyView_1 = this; }
@@ -54,8 +57,9 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
         this._instructionBpList = [];
         this._enableSourceCodeRender = true;
         this._loadingLock = false;
+        this._referenceToMemoryAddress = ( (new Map()));
         this._disassembledInstructions = undefined;
-        this._onDidChangeStackFrame = ( (new Emitter()));
+        this._onDidChangeStackFrame = this._register(( (new Emitter({ leakWarningThreshold: 1000 }))));
         this._previousDebuggingState = _debugService.state;
         this._fontInfo = BareFontInfo.createFromRawSettings(_configurationService.getValue('editor'), PixelRatio.value);
         this._register(_configurationService.onDidChangeConfiguration(e => {
@@ -66,7 +70,6 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                 const newValue = this._configurationService.getValue('debug').disassemblyView.showSourceCode;
                 if (this._enableSourceCodeRender !== newValue) {
                     this._enableSourceCodeRender = newValue;
-                    this.reloadDisassembly(undefined);
                 }
                 else {
                     this._disassembledInstructions?.rerender();
@@ -77,24 +80,42 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
     get fontInfo() { return this._fontInfo; }
     get currentInstructionAddresses() {
         return (
-             (( (( (this._debugService.getModel().getSessions(false).
+             (( (( (( (this._debugService.getModel().getSessions(false).
                 map(session => session.getAllThreads()))).
                 reduce((prev, curr) => prev.concat(curr), []).
                 map(thread => thread.getTopStackFrame()))).
-                map(frame => frame?.instructionPointerReference))
+                map(frame => frame?.instructionPointerReference))).
+                map(ref => ref ? this.getReferenceAddress(ref) : undefined))
         );
     }
-    get focusedCurrentInstructionAddress() {
+    get focusedCurrentInstructionReference() {
         return this._debugService.getViewModel().focusedStackFrame?.thread.getTopStackFrame()?.instructionPointerReference;
     }
-    get focusedInstructionAddress() {
+    get focusedCurrentInstructionAddress() {
+        const ref = this.focusedCurrentInstructionReference;
+        return ref ? this.getReferenceAddress(ref) : undefined;
+    }
+    get focusedInstructionReference() {
         return this._debugService.getViewModel().focusedStackFrame?.instructionPointerReference;
     }
+    get focusedInstructionAddress() {
+        const ref = this.focusedInstructionReference;
+        return ref ? this.getReferenceAddress(ref) : undefined;
+    }
     get isSourceCodeRender() { return this._enableSourceCodeRender; }
     get debugSession() {
         return this._debugService.getViewModel().focusedSession;
     }
     get onDidChangeStackFrame() { return this._onDidChangeStackFrame.event; }
+    get focusedAddressAndOffset() {
+        const element = this._disassembledInstructions?.getFocusedElements()[0];
+        if (!element) {
+            return undefined;
+        }
+        const reference = element.instructionReference;
+        const offset = Number(element.address - this.getReferenceAddress(reference));
+        return { reference, offset, address: element.address };
+    }
     createEditor(parent) {
         this._enableSourceCodeRender = this._configurationService.getValue('debug').disassemblyView.showSourceCode;
         const lineHeight = this.fontInfo.lineHeight;
@@ -104,7 +125,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                 this.headerRowHeight = 0;
             }
             getHeight(row) {
-                if (thisOM.isSourceCodeRender && row.instruction.location?.path && row.instruction.line) {
+                if (thisOM.isSourceCodeRender && row.showSourceLocation && row.instruction.location?.path && row.instruction.line) {
                     if (row.instruction.endLine) {
                         return lineHeight * (row.instruction.endLine - row.instruction.line + 2);
                     }
@@ -148,17 +169,19 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
             accessibilityProvider: ( (new AccessibilityProvider())),
             mouseSupport: false
         }));
-        this.reloadDisassembly();
+        if (this.focusedInstructionReference) {
+            this.reloadDisassembly(this.focusedInstructionReference, 0);
+        }
         this._register(this._disassembledInstructions.onDidScroll(e => {
             if (this._loadingLock) {
                 return;
             }
             if (e.oldScrollTop > e.scrollTop && e.scrollTop < e.height) {
                 this._loadingLock = true;
-                const topElement = Math.floor(e.scrollTop / this.fontInfo.lineHeight) + DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD;
-                this.scrollUp_LoadDisassembledInstructions(DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD).then((success) => {
-                    if (success) {
-                        this._disassembledInstructions.reveal(topElement, 0);
+                const prevTop = Math.floor(e.scrollTop / this.fontInfo.lineHeight);
+                this.scrollUp_LoadDisassembledInstructions(DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD).then((loaded) => {
+                    if (loaded > 0) {
+                        this._disassembledInstructions.reveal(prevTop + loaded, 0);
                     }
                     this._loadingLock = false;
                 });
@@ -168,18 +191,18 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                 this.scrollDown_LoadDisassembledInstructions(DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD).then(() => { this._loadingLock = false; });
             }
         }));
-        this._register(this._debugService.getViewModel().onDidFocusStackFrame((stackFrame) => {
-            if (this._disassembledInstructions) {
-                this.goToAddress();
-                this._onDidChangeStackFrame.fire();
+        this._register(this._debugService.getViewModel().onDidFocusStackFrame(({ stackFrame }) => {
+            if (this._disassembledInstructions && stackFrame?.instructionPointerReference) {
+                this.goToInstructionAndOffset(stackFrame.instructionPointerReference, 0);
             }
+            this._onDidChangeStackFrame.fire();
         }));
         this._register(this._debugService.getModel().onDidChangeBreakpoints(bpEvent => {
             if (bpEvent && this._disassembledInstructions) {
                 let changed = false;
                 bpEvent.added?.forEach((bp) => {
                     if (bp instanceof InstructionBreakpoint) {
-                        const index = this.getIndexFromAddress(bp.instructionReference);
+                        const index = this.getIndexFromReferenceAndOffset(bp.instructionReference, bp.offset);
                         if (index >= 0) {
                             this._disassembledInstructions.row(index).isBreakpointSet = true;
                             this._disassembledInstructions.row(index).isBreakpointEnabled = bp.enabled;
@@ -189,7 +212,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                 });
                 bpEvent.removed?.forEach((bp) => {
                     if (bp instanceof InstructionBreakpoint) {
-                        const index = this.getIndexFromAddress(bp.instructionReference);
+                        const index = this.getIndexFromReferenceAndOffset(bp.instructionReference, bp.offset);
                         if (index >= 0) {
                             this._disassembledInstructions.row(index).isBreakpointSet = false;
                             changed = true;
@@ -198,7 +221,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                 });
                 bpEvent.changed?.forEach((bp) => {
                     if (bp instanceof InstructionBreakpoint) {
-                        const index = this.getIndexFromAddress(bp.instructionReference);
+                        const index = this.getIndexFromReferenceAndOffset(bp.instructionReference, bp.offset);
                         if (index >= 0) {
                             if (this._disassembledInstructions.row(index).isBreakpointEnabled !== bp.enabled) {
                                 this._disassembledInstructions.row(index).isBreakpointEnabled = bp.enabled;
@@ -208,6 +231,9 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                     }
                 });
                 this._instructionBpList = this._debugService.getModel().getInstructionBreakpoints();
+                for (const bp of this._instructionBpList) {
+                    this.primeMemoryReference(bp.instructionReference);
+                }
                 if (changed) {
                     this._onDidChangeStackFrame.fire();
                 }
@@ -216,24 +242,35 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
         this._register(this._debugService.onDidChangeState(e => {
             if (((e === 3  || e === 2) ) &&
                 ((this._previousDebuggingState !== 3  && this._previousDebuggingState !== 2) )) {
-                this._disassembledInstructions?.splice(0, this._disassembledInstructions.length, [disassemblyNotAvailable]);
+                this.clear();
                 this._enableSourceCodeRender = this._configurationService.getValue('debug').disassemblyView.showSourceCode;
             }
             this._previousDebuggingState = e;
+            this._onDidChangeStackFrame.fire();
         }));
     }
     layout(dimension) {
         this._disassembledInstructions?.layout(dimension.height);
     }
+    async goToInstructionAndOffset(instructionReference, offset, focus) {
+        let addr = this._referenceToMemoryAddress.get(instructionReference);
+        if (addr === undefined) {
+            await this.loadDisassembledInstructions(instructionReference, 0, -DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD, DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD);
+            addr = this._referenceToMemoryAddress.get(instructionReference);
+        }
+        if (addr) {
+            this.goToAddress(addr + BigInt(offset), focus);
+        }
+    }
+    getReferenceAddress(instructionReference) {
+        return this._referenceToMemoryAddress.get(instructionReference);
+    }
     goToAddress(address, focus) {
         if (!this._disassembledInstructions) {
-            return;
-        }
-        if (!address) {
-            address = this.focusedInstructionAddress;
+            return false;
         }
         if (!address) {
-            return;
+            return false;
         }
         const index = this.getIndexFromAddress(address);
         if (index >= 0) {
@@ -242,41 +279,53 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                 this._disassembledInstructions.domFocus();
                 this._disassembledInstructions.setFocus([index]);
             }
+            return true;
         }
-        else if (this._debugService.state === 2 ) {
-            this.reloadDisassembly(address);
-        }
+        return false;
     }
     async scrollUp_LoadDisassembledInstructions(instructionCount) {
-        if (this._disassembledInstructions && this._disassembledInstructions.length > 0) {
-            const address = this._disassembledInstructions?.row(0).instruction.address;
-            return this.loadDisassembledInstructions(address, -instructionCount, instructionCount);
+        const first = this._disassembledInstructions?.row(0);
+        if (first) {
+            return this.loadDisassembledInstructions(first.instructionReference, first.instructionReferenceOffset, first.instructionOffset - instructionCount, instructionCount);
         }
-        return false;
+        return 0;
     }
     async scrollDown_LoadDisassembledInstructions(instructionCount) {
-        if (this._disassembledInstructions && this._disassembledInstructions.length > 0) {
-            const address = this._disassembledInstructions?.row(this._disassembledInstructions?.length - 1).instruction.address;
-            return this.loadDisassembledInstructions(address, 1, instructionCount);
+        const last = this._disassembledInstructions?.row(this._disassembledInstructions?.length - 1);
+        if (last) {
+            return this.loadDisassembledInstructions(last.instructionReference, last.instructionReferenceOffset, last.instructionOffset + 1, instructionCount);
         }
-        return false;
+        return 0;
     }
-    async loadDisassembledInstructions(address, instructionOffset, instructionCount) {
-        if (!address || address === '-1') {
-            address = this.focusedInstructionAddress;
+    async primeMemoryReference(instructionReference) {
+        if (( (this._referenceToMemoryAddress.has(instructionReference)))) {
+            return true;
         }
-        if (!address) {
-            return false;
+        const s = await this.debugSession?.disassemble(instructionReference, 0, 0, 1);
+        if (s && s.length > 0) {
+            try {
+                this._referenceToMemoryAddress.set(instructionReference, BigInt(s[0].address));
+                return true;
+            }
+            catch {
+                return false;
+            }
         }
+        return false;
+    }
+    async loadDisassembledInstructions(instructionReference, offset, instructionOffset, instructionCount) {
         const session = this.debugSession;
-        const resultEntries = await session?.disassemble(address, 0, instructionOffset, instructionCount);
+        const resultEntries = await session?.disassemble(instructionReference, offset, instructionOffset, instructionCount);
+        if (!( (this._referenceToMemoryAddress.has(instructionReference))) && instructionOffset !== 0) {
+            await this.loadDisassembledInstructions(instructionReference, 0, 0, DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD);
+        }
         if (session && resultEntries && this._disassembledInstructions) {
             const newEntries = [];
             let lastLocation;
             let lastLine;
             for (let i = 0; i < resultEntries.length; i++) {
-                const found = this._instructionBpList.find(p => p.instructionReference === resultEntries[i].address);
                 const instruction = resultEntries[i];
+                const thisInstructionOffset = instructionOffset + i;
                 if (instruction.location) {
                     lastLocation = instruction.location;
                     lastLine = undefined;
@@ -293,64 +342,121 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                         instruction.location = lastLocation;
                     }
                 }
-                newEntries.push({ allowBreakpoint: true, isBreakpointSet: found !== undefined, isBreakpointEnabled: !!found?.enabled, instruction: instruction });
+                let address;
+                try {
+                    address = BigInt(instruction.address);
+                }
+                catch {
+                    console.error(`Could not parse disassembly address ${instruction.address} (in ${JSON.stringify(instruction)})`);
+                    continue;
+                }
+                const entry = {
+                    allowBreakpoint: true,
+                    isBreakpointSet: false,
+                    isBreakpointEnabled: false,
+                    instructionReference,
+                    instructionReferenceOffset: offset,
+                    instructionOffset: thisInstructionOffset,
+                    instruction,
+                    address,
+                };
+                newEntries.push(entry);
+                if (offset === 0 && thisInstructionOffset === 0) {
+                    this._referenceToMemoryAddress.set(instructionReference, address);
+                }
             }
-            const specialEntriesToRemove = this._disassembledInstructions.length === 1 ? 1 : 0;
-            if (instructionOffset >= 0) {
-                this._disassembledInstructions.splice(this._disassembledInstructions.length, specialEntriesToRemove, newEntries);
+            if (newEntries.length === 0) {
+                return 0;
             }
-            else {
-                this._disassembledInstructions.splice(0, specialEntriesToRemove, newEntries);
+            const refBaseAddress = this._referenceToMemoryAddress.get(instructionReference);
+            const bps = ( (this._instructionBpList.map(p => {
+                const base = this._referenceToMemoryAddress.get(p.instructionReference);
+                if (!base) {
+                    return undefined;
+                }
+                return {
+                    enabled: p.enabled,
+                    address: base + BigInt(p.offset || 0),
+                };
+            })));
+            if (refBaseAddress !== undefined) {
+                for (const entry of newEntries) {
+                    const bp = bps.find(p => p?.address === entry.address);
+                    if (bp) {
+                        entry.isBreakpointSet = true;
+                        entry.isBreakpointEnabled = bp.enabled;
+                    }
+                }
             }
-            return true;
+            const da = this._disassembledInstructions;
+            if (da.length === 1 && this._disassembledInstructions.row(0) === disassemblyNotAvailable) {
+                da.splice(0, 1);
+            }
+            const firstAddr = newEntries[0].address;
+            const lastAddr = newEntries[newEntries.length - 1].address;
+            const startN = binarySearch2(da.length, i => Number(da.row(i).address - firstAddr));
+            const start = startN < 0 ? ~startN : startN;
+            const endN = binarySearch2(da.length, i => Number(da.row(i).address - lastAddr));
+            const end = endN < 0 ? ~endN : endN;
+            const toDelete = end - start;
+            let lastLocated;
+            for (let i = start - 1; i >= 0; i--) {
+                const { instruction } = da.row(i);
+                if (instruction.location && instruction.line !== undefined) {
+                    lastLocated = instruction;
+                    break;
+                }
+            }
+            const shouldShowLocation = (instruction) => instruction.line !== undefined && instruction.location !== undefined &&
+                (!lastLocated || !sourcesEqual(instruction.location, lastLocated.location) || instruction.line !== lastLocated.line);
+            for (const entry of newEntries) {
+                if (shouldShowLocation(entry.instruction)) {
+                    entry.showSourceLocation = true;
+                    lastLocated = entry.instruction;
+                }
+            }
+            da.splice(start, toDelete, newEntries);
+            return newEntries.length - toDelete;
         }
-        return false;
+        return 0;
     }
-    getIndexFromAddress(instructionAddress) {
+    getIndexFromReferenceAndOffset(instructionReference, offset) {
+        const addr = this._referenceToMemoryAddress.get(instructionReference);
+        if (addr === undefined) {
+            return -1;
+        }
+        return this.getIndexFromAddress(addr + BigInt(offset));
+    }
+    getIndexFromAddress(address) {
         const disassembledInstructions = this._disassembledInstructions;
         if (disassembledInstructions && disassembledInstructions.length > 0) {
-            const address = BigInt(instructionAddress);
-            if (address) {
-                return binarySearch2(disassembledInstructions.length, index => {
-                    const row = disassembledInstructions.row(index);
-                    this.ensureAddressParsed(row);
-                    if (row.instructionAddress > address) {
-                        return 1;
-                    }
-                    else if (row.instructionAddress < address) {
-                        return -1;
-                    }
-                    else {
-                        return 0;
-                    }
-                });
-            }
+            return binarySearch2(disassembledInstructions.length, index => {
+                const row = disassembledInstructions.row(index);
+                return Number(row.address - address);
+            });
         }
         return -1;
     }
-    ensureAddressParsed(entry) {
-        if (entry.instructionAddress !== undefined) {
+    reloadDisassembly(instructionReference, offset) {
+        if (!this._disassembledInstructions) {
             return;
         }
-        else {
-            entry.instructionAddress = BigInt(entry.instruction.address);
-        }
-    }
-    reloadDisassembly(targetAddress) {
-        if (this._disassembledInstructions) {
-            this._loadingLock = true;
-            this._disassembledInstructions.splice(0, this._disassembledInstructions.length, [disassemblyNotAvailable]);
-            this._instructionBpList = this._debugService.getModel().getInstructionBreakpoints();
-            this.loadDisassembledInstructions(targetAddress, -DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD * 4, DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD * 8).then(() => {
-                if (this._disassembledInstructions.length > 0) {
-                    const targetIndex = Math.floor(this._disassembledInstructions.length / 2);
-                    this._disassembledInstructions.reveal(targetIndex, 0.5);
-                    this._disassembledInstructions.domFocus();
-                    this._disassembledInstructions.setFocus([targetIndex]);
-                }
-                this._loadingLock = false;
-            });
-        }
+        this._loadingLock = true;
+        this.clear();
+        this._instructionBpList = this._debugService.getModel().getInstructionBreakpoints();
+        this.loadDisassembledInstructions(instructionReference, offset, -DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD * 4, DisassemblyView_1.NUM_INSTRUCTIONS_TO_LOAD * 8).then(() => {
+            if (this._disassembledInstructions.length > 0) {
+                const targetIndex = Math.floor(this._disassembledInstructions.length / 2);
+                this._disassembledInstructions.reveal(targetIndex, 0.5);
+                this._disassembledInstructions.domFocus();
+                this._disassembledInstructions.setFocus([targetIndex]);
+            }
+            this._loadingLock = false;
+        });
+    }
+    clear() {
+        this._referenceToMemoryAddress.clear();
+        this._disassembledInstructions?.splice(0, this._disassembledInstructions.length, [disassemblyNotAvailable]);
     }
 };
 DisassemblyView = DisassemblyView_1 = ( (__decorate([
@@ -398,11 +504,13 @@ let BreakpointRenderer = class BreakpointRenderer {
             addStandardDisposableListener(container, 'click', () => {
                 if (currentElement.element?.allowBreakpoint) {
                     icon.classList.add(this._breakpointHintIcon);
+                    const reference = currentElement.element.instructionReference;
+                    const offset = Number(currentElement.element.address - this._disassemblyView.getReferenceAddress(reference));
                     if (currentElement.element.isBreakpointSet) {
-                        this._debugService.removeInstructionBreakpoints(currentElement.element.instruction.address);
+                        this._debugService.removeInstructionBreakpoints(reference, offset);
                     }
                     else if (currentElement.element.allowBreakpoint && !currentElement.element.isBreakpointSet) {
-                        this._debugService.addInstructionBreakpoint(currentElement.element.instruction.address, 0);
+                        this._debugService.addInstructionBreakpoint(reference, offset, currentElement.element.address);
                     }
                 }
             })
@@ -418,10 +526,10 @@ let BreakpointRenderer = class BreakpointRenderer {
         templateData.disposables = [];
     }
     rerenderDebugStackframe(icon, element) {
-        if (element?.instruction.address === this._disassemblyView.focusedCurrentInstructionAddress) {
+        if (element?.address === this._disassemblyView.focusedCurrentInstructionAddress) {
             icon.classList.add(this._debugStackframe);
         }
-        else if (element?.instruction.address === this._disassemblyView.focusedInstructionAddress) {
+        else if (element?.address === this._disassemblyView.focusedInstructionAddress) {
             icon.classList.add(this._debugStackframeFocused);
         }
         else {
@@ -489,7 +597,7 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
         const instruction = element.instruction;
         templateData.sourcecode.innerText = '';
         const sb = ( (new StringBuilder(1000)));
-        if (this._disassemblyView.isSourceCodeRender && instruction.location?.path && instruction.line) {
+        if (this._disassemblyView.isSourceCodeRender && element.showSourceLocation && instruction.location?.path && instruction.line !== undefined) {
             const sourceURI = this.getUriFromSource(instruction);
             if (sourceURI) {
                 let textModel = undefined;
@@ -546,10 +654,10 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
         templateData.disposables = [];
     }
     rerenderBackground(instruction, sourceCode, element) {
-        if (element && this._disassemblyView.currentInstructionAddresses.includes(element.instruction.address)) {
+        if (element && this._disassemblyView.currentInstructionAddresses.includes(element.address)) {
             instruction.style.background = this._topStackFrameColor?.toString() || 'transparent';
         }
-        else if (element?.instruction.address === this._disassemblyView.focusedInstructionAddress) {
+        else if (element?.address === this._disassemblyView.focusedInstructionAddress) {
             instruction.style.background = this._focusedStackFrameColor?.toString() || 'transparent';
         }
         else {
@@ -627,7 +735,7 @@ class AccessibilityProvider {
 let DisassemblyViewContribution = class DisassemblyViewContribution {
     constructor(editorService, debugService, contextKeyService) {
         contextKeyService.bufferChangeEvents(() => {
-            this._languageSupportsDisassemleRequest = CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST.bindTo(contextKeyService);
+            this._languageSupportsDisassembleRequest = CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST.bindTo(contextKeyService);
         });
         const onDidActiveEditorChangeListener = () => {
             if (this._onDidChangeModelLanguage) {
@@ -637,13 +745,13 @@ let DisassemblyViewContribution = class DisassemblyViewContribution {
             const activeTextEditorControl = editorService.activeTextEditorControl;
             if (isCodeEditor(activeTextEditorControl)) {
                 const language = activeTextEditorControl.getModel()?.getLanguageId();
-                this._languageSupportsDisassemleRequest?.set(!!language && debugService.getAdapterManager().someDebuggerInterestedInLanguage(language));
+                this._languageSupportsDisassembleRequest?.set(!!language && debugService.getAdapterManager().someDebuggerInterestedInLanguage(language));
                 this._onDidChangeModelLanguage = activeTextEditorControl.onDidChangeModelLanguage(e => {
-                    this._languageSupportsDisassemleRequest?.set(debugService.getAdapterManager().someDebuggerInterestedInLanguage(e.newLanguage));
+                    this._languageSupportsDisassembleRequest?.set(debugService.getAdapterManager().someDebuggerInterestedInLanguage(e.newLanguage));
                 });
             }
             else {
-                this._languageSupportsDisassemleRequest?.set(false);
+                this._languageSupportsDisassembleRequest?.set(false);
             }
         };
         onDidActiveEditorChangeListener();

package/vscode/src/vs/workbench/contrib/debug/browser/exceptionWidget.js

@@ -46,7 +46,7 @@ let ExceptionWidget = class ExceptionWidget extends ZoneWidget {
     }
     _fillContainer(container) {
         this.setCssClass('exception-widget');
-        const fontInfo = this.editor.getOption(49 );
+        const fontInfo = this.editor.getOption(50 );
         container.style.fontSize = `${fontInfo.fontSize}px`;
         container.style.lineHeight = `${fontInfo.lineHeight}px`;
         container.tabIndex = 0;
@@ -85,7 +85,7 @@ let ExceptionWidget = class ExceptionWidget extends ZoneWidget {
     }
     _doLayout(_heightInPixel, _widthInPixel) {
         this.container.style.height = 'initial';
-        const lineHeight = this.editor.getOption(65 );
+        const lineHeight = this.editor.getOption(66 );
         const arrowHeight = Math.round(lineHeight / 3);
         const computedLinesNumber = Math.ceil((this.container.offsetHeight + arrowHeight) / lineHeight);
         this._relayout(computedLinesNumber);

package/vscode/src/vs/workbench/contrib/debug/browser/rawDebugSession.js

@@ -100,7 +100,7 @@ let RawDebugSession = class RawDebugSession {
                 case 'terminated':
                     this._onDidTerminateDebugee.fire(event);
                     break;
-                case 'exit':
+                case 'exited':
                     this._onDidExitDebugee.fire(event);
                     break;
                 case 'progressStart':

package/vscode/src/vs/workbench/contrib/debug/browser/repl.js

@@ -282,7 +282,7 @@ let Repl = class Repl extends FilterViewPane {
                 lineHeight: this.replOptions.replConfiguration.lineHeight,
                 fontFamily: this.replOptions.replConfiguration.fontFamily === 'default' ? EDITOR_FONT_DEFAULTS.fontFamily : this.replOptions.replConfiguration.fontFamily
             });
-            const replInputLineHeight = this.replInput.getOption(65 );
+            const replInputLineHeight = this.replInput.getOption(66 );
             this.styleElement.textContent = `
 				.repl .repl-input-wrapper .repl-input-chevron {
 					line-height: ${replInputLineHeight}px