import { hex, byte2signed } from "./util"; import { Platform } from "./baseplatform"; export interface CodeAnalyzer { showLoopTimingForPC(pc:number); pc2minclocks : {[key:number]:number}; pc2maxclocks : {[key:number]:number}; MAX_CLOCKS : number; } /// VCS TIMING ANALYSIS // [taken, not taken] const BRANCH_CONSTRAINTS = [ [{N:0},{N:1}], [{N:1},{N:0}], [{V:0},{V:1}], [{V:1},{V:0}], [{C:0},{C:1}], [{C:1},{C:0}], [{Z:0},{Z:1}], [{Z:1},{Z:0}] ]; function constraintEquals(a,b) { if (a == null || b == null) return null; for (var n in a) { if (b[n] !== 'undefined') return a[n] == b[n]; } for (var n in b) { if (a[n] !== 'undefined') return a[n] == b[n]; } return null; } abstract class CodeAnalyzer6502 implements CodeAnalyzer { pc2minclocks = {}; pc2maxclocks = {}; START_CLOCKS : number; MAX_CLOCKS : number; WRAP_CLOCKS : boolean; jsrresult = {}; platform : Platform; MAX_CYCLES : number = 2000; constructor(platform : Platform) { this.platform = platform; } getClockCountsAtPC(pc) { var opcode = this.platform.readAddress(pc); var meta = this.platform.getOpcodeMetadata(opcode, pc); return meta; // minCycles, maxCycles } traceInstructions(pc:number, minclocks:number, maxclocks:number, subaddr:number, constraints) { if (this.WRAP_CLOCKS) { if (this.pc2minclocks[pc] !== undefined) minclocks = Math.min(minclocks, this.pc2minclocks[pc]); if (this.pc2maxclocks[pc] !== undefined) maxclocks = Math.max(maxclocks, this.pc2maxclocks[pc]); } //console.log("trace", hex(pc), minclocks, maxclocks); if (!constraints) constraints = {}; var modified = true; var abort = false; for (var i=0; modified && !abort; i++) { if (i >= this.MAX_CYCLES) { console.log("too many cycles @", hex(pc), "routine", hex(subaddr)); break; } modified = false; if (this.WRAP_CLOCKS && minclocks >= this.MAX_CLOCKS) { // wrap clocks minclocks = minclocks % this.MAX_CLOCKS; maxclocks = maxclocks % this.MAX_CLOCKS; } else { // truncate clocks minclocks = Math.min(this.MAX_CLOCKS, minclocks); maxclocks = Math.min(this.MAX_CLOCKS, maxclocks); } var meta = this.getClockCountsAtPC(pc); var lob = this.platform.readAddress(pc+1); var hib = this.platform.readAddress(pc+2); var addr = lob + (hib << 8); var pc0 = pc; if (!(minclocks >= this.pc2minclocks[pc0])) { this.pc2minclocks[pc0] = minclocks; modified = true; } if (!(maxclocks <= this.pc2maxclocks[pc0])) { this.pc2maxclocks[pc0] = maxclocks; modified = true; } //console.log(hex(pc),minclocks,maxclocks,modified,meta,constraints); if (!meta.insnlength) { console.log("Illegal instruction!", hex(pc), hex(meta.opcode), meta); break; } pc += meta.insnlength; var oldconstraints = constraints; constraints = null; // TODO: if jump to zero-page, maybe assume RTS? switch (meta.opcode) { /* case 0xb9: // TODO: hack for zero page,y if (addr < 0x100) meta.maxCycles -= 1; break; */ // TODO: only VCS case 0x85: if (lob == 0x2) { // STA WSYNC minclocks = maxclocks = 0; meta.minCycles = meta.maxCycles = 0; } break; // TODO: only NES (sprite 0 poll) case 0x2c: if (lob == 0x02 && hib == 0x20) { // BIT $2002 minclocks = 0; maxclocks = 4; // uncertainty b/c of assumed branch poll meta.minCycles = meta.maxCycles = 0; } break; case 0x20: // JSR this.traceInstructions(addr, minclocks, maxclocks, addr, constraints); var result = this.jsrresult[addr]; if (result) { minclocks = result.minclocks; maxclocks = result.maxclocks; } else { console.log("No JSR result!", hex(pc), hex(addr)); return; } break; case 0x4c: // JMP pc = addr; // TODO: make sure in ROM space break; case 0x40: // RTI abort = true; break; case 0x60: // RTS if (subaddr) { // TODO: 0 doesn't work // TODO: combine with previous result var result = this.jsrresult[subaddr]; if (!result) { result = {minclocks:minclocks, maxclocks:maxclocks}; } else { result = { minclocks:Math.min(minclocks,result.minclocks), maxclocks:Math.max(maxclocks,result.maxclocks) } } this.jsrresult[subaddr] = result; console.log("RTS", hex(pc), hex(subaddr), this.jsrresult[subaddr]); } return; case 0x10: case 0x30: // branch case 0x50: case 0x70: case 0x90: case 0xB0: case 0xD0: case 0xF0: var newpc = pc + byte2signed(lob); var crosspage = (pc>>8) != (newpc>>8); if (!crosspage) meta.maxCycles--; // TODO: other instructions might modify flags too var cons = BRANCH_CONSTRAINTS[Math.floor((meta.opcode-0x10)/0x20)]; var cons0 = constraintEquals(oldconstraints, cons[0]); var cons1 = constraintEquals(oldconstraints, cons[1]); // recursively trace the taken branch if (true || cons0 !== false) { // TODO? this.traceInstructions(newpc, minclocks+meta.maxCycles, maxclocks+meta.maxCycles, subaddr, cons[0]); } // abort if we will always take the branch if (cons1 === false) { console.log("branch always taken", hex(pc), oldconstraints, cons[1]); abort = true; } constraints = cons[1]; // not taken meta.maxCycles = meta.minCycles; // branch not taken, no extra clock(s) break; case 0x6c: console.log("Instruction not supported!", hex(pc), hex(meta.opcode), meta); // TODO return; } // add min/max instruction time to min/max clocks bound minclocks += meta.minCycles; maxclocks += meta.maxCycles; } } showLoopTimingForPC(pc:number) { this.pc2minclocks = {}; this.pc2maxclocks = {}; this.jsrresult = {}; // recurse through all traces this.traceInstructions(pc | this.platform.getOriginPC(), this.START_CLOCKS, this.MAX_CLOCKS, 0, {}); } } // 76 cycles * 2 (support two scanline kernels) export class CodeAnalyzer_vcs extends CodeAnalyzer6502 { constructor(platform : Platform) { super(platform); this.MAX_CLOCKS = this.START_CLOCKS = 76*2; // 2 scanlines this.WRAP_CLOCKS = false; } } // https://wiki.nesdev.com/w/index.php/PPU_rendering#Line-by-line_timing // TODO: sprite 0 hit, CPU stalls export class CodeAnalyzer_nes extends CodeAnalyzer6502 { constructor(platform : Platform) { super(platform); this.MAX_CLOCKS = 114; // 341 clocks for 3 scanlines this.START_CLOCKS = 0; this.WRAP_CLOCKS = true; } }