--- hatari/src/falcon/dsp_disasm.c	2019/04/01 07:13:46	1.1
+++ hatari/src/falcon/dsp_disasm.c	2019/04/01 07:14:53	1.1.1.2
@@ -1,36 +1,35 @@
 /*
- *  Dsp56K disassembler
- *
- *  ARAnyM (C) 2003 Patrice Mandin
- *  Adaption to Hatari (C) 2006 by Thomas Huth
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#include "main.h"
-#include "sysdeps.h"
-#include "ioMem.h"
-#include "dsp.h"
+	DSP M56001 emulation
+	Disassembler
+
+	(C) 2003-2008 ARAnyM developer team
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 2 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h>
+
+#include "dsp_core.h"
 #include "dsp_cpu.h"
 #include "dsp_disasm.h"
 
-#if DEBUG
-#define D(x) x
-#else
-#define D(x)
-#endif
+#define DEBUG 0
 
 /* More disasm infos, if wanted */
 #define DSP_DISASM_REG_PC 0
@@ -46,16 +45,23 @@
  **********************************/
 
 /* Current instruction */
-static uint32 cur_inst;
+static Uint32 cur_inst;
+
+static dsp_core_t *dsp_core;
+
+void dsp56k_disasm_init(dsp_core_t *my_dsp_core)
+{
+	dsp_core = my_dsp_core;
+}
 
 /**********************************
  *	Register change
  **********************************/
 
-static uint32 registers_save[64];
-static uint32 registers_changed[64];
+static Uint32 registers_save[64];
+static Uint32 registers_changed[64];
 #if DSP_DISASM_REG_PC
-static uint32 pc_save;
+static Uint32 pc_save;
 #endif
 
 static const char *registers_name[64]={
@@ -82,10 +88,10 @@ static const char *registers_name[64]={
 
 void dsp56k_disasm_reg_read(void)
 {
-	memcpy(registers_save, dsp_registers , sizeof(registers_save));
+	memcpy(registers_save, dsp_core->registers , sizeof(registers_save));
 	memset(registers_changed, 0, sizeof(registers_changed));
 #if DSP_DISASM_REG_PC
-	pc_save = dsp_pc;
+	pc_save = dsp_core->pc;
 #endif
 }
 
@@ -107,7 +113,7 @@ void dsp56k_disasm_reg_compare(void)
 			case DSP_REG_A1:
 			case DSP_REG_B0:
 			case DSP_REG_B1:
-				fprintf(stderr,"Dsp: Reg: %s: 0x%06x -> 0x%06x\n", registers_name[i], registers_save[i] & BITMASK(24), dsp_registers[i]  & BITMASK(24));
+				fprintf(stderr,"Dsp: Reg: %s: 0x%06x -> 0x%06x\n", registers_name[i], registers_save[i] & BITMASK(24), dsp_core->registers[i]  & BITMASK(24));
 				break;
 			case DSP_REG_R0:
 			case DSP_REG_R1:
@@ -136,7 +142,7 @@ void dsp56k_disasm_reg_compare(void)
 			case DSP_REG_SR:
 			case DSP_REG_LA:
 			case DSP_REG_LC:
-				fprintf(stderr,"Dsp: Reg: %s: 0x%04x -> 0x%04x\n", registers_name[i], registers_save[i] & BITMASK(16), dsp_registers[i]  & BITMASK(16));
+				fprintf(stderr,"Dsp: Reg: %s: 0x%04x -> 0x%04x\n", registers_name[i], registers_save[i] & BITMASK(16), dsp_core->registers[i]  & BITMASK(16));
 				break;
 			case DSP_REG_A2:
 			case DSP_REG_B2:
@@ -144,7 +150,7 @@ void dsp56k_disasm_reg_compare(void)
 			case DSP_REG_SP:
 			case DSP_REG_SSH:
 			case DSP_REG_SSL:
-				fprintf(stderr,"Dsp: Reg: %s: 0x%02x -> 0x%02x\n", registers_name[i], registers_save[i] & BITMASK(8), dsp_registers[i]  & BITMASK(8));
+				fprintf(stderr,"Dsp: Reg: %s: 0x%02x -> 0x%02x\n", registers_name[i], registers_save[i] & BITMASK(8), dsp_core->registers[i]  & BITMASK(8));
 				break;
 			case DSP_REG_A:
 			case DSP_REG_B:
@@ -154,17 +160,17 @@ void dsp56k_disasm_reg_compare(void)
 						registers_save[DSP_REG_A2+(i & 1)] & BITMASK(8),
 						registers_save[DSP_REG_A1+(i & 1)] & BITMASK(24),
 						registers_save[DSP_REG_A0+(i & 1)] & BITMASK(24),
-						dsp_registers[DSP_REG_A2+(i & 1)]  & BITMASK(8),
-						dsp_registers[DSP_REG_A1+(i & 1)]  & BITMASK(24),
-						dsp_registers[DSP_REG_A0+(i & 1)]  & BITMASK(24)
+						dsp_core->registers[DSP_REG_A2+(i & 1)]  & BITMASK(8),
+						dsp_core->registers[DSP_REG_A1+(i & 1)]  & BITMASK(24),
+						dsp_core->registers[DSP_REG_A0+(i & 1)]  & BITMASK(24)
 					);
 				}
 				break;
 		}
 	}
 #if DSP_DISASM_REG_PC
-	if (pc_save != dsp_pc) {
-		fprintf(stderr,"Dsp: Reg: pc: 0x%04x -> 0x%04x\n", pc_save, dsp_pc);
+	if (pc_save != dsp_core->pc) {
+		fprintf(stderr,"Dsp: Reg: pc: 0x%04x -> 0x%04x\n", pc_save, dsp_core->pc);
 	}
 #endif
 }
@@ -173,6 +179,8 @@ void dsp56k_disasm_reg_compare(void)
  *	Opcode disassembler
  **********************************/
 
+static Uint32 read_memory(Uint32 currPc);
+
 typedef void (*dsp_emul_t)(void);
 
 static void opcode8h_0(void);
@@ -183,8 +191,8 @@ static void opcode8h_8(void);
 static void opcode8h_a(void);
 static void opcode8h_b(void);
 
-static int dsp_calc_ea(uint32 ea_mode, char *dest);
-static void dsp_calc_cc(uint32 cc_mode, char *dest);
+static int dsp_calc_ea(Uint32 ea_mode, char *dest);
+static void dsp_calc_cc(Uint32 cc_mode, char *dest);
 static void dsp_undefined(void);
 
 /* Instructions without parallel moves */
