Negative offset read optimisation

Author: asimgunes

src/gdb/GDBDebugSessionBase.ts

@@ -1387,11 +1387,9 @@ export abstract class GDBDebugSessionBase extends LoggingDebugSession {
             };
             this.sendResponse(response);
         } catch (err) {
-            this.sendErrorResponse(
-                response,
-                1,
-                err instanceof Error ? err.message : String(err)
-            );
+            const message = err instanceof Error ? err.message : String(err);
+            this.sendEvent(new OutputEvent(`Error: ${message}`));
+            this.sendErrorResponse(response, 1, message);
         }
     }
 

src/integration-tests/diassemble.spec.ts

@@ -13,7 +13,6 @@ import * as path from 'path';
 import { DebugProtocol } from '@vscode/debugprotocol/lib/debugProtocol';
 import { CdtDebugClient } from './debugClient';
 import { fillDefaults, standardBeforeEach, testProgramsDir } from './utils';
-import { calculateMemoryOffset } from '../util/calculateMemoryOffset';
 import { assert } from 'sinon';
 
 describe('Disassembly Test Suite', function () {
@@ -180,28 +179,17 @@ describe('Disassembly Test Suite', function () {
         );
     });
 
-    it('can handle disassemble at bad address', async function () {
-        const disassemble = (await dc.send('disassemble', {
-            memoryReference: '0x0',
-            instructionCount: 10,
-        })) as DebugProtocol.DisassembleResponse;
-
-        expect(disassemble).not.eq(undefined);
-        expect(disassemble.body).not.eq(undefined);
-        if (disassemble.body) {
-            const instructions = disassemble.body.instructions;
-            expect(instructions).to.have.lengthOf(10);
-            // Checking the invalid instructions content
-            instructions.forEach((inst, ix) => {
-                expect(inst.address).to.eq(
-                    calculateMemoryOffset('0x0', ix * 2)
-                );
-                expect(inst.address).to.have.lengthOf.greaterThan(0);
-                expect(inst.instruction).to.eq(
-                    'failed to retrieve instruction'
-                );
-                expect(inst.presentationHint).to.eq('invalid');
-            });
+    it('return error at bad address', async function () {
+        try {
+            await dc.send('disassemble', {
+                memoryReference: '0x0',
+                instructionCount: 10,
+            } as DebugProtocol.DisassembleArguments);
+            assert.fail('Should throw error!');
+        } catch (e) {
+            expect(e).to.be.deep.equal(
+                new Error('Cannot access memory at address 0x0')
+            );
         }
     });
 });

src/util/disassembly.ts

@@ -178,22 +178,16 @@ export const getInstructions = async (
             if (result.length === 0) {
                 // If cannot retrieve more instructions, break the loop, go to catch
                 // and fill the remaining instructions with empty instruction information
-                throw new Error('Cannot retrieve more instructions!');
+                break;
             }
             pushToList(result);
         }
     } catch (e) {
-        // Fill with empty instructions in case of memory error.
-        const lastMemoryAddress =
-            list.length === 0
-                ? memoryReference
-                : list[isReverseFetch ? 0 : list.length - 1].address;
-        const emptyInstuctions = getEmptyInstructions(
-            lastMemoryAddress,
-            remainingLength(),
-            2
-        );
-        pushToList(emptyInstuctions);
+        // If error occured in the first iteration and no items can be read
+        // throw the original error, otherwise continue and fill the empty instructions.
+        if (list.length === 0) {
+            throw e;
+        }
     }
 
     if (absLength < list.length) {
@@ -206,5 +200,23 @@ export const getInstructions = async (
         }
     }
 
+    // Fill with empty instructions in case couldn't read desired length
+    if (absLength > list.length) {
+        if (list.length === 0) {
+            // In case of memory read error, where no instructions read before you cannot be sure about the memory offsets
+            // Avoid sending empty instructions, which is overriding the previous disassembled instructions in the VSCode
+            // Instead, send error message and fail the request.
+            throw new Error(`Cannot retrieve instructions!`);
+        }
+        const lastMemoryAddress =
+            list[isReverseFetch ? 0 : list.length - 1].address;
+        const emptyInstuctions = getEmptyInstructions(
+            lastMemoryAddress,
+            absLength - list.length,
+            Math.sign(length) * 2
+        );
+        pushToList(emptyInstuctions);
+    }
+
     return list;
 };