lxdream.org :: lxdream/src/sh4/sh4core.c r732:f05753bbe723 (annotated)

tree revision 732:f05753bbe723

filename	src/sh4/sh4core.c
changeset	732:f05753bbe723
prev	671:a530ea88eebd
next	736:a02d1475ccfd
author	nkeynes
date	Thu Jul 10 01:46:00 2008 +0000 (15 years ago)
permissions	-rw-r--r--
last change	Fix alignment check for 64-bit FMOVs Add missing MMU code etc to FMOV emu implementation

file

annotate

diff

log

raw

nkeynes@23	1	/**
nkeynes@586	2	* $Id$
nkeynes@23	3	*
nkeynes@23	4	* SH4 emulation core, and parent module for all the SH4 peripheral
nkeynes@23	5	* modules.
nkeynes@23	6	*
nkeynes@23	7	* Copyright (c) 2005 Nathan Keynes.
nkeynes@23	8	*
nkeynes@23	9	* This program is free software; you can redistribute it and/or modify
nkeynes@23	10	* it under the terms of the GNU General Public License as published by
nkeynes@23	11	* the Free Software Foundation; either version 2 of the License, or
nkeynes@23	12	* (at your option) any later version.
nkeynes@23	13	*
nkeynes@23	14	* This program is distributed in the hope that it will be useful,
nkeynes@23	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
nkeynes@23	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
nkeynes@23	17	* GNU General Public License for more details.
nkeynes@23	18	*/
nkeynes@23	19
nkeynes@35	20	#define MODULE sh4_module
nkeynes@586	21	#include <assert.h>
nkeynes@1	22	#include <math.h>
nkeynes@1	23	#include "dream.h"
nkeynes@430	24	#include "dreamcast.h"
nkeynes@430	25	#include "eventq.h"
nkeynes@430	26	#include "mem.h"
nkeynes@430	27	#include "clock.h"
nkeynes@430	28	#include "syscall.h"
nkeynes@84	29	#include "sh4/sh4core.h"
nkeynes@84	30	#include "sh4/sh4mmio.h"
nkeynes@671	31	#include "sh4/sh4stat.h"
nkeynes@84	32	#include "sh4/intc.h"
nkeynes@1	33
nkeynes@157	34	#define SH4_CALLTRACE 1
nkeynes@157	35
nkeynes@123	36	#define MAX_INT 0x7FFFFFFF
nkeynes@123	37	#define MIN_INT 0x80000000
nkeynes@123	38	#define MAX_INTF 2147483647.0
nkeynes@123	39	#define MIN_INTF -2147483648.0
nkeynes@123	40
nkeynes@23	41	/******************** SH4 Module Definition **************************/
nkeynes@23	42
nkeynes@30	43	uint32_t sh4_run_slice( uint32_t nanosecs )
nkeynes@1	44	{
nkeynes@23	45	int i;
nkeynes@265	46	sh4r.slice_cycle = 0;
nkeynes@23	47
nkeynes@27	48	if( sh4r.sh4_state != SH4_STATE_RUNNING ) {
nkeynes@617	49	sh4_sleep_run_slice(nanosecs);
nkeynes@23	50	}
nkeynes@27	51
nkeynes@235	52	if( sh4_breakpoint_count == 0 ) {
nkeynes@265	53	for( ; sh4r.slice_cycle < nanosecs; sh4r.slice_cycle += sh4_cpu_period ) {
nkeynes@265	54	if( SH4_EVENT_PENDING() ) {
nkeynes@265	55	if( sh4r.event_types & PENDING_EVENT ) {
nkeynes@265	56	event_execute();
nkeynes@265	57	}
nkeynes@265	58	/* Eventq execute may (quite likely) deliver an immediate IRQ */
nkeynes@265	59	if( sh4r.event_types & PENDING_IRQ ) {
nkeynes@265	60	sh4_accept_interrupt();
nkeynes@265	61	}
nkeynes@265	62	}
nkeynes@235	63	if( !sh4_execute_instruction() ) {
nkeynes@43	64	break;
nkeynes@43	65	}
nkeynes@43	66	}
nkeynes@235	67	} else {
nkeynes@265	68	for( ;sh4r.slice_cycle < nanosecs; sh4r.slice_cycle += sh4_cpu_period ) {
nkeynes@265	69	if( SH4_EVENT_PENDING() ) {
nkeynes@265	70	if( sh4r.event_types & PENDING_EVENT ) {
nkeynes@265	71	event_execute();
nkeynes@265	72	}
nkeynes@265	73	/* Eventq execute may (quite likely) deliver an immediate IRQ */
nkeynes@265	74	if( sh4r.event_types & PENDING_IRQ ) {
nkeynes@265	75	sh4_accept_interrupt();
nkeynes@265	76	}
nkeynes@265	77	}
nkeynes@265	78
nkeynes@235	79	if( !sh4_execute_instruction() )
nkeynes@235	80	break;
nkeynes@235	81	#ifdef ENABLE_DEBUG_MODE
nkeynes@235	82	for( i=0; i<sh4_breakpoint_count; i++ ) {
nkeynes@235	83	if( sh4_breakpoints[i].address == sh4r.pc ) {
nkeynes@235	84	break;
nkeynes@235	85	}
nkeynes@235	86	}
nkeynes@235	87	if( i != sh4_breakpoint_count ) {
nkeynes@235	88	dreamcast_stop();
nkeynes@235	89	if( sh4_breakpoints[i].type == BREAK_ONESHOT )
nkeynes@235	90	sh4_clear_breakpoint( sh4r.pc, BREAK_ONESHOT );
nkeynes@235	91	break;
nkeynes@235	92	}
nkeynes@235	93	#endif
nkeynes@43	94	}
nkeynes@27	95	}
nkeynes@30	96
nkeynes@30	97	/* If we aborted early, but the cpu is still technically running,
nkeynes@30	98	* we're doing a hard abort - cut the timeslice back to what we
nkeynes@30	99	* actually executed
nkeynes@30	100	*/
nkeynes@53	101	if( sh4r.slice_cycle != nanosecs && sh4r.sh4_state == SH4_STATE_RUNNING ) {
nkeynes@53	102	nanosecs = sh4r.slice_cycle;
nkeynes@27	103	}
nkeynes@27	104	if( sh4r.sh4_state != SH4_STATE_STANDBY ) {
nkeynes@30	105	TMU_run_slice( nanosecs );
nkeynes@30	106	SCIF_run_slice( nanosecs );
nkeynes@27	107	}
nkeynes@30	108	return nanosecs;
nkeynes@1	109	}
nkeynes@1	110
nkeynes@23	111	/******************** SH4 emulation core **************************/
nkeynes@23	112
nkeynes@246	113	#define UNDEF(ir) return sh4_raise_slot_exception(EXC_ILLEGAL, EXC_SLOT_ILLEGAL)
nkeynes@27	114	#define UNIMP(ir) do{ ERROR( "Halted on unimplemented instruction at %08x, opcode = %04x", sh4r.pc, ir ); dreamcast_stop(); return FALSE; }while(0)
nkeynes@1	115
nkeynes@157	116	#if(SH4_CALLTRACE == 1)
nkeynes@157	117	#define MAX_CALLSTACK 32
nkeynes@157	118	static struct call_stack {
nkeynes@157	119	sh4addr_t call_addr;
nkeynes@157	120	sh4addr_t target_addr;
nkeynes@157	121	sh4addr_t stack_pointer;
nkeynes@157	122	} call_stack[MAX_CALLSTACK];
nkeynes@157	123
nkeynes@157	124	static int call_stack_depth = 0;
nkeynes@157	125	int sh4_call_trace_on = 0;
nkeynes@157	126
nkeynes@430	127	static inline void trace_call( sh4addr_t source, sh4addr_t dest )
nkeynes@157	128	{
nkeynes@157	129	if( call_stack_depth < MAX_CALLSTACK ) {
nkeynes@157	130	call_stack[call_stack_depth].call_addr = source;
nkeynes@157	131	call_stack[call_stack_depth].target_addr = dest;
nkeynes@157	132	call_stack[call_stack_depth].stack_pointer = sh4r.r[15];
nkeynes@157	133	}
nkeynes@157	134	call_stack_depth++;
nkeynes@157	135	}
nkeynes@157	136
nkeynes@430	137	static inline void trace_return( sh4addr_t source, sh4addr_t dest )
nkeynes@157	138	{
nkeynes@157	139	if( call_stack_depth > 0 ) {
nkeynes@157	140	call_stack_depth--;
nkeynes@157	141	}
nkeynes@157	142	}
nkeynes@157	143
nkeynes@157	144	void fprint_stack_trace( FILE *f )
nkeynes@157	145	{
nkeynes@157	146	int i = call_stack_depth -1;
nkeynes@157	147	if( i >= MAX_CALLSTACK )
nkeynes@157	148	i = MAX_CALLSTACK - 1;
nkeynes@157	149	for( ; i >= 0; i-- ) {
nkeynes@157	150	fprintf( f, "%d. Call from %08X => %08X, SP=%08X\n",
nkeynes@157	151	(call_stack_depth - i), call_stack[i].call_addr,
nkeynes@157	152	call_stack[i].target_addr, call_stack[i].stack_pointer );
nkeynes@157	153	}
nkeynes@157	154	}
nkeynes@157	155
nkeynes@157	156	#define TRACE_CALL( source, dest ) trace_call(source, dest)
nkeynes@157	157	#define TRACE_RETURN( source, dest ) trace_return(source, dest)
nkeynes@157	158	#else
nkeynes@157	159	#define TRACE_CALL( dest, rts )
nkeynes@157	160	#define TRACE_RETURN( source, dest )
nkeynes@157	161	#endif
nkeynes@157	162
nkeynes@732	163	#define CHECKPRIV() if( !IS_SH4_PRIVMODE() ) return sh4_raise_slot_exception( EXC_ILLEGAL, EXC_SLOT_ILLEGAL )
nkeynes@732	164	#define CHECKRALIGN16(addr) if( (addr)&0x01 ) return sh4_raise_exception( EXC_DATA_ADDR_READ )
nkeynes@732	165	#define CHECKRALIGN32(addr) if( (addr)&0x03 ) return sh4_raise_exception( EXC_DATA_ADDR_READ )
nkeynes@732	166	#define CHECKRALIGN64(addr) if( (addr)&0x07 ) return sh4_raise_exception( EXC_DATA_ADDR_READ )
nkeynes@732	167	#define CHECKWALIGN16(addr) if( (addr)&0x01 ) return sh4_raise_exception( EXC_DATA_ADDR_WRITE )
nkeynes@732	168	#define CHECKWALIGN32(addr) if( (addr)&0x03 ) return sh4_raise_exception( EXC_DATA_ADDR_WRITE )
nkeynes@732	169	#define CHECKWALIGN64(addr) if( (addr)&0x07 ) return sh4_raise_exception( EXC_DATA_ADDR_WRITE )
nkeynes@732	170
nkeynes@732	171	#define CHECKFPUEN() if( !IS_FPU_ENABLED() ) { if( ir == 0xFFFD ) { UNDEF(ir); } else { return sh4_raise_slot_exception( EXC_FPU_DISABLED, EXC_SLOT_FPU_DISABLED ); } }
nkeynes@732	172	#define CHECKDEST(p) if( (p) == 0 ) { ERROR( "%08X: Branch/jump to NULL, CPU halted", sh4r.pc ); dreamcast_stop(); return FALSE; }
nkeynes@732	173	#define CHECKSLOTILLEGAL() if(sh4r.in_delay_slot) return sh4_raise_exception(EXC_SLOT_ILLEGAL)
nkeynes@732	174
nkeynes@586	175	#define MEM_READ_BYTE( addr, val ) memtmp = mmu_vma_to_phys_read(addr); if( memtmp == MMU_VMA_ERROR ) { return TRUE; } else { val = sh4_read_byte(memtmp); }
nkeynes@586	176	#define MEM_READ_WORD( addr, val ) memtmp = mmu_vma_to_phys_read(addr); if( memtmp == MMU_VMA_ERROR ) { return TRUE; } else { val = sh4_read_word(memtmp); }
nkeynes@586	177	#define MEM_READ_LONG( addr, val ) memtmp = mmu_vma_to_phys_read(addr); if( memtmp == MMU_VMA_ERROR ) { return TRUE; } else { val = sh4_read_long(memtmp); }
nkeynes@586	178	#define MEM_WRITE_BYTE( addr, val ) memtmp = mmu_vma_to_phys_write(addr); if( memtmp == MMU_VMA_ERROR ) { return TRUE; } else { sh4_write_byte(memtmp, val); }
nkeynes@586	179	#define MEM_WRITE_WORD( addr, val ) memtmp = mmu_vma_to_phys_write(addr); if( memtmp == MMU_VMA_ERROR ) { return TRUE; } else { sh4_write_word(memtmp, val); }
nkeynes@586	180	#define MEM_WRITE_LONG( addr, val ) memtmp = mmu_vma_to_phys_write(addr); if( memtmp == MMU_VMA_ERROR ) { return TRUE; } else { sh4_write_long(memtmp, val); }
nkeynes@1	181
nkeynes@1	182	#define FP_WIDTH (IS_FPU_DOUBLESIZE() ? 8 : 4)
nkeynes@1	183
nkeynes@732	184	#define MEM_FP_READ( addr, reg ) \
nkeynes@732	185	if( IS_FPU_DOUBLESIZE() ) { \
nkeynes@732	186	CHECKRALIGN64(addr); \
nkeynes@732	187	memtmp = mmu_vma_to_phys_read(addr); \
nkeynes@732	188	if( memtmp == MMU_VMA_ERROR ) { \
nkeynes@732	189	return TRUE; \
nkeynes@732	190	} else { \
nkeynes@732	191	if( reg & 1 ) { \
nkeynes@732	192	((uint32_t )&XF((reg) & 0x0E)) = sh4_read_long(memtmp); \
nkeynes@732	193	((uint32_t )&XF(reg)) = sh4_read_long(memtmp+4); \
nkeynes@732	194	} else { \
nkeynes@732	195	((uint32_t )&FR(reg)) = sh4_read_long(memtmp); \
nkeynes@732	196	((uint32_t )&FR((reg) \| 0x01)) = sh4_read_long(memtmp+4); \
nkeynes@732	197	} \
nkeynes@732	198	} \
nkeynes@732	199	} else { \
nkeynes@732	200	CHECKRALIGN32(addr); \
nkeynes@732	201	memtmp = mmu_vma_to_phys_read(addr); \
nkeynes@732	202	if( memtmp == MMU_VMA_ERROR ) { \
nkeynes@732	203	return TRUE; \
nkeynes@732	204	} else { \
nkeynes@732	205	((uint32_t )&FR(reg)) = sh4_read_long(memtmp); \
nkeynes@732	206	} \
nkeynes@124	207	}
nkeynes@732	208	#define MEM_FP_WRITE( addr, reg ) \
nkeynes@732	209	if( IS_FPU_DOUBLESIZE() ) { \
nkeynes@732	210	CHECKWALIGN64(addr); \
nkeynes@732	211	memtmp = mmu_vma_to_phys_write(addr); \
nkeynes@732	212	if( memtmp == MMU_VMA_ERROR ) { \
nkeynes@732	213	return TRUE; \
nkeynes@732	214	} else { \
nkeynes@732	215	if( reg & 1 ) { \
nkeynes@732	216	sh4_write_long( memtmp, ((uint32_t )&XF((reg)&0x0E)) ); \
nkeynes@732	217	sh4_write_long( memtmp+4, ((uint32_t )&XF(reg)) ); \
nkeynes@732	218	} else { \
nkeynes@732	219	sh4_write_long( memtmp, ((uint32_t )&FR(reg)) ); \
nkeynes@732	220	sh4_write_long( memtmp+4, ((uint32_t )&FR((reg)\|0x01)) ); \
nkeynes@732	221	} \
nkeynes@732	222	} \
nkeynes@732	223	} else { \
nkeynes@732	224	CHECKWALIGN32(addr); \
nkeynes@732	225	memtmp = mmu_vma_to_phys_write(addr); \
nkeynes@732	226	if( memtmp == MMU_VMA_ERROR ) { \
nkeynes@732	227	return TRUE; \
nkeynes@732	228	} else { \
nkeynes@732	229	sh4_write_long( memtmp, ((uint32_t )&FR((reg))) ); \
nkeynes@732	230	} \
nkeynes@124	231	}
nkeynes@124	232
nkeynes@27	233	gboolean sh4_execute_instruction( void )
nkeynes@1	234	{
nkeynes@84	235	uint32_t pc;
nkeynes@2	236	unsigned short ir;
nkeynes@1	237	uint32_t tmp;
nkeynes@123	238	float ftmp;
nkeynes@123	239	double dtmp;
nkeynes@586	240	int64_t memtmp; // temporary holder for memory reads
nkeynes@1	241
nkeynes@1	242	#define R0 sh4r.r[0]
nkeynes@2	243	pc = sh4r.pc;
nkeynes@84	244	if( pc > 0xFFFFFF00 ) {
nkeynes@84	245	/* SYSCALL Magic */
nkeynes@102	246	syscall_invoke( pc );
nkeynes@104	247	sh4r.in_delay_slot = 0;
nkeynes@84	248	pc = sh4r.pc = sh4r.pr;
nkeynes@84	249	sh4r.new_pc = sh4r.pc + 2;
nkeynes@671	250	return TRUE;
nkeynes@84	251	}
nkeynes@208	252	CHECKRALIGN16(pc);
nkeynes@235	253
nkeynes@671	254	#ifdef ENABLE_SH4STATS
nkeynes@671	255	sh4_stats_add_by_pc(sh4r.pc);
nkeynes@671	256	#endif
nkeynes@671	257
nkeynes@235	258	/* Read instruction */
nkeynes@586	259	if( !IS_IN_ICACHE(pc) ) {
nkeynes@586	260	if( !mmu_update_icache(pc) ) {
nkeynes@586	261	// Fault - look for the fault handler
nkeynes@586	262	if( !mmu_update_icache(sh4r.pc) ) {
nkeynes@586	263	// double fault - halt
nkeynes@586	264	ERROR( "Double fault - halting" );
nkeynes@586	265	dreamcast_stop();
nkeynes@586	266	return FALSE;
nkeynes@586	267	}
nkeynes@235	268	}
nkeynes@586	269	pc = sh4r.pc;
nkeynes@235	270	}
nkeynes@586	271	assert( IS_IN_ICACHE(pc) );
nkeynes@586	272	ir = (uint16_t )GET_ICACHE_PTR(sh4r.pc);
nkeynes@359	273	switch( (ir&0xF000) >> 12 ) {
nkeynes@359	274	case 0x0:
nkeynes@359	275	switch( ir&0xF ) {
nkeynes@359	276	case 0x2:
nkeynes@359	277	switch( (ir&0x80) >> 7 ) {
nkeynes@359	278	case 0x0:
nkeynes@359	279	switch( (ir&0x70) >> 4 ) {
nkeynes@359	280	case 0x0:
nkeynes@359	281	{ /* STC SR, Rn */
nkeynes@359	282	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	283	CHECKPRIV();
nkeynes@359	284	sh4r.r[Rn] = sh4_read_sr();
nkeynes@359	285	}
nkeynes@359	286	break;
nkeynes@359	287	case 0x1:
nkeynes@359	288	{ /* STC GBR, Rn */
nkeynes@359	289	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	290	sh4r.r[Rn] = sh4r.gbr;
nkeynes@359	291	}
nkeynes@359	292	break;
nkeynes@359	293	case 0x2:
nkeynes@359	294	{ /* STC VBR, Rn */
nkeynes@359	295	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	296	CHECKPRIV();
nkeynes@359	297	sh4r.r[Rn] = sh4r.vbr;
nkeynes@359	298	}
nkeynes@359	299	break;
nkeynes@359	300	case 0x3:
nkeynes@359	301	{ /* STC SSR, Rn */
nkeynes@359	302	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	303	CHECKPRIV();
nkeynes@359	304	sh4r.r[Rn] = sh4r.ssr;
nkeynes@359	305	}
nkeynes@359	306	break;
nkeynes@359	307	case 0x4:
nkeynes@359	308	{ /* STC SPC, Rn */
nkeynes@359	309	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	310	CHECKPRIV();
nkeynes@359	311	sh4r.r[Rn] = sh4r.spc;
nkeynes@359	312	}
nkeynes@359	313	break;
nkeynes@359	314	default:
nkeynes@359	315	UNDEF();
nkeynes@359	316	break;
nkeynes@359	317	}
nkeynes@359	318	break;
nkeynes@359	319	case 0x1:
nkeynes@359	320	{ /* STC Rm_BANK, Rn */
nkeynes@359	321	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm_BANK = ((ir>>4)&0x7);
nkeynes@359	322	CHECKPRIV();
nkeynes@359	323	sh4r.r[Rn] = sh4r.r_bank[Rm_BANK];
nkeynes@359	324	}
nkeynes@359	325	break;
nkeynes@359	326	}
nkeynes@359	327	break;
nkeynes@359	328	case 0x3:
nkeynes@359	329	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	330	case 0x0:
nkeynes@359	331	{ /* BSRF Rn */
nkeynes@359	332	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	333	CHECKSLOTILLEGAL();
nkeynes@359	334	CHECKDEST( pc + 4 + sh4r.r[Rn] );
nkeynes@359	335	sh4r.in_delay_slot = 1;
nkeynes@359	336	sh4r.pr = sh4r.pc + 4;
nkeynes@359	337	sh4r.pc = sh4r.new_pc;
nkeynes@359	338	sh4r.new_pc = pc + 4 + sh4r.r[Rn];
nkeynes@359	339	TRACE_CALL( pc, sh4r.new_pc );
nkeynes@359	340	return TRUE;
nkeynes@359	341	}
nkeynes@359	342	break;
nkeynes@359	343	case 0x2:
nkeynes@359	344	{ /* BRAF Rn */
nkeynes@359	345	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	346	CHECKSLOTILLEGAL();
nkeynes@359	347	CHECKDEST( pc + 4 + sh4r.r[Rn] );
nkeynes@359	348	sh4r.in_delay_slot = 1;
nkeynes@359	349	sh4r.pc = sh4r.new_pc;
nkeynes@359	350	sh4r.new_pc = pc + 4 + sh4r.r[Rn];
nkeynes@359	351	return TRUE;
nkeynes@359	352	}
nkeynes@359	353	break;
nkeynes@359	354	case 0x8:
nkeynes@359	355	{ /* PREF @Rn */
nkeynes@359	356	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	357	tmp = sh4r.r[Rn];
nkeynes@359	358	if( (tmp & 0xFC000000) == 0xE0000000 ) {
nkeynes@369	359	sh4_flush_store_queue(tmp);
nkeynes@359	360	}
nkeynes@359	361	}
nkeynes@359	362	break;
nkeynes@359	363	case 0x9:
nkeynes@359	364	{ /* OCBI @Rn */
nkeynes@359	365	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	366	}
nkeynes@359	367	break;
nkeynes@359	368	case 0xA:
nkeynes@359	369	{ /* OCBP @Rn */
nkeynes@359	370	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	371	}
nkeynes@359	372	break;
nkeynes@359	373	case 0xB:
nkeynes@359	374	{ /* OCBWB @Rn */
nkeynes@359	375	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	376	}
nkeynes@359	377	break;
nkeynes@359	378	case 0xC:
nkeynes@359	379	{ /* MOVCA.L R0, @Rn */
nkeynes@359	380	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	381	tmp = sh4r.r[Rn];
nkeynes@359	382	CHECKWALIGN32(tmp);
nkeynes@359	383	MEM_WRITE_LONG( tmp, R0 );
nkeynes@359	384	}
nkeynes@359	385	break;
nkeynes@359	386	default:
nkeynes@359	387	UNDEF();
nkeynes@359	388	break;
nkeynes@359	389	}
nkeynes@359	390	break;
nkeynes@359	391	case 0x4:
nkeynes@359	392	{ /* MOV.B Rm, @(R0, Rn) */
nkeynes@359	393	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	394	MEM_WRITE_BYTE( R0 + sh4r.r[Rn], sh4r.r[Rm] );
nkeynes@359	395	}
nkeynes@359	396	break;
nkeynes@359	397	case 0x5:
nkeynes@359	398	{ /* MOV.W Rm, @(R0, Rn) */
nkeynes@359	399	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	400	CHECKWALIGN16( R0 + sh4r.r[Rn] );
nkeynes@359	401	MEM_WRITE_WORD( R0 + sh4r.r[Rn], sh4r.r[Rm] );
nkeynes@359	402	}
nkeynes@359	403	break;
nkeynes@359	404	case 0x6:
nkeynes@359	405	{ /* MOV.L Rm, @(R0, Rn) */
nkeynes@359	406	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	407	CHECKWALIGN32( R0 + sh4r.r[Rn] );
nkeynes@359	408	MEM_WRITE_LONG( R0 + sh4r.r[Rn], sh4r.r[Rm] );
nkeynes@359	409	}
nkeynes@359	410	break;
nkeynes@359	411	case 0x7:
nkeynes@359	412	{ /* MUL.L Rm, Rn */
nkeynes@359	413	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	414	sh4r.mac = (sh4r.mac&0xFFFFFFFF00000000LL) \|
nkeynes@359	415	(sh4r.r[Rm] * sh4r.r[Rn]);
nkeynes@359	416	}
nkeynes@359	417	break;
nkeynes@359	418	case 0x8:
nkeynes@359	419	switch( (ir&0xFF0) >> 4 ) {
nkeynes@359	420	case 0x0:
nkeynes@359	421	{ /* CLRT */
nkeynes@359	422	sh4r.t = 0;
nkeynes@359	423	}
nkeynes@359	424	break;
nkeynes@359	425	case 0x1:
nkeynes@359	426	{ /* SETT */
nkeynes@359	427	sh4r.t = 1;
nkeynes@359	428	}
nkeynes@359	429	break;
nkeynes@359	430	case 0x2:
nkeynes@359	431	{ /* CLRMAC */
nkeynes@359	432	sh4r.mac = 0;
nkeynes@359	433	}
nkeynes@359	434	break;
nkeynes@359	435	case 0x3:
nkeynes@359	436	{ /* LDTLB */
nkeynes@550	437	MMU_ldtlb();
nkeynes@359	438	}
nkeynes@359	439	break;
nkeynes@359	440	case 0x4:
nkeynes@359	441	{ /* CLRS */
nkeynes@359	442	sh4r.s = 0;
nkeynes@359	443	}
nkeynes@359	444	break;
nkeynes@359	445	case 0x5:
nkeynes@359	446	{ /* SETS */
nkeynes@359	447	sh4r.s = 1;
nkeynes@359	448	}
nkeynes@359	449	break;
nkeynes@359	450	default:
nkeynes@359	451	UNDEF();
nkeynes@359	452	break;
nkeynes@359	453	}
nkeynes@359	454	break;
nkeynes@359	455	case 0x9:
nkeynes@359	456	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	457	case 0x0:
nkeynes@359	458	{ /* NOP */
nkeynes@359	459	/* NOP */
nkeynes@359	460	}
nkeynes@359	461	break;
nkeynes@359	462	case 0x1:
nkeynes@359	463	{ /* DIV0U */
nkeynes@359	464	sh4r.m = sh4r.q = sh4r.t = 0;
nkeynes@359	465	}
nkeynes@359	466	break;
nkeynes@359	467	case 0x2:
nkeynes@359	468	{ /* MOVT Rn */
nkeynes@359	469	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	470	sh4r.r[Rn] = sh4r.t;
nkeynes@359	471	}
nkeynes@359	472	break;
nkeynes@359	473	default:
nkeynes@359	474	UNDEF();
nkeynes@359	475	break;
nkeynes@359	476	}
nkeynes@359	477	break;
nkeynes@359	478	case 0xA:
nkeynes@359	479	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	480	case 0x0:
nkeynes@359	481	{ /* STS MACH, Rn */
nkeynes@359	482	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	483	sh4r.r[Rn] = (sh4r.mac>>32);
nkeynes@359	484	}
nkeynes@359	485	break;
nkeynes@359	486	case 0x1:
nkeynes@359	487	{ /* STS MACL, Rn */
nkeynes@359	488	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	489	sh4r.r[Rn] = (uint32_t)sh4r.mac;
nkeynes@359	490	}
nkeynes@359	491	break;
nkeynes@359	492	case 0x2:
nkeynes@359	493	{ /* STS PR, Rn */
nkeynes@359	494	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	495	sh4r.r[Rn] = sh4r.pr;
nkeynes@359	496	}
nkeynes@359	497	break;
nkeynes@359	498	case 0x3:
nkeynes@359	499	{ /* STC SGR, Rn */
nkeynes@359	500	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	501	CHECKPRIV();
nkeynes@359	502	sh4r.r[Rn] = sh4r.sgr;
nkeynes@359	503	}
nkeynes@359	504	break;
nkeynes@359	505	case 0x5:
nkeynes@359	506	{ /* STS FPUL, Rn */
nkeynes@359	507	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@626	508	CHECKFPUEN();
nkeynes@669	509	sh4r.r[Rn] = FPULi;
nkeynes@359	510	}
nkeynes@359	511	break;
nkeynes@359	512	case 0x6:
nkeynes@359	513	{ /* STS FPSCR, Rn */
nkeynes@359	514	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@626	515	CHECKFPUEN();
nkeynes@359	516	sh4r.r[Rn] = sh4r.fpscr;
nkeynes@359	517	}
nkeynes@359	518	break;
nkeynes@359	519	case 0xF:
nkeynes@359	520	{ /* STC DBR, Rn */
nkeynes@359	521	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	522	CHECKPRIV(); sh4r.r[Rn] = sh4r.dbr;
nkeynes@359	523	}
nkeynes@359	524	break;
nkeynes@359	525	default:
nkeynes@359	526	UNDEF();
nkeynes@359	527	break;
nkeynes@359	528	}
nkeynes@359	529	break;
nkeynes@359	530	case 0xB:
nkeynes@359	531	switch( (ir&0xFF0) >> 4 ) {
nkeynes@359	532	case 0x0:
nkeynes@359	533	{ /* RTS */
nkeynes@359	534	CHECKSLOTILLEGAL();
nkeynes@359	535	CHECKDEST( sh4r.pr );
nkeynes@359	536	sh4r.in_delay_slot = 1;
nkeynes@359	537	sh4r.pc = sh4r.new_pc;
nkeynes@359	538	sh4r.new_pc = sh4r.pr;
nkeynes@359	539	TRACE_RETURN( pc, sh4r.new_pc );
nkeynes@359	540	return TRUE;
nkeynes@359	541	}
nkeynes@359	542	break;
nkeynes@359	543	case 0x1:
nkeynes@359	544	{ /* SLEEP */
nkeynes@359	545	if( MMIO_READ( CPG, STBCR ) & 0x80 ) {
nkeynes@359	546	sh4r.sh4_state = SH4_STATE_STANDBY;
nkeynes@359	547	} else {
nkeynes@359	548	sh4r.sh4_state = SH4_STATE_SLEEP;
nkeynes@359	549	}
nkeynes@359	550	return FALSE; /* Halt CPU */
nkeynes@359	551	}
nkeynes@359	552	break;
nkeynes@359	553	case 0x2:
nkeynes@359	554	{ /* RTE */
nkeynes@359	555	CHECKPRIV();
nkeynes@359	556	CHECKDEST( sh4r.spc );
nkeynes@359	557	CHECKSLOTILLEGAL();
nkeynes@359	558	sh4r.in_delay_slot = 1;
nkeynes@359	559	sh4r.pc = sh4r.new_pc;
nkeynes@359	560	sh4r.new_pc = sh4r.spc;
nkeynes@374	561	sh4_write_sr( sh4r.ssr );
nkeynes@359	562	return TRUE;
nkeynes@359	563	}
nkeynes@359	564	break;
nkeynes@359	565	default:
nkeynes@359	566	UNDEF();
nkeynes@359	567	break;
nkeynes@359	568	}
nkeynes@359	569	break;
nkeynes@359	570	case 0xC:
nkeynes@359	571	{ /* MOV.B @(R0, Rm), Rn */
nkeynes@359	572	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@586	573	MEM_READ_BYTE( R0 + sh4r.r[Rm], sh4r.r[Rn] );
nkeynes@359	574	}
nkeynes@359	575	break;
nkeynes@359	576	case 0xD:
nkeynes@359	577	{ /* MOV.W @(R0, Rm), Rn */
nkeynes@359	578	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	579	CHECKRALIGN16( R0 + sh4r.r[Rm] );
nkeynes@586	580	MEM_READ_WORD( R0 + sh4r.r[Rm], sh4r.r[Rn] );
nkeynes@359	581	}
nkeynes@359	582	break;
nkeynes@359	583	case 0xE:
nkeynes@359	584	{ /* MOV.L @(R0, Rm), Rn */
nkeynes@359	585	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	586	CHECKRALIGN32( R0 + sh4r.r[Rm] );
nkeynes@586	587	MEM_READ_LONG( R0 + sh4r.r[Rm], sh4r.r[Rn] );
nkeynes@359	588	}
nkeynes@359	589	break;
nkeynes@359	590	case 0xF:
nkeynes@359	591	{ /* MAC.L @Rm+, @Rn+ */
nkeynes@359	592	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@587	593	int64_t tmpl;
nkeynes@587	594	if( Rm == Rn ) {
nkeynes@587	595	CHECKRALIGN32( sh4r.r[Rn] );
nkeynes@587	596	MEM_READ_LONG(sh4r.r[Rn], tmp);
nkeynes@587	597	tmpl = SIGNEXT32(tmp);
nkeynes@587	598	MEM_READ_LONG(sh4r.r[Rn]+4, tmp);
nkeynes@587	599	tmpl = tmpl * SIGNEXT32(tmp) + sh4r.mac;
nkeynes@587	600	sh4r.r[Rn] += 8;
nkeynes@587	601	} else {
nkeynes@587	602	CHECKRALIGN32( sh4r.r[Rm] );
nkeynes@587	603	CHECKRALIGN32( sh4r.r[Rn] );
nkeynes@587	604	MEM_READ_LONG(sh4r.r[Rn], tmp);
nkeynes@587	605	tmpl = SIGNEXT32(tmp);
nkeynes@587	606	MEM_READ_LONG(sh4r.r[Rm], tmp);
nkeynes@587	607	tmpl = tmpl * SIGNEXT32(tmp) + sh4r.mac;
nkeynes@587	608	sh4r.r[Rn] += 4;
nkeynes@587	609	sh4r.r[Rm] += 4;
nkeynes@587	610	}
nkeynes@359	611	if( sh4r.s ) {
nkeynes@359	612	/* 48-bit Saturation. Yuch */
nkeynes@359	613	if( tmpl < (int64_t)0xFFFF800000000000LL )
nkeynes@359	614	tmpl = 0xFFFF800000000000LL;
nkeynes@359	615	else if( tmpl > (int64_t)0x00007FFFFFFFFFFFLL )
nkeynes@359	616	tmpl = 0x00007FFFFFFFFFFFLL;
nkeynes@359	617	}
nkeynes@359	618	sh4r.mac = tmpl;
nkeynes@359	619	}
nkeynes@359	620	break;
nkeynes@359	621	default:
nkeynes@359	622	UNDEF();
nkeynes@359	623	break;
nkeynes@359	624	}
nkeynes@359	625	break;
nkeynes@359	626	case 0x1:
nkeynes@359	627	{ /* MOV.L Rm, @(disp, Rn) */
nkeynes@359	628	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF); uint32_t disp = (ir&0xF)<<2;
nkeynes@359	629	tmp = sh4r.r[Rn] + disp;
nkeynes@359	630	CHECKWALIGN32( tmp );
nkeynes@359	631	MEM_WRITE_LONG( tmp, sh4r.r[Rm] );
nkeynes@359	632	}
nkeynes@359	633	break;
nkeynes@359	634	case 0x2:
nkeynes@359	635	switch( ir&0xF ) {
nkeynes@359	636	case 0x0:
nkeynes@359	637	{ /* MOV.B Rm, @Rn */
nkeynes@359	638	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	639	MEM_WRITE_BYTE( sh4r.r[Rn], sh4r.r[Rm] );
nkeynes@359	640	}
nkeynes@359	641	break;
nkeynes@359	642	case 0x1:
nkeynes@359	643	{ /* MOV.W Rm, @Rn */
nkeynes@359	644	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	645	CHECKWALIGN16( sh4r.r[Rn] ); MEM_WRITE_WORD( sh4r.r[Rn], sh4r.r[Rm] );
nkeynes@359	646	}
nkeynes@359	647	break;
nkeynes@359	648	case 0x2:
nkeynes@359	649	{ /* MOV.L Rm, @Rn */
nkeynes@359	650	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	651	CHECKWALIGN32( sh4r.r[Rn] ); MEM_WRITE_LONG( sh4r.r[Rn], sh4r.r[Rm] );
nkeynes@359	652	}
nkeynes@359	653	break;
nkeynes@359	654	case 0x4:
nkeynes@359	655	{ /* MOV.B Rm, @-Rn */
nkeynes@359	656	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@587	657	MEM_WRITE_BYTE( sh4r.r[Rn]-1, sh4r.r[Rm] ); sh4r.r[Rn]--;
nkeynes@359	658	}
nkeynes@359	659	break;
nkeynes@359	660	case 0x5:
nkeynes@359	661	{ /* MOV.W Rm, @-Rn */
nkeynes@359	662	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@587	663	CHECKWALIGN16( sh4r.r[Rn] ); MEM_WRITE_WORD( sh4r.r[Rn]-2, sh4r.r[Rm] ); sh4r.r[Rn] -= 2;
nkeynes@359	664	}
nkeynes@359	665	break;
nkeynes@359	666	case 0x6:
nkeynes@359	667	{ /* MOV.L Rm, @-Rn */
nkeynes@359	668	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@587	669	CHECKWALIGN32( sh4r.r[Rn] ); MEM_WRITE_LONG( sh4r.r[Rn]-4, sh4r.r[Rm] ); sh4r.r[Rn] -= 4;
nkeynes@359	670	}
nkeynes@359	671	break;
nkeynes@359	672	case 0x7:
nkeynes@359	673	{ /* DIV0S Rm, Rn */
nkeynes@359	674	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	675	sh4r.q = sh4r.r[Rn]>>31;
nkeynes@359	676	sh4r.m = sh4r.r[Rm]>>31;
nkeynes@359	677	sh4r.t = sh4r.q ^ sh4r.m;
nkeynes@359	678	}
nkeynes@359	679	break;
nkeynes@359	680	case 0x8:
nkeynes@359	681	{ /* TST Rm, Rn */
nkeynes@359	682	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	683	sh4r.t = (sh4r.r[Rn]&sh4r.r[Rm] ? 0 : 1);
nkeynes@359	684	}
nkeynes@359	685	break;
nkeynes@359	686	case 0x9:
nkeynes@359	687	{ /* AND Rm, Rn */
nkeynes@359	688	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	689	sh4r.r[Rn] &= sh4r.r[Rm];
nkeynes@359	690	}
nkeynes@359	691	break;
nkeynes@359	692	case 0xA:
nkeynes@359	693	{ /* XOR Rm, Rn */
nkeynes@359	694	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	695	sh4r.r[Rn] ^= sh4r.r[Rm];
nkeynes@359	696	}
nkeynes@359	697	break;
nkeynes@359	698	case 0xB:
nkeynes@359	699	{ /* OR Rm, Rn */
nkeynes@359	700	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	701	sh4r.r[Rn] \|= sh4r.r[Rm];
nkeynes@359	702	}
nkeynes@359	703	break;
nkeynes@359	704	case 0xC:
nkeynes@359	705	{ /* CMP/STR Rm, Rn */
nkeynes@359	706	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	707	/* set T = 1 if any byte in RM & RN is the same */
nkeynes@359	708	tmp = sh4r.r[Rm] ^ sh4r.r[Rn];
nkeynes@359	709	sh4r.t = ((tmp&0x000000FF)==0 \|\| (tmp&0x0000FF00)==0 \|\|
nkeynes@359	710	(tmp&0x00FF0000)==0 \|\| (tmp&0xFF000000)==0)?1:0;
nkeynes@359	711	}
nkeynes@359	712	break;
nkeynes@359	713	case 0xD:
nkeynes@359	714	{ /* XTRCT Rm, Rn */
nkeynes@359	715	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	716	sh4r.r[Rn] = (sh4r.r[Rn]>>16) \| (sh4r.r[Rm]<<16);
nkeynes@359	717	}
nkeynes@359	718	break;
nkeynes@359	719	case 0xE:
nkeynes@359	720	{ /* MULU.W Rm, Rn */
nkeynes@359	721	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	722	sh4r.mac = (sh4r.mac&0xFFFFFFFF00000000LL) \|
nkeynes@359	723	(uint32_t)((sh4r.r[Rm]&0xFFFF) * (sh4r.r[Rn]&0xFFFF));
nkeynes@359	724	}
nkeynes@359	725	break;
nkeynes@359	726	case 0xF:
nkeynes@359	727	{ /* MULS.W Rm, Rn */
nkeynes@359	728	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	729	sh4r.mac = (sh4r.mac&0xFFFFFFFF00000000LL) \|
nkeynes@359	730	(uint32_t)(SIGNEXT32(sh4r.r[Rm]&0xFFFF) * SIGNEXT32(sh4r.r[Rn]&0xFFFF));
nkeynes@359	731	}
nkeynes@359	732	break;
nkeynes@359	733	default:
nkeynes@359	734	UNDEF();
nkeynes@359	735	break;
nkeynes@359	736	}
nkeynes@359	737	break;
nkeynes@359	738	case 0x3:
nkeynes@359	739	switch( ir&0xF ) {
nkeynes@359	740	case 0x0:
nkeynes@359	741	{ /* CMP/EQ Rm, Rn */
nkeynes@359	742	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	743	sh4r.t = ( sh4r.r[Rm] == sh4r.r[Rn] ? 1 : 0 );
nkeynes@359	744	}
nkeynes@359	745	break;
nkeynes@359	746	case 0x2:
nkeynes@359	747	{ /* CMP/HS Rm, Rn */
nkeynes@359	748	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	749	sh4r.t = ( sh4r.r[Rn] >= sh4r.r[Rm] ? 1 : 0 );
nkeynes@359	750	}
nkeynes@359	751	break;
nkeynes@359	752	case 0x3:
nkeynes@359	753	{ /* CMP/GE Rm, Rn */
nkeynes@359	754	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	755	sh4r.t = ( ((int32_t)sh4r.r[Rn]) >= ((int32_t)sh4r.r[Rm]) ? 1 : 0 );
nkeynes@359	756	}
nkeynes@359	757	break;
nkeynes@359	758	case 0x4:
nkeynes@359	759	{ /* DIV1 Rm, Rn */
nkeynes@359	760	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@384	761	/* This is derived from the sh4 manual with some simplifications */
nkeynes@359	762	uint32_t tmp0, tmp1, tmp2, dir;
nkeynes@359	763
nkeynes@359	764	dir = sh4r.q ^ sh4r.m;
nkeynes@359	765	sh4r.q = (sh4r.r[Rn] >> 31);
nkeynes@359	766	tmp2 = sh4r.r[Rm];
nkeynes@359	767	sh4r.r[Rn] = (sh4r.r[Rn] << 1) \| sh4r.t;
nkeynes@359	768	tmp0 = sh4r.r[Rn];
nkeynes@359	769	if( dir ) {
nkeynes@359	770	sh4r.r[Rn] += tmp2;
nkeynes@359	771	tmp1 = (sh4r.r[Rn]<tmp0 ? 1 : 0 );
nkeynes@359	772	} else {
nkeynes@359	773	sh4r.r[Rn] -= tmp2;
nkeynes@359	774	tmp1 = (sh4r.r[Rn]>tmp0 ? 1 : 0 );
nkeynes@359	775	}
nkeynes@359	776	sh4r.q ^= sh4r.m ^ tmp1;
nkeynes@359	777	sh4r.t = ( sh4r.q == sh4r.m ? 1 : 0 );
nkeynes@359	778	}
nkeynes@359	779	break;
nkeynes@359	780	case 0x5:
nkeynes@359	781	{ /* DMULU.L Rm, Rn */
nkeynes@359	782	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	783	sh4r.mac = ((uint64_t)sh4r.r[Rm]) * ((uint64_t)sh4r.r[Rn]);
nkeynes@359	784	}
nkeynes@359	785	break;
nkeynes@359	786	case 0x6:
nkeynes@359	787	{ /* CMP/HI Rm, Rn */
nkeynes@359	788	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	789	sh4r.t = ( sh4r.r[Rn] > sh4r.r[Rm] ? 1 : 0 );
nkeynes@359	790	}
nkeynes@359	791	break;
nkeynes@359	792	case 0x7:
nkeynes@359	793	{ /* CMP/GT Rm, Rn */
nkeynes@359	794	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	795	sh4r.t = ( ((int32_t)sh4r.r[Rn]) > ((int32_t)sh4r.r[Rm]) ? 1 : 0 );
nkeynes@359	796	}
nkeynes@359	797	break;
nkeynes@359	798	case 0x8:
nkeynes@359	799	{ /* SUB Rm, Rn */
nkeynes@359	800	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	801	sh4r.r[Rn] -= sh4r.r[Rm];
nkeynes@359	802	}
nkeynes@359	803	break;
nkeynes@359	804	case 0xA:
nkeynes@359	805	{ /* SUBC Rm, Rn */
nkeynes@359	806	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	807	tmp = sh4r.r[Rn];
nkeynes@359	808	sh4r.r[Rn] = sh4r.r[Rn] - sh4r.r[Rm] - sh4r.t;
nkeynes@359	809	sh4r.t = (sh4r.r[Rn] > tmp \|\| (sh4r.r[Rn] == tmp && sh4r.t == 1));
nkeynes@359	810	}
nkeynes@359	811	break;
nkeynes@359	812	case 0xB:
nkeynes@359	813	UNIMP(ir); /* SUBV Rm, Rn */
nkeynes@359	814	break;
nkeynes@359	815	case 0xC:
nkeynes@359	816	{ /* ADD Rm, Rn */
nkeynes@359	817	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	818	sh4r.r[Rn] += sh4r.r[Rm];
nkeynes@359	819	}
nkeynes@359	820	break;
nkeynes@359	821	case 0xD:
nkeynes@359	822	{ /* DMULS.L Rm, Rn */
nkeynes@359	823	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	824	sh4r.mac = SIGNEXT32(sh4r.r[Rm]) * SIGNEXT32(sh4r.r[Rn]);
nkeynes@359	825	}
nkeynes@359	826	break;
nkeynes@359	827	case 0xE:
nkeynes@359	828	{ /* ADDC Rm, Rn */
nkeynes@359	829	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	830	tmp = sh4r.r[Rn];
nkeynes@359	831	sh4r.r[Rn] += sh4r.r[Rm] + sh4r.t;
nkeynes@359	832	sh4r.t = ( sh4r.r[Rn] < tmp \|\| (sh4r.r[Rn] == tmp && sh4r.t != 0) ? 1 : 0 );
nkeynes@359	833	}
nkeynes@359	834	break;
nkeynes@359	835	case 0xF:
nkeynes@359	836	{ /* ADDV Rm, Rn */
nkeynes@359	837	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	838	tmp = sh4r.r[Rn] + sh4r.r[Rm];
nkeynes@359	839	sh4r.t = ( (sh4r.r[Rn]>>31) == (sh4r.r[Rm]>>31) && ((sh4r.r[Rn]>>31) != (tmp>>31)) );
nkeynes@359	840	sh4r.r[Rn] = tmp;
nkeynes@359	841	}
nkeynes@359	842	break;
nkeynes@359	843	default:
nkeynes@359	844	UNDEF();
nkeynes@359	845	break;
nkeynes@359	846	}
nkeynes@359	847	break;
nkeynes@359	848	case 0x4:
nkeynes@359	849	switch( ir&0xF ) {
nkeynes@359	850	case 0x0:
nkeynes@359	851	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	852	case 0x0:
nkeynes@359	853	{ /* SHLL Rn */
nkeynes@359	854	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	855	sh4r.t = sh4r.r[Rn] >> 31; sh4r.r[Rn] <<= 1;
nkeynes@359	856	}
nkeynes@359	857	break;
nkeynes@359	858	case 0x1:
nkeynes@359	859	{ /* DT Rn */
nkeynes@359	860	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	861	sh4r.r[Rn] --;
nkeynes@359	862	sh4r.t = ( sh4r.r[Rn] == 0 ? 1 : 0 );
nkeynes@359	863	}
nkeynes@359	864	break;
nkeynes@359	865	case 0x2:
nkeynes@359	866	{ /* SHAL Rn */
nkeynes@359	867	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	868	sh4r.t = sh4r.r[Rn] >> 31;
nkeynes@359	869	sh4r.r[Rn] <<= 1;
nkeynes@359	870	}
nkeynes@359	871	break;
nkeynes@359	872	default:
nkeynes@359	873	UNDEF();
nkeynes@359	874	break;
nkeynes@359	875	}
nkeynes@359	876	break;
nkeynes@359	877	case 0x1:
nkeynes@359	878	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	879	case 0x0:
nkeynes@359	880	{ /* SHLR Rn */
nkeynes@359	881	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	882	sh4r.t = sh4r.r[Rn] & 0x00000001; sh4r.r[Rn] >>= 1;
nkeynes@359	883	}
nkeynes@359	884	break;
nkeynes@359	885	case 0x1:
nkeynes@359	886	{ /* CMP/PZ Rn */
nkeynes@359	887	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	888	sh4r.t = ( ((int32_t)sh4r.r[Rn]) >= 0 ? 1 : 0 );
nkeynes@359	889	}
nkeynes@359	890	break;
nkeynes@359	891	case 0x2:
nkeynes@359	892	{ /* SHAR Rn */
nkeynes@359	893	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	894	sh4r.t = sh4r.r[Rn] & 0x00000001;
nkeynes@359	895	sh4r.r[Rn] = ((int32_t)sh4r.r[Rn]) >> 1;
nkeynes@359	896	}
nkeynes@359	897	break;
nkeynes@359	898	default:
nkeynes@359	899	UNDEF();
nkeynes@359	900	break;
nkeynes@359	901	}
nkeynes@359	902	break;
nkeynes@359	903	case 0x2:
nkeynes@359	904	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	905	case 0x0:
nkeynes@359	906	{ /* STS.L MACH, @-Rn */
nkeynes@359	907	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@587	908	CHECKWALIGN32( sh4r.r[Rn] );
nkeynes@587	909	MEM_WRITE_LONG( sh4r.r[Rn]-4, (sh4r.mac>>32) );
nkeynes@359	910	sh4r.r[Rn] -= 4;
nkeynes@359	911	}
nkeynes@359	912	break;
nkeynes@359	913	case 0x1:
nkeynes@359	914	{ /* STS.L MACL, @-Rn */
nkeynes@359	915	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@587	916	CHECKWALIGN32( sh4r.r[Rn] );
nkeynes@587	917	MEM_WRITE_LONG( sh4r.r[Rn]-4, (uint32_t)sh4r.mac );
nkeynes@359	918	sh4r.r[Rn] -= 4;
nkeynes@359	919	}
nkeynes@359	920	break;
nkeynes@359	921	case 0x2:
nkeynes@359	922	{ /* STS.L PR, @-Rn */
nkeynes@359	923	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@587	924	CHECKWALIGN32( sh4r.r[Rn] );
nkeynes@587	925	MEM_WRITE_LONG( sh4r.r[Rn]-4, sh4r.pr );
nkeynes@359	926	sh4r.r[Rn] -= 4;
nkeynes@359	927	}
nkeynes@359	928	break;
nkeynes@359	929	case 0x3:
nkeynes@359	930	{ /* STC.L SGR, @-Rn */
nkeynes@359	931	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	932	CHECKPRIV();
nkeynes@587	933	CHECKWALIGN32( sh4r.r[Rn] );
nkeynes@587	934	MEM_WRITE_LONG( sh4r.r[Rn]-4, sh4r.sgr );
nkeynes@359	935	sh4r.r[Rn] -= 4;
nkeynes@359	936	}
nkeynes@359	937	break;
nkeynes@359	938	case 0x5:
nkeynes@359	939	{ /* STS.L FPUL, @-Rn */
nkeynes@359	940	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@626	941	CHECKFPUEN();
nkeynes@587	942	CHECKWALIGN32( sh4r.r[Rn] );
nkeynes@669	943	MEM_WRITE_LONG( sh4r.r[Rn]-4, FPULi );
nkeynes@359	944	sh4r.r[Rn] -= 4;
nkeynes@359	945	}
nkeynes@359	946	break;
nkeynes@359	947	case 0x6:
nkeynes@359	948	{ /* STS.L FPSCR, @-Rn */
nkeynes@359	949	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@626	950	CHECKFPUEN();
nkeynes@587	951	CHECKWALIGN32( sh4r.r[Rn] );
nkeynes@587	952	MEM_WRITE_LONG( sh4r.r[Rn]-4, sh4r.fpscr );
nkeynes@359	953	sh4r.r[Rn] -= 4;
nkeynes@359	954	}
nkeynes@359	955	break;
nkeynes@359	956	case 0xF:
nkeynes@359	957	{ /* STC.L DBR, @-Rn */
nkeynes@359	958	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	959	CHECKPRIV();
nkeynes@587	960	CHECKWALIGN32( sh4r.r[Rn] );
nkeynes@587	961	MEM_WRITE_LONG( sh4r.r[Rn]-4, sh4r.dbr );
nkeynes@359	962	sh4r.r[Rn] -= 4;
nkeynes@359	963	}
nkeynes@359	964	break;
nkeynes@359	965	default:
nkeynes@359	966	UNDEF();
nkeynes@359	967	break;
nkeynes@359	968	}
nkeynes@359	969	break;
nkeynes@359	970	case 0x3:
nkeynes@359	971	switch( (ir&0x80) >> 7 ) {
nkeynes@359	972	case 0x0:
nkeynes@359	973	switch( (ir&0x70) >> 4 ) {
nkeynes@359	974	case 0x0:
nkeynes@359	975	{ /* STC.L SR, @-Rn */
nkeynes@359	976	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	977	CHECKPRIV();
nkeynes@587	978	CHECKWALIGN32( sh4r.r[Rn] );
nkeynes@587	979	MEM_WRITE_LONG( sh4r.r[Rn]-4, sh4_read_sr() );
nkeynes@359	980	sh4r.r[Rn] -= 4;
nkeynes@359	981	}
nkeynes@359	982	break;
nkeynes@359	983	case 0x1:
nkeynes@359	984	{ /* STC.L GBR, @-Rn */
nkeynes@359	985	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@587	986	CHECKWALIGN32( sh4r.r[Rn] );
nkeynes@587	987	MEM_WRITE_LONG( sh4r.r[Rn]-4, sh4r.gbr );
nkeynes@359	988	sh4r.r[Rn] -= 4;
nkeynes@359	989	}
nkeynes@359	990	break;
nkeynes@359	991	case 0x2:
nkeynes@359	992	{ /* STC.L VBR, @-Rn */
nkeynes@359	993	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	994	CHECKPRIV();
nkeynes@587	995	CHECKWALIGN32( sh4r.r[Rn] );
nkeynes@587	996	MEM_WRITE_LONG( sh4r.r[Rn]-4, sh4r.vbr );
nkeynes@359	997	sh4r.r[Rn] -= 4;
nkeynes@359	998	}
nkeynes@359	999	break;
nkeynes@359	1000	case 0x3:
nkeynes@359	1001	{ /* STC.L SSR, @-Rn */
nkeynes@359	1002	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1003	CHECKPRIV();
nkeynes@587	1004	CHECKWALIGN32( sh4r.r[Rn] );
nkeynes@587	1005	MEM_WRITE_LONG( sh4r.r[Rn]-4, sh4r.ssr );
nkeynes@359	1006	sh4r.r[Rn] -= 4;
nkeynes@359	1007	}
nkeynes@359	1008	break;
nkeynes@359	1009	case 0x4:
nkeynes@359	1010	{ /* STC.L SPC, @-Rn */
nkeynes@359	1011	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1012	CHECKPRIV();
nkeynes@587	1013	CHECKWALIGN32( sh4r.r[Rn] );
nkeynes@587	1014	MEM_WRITE_LONG( sh4r.r[Rn]-4, sh4r.spc );
nkeynes@359	1015	sh4r.r[Rn] -= 4;
nkeynes@359	1016	}
nkeynes@359	1017	break;
nkeynes@359	1018	default:
nkeynes@359	1019	UNDEF();
nkeynes@359	1020	break;
nkeynes@359	1021	}
nkeynes@359	1022	break;
nkeynes@359	1023	case 0x1:
nkeynes@359	1024	{ /* STC.L Rm_BANK, @-Rn */
nkeynes@359	1025	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm_BANK = ((ir>>4)&0x7);
nkeynes@359	1026	CHECKPRIV();
nkeynes@587	1027	CHECKWALIGN32( sh4r.r[Rn] );
nkeynes@587	1028	MEM_WRITE_LONG( sh4r.r[Rn]-4, sh4r.r_bank[Rm_BANK] );
nkeynes@359	1029	sh4r.r[Rn] -= 4;
nkeynes@359	1030	}
nkeynes@359	1031	break;
nkeynes@359	1032	}
nkeynes@359	1033	break;
nkeynes@359	1034	case 0x4:
nkeynes@359	1035	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	1036	case 0x0:
nkeynes@359	1037	{ /* ROTL Rn */
nkeynes@359	1038	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1039	sh4r.t = sh4r.r[Rn] >> 31;
nkeynes@359	1040	sh4r.r[Rn] <<= 1;
nkeynes@359	1041	sh4r.r[Rn] \|= sh4r.t;
nkeynes@359	1042	}
nkeynes@359	1043	break;
nkeynes@359	1044	case 0x2:
nkeynes@359	1045	{ /* ROTCL Rn */
nkeynes@359	1046	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1047	tmp = sh4r.r[Rn] >> 31;
nkeynes@359	1048	sh4r.r[Rn] <<= 1;
nkeynes@359	1049	sh4r.r[Rn] \|= sh4r.t;
nkeynes@359	1050	sh4r.t = tmp;
nkeynes@359	1051	}
nkeynes@359	1052	break;
nkeynes@359	1053	default:
nkeynes@359	1054	UNDEF();
nkeynes@359	1055	break;
nkeynes@359	1056	}
nkeynes@359	1057	break;
nkeynes@359	1058	case 0x5:
nkeynes@359	1059	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	1060	case 0x0:
nkeynes@359	1061	{ /* ROTR Rn */
nkeynes@359	1062	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1063	sh4r.t = sh4r.r[Rn] & 0x00000001;
nkeynes@359	1064	sh4r.r[Rn] >>= 1;
nkeynes@359	1065	sh4r.r[Rn] \|= (sh4r.t << 31);
nkeynes@359	1066	}
nkeynes@359	1067	break;
nkeynes@359	1068	case 0x1:
nkeynes@359	1069	{ /* CMP/PL Rn */
nkeynes@359	1070	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1071	sh4r.t = ( ((int32_t)sh4r.r[Rn]) > 0 ? 1 : 0 );
nkeynes@359	1072	}
nkeynes@359	1073	break;
nkeynes@359	1074	case 0x2:
nkeynes@359	1075	{ /* ROTCR Rn */
nkeynes@359	1076	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1077	tmp = sh4r.r[Rn] & 0x00000001;
nkeynes@359	1078	sh4r.r[Rn] >>= 1;
nkeynes@359	1079	sh4r.r[Rn] \|= (sh4r.t << 31 );
nkeynes@359	1080	sh4r.t = tmp;
nkeynes@359	1081	}
nkeynes@359	1082	break;
nkeynes@359	1083	default:
nkeynes@359	1084	UNDEF();
nkeynes@359	1085	break;
nkeynes@359	1086	}
nkeynes@359	1087	break;
nkeynes@359	1088	case 0x6:
nkeynes@359	1089	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	1090	case 0x0:
nkeynes@359	1091	{ /* LDS.L @Rm+, MACH */
nkeynes@359	1092	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1093	CHECKRALIGN32( sh4r.r[Rm] );
nkeynes@586	1094	MEM_READ_LONG(sh4r.r[Rm], tmp);
nkeynes@359	1095	sh4r.mac = (sh4r.mac & 0x00000000FFFFFFFF) \|
nkeynes@586	1096	(((uint64_t)tmp)<<32);
nkeynes@359	1097	sh4r.r[Rm] += 4;
nkeynes@359	1098	}
nkeynes@359	1099	break;
nkeynes@359	1100	case 0x1:
nkeynes@359	1101	{ /* LDS.L @Rm+, MACL */
nkeynes@359	1102	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1103	CHECKRALIGN32( sh4r.r[Rm] );
nkeynes@586	1104	MEM_READ_LONG(sh4r.r[Rm], tmp);
nkeynes@359	1105	sh4r.mac = (sh4r.mac & 0xFFFFFFFF00000000LL) \|
nkeynes@586	1106	(uint64_t)((uint32_t)tmp);
nkeynes@359	1107	sh4r.r[Rm] += 4;
nkeynes@359	1108	}
nkeynes@359	1109	break;
nkeynes@359	1110	case 0x2:
nkeynes@359	1111	{ /* LDS.L @Rm+, PR */
nkeynes@359	1112	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1113	CHECKRALIGN32( sh4r.r[Rm] );
nkeynes@586	1114	MEM_READ_LONG( sh4r.r[Rm], sh4r.pr );
nkeynes@359	1115	sh4r.r[Rm] += 4;
nkeynes@359	1116	}
nkeynes@359	1117	break;
nkeynes@359	1118	case 0x3:
nkeynes@359	1119	{ /* LDC.L @Rm+, SGR */
nkeynes@359	1120	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1121	CHECKPRIV();
nkeynes@359	1122	CHECKRALIGN32( sh4r.r[Rm] );
nkeynes@586	1123	MEM_READ_LONG(sh4r.r[Rm], sh4r.sgr);
nkeynes@359	1124	sh4r.r[Rm] +=4;
nkeynes@359	1125	}
nkeynes@359	1126	break;
nkeynes@359	1127	case 0x5:
nkeynes@359	1128	{ /* LDS.L @Rm+, FPUL */
nkeynes@359	1129	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@626	1130	CHECKFPUEN();
nkeynes@359	1131	CHECKRALIGN32( sh4r.r[Rm] );
nkeynes@669	1132	MEM_READ_LONG(sh4r.r[Rm], FPULi);
nkeynes@359	1133	sh4r.r[Rm] +=4;
nkeynes@359	1134	}
nkeynes@359	1135	break;
nkeynes@359	1136	case 0x6:
nkeynes@359	1137	{ /* LDS.L @Rm+, FPSCR */
nkeynes@359	1138	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@626	1139	CHECKFPUEN();
nkeynes@359	1140	CHECKRALIGN32( sh4r.r[Rm] );
nkeynes@669	1141	MEM_READ_LONG(sh4r.r[Rm], tmp);
nkeynes@359	1142	sh4r.r[Rm] +=4;
nkeynes@669	1143	sh4_write_fpscr( tmp );
nkeynes@359	1144	}
nkeynes@359	1145	break;
nkeynes@359	1146	case 0xF:
nkeynes@359	1147	{ /* LDC.L @Rm+, DBR */
nkeynes@359	1148	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1149	CHECKPRIV();
nkeynes@359	1150	CHECKRALIGN32( sh4r.r[Rm] );
nkeynes@586	1151	MEM_READ_LONG(sh4r.r[Rm], sh4r.dbr);
nkeynes@359	1152	sh4r.r[Rm] +=4;
nkeynes@359	1153	}
nkeynes@359	1154	break;
nkeynes@359	1155	default:
nkeynes@359	1156	UNDEF();
nkeynes@359	1157	break;
nkeynes@359	1158	}
nkeynes@359	1159	break;
nkeynes@359	1160	case 0x7:
nkeynes@359	1161	switch( (ir&0x80) >> 7 ) {
nkeynes@359	1162	case 0x0:
nkeynes@359	1163	switch( (ir&0x70) >> 4 ) {
nkeynes@359	1164	case 0x0:
nkeynes@359	1165	{ /* LDC.L @Rm+, SR */
nkeynes@359	1166	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1167	CHECKSLOTILLEGAL();
nkeynes@359	1168	CHECKPRIV();
nkeynes@359	1169	CHECKWALIGN32( sh4r.r[Rm] );
nkeynes@586	1170	MEM_READ_LONG(sh4r.r[Rm], tmp);
nkeynes@586	1171	sh4_write_sr( tmp );
nkeynes@359	1172	sh4r.r[Rm] +=4;
nkeynes@359	1173	}
nkeynes@359	1174	break;
nkeynes@359	1175	case 0x1:
nkeynes@359	1176	{ /* LDC.L @Rm+, GBR */
nkeynes@359	1177	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1178	CHECKRALIGN32( sh4r.r[Rm] );
nkeynes@586	1179	MEM_READ_LONG(sh4r.r[Rm], sh4r.gbr);
nkeynes@359	1180	sh4r.r[Rm] +=4;
nkeynes@359	1181	}
nkeynes@359	1182	break;
nkeynes@359	1183	case 0x2:
nkeynes@359	1184	{ /* LDC.L @Rm+, VBR */
nkeynes@359	1185	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1186	CHECKPRIV();
nkeynes@359	1187	CHECKRALIGN32( sh4r.r[Rm] );
nkeynes@586	1188	MEM_READ_LONG(sh4r.r[Rm], sh4r.vbr);
nkeynes@359	1189	sh4r.r[Rm] +=4;
nkeynes@359	1190	}
nkeynes@359	1191	break;
nkeynes@359	1192	case 0x3:
nkeynes@359	1193	{ /* LDC.L @Rm+, SSR */
nkeynes@359	1194	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1195	CHECKPRIV();
nkeynes@359	1196	CHECKRALIGN32( sh4r.r[Rm] );
nkeynes@586	1197	MEM_READ_LONG(sh4r.r[Rm], sh4r.ssr);
nkeynes@359	1198	sh4r.r[Rm] +=4;
nkeynes@359	1199	}
nkeynes@359	1200	break;
nkeynes@359	1201	case 0x4:
nkeynes@359	1202	{ /* LDC.L @Rm+, SPC */
nkeynes@359	1203	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1204	CHECKPRIV();
nkeynes@359	1205	CHECKRALIGN32( sh4r.r[Rm] );
nkeynes@586	1206	MEM_READ_LONG(sh4r.r[Rm], sh4r.spc);
nkeynes@359	1207	sh4r.r[Rm] +=4;
nkeynes@359	1208	}
nkeynes@359	1209	break;
nkeynes@359	1210	default:
nkeynes@359	1211	UNDEF();
nkeynes@359	1212	break;
nkeynes@359	1213	}
nkeynes@359	1214	break;
nkeynes@359	1215	case 0x1:
nkeynes@359	1216	{ /* LDC.L @Rm+, Rn_BANK */
nkeynes@359	1217	uint32_t Rm = ((ir>>8)&0xF); uint32_t Rn_BANK = ((ir>>4)&0x7);
nkeynes@359	1218	CHECKPRIV();
nkeynes@359	1219	CHECKRALIGN32( sh4r.r[Rm] );
nkeynes@586	1220	MEM_READ_LONG( sh4r.r[Rm], sh4r.r_bank[Rn_BANK] );
nkeynes@359	1221	sh4r.r[Rm] += 4;
nkeynes@359	1222	}
nkeynes@359	1223	break;
nkeynes@359	1224	}
nkeynes@359	1225	break;
nkeynes@359	1226	case 0x8:
nkeynes@359	1227	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	1228	case 0x0:
nkeynes@359	1229	{ /* SHLL2 Rn */
nkeynes@359	1230	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1231	sh4r.r[Rn] <<= 2;
nkeynes@359	1232	}
nkeynes@359	1233	break;
nkeynes@359	1234	case 0x1:
nkeynes@359	1235	{ /* SHLL8 Rn */
nkeynes@359	1236	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1237	sh4r.r[Rn] <<= 8;
nkeynes@359	1238	}
nkeynes@359	1239	break;
nkeynes@359	1240	case 0x2:
nkeynes@359	1241	{ /* SHLL16 Rn */
nkeynes@359	1242	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1243	sh4r.r[Rn] <<= 16;
nkeynes@359	1244	}
nkeynes@359	1245	break;
nkeynes@359	1246	default:
nkeynes@359	1247	UNDEF();
nkeynes@359	1248	break;
nkeynes@359	1249	}
nkeynes@359	1250	break;
nkeynes@359	1251	case 0x9:
nkeynes@359	1252	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	1253	case 0x0:
nkeynes@359	1254	{ /* SHLR2 Rn */
nkeynes@359	1255	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1256	sh4r.r[Rn] >>= 2;
nkeynes@359	1257	}
nkeynes@359	1258	break;
nkeynes@359	1259	case 0x1:
nkeynes@359	1260	{ /* SHLR8 Rn */
nkeynes@359	1261	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1262	sh4r.r[Rn] >>= 8;
nkeynes@359	1263	}
nkeynes@359	1264	break;
nkeynes@359	1265	case 0x2:
nkeynes@359	1266	{ /* SHLR16 Rn */
nkeynes@359	1267	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1268	sh4r.r[Rn] >>= 16;
nkeynes@359	1269	}
nkeynes@359	1270	break;
nkeynes@359	1271	default:
nkeynes@359	1272	UNDEF();
nkeynes@359	1273	break;
nkeynes@359	1274	}
nkeynes@359	1275	break;
nkeynes@359	1276	case 0xA:
nkeynes@359	1277	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	1278	case 0x0:
nkeynes@359	1279	{ /* LDS Rm, MACH */
nkeynes@359	1280	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1281	sh4r.mac = (sh4r.mac & 0x00000000FFFFFFFF) \|
nkeynes@359	1282	(((uint64_t)sh4r.r[Rm])<<32);
nkeynes@359	1283	}
nkeynes@359	1284	break;
nkeynes@359	1285	case 0x1:
nkeynes@359	1286	{ /* LDS Rm, MACL */
nkeynes@359	1287	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1288	sh4r.mac = (sh4r.mac & 0xFFFFFFFF00000000LL) \|
nkeynes@359	1289	(uint64_t)((uint32_t)(sh4r.r[Rm]));
nkeynes@359	1290	}
nkeynes@359	1291	break;
nkeynes@359	1292	case 0x2:
nkeynes@359	1293	{ /* LDS Rm, PR */
nkeynes@359	1294	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1295	sh4r.pr = sh4r.r[Rm];
nkeynes@359	1296	}
nkeynes@359	1297	break;
nkeynes@359	1298	case 0x3:
nkeynes@359	1299	{ /* LDC Rm, SGR */
nkeynes@359	1300	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1301	CHECKPRIV();
nkeynes@359	1302	sh4r.sgr = sh4r.r[Rm];
nkeynes@359	1303	}
nkeynes@359	1304	break;
nkeynes@359	1305	case 0x5:
nkeynes@359	1306	{ /* LDS Rm, FPUL */
nkeynes@359	1307	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@626	1308	CHECKFPUEN();
nkeynes@669	1309	FPULi = sh4r.r[Rm];
nkeynes@359	1310	}
nkeynes@359	1311	break;
nkeynes@359	1312	case 0x6:
nkeynes@359	1313	{ /* LDS Rm, FPSCR */
nkeynes@359	1314	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@626	1315	CHECKFPUEN();
nkeynes@669	1316	sh4_write_fpscr( sh4r.r[Rm] );
nkeynes@359	1317	}
nkeynes@359	1318	break;
nkeynes@359	1319	case 0xF:
nkeynes@359	1320	{ /* LDC Rm, DBR */
nkeynes@359	1321	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1322	CHECKPRIV();
nkeynes@359	1323	sh4r.dbr = sh4r.r[Rm];
nkeynes@359	1324	}
nkeynes@359	1325	break;
nkeynes@359	1326	default:
nkeynes@359	1327	UNDEF();
nkeynes@359	1328	break;
nkeynes@359	1329	}
nkeynes@359	1330	break;
nkeynes@359	1331	case 0xB:
nkeynes@359	1332	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	1333	case 0x0:
nkeynes@359	1334	{ /* JSR @Rn */
nkeynes@359	1335	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1336	CHECKDEST( sh4r.r[Rn] );
nkeynes@359	1337	CHECKSLOTILLEGAL();
nkeynes@359	1338	sh4r.in_delay_slot = 1;
nkeynes@359	1339	sh4r.pc = sh4r.new_pc;
nkeynes@359	1340	sh4r.new_pc = sh4r.r[Rn];
nkeynes@359	1341	sh4r.pr = pc + 4;
nkeynes@359	1342	TRACE_CALL( pc, sh4r.new_pc );
nkeynes@359	1343	return TRUE;
nkeynes@359	1344	}
nkeynes@359	1345	break;
nkeynes@359	1346	case 0x1:
nkeynes@359	1347	{ /* TAS.B @Rn */
nkeynes@359	1348	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@586	1349	MEM_READ_BYTE( sh4r.r[Rn], tmp );
nkeynes@359	1350	sh4r.t = ( tmp == 0 ? 1 : 0 );
nkeynes@359	1351	MEM_WRITE_BYTE( sh4r.r[Rn], tmp \| 0x80 );
nkeynes@359	1352	}
nkeynes@359	1353	break;
nkeynes@359	1354	case 0x2:
nkeynes@359	1355	{ /* JMP @Rn */
nkeynes@359	1356	uint32_t Rn = ((ir>>8)&0xF);
nkeynes@359	1357	CHECKDEST( sh4r.r[Rn] );
nkeynes@359	1358	CHECKSLOTILLEGAL();
nkeynes@359	1359	sh4r.in_delay_slot = 1;
nkeynes@359	1360	sh4r.pc = sh4r.new_pc;
nkeynes@359	1361	sh4r.new_pc = sh4r.r[Rn];
nkeynes@359	1362	return TRUE;
nkeynes@359	1363	}
nkeynes@359	1364	break;
nkeynes@359	1365	default:
nkeynes@359	1366	UNDEF();
nkeynes@359	1367	break;
nkeynes@359	1368	}
nkeynes@359	1369	break;
nkeynes@359	1370	case 0xC:
nkeynes@359	1371	{ /* SHAD Rm, Rn */
nkeynes@359	1372	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1373	tmp = sh4r.r[Rm];
nkeynes@359	1374	if( (tmp & 0x80000000) == 0 ) sh4r.r[Rn] <<= (tmp&0x1f);
nkeynes@359	1375	else if( (tmp & 0x1F) == 0 )
nkeynes@359	1376	sh4r.r[Rn] = ((int32_t)sh4r.r[Rn]) >> 31;
nkeynes@359	1377	else
nkeynes@359	1378	sh4r.r[Rn] = ((int32_t)sh4r.r[Rn]) >> (((~sh4r.r[Rm]) & 0x1F)+1);
nkeynes@359	1379	}
nkeynes@359	1380	break;
nkeynes@359	1381	case 0xD:
nkeynes@359	1382	{ /* SHLD Rm, Rn */
nkeynes@359	1383	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1384	tmp = sh4r.r[Rm];
nkeynes@359	1385	if( (tmp & 0x80000000) == 0 ) sh4r.r[Rn] <<= (tmp&0x1f);
nkeynes@359	1386	else if( (tmp & 0x1F) == 0 ) sh4r.r[Rn] = 0;
nkeynes@359	1387	else sh4r.r[Rn] >>= (((~tmp) & 0x1F)+1);
nkeynes@359	1388	}
nkeynes@359	1389	break;
nkeynes@359	1390	case 0xE:
nkeynes@359	1391	switch( (ir&0x80) >> 7 ) {
nkeynes@359	1392	case 0x0:
nkeynes@359	1393	switch( (ir&0x70) >> 4 ) {
nkeynes@359	1394	case 0x0:
nkeynes@359	1395	{ /* LDC Rm, SR */
nkeynes@359	1396	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1397	CHECKSLOTILLEGAL();
nkeynes@359	1398	CHECKPRIV();
nkeynes@374	1399	sh4_write_sr( sh4r.r[Rm] );
nkeynes@359	1400	}
nkeynes@359	1401	break;
nkeynes@359	1402	case 0x1:
nkeynes@359	1403	{ /* LDC Rm, GBR */
nkeynes@359	1404	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1405	sh4r.gbr = sh4r.r[Rm];
nkeynes@359	1406	}
nkeynes@359	1407	break;
nkeynes@359	1408	case 0x2:
nkeynes@359	1409	{ /* LDC Rm, VBR */
nkeynes@359	1410	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1411	CHECKPRIV();
nkeynes@359	1412	sh4r.vbr = sh4r.r[Rm];
nkeynes@359	1413	}
nkeynes@359	1414	break;
nkeynes@359	1415	case 0x3:
nkeynes@359	1416	{ /* LDC Rm, SSR */
nkeynes@359	1417	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1418	CHECKPRIV();
nkeynes@359	1419	sh4r.ssr = sh4r.r[Rm];
nkeynes@359	1420	}
nkeynes@359	1421	break;
nkeynes@359	1422	case 0x4:
nkeynes@359	1423	{ /* LDC Rm, SPC */
nkeynes@359	1424	uint32_t Rm = ((ir>>8)&0xF);
nkeynes@359	1425	CHECKPRIV();
nkeynes@359	1426	sh4r.spc = sh4r.r[Rm];
nkeynes@359	1427	}
nkeynes@359	1428	break;
nkeynes@359	1429	default:
nkeynes@359	1430	UNDEF();
nkeynes@359	1431	break;
nkeynes@359	1432	}
nkeynes@359	1433	break;
nkeynes@359	1434	case 0x1:
nkeynes@359	1435	{ /* LDC Rm, Rn_BANK */
nkeynes@359	1436	uint32_t Rm = ((ir>>8)&0xF); uint32_t Rn_BANK = ((ir>>4)&0x7);
nkeynes@359	1437	CHECKPRIV();
nkeynes@359	1438	sh4r.r_bank[Rn_BANK] = sh4r.r[Rm];
nkeynes@359	1439	}
nkeynes@359	1440	break;
nkeynes@359	1441	}
nkeynes@359	1442	break;
nkeynes@359	1443	case 0xF:
nkeynes@359	1444	{ /* MAC.W @Rm+, @Rn+ */
nkeynes@359	1445	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@587	1446	int32_t stmp;
nkeynes@587	1447	if( Rm == Rn ) {
nkeynes@587	1448	CHECKRALIGN16(sh4r.r[Rn]);
nkeynes@587	1449	MEM_READ_WORD( sh4r.r[Rn], tmp );
nkeynes@587	1450	stmp = SIGNEXT16(tmp);
nkeynes@587	1451	MEM_READ_WORD( sh4r.r[Rn]+2, tmp );
nkeynes@587	1452	stmp *= SIGNEXT16(tmp);
nkeynes@587	1453	sh4r.r[Rn] += 4;
nkeynes@587	1454	} else {
nkeynes@587	1455	CHECKRALIGN16( sh4r.r[Rn] );
nkeynes@587	1456	CHECKRALIGN16( sh4r.r[Rm] );
nkeynes@587	1457	MEM_READ_WORD(sh4r.r[Rn], tmp);
nkeynes@587	1458	stmp = SIGNEXT16(tmp);
nkeynes@587	1459	MEM_READ_WORD(sh4r.r[Rm], tmp);
nkeynes@587	1460	stmp = stmp * SIGNEXT16(tmp);
nkeynes@587	1461	sh4r.r[Rn] += 2;
nkeynes@587	1462	sh4r.r[Rm] += 2;
nkeynes@587	1463	}
nkeynes@359	1464	if( sh4r.s ) {
nkeynes@359	1465	int64_t tmpl = (int64_t)((int32_t)sh4r.mac) + (int64_t)stmp;
nkeynes@359	1466	if( tmpl > (int64_t)0x000000007FFFFFFFLL ) {
nkeynes@359	1467	sh4r.mac = 0x000000017FFFFFFFLL;
nkeynes@359	1468	} else if( tmpl < (int64_t)0xFFFFFFFF80000000LL ) {
nkeynes@359	1469	sh4r.mac = 0x0000000180000000LL;
nkeynes@359	1470	} else {
nkeynes@359	1471	sh4r.mac = (sh4r.mac & 0xFFFFFFFF00000000LL) \|
nkeynes@359	1472	((uint32_t)(sh4r.mac + stmp));
nkeynes@359	1473	}
nkeynes@359	1474	} else {
nkeynes@359	1475	sh4r.mac += SIGNEXT32(stmp);
nkeynes@359	1476	}
nkeynes@359	1477	}
nkeynes@359	1478	break;
nkeynes@359	1479	}
nkeynes@359	1480	break;
nkeynes@359	1481	case 0x5:
nkeynes@359	1482	{ /* MOV.L @(disp, Rm), Rn */
nkeynes@359	1483	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF); uint32_t disp = (ir&0xF)<<2;
nkeynes@359	1484	tmp = sh4r.r[Rm] + disp;
nkeynes@359	1485	CHECKRALIGN32( tmp );
nkeynes@586	1486	MEM_READ_LONG( tmp, sh4r.r[Rn] );
nkeynes@359	1487	}
nkeynes@359	1488	break;
nkeynes@359	1489	case 0x6:
nkeynes@359	1490	switch( ir&0xF ) {
nkeynes@359	1491	case 0x0:
nkeynes@359	1492	{ /* MOV.B @Rm, Rn */
nkeynes@359	1493	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@586	1494	MEM_READ_BYTE( sh4r.r[Rm], sh4r.r[Rn] );
nkeynes@359	1495	}
nkeynes@359	1496	break;
nkeynes@359	1497	case 0x1:
nkeynes@359	1498	{ /* MOV.W @Rm, Rn */
nkeynes@359	1499	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@586	1500	CHECKRALIGN16( sh4r.r[Rm] ); MEM_READ_WORD( sh4r.r[Rm], sh4r.r[Rn] );
nkeynes@359	1501	}
nkeynes@359	1502	break;
nkeynes@359	1503	case 0x2:
nkeynes@359	1504	{ /* MOV.L @Rm, Rn */
nkeynes@359	1505	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@586	1506	CHECKRALIGN32( sh4r.r[Rm] ); MEM_READ_LONG( sh4r.r[Rm], sh4r.r[Rn] );
nkeynes@359	1507	}
nkeynes@359	1508	break;
nkeynes@359	1509	case 0x3:
nkeynes@359	1510	{ /* MOV Rm, Rn */
nkeynes@359	1511	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1512	sh4r.r[Rn] = sh4r.r[Rm];
nkeynes@359	1513	}
nkeynes@359	1514	break;
nkeynes@359	1515	case 0x4:
nkeynes@359	1516	{ /* MOV.B @Rm+, Rn */
nkeynes@359	1517	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@586	1518	MEM_READ_BYTE( sh4r.r[Rm], sh4r.r[Rn] ); sh4r.r[Rm] ++;
nkeynes@359	1519	}
nkeynes@359	1520	break;
nkeynes@359	1521	case 0x5:
nkeynes@359	1522	{ /* MOV.W @Rm+, Rn */
nkeynes@359	1523	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@586	1524	CHECKRALIGN16( sh4r.r[Rm] ); MEM_READ_WORD( sh4r.r[Rm], sh4r.r[Rn] ); sh4r.r[Rm] += 2;
nkeynes@359	1525	}
nkeynes@359	1526	break;
nkeynes@359	1527	case 0x6:
nkeynes@359	1528	{ /* MOV.L @Rm+, Rn */
nkeynes@359	1529	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@586	1530	CHECKRALIGN32( sh4r.r[Rm] ); MEM_READ_LONG( sh4r.r[Rm], sh4r.r[Rn] ); sh4r.r[Rm] += 4;
nkeynes@359	1531	}
nkeynes@359	1532	break;
nkeynes@359	1533	case 0x7:
nkeynes@359	1534	{ /* NOT Rm, Rn */
nkeynes@359	1535	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1536	sh4r.r[Rn] = ~sh4r.r[Rm];
nkeynes@359	1537	}
nkeynes@359	1538	break;
nkeynes@359	1539	case 0x8:
nkeynes@359	1540	{ /* SWAP.B Rm, Rn */
nkeynes@359	1541	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1542	sh4r.r[Rn] = (sh4r.r[Rm]&0xFFFF0000) \| ((sh4r.r[Rm]&0x0000FF00)>>8) \| ((sh4r.r[Rm]&0x000000FF)<<8);
nkeynes@359	1543	}
nkeynes@359	1544	break;
nkeynes@359	1545	case 0x9:
nkeynes@359	1546	{ /* SWAP.W Rm, Rn */
nkeynes@359	1547	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1548	sh4r.r[Rn] = (sh4r.r[Rm]>>16) \| (sh4r.r[Rm]<<16);
nkeynes@359	1549	}
nkeynes@359	1550	break;
nkeynes@359	1551	case 0xA:
nkeynes@359	1552	{ /* NEGC Rm, Rn */
nkeynes@359	1553	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1554	tmp = 0 - sh4r.r[Rm];
nkeynes@359	1555	sh4r.r[Rn] = tmp - sh4r.t;
nkeynes@359	1556	sh4r.t = ( 0<tmp \|\| tmp<sh4r.r[Rn] ? 1 : 0 );
nkeynes@359	1557	}
nkeynes@359	1558	break;
nkeynes@359	1559	case 0xB:
nkeynes@359	1560	{ /* NEG Rm, Rn */
nkeynes@359	1561	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1562	sh4r.r[Rn] = 0 - sh4r.r[Rm];
nkeynes@359	1563	}
nkeynes@359	1564	break;
nkeynes@359	1565	case 0xC:
nkeynes@359	1566	{ /* EXTU.B Rm, Rn */
nkeynes@359	1567	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1568	sh4r.r[Rn] = sh4r.r[Rm]&0x000000FF;
nkeynes@359	1569	}
nkeynes@359	1570	break;
nkeynes@359	1571	case 0xD:
nkeynes@359	1572	{ /* EXTU.W Rm, Rn */
nkeynes@359	1573	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1574	sh4r.r[Rn] = sh4r.r[Rm]&0x0000FFFF;
nkeynes@359	1575	}
nkeynes@359	1576	break;
nkeynes@359	1577	case 0xE:
nkeynes@359	1578	{ /* EXTS.B Rm, Rn */
nkeynes@359	1579	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1580	sh4r.r[Rn] = SIGNEXT8( sh4r.r[Rm]&0x000000FF );
nkeynes@359	1581	}
nkeynes@359	1582	break;
nkeynes@359	1583	case 0xF:
nkeynes@359	1584	{ /* EXTS.W Rm, Rn */
nkeynes@359	1585	uint32_t Rn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1586	sh4r.r[Rn] = SIGNEXT16( sh4r.r[Rm]&0x0000FFFF );
nkeynes@359	1587	}
nkeynes@359	1588	break;
nkeynes@359	1589	}
nkeynes@359	1590	break;
nkeynes@359	1591	case 0x7:
nkeynes@359	1592	{ /* ADD #imm, Rn */
nkeynes@359	1593	uint32_t Rn = ((ir>>8)&0xF); int32_t imm = SIGNEXT8(ir&0xFF);
nkeynes@359	1594	sh4r.r[Rn] += imm;
nkeynes@359	1595	}
nkeynes@359	1596	break;
nkeynes@359	1597	case 0x8:
nkeynes@359	1598	switch( (ir&0xF00) >> 8 ) {
nkeynes@359	1599	case 0x0:
nkeynes@359	1600	{ /* MOV.B R0, @(disp, Rn) */
nkeynes@359	1601	uint32_t Rn = ((ir>>4)&0xF); uint32_t disp = (ir&0xF);
nkeynes@359	1602	MEM_WRITE_BYTE( sh4r.r[Rn] + disp, R0 );
nkeynes@359	1603	}
nkeynes@359	1604	break;
nkeynes@359	1605	case 0x1:
nkeynes@359	1606	{ /* MOV.W R0, @(disp, Rn) */
nkeynes@359	1607	uint32_t Rn = ((ir>>4)&0xF); uint32_t disp = (ir&0xF)<<1;
nkeynes@359	1608	tmp = sh4r.r[Rn] + disp;
nkeynes@359	1609	CHECKWALIGN16( tmp );
nkeynes@359	1610	MEM_WRITE_WORD( tmp, R0 );
nkeynes@359	1611	}
nkeynes@359	1612	break;
nkeynes@359	1613	case 0x4:
nkeynes@359	1614	{ /* MOV.B @(disp, Rm), R0 */
nkeynes@359	1615	uint32_t Rm = ((ir>>4)&0xF); uint32_t disp = (ir&0xF);
nkeynes@586	1616	MEM_READ_BYTE( sh4r.r[Rm] + disp, R0 );
nkeynes@359	1617	}
nkeynes@359	1618	break;
nkeynes@359	1619	case 0x5:
nkeynes@359	1620	{ /* MOV.W @(disp, Rm), R0 */
nkeynes@359	1621	uint32_t Rm = ((ir>>4)&0xF); uint32_t disp = (ir&0xF)<<1;
nkeynes@359	1622	tmp = sh4r.r[Rm] + disp;
nkeynes@359	1623	CHECKRALIGN16( tmp );
nkeynes@586	1624	MEM_READ_WORD( tmp, R0 );
nkeynes@359	1625	}
nkeynes@359	1626	break;
nkeynes@359	1627	case 0x8:
nkeynes@359	1628	{ /* CMP/EQ #imm, R0 */
nkeynes@359	1629	int32_t imm = SIGNEXT8(ir&0xFF);
nkeynes@359	1630	sh4r.t = ( R0 == imm ? 1 : 0 );
nkeynes@359	1631	}
nkeynes@359	1632	break;
nkeynes@359	1633	case 0x9:
nkeynes@359	1634	{ /* BT disp */
nkeynes@359	1635	int32_t disp = SIGNEXT8(ir&0xFF)<<1;
nkeynes@359	1636	CHECKSLOTILLEGAL();
nkeynes@359	1637	if( sh4r.t ) {
nkeynes@359	1638	CHECKDEST( sh4r.pc + disp + 4 )
nkeynes@359	1639	sh4r.pc += disp + 4;
nkeynes@359	1640	sh4r.new_pc = sh4r.pc + 2;
nkeynes@27	1641	return TRUE;
nkeynes@359	1642	}
nkeynes@359	1643	}
nkeynes@359	1644	break;
nkeynes@359	1645	case 0xB:
nkeynes@359	1646	{ /* BF disp */
nkeynes@359	1647	int32_t disp = SIGNEXT8(ir&0xFF)<<1;
nkeynes@359	1648	CHECKSLOTILLEGAL();
nkeynes@359	1649	if( !sh4r.t ) {
nkeynes@359	1650	CHECKDEST( sh4r.pc + disp + 4 )
nkeynes@359	1651	sh4r.pc += disp + 4;
nkeynes@359	1652	sh4r.new_pc = sh4r.pc + 2;
nkeynes@359	1653	return TRUE;
nkeynes@359	1654	}
nkeynes@359	1655	}
nkeynes@359	1656	break;
nkeynes@359	1657	case 0xD:
nkeynes@359	1658	{ /* BT/S disp */
nkeynes@359	1659	int32_t disp = SIGNEXT8(ir&0xFF)<<1;
nkeynes@359	1660	CHECKSLOTILLEGAL();
nkeynes@359	1661	if( sh4r.t ) {
nkeynes@359	1662	CHECKDEST( sh4r.pc + disp + 4 )
nkeynes@2	1663	sh4r.in_delay_slot = 1;
nkeynes@1	1664	sh4r.pc = sh4r.new_pc;
nkeynes@359	1665	sh4r.new_pc = pc + disp + 4;
nkeynes@359	1666	sh4r.in_delay_slot = 1;
nkeynes@27	1667	return TRUE;
nkeynes@359	1668	}
nkeynes@359	1669	}
nkeynes@359	1670	break;
nkeynes@359	1671	case 0xF:
nkeynes@359	1672	{ /* BF/S disp */
nkeynes@359	1673	int32_t disp = SIGNEXT8(ir&0xFF)<<1;
nkeynes@359	1674	CHECKSLOTILLEGAL();
nkeynes@359	1675	if( !sh4r.t ) {
nkeynes@359	1676	CHECKDEST( sh4r.pc + disp + 4 )
nkeynes@2	1677	sh4r.in_delay_slot = 1;
nkeynes@1	1678	sh4r.pc = sh4r.new_pc;
nkeynes@359	1679	sh4r.new_pc = pc + disp + 4;
nkeynes@27	1680	return TRUE;
nkeynes@359	1681	}
nkeynes@359	1682	}
nkeynes@359	1683	break;
nkeynes@359	1684	default:
nkeynes@359	1685	UNDEF();
nkeynes@359	1686	break;
nkeynes@359	1687	}
nkeynes@359	1688	break;
nkeynes@359	1689	case 0x9:
nkeynes@359	1690	{ /* MOV.W @(disp, PC), Rn */
nkeynes@359	1691	uint32_t Rn = ((ir>>8)&0xF); uint32_t disp = (ir&0xFF)<<1;
nkeynes@359	1692	CHECKSLOTILLEGAL();
nkeynes@359	1693	tmp = pc + 4 + disp;
nkeynes@586	1694	MEM_READ_WORD( tmp, sh4r.r[Rn] );
nkeynes@359	1695	}
nkeynes@359	1696	break;
nkeynes@359	1697	case 0xA:
nkeynes@359	1698	{ /* BRA disp */
nkeynes@359	1699	int32_t disp = SIGNEXT12(ir&0xFFF)<<1;
nkeynes@359	1700	CHECKSLOTILLEGAL();
nkeynes@359	1701	CHECKDEST( sh4r.pc + disp + 4 );
nkeynes@359	1702	sh4r.in_delay_slot = 1;
nkeynes@359	1703	sh4r.pc = sh4r.new_pc;
nkeynes@359	1704	sh4r.new_pc = pc + 4 + disp;
nkeynes@359	1705	return TRUE;
nkeynes@359	1706	}
nkeynes@359	1707	break;
nkeynes@359	1708	case 0xB:
nkeynes@359	1709	{ /* BSR disp */
nkeynes@359	1710	int32_t disp = SIGNEXT12(ir&0xFFF)<<1;
nkeynes@359	1711	CHECKDEST( sh4r.pc + disp + 4 );
nkeynes@359	1712	CHECKSLOTILLEGAL();
nkeynes@359	1713	sh4r.in_delay_slot = 1;
nkeynes@359	1714	sh4r.pr = pc + 4;
nkeynes@359	1715	sh4r.pc = sh4r.new_pc;
nkeynes@359	1716	sh4r.new_pc = pc + 4 + disp;
nkeynes@359	1717	TRACE_CALL( pc, sh4r.new_pc );
nkeynes@359	1718	return TRUE;
nkeynes@359	1719	}
nkeynes@359	1720	break;
nkeynes@359	1721	case 0xC:
nkeynes@359	1722	switch( (ir&0xF00) >> 8 ) {
nkeynes@359	1723	case 0x0:
nkeynes@359	1724	{ /* MOV.B R0, @(disp, GBR) */
nkeynes@359	1725	uint32_t disp = (ir&0xFF);
nkeynes@359	1726	MEM_WRITE_BYTE( sh4r.gbr + disp, R0 );
nkeynes@359	1727	}
nkeynes@359	1728	break;
nkeynes@359	1729	case 0x1:
nkeynes@359	1730	{ /* MOV.W R0, @(disp, GBR) */
nkeynes@359	1731	uint32_t disp = (ir&0xFF)<<1;
nkeynes@359	1732	tmp = sh4r.gbr + disp;
nkeynes@359	1733	CHECKWALIGN16( tmp );
nkeynes@359	1734	MEM_WRITE_WORD( tmp, R0 );
nkeynes@359	1735	}
nkeynes@359	1736	break;
nkeynes@359	1737	case 0x2:
nkeynes@359	1738	{ /* MOV.L R0, @(disp, GBR) */
nkeynes@359	1739	uint32_t disp = (ir&0xFF)<<2;
nkeynes@359	1740	tmp = sh4r.gbr + disp;
nkeynes@359	1741	CHECKWALIGN32( tmp );
nkeynes@359	1742	MEM_WRITE_LONG( tmp, R0 );
nkeynes@359	1743	}
nkeynes@359	1744	break;
nkeynes@359	1745	case 0x3:
nkeynes@359	1746	{ /* TRAPA #imm */
nkeynes@359	1747	uint32_t imm = (ir&0xFF);
nkeynes@359	1748	CHECKSLOTILLEGAL();
nkeynes@359	1749	sh4r.pc += 2;
nkeynes@586	1750	sh4_raise_trap( imm );
nkeynes@586	1751	return TRUE;
nkeynes@359	1752	}
nkeynes@359	1753	break;
nkeynes@359	1754	case 0x4:
nkeynes@359	1755	{ /* MOV.B @(disp, GBR), R0 */
nkeynes@359	1756	uint32_t disp = (ir&0xFF);
nkeynes@586	1757	MEM_READ_BYTE( sh4r.gbr + disp, R0 );
nkeynes@359	1758	}
nkeynes@359	1759	break;
nkeynes@359	1760	case 0x5:
nkeynes@359	1761	{ /* MOV.W @(disp, GBR), R0 */
nkeynes@359	1762	uint32_t disp = (ir&0xFF)<<1;
nkeynes@359	1763	tmp = sh4r.gbr + disp;
nkeynes@359	1764	CHECKRALIGN16( tmp );
nkeynes@586	1765	MEM_READ_WORD( tmp, R0 );
nkeynes@359	1766	}
nkeynes@359	1767	break;
nkeynes@359	1768	case 0x6:
nkeynes@359	1769	{ /* MOV.L @(disp, GBR), R0 */
nkeynes@359	1770	uint32_t disp = (ir&0xFF)<<2;
nkeynes@359	1771	tmp = sh4r.gbr + disp;
nkeynes@359	1772	CHECKRALIGN32( tmp );
nkeynes@586	1773	MEM_READ_LONG( tmp, R0 );
nkeynes@359	1774	}
nkeynes@359	1775	break;
nkeynes@359	1776	case 0x7:
nkeynes@359	1777	{ /* MOVA @(disp, PC), R0 */
nkeynes@359	1778	uint32_t disp = (ir&0xFF)<<2;
nkeynes@359	1779	CHECKSLOTILLEGAL();
nkeynes@359	1780	R0 = (pc&0xFFFFFFFC) + disp + 4;
nkeynes@359	1781	}
nkeynes@359	1782	break;
nkeynes@359	1783	case 0x8:
nkeynes@359	1784	{ /* TST #imm, R0 */
nkeynes@359	1785	uint32_t imm = (ir&0xFF);
nkeynes@359	1786	sh4r.t = (R0 & imm ? 0 : 1);
nkeynes@359	1787	}
nkeynes@359	1788	break;
nkeynes@359	1789	case 0x9:
nkeynes@359	1790	{ /* AND #imm, R0 */
nkeynes@359	1791	uint32_t imm = (ir&0xFF);
nkeynes@359	1792	R0 &= imm;
nkeynes@359	1793	}
nkeynes@359	1794	break;
nkeynes@359	1795	case 0xA:
nkeynes@359	1796	{ /* XOR #imm, R0 */
nkeynes@359	1797	uint32_t imm = (ir&0xFF);
nkeynes@359	1798	R0 ^= imm;
nkeynes@359	1799	}
nkeynes@359	1800	break;
nkeynes@359	1801	case 0xB:
nkeynes@359	1802	{ /* OR #imm, R0 */
nkeynes@359	1803	uint32_t imm = (ir&0xFF);
nkeynes@359	1804	R0 \|= imm;
nkeynes@359	1805	}
nkeynes@359	1806	break;
nkeynes@359	1807	case 0xC:
nkeynes@359	1808	{ /* TST.B #imm, @(R0, GBR) */
nkeynes@359	1809	uint32_t imm = (ir&0xFF);
nkeynes@586	1810	MEM_READ_BYTE(R0+sh4r.gbr, tmp); sh4r.t = ( tmp & imm ? 0 : 1 );
nkeynes@359	1811	}
nkeynes@359	1812	break;
nkeynes@359	1813	case 0xD:
nkeynes@359	1814	{ /* AND.B #imm, @(R0, GBR) */
nkeynes@359	1815	uint32_t imm = (ir&0xFF);
nkeynes@586	1816	MEM_READ_BYTE(R0+sh4r.gbr, tmp); MEM_WRITE_BYTE( R0 + sh4r.gbr, imm & tmp );
nkeynes@359	1817	}
nkeynes@359	1818	break;
nkeynes@359	1819	case 0xE:
nkeynes@359	1820	{ /* XOR.B #imm, @(R0, GBR) */
nkeynes@359	1821	uint32_t imm = (ir&0xFF);
nkeynes@586	1822	MEM_READ_BYTE(R0+sh4r.gbr, tmp); MEM_WRITE_BYTE( R0 + sh4r.gbr, imm ^ tmp );
nkeynes@359	1823	}
nkeynes@359	1824	break;
nkeynes@359	1825	case 0xF:
nkeynes@359	1826	{ /* OR.B #imm, @(R0, GBR) */
nkeynes@359	1827	uint32_t imm = (ir&0xFF);
nkeynes@586	1828	MEM_READ_BYTE(R0+sh4r.gbr, tmp); MEM_WRITE_BYTE( R0 + sh4r.gbr, imm \| tmp );
nkeynes@359	1829	}
nkeynes@359	1830	break;
nkeynes@359	1831	}
nkeynes@359	1832	break;
nkeynes@359	1833	case 0xD:
nkeynes@359	1834	{ /* MOV.L @(disp, PC), Rn */
nkeynes@359	1835	uint32_t Rn = ((ir>>8)&0xF); uint32_t disp = (ir&0xFF)<<2;
nkeynes@359	1836	CHECKSLOTILLEGAL();
nkeynes@359	1837	tmp = (pc&0xFFFFFFFC) + disp + 4;
nkeynes@586	1838	MEM_READ_LONG( tmp, sh4r.r[Rn] );
nkeynes@359	1839	}
nkeynes@359	1840	break;
nkeynes@359	1841	case 0xE:
nkeynes@359	1842	{ /* MOV #imm, Rn */
nkeynes@359	1843	uint32_t Rn = ((ir>>8)&0xF); int32_t imm = SIGNEXT8(ir&0xFF);
nkeynes@359	1844	sh4r.r[Rn] = imm;
nkeynes@359	1845	}
nkeynes@359	1846	break;
nkeynes@359	1847	case 0xF:
nkeynes@359	1848	switch( ir&0xF ) {
nkeynes@359	1849	case 0x0:
nkeynes@359	1850	{ /* FADD FRm, FRn */
nkeynes@359	1851	uint32_t FRn = ((ir>>8)&0xF); uint32_t FRm = ((ir>>4)&0xF);
nkeynes@359	1852	CHECKFPUEN();
nkeynes@359	1853	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@359	1854	DR(FRn) += DR(FRm);
nkeynes@359	1855	} else {
nkeynes@359	1856	FR(FRn) += FR(FRm);
nkeynes@359	1857	}
nkeynes@359	1858	}
nkeynes@359	1859	break;
nkeynes@359	1860	case 0x1:
nkeynes@359	1861	{ /* FSUB FRm, FRn */
nkeynes@359	1862	uint32_t FRn = ((ir>>8)&0xF); uint32_t FRm = ((ir>>4)&0xF);
nkeynes@359	1863	CHECKFPUEN();
nkeynes@359	1864	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@359	1865	DR(FRn) -= DR(FRm);
nkeynes@359	1866	} else {
nkeynes@359	1867	FR(FRn) -= FR(FRm);
nkeynes@359	1868	}
nkeynes@359	1869	}
nkeynes@359	1870	break;
nkeynes@359	1871	case 0x2:
nkeynes@359	1872	{ /* FMUL FRm, FRn */
nkeynes@359	1873	uint32_t FRn = ((ir>>8)&0xF); uint32_t FRm = ((ir>>4)&0xF);
nkeynes@359	1874	CHECKFPUEN();
nkeynes@359	1875	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@359	1876	DR(FRn) *= DR(FRm);
nkeynes@359	1877	} else {
nkeynes@359	1878	FR(FRn) *= FR(FRm);
nkeynes@359	1879	}
nkeynes@359	1880	}
nkeynes@359	1881	break;
nkeynes@359	1882	case 0x3:
nkeynes@359	1883	{ /* FDIV FRm, FRn */
nkeynes@359	1884	uint32_t FRn = ((ir>>8)&0xF); uint32_t FRm = ((ir>>4)&0xF);
nkeynes@359	1885	CHECKFPUEN();
nkeynes@359	1886	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@359	1887	DR(FRn) /= DR(FRm);
nkeynes@359	1888	} else {
nkeynes@359	1889	FR(FRn) /= FR(FRm);
nkeynes@359	1890	}
nkeynes@359	1891	}
nkeynes@359	1892	break;
nkeynes@359	1893	case 0x4:
nkeynes@359	1894	{ /* FCMP/EQ FRm, FRn */
nkeynes@359	1895	uint32_t FRn = ((ir>>8)&0xF); uint32_t FRm = ((ir>>4)&0xF);
nkeynes@359	1896	CHECKFPUEN();
nkeynes@359	1897	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@359	1898	sh4r.t = ( DR(FRn) == DR(FRm) ? 1 : 0 );
nkeynes@359	1899	} else {
nkeynes@359	1900	sh4r.t = ( FR(FRn) == FR(FRm) ? 1 : 0 );
nkeynes@359	1901	}
nkeynes@359	1902	}
nkeynes@359	1903	break;
nkeynes@359	1904	case 0x5:
nkeynes@359	1905	{ /* FCMP/GT FRm, FRn */
nkeynes@359	1906	uint32_t FRn = ((ir>>8)&0xF); uint32_t FRm = ((ir>>4)&0xF);
nkeynes@359	1907	CHECKFPUEN();
nkeynes@359	1908	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@359	1909	sh4r.t = ( DR(FRn) > DR(FRm) ? 1 : 0 );
nkeynes@359	1910	} else {
nkeynes@359	1911	sh4r.t = ( FR(FRn) > FR(FRm) ? 1 : 0 );
nkeynes@359	1912	}
nkeynes@359	1913	}
nkeynes@359	1914	break;
nkeynes@359	1915	case 0x6:
nkeynes@359	1916	{ /* FMOV @(R0, Rm), FRn */
nkeynes@359	1917	uint32_t FRn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1918	MEM_FP_READ( sh4r.r[Rm] + R0, FRn );
nkeynes@359	1919	}
nkeynes@359	1920	break;
nkeynes@359	1921	case 0x7:
nkeynes@359	1922	{ /* FMOV FRm, @(R0, Rn) */
nkeynes@359	1923	uint32_t Rn = ((ir>>8)&0xF); uint32_t FRm = ((ir>>4)&0xF);
nkeynes@359	1924	MEM_FP_WRITE( sh4r.r[Rn] + R0, FRm );
nkeynes@359	1925	}
nkeynes@359	1926	break;
nkeynes@359	1927	case 0x8:
nkeynes@359	1928	{ /* FMOV @Rm, FRn */
nkeynes@359	1929	uint32_t FRn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1930	MEM_FP_READ( sh4r.r[Rm], FRn );
nkeynes@359	1931	}
nkeynes@359	1932	break;
nkeynes@359	1933	case 0x9:
nkeynes@359	1934	{ /* FMOV @Rm+, FRn */
nkeynes@359	1935	uint32_t FRn = ((ir>>8)&0xF); uint32_t Rm = ((ir>>4)&0xF);
nkeynes@359	1936	MEM_FP_READ( sh4r.r[Rm], FRn ); sh4r.r[Rm] += FP_WIDTH;
nkeynes@359	1937	}
nkeynes@359	1938	break;
nkeynes@359	1939	case 0xA:
nkeynes@359	1940	{ /* FMOV FRm, @Rn */
nkeynes@359	1941	uint32_t Rn = ((ir>>8)&0xF); uint32_t FRm = ((ir>>4)&0xF);
nkeynes@359	1942	MEM_FP_WRITE( sh4r.r[Rn], FRm );
nkeynes@359	1943	}
nkeynes@359	1944	break;
nkeynes@359	1945	case 0xB:
nkeynes@359	1946	{ /* FMOV FRm, @-Rn */
nkeynes@359	1947	uint32_t Rn = ((ir>>8)&0xF); uint32_t FRm = ((ir>>4)&0xF);
nkeynes@587	1948	MEM_FP_WRITE( sh4r.r[Rn] - FP_WIDTH, FRm ); sh4r.r[Rn] -= FP_WIDTH;
nkeynes@359	1949	}
nkeynes@359	1950	break;
nkeynes@359	1951	case 0xC:
nkeynes@359	1952	{ /* FMOV FRm, FRn */
nkeynes@359	1953	uint32_t FRn = ((ir>>8)&0xF); uint32_t FRm = ((ir>>4)&0xF);
nkeynes@359	1954	if( IS_FPU_DOUBLESIZE() )
nkeynes@359	1955	DR(FRn) = DR(FRm);
nkeynes@359	1956	else
nkeynes@359	1957	FR(FRn) = FR(FRm);
nkeynes@359	1958	}
nkeynes@359	1959	break;
nkeynes@359	1960	case 0xD:
nkeynes@359	1961	switch( (ir&0xF0) >> 4 ) {
nkeynes@359	1962	case 0x0:
nkeynes@359	1963	{ /* FSTS FPUL, FRn */
nkeynes@359	1964	uint32_t FRn = ((ir>>8)&0xF);
nkeynes@359	1965	CHECKFPUEN(); FR(FRn) = FPULf;
nkeynes@359	1966	}
nkeynes@359	1967	break;
nkeynes@359	1968	case 0x1:
nkeynes@359	1969	{ /* FLDS FRm, FPUL */
nkeynes@359	1970	uint32_t FRm = ((ir>>8)&0xF);
nkeynes@359	1971	CHECKFPUEN(); FPULf = FR(FRm);
nkeynes@359	1972	}
nkeynes@359	1973	break;
nkeynes@359	1974	case 0x2:
nkeynes@359	1975	{ /* FLOAT FPUL, FRn */
nkeynes@359	1976	uint32_t FRn = ((ir>>8)&0xF);
nkeynes@359	1977	CHECKFPUEN();
nkeynes@374	1978	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@374	1979	if( FRn&1 ) { // No, really...
nkeynes@374	1980	dtmp = (double)FPULi;
nkeynes@374	1981	FR(FRn) = (((float )&dtmp)+1);
nkeynes@374	1982	} else {
nkeynes@374	1983	DRF(FRn>>1) = (double)FPULi;
nkeynes@374	1984	}
nkeynes@374	1985	} else {
nkeynes@359	1986	FR(FRn) = (float)FPULi;
nkeynes@359	1987	}
nkeynes@374	1988	}
nkeynes@359	1989	break;
nkeynes@359	1990	case 0x3:
nkeynes@359	1991	{ /* FTRC FRm, FPUL */
nkeynes@359	1992	uint32_t FRm = ((ir>>8)&0xF);
nkeynes@359	1993	CHECKFPUEN();
nkeynes@359	1994	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@374	1995	if( FRm&1 ) {
nkeynes@374	1996	dtmp = 0;
nkeynes@374	1997	(((float )&dtmp)+1) = FR(FRm);
nkeynes@374	1998	} else {
nkeynes@374	1999	dtmp = DRF(FRm>>1);
nkeynes@374	2000	}
nkeynes@359	2001	if( dtmp >= MAX_INTF )
nkeynes@359	2002	FPULi = MAX_INT;
nkeynes@359	2003	else if( dtmp <= MIN_INTF )
nkeynes@359	2004	FPULi = MIN_INT;
nkeynes@359	2005	else
nkeynes@359	2006	FPULi = (int32_t)dtmp;
nkeynes@359	2007	} else {
nkeynes@359	2008	ftmp = FR(FRm);
nkeynes@359	2009	if( ftmp >= MAX_INTF )
nkeynes@359	2010	FPULi = MAX_INT;
nkeynes@359	2011	else if( ftmp <= MIN_INTF )
nkeynes@359	2012	FPULi = MIN_INT;
nkeynes@359	2013	else
nkeynes@359	2014	FPULi = (int32_t)ftmp;
nkeynes@359	2015	}
nkeynes@359	2016	}
nkeynes@359	2017	break;
nkeynes@359	2018	case 0x4:
nkeynes@359	2019	{ /* FNEG FRn */
nkeynes@359	2020	uint32_t FRn = ((ir>>8)&0xF);
nkeynes@359	2021	CHECKFPUEN();
nkeynes@359	2022	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@359	2023	DR(FRn) = -DR(FRn);
nkeynes@359	2024	} else {
nkeynes@359	2025	FR(FRn) = -FR(FRn);
nkeynes@359	2026	}
nkeynes@359	2027	}
nkeynes@359	2028	break;
nkeynes@359	2029	case 0x5:
nkeynes@359	2030	{ /* FABS FRn */
nkeynes@359	2031	uint32_t FRn = ((ir>>8)&0xF);
nkeynes@359	2032	CHECKFPUEN();
nkeynes@359	2033	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@359	2034	DR(FRn) = fabs(DR(FRn));
nkeynes@359	2035	} else {
nkeynes@359	2036	FR(FRn) = fabsf(FR(FRn));
nkeynes@359	2037	}
nkeynes@359	2038	}
nkeynes@359	2039	break;
nkeynes@359	2040	case 0x6:
nkeynes@359	2041	{ /* FSQRT FRn */
nkeynes@359	2042	uint32_t FRn = ((ir>>8)&0xF);
nkeynes@359	2043	CHECKFPUEN();
nkeynes@359	2044	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@359	2045	DR(FRn) = sqrt(DR(FRn));
nkeynes@359	2046	} else {
nkeynes@359	2047	FR(FRn) = sqrtf(FR(FRn));
nkeynes@359	2048	}
nkeynes@359	2049	}
nkeynes@359	2050	break;
nkeynes@359	2051	case 0x7:
nkeynes@359	2052	{ /* FSRRA FRn */
nkeynes@359	2053	uint32_t FRn = ((ir>>8)&0xF);
nkeynes@359	2054	CHECKFPUEN();
nkeynes@359	2055	if( !IS_FPU_DOUBLEPREC() ) {
nkeynes@359	2056	FR(FRn) = 1.0/sqrtf(FR(FRn));
nkeynes@359	2057	}
nkeynes@359	2058	}
nkeynes@359	2059	break;
nkeynes@359	2060	case 0x8:
nkeynes@359	2061	{ /* FLDI0 FRn */
nkeynes@359	2062	uint32_t FRn = ((ir>>8)&0xF);
nkeynes@359	2063	CHECKFPUEN();
nkeynes@359	2064	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@359	2065	DR(FRn) = 0.0;
nkeynes@359	2066	} else {
nkeynes@359	2067	FR(FRn) = 0.0;
nkeynes@359	2068	}
nkeynes@359	2069	}
nkeynes@359	2070	break;
nkeynes@359	2071	case 0x9:
nkeynes@359	2072	{ /* FLDI1 FRn */
nkeynes@359	2073	uint32_t FRn = ((ir>>8)&0xF);
nkeynes@359	2074	CHECKFPUEN();
nkeynes@359	2075	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@359	2076	DR(FRn) = 1.0;
nkeynes@359	2077	} else {
nkeynes@359	2078	FR(FRn) = 1.0;
nkeynes@359	2079	}
nkeynes@359	2080	}
nkeynes@359	2081	break;
nkeynes@359	2082	case 0xA:
nkeynes@359	2083	{ /* FCNVSD FPUL, FRn */
nkeynes@359	2084	uint32_t FRn = ((ir>>8)&0xF);
nkeynes@359	2085	CHECKFPUEN();
nkeynes@359	2086	if( IS_FPU_DOUBLEPREC() && !IS_FPU_DOUBLESIZE() ) {
nkeynes@359	2087	DR(FRn) = (double)FPULf;
nkeynes@359	2088	}
nkeynes@359	2089	}
nkeynes@359	2090	break;
nkeynes@359	2091	case 0xB:
nkeynes@359	2092	{ /* FCNVDS FRm, FPUL */
nkeynes@359	2093	uint32_t FRm = ((ir>>8)&0xF);
nkeynes@359	2094	CHECKFPUEN();
nkeynes@359	2095	if( IS_FPU_DOUBLEPREC() && !IS_FPU_DOUBLESIZE() ) {
nkeynes@359	2096	FPULf = (float)DR(FRm);
nkeynes@359	2097	}
nkeynes@359	2098	}
nkeynes@359	2099	break;
nkeynes@359	2100	case 0xE:
nkeynes@359	2101	{ /* FIPR FVm, FVn */
nkeynes@359	2102	uint32_t FVn = ((ir>>10)&0x3); uint32_t FVm = ((ir>>8)&0x3);
nkeynes@359	2103	CHECKFPUEN();
nkeynes@359	2104	if( !IS_FPU_DOUBLEPREC() ) {
nkeynes@359	2105	int tmp2 = FVn<<2;
nkeynes@359	2106	tmp = FVm<<2;
nkeynes@359	2107	FR(tmp2+3) = FR(tmp)*FR(tmp2) +
nkeynes@359	2108	FR(tmp+1)*FR(tmp2+1) +
nkeynes@359	2109	FR(tmp+2)*FR(tmp2+2) +
nkeynes@359	2110	FR(tmp+3)*FR(tmp2+3);
nkeynes@359	2111	}
nkeynes@359	2112	}
nkeynes@359	2113	break;
nkeynes@359	2114	case 0xF:
nkeynes@359	2115	switch( (ir&0x100) >> 8 ) {
nkeynes@359	2116	case 0x0:
nkeynes@359	2117	{ /* FSCA FPUL, FRn */
nkeynes@359	2118	uint32_t FRn = ((ir>>9)&0x7)<<1;
nkeynes@359	2119	CHECKFPUEN();
nkeynes@359	2120	if( !IS_FPU_DOUBLEPREC() ) {
nkeynes@391	2121	sh4_fsca( FPULi, &(DRF(FRn>>1)) );
nkeynes@391	2122	/*
nkeynes@359	2123	float angle = (((float)(FPULi&0xFFFF))/65536.0) * 2 * M_PI;
nkeynes@359	2124	FR(FRn) = sinf(angle);
nkeynes@359	2125	FR((FRn)+1) = cosf(angle);
nkeynes@391	2126	*/
nkeynes@359	2127	}
nkeynes@359	2128	}
nkeynes@359	2129	break;
nkeynes@359	2130	case 0x1:
nkeynes@359	2131	switch( (ir&0x200) >> 9 ) {
nkeynes@359	2132	case 0x0:
nkeynes@359	2133	{ /* FTRV XMTRX, FVn */
nkeynes@359	2134	uint32_t FVn = ((ir>>10)&0x3);
nkeynes@359	2135	CHECKFPUEN();
nkeynes@359	2136	if( !IS_FPU_DOUBLEPREC() ) {
nkeynes@669	2137	sh4_ftrv(&(DRF(FVn<<1)) );
nkeynes@359	2138	}
nkeynes@359	2139	}
nkeynes@359	2140	break;
nkeynes@359	2141	case 0x1:
nkeynes@359	2142	switch( (ir&0xC00) >> 10 ) {
nkeynes@359	2143	case 0x0:
nkeynes@359	2144	{ /* FSCHG */
nkeynes@359	2145	CHECKFPUEN(); sh4r.fpscr ^= FPSCR_SZ;
nkeynes@359	2146	}
nkeynes@359	2147	break;
nkeynes@359	2148	case 0x2:
nkeynes@359	2149	{ /* FRCHG */
nkeynes@374	2150	CHECKFPUEN();
nkeynes@374	2151	sh4r.fpscr ^= FPSCR_FR;
nkeynes@669	2152	sh4_switch_fr_banks();
nkeynes@359	2153	}
nkeynes@359	2154	break;
nkeynes@359	2155	case 0x3:
nkeynes@359	2156	{ /* UNDEF */
nkeynes@359	2157	UNDEF(ir);
nkeynes@359	2158	}
nkeynes@359	2159	break;
nkeynes@359	2160	default:
nkeynes@359	2161	UNDEF();
nkeynes@359	2162	break;
nkeynes@359	2163	}
nkeynes@359	2164	break;
nkeynes@359	2165	}
nkeynes@359	2166	break;
nkeynes@359	2167	}
nkeynes@359	2168	break;
nkeynes@359	2169	default:
nkeynes@359	2170	UNDEF();
nkeynes@359	2171	break;
nkeynes@359	2172	}
nkeynes@359	2173	break;
nkeynes@359	2174	case 0xE:
nkeynes@359	2175	{ /* FMAC FR0, FRm, FRn */
nkeynes@359	2176	uint32_t FRn = ((ir>>8)&0xF); uint32_t FRm = ((ir>>4)&0xF);
nkeynes@359	2177	CHECKFPUEN();
nkeynes@359	2178	if( IS_FPU_DOUBLEPREC() ) {
nkeynes@359	2179	DR(FRn) += DR(FRm)*DR(0);
nkeynes@359	2180	} else {
nkeynes@359	2181	FR(FRn) += FR(FRm)*FR(0);
nkeynes@359	2182	}
nkeynes@359	2183	}
nkeynes@359	2184	break;
nkeynes@359	2185	default:
nkeynes@359	2186	UNDEF();
nkeynes@359	2187	break;
nkeynes@359	2188	}
nkeynes@359	2189	break;
nkeynes@359	2190	}
nkeynes@1	2191
nkeynes@1	2192	sh4r.pc = sh4r.new_pc;
nkeynes@1	2193	sh4r.new_pc += 2;
nkeynes@2	2194	sh4r.in_delay_slot = 0;
nkeynes@273	2195	return TRUE;
nkeynes@1	2196	}