@@ -602,11 +610,11 @@ static int registers_tcc[16][2]={
 
 	{DSP_REG_X0,DSP_REG_A},
 	{DSP_REG_X0,DSP_REG_B},
-	{DSP_REG_X1,DSP_REG_A},
-	{DSP_REG_X1,DSP_REG_B},
-
 	{DSP_REG_Y0,DSP_REG_A},
 	{DSP_REG_Y0,DSP_REG_B},
+
+	{DSP_REG_X1,DSP_REG_A},
+	{DSP_REG_X1,DSP_REG_B},
 	{DSP_REG_Y1,DSP_REG_A},
 	{DSP_REG_Y1,DSP_REG_B}
 };
@@ -658,15 +666,9 @@ static char parallelmove_name[64];
 
 void dsp56k_disasm(void)
 {
-	uint32 value;
+	Uint32 value;
 
-	cur_inst = dsp_ram[DSP_SPACE_P][dsp_pc];
-
-#if 0
-	if (dsp_pc == 0x728) {
-		D(bug("Dsp: Disasm: instruction = 0x%06x",cur_inst));
-	}
-#endif
+	cur_inst = read_memory(dsp_core->pc);
 
 	strcpy(parallelmove_name, "");
 
@@ -688,11 +690,29 @@ void dsp56k_disasm(void)
 	}
 }
 
+void dsp56k_disasm_force_reg_changed(int num_dsp_reg)
+{
+	registers_changed[num_dsp_reg]=1;
+}
+
+static Uint32 read_memory(Uint32 currPc)
+{
+	Uint32 value;
+
+	if (currPc<0x200) {
+		value = dsp_core->ramint[DSP_SPACE_P][currPc];
+	} else {
+		value = dsp_core->ram[DSP_SPACE_P][currPc & (DSP_RAMSIZE-1)];
+	}
+
+	return value & BITMASK(24);
+}
+
 /**********************************
  *	Conditions code calculation
  **********************************/
 
-static void dsp_calc_cc(uint32 cc_mode, char *dest)
+static void dsp_calc_cc(Uint32 cc_mode, char *dest)
 {
 	strcpy(dest, cc_name[cc_mode & BITMASK(4)]);
 }
