public void TestIMUL()
{
i8086CPU cpu = GetCPU(new byte[] { 0xf6, 0xeb }); /* IMUL BL */
cpu.EU.Registers.AL = 0xfe;
cpu.EU.Registers.BL = 0xfc;
cpu.NextInstruction();
Assert.AreEqual(0x08, cpu.EU.Registers.AX, "IMUL AX result failed");
cpu = GetCPU(new byte[] { 0xf6, 0xeb }); /* IMUL BL */
cpu.EU.Registers.AL = 48;
cpu.EU.Registers.BL = 4;
cpu.NextInstruction();
Assert.AreEqual(0xc0, cpu.EU.Registers.AX, "IMUL 2 AX result failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "IMUL 2 OF failed");
cpu = GetCPU(new byte[] { 0xf6, 0xeb }); /* IMUL BL */
cpu.EU.Registers.AL = 0xfc; // -4
cpu.EU.Registers.BL = 4;
cpu.NextInstruction();
Assert.AreEqual(0xfff0, cpu.EU.Registers.AX, "IMUL 3 AX result failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "IMUL 3 OF failed");
cpu = GetCPU(new byte[] { 0xf7, 0xeb }); /* IMUL BX */
cpu.EU.Registers.AX = 48;
cpu.EU.Registers.BX = 4;
cpu.NextInstructionDebug();
Assert.AreEqual(0x00, cpu.EU.Registers.DX, "IMUL 4 DX result failed");
Assert.AreEqual(0xc0, cpu.EU.Registers.AX, "IMUL 4 AX result failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "IMUL 4 OF failed");
}
public void Test88()
{
byte value8;
i8086CPU cpu = GetCPU(new byte[] { 0x88, 0x4f, 0x10 } /* MOV [bx+10],CL */);
value8 = 0x2f;
cpu.EU.Registers.CL = value8;
cpu.NextInstruction();
Assert.AreEqual(value8, cpu.Bus.GetData8(cpu.EU.Registers.BX + 0x10), "Instruction 0x88 failed");
cpu.Boot(new byte[] { 0x88, 0x8f, 0x10, 0x00 } /* MOV [bx+10],CL using 16 bit displacement */);
value8 = 0x2f;
cpu.EU.Registers.CL = value8;
cpu.NextInstruction();
Assert.AreEqual(value8, cpu.Bus.GetData8(cpu.EU.Registers.BX + 0x10), "Instruction 0x88 failed");
// Test with segment override
cpu.Boot(new byte[] { 0x26, 0x88, 0x8f, 0x10, 0x00 } /* MOV [bx+10],CL using 16 bit displacement with ES override */);
value8 = 0x2f;
cpu.EU.Registers.CL = value8;
// only need to call NextInstruction once because when there is a segment override the next instruction is always
// executed immediately. In a real system, interrupts are not allowed after a segment override.
cpu.NextInstruction();
// now set the override again so the correct memory segment is accessed
cpu.Bus.SegmentOverride = i8086BusInterfaceUnit.SegmentOverrideState.UseES;
Assert.AreEqual(value8, cpu.Bus.GetData8(cpu.EU.Registers.BX + 0x10), "Instruction 0x88 failed");
}
public void Test28()
{
// Test Flags
i8086CPU cpu = GetCPU(new byte[] { 0x28, 0xd8, /* SUB AL,BL */
0x28, 0xd1 /* SUB CL,DL */
});
cpu.EU.Registers.AL = 0x00;
cpu.EU.Registers.BL = 0x00;
cpu.NextInstruction();
Assert.AreEqual(0x00, cpu.EU.Registers.AL, "SUB (1) result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "SUB (1) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "SUB (1) parity flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ZeroFlag, "SUB (1) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "SUB (1) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "SUB (1) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "SUB (1) overflow flag failed");
cpu.EU.Registers.CL = 0x80;
cpu.EU.Registers.DL = 0x80;
cpu.NextInstruction();
Assert.AreEqual(0x00, cpu.EU.Registers.CL, "SUB (2) result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "SUB (2) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "SUB (2) parity flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ZeroFlag, "SUB (2) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "SUB (2) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "SUB (2) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "SUB (2) overflow flag failed");
}
public void Test_DAA()
{
i8086CPU cpu = GetCPU(new byte[] { 0x00, 0xd8, /* ADD AL,BL */
0x27 /* DAA */ });
cpu.EU.Registers.AL = 0x79;
cpu.EU.Registers.BL = 0x35;
cpu.NextInstruction();
Assert.AreEqual(0xae, cpu.EU.Registers.AL, "ADD result failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "ADD overflow flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.SignFlag, "ADD sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "ADD zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADD auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "ADD parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "ADD carry flag failed");
cpu.NextInstruction();
Assert.AreEqual(0x14, cpu.EU.Registers.AL, "DAA (1) result failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "DAA (1) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "DAA (1) zero flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.AuxCarryFlag, "DAA (1) auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "DAA (1) parity flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "DAA (1) carry flag failed");
}
public void TestINC()
{
// Test Flags
i8086CPU cpu = GetCPU(new byte[] { 0x40, 0x41, 0x42, 0x43 });
cpu.EU.Registers.AX = 0x000f;
cpu.NextInstruction();
Assert.AreEqual(0x0010, cpu.EU.Registers.AX, "INC (1) result failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "INC (1) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "INC (1) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "INC (1) sign flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.AuxCarryFlag, "INC (1) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "INC (1) overflow flag failed");
cpu.EU.Registers.CX = 0xff01;
cpu.NextInstruction();
Assert.AreEqual(0xff02, cpu.EU.Registers.CX, "INC (2) result failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "INC (2) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "INC (2) zero flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.SignFlag, "INC (2) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "INC (2) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "INC (2) overflow flag failed");
cpu.EU.Registers.DX = 0xffff;
cpu.NextInstruction();
Assert.AreEqual(0x0000, cpu.EU.Registers.DX, "INC (3) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "INC (3) parity flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ZeroFlag, "INC (3) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "INC (3) sign flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.AuxCarryFlag, "INC (3) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "INC (3) overflow flag failed");
}
public void TestDEC()
{
// Test Flags
i8086CPU cpu = GetCPU(new byte[] { 0x4c, 0x4d, 0x4e, 0x4f });
cpu.EU.Registers.SP = 0x000f;
cpu.NextInstruction();
Assert.AreEqual(0x000e, cpu.EU.Registers.SP, "DEC (1) result failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "DEC (1) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "DEC (1) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "DEC (1) sign flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.AuxCarryFlag, "DEC (1) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "DEC (1) overflow flag failed");
cpu.EU.Registers.BP = 0xff01;
cpu.NextInstruction();
Assert.AreEqual(0xff00, cpu.EU.Registers.BP, "DEC (2) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "DEC (2) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "DEC (2) zero flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.SignFlag, "DEC (2) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "DEC (2) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "DEC (2) overflow flag failed");
cpu.EU.Registers.SI = 0x0000;
cpu.NextInstruction();
Assert.AreEqual(0xffff, cpu.EU.Registers.SI, "DEC (3) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "DEC (3) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "DEC (3) zero flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.SignFlag, "DEC (3) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "DEC (3) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "DEC (3) overflow flag failed");
}
public void Test_POST_2()
{
// writes into each register
i8086CPU cpu = GetCPU(new byte[] {
0xb8, 0xff, 0xff, // mov ax,0xffff
0xf9, // stc
/* C8 */ 0x8e, 0xd8, // mov ds, ax
0x8c, 0xdb, // mov bx, ds
0x8e, 0xc3, // mov es, bx
0x8c, 0xc1,
0x8e, 0xd1,
0x8c, 0xd2,
0x8b, 0xe2,
0x8b, 0xec,
0x8b, 0xf5,
0x8b, 0xfe,
0x73, 0x07, // jnc c9
0x33, 0xc7,
0x75, 0x07, // jnz err
0xf8, // clc
0xeb, 0xe3, // jmp c8
/* C9 */ 0x0b, 0xc7,
0xf4 //hlt
});
cpu.Run();
Assert.AreEqual(true, cpu.EU.CondReg.ZeroFlag, "POST 2: zero flag failed");
}
public void TestIDIV()
{
i8086CPU cpu = GetCPU(new byte[] { 0xf6, 0xfb }); /* IDIV BL */
cpu.EU.Registers.AX = 0xffd0; // -48
cpu.EU.Registers.BL = 0x05; // 5
// result AL = -9, AH = -3
cpu.NextInstruction();
Assert.AreEqual(0xf7, cpu.EU.Registers.AL, "IDIV AL result failed");
Assert.AreEqual(0xfd, cpu.EU.Registers.AH, "IDIV AH result failed");
cpu = GetCPU(new byte[] { 0xf6, 0xfb }); /* IDIV BL */
cpu.EU.Registers.AX = 0xff35; // -203
cpu.EU.Registers.BL = 0x04; // 4
cpu.NextInstruction();
//AL = -50, AH = -3
Assert.AreEqual(0xce, cpu.EU.Registers.AL, "IDIV 2 AL result failed");
Assert.AreEqual(0xfd, cpu.EU.Registers.AH, "IDIV 2 AH result failed");
cpu = GetCPU(new byte[] { 0xf7, 0xfb }); /* IDIV BX */
cpu.EU.Registers.DX = 0xffff; // sign extend AX
cpu.EU.Registers.AX = 0xec78; // -5000
cpu.EU.Registers.BX = 256;
cpu.NextInstructionDebug();
// AX = -19, DX = -136
Assert.AreEqual(0xffed, cpu.EU.Registers.AX, "IDIV 3 AX result failed");
Assert.AreEqual(0xff78, cpu.EU.Registers.DX, "IDIV 3 DX result failed");
}
public void Test_CBW()
{
i8086CPU cpu = GetCPU(new byte[] { 0x98 });
cpu.EU.Registers.AX = 0x00fb;
cpu.NextInstruction();
Assert.AreEqual(0xfffb, cpu.EU.Registers.AX, "CBW result failed");
}
public void Testa0()
{
i8086CPU cpu = GetCPU(new byte[] { 0xa0, 0x23, 0x98 });
cpu.Bus.SaveData8(0x9823, 0x65);
cpu.NextInstruction();
Assert.AreEqual(0x65, cpu.EU.Registers.AL, "Instruction a0 failed");
}
public void Testa1()
{
i8086CPU cpu = GetCPU(new byte[] { 0xa1, 0x23, 0x98 });
cpu.Bus.SaveData16(0x9823, 0x65fe);
cpu.NextInstruction();
Assert.AreEqual(0x65fe, cpu.EU.Registers.AX, "Instruction a1 failed");
}
public void Testa2()
{
i8086CPU cpu = GetCPU(new byte[] { 0xa2, 0x23, 0x98 });
cpu.EU.Registers.AL = 0xc4;
cpu.NextInstruction();
Assert.AreEqual(0xc4, cpu.Bus.GetData8(0x9823), "Instruction a2 failed");
}
public void Testa3()
{
i8086CPU cpu = GetCPU(new byte[] { 0xa3, 0x23, 0x98 });
cpu.EU.Registers.AX = 0xc42f;
cpu.NextInstruction();
Assert.AreEqual(0xc42f, cpu.Bus.GetData16(0x9823), "Instruction a3 failed");
}
public void Test89()
{
i8086CPU cpu = GetCPU(new byte[] { 0x89, 0xd8, 0x10 } /* MOV ax,bx */);
cpu.EU.Registers.AX = 0x11ab;
cpu.EU.Registers.BX = 0x22fe;
cpu.NextInstruction();
Assert.AreEqual(0x22fe, cpu.EU.Registers.AX, "Instruction 0x89 failed");
}
private i8086CPU GetCPU(byte[] program)
{
i8086CPU cpu = new i8086CPU();
cpu.Boot(program);
cpu.Bus.DS = 0x2000;
cpu.Bus.SS = 0x4000;
cpu.Bus.ES = 0x6000;
return(cpu);
}
public void Test_SHR()
{
i8086CPU cpu = GetCPU(new byte[] { 0xd0, 0xe8 });/* SHR AL,1 */
cpu.EU.Registers.AL = 0x07;
cpu.NextInstruction();
Assert.AreEqual(0x03, cpu.EU.Registers.AL, "SHR result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "SHR CF failed");
}
public void Test8b()
{
i8086CPU cpu = GetCPU(new byte[] { 0x8b, 0xc8 } /* MOV cx,ax (16 bit) */);
cpu.EU.Registers.AX = 0x11ab;
cpu.EU.Registers.CX = 0x22fe;
cpu.NextInstruction();
Assert.AreEqual(0x11ab, cpu.EU.Registers.CX, "Instruction 0x8b failed");
}
public void Test_ROR()
{
i8086CPU cpu = GetCPU(new byte[] { 0xd0, 0xc8 });/* ROR AL,1 */
cpu.EU.Registers.AL = 0x1c;
cpu.NextInstruction();
Assert.AreEqual(0x0e, cpu.EU.Registers.AL, "ROR result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "ROR CF failed");
}
public void Test_SAL()
{
i8086CPU cpu = GetCPU(new byte[] { 0xd0, 0xe0 });/* SAL AL,1 */
cpu.EU.Registers.AL = 0xe0;
cpu.NextInstruction();
Assert.AreEqual(0xc0, cpu.EU.Registers.AL, "SAL result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "SAL CF failed");
}
public void Test_POST_1()
{
i8086CPU cpu = GetCPU(new byte[] {
// Test 1
0xb4, 0xd5, /* MOV AH, 0xD5 */
0x9e, /* SAHF */
// Test 2
0x9f, /* LAHF */
0xb1, 0x05, /* MOV CL,5 */
0xd2, 0xec, /* SHR AH, CL */
// Test 3
0xb0, 0x40, /* MOV AL, 40 */
0xd0, 0xe0, /* SHL AL, 1*/
// Test 4
0x32, 0xe4, /* XOR ah, ah */
0x9e, /* SAHF */
// Test 5
0x9f, /* LAHF */
0xb1, 0x05, /* MOV CL,5 */
0xd2, 0xec, /* SHL AH,CL */
// Test 6
0xd0, 0xe4 /* SHL AH,1 */
});
cpu.NextInstruction();
cpu.NextInstruction();
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "POST 1: parity flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ZeroFlag, "POST 1: zero flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.SignFlag, "POST 1: sign flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "POST 1: carry flag failed");
cpu.NextInstruction();
cpu.NextInstruction();
cpu.NextInstruction();
Assert.AreEqual(true, cpu.EU.CondReg.AuxCarryFlag, "POST 2: aux carry flag failed");
cpu.NextInstruction();
cpu.NextInstruction();
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "POST 3: overflow flag failed");
cpu.NextInstruction();
cpu.NextInstruction();
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "POST 4: parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "POST 4: zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "POST 4: sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "POST 4: carry flag failed");
cpu.NextInstruction();
cpu.NextInstruction();
cpu.NextInstruction();
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "POST 5: carry flag failed");
cpu.NextInstruction();
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "POST 6: overflow flag failed");
}
public void Test_RCL()
{
i8086CPU cpu = GetCPU(new byte[] { 0xd0, 0xd0 });/* RCL AL,1 */
cpu.EU.CondReg.CarryFlag = true;
cpu.EU.Registers.AL = 0x1c;
cpu.NextInstruction();
Assert.AreEqual(0x39, cpu.EU.Registers.AL, "RCL result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "RCL CF failed");
}
public void Test8c()
{
i8086CPU cpu = GetCPU(new byte[] { 0x8c, 0x5f, 0x35 } /* MOV bx+35, ds (16 bit) */);
cpu.Bus.DS = 0x76d2;
cpu.EU.Registers.BX = 0x1015;
cpu.NextInstruction();
Assert.AreEqual(0x76d2, cpu.Bus.GetData16(cpu.EU.Registers.BX + 0x35), "Instruction 0x8c failed");
}
public void Test_AAS()
{
i8086CPU cpu = GetCPU(new byte[] { 0x3f });
cpu.EU.Registers.AX = 0x2ff;
cpu.NextInstruction();
Assert.AreEqual(0x01, cpu.EU.Registers.AH, "AAA AH result failed");
Assert.AreEqual(0x09, cpu.EU.Registers.AL, "AAA AL result failed");
Assert.AreEqual(true, cpu.EU.CondReg.AuxCarryFlag, "AAA auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "AAA carry flag failed");
}
public void Test2a()
{
// Test Flags
i8086CPU cpu = GetCPU(new byte[] { 0x02, 0xd8, /* SUB BL,AL */
0x02, 0xd1, /* SUB DL,CL */
0x02, 0xe7, /* SUB AH,BH */
0x02, 0x36, 0x15, 0x01 /* SUB DH,[0115] */
});
cpu.EU.Registers.AL = 0xf7;
cpu.EU.Registers.BL = 0x28; // F7+28=11F. Carry=1, Parity=0, Zero=0, Sign=0, AuxCarry=0, Overflow=0
cpu.NextInstruction();
Assert.AreEqual(0x1f, cpu.EU.Registers.BL, "SUB (1) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "SUB (1) carry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "SUB (1) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "SUB (1) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "SUB (1) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "SUB (1) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "SUB (1) overflow flag failed");
cpu.EU.Registers.CL = 0x80;
cpu.EU.Registers.DL = 0x80; // 80+80=100. Carry=1, Parity=1, Zero=1, Sign=0, AuxCarry=0, Overflow=1
cpu.NextInstruction();
Assert.AreEqual(0x00, cpu.EU.Registers.DL, "SUB (2) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "SUB (2) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "SUB (2) parity flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ZeroFlag, "SUB (2) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "SUB (2) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "SUB (2) auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "SUB (2) overflow flag failed");
cpu.EU.Registers.BH = 0x40;
cpu.EU.Registers.AH = 0x40; // 40+40=80. Carry=0, Parity=0, Zero=0, Sign=1, AuxCarry=0, Overflow=1
cpu.NextInstruction();
Assert.AreEqual(0x80, cpu.EU.Registers.AH, "SUB (3) result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "SUB (3) carry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "SUB (3) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "SUB (3) zero flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.SignFlag, "SUB (3) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "SUB (3) auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "SUB (3) overflow flag failed");
cpu.EU.Registers.DH = 0xff;
cpu.Bus.SaveData8(0x0115, 0x01); // ff+01=100. Carry=1, Parity=1, Zero=1, Sign=0, AuxCarry=0, Overflow=0
cpu.NextInstruction();
Assert.AreEqual(0x00, cpu.EU.Registers.DH, "SUB (4) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "SUB (4) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "SUB (4) parity flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ZeroFlag, "SUB (4) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "SUB (4) sign flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.AuxCarryFlag, "SUB (4) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "SUB (4) overflow flag failed");
}
public void Test2b()
{
// Test Flags
i8086CPU cpu = GetCPU(new byte[] { 0x03, 0xd8, /* SUB BX,AX */
0x03, 0xd1, /* SUB DX,CX */
0x03, 0xe7, /* SUB SP,DI */
0x03, 0x36, 0x15, 0x01 /* SUB SI,[0115] */
});
cpu.EU.Registers.AX = 0xf700;
cpu.EU.Registers.BX = 0x2800; // F700+2800=11F00. Carry=1, Parity=0, Zero=0, Sign=0, AuxCarry=0, Overflow=0
cpu.NextInstruction();
Assert.AreEqual(0x1f00, cpu.EU.Registers.BX, "SUB (1) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "SUB (1) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "SUB (1) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "SUB (1) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "SUB (1) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "SUB (1) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "SUB (1) overflow flag failed");
cpu.EU.Registers.CX = 0x8000;
cpu.EU.Registers.DX = 0x8000; // 80+80=10000. Carry=1, Parity=1, Zero=1, Sign=0, AuxCarry=0, Overflow=1
cpu.NextInstruction();
Assert.AreEqual(0x00, cpu.EU.Registers.DX, "SUB (2) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "SUB (2) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "SUB (2) parity flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ZeroFlag, "SUB (2) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "SUB (2) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "SUB (2) auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "SUB (2) overflow flag failed");
cpu.EU.Registers.DI = 0x4000;
cpu.EU.Registers.SP = 0x4000; // 4000+4000=8000. Carry=0, Parity=0, Zero=0, Sign=1, AuxCarry=0, Overflow=1
cpu.NextInstruction();
Assert.AreEqual(0x8000, cpu.EU.Registers.SP, "SUB (3) result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "SUB (3) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "SUB (3) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "SUB (3) zero flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.SignFlag, "SUB (3) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "SUB (3) auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "SUB (3) overflow flag failed");
cpu.EU.Registers.SI = 0xff00;
cpu.Bus.SaveData16(0x0115, 0x0100); // ff00+0100=10000. Carry=1, Parity=1, Zero=1, Sign=0, AuxCarry=0, Overflow=0
cpu.NextInstruction();
Assert.AreEqual(0x0000, cpu.EU.Registers.SI, "SUB (4) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "SUB (4) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "SUB (4) parity flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ZeroFlag, "SUB (4) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "SUB (4) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "SUB (4) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "SUB (4) overflow flag failed");
}
public void Test10()
{
// Test Flags
i8086CPU cpu = GetCPU(new byte[] { 0x10, 0xd8, /* ADC AL,BL */
0x10, 0xd1, /* ADC CL,DL */
0x10, 0xe7, /* ADC BH,AH */
0x10, 0x36, 0x15, 0x01 /* ADC [0115],DH */
});
cpu.EU.Registers.AL = 0xf7;
cpu.EU.Registers.BL = 0x28; // F7+28=11F. Carry=1, Parity=0, Zero=0, Sign=0, AuxCarry=0, Overflow=0
cpu.NextInstruction();
Assert.AreEqual(0x1f, cpu.EU.Registers.AL, "ADC (1) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "ADC (1) carry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "ADC (1) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "ADC (1) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "ADC (1) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADC (1) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "ADC (1) overflow flag failed");
cpu.EU.Registers.CL = 0x80;
cpu.EU.Registers.DL = 0x80; // 80+80+1=101. Carry=1, Parity=0, Zero=0, Sign=0, AuxCarry=0, Overflow=1
cpu.NextInstruction();
Assert.AreEqual(0x01, cpu.EU.Registers.CL, "ADC (2) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "ADC (2) carry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "ADC (2) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "ADC (2) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "ADC (2) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADC (2) auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "ADC (2) overflow flag failed");
cpu.EU.Registers.BH = 0x40;
cpu.EU.Registers.AH = 0x40; // 40+40+1=81. Carry=0, Parity=1, Zero=0, Sign=1, AuxCarry=0, Overflow=1
cpu.NextInstruction();
Assert.AreEqual(0x81, cpu.EU.Registers.BH, "ADC (3) result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "ADC (3) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "ADC (3) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "ADC (3) zero flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.SignFlag, "ADC (3) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADC (3) auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "ADC (3) overflow flag failed");
cpu.EU.Registers.DH = 0xff;
cpu.Bus.SaveData8(0x0115, 0x01); // ff+01=100. Carry=1, Parity=1, Zero=1, Sign=0, AuxCarry=0, Overflow=0
cpu.NextInstruction();
Assert.AreEqual(0x00, cpu.Bus.GetData8(0x0115), "ADC (4) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "ADC (4) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "ADC (4) parity flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ZeroFlag, "ADC (4) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "ADC (4) sign flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.AuxCarryFlag, "ADC (4) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "ADC (4) overflow flag failed");
}
public void Test8e()
{
i8086CPU cpu = GetCPU(new byte[] { 0x8e, 0x45, 0x35 } /* MOV es, di+35 (16 bit) */);
cpu.Bus.ES = 0xffff;
cpu.EU.Registers.DI = 0x1015;
cpu.Bus.SaveData16(cpu.EU.Registers.DI + 0x35, 0x9f23);
cpu.NextInstruction();
Assert.AreEqual(0x9f23, cpu.Bus.ES, "Instruction 0x8e failed");
}
public void Test11()
{
// Test Flags
i8086CPU cpu = GetCPU(new byte[] { 0x11, 0xd8, /* ADC AX,BX */
0x11, 0xd1, /* ADC CX,DD */
0x11, 0xe7, /* ADC DI,SP */
0x11, 0x36, 0x15, 0x01 /* ADC [0115],SI */
});
cpu.EU.Registers.AX = 0xf700;
cpu.EU.Registers.BX = 0x2800; // F700+2800=11F00. Carry=1, Parity=0, Zero=0, Sign=0, AuxCarry=0, Overflow=0
cpu.NextInstruction();
Assert.AreEqual(0x1f00, cpu.EU.Registers.AX, "ADC (1) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "ADC (1) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "ADC (1) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "ADC (1) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "ADC (1) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADC (1) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "ADC (1) overflow flag failed");
cpu.EU.Registers.CX = 0x8000;
cpu.EU.Registers.DX = 0x8000; // 8000+8000+1=10001. Carry=1, Parity=0, Zero=0, Sign=0, AuxCarry=0, Overflow=1
cpu.NextInstruction();
Assert.AreEqual(0x01, cpu.EU.Registers.CX, "ADC (2) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "ADC (2) carry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "ADC (2) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "ADC (2) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "ADC (2) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADC (2) auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "ADC (2) overflow flag failed");
cpu.EU.Registers.DI = 0x4000;
cpu.EU.Registers.SP = 0x4000; // 4000+4000+1=8001. Carry=0, Parity=0, Zero=0, Sign=1, AuxCarry=0, Overflow=1
cpu.NextInstruction();
Assert.AreEqual(0x8001, cpu.EU.Registers.DI, "ADC (3) result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "ADC (3) carry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "ADC (3) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "ADC (3) zero flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.SignFlag, "ADC (3) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADC (3) auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "ADC (3) overflow flag failed");
cpu.EU.Registers.SI = 0xff00;
cpu.Bus.SaveData16(0x0115, 0x0100); // ff00+0100=10000. Carry=1, Parity=1, Zero=1, Sign=0, AuxCarry=0, Overflow=0
cpu.NextInstruction();
Assert.AreEqual(0x0000, cpu.Bus.GetData16(0x0115), "ADC (4) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "ADC (4) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "ADC (4) parity flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ZeroFlag, "ADC (4) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "ADC (4) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADC (4) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "ADC (4) overflow flag failed");
}
/*
* To make a full 8086 computer the following is needed:
* - XT BIOS
* - Intel 8253 timer
* - Intel 8259 interrupt controller
* - video driver
*
* optional
* - mouse
* - Intel 8237 DMA controller (for soundblaster emulation)
* - network
*/
static void Main(string[] args)
{
//DisassembleThings();
Console.SetWindowSize(100, 50);
cpu = new i8086CPU();
// laptop
//cpu.Boot(FileLoader.LoadFile("C:\\Users\\menschas\\Source\\e8086\\Resources\\codegolf.bin"));
// desktop
//cpu.Boot(FileLoader.LoadFile("C:\\Users\\adam\\Documents\\My Projects\\e8086\\Resources\\codegolf.bin"));
//cpu.EU.Registers.SP = 0x100;
// Addition overflow test from http://www.c-jump.com/CIS77/ASM/Flags/lecture.html
//cpu.Boot(new byte[] {
// 0xc6, 0x06, 0x00, 0x10, 0x27,
// 0xc6, 0xc0, 0x1a,
// 0x40,
// 0x80, 0xc0, 0x4c,
// 0x02, 0x06, 0x00, 0x10,
// 0x88, 0xc4,
// 0x00, 0xe0
//});
// Subtraction overflow test from http://www.c-jump.com/CIS77/ASM/Flags/lecture.html
//cpu.Boot(new byte[] {
// 0xc6, 0xc0, 0x5f,
// 0x48,
// 0x80, 0xe8, 0x17,
// 0xc6, 0x06, 0x00, 0x10, 0x7a,
// 0x2a, 0x06, 0x00, 0x10,
// //0xb4, 0x77,
// 0xc6, 0xc4, 0x77,
// 0x28, 0xe0
//});
do
{
Console.Clear();
DisplayDebug();
//DisplayVRAM();
DisplayMenu();
} while (!exit);
//StreamWriter sw = new StreamWriter("C:\\Users\\menschas\\Source\\e8086\\Resources\\codegolf_stats.txt");
//sw.WriteLine(string.Format("Total Instructions Executed: {0}", cpu.EU.Stats.InstructionCount));
//sw.WriteLine();
//sw.WriteLine("Count per op code:");
//sw.Write(cpu.EU.Stats.GetOpReport());
//sw.Close();
}
public void Test_AAM()
{
i8086CPU cpu = GetCPU(new byte[] { 0xd4 });
cpu.EU.Registers.AL = 0x0f;
cpu.NextInstruction();
Assert.AreEqual(0x01, cpu.EU.Registers.AH, "AAM AH result failed");
Assert.AreEqual(0x05, cpu.EU.Registers.AL, "AAM AL result failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "AAM sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "AAM zero flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "AAM parity flag failed");
}
