lxdream.org :: lxdream/src/sh4/sh4core.c r570:d2893980fbf5 (annotated)

tree revision 570:d2893980fbf5 lxdream-mmu

filename	src/sh4/sh4core.c
changeset	570:d2893980fbf5
prev	569:a1c49e1e8776
next	576:4945fa2ed24f
author	nkeynes
date	Sun Jan 06 12:24:18 2008 +0000 (16 years ago)
branch	lxdream-mmu
permissions	-rw-r--r--
last change	Change to generate different code for mmu on/off cases

file

annotate

diff

log

raw

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