@@ -701,7 +721,7 @@ static void dsp_calc_cc(uint32 cc_mode,
  *	Effective address calculation
  **********************************/
 
-static int dsp_calc_ea(uint32 ea_mode, char *dest)
+static int dsp_calc_ea(Uint32 ea_mode, char *dest)
 {
 	int value, retour, numreg;
 
@@ -746,11 +766,11 @@ static int dsp_calc_ea(uint32 ea_mode, c
 			switch ((ea_mode >> 2) & 1) {
 				case 0:
 					/* Absolute address */
-					sprintf(dest, ea_names[value], dsp_ram[DSP_SPACE_P][dsp_pc+1]);
+					sprintf(dest, ea_names[value], read_memory(dsp_core->pc+1));
 					break;
 				case 1:
 					/* Immediate value */
-					sprintf(dest, ea_names[8], dsp_ram[DSP_SPACE_P][dsp_pc+1]);
+					sprintf(dest, ea_names[8], read_memory(dsp_core->pc+1));
 					retour = 1;
 					break;
 			}
@@ -761,7 +781,7 @@ static int dsp_calc_ea(uint32 ea_mode, c
 
 static void opcode8h_0(void)
 {
-	uint32 value;
+	Uint32 value;
 
 	if (cur_inst <= 0x00008c) {
 		switch(cur_inst) {
@@ -841,7 +861,7 @@ static void opcode8h_6(void)
 
 static void opcode8h_8(void)
 {
-	uint32 value;
+	Uint32 value;
 
 	value = (cur_inst >> 12) & BITMASK(4);
 	opcodes_0809[value]();
@@ -849,7 +869,7 @@ static void opcode8h_8(void)
 
 static void opcode8h_a(void)
 {
-	uint32 value;
+	Uint32 value;
 	
 	value = (cur_inst >> 11) & (BITMASK(2)<<3);
 	value |= (cur_inst >> 5) & BITMASK(3);
@@ -859,7 +879,7 @@ static void opcode8h_a(void)
 
 static void opcode8h_b(void)
 {
-	uint32 value;
+	Uint32 value;
 	
 	value = (cur_inst >> 11) & (BITMASK(2)<<3);
 	value |= (cur_inst >> 5) & BITMASK(3);
@@ -873,7 +893,7 @@ static void opcode8h_b(void)
 
 static void dsp_undefined(void)
 {
-	fprintf(stderr,"Dsp: 0x%04x: 0x%06x unknown instruction\n",dsp_pc, cur_inst);
+	fprintf(stderr,"Dsp: 0x%04x: 0x%06x unknown instruction\n",dsp_core->pc, cur_inst);
 }
 
 static void dsp_andi(void)
@@ -898,8 +918,10 @@ static void dsp_andi(void)
 			break;
 	}
 
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: andi #0x%02x,%s\n",
-		dsp_pc,
+		dsp_core->pc,
 		(cur_inst>>8) & BITMASK(8),
 		regname
 	);
@@ -908,7 +930,7 @@ static void dsp_andi(void)
 static void dsp_bchg(void)
 {
 	char name[16], addr_name[16];
-	uint32 memspace, value, numbit;
+	Uint32 memspace, value, numbit;
 	
 	memspace = (cur_inst>>6) & 1;
 	value = (cur_inst>>8) & BITMASK(6);
@@ -950,13 +972,15 @@ static void dsp_bchg(void)
 			break;
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: bchg #%d,%s\n",dsp_pc, numbit, name);
+	registers_changed[DSP_REG_SR]=1;
+
+	fprintf(stderr,"Dsp: 0x%04x: bchg #%d,%s\n",dsp_core->pc, numbit, name);
 }
 
 static void dsp_bclr(void)
 {
 	char name[16], addr_name[16];
-	uint32 memspace, value, numbit;
+	Uint32 memspace, value, numbit;
 	
 	memspace = (cur_inst>>6) & 1;
 	value = (cur_inst>>8) & BITMASK(6);
@@ -998,13 +1022,15 @@ static void dsp_bclr(void)
 			break;
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: bclr #%d,%s\n",dsp_pc, numbit, name);
+	registers_changed[DSP_REG_SR]=1;
+
+	fprintf(stderr,"Dsp: 0x%04x: bclr #%d,%s\n",dsp_core->pc, numbit, name);
 }
 
 static void dsp_bset(void)
 {
 	char name[16], addr_name[16];
-	uint32 memspace, value, numbit;
+	Uint32 memspace, value, numbit;
 	
 	memspace = (cur_inst>>6) & 1;
 	value = (cur_inst>>8) & BITMASK(6);
@@ -1046,13 +1072,15 @@ static void dsp_bset(void)
 			break;
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: bset #%d,%s\n",dsp_pc, numbit, name);
+	registers_changed[DSP_REG_SR]=1;
+
+	fprintf(stderr,"Dsp: 0x%04x: bset #%d,%s\n",dsp_core->pc, numbit, name);
 }
 
 static void dsp_btst(void)
 {
 	char name[16], addr_name[16];
-	uint32 memspace, value, numbit;
+	Uint32 memspace, value, numbit;
 	
 	memspace = (cur_inst>>6) & 1;
 	value = (cur_inst>>8) & BITMASK(6);
@@ -1094,12 +1122,14 @@ static void dsp_btst(void)
 			break;
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: btst #%d,%s\n",dsp_pc, numbit, name);
+	registers_changed[DSP_REG_SR]=1;
+
+	fprintf(stderr,"Dsp: 0x%04x: btst #%d,%s\n",dsp_core->pc, numbit, name);
 }
 
 static void dsp_div(void)
 {
-	uint32 srcreg=DSP_REG_NULL, destreg;
+	Uint32 srcreg=DSP_REG_NULL, destreg;
 	
 	switch((cur_inst>>4) & BITMASK(2)) {
 		case 0:
@@ -1117,13 +1147,14 @@ static void dsp_div(void)
 	}
 	destreg = DSP_REG_A+((cur_inst>>3) & 1);
 	registers_changed[destreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
-	fprintf(stderr,"Dsp: 0x%04x: div %s,%s\n",dsp_pc, registers_name[srcreg],registers_name[destreg]);
+	fprintf(stderr,"Dsp: 0x%04x: div %s,%s\n",dsp_core->pc, registers_name[srcreg],registers_name[destreg]);
 }
 
 static void dsp_do(void)
 {
-	uint32 value;
+	Uint32 value;
 
 	value = (cur_inst>>12) & (BITMASK(2)<<2);
 	value |= (cur_inst>>6) & 1<<1;
@@ -1133,6 +1164,7 @@ static void dsp_do(void)
 	
 	registers_changed[DSP_REG_LA]=1;
 	registers_changed[DSP_REG_LC]=1;
+	registers_changed[DSP_REG_SR]=1;
 }
 
 static void dsp_do_0(void)
@@ -1146,25 +1178,25 @@ static void dsp_do_0(void)
 	}
 
 	fprintf(stderr,"Dsp: 0x%04x: do %s,p:0x%04x\n",
-		dsp_pc,
+		dsp_core->pc,
 		name,
-		dsp_ram[DSP_SPACE_P][dsp_pc+1] & BITMASK(16)
+		read_memory(dsp_core->pc+1)
 	);
 }
 
 static void dsp_do_2(void)
 {
 	fprintf(stderr,"Dsp: 0x%04x: do #0x%04x,p:0x%04x\n",
-		dsp_pc,
+		dsp_core->pc,
 		((cur_inst>>8) & BITMASK(8))|((cur_inst & BITMASK(4))<<8),
-		dsp_ram[DSP_SPACE_P][dsp_pc+1] & BITMASK(16)
+		read_memory(dsp_core->pc+1)
 	);
 }
 
 static void dsp_do_4(void)
 {
 	char addr_name[16], name[16];
-	uint32 ea_mode;
+	Uint32 ea_mode;
 	
 	ea_mode = (cur_inst>>8) & BITMASK(6);
 	dsp_calc_ea(ea_mode, addr_name);
@@ -1176,35 +1208,35 @@ static void dsp_do_4(void)
 	}
 
 	fprintf(stderr,"Dsp: 0x%04x: do %s,p:0x%04x\n", 
-		dsp_pc,
+		dsp_core->pc,
 		name,
-		dsp_ram[DSP_SPACE_P][dsp_pc+1] & BITMASK(16)
+		read_memory(dsp_core->pc+1)
 	);
 }
 
 static void dsp_do_c(void)
 {
 	fprintf(stderr,"Dsp: 0x%04x: do %s,p:0x%04x\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[(cur_inst>>8) & BITMASK(6)],
-		dsp_ram[DSP_SPACE_P][dsp_pc+1] & BITMASK(16)
+		read_memory(dsp_core->pc+1)
 	);
 }
 
 static void dsp_enddo(void)
 {
-	fprintf(stderr,"Dsp: 0x%04x: enddo\n",dsp_pc);
+	fprintf(stderr,"Dsp: 0x%04x: enddo\n",dsp_core->pc);
 }
 
 static void dsp_illegal(void)
 {
-	fprintf(stderr,"Dsp: 0x%04x: illegal\n",dsp_pc);
+	fprintf(stderr,"Dsp: 0x%04x: illegal\n",dsp_core->pc);
 }
 
 static void dsp_jcc(void)
 {
 	char cond_name[16], addr_name[16];
-	uint32 cc_code=0;
+	Uint32 cc_code=0;
 	
 	switch((cur_inst >> 16) & BITMASK(8)) {
 		case 0x0a:
@@ -1218,13 +1250,13 @@ static void dsp_jcc(void)
 	}
 	dsp_calc_cc(cc_code, cond_name);	
 
-	fprintf(stderr,"Dsp: 0x%04x: j%s p:%s\n",dsp_pc, cond_name, addr_name);
+	fprintf(stderr,"Dsp: 0x%04x: j%s p:%s\n",dsp_core->pc, cond_name, addr_name);
 }
 
 static void dsp_jclr(void)
 {
 	char srcname[16], addr_name[16];
-	uint32 memspace, value, numbit;
+	Uint32 memspace, value, numbit;
 	
 	memspace = (cur_inst>>6) & 1;
 	value = (cur_inst>>8) & BITMASK(6);
@@ -1267,10 +1299,10 @@ static void dsp_jclr(void)
 	}
 
 	fprintf(stderr,"Dsp: 0x%04x: jclr #%d,%s,p:0x%04x\n",
-		dsp_pc,
+		dsp_core->pc,
 		numbit,
 		srcname,
-		dsp_ram[DSP_SPACE_P][dsp_pc+1]
+		read_memory(dsp_core->pc+1)
 	);
 }
 
@@ -1287,13 +1319,13 @@ static void dsp_jmp(void)
 			break;
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: jmp p:%s\n",dsp_pc, dstname);
+	fprintf(stderr,"Dsp: 0x%04x: jmp p:%s\n",dsp_core->pc, dstname);
 }
 
 static void dsp_jscc(void)
 {
 	char cond_name[16], addr_name[16];
-	uint32 cc_code=0;
+	Uint32 cc_code=0;
 	
 	switch((cur_inst >> 16) & BITMASK(8)) {
 		case 0x0b:
@@ -1307,13 +1339,13 @@ static void dsp_jscc(void)
 	}
 	dsp_calc_cc(cc_code, cond_name);	
 
-	fprintf(stderr,"Dsp: 0x%04x: js%s p:%s\n",dsp_pc, cond_name, addr_name);
+	fprintf(stderr,"Dsp: 0x%04x: js%s p:%s\n",dsp_core->pc, cond_name, addr_name);
 }
 	
 static void dsp_jsclr(void)
 {
 	char srcname[16], addr_name[16];
-	uint32 memspace, value, numbit;
+	Uint32 memspace, value, numbit;
 	
 	memspace = (cur_inst>>6) & 1;
 	value = (cur_inst>>8) & BITMASK(6);
@@ -1356,17 +1388,17 @@ static void dsp_jsclr(void)
 	}
 
 	fprintf(stderr,"Dsp: 0x%04x: jsclr #%d,%s,p:0x%04x\n",
-		dsp_pc,
+		dsp_core->pc,
 		numbit,
 		srcname,
-		dsp_ram[DSP_SPACE_P][dsp_pc+1]
+		read_memory(dsp_core->pc+1)
 	);
 }
 
 static void dsp_jset(void)
 {
 	char srcname[16], addr_name[16];
-	uint32 memspace, value, numbit;
+	Uint32 memspace, value, numbit;
 	
 	memspace = (cur_inst>>6) & 1;
 	value = (cur_inst>>8) & BITMASK(6);
@@ -1409,10 +1441,10 @@ static void dsp_jset(void)
 	}
 
 	fprintf(stderr,"Dsp: 0x%04x: jset #%d,%s,p:0x%04x\n",
-		dsp_pc,
+		dsp_core->pc,
 		numbit,
 		srcname,
-		dsp_ram[DSP_SPACE_P][dsp_pc+1]
+		read_memory(dsp_core->pc+1)
 	);
 }
 
@@ -1426,13 +1458,13 @@ static void dsp_jsr(void)
 		dsp_calc_ea((cur_inst>>8) & BITMASK(6),dstname);
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: jsr p:%s\n",dsp_pc, dstname);
+	fprintf(stderr,"Dsp: 0x%04x: jsr p:%s\n",dsp_core->pc, dstname);
 }
 
 static void dsp_jsset(void)
 {
 	char srcname[16], addr_name[16];
-	uint32 memspace, value, numbit;
+	Uint32 memspace, value, numbit;
 	
 	memspace = (cur_inst>>6) & 1;
 	value = (cur_inst>>8) & BITMASK(6);
@@ -1475,10 +1507,10 @@ static void dsp_jsset(void)
 	}
 
 	fprintf(stderr,"Dsp: 0x%04x: jsset #%d,%s,p:0x%04x\n",
-		dsp_pc,
+		dsp_core->pc,
 		numbit,
 		srcname,
-		dsp_ram[DSP_SPACE_P][dsp_pc+1]
+		read_memory(dsp_core->pc+1)
 	);
 }
 
