Fixed: Symbol path eval, added "early exit" on timeout and Debug Exit (#856)

* Fixed evaluation of path symbols, and added "early exit" (on 10sec timeout, and on exit)
* Added tests
* Moved execution-cancellation into it's own module

Author: thorstendb-ARM

src/views/component-viewer/component-viewer-instance.ts

@@ -222,6 +222,11 @@ export class ComponentViewerInstance {
         return this._statementEngine;
     }
 
+    /** Cancel any in-progress executeAll run (e.g. when the debug session ends). */
+    public cancelExecution(reason: string): void {
+        this._scvdEvalContext?.cancellation.cancel(reason);
+    }
+
     private set statementEngine(value: StatementEngine | undefined) {
         this._statementEngine = value;
     }

src/views/component-viewer/component-viewer-main.ts

@@ -228,6 +228,15 @@ export class ComponentViewer {
     }
 
     private async handleOnWillStopSession(session: GDBTargetDebugSession): Promise<void> {
+        // Cancel any in-progress executeAll for the session being stopped.
+        // JS is single-threaded, so this flag will be picked up at the next
+        // await point (i.e. the next GDB read) inside any running loop.
+        for (const instance of this._instances) {
+            if (instance.sessionId === session.session.id) {
+                instance.componentViewerInstance.cancelExecution('debug session ended');
+            }
+        }
+
         // Clear active session if it is the one being stopped
         if (this._activeSession?.session.id === session.session.id) {
             this._activeSession = undefined;

src/views/component-viewer/execution-cancellation.ts

@@ -0,0 +1,60 @@
+/**
+ * Copyright 2025-2026 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// generated with AI
+
+/**
+ * Shared cancellation signal for a single `executeAll` run.
+ *
+ * Checked at every loop iteration in `StatementList` and `StatementReadList`
+ * (after each `await` point) so the engine can be stopped promptly both by
+ * an external caller (e.g. debug-session end) and by a per-run timeout.
+ */
+export class ExecutionCancellation {
+    static readonly DEFAULT_TIMEOUT_MS = 10_000;
+
+    private _isCancelled = false;
+    private _reason: string | undefined;
+    private _timeoutMs = ExecutionCancellation.DEFAULT_TIMEOUT_MS;
+    private _deadline = Date.now() + this._timeoutMs;
+
+    public get isCancelled(): boolean { return this._isCancelled; }
+    public get reason(): string | undefined { return this._reason; }
+
+    /** Prepare for a new `executeAll` run. Clears any previous cancellation and
+     *  sets a fresh wall-clock deadline. */
+    public reset(timeoutMs?: number): void {
+        this._isCancelled = false;
+        this._reason = undefined;
+        this._timeoutMs = timeoutMs ?? ExecutionCancellation.DEFAULT_TIMEOUT_MS;
+        this._deadline = Date.now() + this._timeoutMs;
+    }
+
+    /** Cancel immediately (e.g. session ended). Safe to call from an event handler. */
+    public cancel(reason: string): void {
+        if (!this._isCancelled) {
+            this._isCancelled = true;
+            this._reason = reason;
+        }
+    }
+
+    /** Check deadline and auto-cancel on expiry. Returns `true` when cancelled. */
+    public checkDeadline(): boolean {
+        if (!this._isCancelled && Date.now() > this._deadline) {
+            this.cancel('executeAll timeout exceeded');
+        }
+        return this._isCancelled;
+    }
+}

src/views/component-viewer/scvd-debug-target.ts

@@ -46,6 +46,24 @@ function normalize(name: string): string {
     return name.trim().toUpperCase();
 }
 
+/**
+ * Convert a symbol path notation to GDB qualified symbol syntax.
+ * Input:  "tasks.c/xSchedulerRunning"  →  Output: "'tasks.c'::xSchedulerRunning"
+ * Input:  "xSchedulerRunning"          →  Output: "xSchedulerRunning" (unchanged)
+ */
+export function toGdbSymbol(symbol: string): string {
+    const slashIndex = symbol.indexOf('/');
+    if (slashIndex < 0) {
+        return symbol;
+    }
+    const file = symbol.substring(0, slashIndex);
+    const name = symbol.substring(slashIndex + 1);
+    if (!file || !name) {
+        return symbol;
+    }
+    return `'${file}'::${name}`;
+}
+
 function toUint32(value: number | bigint): number | bigint {
     if (typeof value === 'bigint') {
         return value & 0xFFFFFFFFn;
@@ -157,7 +175,8 @@ export class ScvdDebugTarget {
         }
 
         const addressInfo = await this.symbolCaches.getAddressWithName(symbol, async (symbolName) => {
-            const symbolAddressStr = await this.targetAccess.evaluateSymbolAddress(symbolName, 'hover', existCheck);
+            const gdbSymbol = toGdbSymbol(symbolName);
+            const symbolAddressStr = await this.targetAccess.evaluateSymbolAddress(gdbSymbol, 'hover', existCheck);
             if (symbolAddressStr !== undefined) {
                 const parsed = parseInt(symbolAddressStr as unknown as string, 16);
                 if (Number.isFinite(parsed)) {
@@ -228,7 +247,8 @@ export class ScvdDebugTarget {
             return undefined;
         }
         return this.symbolCaches.getArrayCount(symbol, async (symbolName) => {
-            const result = await this.targetAccess.evaluateNumberOfArrayElements(symbolName);
+            const gdbSymbol = toGdbSymbol(symbolName);
+            const result = await this.targetAccess.evaluateNumberOfArrayElements(gdbSymbol);
             componentViewerLogger.debug(`get Num Array Elements: ${symbolName} resolved to ${result}`);
             return result;
         });
@@ -260,7 +280,8 @@ export class ScvdDebugTarget {
         }
 
         return this.symbolCaches.getSize(symbol, async (symbolName) => {
-            const size = await this.targetAccess.evaluateSymbolSize(symbolName);
+            const gdbSymbol = toGdbSymbol(symbolName);
+            const size = await this.targetAccess.evaluateSymbolSize(gdbSymbol);
             if (typeof size === 'number' && size >= 0) {
                 componentViewerLogger.debug(`get Symbol Size: ${symbolName} resolved to ${size}`);
                 return size;

src/views/component-viewer/scvd-eval-context.ts

@@ -27,6 +27,7 @@ import { ScvdFormatSpecifier } from './model/scvd-format-specifier';
 import { ScvdDebugTarget } from './scvd-debug-target';
 import { ScvdEvalInterface } from './scvd-eval-interface';
 import { parsePerf } from './stats-config';
+import { ExecutionCancellation } from './execution-cancellation';
 
 export interface ExecutionContext {
     memoryHost: MemoryHost;
@@ -35,6 +36,7 @@ export interface ExecutionContext {
     debugTarget: ScvdDebugTarget;
     evaluator: Evaluator;
     parser: ScvdExpressionParser;
+    cancellation: ExecutionCancellation;
 }
 
 export class ScvdExpressionParser {
@@ -76,6 +78,7 @@ export class ScvdEvalContext {
     private _model: ScvdComponentViewer;
     private _integerModelKind: IntegerModelKind;
     private _parserInterface: ScvdExpressionParser;
+    private _cancellation = new ExecutionCancellation();
 
     constructor(
         model: ScvdComponentViewer
@@ -134,6 +137,10 @@ export class ScvdEvalContext {
         this.applyIntegerModel();
     }
 
+    public get cancellation(): ExecutionCancellation {
+        return this._cancellation;
+    }
+
     public getExecutionContext(): ExecutionContext {
         return {
             memoryHost: this.memoryHost,
@@ -144,6 +151,7 @@ export class ScvdEvalContext {
                 throw new Error('SCVD EvalContext: DebugTarget not initialized');
             })(),
             parser: this._parserInterface,
+            cancellation: this._cancellation,
         };
     }
 

src/views/component-viewer/scvd-eval-interface.ts

@@ -213,7 +213,6 @@ export class ScvdEvalInterface implements ModelHost, DataAccessHost, IntrinsicPr
     public async resolveColonPath(_container: RefContainer, parts: string[]): Promise<EvalValue> {
         // ColonPath in general expression context (not inside __Offset_of)
         // Example: typedef:member evaluates to the offset value itself
-        // This matches C++ behavior where type:member expressions can be used directly
 
         if (parts.length === 2) {
             const [typedefName, memberName] = parts;
@@ -391,11 +390,12 @@ export class ScvdEvalInterface implements ModelHost, DataAccessHost, IntrinsicPr
     public async __size_of(symbol: string): Promise<number | undefined> {
         const perfStartTime = perf?.start() ?? 0;
         try {
-            const sizeBytes = await this._debugTarget.getSymbolSize(symbol);
-            if (sizeBytes !== undefined) {
-                return sizeBytes;
-            }
-            // Legacy fallback: try array element count if size is unavailable
+            // __size_of must return the number of elements, not byte count:
+            //   - arrays:  element count  (sizeof(x) / sizeof(x[0]))
+            //   - scalars: 1              (sizeof(x) / sizeof(x[0]) == 1)
+            // getNumArrayElements evaluates sizeof(x)/sizeof(x[0]) in GDB, which
+            // is correct for both cases.  getSymbolSize evaluates sizeof(x) which
+            // returns total byte size and must NOT be used here.
             const arrayElements = await this._debugTarget.getNumArrayElements(symbol);
             if (arrayElements !== undefined) {
                 return arrayElements;

src/views/component-viewer/statement-engine/statement-engine.ts

@@ -49,6 +49,9 @@ export class StatementEngine {
     private _statementTree: StatementBase | undefined;
     private _executionContext: ExecutionContext;
 
+    /** Wall-clock budget for a single executeAll run (ms). */
+    public static readonly EXECUTE_ALL_TIMEOUT_MS = 10_000;
+
     constructor(
         model: ScvdComponentViewer,
         executionContext: ExecutionContext
@@ -162,6 +165,7 @@ export class StatementEngine {
         // Execute all statements in the statement tree.
         // This is a placeholder implementation.
 
+        this._executionContext.cancellation.reset(StatementEngine.EXECUTE_ALL_TIMEOUT_MS);
         this._executionContext.memoryHost.clearNonConst();
         const evalHost = this._executionContext.evalContext.data as {
             resetEvalCaches?: () => void;

src/views/component-viewer/statement-engine/statement-list.ts

@@ -99,7 +99,14 @@ export class StatementList extends StatementBase {
 
         let loopValue = Number(startValue);
         let maximumCount = 100000;   // prevent infinite loops
+
         while (maximumCount-- > 0) {
+            // Check for external cancellation (session ended) or global timeout
+            if (executionContext.cancellation.checkDeadline()) {
+                componentViewerLogger.warn(`Line: ${this.line}: <list> "${name}" aborted: ${executionContext.cancellation.reason}`);
+                break;
+            }
+
             executionContext.memoryHost.setVariable(name, varTargetSize, loopValue, 0, undefined, varTargetSize);    // update loop variable in memory
 
             // while-loop

src/views/component-viewer/statement-engine/statement-readList.ts

@@ -295,6 +295,12 @@ export class StatementReadList extends StatementBase {
             let readIdx = 0;
             const visitedAddresses = new Set<number | bigint>();
             while (nextPtrAddr !== undefined) {
+                // Check for external cancellation (session ended) or global timeout
+                if (executionContext.cancellation.checkDeadline()) {
+                    componentViewerLogger.warn(`${this.scvdItem.getLineNoStr()}: Executing "readlist": ${scvdReadList.name} aborted: ${executionContext.cancellation.reason}`);
+                    break;
+                }
+
                 const itemAddress: number | bigint | undefined = typeof nextPtrAddr === 'bigint' ? nextPtrAddr : (nextPtrAddr >>> 0);
 
                 // Detect cycles: check if we've visited this address before

src/views/component-viewer/test/integration/scvd-debug-target.test.ts

@@ -20,7 +20,7 @@
  */
 
 import { componentViewerLogger } from '../../../../logger';
-import { ScvdDebugTarget, gdbNameFor, __test__ } from '../../scvd-debug-target';
+import { ScvdDebugTarget, gdbNameFor, toGdbSymbol, __test__ } from '../../scvd-debug-target';
 import { TargetReadCache } from '../../target-read-cache';
 import type { GDBTargetDebugSession, GDBTargetDebugTracker } from '../../../../debug-session';
 
@@ -74,6 +74,15 @@ describe('scvd-debug-target', () => {
         expect(gdbNameFor('unknown')).toBeUndefined();
     });
 
+    it('converts symbol path notation to GDB qualified syntax', () => {
+        expect(toGdbSymbol('tasks.c/xSchedulerRunning')).toBe('\'tasks.c\'::xSchedulerRunning');
+        expect(toGdbSymbol('main.c/myGlobal')).toBe('\'main.c\'::myGlobal');
+        expect(toGdbSymbol('xSchedulerRunning')).toBe('xSchedulerRunning');
+        expect(toGdbSymbol('/noFile')).toBe('/noFile');
+        expect(toGdbSymbol('noSymbol/')).toBe('noSymbol/');
+        expect(toGdbSymbol('')).toBe('');
+    });
+
     it('resolves symbol info when session is active', async () => {
         accessMock.evaluateSymbolAddress.mockResolvedValue('0x100');
         const tracker = { onContinued: jest.fn(), onStopped: jest.fn() } as unknown as GDBTargetDebugTracker;