summaryrefslogtreecommitdiffstatshomepage
path: root/src/emu/cpu/v60/am2.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/emu/cpu/v60/am2.c')
-rw-r--r--src/emu/cpu/v60/am2.c1256
1 files changed, 1256 insertions, 0 deletions
diff --git a/src/emu/cpu/v60/am2.c b/src/emu/cpu/v60/am2.c
new file mode 100644
index 00000000000..abbd2e5682c
--- /dev/null
+++ b/src/emu/cpu/v60/am2.c
@@ -0,0 +1,1256 @@
+
+// AM2 Functions (for ReadAMAddress)
+// *********************************
+
+static UINT32 am2Register(void)
+{
+ amFlag = 1;
+ amOut = modVal&0x1F;
+ return 1;
+}
+
+static UINT32 am2RegisterIndirect(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal&0x1F];
+ return 1;
+}
+
+static UINT32 bam2RegisterIndirect(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal&0x1F];
+ bamOffset = 0;
+ return 1;
+}
+
+static UINT32 am2RegisterIndirectIndexed(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = v60.reg[modVal2&0x1F] + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = v60.reg[modVal2&0x1F] + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = v60.reg[modVal2&0x1F] + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = v60.reg[modVal2&0x1F] + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 2;
+}
+
+static UINT32 bam2RegisterIndirectIndexed(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal2&0x1F];
+ bamOffset = v60.reg[modVal&0x1F];
+ return 2;
+}
+
+static UINT32 am2Autoincrement(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal&0x1F];
+
+ switch (modDim)
+ {
+ case 0:
+ v60.reg[modVal&0x1F] += 1;
+ break;
+ case 1:
+ v60.reg[modVal&0x1F] += 2;
+ break;
+ case 2:
+ v60.reg[modVal&0x1F] += 4;
+ break;
+ case 3:
+ v60.reg[modVal&0x1F] += 8;
+ break;
+ }
+
+ return 1;
+}
+
+static UINT32 bam2Autoincrement(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal&0x1F];
+ bamOffset = 0;
+
+ switch (modDim)
+ {
+ case 10:
+ v60.reg[modVal&0x1F]+=1;
+ break;
+ case 11:
+ v60.reg[modVal&0x1F]+=4;
+ break;
+ default:
+ fatalerror("CPU - AM2 - 7 (t0 PC=%x)", PC);
+ break;
+ }
+
+ return 1;
+}
+
+static UINT32 am2Autodecrement(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ v60.reg[modVal&0x1F] -= 1;
+ break;
+ case 1:
+ v60.reg[modVal&0x1F] -= 2;
+ break;
+ case 2:
+ v60.reg[modVal&0x1F] -= 4;
+ break;
+ case 3:
+ v60.reg[modVal&0x1F] -= 8;
+ break;
+ }
+
+ amOut = v60.reg[modVal&0x1F];
+ return 1;
+}
+
+static UINT32 bam2Autodecrement(void)
+{
+ amFlag = 0;
+ bamOffset = 0;
+
+ switch (modDim)
+ {
+ case 10:
+ v60.reg[modVal&0x1F]-=1;
+ break;
+ case 11:
+ v60.reg[modVal&0x1F]-=4;
+ break;
+ default:
+ fatalerror("CPU - BAM2 - 7 (PC=%06x)", PC);
+ break;
+ }
+
+ amOut = v60.reg[modVal&0x1F];
+ return 1;
+}
+
+
+static UINT32 am2Displacement8(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal&0x1F] + (INT8)OpRead8(modAdd+1);
+
+ return 2;
+}
+
+static UINT32 bam2Displacement8(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal&0x1F];
+ bamOffset = (INT8)OpRead8(modAdd+1);
+
+ return 2;
+}
+
+static UINT32 am2Displacement16(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal&0x1F] + (INT16)OpRead16(modAdd+1);
+
+ return 3;
+}
+
+static UINT32 bam2Displacement16(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal&0x1F];
+ bamOffset = (INT16)OpRead16(modAdd+1);
+
+ return 3;
+}
+
+static UINT32 am2Displacement32(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal&0x1F] + OpRead32(modAdd+1);
+
+ return 5;
+}
+
+static UINT32 bam2Displacement32(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal&0x1F];
+ bamOffset = OpRead32(modAdd+1);
+
+ return 5;
+}
+
+static UINT32 am2DisplacementIndexed8(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = v60.reg[modVal2&0x1F] + (INT8)OpRead8(modAdd+2) + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = v60.reg[modVal2&0x1F] + (INT8)OpRead8(modAdd+2) + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = v60.reg[modVal2&0x1F] + (INT8)OpRead8(modAdd+2) + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = v60.reg[modVal2&0x1F] + (INT8)OpRead8(modAdd+2) + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 3;
+}
+
+static UINT32 bam2DisplacementIndexed8(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal2&0x1F] + (INT8)OpRead8(modAdd+2);
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 3;
+}
+
+static UINT32 am2DisplacementIndexed16(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = v60.reg[modVal2&0x1F] + (INT16)OpRead16(modAdd+2) + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = v60.reg[modVal2&0x1F] + (INT16)OpRead16(modAdd+2) + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = v60.reg[modVal2&0x1F] + (INT16)OpRead16(modAdd+2) + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = v60.reg[modVal2&0x1F] + (INT16)OpRead16(modAdd+2) + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 4;
+}
+
+static UINT32 bam2DisplacementIndexed16(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal2&0x1F] + (INT16)OpRead16(modAdd+2);
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 4;
+}
+
+static UINT32 am2DisplacementIndexed32(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = v60.reg[modVal2&0x1F] + OpRead32(modAdd+2) + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = v60.reg[modVal2&0x1F] + OpRead32(modAdd+2) + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = v60.reg[modVal2&0x1F] + OpRead32(modAdd+2) + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = v60.reg[modVal2&0x1F] + OpRead32(modAdd+2) + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 6;
+}
+
+static UINT32 bam2DisplacementIndexed32(void)
+{
+ amFlag = 0;
+ amOut = v60.reg[modVal2&0x1F] + OpRead32(modAdd+2);
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 6;
+}
+
+static UINT32 am2PCDisplacement8(void)
+{
+ amFlag = 0;
+ amOut = PC + (INT8)OpRead8(modAdd+1);
+
+ return 2;
+}
+
+static UINT32 bam2PCDisplacement8(void)
+{
+ amFlag = 0;
+ amOut = PC;
+ bamOffset = (INT8)OpRead8(modAdd+1);
+
+ return 2;
+}
+
+static UINT32 am2PCDisplacement16(void)
+{
+ amFlag = 0;
+ amOut = PC + (INT16)OpRead16(modAdd+1);
+
+ return 3;
+}
+
+static UINT32 bam2PCDisplacement16(void)
+{
+ amFlag = 0;
+ amOut = PC;
+ bamOffset = (INT16)OpRead16(modAdd+1);
+
+ return 3;
+}
+
+static UINT32 am2PCDisplacement32(void)
+{
+ amFlag = 0;
+ amOut = PC + OpRead32(modAdd+1);
+
+ return 5;
+}
+
+static UINT32 bam2PCDisplacement32(void)
+{
+ amFlag = 0;
+ amOut = PC;
+ bamOffset = OpRead32(modAdd+1);
+
+ return 5;
+}
+
+
+static UINT32 am2PCDisplacementIndexed8(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = PC + (INT8)OpRead8(modAdd+2) + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = PC + (INT8)OpRead8(modAdd+2) + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = PC + (INT8)OpRead8(modAdd+2) + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = PC + (INT8)OpRead8(modAdd+2) + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 3;
+}
+
+static UINT32 bam2PCDisplacementIndexed8(void)
+{
+ amFlag = 0;
+ amOut = PC + (INT8)OpRead8(modAdd+2);
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 3;
+}
+
+static UINT32 am2PCDisplacementIndexed16(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = PC + (INT16)OpRead16(modAdd+2) + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = PC + (INT16)OpRead16(modAdd+2) + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = PC + (INT16)OpRead16(modAdd+2) + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = PC + (INT16)OpRead16(modAdd+2) + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 4;
+}
+
+static UINT32 bam2PCDisplacementIndexed16(void)
+{
+ amFlag = 0;
+ amOut = PC + (INT16)OpRead16(modAdd+2);
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 4;
+}
+
+static UINT32 am2PCDisplacementIndexed32(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = PC + OpRead32(modAdd+2) + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = PC + OpRead32(modAdd+2) + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = PC + OpRead32(modAdd+2) + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = PC + OpRead32(modAdd+2) + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 6;
+}
+
+static UINT32 bam2PCDisplacementIndexed32(void)
+{
+ amFlag = 0;
+ amOut = PC + OpRead32(modAdd+2);
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 6;
+}
+
+static UINT32 am2DisplacementIndirect8(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal&0x1F] + (INT8)OpRead8(modAdd+1));
+
+ return 2;
+}
+
+static UINT32 bam2DisplacementIndirect8(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal&0x1F] + (INT8)OpRead8(modAdd+1));
+ bamOffset = 0;
+ return 2;
+}
+
+static UINT32 am2DisplacementIndirect16(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal&0x1F] + (INT16)OpRead16(modAdd+1));
+
+ return 3;
+}
+
+static UINT32 bam2DisplacementIndirect16(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal&0x1F] + (INT16)OpRead16(modAdd+1));
+ bamOffset = 0;
+ return 3;
+}
+
+static UINT32 am2DisplacementIndirect32(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal&0x1F] + OpRead32(modAdd+1));
+
+ return 5;
+}
+
+static UINT32 bam2DisplacementIndirect32(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal&0x1F] + OpRead32(modAdd+1));
+ bamOffset = 0;
+
+ return 5;
+}
+
+static UINT32 am2DisplacementIndirectIndexed8(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + (INT8)OpRead8(modAdd+2)) + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + (INT8)OpRead8(modAdd+2)) + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + (INT8)OpRead8(modAdd+2)) + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + (INT8)OpRead8(modAdd+2)) + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 3;
+}
+
+static UINT32 bam2DisplacementIndirectIndexed8(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + (INT8)OpRead8(modAdd+2));
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 3;
+}
+
+static UINT32 am2DisplacementIndirectIndexed16(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + (INT16)OpRead16(modAdd+2)) + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + (INT16)OpRead16(modAdd+2)) + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + (INT16)OpRead16(modAdd+2)) + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + (INT16)OpRead16(modAdd+2)) + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 4;
+}
+
+static UINT32 bam2DisplacementIndirectIndexed16(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + (INT16)OpRead16(modAdd+2));
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 4;
+}
+
+static UINT32 am2DisplacementIndirectIndexed32(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + OpRead32(modAdd+2)) + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + OpRead32(modAdd+2)) + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + OpRead32(modAdd+2)) + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + OpRead32(modAdd+2)) + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 6;
+}
+
+static UINT32 bam2DisplacementIndirectIndexed32(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal2&0x1F] + OpRead32(modAdd+2));
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 6;
+}
+
+static UINT32 am2PCDisplacementIndirect8(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + (INT8)OpRead8(modAdd+1));
+
+ return 2;
+}
+
+static UINT32 bam2PCDisplacementIndirect8(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + (INT8)OpRead8(modAdd+1));
+ bamOffset = 0;
+
+ return 2;
+}
+
+static UINT32 am2PCDisplacementIndirect16(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + (INT16)OpRead16(modAdd+1));
+
+ return 3;
+}
+
+static UINT32 bam2PCDisplacementIndirect16(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + (INT16)OpRead16(modAdd+1));
+ bamOffset = 0;
+
+ return 3;
+}
+
+static UINT32 am2PCDisplacementIndirect32(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + OpRead32(modAdd+1));
+
+ return 5;
+}
+
+static UINT32 bam2PCDisplacementIndirect32(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + OpRead32(modAdd+1));
+ bamOffset = 0;
+
+ return 5;
+}
+
+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;
+}
+
+static UINT32 bam2PCDisplacementIndirectIndexed8(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + (INT8)OpRead8(modAdd+2));
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 3;
+}
+
+static UINT32 am2PCDisplacementIndirectIndexed16(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = MemRead32(PC + (INT16)OpRead16(modAdd+2)) + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = MemRead32(PC + (INT16)OpRead16(modAdd+2)) + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = MemRead32(PC + (INT16)OpRead16(modAdd+2)) + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = MemRead32(PC + (INT16)OpRead16(modAdd+2)) + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 4;
+}
+
+
+static UINT32 bam2PCDisplacementIndirectIndexed16(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + (INT16)OpRead16(modAdd+2));
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 4;
+}
+
+
+static UINT32 am2PCDisplacementIndirectIndexed32(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = MemRead32(PC + OpRead32(modAdd+2)) + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = MemRead32(PC + OpRead32(modAdd+2)) + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = MemRead32(PC + OpRead32(modAdd+2)) + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = MemRead32(PC + OpRead32(modAdd+2)) + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 6;
+}
+
+static UINT32 bam2PCDisplacementIndirectIndexed32(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + OpRead32(modAdd+2));
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 6;
+}
+
+static UINT32 am2DoubleDisplacement8(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal&0x1F] + (INT8)OpRead8(modAdd+1)) + (INT8)OpRead8(modAdd+2);
+
+ return 3;
+}
+
+static UINT32 bam2DoubleDisplacement8(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal&0x1F] + (INT8)OpRead8(modAdd+1));
+ bamOffset = (INT8)OpRead8(modAdd+2);
+
+ return 3;
+}
+
+static UINT32 am2DoubleDisplacement16(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal&0x1F] + (INT16)OpRead16(modAdd+1)) + (INT16)OpRead16(modAdd+3);
+
+ return 5;
+}
+
+static UINT32 bam2DoubleDisplacement16(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal&0x1F] + (INT16)OpRead16(modAdd+1));
+ bamOffset = (INT8)OpRead8(modAdd+3);
+
+ return 5;
+}
+
+static UINT32 am2DoubleDisplacement32(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal&0x1F] + OpRead32(modAdd+1)) + OpRead32(modAdd+5);
+
+ return 9;
+}
+
+static UINT32 bam2DoubleDisplacement32(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(v60.reg[modVal&0x1F] + OpRead32(modAdd+1));
+ bamOffset = OpRead32(modAdd+5);
+
+ return 9;
+}
+
+
+static UINT32 am2PCDoubleDisplacement8(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + (INT8)OpRead8(modAdd+1)) + (INT8)OpRead8(modAdd+2);
+
+ return 3;
+}
+
+static UINT32 bam2PCDoubleDisplacement8(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + (INT8)OpRead8(modAdd+1));
+ bamOffset = (INT8)OpRead8(modAdd+2);
+
+ return 3;
+}
+
+static UINT32 am2PCDoubleDisplacement16(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + (INT16)OpRead16(modAdd+1)) + (INT16)OpRead16(modAdd+3);
+
+ return 5;
+}
+
+static UINT32 bam2PCDoubleDisplacement16(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + (INT16)OpRead16(modAdd+1));
+ bamOffset = (INT8)OpRead8(modAdd+3);
+
+ return 5;
+}
+
+static UINT32 am2PCDoubleDisplacement32(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + OpRead32(modAdd+1)) + OpRead32(modAdd+5);
+
+ return 9;
+}
+
+static UINT32 bam2PCDoubleDisplacement32(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(PC + OpRead32(modAdd+1));
+ bamOffset = OpRead32(modAdd+5);
+
+ return 9;
+}
+
+static UINT32 am2DirectAddress(void)
+{
+ amFlag = 0;
+ amOut = OpRead32(modAdd+1);
+
+ return 5;
+}
+
+static UINT32 bam2DirectAddress(void)
+{
+ amFlag = 0;
+ amOut = OpRead32(modAdd+1);
+ bamOffset = 0;
+
+ return 5;
+}
+
+static UINT32 am2DirectAddressIndexed(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = OpRead32(modAdd+2) + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = OpRead32(modAdd+2) + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = OpRead32(modAdd+2) + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = OpRead32(modAdd+2) + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 6;
+}
+
+static UINT32 bam2DirectAddressIndexed(void)
+{
+ amFlag = 0;
+ amOut = OpRead32(modAdd+2);
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 6;
+}
+
+static UINT32 am2DirectAddressDeferred(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(OpRead32(modAdd+1));
+
+ return 5;
+}
+
+static UINT32 bam2DirectAddressDeferred(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(OpRead32(modAdd+1));
+ bamOffset = 0;
+
+ return 5;
+}
+
+static UINT32 am2DirectAddressDeferredIndexed(void)
+{
+ amFlag = 0;
+
+ switch (modDim)
+ {
+ case 0:
+ amOut = MemRead32(OpRead32(modAdd+2)) + v60.reg[modVal&0x1F];
+ break;
+ case 1:
+ amOut = MemRead32(OpRead32(modAdd+2)) + v60.reg[modVal&0x1F] * 2;
+ break;
+ case 2:
+ amOut = MemRead32(OpRead32(modAdd+2)) + v60.reg[modVal&0x1F] * 4;
+ break;
+ case 3:
+ amOut = MemRead32(OpRead32(modAdd+2)) + v60.reg[modVal&0x1F] * 8;
+ break;
+ }
+
+ return 6;
+}
+
+static UINT32 bam2DirectAddressDeferredIndexed(void)
+{
+ amFlag = 0;
+ amOut = MemRead32(OpRead32(modAdd+2));
+ bamOffset = v60.reg[modVal&0x1F];
+
+ return 6;
+}
+
+static UINT32 am2Immediate(void)
+{
+ // Fuck off LDPR
+ return am1Immediate();
+}
+
+static UINT32 am2ImmediateQuick(void)
+{
+ // fuck off LDPR
+ return am1ImmediateQuick();
+}
+
+
+// AM2 Tables (for ReadAMAddress)
+// ******************************
+
+static UINT32 am2Error1(void)
+{
+ fatalerror("CPU - AM2 - 1 (PC=%06x)", PC);
+ return 0; /* never reached, fatalerror won't return */
+}
+
+static UINT32 am2Error2(void)
+{
+ fatalerror("CPU - AM2 - 2 (PC=%06x)", PC);
+ return 0; /* never reached, fatalerror won't return */
+}
+
+#ifdef UNUSED_FUNCTION
+static UINT32 am2Error3(void)
+{
+ fatalerror("CPU - AM2 - 3 (PC=%06x)", PC);
+ return 0; /* never reached, fatalerror won't return */
+}
+#endif
+
+static UINT32 am2Error4(void)
+{
+ fatalerror("CPU - AM2 - 4 (PC=%06x)", PC);
+ return 0; /* never reached, fatalerror won't return */
+}
+
+static UINT32 am2Error5(void)
+{
+ fatalerror("CPU - AM2 - 5 (PC=%06x)", PC);
+ return 0; /* never reached, fatalerror won't return */
+}
+
+static UINT32 bam2Error1(void)
+{
+ fatalerror("CPU - BAM2 - 1 (PC=%06x)", PC);
+ return 0; /* never reached, fatalerror won't return */
+}
+
+static UINT32 bam2Error2(void)
+{
+ fatalerror("CPU - BAM2 - 2 (PC=%06x)", PC);
+ return 0; /* never reached, fatalerror won't return */
+}
+
+#ifdef UNUSED_FUNCTION
+static UINT32 bam2Error3(void)
+{
+ fatalerror("CPU - BAM2 - 3 (PC=%06x)", PC);
+ return 0; /* never reached, fatalerror won't return */
+}
+#endif
+
+static UINT32 bam2Error4(void)
+{
+ fatalerror("CPU - BAM2 - 4 (PC=%06x)", PC);
+ return 0; /* never reached, fatalerror won't return */
+}
+
+static UINT32 bam2Error5(void)
+{
+ fatalerror("CPU - BAM2 - 5 (PC=%06x)", PC);
+ return 0; /* never reached, fatalerror won't return */
+}
+
+static UINT32 bam2Error6(void)
+{
+ fatalerror("CPU - BAM2 - 6 (PC=%06x)", PC);
+ return 0; /* never reached, fatalerror won't return */
+}
+
+
+static UINT32 (*const AMTable2_G7a[16])(void) =
+{
+ am2PCDisplacementIndexed8,
+ am2PCDisplacementIndexed16,
+ am2PCDisplacementIndexed32,
+ am2DirectAddressIndexed,
+ am2Error5,
+ am2Error5,
+ am2Error5,
+ am2Error5,
+ am2PCDisplacementIndirectIndexed8,
+ am2PCDisplacementIndirectIndexed16,
+ am2PCDisplacementIndirectIndexed32,
+ am2DirectAddressDeferredIndexed,
+ am2Error5,
+ am2Error5,
+ am2Error5,
+ am2Error5
+};
+
+static UINT32 (*const BAMTable2_G7a[16])(void) =
+{
+ bam2PCDisplacementIndexed8,
+ bam2PCDisplacementIndexed16,
+ bam2PCDisplacementIndexed32,
+ bam2DirectAddressIndexed,
+ bam2Error5,
+ bam2Error5,
+ bam2Error5,
+ bam2Error5,
+ bam2PCDisplacementIndirectIndexed8,
+ bam2PCDisplacementIndirectIndexed16,
+ bam2PCDisplacementIndirectIndexed32,
+ bam2DirectAddressDeferredIndexed,
+ bam2Error5,
+ bam2Error5,
+ bam2Error5,
+ bam2Error5
+};
+
+static UINT32 am2Group7a(void)
+{
+ if (!(modVal2&0x10))
+ return am2Error4();
+
+ return AMTable2_G7a[modVal2&0xF]();
+}
+
+static UINT32 bam2Group7a(void)
+{
+ if (!(modVal2&0x10))
+ return bam2Error4();
+
+ return BAMTable2_G7a[modVal2&0xF]();
+}
+
+static UINT32 (*const AMTable2_G7[32])(void) =
+{
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2ImmediateQuick,
+ am2PCDisplacement8,
+ am2PCDisplacement16,
+ am2PCDisplacement32,
+ am2DirectAddress,
+ am2Immediate,
+ am2Error2,
+ am2Error2,
+ am2Error2,
+ am2PCDisplacementIndirect8,
+ am2PCDisplacementIndirect16,
+ am2PCDisplacementIndirect32,
+ am2DirectAddressDeferred,
+ am2PCDoubleDisplacement8,
+ am2PCDoubleDisplacement16,
+ am2PCDoubleDisplacement32,
+ am2Error2
+};
+
+static UINT32 (*const BAMTable2_G7[32])(void) =
+{
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2Error6,
+ bam2PCDisplacement8,
+ bam2PCDisplacement16,
+ bam2PCDisplacement32,
+ bam2DirectAddress,
+ bam2Error6,
+ bam2Error2,
+ bam2Error2,
+ bam2Error2,
+ bam2PCDisplacementIndirect8,
+ bam2PCDisplacementIndirect16,
+ bam2PCDisplacementIndirect32,
+ bam2DirectAddressDeferred,
+ bam2PCDoubleDisplacement8,
+ bam2PCDoubleDisplacement16,
+ bam2PCDoubleDisplacement32,
+ bam2Error2
+};
+
+static UINT32 (*const AMTable2_G6[8])(void) =
+{
+ am2DisplacementIndexed8,
+ am2DisplacementIndexed16,
+ am2DisplacementIndexed32,
+ am2RegisterIndirectIndexed,
+ am2DisplacementIndirectIndexed8,
+ am2DisplacementIndirectIndexed16,
+ am2DisplacementIndirectIndexed32,
+ am2Group7a
+};
+
+static UINT32 (*const BAMTable2_G6[8])(void) =
+{
+ bam2DisplacementIndexed8,
+ bam2DisplacementIndexed16,
+ bam2DisplacementIndexed32,
+ bam2RegisterIndirectIndexed,
+ bam2DisplacementIndirectIndexed8,
+ bam2DisplacementIndirectIndexed16,
+ bam2DisplacementIndirectIndexed32,
+ bam2Group7a
+};
+
+
+
+
+static UINT32 am2Group6(void)
+{
+ modVal2=OpRead8(modAdd+1);
+ return AMTable2_G6[modVal2>>5]();
+}
+static UINT32 bam2Group6(void)
+{
+ modVal2=OpRead8(modAdd+1);
+ return BAMTable2_G6[modVal2>>5]();
+}
+
+static UINT32 am2Group7(void)
+{
+ return AMTable2_G7[modVal&0x1F]();
+}
+static UINT32 bam2Group7(void)
+{
+ return BAMTable2_G7[modVal&0x1F]();
+}
+
+
+static UINT32 (*const AMTable2[2][8])(void) =
+{
+ {
+ am2Displacement8,
+ am2Displacement16,
+ am2Displacement32,
+ am2RegisterIndirect,
+ am2DisplacementIndirect8,
+ am2DisplacementIndirect16,
+ am2DisplacementIndirect32,
+ am2Group7
+ },
+
+ {
+ am2DoubleDisplacement8,
+ am2DoubleDisplacement16,
+ am2DoubleDisplacement32,
+ am2Register,
+ am2Autoincrement,
+ am2Autodecrement,
+ am2Group6,
+ am2Error1
+ }
+};
+
+static UINT32 (*const BAMTable2[2][8])(void) =
+{
+ {
+ bam2Displacement8,
+ bam2Displacement16,
+ bam2Displacement32,
+ bam2RegisterIndirect,
+ bam2DisplacementIndirect8,
+ bam2DisplacementIndirect16,
+ bam2DisplacementIndirect32,
+ bam2Group7
+ },
+
+ {
+ bam2DoubleDisplacement8,
+ bam2DoubleDisplacement16,
+ bam2DoubleDisplacement32,
+ bam2Error6,
+ bam2Autoincrement,
+ bam2Autodecrement,
+ bam2Group6,
+ bam2Error1
+ }
+};
+
+
+
+