public void Test_LD_HLP_A() { byte data = 0x42; ushort hl = 0x1234; var actualState = new CpuState(); actualState.Registers.A = data; actualState.Registers.HL = hl; var expectedState = new CpuState(); expectedState.Registers.A = data; expectedState.Registers.HL = (ushort)(hl + 1); var memoryMock = new Mock <IRandomAccessMemory>(); var instruction = new LD_HLP_A(); instruction.Initialize(); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(hl, data), Times.Once); }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, Action<byte> write, ref int cycles) { bool carry = cpuState.IsFlagSet(CpuState.Flags.Carry); cpuState.SetFlag(CpuState.Flags.Carry, arg & 0x80); arg <<= 1; if (carry) { arg |= 1; } write(arg); cpuState.SetNegativeFlag(arg); cpuState.SetZeroFlag(arg); switch (Variants[memory[cpuState.Pc]]) { case AddressingMode.Accumulator: cycles = 2; break; case AddressingMode.ZeroPage: cycles = 5; break; case AddressingMode.ZeroPageXIndexed: cycles = 6; break; case AddressingMode.Absolute: cycles = 6; break; case AddressingMode.AbsoluteX: cycles = 7; break; } }
public void Test_RST(byte opcode) { ushort resetAddress = (ushort)(opcode & 0x38); ushort sp = 0x4242; ushort pc = 0x1122; var expectedState = new CpuState(); expectedState.StackPointer = (ushort)(sp - 2); expectedState.ProgramCounter = resetAddress; var actualState = new CpuState(); actualState.StackPointer = sp; actualState.ProgramCounter = pc; var memoryMock = new Mock <IRandomAccessMemory>(); var instruction = new RST(); instruction.Initialize(opcode); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte((ushort)(sp - 1), (byte)(pc >> 8)), Times.Once); memoryMock.Verify(m => m.WriteByte((ushort)(sp - 2), (byte)(pc & 0x00FF)), Times.Once); }
public void Test_JR() { ushort pc = 0x4242; byte offset = 0x11; var expectedState = new CpuState(); expectedState.ProgramCounter = (ushort)(pc + 1 + (sbyte)offset); var actualState = new CpuState(); actualState.ProgramCounter = pc; var memoryMock = new Mock <IRandomAccessMemory>(); memoryMock.Setup(m => m.ReadByte(pc)).Returns(offset); var instruction = new JR(); instruction.Initialize(); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(It.IsAny <ushort>(), It.IsAny <byte>()), Times.Never); }
public void Test_RET() { ushort sp = 0x4242; byte lsbData = 0x11; byte msbData = 0x22; var expectedState = new CpuState(); expectedState.StackPointer = (ushort)(sp + 2); expectedState.ProgramCounter = (ushort)((msbData << 8) | lsbData); var actualState = new CpuState(); actualState.StackPointer = sp; var memoryMock = new Mock <IRandomAccessMemory>(); memoryMock.Setup(m => m.ReadByte(sp)).Returns(lsbData); memoryMock.Setup(m => m.ReadByte((ushort)(sp + 1))).Returns(msbData); var instruction = new RET(); instruction.Initialize(); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(It.IsAny <ushort>(), It.IsAny <byte>()), Times.Never); }
public void Test_RLR8(byte opcode) { var registerIndex = opcode & 0x07; var actualState = new CpuState(); actualState.Registers[registerIndex] = 0x08; actualState.Registers.ZeroFlag = true; actualState.Registers.SubtractionFlag = true; actualState.Registers.HalfCarryFlag = true; actualState.Registers.CarryFlag = true; var expectedState = new CpuState(); expectedState.Registers[registerIndex] = 0x11; var memoryMock = new Mock <IRandomAccessMemory>(); var instruction = new RLR8(); instruction.Initialize(opcode); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(It.IsAny <ushort>(), It.IsAny <byte>()), Times.Never); }
public void Test_LDA_D16_() { ushort pc = 0x1111; byte data = 0x42; byte addressLsb = 0x23; byte addressMsb = 0x01; var actualState = new CpuState(); actualState.ProgramCounter = pc; var expectedState = new CpuState(); expectedState.Registers.A = data; expectedState.ProgramCounter = (ushort)(pc + 2); var memoryMock = new Mock <IRandomAccessMemory>(); memoryMock.Setup(m => m.ReadByte(pc)).Returns(addressLsb); memoryMock.Setup(m => m.ReadByte((ushort)(pc + 1))).Returns(addressMsb); memoryMock.Setup(m => m.ReadByte((ushort)((addressMsb << 8) | addressLsb))).Returns(data); var instruction = new LDA_D16_(); instruction.Initialize(); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(It.IsAny <ushort>(), It.IsAny <byte>()), Times.Never); }
public void Test_SETN_HL_(byte opcode) { byte data = 0x00; ushort hl = 0x4242; var actualState = new CpuState(); actualState.Registers.HL = hl; var expectedState = new CpuState(); expectedState.Registers.HL = hl; var bitIndex = (opcode & 0x38) >> 3; var memoryMock = new Mock <IRandomAccessMemory>(); memoryMock.Setup(m => m.ReadByte(hl)).Returns(data); var instruction = new SETN_HL_(); instruction.Initialize(opcode); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } //assert TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(hl, (byte)(data | (0x01 << bitIndex))), Times.Once); }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, ref int cycles) { cpuState.X = arg; cpuState.SetNegativeFlag(arg); cpuState.SetZeroFlag(arg); }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, Action<byte> write, ref int cycles) { ushort result = arg; result <<= 1; var byteResult = (byte) (result & 0xFF); write(byteResult); cpuState.SetNegativeFlag(byteResult); cpuState.SetZeroFlag(byteResult); cpuState.SetFlag(CpuState.Flags.Carry, result & 0xFF00); switch (Variants[memory[cpuState.Pc]]) { case AddressingMode.Accumulator: cycles = 2; break; case AddressingMode.ZeroPage: cycles = 5; break; case AddressingMode.ZeroPageXIndexed: cycles = 6; break; case AddressingMode.Absolute: cycles = 6; break; case AddressingMode.AbsoluteX: cycles = 7; break; } }
public void Test_LDR8R8(byte opcode) { byte data = 0x42; var sourceIndex = opcode & 0x07; var targetIndex = (opcode >> 3) & 0x07; var expectedState = new CpuState(); expectedState.Registers[sourceIndex] = data; expectedState.Registers[targetIndex] = data; var actualState = new CpuState(); actualState.Registers[sourceIndex] = data; var memoryMock = new Mock <IRandomAccessMemory>(); var instruction = new LDR8R8(); instruction.Initialize(opcode); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } //assert TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(It.IsAny <ushort>(), It.IsAny <byte>()), Times.Never); }
public void Test_LDSPHL() { ushort hl = 0x1234; var actualState = new CpuState(); actualState.Registers.HL = hl; var expectedState = new CpuState(); expectedState.Registers.HL = hl; expectedState.StackPointer = hl; var memoryMock = new Mock <IRandomAccessMemory>(); var instruction = new LDSPHL(); instruction.Initialize(); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(It.IsAny <ushort>(), It.IsAny <byte>()), Times.Never); }
public virtual void make(CpuState cpu) { pc = cpu.pc; for (int i = 0; i < NUMBER_REGISTERS; i++) { gpr[i] = cpu.getRegister(i); } threadID = Modules.ThreadManForUserModule.CurrentThreadID; threadName = Modules.ThreadManForUserModule.getThreadName(threadID); Memory mem = MemoryViewer.Memory; if (MemoryViewer.isAddressGood(cpu.pc)) { opcode = mem.read32(cpu.pc); Common.Instruction insn = Decoder.instruction(opcode); asm = insn.disasm(cpu.pc, opcode); } else { opcode = 0; asm = "?"; } dirty = true; }
public void Test_LD_HL_D8() { ushort pc = 0x1234; ushort hl = 0x4321; byte data = 0x42; var actualState = new CpuState(); actualState.ProgramCounter = pc; actualState.Registers.HL = hl; var expectedState = new CpuState(); expectedState.ProgramCounter = (ushort)(actualState.ProgramCounter + 1); expectedState.Registers.HL = hl; var memoryMock = new Mock <IRandomAccessMemory>(); memoryMock.Setup(m => m.ReadByte(pc)).Returns(data); var instruction = new LD_HL_D8(); instruction.Initialize(); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(hl, data), Times.Once); }
public void Test_LDA_HLM_() { byte data = 0x42; ushort hl = 0x1234; var actualState = new CpuState(); actualState.Registers.HL = hl; var expectedState = new CpuState(); expectedState.Registers.A = data; expectedState.Registers.HL = (ushort)(hl - 1); var memoryMock = new Mock <IRandomAccessMemory>(); memoryMock.Setup(m => m.ReadByte(hl)).Returns(data); var instruction = new LDA_HLM_(); instruction.Initialize(); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(It.IsAny <ushort>(), It.IsAny <byte>()), Times.Never); }
public void Test_DAA() { byte a = 0x22; var actualState = new CpuState(); actualState.Registers.A = a; actualState.Registers.HalfCarryFlag = true; var expectedState = new CpuState(); expectedState.Registers.A = 0x28; var memoryMock = new Mock <IRandomAccessMemory>(); var instruction = new DAA(); instruction.Initialize(); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(It.IsAny <ushort>(), It.IsAny <byte>()), Times.Never); }
public void Test_LDR8_HL_(byte opcode) { ushort hl = 0x1212; byte data = 0x12; var registerIndex = (opcode >> 3) & 0x7; var actualState = new CpuState(); actualState.Registers.HL = hl; var expectedState = new CpuState(); expectedState.Registers[registerIndex] = data; expectedState.Registers.HL = hl; var memoryMock = new Mock <IRandomAccessMemory>(); memoryMock.Setup(m => m.ReadByte(hl)).Returns(data); var instruction = new LDR8_HL_(); instruction.Initialize(opcode); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(It.IsAny <ushort>(), It.IsAny <byte>()), Times.Never); }
public void Test_DEC_HL_() { ushort address = 0x4242; byte data = 0x00; var expectedState = new CpuState(); expectedState.Registers.HL = address; expectedState.Registers.HalfCarryFlag = true; expectedState.Registers.SubtractionFlag = true; var actualState = new CpuState(); actualState.Registers.HL = address; actualState.Registers.ZeroFlag = true; var memoryMock = new Mock <IRandomAccessMemory>(); memoryMock.Setup(m => m.ReadByte(address)).Returns(data); var instruction = new DEC_HL_(); instruction.Initialize(); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } //assert TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(address, (byte)(data - 1)), Times.Once()); }
public void Test_SWAP_HL_() { ushort hl = 0x4242; byte actualData = 0x42; byte expectedData = 0x24; var actualState = new CpuState(); actualState.Registers.ZeroFlag = true; actualState.Registers.SubtractionFlag = true; actualState.Registers.HalfCarryFlag = true; actualState.Registers.CarryFlag = true; actualState.Registers.HL = hl; var expectedState = new CpuState(); expectedState.Registers.HL = hl; var memoryMock = new Mock <IRandomAccessMemory>(); memoryMock.Setup(m => m.ReadByte(hl)).Returns(actualData); var instruction = new SWAP_HL_(); instruction.Initialize(); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(hl, expectedData), Times.Once); }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, Action<byte> write, ref int cycles) { var res = (byte)((cpuState.X - 1) & 0xFF); cpuState.X = res; cpuState.SetNegativeFlag(res); cpuState.SetZeroFlag(res); }
public void Test_LDH_D8_A() { byte data = 0x42; byte addressLsb = 0x24; ushort pc = 0x1234; var actualState = new CpuState(); actualState.Registers.A = data; actualState.ProgramCounter = pc; var expectedState = new CpuState(); expectedState.Registers.A = data; expectedState.ProgramCounter = (ushort)(pc + 1); var memoryMock = new Mock <IRandomAccessMemory>(); memoryMock.Setup(m => m.ReadByte(pc)).Returns(addressLsb); var instruction = new LDH_D8_A(); instruction.Initialize(); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte((ushort)((0xFF << 8) | addressLsb), data), Times.Once); }
public MonitorFrame(byte[] buf) { if (buf.Length < frame_len) { return; } frame_head_tag = BitConverter.ToUInt16(buf, 0); if (frame_head_tag != 0xAA50) { return; } frame_sn = BitConverter.ToUInt16(buf, 2); time_stamp = BitConverter.ToUInt32(buf, 4); data_type = (MonitorDataType)BitConverter.ToUInt16(buf, 8); series_state = (SeriesState)buf[10]; cpu_state = (CpuState)buf[11]; data_length = BitConverter.ToUInt16(buf, 12); crc = BitConverter.ToUInt16(buf, 14); UInt16 new_crc = Crc16.GetCrc(buf, 14); if (new_crc != crc) { return; } is_ok = true; return; }
public void Test_SETNR8(byte opcode) { var expectedState = new CpuState(); var actualState = new CpuState(); var bitIndex = (opcode & 0x38) >> 3; var registerIndex = opcode & 0x07; expectedState.Registers[registerIndex] = (ushort)(0x01 << bitIndex); var memoryMock = new Mock <IRandomAccessMemory>(); var instruction = new SETNR8(); instruction.Initialize(opcode); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } //assert TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(It.IsAny <ushort>(), It.IsAny <byte>()), Times.Never); }
public int Execute(CpuState cpuState, IMemory memory) { throw new Exception("die"); cpuState.Interrupt(0xFFFE, memory); return 7; }
public void Test_LDHA_C_() { byte data = 0x42; byte addressLsb = 0x24; var actualState = new CpuState(); actualState.Registers.C = addressLsb; var expectedState = new CpuState(); expectedState.Registers.A = data; expectedState.Registers.C = addressLsb; var memoryMock = new Mock <IRandomAccessMemory>(); memoryMock.Setup(m => m.ReadByte((ushort)((0xFF << 8) | addressLsb))).Returns(data); var instruction = new LDHA_C_(); instruction.Initialize(); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(It.IsAny <ushort>(), It.IsAny <byte>()), Times.Never); }
public void Test_LDR8D8(byte opcode) { ushort pc = 0x1234; byte data = 0x42; var registerIndex = opcode >> 3; var actualState = new CpuState(); actualState.ProgramCounter = pc; var expectedState = new CpuState(); expectedState.ProgramCounter = (ushort)(actualState.ProgramCounter + 1); expectedState.Registers[registerIndex] = data; var memoryMock = new Mock <IRandomAccessMemory>(); memoryMock.Setup(m => m.ReadByte(pc)).Returns(data); var instruction = new LDR8D8(); instruction.Initialize(opcode); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(It.IsAny <ushort>(), It.IsAny <byte>()), Times.Never); }
public int Execute(CpuState cpuState, IMemory memory) { // Addresses are relative to the beginning of the next instruction not // the beginning of this one, so we'll need to advance the program counter. cpuState.Pc += 2; if (ShouldBranch(cpuState, memory)) { var offset = memory[cpuState.Pc - 1]; ushort newPc; if ((offset & 0x80) != 0) { newPc = (ushort) (cpuState.Pc - (0x100 - offset)); } else { newPc = (ushort)(cpuState.Pc + offset); } int cycles = 3; if ((newPc & 0xFF00) != (cpuState.Pc & 0xFF00)) { // Extra cycle if the relative branch occurs to cross a page boundary ++cycles; } cpuState.Pc = newPc; return cycles; } return 2; }
public void Test_LD_HL_R8(byte opcode) { ushort hl = 0x1212; byte data = 0x12; var registerIndex = opcode & 0x07; var actualState = new CpuState(); actualState.Registers[registerIndex] = data; actualState.Registers.HL = hl; var expectedState = new CpuState(); expectedState.Registers[registerIndex] = data; expectedState.Registers.HL = hl; var memoryMock = new Mock <IRandomAccessMemory>(); var instruction = new LD_HL_R8(); instruction.Initialize(opcode); //act while (!instruction.IsFetchNecessary()) { instruction.ExecuteCycle(actualState, memoryMock.Object); } TestHelper.AssertCpuState(expectedState, actualState); memoryMock.Verify(m => m.WriteByte(hl, data), Times.Once); }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, Action<byte> write, ref int cycles) { cpuState.A = cpuState.PopStack(memory); cpuState.SetNegativeFlag(cpuState.A); cpuState.SetZeroFlag(cpuState.A); cycles = 4; }
private void StartFetch() { _state = new CpuFetch(_cpu); _currentState = CpuStates.Fetch; _opcodeBuilder.Clear(); _cycles.Reset(); }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, Action<byte> write, ref int cycles) { var breakSet = cpuState.IsFlagSet(CpuState.Flags.Break); cpuState.StatusRegister = cpuState.PopStack(memory); cpuState.StatusRegister |= 1 << 5; cpuState.SetFlag(CpuState.Flags.Break, breakSet); cycles = 4; }
protected virtual void OnInstructionPartCompleted(CpuState completedPart) { if (completedPart == null || !completedPart.IsComplete) { throw Errors.InstructionPartWasNotCompleted(); } }
public int Execute(CpuState cpuState, IMemory memory) { var ret = cpuState.Pc + 2; cpuState.PushStack((byte)((ret & 0xFF00) >> 8), memory); cpuState.PushStack((byte) (ret & 0xFF), memory); cpuState.Pc = memory.ReadShort(cpuState.Pc + 1); return 6; }
public void UpdateCpuState(CpuState state) { Registers.First(r => r.RegisterName == "PC").Value = state.PC; Registers.Find(r => r.RegisterName == "Stack").Value = state.Stack; for (int i = 0; i < 32; i++) { Registers.Find(r => r.RegisterName == $"R{i}").Value = state.Registers[i]; } }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, Action<byte> write, ref int cycles) { var comparer = cpuState.A; var cmp = comparer - arg; cpuState.SetFlag(CpuState.Flags.Carry, cmp >= 0); cpuState.SetNegativeFlag((byte) (cmp & 0xFF)); cpuState.SetZeroFlag((byte) (cmp & 0xFF)); }
public void PopState() { if (m_CpuStack.Count != 0) { CpuState state = m_CpuStack.Pop(); ProgramCounter = state.Pc; ProcessorFlags = state.Flags; } }
public int Execute(CpuState cpuState, IMemory memory) { var low = cpuState.PopStack(memory); var high = cpuState.PopStack(memory); cpuState.Pc = (ushort)((high << 8) | low); ++cpuState.Pc; return 6; }
public virtual int hleKernelPrintf(CpuState cpu, PspString formatString, Logger logger) { // Format and print the message to the logger if (logger.InfoEnabled) { string formattedMsg = hleKernelSprintf(cpu, formatString.String, _a1); logger.info(formattedMsg); } return(0); }
public void Save(CpuState state) { if (_lastFilePath == null) { SaveAs(state); } else { Save(state, _lastFilePath); } }
public static void append(CpuState cpu) { frames[position].make(cpu); if (size < capacity) { size++; } position = (position + 1) % capacity; }
public virtual string hleKernelSprintf(CpuState cpu, string format, object[] formatParameters) { string formattedMsg = format; try { // Translate the C-like format string to a Java format string: // - %u or %i -> %d // - %4u -> %4d // - %lld or %ld -> %d // - %llx or %lx -> %x // - %p -> %08X string javaMsg = format; javaMsg = javaMsg.replaceAll("\\%(\\d*)l?l?[uid]", "%$1d"); javaMsg = javaMsg.replaceAll("\\%(\\d*)l?l?([xX])", "%$1$2"); javaMsg = javaMsg.replaceAll("\\%p", "%08X"); // Support for "%s" (at any place and can occur multiple times) int index = -1; for (int parameterIndex = 0; parameterIndex < formatParameters.Length; parameterIndex++) { index = javaMsg.IndexOf('%', index + 1); if (index < 0) { break; } string parameterFormat = javaMsg.Substring(index); if (parameterFormat.StartsWith("%s", StringComparison.Ordinal)) { // Convert an integer address to a String by reading // the String at the given address int address = ((int?)formatParameters[parameterIndex]).Value; if (address == 0) { formatParameters[parameterIndex] = "(null)"; } else { formatParameters[parameterIndex] = Utilities.readStringZ(address); } } } // String.format: If there are more arguments than format specifiers, the extra arguments are ignored. formattedMsg = string.format(javaMsg, formatParameters); } catch (Exception) { // Ignore formatting exception } return(formattedMsg); }
public int Execute(CpuState cpuState, IMemory memory) { int cycles = 3; ushort dest = memory.ReadShort(cpuState.Pc + 1); if (Variants[memory[cpuState.Pc]] == AddressingMode.Indirect) { dest = memory.ReadShort(dest); cycles = 5; } cpuState.Pc = dest; return cycles; }
public int Execute(CpuState cpuState, IMemory memory) { var breakSet = cpuState.IsFlagSet(CpuState.Flags.Break); cpuState.StatusRegister = cpuState.PopStack(memory); cpuState.SetFlag(CpuState.Flags.Break, breakSet); cpuState.StatusRegister |= 1 << 5; var low = cpuState.PopStack(memory); var high = cpuState.PopStack(memory); cpuState.Pc = (ushort)((high << 8) | low); return 6; }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, Action<byte> write, ref int cycles) { var sum = (ushort) (arg + cpuState.A); if (cpuState.IsFlagSet(CpuState.Flags.Carry)) { ++sum; } var byteSum = (byte)(sum & 0xFF); cpuState.SetOverflow(cpuState.A, arg, byteSum); cpuState.A = byteSum; cpuState.SetZeroFlag(cpuState.A); cpuState.SetNegativeFlag(cpuState.A); cpuState.SetFlag(CpuState.Flags.Carry, sum & 0xFF00); }
public int Execute(CpuState cpuState, IMemory memory) { int cycles = 3; ushort dest = memory.ReadShort(cpuState.Pc + 1); if (Variants[memory[cpuState.Pc]] == AddressingMode.Indirect) { // Reading the address cannot page wrap var secondByte = (dest + 1) & 0xFF; secondByte |= dest & 0xFF00; dest = (ushort) (memory[dest] | (memory[secondByte] << 8)); cycles = 5; } cpuState.Pc = dest; return cycles; }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, Action<byte> write, ref int cycles) { // A - M - C -> A N Z C I D V // + + + - - + int a = cpuState.A; arg ^= 0xFF; a += arg; if (cpuState.IsFlagSet(CpuState.Flags.Carry)) { ++a; } var byteResult = (byte) (a & 0xFF); cpuState.SetOverflow(cpuState.A, arg, byteResult); cpuState.A = byteResult; cpuState.SetNegativeFlag(cpuState.A); cpuState.SetZeroFlag(cpuState.A); cpuState.SetFlag(CpuState.Flags.Carry, (byteResult & 0x80) == 0); }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, Action<byte> write, ref int cycles) { var res = (byte) ((arg - 1)&0xFF); write(res); cpuState.SetNegativeFlag(res); cpuState.SetZeroFlag(res); switch (Variants[memory[cpuState.Pc]]) { case AddressingMode.ZeroPage: cycles = 5; break; case AddressingMode.ZeroPageXIndexed: cycles = 6; break; case AddressingMode.Absolute: cycles = 6; break; case AddressingMode.AbsoluteX: cycles = 7; break; } }
public override void Do(CpuState state, ushort args) { state.ProgramCounter++; action(state, (byte)(args >> 8), (byte)(0xF & (args >> 4))); }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, Action<byte> write, ref int cycles) { cpuState.SetFlag(CpuState.Flags.DecimalMode, false); }
public static string Disassemble(this IInstruction instruction, byte[] args, IMemory memory, CpuState cpuState) { switch (instruction.Variants[args[0]]) { case AddressingMode.Accumulator: return string.Format("{0} A", instruction.Mnemonic); case AddressingMode.Absolute: if (instruction is JMP || instruction is JSR) { return string.Format("{0} ${1:X2}{2:X2}", instruction.Mnemonic, args[2], args[1]); } else { return string.Format("{0} ${1:X2}{2:X2} = {3:X2}", instruction.Mnemonic, args[2], args[1], memory[(args[2] << 8) | args[1]]); } case AddressingMode.AbsoluteX: { ushort addr = (ushort) ((args[2] << 8) | args[1]); addr += cpuState.X; return string.Format("{0} ${1:X2}{2:X2},X @ {3:X4} = {4:X2}", instruction.Mnemonic, args[2], args[1], addr, memory[addr]); } case AddressingMode.AbsoluteY: { ushort addr = (ushort) ((args[2] << 8) | args[1]); addr += cpuState.Y; return string.Format("{0} ${1:X2}{2:X2},Y @ {3:X4} = {4:X2}", instruction.Mnemonic, args[2], args[1], addr, memory[addr]); } case AddressingMode.Immediate: return string.Format("{0} #${1:X2}", instruction.Mnemonic, args[1]); case AddressingMode.Implied: return instruction.Mnemonic; case AddressingMode.Indirect: return string.Format("{0} (${1:X2}{2:X2}) = {3:X4}", instruction.Mnemonic, args[2], args[1], memory.ReadShort((args[2] << 8) | args[1])); case AddressingMode.XIndexedIndirect: { byte addr = (byte) (args[1] + cpuState.X); var finalAddr = memory.ReadZeroPageShort(addr); return string.Format("{0} (${1:X2},X) @ {2:X2} = {3:X4} = {4:X2}", instruction.Mnemonic, args[1], addr, finalAddr, memory[finalAddr]); } case AddressingMode.IndirectYIndexed: { ushort addr = memory.ReadZeroPageShort(args[1]); ushort finalAddr = (ushort) (addr + cpuState.Y); return string.Format("{0} (${1:X2}),Y = {2:X4} @ {3:X4} = {4:X2}", instruction.Mnemonic, args[1], addr, finalAddr, memory[finalAddr]); } case AddressingMode.Relative: { ushort newPc; if ((args[1] & 0x80) != 0) { newPc = (ushort)(cpuState.Pc - (0x100 - args[1])); } else { newPc = (ushort)(cpuState.Pc + args[1]); } return string.Format("{0} ${1:X4}", instruction.Mnemonic, newPc + 2); } case AddressingMode.ZeroPage: return string.Format("{0} ${1:X2} = {2:X2}", instruction.Mnemonic, args[1], memory[args[1]]); case AddressingMode.ZeroPageXIndexed: return string.Format("{0} ${1:X2},X", instruction.Mnemonic, args[1]); case AddressingMode.ZeroPageYIndexed: return string.Format("{0} ${1:X2},Y", instruction.Mnemonic, args[1]); default: throw new Exception("Disassembly for addressing mode is unimplemented"); } }
protected override bool ShouldBranch(CpuState cpuState, IMemory memory) { return !cpuState.IsFlagSet(CpuState.Flags.Zero); }
public override void Do(CpuState state, ushort args) { state.ProgramCounter = func(state, (FlowControlCondition)(args >> 10)); }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, ref int cycles) { cpuState.SetFlag(CpuState.Flags.InterruptDisable, true); }
protected abstract bool ShouldBranch(CpuState cpuState, IMemory memory);
public override void Do(CpuState state, ushort args) { state.ProgramCounter++; func(state, args != 0); }
protected override void InternalExecute(CpuState cpuState, IMemory memory, Action<byte> write, ref int cycles) { write(cpuState.Y); }
protected override bool ShouldBranch(CpuState cpuState, IMemory memory) { return cpuState.IsFlagSet(CpuState.Flags.Negative); }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, Action<byte> write, ref int cycles) { // NOP }
public override void Do(CpuState state, ushort args) { state.ProgramCounter++; action(state); }
protected override void InternalExecute(CpuState cpuState, IMemory memory, byte arg, Action<byte> write, ref int cycles) { cpuState.PushStack(cpuState.A, memory); cycles = 3; }