@@ -1490,12 +1522,12 @@ static void dsp_lua(void)
 	numreg = cur_inst & BITMASK(3);
 	registers_changed[DSP_REG_R0+numreg]=1;
 	
-	fprintf(stderr,"Dsp: 0x%04x: lua %s,r%d\n",dsp_pc, addr_name, numreg);
+	fprintf(stderr,"Dsp: 0x%04x: lua %s,r%d\n",dsp_core->pc, addr_name, numreg);
 }
 
 static void dsp_movec(void)
 {
-	uint32 value;
+	Uint32 value;
 	
 	value = (cur_inst>>13) & (1<<3);
 	value |= (cur_inst>>12) & (1<<2);
@@ -1503,11 +1535,13 @@ static void dsp_movec(void)
 	value |= (cur_inst>>5) & 1;
 
 	opcodes_movec[value]();
+
+	registers_changed[DSP_REG_SR]=1;
 }
 
 static void dsp_movec_7(void)
 {
-	uint32 numreg1, numreg2;
+	Uint32 numreg1, numreg2;
 
 	/* S1,D2 */
 	/* S2,D1 */
@@ -1517,11 +1551,11 @@ static void dsp_movec_7(void)
 
 	if (cur_inst & (1<<15)) {
 		/* Write D1 */
-		fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_pc, registers_name[numreg2], registers_name[numreg1]);
+		fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_core->pc, registers_name[numreg2], registers_name[numreg1]);
 		registers_changed[numreg1]=1;
 	} else {
 		/* Read S1 */
-		fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_pc, registers_name[numreg1], registers_name[numreg2]);
+		fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_core->pc, registers_name[numreg1], registers_name[numreg2]);
 		registers_changed[numreg2]=1;
 	}
 }
@@ -1530,7 +1564,7 @@ static void dsp_movec_9(void)
 {
 	const char *spacename;
 	char srcname[16],dstname[16];
-	uint32 numreg, addr;
+	Uint32 numreg, addr;
 
 	/* x:aa,D1 */
 	/* S1,x:aa */
@@ -1556,26 +1590,26 @@ static void dsp_movec_9(void)
 		sprintf(dstname, "%s:0x%04x", spacename, addr);
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_pc, srcname, dstname);
+	fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_core->pc, srcname, dstname);
 }
 
 static void dsp_movec_b(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	/* #xx,D1 */
 
 	numreg = (cur_inst & BITMASK(5))|0x20;
 
 	registers_changed[numreg]=1;
-	fprintf(stderr,"Dsp: 0x%04x: movec #0x%02x,%s\n",dsp_pc, (cur_inst>>8) & BITMASK(8), registers_name[numreg]);
+	fprintf(stderr,"Dsp: 0x%04x: movec #0x%02x,%s\n",dsp_core->pc, (cur_inst>>8) & BITMASK(8), registers_name[numreg]);
 }
 
 static void dsp_movec_d(void)
 {
 	const char *spacename;
 	char srcname[16], dstname[16], addr_name[16];
-	uint32 numreg, ea_mode;
+	Uint32 numreg, ea_mode;
 	int retour;
 
 	/* x:ea,D1 */
@@ -1609,13 +1643,13 @@ static void dsp_movec_d(void)
 		sprintf(dstname, "%s:%s", spacename, addr_name);
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_pc, srcname, dstname);
+	fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_core->pc, srcname, dstname);
 }
 
 static void dsp_movem(void)
 {
 	char addr_name[16], srcname[16], dstname[16];
-	uint32 ea_mode, numreg;
+	Uint32 ea_mode, numreg;
 
 	if (cur_inst & (1<<14)) {
 		/* S,p:ea */
@@ -1642,22 +1676,25 @@ static void dsp_movem(void)
 		sprintf(dstname, "p:%s", addr_name);
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: movem %s,%s\n",dsp_pc, srcname, dstname);
+	registers_changed[DSP_REG_SR]=1;
+
+	fprintf(stderr,"Dsp: 0x%04x: movem %s,%s\n",dsp_core->pc, srcname, dstname);
 }
 
 static void dsp_movep(void)
 {
-	uint32 value;
+	Uint32 value;
 	
 	value = (cur_inst>>6) & BITMASK(2);
 
 	opcodes_movep[value]();
+	registers_changed[DSP_REG_SR]=1;
 }
 
 static void dsp_movep_0(void)
 {
 	char srcname[16]="",dstname[16]="";
-	uint32 addr, memspace, numreg;
+	Uint32 addr, memspace, numreg;
 
 	/* S,x:pp */
 	/* x:pp,D */
@@ -1691,13 +1728,13 @@ static void dsp_movep_0(void)
 		strcpy(dstname, registers_name[numreg]);
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_pc, srcname, dstname);
+	fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_core->pc, srcname, dstname);
 }
 
 static void dsp_movep_1(void)
 {
 	char srcname[16]="",dstname[16]="",name[16]="";
-	uint32 addr, memspace; 
+	Uint32 addr, memspace; 
 
 	/* p:ea,x:pp */
 	/* x:pp,p:ea */
@@ -1730,13 +1767,13 @@ static void dsp_movep_1(void)
 		sprintf(dstname, "p:%s", name);
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_pc, srcname, dstname);
+	fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_core->pc, srcname, dstname);
 }
 
 static void dsp_movep_2(void)
 {
 	char srcname[16]="",dstname[16]="",name[16]="";
-	uint32 addr, memspace, easpace, retour; 
+	Uint32 addr, memspace, easpace, retour; 
 
 	/* x:ea,x:pp */
 	/* y:ea,x:pp */
@@ -1789,25 +1826,26 @@ static void dsp_movep_2(void)
 		}
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_pc, srcname, dstname);
+	fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_core->pc, srcname, dstname);
 }
 
 static void dsp_nop(void)
 {
-	fprintf(stderr,"Dsp: 0x%04x: nop\n",dsp_pc);
+	fprintf(stderr,"Dsp: 0x%04x: nop\n",dsp_core->pc);
 }
 
 static void dsp_norm(void)
 {
-	uint32 srcreg, destreg;
+	Uint32 srcreg, destreg;
 
 	srcreg = DSP_REG_R0+((cur_inst>>8) & BITMASK(3));
 	destreg = DSP_REG_A+((cur_inst>>3) & 1);
 
 	registers_changed[srcreg]=1;
 	registers_changed[destreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
-	fprintf(stderr,"Dsp: 0x%04x: norm %s,%s\n",dsp_pc, registers_name[srcreg], registers_name[destreg]);
+	fprintf(stderr,"Dsp: 0x%04x: norm %s,%s\n",dsp_core->pc, registers_name[srcreg], registers_name[destreg]);
 }
 
 static void dsp_ori(void)
@@ -1832,8 +1870,10 @@ static void dsp_ori(void)
 			break;
 	}
 
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: ori #0x%02x,%s\n",
-		dsp_pc,
+		dsp_core->pc,
 		(cur_inst>>8) & BITMASK(8),
 		regname
 	);
