Method findDisasmRanges

src/backend/disasm.ts:810–873

(trueStart: number, trueEnd: number, referenceAddress: number)

    // information when there are gaps between functions. There is also a problem with functions
    // that do not have a size
    private findDisasmRanges(trueStart: number, trueEnd: number, referenceAddress: number): DisasmRange[] {
        const doDbgPrint = false;
        const printFunc = (item: SymbolNode) => {
            if (doDbgPrint) {
                const file = item.symbol.file || '<unknown-file>';
                const msg = `(${hexFormat(item.low)}, ${item.low}), (${hexFormat(item.high)}, ${item.high}) ${item.symbol.name} ${file}`;
                this.handleMsg('stdout', msg + '\n');
                console.log(msg);
            }
        };

        if (doDbgPrint) {
            this.handleMsg('stdout', `${hexFormat(trueStart)}, ${hexFormat(trueEnd)} Search range\n`);
            this.handleMsg('stdout', '-'.repeat(80) + '\n');
        }
        trueStart = this.clipLow(referenceAddress, trueStart);
        trueEnd = this.clipHigh(referenceAddress, trueEnd);

        const ret: DisasmRange[] = [];
        const functions = this.gdbSession.symbolTable.symbolsAsIntervalTree.search(trueStart, trueEnd);
        let range: DisasmRange = {
            qStart: Math.min(trueStart, referenceAddress),
            qEnd: Math.max(trueEnd, referenceAddress + this.maxInstrSize),
            verify: referenceAddress,
            isKnownStart: false
        };
        ret.push(range);
        if (functions.length > 0) {
            let prev = functions[0];
            printFunc(prev);
            let high = prev.high + 1;
            range.qEnd = high;
            range.verify = range.qStart = prev.low;
            range.symNode = prev;
            range.isKnownStart = true;
            for (let ix = 1; ix < functions.length; ix++ ) {
                const item = functions[ix];
                if ((prev.low !== item.low) || (prev.high !== item.high)) { // Yes, duplicates are possible
                    const diff = item.low - high;
                    high = item.high + 1;
                    if (diff === 0) {
                        range.qEnd = high;      // extend the range
                    } else {
                        range.qEnd = Math.max(range.qEnd, item.low /*- 1*/);
                        // If we want to deal with gaps between functions as if they are data, this is the place to do it
                        range = {       // Start a new range
                            qStart: item.low,
                            qEnd: high,
                            verify: item.low,
                            isKnownStart: true,
                            symNode: item
                        };
                        ret.push(range);
                    }
                }
                printFunc(item);
                prev = item;
            }