Merge branch 'master' of https://github.com/Marus/cortex-debug

Author: Haneef Mohammed

.vscode/launch.json

@@ -18,7 +18,6 @@
 			"name": "Debug Server",
 			"type": "node",
 			"request": "launch",
-
 			"runtimeArgs": [ "--nolazy", "--trace-warnings" ],
 			"program": "${workspaceRoot}/dist/debugadapter.js",
 			"stopOnEntry": false,

TODO.md

@@ -16,4 +16,6 @@ Low, medium, high are importance/usefulness. But they sometimes represent *bang-
 # Other
 
 * High: WSL: First class support. This includes Docker, WSL and perhaps 'ssh'. VSCode and WSL seem to be maturing. Still not there but...there may be enough
-* 
+* Low: Live Debug: See if we can update program status without stopping the program. Not sure what will work and with which gdb-server
+  * invasive method: program is periodically paused and updates provided -- it has the look of live but is invasive for sure
+  * non-invasive (non-stop): Update without pausing the program. I should say minimally invasive.

package-lock.json

@@ -11,6 +11,14 @@ export interface Breakpoint {
     number?: number;
 }
 
+export interface DataBreakpoint {
+    exp: string;
+    accessType: 'read' | 'write' | 'readWrite';
+    condition?: string;
+    countCondition?: string;
+    number?: number;
+}
+
 export interface Stack {
     level: number;
     address: string;
@@ -59,8 +67,10 @@ export class VariableObject {
     public hasMore: boolean;
     public id: number;
     public fullExp: string;
+    public parent: number;      // Variable Reference
     public children: {[name: string]: string};
-    constructor(node: any) {
+    constructor(p: number, node: any) {
+        this.parent = p;
         this.name = MINode.valueOf(node, 'name');
         this.exp = MINode.valueOf(node, 'exp');
         this.numchild = parseInt(MINode.valueOf(node, 'numchild'));
@@ -86,7 +96,7 @@ export class VariableObject {
             val = parseInt(value.toLowerCase());
 
             ret += ' ' + name + ';\n' ;
-            ret += toStringDecHexOctBin(val);       
+            ret += toStringDecHexOctBin(val);
         }
         return ret;
     }

package.json

@@ -1,4 +1,4 @@
-import { Breakpoint, IBackend, Stack, Variable, VariableObject, MIError } from '../backend';
+import { Breakpoint, DataBreakpoint, IBackend, Stack, Variable, VariableObject, MIError } from '../backend';
 import * as ChildProcess from 'child_process';
 import { EventEmitter } from 'events';
 import { parseMI, MINode } from '../mi_parse';
@@ -28,8 +28,7 @@ function couldBeOutput(line: string) {
 const trace = false;
 
 export class MI2 extends EventEmitter implements IBackend {
-    public printCalls: boolean;
-    public debugOutput: boolean;
+    public debugOutput: boolean | 'raw' | 'raw-only';
     public procEnv: any;
     protected currentToken: number = 1;
     protected handlers: { [index: number]: (info: MINode) => any } = {};
@@ -140,7 +139,12 @@ export class MI2 extends EventEmitter implements IBackend {
             else {
                 const parsed = parseMI(line);
                 if (this.debugOutput) {
-                    this.log('log', 'GDB -> App: ' + JSON.stringify(parsed));
+                    if ((this.debugOutput === 'raw-only') || (this.debugOutput === 'raw')) {
+                        this.log('log', '-> ' + line);
+                    }
+                    if (this.debugOutput !== 'raw-only') {
+                        this.log('log', 'GDB -> App: ' + JSON.stringify(parsed));
+                    }
                 }
                 let handled = false;
                 if (parsed.token !== undefined && parsed.resultRecords) {
@@ -174,6 +178,13 @@ export class MI2 extends EventEmitter implements IBackend {
                                     if (reason === 'breakpoint-hit') {
                                         this.emit('breakpoint', parsed);
                                     }
+                                    else if (reason && (reason as string).includes('watchpoint-trigger')) {
+                                        this.emit('watchpoint', parsed);
+                                    }
+                                    else if (reason && (reason as string).includes('watchpoint-scope')) {
+                                        // When a local variable goes out of scope
+                                        this.emit('watchpoint-scope', parsed);
+                                    }
                                     else if (reason === 'end-stepping-range') {
                                         this.emit('step-end', parsed);
                                     }
@@ -244,7 +255,7 @@ export class MI2 extends EventEmitter implements IBackend {
     }
 
     private tryKill() {
-        if (!this.exited) {
+        if (!this.exited && this.process) {
             const proc = this.process;
             try {
                 ServerConsoleLog('GDB kill()');
@@ -274,10 +285,31 @@ export class MI2 extends EventEmitter implements IBackend {
         if (trace) {
             this.log('stderr', 'detach');
         }
-        this.sendCommand('target-detach');  // This may not be successful, go ahead and stop gdb as well. Sometimes hangs!
-        setTimeout(() => {
+        let to = setTimeout(() => {
+            if (to) {
+                ServerConsoleLog('target-detach hung: target probably running, thats okay, continue to stop()');
+                to = null;
+                this.stop();
+            }
+        }, 10);
+
+        // Following can hang if no response, or fail because the target is still running. Yes,
+        // we sometimes detach when target is still running. This also causes unhandled rejection
+        // warning/error from Node, so handle rejections.
+        this.sendCommand('target-detach').then(() => {
+            if (to) {
+                clearTimeout(to);
+                to = null;
+            }
             this.stop();
-        }, 5);
+        }, (e) => {
+            if (to) {
+                clearTimeout(to);
+                to = null;
+            }
+            ServerConsoleLog('target-detach failed: target probably running, thats okay, continue to stop()');
+            this.stop();
+        });
     }
 
     public interrupt(arg: string = ''): Thenable<boolean> {
@@ -473,6 +505,57 @@ export class MI2 extends EventEmitter implements IBackend {
         });
     }
 
+    public addDataBreakPoint(breakpoint: DataBreakpoint): Promise<DataBreakpoint> {
+        if (trace) {
+            this.log('stderr', 'addBreakPoint');
+        }
+        return new Promise((resolve, reject) => {
+            let location = '';
+            if (breakpoint.countCondition) {
+                if (breakpoint.countCondition[0] === '>') {
+                    location += '-i ' + numRegex.exec(breakpoint.countCondition.substr(1))[0] + ' ';
+                }
+                else {
+                    const match = numRegex.exec(breakpoint.countCondition)[0];
+                    if (match.length !== breakpoint.countCondition.length) {
+                        // tslint:disable-next-line:max-line-length
+                        this.log('stderr', 'Unsupported break count expression: \'' + breakpoint.countCondition + '\'. Only supports \'X\' for breaking once after X times or \'>X\' for ignoring the first X breaks');
+                        location += '-t ';
+                    }
+                    else if (parseInt(match) !== 0) {
+                        location += '-t -i ' + parseInt(match) + ' ';
+                    }
+                }
+            }
+
+            location += breakpoint.exp;
+            const aType = breakpoint.accessType === 'read' ? '-r' : (breakpoint.accessType === 'readWrite' ? '-a' : '');
+            this.sendCommand(`break-watch ${aType} ${location}`).then((result) => {
+                if (result.resultRecords.resultClass === 'done') {
+                    const bkptNum = parseInt(result.result('bkpt.number'));
+                    const line = result.result('bkpt.line');
+                    breakpoint.number = bkptNum;
+
+                    if (breakpoint.condition) {
+                        this.setBreakPointCondition(bkptNum, breakpoint.condition).then((result) => {
+                            if (result.resultRecords.resultClass === 'done') {
+                                resolve(breakpoint);
+                            } else {
+                                reject(new MIError(result.result('msg') || 'Internal error', 'Setting breakpoint condition'));
+                            }
+                        }, reject);
+                    }
+                    else {
+                        resolve(breakpoint);
+                    }
+                }
+                else {
+                    reject(new MIError(result.result('msg') || 'Internal error', `Setting breakpoint at ${location}`));
+                }
+            }, reject);
+        });
+    }
+
     public getFrame(thread: number, frame: number): Thenable<Stack> {
         return new Promise((resolve, reject) => {
             const command = `stack-info-frame --thread ${thread} --frame ${frame}`;
@@ -600,7 +683,7 @@ export class MI2 extends EventEmitter implements IBackend {
         x: 'hexadecimal'
     };
 
-    public async varCreate(expression: string, name: string = '-', scope: string = '@'): Promise<VariableObject> {
+    public async varCreate(parent: number, expression: string, name: string = '-', scope: string = '@'): Promise<VariableObject> {
         if (trace) {
             this.log('stderr', 'varCreate');
         }
@@ -623,7 +706,7 @@ export class MI2 extends EventEmitter implements IBackend {
         if (overrideVal) {
             result = result.map((r: string[]) => r[0] === 'value' ?  ['value', overrideVal] : r);
         }
-        return new VariableObject(result);
+        return new VariableObject(parent, result);
     }
 
     public async varEvalExpression(name: string): Promise<MINode> {
@@ -633,7 +716,7 @@ export class MI2 extends EventEmitter implements IBackend {
         return this.sendCommand(`var-evaluate-expression ${name}`);
     }
 
-    public async varListChildren(name: string, flattenAnonymous: boolean): Promise<VariableObject[]> {
+    public async varListChildren(parent: number, name: string, flattenAnonymous: boolean): Promise<VariableObject[]> {
         if (trace) {
             this.log('stderr', 'varListChildren');
         }
@@ -642,9 +725,9 @@ export class MI2 extends EventEmitter implements IBackend {
         const children = res.result('children') || [];
         const omg: VariableObject[] = [];
         for (const item of children) {
-            const child = new VariableObject(item[1]);
+            const child = new VariableObject(parent, item[1]);
             if (flattenAnonymous && child.exp.startsWith('<anonymous ')) {
-                omg.push(... await this.varListChildren(child.name, flattenAnonymous));
+                omg.push(... await this.varListChildren(parent, child.name, flattenAnonymous));
             } else {
                 omg.push(child);
             }
@@ -692,7 +775,7 @@ export class MI2 extends EventEmitter implements IBackend {
     }
 
     public sendRaw(raw: string) {
-        if (this.printCalls || trace) {
+        if (this.debugOutput || trace) {
             this.log('log', raw);
         }
         if (raw.includes('undefined')) {

src/backend/backend.ts

@@ -5,9 +5,9 @@ import * as fs from 'fs';
 import { EventEmitter } from 'events';
 import { setTimeout } from 'timers';
 
-const tmpDirName = os.platform() === 'win32' ? process.env.TEMP || process.env.TMP || '.' : '/tmp';
 export function ServerConsoleLog(str: string) {
     try {
+        const tmpDirName = os.tmpdir();
         const date = new Date();
         str = `[${date.toISOString()}] ` + str;
         console.log(str);
@@ -85,10 +85,12 @@ export class GDBServer extends EventEmitter {
     }
 
     private exitTimeout: NodeJS.Timeout = null;
+    private killInProgress = false;
     public exit(): void {
-        if (this.process) {
+        if (this.process && !this.killInProgress) {
             try {
                 ServerConsoleLog('GDBServer: forcing an exit with kill()');
+                this.killInProgress = true;
                 this.process.kill();
             }
             catch (e) {

src/backend/mi2/mi2.ts

@@ -69,7 +69,7 @@ export class SymbolTable {
      * showed that it is both complex and very slow.
      */
 
-    public loadSymbols(noCache: boolean = false) {
+    public loadSymbols(noCache: boolean = false, useObjdump: string = '') {
         try {
             let objdumpExePath = os.platform() !== 'win32' ? `${this.toolchainPrefix}-objdump` : `${this.toolchainPrefix}-objdump.exe`;
             if (this.toolchainPath) {
@@ -85,14 +85,15 @@ export class SymbolTable {
                 options.push('-C');
             }
 
-            const tmpName = tmp.tmpNameSync();
-            const outFd = fs.openSync(tmpName, 'w');
-            const objdump = childProcess.spawnSync(objdumpExePath, [...options, this.executable], {
-                stdio: ['ignore', outFd, 'ignore']
-            });
-            fs.closeSync(outFd);
-
-            const str = this.readLinesAndFileMaps(tmpName, !restored);
+            if (!useObjdump || !fs.existsSync(useObjdump)) {
+                useObjdump = tmp.tmpNameSync();
+                const outFd = fs.openSync(useObjdump, 'w');
+                const objdump = childProcess.spawnSync(objdumpExePath, [...options, this.executable], {
+                    stdio: ['ignore', outFd, 'ignore']
+                });
+                fs.closeSync(outFd);
+            }
+            const str = this.readLinesAndFileMaps(useObjdump, !restored);
 
             const regex = RegExp(SYMBOL_REGEX);
             let currentFile: string = null;

src/backend/server.ts

@@ -6,7 +6,8 @@ import { GDBServer } from './backend/server';
 
 export enum CortexDebugKeys {
     REGISTER_DISPLAY_MODE = 'registerUseNaturalFormat',
-    VARIABLE_DISPLAY_MODE = 'variableUseNaturalFormat'
+    VARIABLE_DISPLAY_MODE = 'variableUseNaturalFormat',
+    SERVER_LOG_FILE_NAME = 'dbgServerLogfile'
 }
 
 export enum NumberFormat {
@@ -189,7 +190,7 @@ export interface ConfigurationArguments extends DebugProtocol.LaunchRequestArgum
     rttConfig: RTTConfiguration;
     swoConfig: SWOConfiguration;
     graphConfig: any[];
-    showDevDebugOutput: boolean;
+    showDevDebugOutput: boolean | 'raw' | 'raw-only';
     showDevDebugTimestamps: boolean;
     cwd: string;
     extensionPath: string;