Ejemplo n.º 1
0
UINT32 am2PCDoubleDisplacement32(void)
{
	amFlag = 0;
	amOut = MemRead32(PC + OpRead32(modAdd+1)) + OpRead32(modAdd+5);

	return 9;
}
Ejemplo n.º 2
0
UINT32 am2PCDoubleDisplacement8(void)
{
	amFlag = 0;
	amOut = MemRead32(PC + (INT8)OpRead8(modAdd+1)) + (INT8)OpRead8(modAdd+2);

	return 3;
}
Ejemplo n.º 3
0
UINT32 am2PCDoubleDisplacement16(void)
{
	amFlag = 0;
	amOut = MemRead32(PC + (INT16)OpRead16(modAdd+1)) + (INT16)OpRead16(modAdd+3);

	return 5;
}
Ejemplo n.º 4
0
UINT32 am2DoubleDisplacement16(void)
{
	amFlag = 0;
	amOut = MemRead32(v60.reg[modVal&0x1F] + (INT16)OpRead16(modAdd+1)) + (INT16)OpRead16(modAdd+3);

	return 5;
}
Ejemplo n.º 5
0
UINT32 am2DoubleDisplacement32(void)
{
	amFlag = 0;
	amOut = MemRead32(v60.reg[modVal&0x1F] + OpRead32(modAdd+1)) + OpRead32(modAdd+5);

	return 9;
}
Ejemplo n.º 6
0
UINT32 am2PCDisplacementIndirect32(void)
{
	amFlag = 0;
	amOut = MemRead32(PC + OpRead32(modAdd+1));

	return 5;
}
Ejemplo n.º 7
0
UINT32 am2DoubleDisplacement8(void)
{
	amFlag = 0;
	amOut = MemRead32(v60.reg[modVal&0x1F] + (INT8)OpRead8(modAdd+1)) + (INT8)OpRead8(modAdd+2);

	return 3;
}
Ejemplo n.º 8
0
UINT32 am2PCDisplacementIndirect16(void)
{
	amFlag = 0;
	amOut = MemRead32(PC + (INT16)OpRead16(modAdd+1));

	return 3;
}
Ejemplo n.º 9
0
UINT32 am2PCDisplacementIndirect8(void)
{
	amFlag = 0;
	amOut = MemRead32(PC + (INT8)OpRead8(modAdd+1));

	return 2;
}
Ejemplo n.º 10
0
UINT32 am2DisplacementIndirect32(void)
{
	amFlag = 0;
	amOut = MemRead32(v60.reg[modVal&0x1F] + OpRead32(modAdd+1));

	return 5;
}
Ejemplo n.º 11
0
UINT32 am2DirectAddressDeferred(void)
{
	amFlag = 0;
	amOut = MemRead32(OpRead32(modAdd+1));

	return 5;
}
Ejemplo n.º 12
0
UINT32 am2DisplacementIndirect8(void)
{
	amFlag = 0;
	amOut = MemRead32(v60.reg[modVal&0x1F] + (INT8)OpRead8(modAdd+1));

	return 2;
}
Ejemplo n.º 13
0
UINT32 opPOPM(void)
{
	int i;

	modAdd=PC+1;
	modDim=2;

	/* Read the bit register list */
	amLength1=ReadAM();

	for (i=0;i<31;i++)
		if (amOut & (1<<i))
		{
			v60.reg[i] = MemRead32(SP);
			SP += 4;
		}

	if (amOut & (1<<31))
	{
		v60WritePSW((v60ReadPSW() & 0xffff0000) | MemRead16(SP));
		SP += 4;
	}

	return amLength1 + 1;
}
Ejemplo n.º 14
0
UINT32 bam2DisplacementIndirect16(void)
{
	amFlag = 0;
	amOut = MemRead32(v60.reg[modVal&0x1F] + (INT16)OpRead16(modAdd+1));
	bamOffset = 0;
	return 3;
}
Ejemplo n.º 15
0
static UINT32 am3DoubleDisplacement8(void)
{
	switch (modDim)
	{
	case 0:
		MemWrite8(MemRead32(v60.reg[modVal&0x1F] + (INT8)OpRead8(modAdd+1)) + (INT8)OpRead8(modAdd+2), modWriteValB);
		break;
	case 1:
		MemWrite16(MemRead32(v60.reg[modVal&0x1F] + (INT8)OpRead8(modAdd+1)) + (INT8)OpRead8(modAdd+2), modWriteValH);
		break;
	case 2:
		MemWrite32(MemRead32(v60.reg[modVal&0x1F] + (INT8)OpRead8(modAdd+1)) + (INT8)OpRead8(modAdd+2), modWriteValW);
		break;
	}

	return 3;
}
Ejemplo n.º 16
0
static UINT32 am3PCDisplacementIndirectIndexed32(void)
{
	switch (modDim)
	{
	case 0:
		MemWrite8(MemRead32(PC + OpRead32(modAdd+2)) + v60.reg[modVal&0x1F], modWriteValB);
		break;
	case 1:
		MemWrite16(MemRead32(PC + OpRead32(modAdd+2)) + v60.reg[modVal&0x1F] * 2, modWriteValH);
		break;
	case 2:
		MemWrite32(MemRead32(PC + OpRead32(modAdd+2)) + v60.reg[modVal&0x1F] * 4, modWriteValW);
		break;
	}

	return 6;
}
Ejemplo n.º 17
0
static UINT32 am3PCDisplacementIndirect8(void)
{
	switch (modDim)
	{
	case 0:
		MemWrite8(MemRead32(PC + (INT8)OpRead8(modAdd+1)), modWriteValB);
		break;
	case 1:
		MemWrite16(MemRead32(PC + (INT8)OpRead8(modAdd+1)), modWriteValH);
		break;
	case 2:
		MemWrite32(MemRead32(PC + (INT8)OpRead8(modAdd+1)), modWriteValW);
		break;
	}

	return 2;
}
Ejemplo n.º 18
0
static UINT32 am3DisplacementIndirect32(void)
{
	switch (modDim)
	{
	case 0:
		MemWrite8(MemRead32(v60.reg[modVal&0x1F] + OpRead32(modAdd+1)), modWriteValB);
		break;
	case 1:
		MemWrite16(MemRead32(v60.reg[modVal&0x1F] + OpRead32(modAdd+1)), modWriteValH);
		break;
	case 2:
		MemWrite32(MemRead32(v60.reg[modVal&0x1F] + OpRead32(modAdd+1)), modWriteValW);
		break;
	}

	return 5;
}
Ejemplo n.º 19
0
static UINT32 bam2DirectAddressDeferredIndexed(void)
{
	amFlag = 0;
	amOut = MemRead32(OpRead32(modAdd+2));
	bamOffset = v60.reg[modVal&0x1F];

	return 6;
}
Ejemplo n.º 20
0
static UINT32 bam2DirectAddressDeferred(void)
{
	amFlag = 0;
	amOut = MemRead32(OpRead32(modAdd+1));
	bamOffset = 0;

	return 5;
}
Ejemplo n.º 21
0
static UINT32 bam2PCDoubleDisplacement32(void)
{
	amFlag = 0;
	amOut = MemRead32(PC + OpRead32(modAdd+1));
	bamOffset = OpRead32(modAdd+5);

	return 9;
}
Ejemplo n.º 22
0
static UINT32 bam2PCDoubleDisplacement16(void)
{
	amFlag = 0;
	amOut = MemRead32(PC + (INT16)OpRead16(modAdd+1));
	bamOffset = (INT8)OpRead8(modAdd+3);

	return 5;
}
Ejemplo n.º 23
0
static UINT32 bam2DoubleDisplacement16(void)
{
	amFlag = 0;
	amOut = MemRead32(v60.reg[modVal&0x1F] + (INT16)OpRead16(modAdd+1));
	bamOffset = (INT8)OpRead8(modAdd+3);

	return 5;
}
Ejemplo n.º 24
0
static UINT32 bam2PCDisplacementIndirectIndexed32(void)
{
	amFlag = 0;
	amOut = MemRead32(PC + OpRead32(modAdd+2));
	bamOffset = v60.reg[modVal&0x1F];

	return 6;
}
Ejemplo n.º 25
0
static UINT32 am3DirectAddressDeferred(void)
{
	switch (modDim)
	{
	case 0:
		MemWrite8(MemRead32(OpRead32(modAdd+1)), modWriteValB);
		break;
	case 1:
		MemWrite16(MemRead32(OpRead32(modAdd+1)), modWriteValH);
		break;
	case 2:
		MemWrite32(MemRead32(OpRead32(modAdd+1)), modWriteValW);
		break;
	}

	return 5;
}
Ejemplo n.º 26
0
static UINT32 am3PCDoubleDisplacement16(void)
{
	switch (modDim)
	{
	case 0:
		MemWrite8(MemRead32(PC + (INT16)OpRead16(modAdd+1)) + (INT16)OpRead16(modAdd+3), modWriteValB);
		break;
	case 1:
		MemWrite16(MemRead32(PC + (INT16)OpRead16(modAdd+1)) + (INT16)OpRead16(modAdd+3), modWriteValH);
		break;
	case 2:
		MemWrite32(MemRead32(PC + (INT16)OpRead16(modAdd+1)) + (INT16)OpRead16(modAdd+3), modWriteValW);
		break;
	}

	return 5;
}
Ejemplo n.º 27
0
static UINT32 am3PCDoubleDisplacement32(void)
{
	switch (modDim)
	{
	case 0:
		MemWrite8(MemRead32(PC + OpRead32(modAdd+1)) + OpRead32(modAdd+5), modWriteValB);
		break;
	case 1:
		MemWrite16(MemRead32(PC + OpRead32(modAdd+1)) + OpRead32(modAdd+5), modWriteValH);
		break;
	case 2:
		MemWrite32(MemRead32(PC + OpRead32(modAdd+1)) + OpRead32(modAdd+5), modWriteValW);
		break;
	}

	return 9;
}
Ejemplo n.º 28
0
static UINT32 bam2DisplacementIndirectIndexed16(void)
{
	amFlag = 0;
	amOut = MemRead32(v60.reg[modVal2&0x1F] + (INT16)OpRead16(modAdd+2));
	bamOffset = v60.reg[modVal&0x1F];

	return 4;
}
Ejemplo n.º 29
0
static UINT32 am3DirectAddressDeferredIndexed(void)
{
	switch (modDim)
	{
	case 0:
		MemWrite8(MemRead32(OpRead32(modAdd+2)) + v60.reg[modVal&0x1F], modWriteValB);
		break;
	case 1:
		MemWrite16(MemRead32(OpRead32(modAdd+2)) + v60.reg[modVal&0x1F], modWriteValH);
		break;
	case 2:
		MemWrite32(MemRead32(OpRead32(modAdd+2)) + v60.reg[modVal&0x1F], modWriteValW);
		break;
	}

	return 6;
}
Ejemplo n.º 30
0
static UINT32 bam2PCDisplacementIndirect32(void)
{
	amFlag = 0;
	amOut = MemRead32(PC + OpRead32(modAdd+1));
	bamOffset = 0;

	return 5;
}