Method disassembleProtocolRequest2

src/backend/disasm.ts:667–805

(
        response: DebugProtocol.DisassembleResponse,
        args: DebugProtocol.DisassembleArguments,
        request?: DebugProtocol.Request)

    }

    private disassembleProtocolRequest2(
        response: DebugProtocol.DisassembleResponse,
        args: DebugProtocol.DisassembleArguments,
        request?: DebugProtocol.Request): Promise<void>
    {
        return new Promise(async (resolve, reject) => {
            try {
                await this.getMemoryRegions();
                const seq = request?.seq;
                if (GdbDisassembler.debug) {
                    this.handleMsg('log', `Debug-${seq}: Dequeuing...\n`);
                    console.log('disassembleRequest: ', args);
                }

                const baseAddress = parseInt(args.memoryReference);
                const offset = args.offset || 0;
                const instrOffset = args.instructionOffset || 0;
                const timer = this.doTiming ? new HrTimer() : undefined;

                if (offset !== 0) {
                    throw (new Error('VSCode using non-zero disassembly offset? Don\'t know how to handle this yet. Please report this problem'));
                }
                const startAddr = Math.max(0, Math.min(baseAddress, baseAddress + (instrOffset * this.maxInstrSize)));
                const endAddr = baseAddress + (args.instructionCount + instrOffset) * this.maxInstrSize;
                // this.handleMsg('log', 'Start: ' + ([startAddr, baseAddress, baseAddress - startAddr].map((x) => hexFormat(x))).join(',') + '\n');
                // this.handleMsg('log', 'End  : ' + ([baseAddress, endAddr, endAddr - baseAddress].map((x) => hexFormat(x))).join(',') + '\n');

                const ranges = this.findDisasmRanges(startAddr, endAddr, baseAddress);
                const promises = ranges.map((r) => this.getProtocolDisassembly(r, args));
                const instrRanges = await Promise.all(promises);
                const orig = Array.from(instrRanges);
                // Remove all Error items from front and back
                while ((instrRanges.length > 0) && !(instrRanges[0] instanceof DisassemblyReturn)) {
                    instrRanges.shift();
                    ranges.shift();
                }
                while ((instrRanges.length > 0) && !(instrRanges[instrRanges.length - 1] instanceof DisassemblyReturn)) {
                    instrRanges.pop();
                    ranges.pop();
                }
                if (instrRanges.length === 0) {
                    throw new Error(`Disassembly failed completely for ${hexFormat(startAddr)} - ${hexFormat(endAddr)}`);
                }
                let all: InstructionRange;
                for (const r of instrRanges) {
                    const range = ranges.shift();
                    if (!(r instanceof DisassemblyReturn)) {
                        throw new Error(`Disassembly failed completely for ${hexFormat(range.qStart)} - ${hexFormat(range.qEnd)}`);
                    }
                    const tmp = new InstructionRange((r as DisassemblyReturn).instructions);
                    if (!all) {
                        all = tmp;
                    } else {
                        all.forceMerge(tmp);
                    }
                }

                let instrs = all.instructions;