@@ -1841,7 +1881,7 @@ static void dsp_ori(void)
 
 static void dsp_rep(void)
 {
-	uint32 value;
+	Uint32 value;
 
 	value = (cur_inst>>12) & (BITMASK(2)<<2);
 	value |= (cur_inst>>6) & (1<<1);
@@ -1849,8 +1889,8 @@ static void dsp_rep(void)
 
 	opcodes_rep[value]();
 
-	registers_changed[DSP_REG_LA]=1;
 	registers_changed[DSP_REG_LC]=1;
+	registers_changed[DSP_REG_SR]=1;
 }
 
 static void dsp_rep_1(void)
@@ -1866,13 +1906,13 @@ static void dsp_rep_1(void)
 		sprintf(name, "x:0x%04x",(cur_inst>>8) & BITMASK(6));
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_pc, name);
+	fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_core->pc, name);
 }
 
 static void dsp_rep_3(void)
 {
 	/* #xxx */
-	fprintf(stderr,"Dsp: 0x%04x: rep #0x%02x\n",dsp_pc, (cur_inst>>8) & BITMASK(8));
+	fprintf(stderr,"Dsp: 0x%04x: rep #0x%02x\n",dsp_core->pc, (cur_inst>>8) & BITMASK(8));
 }
 
 static void dsp_rep_5(void)
@@ -1889,49 +1929,51 @@ static void dsp_rep_5(void)
 		sprintf(name, "x:%s",addr_name);
 	}
 
