Method getProtocolDisassembly

src/backend/disasm.ts:495–561

(range: DisasmRange, args: DebugProtocol.DisassembleArguments)

    }

    protected getProtocolDisassembly(range: DisasmRange, args: DebugProtocol.DisassembleArguments): Promise<DisassemblyReturn | Error> {
        let startAddress = range.qStart;
        const endAddress = range.qEnd;
        const validationAddr = range.verify;
        // To annotate questionable instructions. Too lazy to do on per instruction basis
        return new Promise<DisassemblyReturn | Error>(async (resolve) => {
            let iter = 0;
            const maxTries = Math.ceil((this.maxInstrSize - this.minInstrSize) / this.instrMultiple);
            const doWork = () => {
                const old = this.findInCache(startAddress, endAddress);
                if (old) {
                    const foundIx = old.findInstrIndex(validationAddr);
                    if (foundIx < 0) {
                        const msg = `Bad instruction cache. Could not find address ${validationAddr} that should have been found`;
                        this.handleMsg('log', msg + '\n');
                        resolve(new Error(msg));
                    } else {
                        resolve(new DisassemblyReturn(old.instructions, foundIx));
                    }
                    return;
                }

                const entireRangeGood = range.isKnownStart || this.isRangeInValidMem(startAddress, endAddress);
                const end = endAddress;
                // const end = range.isData ? endAddress : this.clipHigh(endAddress, endAddress + this.maxInstrSize); // Get a bit more for functions
                let cmd: string;
                cmd = `data-disassemble -s ${hexFormat(startAddress)} -e ${hexFormat(end)} -- 5`;
                if (this.doTiming) {
                    const symName = range.symNode ? ` (${range.symNode.symbol.name})` : '';
                    const count = `${end - startAddress} bytes`.padStart(15);
                    this.handleMsg('log', `Debug: Gdb command: -${cmd}${count} ${symName}\n`);
                }
                this.miDebugger.sendCommand(cmd, false, false, true).then((result) => {
                    try {
                        const ret = this.parseDisassembleResults(result, validationAddr, entireRangeGood, cmd);
                        const foundIx = ret.foundAt;
                        if (foundIx < 0) {
                            if (GdbDisassembler.debug) {
                                const msg = `Could not disassemble at this address Looking for ${hexFormat(validationAddr)}: ${cmd} `;
                                console.log(msg, ret.instructions);
                            }
                            if ((startAddress >= this.instrMultiple) && (iter < maxTries)) {
                                iter++;
                                startAddress -= this.instrMultiple;      // Try again with this address
                                doWork();
                            } else {
                                const msg = `Error: Could not disassemble at this address ${hexFormat(validationAddr)} ` + JSON.stringify(args);
                                this.handleMsg('log', msg + '\n');
                                resolve(new Error(msg));
                            }
                        } else {
                            const instrRange = new InstructionRange(ret.instructions);
                            this.addToCache(instrRange);
                            resolve(ret);
                        }
                    }
                    catch (e) {
                        resolve(e);