public void CheckAddD0ToD1()
{
// ADD Dn,<ea>
// 1101 dddD ssmm mxxx
// 1101 0010 0000 0000 0xD200
// ADD.B D0,D1
byte[] data = new byte[]
{
0xD2, 0x00
};
MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF);
state.WriteDReg(0x0, 0x22221111);
state.WriteDReg(0x1, 0x33332222);
state.FetchOpCode();
var opcode = new ADD(state);
Assert.That(opcode.Assembly, Is.EqualTo("ADD.B D0,D1"));
Assert.That(state.PC, Is.EqualTo(0x02));
Assert.That(state.ReadDReg(0x0), Is.EqualTo(0x22221111));
Assert.That(state.ReadDReg(0x1), Is.EqualTo(0x00000033));
}
public void CheckAddD1To_A0i_()
{
// ADD Dn,<ea>
// 1101 dddD ssmm mxxx
// 1101 0011 0001 1000 0xD318
// ADD D1,(A0)+
byte[] data = new byte[]
{
0xD3, 0x18
};
MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF);
state.WriteDReg(0x1, 0x22221111);
state.WriteAReg(0x0, 0x00FF0000);
state.WriteByte(0x00FF0000, 0x22);
state.FetchOpCode();
var opcode = new ADD(state);
Assert.That(opcode.Assembly, Is.EqualTo("ADD.B D1,(A0)+"));
Assert.That(state.PC, Is.EqualTo(0x02));
Assert.That(state.ReadAReg(0x0), Is.EqualTo(0x00FF0001));
Assert.That(state.ReadDReg(0x1), Is.EqualTo(0x22221111));
Assert.That(state.ReadByte(0x00FF0000), Is.EqualTo(0x33));
}
public void CheckAnd_Ani_()
{
// ANDI #<data>,<ea>
// 0000 0010 0001 1001 0x0219
// 0000 0000 0000 0101 0x000A
// ANDI #10,(A1)
byte[] data = new byte[]
{
0x02, 0x19, 0x00, 0x0A
};
MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF);
state.WriteAReg(0x1, 0x00FF0000);
state.WriteByte(0x00FF0000, 0xFF);
state.WriteByte(0x00FF0002, 0xAA);
state.WriteDReg(0x1, 0xFF);
state.FetchOpCode();
var opcode = new ANDI(state);
Assert.That(opcode.Assembly, Is.EqualTo("ANDI #10,(A1)+"));
Assert.That(state.PC, Is.EqualTo(0x04));
Assert.That(state.ReadAReg(0x1), Is.EqualTo(0x00FF0001));
Assert.That(state.ReadByte(0x00FF0000), Is.EqualTo(0x0000000A));
}
public void CheckAddD1ToD0()
{
// ADD Dn,<ea>
// 1101 dddD ssmm mxxx
// 1101 0011 0000 0000 0xD300
// ADD D1,D0
byte[] data = new byte[]
{
0xD3, 0x00
};
MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF);
state.WriteDReg(0x0, 0x22221111);
state.WriteDReg(0x1, 0x33332222);
state.FetchOpCode();
Assert.Throws <InvalidOpCodeException>(() => new ADD(state));
}
public void CheckLoadD0ToA1()
{
// LEA <ea>,An
// 0100 0011 1100 0000 0x43C0
// LEA D0,A1
byte[] data = new byte[]
{
0x43, 0xC0
};
MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF);
state.WriteDReg(0x0, 0xAABBCCDD);
state.FetchOpCode();
Assert.Throws <InvalidOpCodeException>(() => new LEA(state));
}
public void CheckAndAn()
{
// ANDI #<data>,<ea>
// 0000 0010 0000 1001 0x0209
// 0000 0000 0000 0101 0x000A
// ANDI #10,A1
byte[] data = new byte[]
{
0x02, 0x09, 0x00, 0x0A
};
MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF);
state.WriteDReg(0x1, 0xFF);
state.FetchOpCode();
Assert.Throws <InvalidOpCodeException>(() => new ANDI(state));
}
public void CheckMoveD0ToD1()
{
// MOVE <ea>,<ea>
// 0001 0010 0000 0000 0x1200
// MOVE D0,D1
byte[] data = new byte[]
{
0x12, 0x00
};
MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF);
state.WriteDReg(0x0, 0xAABBCCDD);
state.FetchOpCode();
var opcode = new MOVE(state);
Assert.That(opcode.Assembly, Is.EqualTo("MOVE.b D0,D1"));
Assert.That(state.PC, Is.EqualTo(0x02));
Assert.That(state.ReadDReg(0x1), Is.EqualTo(0x000000DD));
}
public void CheckMoveD0ToA1()
{
// 00ss aaa0 01mm mxxx
// 0001 0010 0100 0000 0x1240
// MOVEM <ea>,An
// MOVEM D0,A1
byte[] data = new byte[]
{
0x12, 0x40
};
MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF);
state.WriteDReg(0x0, 0xAABBCCDD);
state.FetchOpCode();
var opcode = new MOVEA(state);
Assert.That(opcode.Assembly, Is.EqualTo($"MOVEA D0,A1"));
Assert.That(opcode.Size, Is.EqualTo(Size.Word));
Assert.That(state.ReadAReg(0x1), Is.EqualTo(0xCCDD));
}
public void CheckAndDn()
{
// ANDI #<data>,<ea>
// 0000 0010 0000 0001 0x0201
// 0000 0000 0000 0101 0x000A
// ANDI #10,D1
byte[] data = new byte[]
{
0x02, 0x01, 0x00, 0x0A
};
MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF);
state.WriteDReg(0x1, 0xFF);
state.FetchOpCode();
var opcode = new ANDI(state);
Assert.That(opcode.Assembly, Is.EqualTo("ANDI #10,D1"));
Assert.That(state.PC, Is.EqualTo(0x04));
Assert.That(state.ReadDReg(0x1), Is.EqualTo(0x0000000A));
}
/// <summary>
/// Initializes a new instance of the <see cref="MOVEM"/> class.
/// </summary>
/// <param name="state">machine state.</param>
public MOVEM(MegadriveState state)
: base("01001D001smmmxxx", state)
{
this.mask = state.ReadWord(state.PC);
state.PC += 2;
this.EffectiveAddress = this.FetchEffectiveAddress();
// TODO: should the increment only include values that are beingset?
switch (this.Size)
{
case Size.Word:
switch (this.GetDirection())
{
case MoveDirection.MemoryToRegister:
ushort maskCheck = 1;
int count = 0;
for (int i = 0; i < 8; i++)
{
uint d = state.ReadWord((uint)(this.EffectiveAddress + (count * 2)));
if ((this.mask & maskCheck) == maskCheck)
{
state.WriteDReg((byte)i, d);
count++;
}
maskCheck += maskCheck;
}
for (int i = 0; i < 8; i++)
{
uint d = state.ReadWord((uint)(this.EffectiveAddress + (count * 2)));
if ((this.mask & maskCheck) == maskCheck)
{
state.WriteAReg((byte)i, d);
count++;
}
maskCheck += maskCheck;
}
this.WriteValueToEffectiveAddress(this.DecodeEffectiveAddressMode(), this.GetXn(), (uint)(this.EffectiveAddress + (count * 2)));
break;
case MoveDirection.RegisterToMemory:
throw new System.NotImplementedException();
default:
throw new InvalidStateException();
}
break;
case Size.Long:
switch (this.GetDirection())
{
case MoveDirection.MemoryToRegister:
ushort maskCheck = 1;
int count = 0;
for (int i = 0; i < 8; i++)
{
uint d = state.ReadLong((uint)(this.EffectiveAddress + (count * 4)));
if ((this.mask & maskCheck) == maskCheck)
{
state.WriteDReg((byte)i, d);
count++;
}
maskCheck += maskCheck;
}
for (int i = 0; i < 8; i++)
{
uint d = state.ReadLong((uint)(this.EffectiveAddress + (count * 4)));
if ((this.mask & maskCheck) == maskCheck)
{
state.WriteAReg((byte)i, d);
count++;
}
maskCheck += maskCheck;
}
this.WriteValueToEffectiveAddress(this.DecodeEffectiveAddressMode(), this.GetXn(), (uint)(this.EffectiveAddress + (count * 4)));
break;
case MoveDirection.RegisterToMemory:
throw new System.NotImplementedException();
default:
throw new InvalidStateException();
}
break;
default:
throw new InvalidStateException();
}
}