-	fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_pc, name);
+	fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_core->pc, name);
 }
 
 static void dsp_rep_d(void)
 {
 	/* R */
 
-	fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_pc, registers_name[(cur_inst>>8) & BITMASK(6)]);
+	fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_core->pc, registers_name[(cur_inst>>8) & BITMASK(6)]);
 }
 
 static void dsp_reset(void)
 {
-	fprintf(stderr,"Dsp: 0x%04x: reset\n",dsp_pc);
+	fprintf(stderr,"Dsp: 0x%04x: reset\n",dsp_core->pc);
 }
 
 static void dsp_rti(void)
 {
-	fprintf(stderr,"Dsp: 0x%04x: rti\n",dsp_pc);
+	registers_changed[DSP_REG_SR]=1;
+	fprintf(stderr,"Dsp: 0x%04x: rti\n",dsp_core->pc);
 }
 
 static void dsp_rts(void)
 {
-	fprintf(stderr,"Dsp: 0x%04x: rts\n",dsp_pc);
+	registers_changed[DSP_REG_SR]=1;
+	fprintf(stderr,"Dsp: 0x%04x: rts\n",dsp_core->pc);
 }
 
 static void dsp_stop(void)
 {
-	fprintf(stderr,"Dsp: 0x%04x: stop\n",dsp_pc);
+	fprintf(stderr,"Dsp: 0x%04x: stop\n",dsp_core->pc);
 }
 	
 static void dsp_swi(void)
 {
-	fprintf(stderr,"Dsp: 0x%04x: swi\n",dsp_pc);
+	fprintf(stderr,"Dsp: 0x%04x: swi\n",dsp_core->pc);
 }
 
 static void dsp_tcc(void)
 {
 	char ccname[16];
-	uint32 src1reg, dst1reg, src2reg, dst2reg;
+	Uint32 src1reg, dst1reg, src2reg, dst2reg;
 
 	dsp_calc_cc((cur_inst>>12) & BITMASK(4), ccname);
 	src1reg = registers_tcc[(cur_inst>>3) & BITMASK(4)][0];
-	dst1reg = registers_tcc[(cur_inst>>3) & BITMASK(4)][0];
+	dst1reg = registers_tcc[(cur_inst>>3) & BITMASK(4)][1];
 
 	registers_changed[dst1reg]=1;
 	if (cur_inst & (1<<16)) {
@@ -1940,7 +1982,7 @@ static void dsp_tcc(void)
 
 		registers_changed[dst2reg]=1;
 		fprintf(stderr,"Dsp: 0x%04x: t%s %s,%s %s,%s\n",
-			dsp_pc,
+			dsp_core->pc,
 			ccname,
 			registers_name[src1reg],
 			registers_name[dst1reg],
@@ -1949,7 +1991,7 @@ static void dsp_tcc(void)
 		);
 	} else {
 		fprintf(stderr,"Dsp: 0x%04x: t%s %s,%s\n",
-			dsp_pc,
+			dsp_core->pc,
 			ccname,
 			registers_name[src1reg],
 			registers_name[dst1reg]
@@ -1959,7 +2001,7 @@ static void dsp_tcc(void)
 
 static void dsp_wait(void)
 {
-	fprintf(stderr,"Dsp: 0x%04x: wait\n",dsp_pc);
+	fprintf(stderr,"Dsp: 0x%04x: wait\n",dsp_core->pc);
 }
 
 /**********************************
@@ -1968,7 +2010,7 @@ static void dsp_wait(void)
 
 static void dsp_pm(void)
 {
-	uint32 value;
+	Uint32 value;
 
 	value = (cur_inst >> 20) & BITMASK(4);
 
@@ -1978,7 +2020,7 @@ static void dsp_pm(void)
 static void dsp_pm_0(void)
 {
 	char space_name[16], addr_name[16];
-	uint32 memspace, numreg1, numreg2;
+	Uint32 memspace, numreg1, numreg2;
 /*
 	0000 100d 00mm mrrr S,x:ea	x0,D
 	0000 100d 10mm mrrr S,y:ea	y0,D
@@ -2019,7 +2061,7 @@ static void dsp_pm_1(void)
 */
 
 	char addr_name[16];
-	uint32 memspace, write_flag, retour, s1reg, s2reg, d1reg, d2reg;
+	Uint32 memspace, write_flag, retour, s1reg, s2reg, d1reg, d2reg;
 
 	memspace = (cur_inst>>14) & 1;
 	write_flag = (cur_inst>>15) & 1;
@@ -2119,7 +2161,7 @@ static void dsp_pm_1(void)
 static void dsp_pm_2(void)
 {
 	char addr_name[16];
-	uint32 numreg1, numreg2;
+	Uint32 numreg1, numreg2;
 /*
 	0010 0000 0000 0000 nop
 	0010 0000 010m mrrr R update
@@ -2153,7 +2195,7 @@ static void dsp_pm_2(void)
 static void dsp_pm_4(void)
 {
 	char addr_name[16];
-	uint32 value, retour, ea_mode, memspace;
+	Uint32 value, retour, ea_mode, memspace;
 /*
 	0100 l0ll w0aa aaaa l:aa,D
 						S,l:aa
@@ -2180,7 +2222,7 @@ static void dsp_pm_4(void)
 		if (cur_inst & (1<<14)) {
 			retour = dsp_calc_ea(ea_mode, addr_name);	
 		} else {
-			sprintf(addr_name,"0x%04x", value);
+			sprintf(addr_name,"0x%04x", ea_mode);
 			retour = 0;
 		}
 
@@ -2252,7 +2294,7 @@ static void dsp_pm_4(void)
 static void dsp_pm_8(void)
 {
 	char addr1_name[16], addr2_name[16];
-	uint32 ea_mode1, ea_mode2, numreg1, numreg2;
+	Uint32 ea_mode1, ea_mode2, numreg1, numreg2;
 /*
 	1wmm eeff WrrM MRRR x:ea,D1		y:ea,D2	
 						x:ea,D1		S2,y:ea
@@ -2336,13 +2378,15 @@ static void dsp_pm_8(void)
 
 static void dsp_abs(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 	
 	numreg = DSP_REG_A+((cur_inst>>3) & 1);
 
 	registers_changed[numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: abs %s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[numreg],
 		parallelmove_name
 	);
@@ -2351,7 +2395,7 @@ static void dsp_abs(void)
 static void dsp_adc(void)
 {
 	const char *srcname;
-	uint32 numreg;
+	Uint32 numreg;
 
 	if (cur_inst & (1<<4)) {
 		srcname="y";
@@ -2361,9 +2405,10 @@ static void dsp_adc(void)
 
 	numreg=DSP_REG_A+((cur_inst>>3) & 1);
 	registers_changed[numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: adc %s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		srcname,
 		registers_name[numreg],
 		parallelmove_name
@@ -2373,7 +2418,7 @@ static void dsp_adc(void)
 static void dsp_add(void)
 {
 	const char *srcname;
-	uint32 srcreg, dstreg;
+	Uint32 srcreg, dstreg;
 	
 	srcreg = (cur_inst>>4) & BITMASK(3);
 	dstreg = (cur_inst>>3) & 1;
@@ -2389,11 +2434,17 @@ static void dsp_add(void)
 		case 3:
 			srcname="y";
 			break;
-		case DSP_REG_X0:
-		case DSP_REG_X1:
-		case DSP_REG_Y0:
-		case DSP_REG_Y1:
-			srcname=registers_name[srcreg];
+		case 4:
+			srcname=registers_name[DSP_REG_X0];
+			break;
+		case 5:
+			srcname=registers_name[DSP_REG_Y0];
+			break;
+		case 6:
+			srcname=registers_name[DSP_REG_X1];
+			break;
+		case 7:
+			srcname=registers_name[DSP_REG_Y1];
 			break;
 		default:
 			srcname="";
@@ -2401,8 +2452,10 @@ static void dsp_add(void)
 	}
 
 	registers_changed[DSP_REG_A+dstreg]=1;
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: add %s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		srcname,
 		registers_name[DSP_REG_A+dstreg],
 		parallelmove_name
@@ -2411,13 +2464,15 @@ static void dsp_add(void)
 
 static void dsp_addl(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = (cur_inst>>3) & 1;
 
 	registers_changed[DSP_REG_A+numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: addl %s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[DSP_REG_A+(numreg ^ 1)],
 		registers_name[DSP_REG_A+numreg],
 		parallelmove_name
@@ -2426,13 +2481,15 @@ static void dsp_addl(void)
 
 static void dsp_addr(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = (cur_inst>>3) & 1;
 
 	registers_changed[DSP_REG_A+numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: addr %s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[DSP_REG_A+(numreg ^ 1)],
 		registers_name[DSP_REG_A+numreg],
 		parallelmove_name
@@ -2441,30 +2498,46 @@ static void dsp_addr(void)
 
 static void dsp_and(void)
 {
-	uint32 numreg;
+	Uint32 srcreg,dstreg;
 
-	numreg = DSP_REG_A+((cur_inst>>3) & 1);
+	switch((cur_inst>>4) & BITMASK(2)) {
+		case 1:
+			srcreg=DSP_REG_Y0;
+			break;
+		case 2:
+			srcreg=DSP_REG_X1;
+			break;
+		case 3:
+			srcreg=DSP_REG_Y1;
+			break;
+		case 0:
+		default:
+			srcreg=DSP_REG_X0;
+	}
+	dstreg = DSP_REG_A+((cur_inst>>3) & 1);
 
-	registers_changed[numreg]=1;
+	registers_changed[dstreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: and %s,%s %s\n",
-		dsp_pc,
-		registers_name[DSP_REG_X0+((cur_inst>>4) & BITMASK(2))],
-		registers_name[numreg],
+		dsp_core->pc,
+		registers_name[srcreg],
+		registers_name[dstreg],
 		parallelmove_name
 	);
 }
 
 static void dsp_asl(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = DSP_REG_A+((cur_inst>>3) & 1);
 
 	registers_changed[numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: asl %s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[numreg],
 		parallelmove_name
 	);
@@ -2472,14 +2545,15 @@ static void dsp_asl(void)
 
 static void dsp_asr(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = DSP_REG_A+((cur_inst>>3) & 1);
 
 	registers_changed[numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: asr %s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[numreg],
 		parallelmove_name
 	);
@@ -2487,14 +2561,15 @@ static void dsp_asr(void)
 
 static void dsp_clr(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = DSP_REG_A+((cur_inst>>3) & 1);
 
 	registers_changed[numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: clr %s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[numreg],
 		parallelmove_name
 	);
@@ -2502,7 +2577,7 @@ static void dsp_clr(void)
 
 static void dsp_cmp(void)
 {
-	uint32 srcreg, dstreg;
+	Uint32 srcreg, dstreg;
 	
 	srcreg = (cur_inst>>4) & BITMASK(3);
 	dstreg = (cur_inst>>3) & 1;
@@ -2525,8 +2600,10 @@ static void dsp_cmp(void)
 			break;
 	}
 
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: cmp %s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[srcreg],
 		registers_name[DSP_REG_A+dstreg],
 		parallelmove_name
@@ -2535,7 +2612,7 @@ static void dsp_cmp(void)
 
 static void dsp_cmpm(void)
 {
-	uint32 srcreg, dstreg;
+	Uint32 srcreg, dstreg;
 	
 	srcreg = (cur_inst>>4) & BITMASK(3);
 	dstreg = (cur_inst>>3) & 1;
@@ -2558,8 +2635,10 @@ static void dsp_cmpm(void)
 			break;
 	}
 
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: cmpm %s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[srcreg],
 		registers_name[DSP_REG_A+dstreg],
 		parallelmove_name
@@ -2568,30 +2647,46 @@ static void dsp_cmpm(void)
 
 static void dsp_eor(void)
 {
-	uint32 numreg;
+	Uint32 srcreg, dstreg;
 
-	numreg = DSP_REG_A+((cur_inst>>3) & 1);
+	switch((cur_inst>>4) & BITMASK(2)) {
+		case 1:
+			srcreg=DSP_REG_Y0;
+			break;
+		case 2:
+			srcreg=DSP_REG_X1;
+			break;
+		case 3:
+			srcreg=DSP_REG_Y1;
+			break;
+		case 0:
+		default:
+			srcreg=DSP_REG_X0;
+	}
+	dstreg = DSP_REG_A+((cur_inst>>3) & 1);
 
-	registers_changed[numreg]=1;
+	registers_changed[dstreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: eor %s,%s %s\n",
-		dsp_pc,
-		registers_name[DSP_REG_X0+((cur_inst>>4) & BITMASK(2))],
-		registers_name[numreg],
+		dsp_core->pc,
+		registers_name[srcreg],
+		registers_name[dstreg],
 		parallelmove_name
 	);
 }
 
 static void dsp_lsl(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = DSP_REG_A+((cur_inst>>3) & 1);
 
 	registers_changed[numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: lsl %s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[numreg],
 		parallelmove_name
 	);
@@ -2599,14 +2694,15 @@ static void dsp_lsl(void)
 
 static void dsp_lsr(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = DSP_REG_A+((cur_inst>>3) & 1);
 
 	registers_changed[numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: lsr %s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[numreg],
 		parallelmove_name
 	);
@@ -2615,7 +2711,7 @@ static void dsp_lsr(void)
 static void dsp_mac(void)
 {
 	const char *sign_name;
-	uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
+	Uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
 
 	if (cur_inst & (1<<2)) {
 		sign_name="-";
@@ -2660,8 +2756,10 @@ static void dsp_mac(void)
 	dstreg = (cur_inst>>3) & 1;
 
 	registers_changed[DSP_REG_A+dstreg]=1;
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: mac %s%s,%s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		sign_name,
 		registers_name[src1reg],
 		registers_name[src2reg],
@@ -2673,7 +2771,7 @@ static void dsp_mac(void)
 static void dsp_macr(void)
 {
 	const char *sign_name;
-	uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
+	Uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
 
 	if (cur_inst & (1<<2)) {
 		sign_name="-";
@@ -2718,8 +2816,10 @@ static void dsp_macr(void)
 	dstreg = (cur_inst>>3) & 1;
 
 	registers_changed[DSP_REG_A+dstreg]=1;
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: macr %s%s,%s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		sign_name,
 		registers_name[src1reg],
 		registers_name[src2reg],
@@ -2730,19 +2830,19 @@ static void dsp_macr(void)
 
 static void dsp_move(void)
 {
-	fprintf(stderr,"Dsp: 0x%04x: move %s\n",dsp_pc, parallelmove_name);
+	fprintf(stderr,"Dsp: 0x%04x: move %s\n",dsp_core->pc, parallelmove_name);
 }
 
 static void dsp_move_nopm(void)
 {
 	dsp_pm();
-	fprintf(stderr,"Dsp: 0x%04x: move %s\n",dsp_pc, parallelmove_name);
+	fprintf(stderr,"Dsp: 0x%04x: move %s\n",dsp_core->pc, parallelmove_name);
 }
 
 static void dsp_mpy(void)
 {
 	const char *sign_name;
-	uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
+	Uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
 
 	if (cur_inst & (1<<2)) {
 		sign_name="-";
@@ -2787,8 +2887,10 @@ static void dsp_mpy(void)
 	dstreg = (cur_inst>>3) & 1;
 
 	registers_changed[DSP_REG_A+dstreg]=1;
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: mpy %s%s,%s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		sign_name,
 		registers_name[src1reg],
 		registers_name[src2reg],
@@ -2800,7 +2902,7 @@ static void dsp_mpy(void)
 static void dsp_mpyr(void)
 {
 	const char *sign_name;
-	uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
+	Uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
 
 	if (cur_inst & (1<<2)) {
 		sign_name="-";
@@ -2845,8 +2947,10 @@ static void dsp_mpyr(void)
 	dstreg = (cur_inst>>3) & 1;
 
 	registers_changed[DSP_REG_A+dstreg]=1;
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: mpyr %s%s,%s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		sign_name,
 		registers_name[src1reg],
 		registers_name[src2reg],
@@ -2857,14 +2961,15 @@ static void dsp_mpyr(void)
 
 static void dsp_neg(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = DSP_REG_A+((cur_inst>>3) & 1);
 
 	registers_changed[numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: neg %s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[numreg],
 		parallelmove_name
 	);
@@ -2872,14 +2977,15 @@ static void dsp_neg(void)
 
 static void dsp_not(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = DSP_REG_A+((cur_inst>>3) & 1);
 
 	registers_changed[numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: not %s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[numreg],
 		parallelmove_name
 	);
@@ -2887,30 +2993,46 @@ static void dsp_not(void)
 
 static void dsp_or(void)
 {
-	uint32 numreg;
+	Uint32 srcreg, dstreg;
 
-	numreg = DSP_REG_A+((cur_inst>>3) & 1);
+	switch((cur_inst>>4) & BITMASK(2)) {
+		case 1:
+			srcreg=DSP_REG_Y0;
+			break;
+		case 2:
+			srcreg=DSP_REG_X1;
+			break;
+		case 3:
+			srcreg=DSP_REG_Y1;
+			break;
+		case 0:
+		default:
+			srcreg=DSP_REG_X0;
+	}
+	dstreg = DSP_REG_A+((cur_inst>>3) & 1);
 
-	registers_changed[numreg]=1;
+	registers_changed[dstreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: or %s,%s %s\n",
-		dsp_pc,
-		registers_name[DSP_REG_X0+((cur_inst>>4) & BITMASK(2))],
-		registers_name[numreg],
+		dsp_core->pc,
+		registers_name[srcreg],
+		registers_name[dstreg],
 		parallelmove_name
 	);
 }
 
 static void dsp_rnd(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = DSP_REG_A+((cur_inst>>3) & 1);
 
 	registers_changed[numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: rnd %s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[numreg],
 		parallelmove_name
 	);
@@ -2918,14 +3040,15 @@ static void dsp_rnd(void)
 
 static void dsp_rol(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = DSP_REG_A+((cur_inst>>3) & 1);
 
 	registers_changed[numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: rol %s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[numreg],
 		parallelmove_name
 	);
@@ -2933,14 +3056,15 @@ static void dsp_rol(void)
 
 static void dsp_ror(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = DSP_REG_A+((cur_inst>>3) & 1);
 
 	registers_changed[numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: ror %s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[numreg],
 		parallelmove_name
 	);
@@ -2949,7 +3073,7 @@ static void dsp_ror(void)
 static void dsp_sbc(void)
 {
 	const char *srcname;
-	uint32 numreg;
+	Uint32 numreg;
 
 	if (cur_inst & (1<<4)) {
 		srcname="y";
@@ -2960,9 +3084,10 @@ static void dsp_sbc(void)
 	numreg = DSP_REG_A+((cur_inst>>3) & 1);
 
 	registers_changed[numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
 
 	fprintf(stderr,"Dsp: 0x%04x: sbc %s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		srcname,
 		registers_name[numreg],
 		parallelmove_name
@@ -2972,7 +3097,7 @@ static void dsp_sbc(void)
 static void dsp_sub(void)
 {
 	const char *srcname;
-	uint32 srcreg, dstreg;
+	Uint32 srcreg, dstreg;
 	
 	srcreg = (cur_inst>>4) & BITMASK(3);
 	dstreg = (cur_inst>>3) & 1;
@@ -2988,11 +3113,17 @@ static void dsp_sub(void)
 		case 3:
 			srcname="y";
 			break;
-		case DSP_REG_X0:
-		case DSP_REG_X1:
-		case DSP_REG_Y0:
-		case DSP_REG_Y1:
-			srcname=registers_name[srcreg];
+		case 4:
+			srcname=registers_name[DSP_REG_X0];
+			break;
+		case 5:
+			srcname=registers_name[DSP_REG_Y0];
+			break;
+		case 6:
+			srcname=registers_name[DSP_REG_X1];
+			break;
+		case 7:
+			srcname=registers_name[DSP_REG_Y1];
 			break;
 		default:
 			srcname="";
@@ -3000,8 +3131,10 @@ static void dsp_sub(void)
 	}
 
 	registers_changed[DSP_REG_A+dstreg]=1;
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: sub %s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		srcname,
 		registers_name[DSP_REG_A+dstreg],
 		parallelmove_name
@@ -3010,13 +3143,15 @@ static void dsp_sub(void)
 
 static void dsp_subl(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = (cur_inst>>3) & 1;
 
 	registers_changed[DSP_REG_A+numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: subl %s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[DSP_REG_A+(numreg ^ 1)],
 		registers_name[DSP_REG_A+numreg],
 		parallelmove_name
@@ -3025,13 +3160,15 @@ static void dsp_subl(void)
 
 static void dsp_subr(void)
 {
-	uint32 numreg;
+	Uint32 numreg;
 
 	numreg = (cur_inst>>3) & 1;
 
 	registers_changed[DSP_REG_A+numreg]=1;
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: subr %s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[DSP_REG_A+(numreg ^ 1)],
 		registers_name[DSP_REG_A+numreg],
 		parallelmove_name
@@ -3040,18 +3177,35 @@ static void dsp_subr(void)
 
 static void dsp_tfr(void)
 {
-	uint32 srcreg, dstreg;
+	Uint32 srcreg, dstreg;
 	
 	srcreg = (cur_inst>>4) & BITMASK(3);
 	dstreg = (cur_inst>>3) & 1;
 
-	if (srcreg==0) {
-		srcreg = DSP_REG_A+(dstreg ^ 1);
+	switch(srcreg) {
+		case 4:
+			srcreg = DSP_REG_X0;
+			break;
+		case 5:
+			srcreg = DSP_REG_Y0;
+			break;
+		case 6:
+			srcreg = DSP_REG_X1;
+			break;
+		case 7:
+			srcreg = DSP_REG_Y1;
+			break;
+		case 0:
+		default:
+			srcreg = DSP_REG_A+(dstreg ^ 1);
+			break;
 	}
 
 	registers_changed[DSP_REG_A+dstreg]=1;
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: tfr %s,%s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[srcreg],
 		registers_name[DSP_REG_A+dstreg],
 		parallelmove_name
@@ -3060,23 +3214,11 @@ static void dsp_tfr(void)
 
 static void dsp_tst(void)
 {
+	registers_changed[DSP_REG_SR]=1;
+
 	fprintf(stderr,"Dsp: 0x%04x: tst %s %s\n",
-		dsp_pc,
+		dsp_core->pc,
 		registers_name[DSP_REG_A+((cur_inst>>3) & 1)],
 		parallelmove_name
 	);
 }
-
-/*
-	2002-07-31:PM
-		BUG:pm_2 (register update) wrong calc of eamode
-	2002-07-30:PM
-		FIX:output registers that have been written to
-	2002-07-26:PM
-		BUG:added missing '\n' to disasm output
-	2002-07-22:PM
-		FIX:disasm output changed from D(bug()) to fprintf()
-	2002-07-19:PM
-		BUG:movec_b and movec_d operations permuted
-		BUG:pm_5: bad calc of address in [x|y]:aa addressing
-*/