711 lines
16 KiB
Go
711 lines
16 KiB
Go
package vm
|
|
|
|
// interrupt, N Z C I D V
|
|
// push PC+2, push SR - - - 1 - -
|
|
func execBRK(vm *VM, o operation) error {
|
|
// set processer status flag to BRK
|
|
vm.cpu.ps = flagBreak
|
|
|
|
vm.pushDWordToStack(vm.cpu.pc + 1)
|
|
vm.pushWordToStack(vm.cpu.ps)
|
|
|
|
vm.setFlag(flagDisableInterrupts)
|
|
vm.cpu.pc = uint16(vm.mem[0xFFFF])<<8 | uint16(vm.mem[0xFFFE])
|
|
|
|
return nil
|
|
}
|
|
|
|
// pull SR, pull PC N Z C I D V
|
|
// from stack
|
|
func execRTI(vm *VM, o operation) error {
|
|
vm.cpu.ps = vm.popStackWord()
|
|
vm.cpu.pc = vm.popStackDWord()
|
|
return nil
|
|
}
|
|
|
|
// M - 1 -> M N Z C I D V
|
|
// + + - - - -
|
|
func execDEC(vm *VM, o operation) error {
|
|
addr, err := vm.getAddr(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
b := vm.mem[addr]
|
|
b--
|
|
vm.mem[addr] = b
|
|
vm.maybeSetFlagZero(b)
|
|
vm.maybeSetFlagOverflow(b)
|
|
return nil
|
|
}
|
|
|
|
// M + 1 -> M N Z C I D V
|
|
// + + - - - -
|
|
func execINC(vm *VM, o operation) error {
|
|
addr, err := vm.getAddr(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
b := vm.mem[addr]
|
|
b++
|
|
vm.mem[addr] = b
|
|
vm.maybeSetFlagZero(b)
|
|
vm.maybeSetFlagOverflow(b)
|
|
return nil
|
|
}
|
|
|
|
// X + 1 -> X N Z C I D V
|
|
// + + - - - -
|
|
func execINX(vm *VM, o operation) error {
|
|
vm.cpu.x++
|
|
vm.maybeSetFlagZero(vm.cpu.x)
|
|
vm.maybeSetFlagOverflow(vm.cpu.x)
|
|
return nil
|
|
}
|
|
|
|
// Y + 1 -> Y N Z C I D V
|
|
// + + - - - -
|
|
func execINY(vm *VM, o operation) error {
|
|
vm.cpu.y++
|
|
vm.maybeSetFlagZero(vm.cpu.y)
|
|
vm.maybeSetFlagOverflow(vm.cpu.y)
|
|
return nil
|
|
}
|
|
|
|
// A -> X N Z C I D V
|
|
// + + - - - -
|
|
func execTAX(vm *VM, o operation) error {
|
|
vm.cpu.x = vm.cpu.a
|
|
vm.maybeSetFlagZero(vm.cpu.x)
|
|
vm.maybeSetFlagOverflow(vm.cpu.x)
|
|
return nil
|
|
}
|
|
|
|
// A -> Y N Z C I D V
|
|
// + + - - - -
|
|
func execTAY(vm *VM, o operation) error {
|
|
vm.cpu.y = vm.cpu.a
|
|
vm.maybeSetFlagZero(vm.cpu.y)
|
|
vm.maybeSetFlagOverflow(vm.cpu.y)
|
|
return nil
|
|
}
|
|
|
|
// X - 1 -> X N Z C I D V
|
|
// + + - - - -
|
|
func execDEX(vm *VM, o operation) error {
|
|
vm.cpu.x--
|
|
vm.maybeSetFlagZero(vm.cpu.x)
|
|
vm.maybeSetFlagOverflow(vm.cpu.x)
|
|
return nil
|
|
}
|
|
|
|
// Y - 1 -> Y N Z C I D V
|
|
// + + - - - -
|
|
func execDEY(vm *VM, o operation) error {
|
|
vm.cpu.y--
|
|
vm.maybeSetFlagZero(vm.cpu.y)
|
|
vm.maybeSetFlagOverflow(vm.cpu.y)
|
|
return nil
|
|
}
|
|
|
|
// M -> A N Z C I D V
|
|
// + + - - - -
|
|
func execLDA(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.cpu.a = operand
|
|
vm.maybeSetFlagZero(vm.cpu.a)
|
|
vm.maybeSetFlagOverflow(vm.cpu.a)
|
|
return nil
|
|
}
|
|
|
|
// M -> X N Z C I D V
|
|
// + + - - - -
|
|
func execLDX(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.cpu.x = operand
|
|
vm.maybeSetFlagZero(vm.cpu.x)
|
|
vm.maybeSetFlagOverflow(vm.cpu.x)
|
|
return nil
|
|
}
|
|
|
|
// M -> Y N Z C I D V
|
|
// + + - - - -
|
|
func execLDY(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.cpu.y = operand
|
|
vm.maybeSetFlagZero(vm.cpu.y)
|
|
vm.maybeSetFlagOverflow(vm.cpu.y)
|
|
return nil
|
|
}
|
|
|
|
// A + M + C -> A, C N Z C I D V
|
|
// + + + - - +
|
|
func execADC(vm *VM, o operation) error {
|
|
b, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
operand := uint16(b)
|
|
regA := uint16(vm.cpu.a)
|
|
sum := regA + operand + uint16(vm.getFlag(flagCarry))
|
|
vm.cpu.a = byte(sum)
|
|
|
|
vm.clearFlag(flagCarry)
|
|
if sum > 255 {
|
|
vm.setFlag(flagCarry)
|
|
}
|
|
|
|
// http://www.righto.com/2012/12/the-6502-overflow-flag-explained.html
|
|
vm.clearFlag(flagOverflow)
|
|
if (operand^sum)&(regA^sum)&0x80 != 0 {
|
|
vm.setFlag(flagOverflow)
|
|
}
|
|
|
|
vm.maybeSetFlagZero(vm.cpu.a)
|
|
vm.maybeSetFlagOverflow(vm.cpu.a)
|
|
|
|
return nil
|
|
}
|
|
|
|
// A - M - C -> A N Z C I D V
|
|
// + + + - - +
|
|
func execSBC(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
carry := uint16(1 - vm.getFlag(flagCarry))
|
|
regA := vm.cpu.a
|
|
sum := uint16(regA) - carry - uint16(operand)
|
|
vm.cpu.a = byte(sum)
|
|
vm.clearFlag(flagOverflow)
|
|
|
|
if byte(regA)>>7 != vm.cpu.a>>7 {
|
|
vm.setFlag(flagOverflow)
|
|
}
|
|
|
|
if uint16(sum) < 256 {
|
|
vm.setFlag(flagCarry)
|
|
} else {
|
|
vm.clearFlag(flagCarry)
|
|
}
|
|
|
|
vm.clearFlag(flagOverflow)
|
|
if ((255-operand)^vm.cpu.a)&(regA^vm.cpu.a)&0x80 != 0 {
|
|
vm.setFlag(flagOverflow)
|
|
}
|
|
|
|
vm.maybeSetFlagZero(vm.cpu.a)
|
|
vm.maybeSetFlagOverflow(vm.cpu.a)
|
|
return nil
|
|
}
|
|
|
|
// X -> M N Z C I D V
|
|
// - - - - - -
|
|
func execSTX(vm *VM, o operation) error {
|
|
addr, err := vm.getAddr(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.mem[addr] = vm.cpu.x
|
|
return nil
|
|
}
|
|
|
|
// Y -> M N Z C I D V
|
|
// - - - - - -
|
|
func execSTY(vm *VM, o operation) error {
|
|
addr, err := vm.getAddr(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.mem[addr] = vm.cpu.y
|
|
return nil
|
|
}
|
|
|
|
// A -> M N Z C I D V
|
|
// - - - - - -
|
|
func execSTA(vm *VM, o operation) error {
|
|
addr, err := vm.getAddr(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.mem[addr] = vm.cpu.a
|
|
return nil
|
|
}
|
|
|
|
// branch on Z = 1 N Z C I D V
|
|
// - - - - - -
|
|
func execBEQ(vm *VM, o operation) error {
|
|
if vm.getFlag(flagZero) == flagZero {
|
|
vm.branch(o)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// branch on Z = 0 N Z C I D V
|
|
// - - - - - -
|
|
func execBNE(vm *VM, o operation) error {
|
|
if vm.getFlag(flagZero) != flagZero {
|
|
vm.branch(o)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// branch on V = 0 N Z C I D V
|
|
// - - - - - -
|
|
func execBVC(vm *VM, o operation) error {
|
|
if vm.getFlag(flagOverflow) == 0 {
|
|
vm.branch(o)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// branch on V = 1 N Z C I D V
|
|
// - - - - - -
|
|
func execBVS(vm *VM, o operation) error {
|
|
if vm.getFlag(flagOverflow) != 0 {
|
|
vm.branch(o)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// bits 7 and 6 of operand are transfered to bit 7 and 6 of SR (N,V);
|
|
// the zeroflag is set to the result of operand AND accumulator.
|
|
func execBIT(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.maybeSetFlagZero(vm.cpu.a & operand)
|
|
vm.clearFlag(flagOverflow)
|
|
|
|
if operand&flagOverflow != 0 {
|
|
vm.setFlag(flagOverflow)
|
|
}
|
|
|
|
vm.maybeSetFlagOverflow(operand)
|
|
return nil
|
|
}
|
|
|
|
// branch on C = 0 N Z C I D V
|
|
// - - - - - -
|
|
func execBCC(vm *VM, o operation) error {
|
|
if vm.getFlag(flagCarry) == 0 {
|
|
vm.branch(o)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// branch on N = 1 N Z C I D V
|
|
// - - - - - -
|
|
func execBMI(vm *VM, o operation) error {
|
|
if vm.getFlag(flagNegative) == flagNegative {
|
|
vm.branch(o)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// branch on N = 0 N Z C I D V
|
|
// - - - - - -
|
|
func execBPL(vm *VM, o operation) error {
|
|
if vm.getFlag(flagNegative) == 0 {
|
|
vm.branch(o)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// branch on C = 1 N Z C I D V
|
|
// - - - - - -
|
|
func execBCS(vm *VM, o operation) error {
|
|
if vm.getFlag(flagCarry) != 0 {
|
|
vm.branch(o)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// X - M N Z C I D V
|
|
// + + + - - -
|
|
func execCPX(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.compare(vm.cpu.x, operand)
|
|
return nil
|
|
}
|
|
|
|
// A EOR M -> A N Z C I D V
|
|
// + + - - - -
|
|
func execEOR(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.cpu.a ^= operand
|
|
vm.maybeSetFlagOverflow(vm.cpu.a)
|
|
vm.maybeSetFlagZero(vm.cpu.a)
|
|
return nil
|
|
}
|
|
|
|
// A - M N Z C I D V
|
|
// + + + - - -
|
|
func execCMP(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.compare(vm.cpu.a, operand)
|
|
return nil
|
|
}
|
|
|
|
// Y - M N Z C I D V
|
|
// + + + - - -
|
|
func execCPY(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.compare(vm.cpu.y, operand)
|
|
return nil
|
|
}
|
|
|
|
// 0 -> C N Z C I D V
|
|
// - - 0 - - -
|
|
func execCLC(vm *VM, o operation) error {
|
|
vm.clearFlag(flagCarry)
|
|
return nil
|
|
}
|
|
|
|
// 0 -> D N Z C I D V
|
|
// - - - - 0 -
|
|
func execCLD(vm *VM, o operation) error {
|
|
vm.clearFlag(flagDecimalMode)
|
|
return nil
|
|
}
|
|
|
|
// 0 -> I N Z C I D V
|
|
// - - - 0 - -
|
|
func execCLI(vm *VM, o operation) error {
|
|
vm.clearFlag(flagDisableInterrupts)
|
|
return nil
|
|
}
|
|
|
|
// 0 -> V N Z C I D V
|
|
// - - - - - 0
|
|
func execCLV(vm *VM, o operation) error {
|
|
vm.clearFlag(flagOverflow)
|
|
return nil
|
|
}
|
|
|
|
// 1 -> C N Z C I D V
|
|
// - - 1 - - -
|
|
func execSEC(vm *VM, o operation) error {
|
|
vm.setFlag(flagCarry)
|
|
return nil
|
|
}
|
|
|
|
// 1 -> D N Z C I D V
|
|
// - - - - 1 -
|
|
func execSED(vm *VM, o operation) error {
|
|
vm.setFlag(flagDecimalMode)
|
|
return nil
|
|
}
|
|
|
|
// 1 -> I N Z C I D V
|
|
// - - - 1 - -
|
|
func execSEI(vm *VM, o operation) error {
|
|
vm.setFlag(flagDisableInterrupts)
|
|
return nil
|
|
}
|
|
|
|
// --- N Z C I D V
|
|
// - - - - - -
|
|
func execNOP(vm *VM, o operation) error {
|
|
return nil
|
|
}
|
|
|
|
// (PC+1) -> PCL N Z C I D V
|
|
// (PC+2) -> PCH - - - - - -
|
|
func execJMP(vm *VM, o operation) error {
|
|
if o.addrMode == indirect {
|
|
addr, err := vm.getAddr(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.cpu.pc = vm.littleEndianToUint16(vm.mem[addr+1], vm.mem[addr])
|
|
return nil
|
|
}
|
|
addr, err := vm.getAddr(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.cpu.pc = addr
|
|
return nil
|
|
}
|
|
|
|
// push A N Z C I D V
|
|
// - - - - - -
|
|
func execPHA(vm *VM, o operation) error {
|
|
vm.pushWordToStack(vm.cpu.a)
|
|
return nil
|
|
}
|
|
|
|
// X -> A N Z C I D V
|
|
// + + - - - -
|
|
func execTXA(vm *VM, o operation) error {
|
|
vm.cpu.a = vm.cpu.x
|
|
vm.maybeSetFlagOverflow(vm.cpu.a)
|
|
vm.maybeSetFlagZero(vm.cpu.a)
|
|
return nil
|
|
}
|
|
|
|
// Y -> A N Z C I D V
|
|
// + + - - - -
|
|
func execTYA(vm *VM, o operation) error {
|
|
vm.cpu.a = vm.cpu.y
|
|
vm.maybeSetFlagOverflow(vm.cpu.a)
|
|
vm.maybeSetFlagZero(vm.cpu.a)
|
|
return nil
|
|
}
|
|
|
|
// SP -> X N Z C I D V
|
|
// + + - - - -
|
|
func execTSX(vm *VM, o operation) error {
|
|
vm.cpu.x = vm.cpu.sp
|
|
vm.maybeSetFlagOverflow(vm.cpu.x)
|
|
vm.maybeSetFlagZero(vm.cpu.x)
|
|
return nil
|
|
}
|
|
|
|
// pull A N Z C I D V
|
|
// + + - - - -
|
|
func execPLA(vm *VM, o operation) error {
|
|
vm.cpu.a = vm.popStackWord()
|
|
vm.maybeSetFlagOverflow(vm.cpu.a)
|
|
vm.maybeSetFlagZero(vm.cpu.a)
|
|
return nil
|
|
}
|
|
|
|
// pull SR from stack N Z C I D V
|
|
func execPLP(vm *VM, o operation) error {
|
|
vm.cpu.ps = vm.popStackWord() | 0B_00110000
|
|
vm.maybeSetFlagOverflow(vm.cpu.a)
|
|
vm.maybeSetFlagZero(vm.cpu.a)
|
|
return nil
|
|
}
|
|
|
|
// push SR N Z C I D V
|
|
// - - - - - -
|
|
func execPHP(vm *VM, o operation) error {
|
|
vm.pushWordToStack(vm.cpu.ps)
|
|
return nil
|
|
}
|
|
|
|
// push (PC+2), N Z C I D V
|
|
// (PC+1) -> PCL - - - - - -
|
|
// (PC+2) -> PCH
|
|
func execJSR(vm *VM, o operation) error {
|
|
vm.pushDWordToStack(vm.cpu.pc - 1)
|
|
addr, err := vm.getAddr(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.cpu.pc = addr
|
|
return nil
|
|
}
|
|
|
|
// pull PC, PC+1 -> PC N Z C I D V
|
|
// - - - - - -
|
|
func execRTS(vm *VM, o operation) error {
|
|
vm.cpu.pc = vm.popStackDWord() + 1
|
|
return nil
|
|
}
|
|
|
|
// 0 -> [76543210] -> C N Z C I D V
|
|
// 0 + + - - -
|
|
func execLSR(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
bit := (operand << 7) > 0
|
|
operand >>= 1
|
|
|
|
if bit {
|
|
vm.setFlag(flagCarry)
|
|
} else {
|
|
vm.clearFlag(flagCarry)
|
|
}
|
|
|
|
vm.maybeSetFlagZero(operand)
|
|
vm.maybeSetFlagOverflow(operand)
|
|
|
|
if o.addrMode == accumulator {
|
|
vm.cpu.a = operand
|
|
return nil
|
|
}
|
|
|
|
if err := vm.setMem(o, operand); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// C <- [76543210] <- C N Z C I D V
|
|
// + + + - - -
|
|
func execROL(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var carry bool
|
|
if vm.getFlag(flagCarry) == flagCarry {
|
|
carry = true
|
|
}
|
|
|
|
if operand>>7 != 0 {
|
|
vm.setFlag(flagCarry)
|
|
} else {
|
|
vm.clearFlag(flagCarry)
|
|
}
|
|
|
|
operand <<= 1
|
|
|
|
if carry {
|
|
operand |= flagCarry
|
|
}
|
|
|
|
vm.maybeSetFlagZero(operand)
|
|
vm.maybeSetFlagOverflow(operand)
|
|
|
|
if o.addrMode == accumulator {
|
|
vm.cpu.a = operand
|
|
return nil
|
|
}
|
|
|
|
if err := vm.setMem(o, operand); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// X -> SP N Z C I D V
|
|
// - - - - - -
|
|
func execTXS(vm *VM, o operation) error {
|
|
vm.cpu.sp = vm.cpu.x
|
|
// TODO: needed?
|
|
// vm.maybeSetFlagZero(vm.cpu.sp)
|
|
// vm.maybeSetFlagOverflow(vm.cpu.sp)
|
|
return nil
|
|
}
|
|
|
|
// C -> [76543210] -> C N Z C I D V
|
|
// + + + - - -
|
|
func execROR(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var carry bool
|
|
if vm.getFlag(flagCarry) == flagCarry {
|
|
carry = true
|
|
}
|
|
|
|
if operand&0x01 != 0 {
|
|
vm.setFlag(flagCarry)
|
|
} else {
|
|
vm.clearFlag(flagCarry)
|
|
}
|
|
|
|
operand >>= 1
|
|
|
|
if carry {
|
|
operand |= flagNegative
|
|
}
|
|
|
|
vm.maybeSetFlagZero(operand)
|
|
vm.maybeSetFlagOverflow(operand)
|
|
|
|
if o.addrMode == accumulator {
|
|
vm.cpu.a = operand
|
|
return nil
|
|
}
|
|
|
|
if err := vm.setMem(o, operand); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// C <- [76543210] <- 0 N Z C I D V
|
|
// + + + - - -
|
|
func execASL(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if operand>>7 == 1 {
|
|
vm.setFlag(flagCarry)
|
|
} else {
|
|
vm.clearFlag(flagCarry)
|
|
}
|
|
|
|
operand <<= 1
|
|
|
|
vm.maybeSetFlagZero(operand)
|
|
vm.maybeSetFlagOverflow(operand)
|
|
|
|
if o.addrMode == accumulator {
|
|
vm.cpu.a = operand
|
|
return nil
|
|
}
|
|
|
|
if err := vm.setMem(o, operand); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// A AND M -> A N Z C I D V
|
|
// + + - - - -
|
|
func execAND(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.cpu.a &= operand
|
|
vm.maybeSetFlagZero(vm.cpu.a)
|
|
vm.maybeSetFlagOverflow(vm.cpu.a)
|
|
return nil
|
|
}
|
|
|
|
// A OR M -> A N Z C I D V
|
|
// + + - - - -
|
|
func execORA(vm *VM, o operation) error {
|
|
operand, err := vm.getOperand(o)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
vm.cpu.a |= operand
|
|
vm.maybeSetFlagZero(vm.cpu.a)
|
|
vm.maybeSetFlagOverflow(vm.cpu.a)
|
|
return nil
|
|
}
|