Esempio n. 1
0
UINT32 bam2PCDisplacementIndirect8(void)
{
	amFlag = 0;
	amOut = MemRead32(PC + (INT8)OpRead8(modAdd+1));
	bamOffset = 0;

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

	return 5;
}
Esempio n. 3
0
UINT32 bam2PCDisplacement8(void)
{
	amFlag = 0;
	amOut = PC;
	bamOffset = (INT8)OpRead8(modAdd+1);

	return 2;
}
Esempio n. 4
0
UINT32 bam2DisplacementIndirectIndexed8(void)
{
	amFlag = 0;
	amOut = MemRead32(v60.reg[modVal2&0x1F] + (INT8)OpRead8(modAdd+2));
	bamOffset = v60.reg[modVal&0x1F];

	return 3;
}
Esempio n. 5
0
static UINT32 bam2PCDoubleDisplacement16(v60_state *cpustate)
{
	cpustate->amflag = 0;
	cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT16)OpRead16(cpustate, cpustate->modadd + 1));
	cpustate->bamoffset = (INT8)OpRead8(cpustate, cpustate->modadd + 3);

	return 5;
}
Esempio n. 6
0
static UINT32 bam2PCDisplacementIndirectIndexed8(v60_state *cpustate)
{
	cpustate->amflag = 0;
	cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2));
	cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F];

	return 3;
}
Esempio n. 7
0
static UINT32 bam2DoubleDisplacement8(v60_state *cpustate)
{
	cpustate->amflag = 0;
	cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->reg[cpustate->modval & 0x1F] + (INT8)OpRead8(cpustate, cpustate->modadd + 1));
	cpustate->bamoffset = (INT8)OpRead8(cpustate, cpustate->modadd + 2);

	return 3;
}
Esempio n. 8
0
static UINT32 bam2PCDisplacementIndexed8(v60_state *cpustate)
{
	cpustate->amflag = 0;
	cpustate->amout = cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 2);
	cpustate->bamoffset = cpustate->reg[cpustate->modval & 0x1F];

	return 3;
}
Esempio n. 9
0
static UINT32 bam2PCDisplacementIndirect8(v60_state *cpustate)
{
	cpustate->amflag = 0;
	cpustate->amout = cpustate->program->read_dword_unaligned(cpustate->PC + (INT8)OpRead8(cpustate, cpustate->modadd + 1));
	cpustate->bamoffset = 0;

	return 2;
}
Esempio n. 10
0
static UINT32 bam2PCDisplacement8(v60_state *cpustate)
{
	cpustate->amflag = 0;
	cpustate->amout = cpustate->PC;
	cpustate->bamoffset = (INT8)OpRead8(cpustate, cpustate->modadd + 1);

	return 2;
}
Esempio n. 11
0
static UINT32 bam2Displacement8(v60_state *cpustate)
{
	cpustate->amflag = 0;
	cpustate->amout = cpustate->reg[cpustate->modval & 0x1F];
	cpustate->bamoffset = (INT8)OpRead8(cpustate, cpustate->modadd + 1);

	return 2;
}
Esempio n. 12
0
UINT32 bam2PCDisplacementIndexed8(void)
{
	amFlag = 0;
	amOut = PC + (INT8)OpRead8(modAdd+2);
	bamOffset = v60.reg[modVal&0x1F];

	return 3;
}
Esempio n. 13
0
UINT32 bam2Displacement8(void)
{
	amFlag = 0;
	amOut = v60.reg[modVal&0x1F];
	bamOffset = (INT8)OpRead8(modAdd+1);

	return 2;
}
Esempio n. 14
0
UINT32 bam2PCDoubleDisplacement16(void)
{
	amFlag = 0;
	amOut = MemRead32(PC + (INT16)OpRead16(modAdd+1));
	bamOffset = (INT8)OpRead8(modAdd+3);

	return 5;
}
Esempio n. 15
0
static UINT32 opBP8(void) /* TRUSTED */
{
	if (!(_S))
	{
		PC += (INT8)OpRead8(PC + 1);
		return 0;
	}

	return 2;
}
Esempio n. 16
0
static UINT32 opBV8(v60_state *cpustate) /* TRUSTED */
{
	if ((cpustate->_OV))
	{
		cpustate->PC += (INT8)OpRead8(cpustate->program, cpustate->PC + 1);
		return 0;
	}

	return 2;
}
Esempio n. 17
0
static UINT32 opBL8(void) /* TRUSTED */
{
	if ((_CY))
	{
		PC += (INT8)OpRead8(PC + 1);
		return 0;
	}

	return 2;
}
Esempio n. 18
0
static UINT32 opBN8(v60_state *cpustate) /* TRUSTED */
{
    if ((cpustate->_S))
    {
        cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1);
        return 0;
    }

    return 2;
}
Esempio n. 19
0
UINT32 opBN8(void) /* TRUSTED */
{
	if ((_S))
	{
		PC += (INT8)OpRead8(PC + 1);
		return 0;
	}

	return 2;
}
Esempio n. 20
0
static UINT32 opBH8(v60_state *cpustate) /* TRUSTED */
{
    if (!(cpustate->_CY | cpustate->_Z))
    {
        cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1);
        return 0;
    }

    return 2;
}
Esempio n. 21
0
UINT32 opBH8(void) /* TRUSTED */
{
	if (!(_CY | _Z))
	{
		PC += (INT8)OpRead8(PC + 1);
		return 0;
	}

	return 2;
}
Esempio n. 22
0
UINT32 opBNV8(void) /* TRUSTED */
{
	if (!(_OV))
	{
		PC += (INT8)OpRead8(PC + 1);
		return 0;
	}

	return 2;
}
Esempio n. 23
0
UINT32 v60_device::opBN8() /* TRUSTED */
{
	if ((_S))
	{
		PC += (INT8)OpRead8(PC + 1);
		return 0;
	}

	return 2;
}
Esempio n. 24
0
UINT32 v60_device::opBH8() /* TRUSTED */
{
	if (!(_CY | _Z))
	{
		PC += (INT8)OpRead8(PC + 1);
		return 0;
	}

	return 2;
}
Esempio n. 25
0
static UINT32 opBLE8(v60_state *cpustate) /* TRUSTED */
{
    NORMALIZEFLAGS(cpustate);

    if (((cpustate->_S ^ cpustate->_OV) | cpustate->_Z))
    {
        cpustate->PC += (INT8)OpRead8(cpustate, cpustate->PC + 1);
        return 0;
    }

    return 2;
}
Esempio n. 26
0
UINT32 opBLE8(void) /* TRUSTED */
{
	NORMALIZEFLAGS();

	if (((_S ^ _OV) | _Z))
	{
		PC += (INT8)OpRead8(PC + 1);
		return 0;
	}

	return 2;
}
Esempio n. 27
0
UINT32 v60_device::opBLE8() /* TRUSTED */
{
	NORMALIZEFLAGS();

	if (((_S ^ _OV) | _Z))
	{
		PC += (INT8)OpRead8(PC + 1);
		return 0;
	}

	return 2;
}
Esempio n. 28
0
static UINT32 opBGE8(void) /* TRUSTED */
{
	NORMALIZEFLAGS();

	if (!(_S ^ _OV))
	{
		PC += (INT8)OpRead8(PC + 1);
		return 0;
	}

	return 2;
}
Esempio n. 29
0
static UINT32 opBGE8(v60_state *cpustate) /* TRUSTED */
{
	NORMALIZEFLAGS(cpustate);

	if (!(cpustate->_S ^ cpustate->_OV))
	{
		cpustate->PC += (INT8)OpRead8(cpustate->program, cpustate->PC + 1);
		return 0;
	}

	return 2;
}
Esempio n. 30
0
static UINT32 am2PCDisplacementIndirectIndexed8(void)
{
	amFlag = 0;

	switch (modDim)
	{
	case 0:
		amOut = MemRead32(PC + (INT8)OpRead8(modAdd+2)) + v60.reg[modVal&0x1F];
		break;
	case 1:
		amOut = MemRead32(PC + (INT8)OpRead8(modAdd+2)) + v60.reg[modVal&0x1F] * 2;
		break;
	case 2:
		amOut = MemRead32(PC + (INT8)OpRead8(modAdd+2)) + v60.reg[modVal&0x1F] * 4;
		break;
	case 3:
		amOut = MemRead32(PC + (INT8)OpRead8(modAdd+2)) + v60.reg[modVal&0x1F] * 8;
		break;
	}

	return 3;
}