Previous

199869 Revisions

Next

r26777 Friday 27th December, 2013 at 09:46:44 UTC by Wilbert Pol
se3208.c: Modernized cpu core.  [Wilbert Pol]

[src/emu/cpu/se3208]

se3208.c se3208.h

trunk/src/emu/cpu/se3208/se3208.c

r26776	r26777
10	10
11	11	*/
12	12
13		struct se3208_state_t
14		{
15		//GPR
16		UINT32 R[8];
17		//SPR
18		UINT32 PC;
19		UINT32 SR;
20		UINT32 SP;
21		UINT32 ER;
22		UINT32 PPC;
23	13
24		device_irq_acknowledge_callback irq_callback;
25		legacy_cpu_device *device;
26		address_space *program;
27		direct_read_data *direct;
28		UINT8 IRQ;
29		UINT8 NMI;
30
31		int icount;
32		};
33
34	14	#define FLAG_C      0x0080
35	15	#define FLAG_V      0x0010
36	16	#define FLAG_S      0x0020
r26776	r26777
42	22	#define FLAG_ENI    0x2000
43	23	#define FLAG_NMI    0x4000
44	24
45		#define CLRFLAG(f)  se3208_state->SR&=~(f);
46		#define SETFLAG(f)  se3208_state->SR|=(f);
47		#define TESTFLAG(f) (se3208_state->SR&(f))
	25	#define CLRFLAG(f)  m_SR&=~(f);
	26	#define SETFLAG(f)  m_SR|=(f);
	27	#define TESTFLAG(f) (m_SR&(f))
48	28
49	29	#define EXTRACT(val,sbit,ebit)  (((val)>>sbit)&((1<<((ebit-sbit)+1))-1))
50	30	#define SEX8(val)   ((val&0x80)?(val|0xFFFFFF00):(val&0xFF))
r26776	r26777
54	34	#define SEX(bits,val)   ((val)&(1<<(bits-1))?((val)|(~((1<<bits)-1))):(val&((1<<bits)-1)))
55	35
56	36	//Precompute the instruction decoding in a big table
57		typedef void (*_OP)(se3208_state_t *se3208_state, UINT16 Opcode);
58		#define INST(a) static void a(se3208_state_t *se3208_state, UINT16 Opcode)
59		static _OP *OpTable=NULL;
	37	#define INST(a) void se3208_device::a(UINT16 Opcode)
60	38
61		INLINE se3208_state_t *get_safe_token(device_t *device)
	39
	40	const device_type SE3208 = &device_creator<se3208_device>;
	41
	42
	43	se3208_device::se3208_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	44	: cpu_device(mconfig, SE3208, "SE3208", tag, owner, clock, "se3208", __FILE__)
	45	, m_program_config("program", ENDIANNESS_LITTLE, 32, 32, 0)
62	46	{
63		assert(device != NULL);
64		assert(device->type() == SE3208);
65		return (se3208_state_t *)downcast<legacy_cpu_device *>(device)->token();
66	47	}
67	48
68		INLINE UINT32 read_dword_unaligned(address_space &space, UINT32 address)
	49
	50	UINT32 se3208_device::read_dword_unaligned(address_space &space, UINT32 address)
69	51	{
70	52	if (address & 3)
71	53	return space.read_byte(address) | space.read_byte(address+1)<<8 | space.read_byte(address+2)<<16 | space.read_byte(address+3)<<24;
r26776	r26777
73	55	return space.read_dword(address);
74	56	}
75	57
76		INLINE UINT16 read_word_unaligned(address_space &space, UINT32 address)
	58	UINT16 se3208_device::read_word_unaligned(address_space &space, UINT32 address)
77	59	{
78	60	if (address & 1)
79	61	return space.read_byte(address) | space.read_byte(address+1)<<8;
r26776	r26777
81	63	return space.read_word(address);
82	64	}
83	65
84		INLINE void write_dword_unaligned(address_space &space, UINT32 address, UINT32 data)
	66	void se3208_device::write_dword_unaligned(address_space &space, UINT32 address, UINT32 data)
85	67	{
86	68	if (address & 3)
87	69	{
r26776	r26777
96	78	}
97	79	}
98	80
99		INLINE void write_word_unaligned(address_space &space, UINT32 address, UINT16 data)
	81	void se3208_device::write_word_unaligned(address_space &space, UINT32 address, UINT16 data)
100	82	{
101	83	if (address & 1)
102	84	{
r26776	r26777
110	92	}
111	93
112	94
113		INLINE UINT8 SE3208_Read8(se3208_state_t *se3208_state, UINT32 addr)
	95	UINT8 se3208_device::SE3208_Read8(UINT32 addr)
114	96	{
115		return se3208_state->program->read_byte(addr);
	97	return m_program->read_byte(addr);
116	98	}
117	99
118		INLINE UINT16 SE3208_Read16(se3208_state_t *se3208_state, UINT32 addr)
	100	UINT16 se3208_device::SE3208_Read16(UINT32 addr)
119	101	{
120		return read_word_unaligned(*se3208_state->program,addr);
	102	return read_word_unaligned(*m_program,addr);
121	103	}
122	104
123		INLINE UINT32 SE3208_Read32(se3208_state_t *se3208_state, UINT32 addr)
	105	UINT32 se3208_device::SE3208_Read32(UINT32 addr)
124	106	{
125		return read_dword_unaligned(*se3208_state->program,addr);
	107	return read_dword_unaligned(*m_program,addr);
126	108	}
127	109
128		INLINE void SE3208_Write8(se3208_state_t *se3208_state, UINT32 addr,UINT8 val)
	110	void se3208_device::SE3208_Write8(UINT32 addr,UINT8 val)
129	111	{
130		se3208_state->program->write_byte(addr,val);
	112	m_program->write_byte(addr,val);
131	113	}
132	114
133		INLINE void SE3208_Write16(se3208_state_t *se3208_state, UINT32 addr,UINT16 val)
	115	void se3208_device::SE3208_Write16(UINT32 addr,UINT16 val)
134	116	{
135		write_word_unaligned(*se3208_state->program,addr,val);
	117	write_word_unaligned(*m_program,addr,val);
136	118	}
137	119
138		INLINE void SE3208_Write32(se3208_state_t *se3208_state, UINT32 addr,UINT32 val)
	120	void se3208_device::SE3208_Write32(UINT32 addr,UINT32 val)
139	121	{
140		write_dword_unaligned(*se3208_state->program,addr,val);
	122	write_dword_unaligned(*m_program,addr,val);
141	123	}
142	124
143	125
144	126
145		INLINE UINT32 AddWithFlags(se3208_state_t *se3208_state, UINT32 a,UINT32 b)
	127	UINT32 se3208_device::AddWithFlags(UINT32 a,UINT32 b)
146	128	{
147	129	UINT32 r=a+b;
148	130	CLRFLAG(FLAG_Z|FLAG_C|FLAG_V|FLAG_S);
r26776	r26777
157	139	return r;
158	140	}
159	141
160		INLINE UINT32 SubWithFlags(se3208_state_t *se3208_state, UINT32 a,UINT32 b) //a-b
	142	UINT32 se3208_device::SubWithFlags(UINT32 a,UINT32 b) //a-b
161	143	{
162	144	UINT32 r=a-b;
163	145	CLRFLAG(FLAG_Z|FLAG_C|FLAG_V|FLAG_S);
r26776	r26777
172	154	return r;
173	155	}
174	156
175		INLINE UINT32 AdcWithFlags(se3208_state_t *se3208_state,UINT32 a,UINT32 b)
	157	UINT32 se3208_device::AdcWithFlags(UINT32 a,UINT32 b)
176	158	{
177		UINT32 C=(se3208_state->SR&FLAG_C)?1:0;
	159	UINT32 C=(m_SR&FLAG_C)?1:0;
178	160	UINT32 r=a+b+C;
179	161	CLRFLAG(FLAG_Z|FLAG_C|FLAG_V|FLAG_S);
180	162	if(!r)
r26776	r26777
189	171
190	172	}
191	173
192		INLINE UINT32 SbcWithFlags(se3208_state_t *se3208_state,UINT32 a,UINT32 b)
	174	UINT32 se3208_device::SbcWithFlags(UINT32 a,UINT32 b)
193	175	{
194		UINT32 C=(se3208_state->SR&FLAG_C)?1:0;
	176	UINT32 C=(m_SR&FLAG_C)?1:0;
195	177	UINT32 r=a-b-C;
196	178	CLRFLAG(FLAG_Z|FLAG_C|FLAG_V|FLAG_S);
197	179	if(!r)
r26776	r26777
205	187	return r;
206	188	}
207	189
208		INLINE UINT32 MulWithFlags(se3208_state_t *se3208_state,UINT32 a,UINT32 b)
	190	UINT32 se3208_device::MulWithFlags(UINT32 a,UINT32 b)
209	191	{
210	192	INT64 r=(INT64) a*(INT64) b;
211	193	CLRFLAG(FLAG_V);
r26776	r26777
214	196	return (UINT32) (r&0xffffffff);
215	197	}
216	198
217		INLINE UINT32 NegWithFlags(se3208_state_t *se3208_state,UINT32 a)
	199	UINT32 se3208_device::NegWithFlags(UINT32 a)
218	200	{
219		return SubWithFlags(se3208_state,0,a);
	201	return SubWithFlags(0,a);
220	202	}
221	203
222		INLINE UINT32 AsrWithFlags(se3208_state_t *se3208_state,UINT32 Val, UINT8 By)
	204	UINT32 se3208_device::AsrWithFlags(UINT32 Val, UINT8 By)
223	205	{
224	206	signed int v=(signed int) Val;
225	207	v>>=By;
r26776	r26777
233	215	return (UINT32) v;
234	216	}
235	217
236		INLINE UINT32 LsrWithFlags(se3208_state_t *se3208_state,UINT32 Val, UINT8 By)
	218	UINT32 se3208_device::LsrWithFlags(UINT32 Val, UINT8 By)
237	219	{
238	220	UINT32 v=Val;
239	221	v>>=By;
r26776	r26777
247	229	return v;
248	230	}
249	231
250		INLINE UINT32 AslWithFlags(se3208_state_t *se3208_state,UINT32 Val, UINT8 By)
	232	UINT32 se3208_device::AslWithFlags(UINT32 Val, UINT8 By)
251	233	{
252	234	UINT32 v=Val;
253	235	v<<=By;
r26776	r26777
275	257	UINT32 Val;
276	258
277	259	if(Index)
278		Index=se3208_state->R[Index];
	260	Index=m_R[Index];
279	261	else
280	262	Index=0;
281	263
282	264	if(TESTFLAG(FLAG_E))
283		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	265	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
284	266
285		Val=SE3208_Read8(se3208_state, Index+Offset);
286		se3208_state->R[SrcDst]=SEX8(Val);
	267	Val=SE3208_Read8(Index+Offset);
	268	m_R[SrcDst]=SEX8(Val);
287	269
288	270	CLRFLAG(FLAG_E);
289	271	}
r26776	r26777
295	277	UINT32 SrcDst=EXTRACT(Opcode,8,10);
296	278
297	279	if(Index)
298		Index=se3208_state->R[Index];
	280	Index=m_R[Index];
299	281	else
300	282	Index=0;
301	283
302	284	if(TESTFLAG(FLAG_E))
303		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	285	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
304	286
305		SE3208_Write8(se3208_state, Index+Offset,ZEX8(se3208_state->R[SrcDst]));
	287	SE3208_Write8(Index+Offset,ZEX8(m_R[SrcDst]));
306	288
307	289	CLRFLAG(FLAG_E);
308	290	}
r26776	r26777
317	299	Offset<<=1;
318	300
319	301	if(Index)
320		Index=se3208_state->R[Index];
	302	Index=m_R[Index];
321	303	else
322	304	Index=0;
323	305
324	306	if(TESTFLAG(FLAG_E))
325		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	307	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
326	308
327		Val=SE3208_Read16(se3208_state, Index+Offset);
328		se3208_state->R[SrcDst]=SEX16(Val);
	309	Val=SE3208_Read16(Index+Offset);
	310	m_R[SrcDst]=SEX16(Val);
329	311
330	312	CLRFLAG(FLAG_E);
331	313	}
r26776	r26777
339	321	Offset<<=1;
340	322
341	323	if(Index)
342		Index=se3208_state->R[Index];
	324	Index=m_R[Index];
343	325	else
344	326	Index=0;
345	327
346	328	if(TESTFLAG(FLAG_E))
347		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	329	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
348	330
349		SE3208_Write16(se3208_state, Index+Offset,ZEX16(se3208_state->R[SrcDst]));
	331	SE3208_Write16(Index+Offset,ZEX16(m_R[SrcDst]));
350	332
351	333	CLRFLAG(FLAG_E);
352	334	}
r26776	r26777
360	342	Offset<<=2;
361	343
362	344	if(Index)
363		Index=se3208_state->R[Index];
	345	Index=m_R[Index];
364	346	else
365	347	Index=0;
366	348
367	349	if(TESTFLAG(FLAG_E))
368		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	350	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
369	351
370		se3208_state->R[SrcDst]=SE3208_Read32(se3208_state, Index+Offset);
	352	m_R[SrcDst]=SE3208_Read32(Index+Offset);
371	353
372	354	CLRFLAG(FLAG_E);
373	355	}
r26776	r26777
381	363	Offset<<=2;
382	364
383	365	if(Index)
384		Index=se3208_state->R[Index];
	366	Index=m_R[Index];
385	367	else
386	368	Index=0;
387	369
388	370	if(TESTFLAG(FLAG_E))
389		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	371	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
390	372
391		SE3208_Write32(se3208_state, Index+Offset,se3208_state->R[SrcDst]);
	373	SE3208_Write32(Index+Offset,m_R[SrcDst]);
392	374
393	375	CLRFLAG(FLAG_E);
394	376	}
r26776	r26777
401	383	UINT32 Val;
402	384
403	385	if(Index)
404		Index=se3208_state->R[Index];
	386	Index=m_R[Index];
405	387	else
406	388	Index=0;
407	389
408	390	if(TESTFLAG(FLAG_E))
409		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	391	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
410	392
411		Val=SE3208_Read8(se3208_state, Index+Offset);
412		se3208_state->R[SrcDst]=ZEX8(Val);
	393	Val=SE3208_Read8(Index+Offset);
	394	m_R[SrcDst]=ZEX8(Val);
413	395
414	396	CLRFLAG(FLAG_E);
415	397	}
r26776	r26777
424	406	Offset<<=1;
425	407
426	408	if(Index)
427		Index=se3208_state->R[Index];
	409	Index=m_R[Index];
428	410	else
429	411	Index=0;
430	412
431	413	if(TESTFLAG(FLAG_E))
432		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	414	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
433	415
434		Val=SE3208_Read16(se3208_state, Index+Offset);
435		se3208_state->R[SrcDst]=ZEX16(Val);
	416	Val=SE3208_Read16(Index+Offset);
	417	m_R[SrcDst]=ZEX16(Val);
436	418
437	419	CLRFLAG(FLAG_E);
438	420	}
r26776	r26777
442	424	{
443	425	UINT32 Imm=EXTRACT(Opcode,0,13);
444	426	if(TESTFLAG(FLAG_E))
445		se3208_state->ER=(EXTRACT(se3208_state->ER,0,17)<<14)|Imm;
	427	m_ER=(EXTRACT(m_ER,0,17)<<14)|Imm;
446	428	else
447		se3208_state->ER=SEX(14,Imm);
	429	m_ER=SEX(14,Imm);
448	430
449	431
450	432	SETFLAG(FLAG_E);
r26776	r26777
453	435	INST(LDSP)
454	436	{
455	437	UINT32 Offset=EXTRACT(Opcode,0,7);
456		UINT32 Index=se3208_state->SP;
	438	UINT32 Index=m_SP;
457	439	UINT32 SrcDst=EXTRACT(Opcode,8,10);
458	440
459	441	Offset<<=2;
460	442
461	443	if(TESTFLAG(FLAG_E))
462		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	444	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
463	445
464		se3208_state->R[SrcDst]=SE3208_Read32(se3208_state, Index+Offset);
	446	m_R[SrcDst]=SE3208_Read32(Index+Offset);
465	447
466	448	CLRFLAG(FLAG_E);
467	449	}
r26776	r26777
469	451	INST(STSP)
470	452	{
471	453	UINT32 Offset=EXTRACT(Opcode,0,7);
472		UINT32 Index=se3208_state->SP;
	454	UINT32 Index=m_SP;
473	455	UINT32 SrcDst=EXTRACT(Opcode,8,10);
474	456
475	457	Offset<<=2;
476	458
477	459	if(TESTFLAG(FLAG_E))
478		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	460	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
479	461
480		SE3208_Write32(se3208_state, Index+Offset,se3208_state->R[SrcDst]);
	462	SE3208_Write32(Index+Offset,m_R[SrcDst]);
481	463
482	464	CLRFLAG(FLAG_E);
483	465	}
484	466
485		static void PushVal(se3208_state_t *se3208_state, UINT32 Val)
	467	void se3208_device::PushVal(UINT32 Val)
486	468	{
487		se3208_state->SP-=4;
488		SE3208_Write32(se3208_state, se3208_state->SP,Val);
	469	m_SP-=4;
	470	SE3208_Write32(m_SP,Val);
489	471	}
490	472
491		static UINT32 PopVal(se3208_state_t *se3208_state)
	473	UINT32 se3208_device::PopVal()
492	474	{
493		UINT32 Val=SE3208_Read32(se3208_state, se3208_state->SP);
494		se3208_state->SP+=4;
	475	UINT32 Val=SE3208_Read32(m_SP);
	476	m_SP+=4;
495	477	return Val;
496	478	}
497	479
r26776	r26777
499	481	{
500	482	UINT32 Set=EXTRACT(Opcode,0,10);
501	483	if(Set&(1<<10))
502		PushVal(se3208_state,se3208_state->PC);
	484	PushVal(m_PC);
503	485	if(Set&(1<<9))
504		PushVal(se3208_state,se3208_state->SR);
	486	PushVal(m_SR);
505	487	if(Set&(1<<8))
506		PushVal(se3208_state,se3208_state->ER);
	488	PushVal(m_ER);
507	489	if(Set&(1<<7))
508		PushVal(se3208_state,se3208_state->R[7]);
	490	PushVal(m_R[7]);
509	491	if(Set&(1<<6))
510		PushVal(se3208_state,se3208_state->R[6]);
	492	PushVal(m_R[6]);
511	493	if(Set&(1<<5))
512		PushVal(se3208_state,se3208_state->R[5]);
	494	PushVal(m_R[5]);
513	495	if(Set&(1<<4))
514		PushVal(se3208_state,se3208_state->R[4]);
	496	PushVal(m_R[4]);
515	497	if(Set&(1<<3))
516		PushVal(se3208_state,se3208_state->R[3]);
	498	PushVal(m_R[3]);
517	499	if(Set&(1<<2))
518		PushVal(se3208_state,se3208_state->R[2]);
	500	PushVal(m_R[2]);
519	501	if(Set&(1<<1))
520		PushVal(se3208_state,se3208_state->R[1]);
	502	PushVal(m_R[1]);
521	503	if(Set&(1<<0))
522		PushVal(se3208_state,se3208_state->R[0]);
	504	PushVal(m_R[0]);
523	505	}
524	506
525	507	INST(POP)
526	508	{
527	509	UINT32 Set=EXTRACT(Opcode,0,10);
528	510	if(Set&(1<<0))
529		se3208_state->R[0]=PopVal(se3208_state);
	511	m_R[0]=PopVal();
530	512	if(Set&(1<<1))
531		se3208_state->R[1]=PopVal(se3208_state);
	513	m_R[1]=PopVal();
532	514	if(Set&(1<<2))
533		se3208_state->R[2]=PopVal(se3208_state);
	515	m_R[2]=PopVal();
534	516	if(Set&(1<<3))
535		se3208_state->R[3]=PopVal(se3208_state);
	517	m_R[3]=PopVal();
536	518	if(Set&(1<<4))
537		se3208_state->R[4]=PopVal(se3208_state);
	519	m_R[4]=PopVal();
538	520	if(Set&(1<<5))
539		se3208_state->R[5]=PopVal(se3208_state);
	521	m_R[5]=PopVal();
540	522	if(Set&(1<<6))
541		se3208_state->R[6]=PopVal(se3208_state);
	523	m_R[6]=PopVal();
542	524	if(Set&(1<<7))
543		se3208_state->R[7]=PopVal(se3208_state);
	525	m_R[7]=PopVal();
544	526	if(Set&(1<<8))
545		se3208_state->ER=PopVal(se3208_state);
	527	m_ER=PopVal();
546	528	if(Set&(1<<9))
547		se3208_state->SR=PopVal(se3208_state);
	529	m_SR=PopVal();
548	530	if(Set&(1<<10))
549	531	{
550		se3208_state->PC=PopVal(se3208_state)-2;        //PC automatically incresases by 2
	532	m_PC=PopVal()-2;        //PC automatically incresases by 2
551	533	}
552	534	}
553	535
r26776	r26777
557	539	UINT32 Index=EXTRACT(Opcode,3,5);
558	540
559	541	if(Index)
560		Index=se3208_state->R[Index];
	542	Index=m_R[Index];
561	543	else
562	544	Index=0;
563	545
564	546	if(TESTFLAG(FLAG_E))
565		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	547	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
566	548	else
567	549	Offset=SEX(4,Offset);
568	550
569		se3208_state->SP=Index+Offset;
	551	m_SP=Index+Offset;
570	552
571	553	CLRFLAG(FLAG_E);
572	554	}
r26776	r26777
577	559	UINT32 Index=EXTRACT(Opcode,3,5);
578	560
579	561	if(TESTFLAG(FLAG_E))
580		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	562	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
581	563	else
582	564	Offset=SEX(4,Offset);
583	565
584		se3208_state->R[Index]=se3208_state->SP+Offset;
	566	m_R[Index]=m_SP+Offset;
585	567
586	568	CLRFLAG(FLAG_E);
587	569	}
r26776	r26777
593	575	Offset<<=2;
594	576
595	577	if(TESTFLAG(FLAG_E))
596		Offset=(EXTRACT(se3208_state->ER,0,23)<<8)|(Offset&0xff);
	578	Offset=(EXTRACT(m_ER,0,23)<<8)|(Offset&0xff);
597	579	else
598	580	Offset=SEX(10,Offset);
599	581
600		se3208_state->SP=se3208_state->SP+Offset;
	582	m_SP=m_SP+Offset;
601	583
602	584	CLRFLAG(FLAG_E);
603	585	}
r26776	r26777
607	589	UINT32 Src=EXTRACT(Opcode,3,5);
608	590	UINT32 Dst=EXTRACT(Opcode,9,11);
609	591
610		se3208_state->R[Dst]=se3208_state->R[Src];
	592	m_R[Dst]=m_R[Src];
611	593	}
612	594
613	595	INST(LDI)
r26776	r26777
616	598	UINT32 Imm=EXTRACT(Opcode,0,7);
617	599
618	600	if(TESTFLAG(FLAG_E))
619		Imm=(EXTRACT(se3208_state->ER,0,27)<<4)|(Imm&0xf);
	601	Imm=(EXTRACT(m_ER,0,27)<<4)|(Imm&0xf);
620	602	else
621	603	Imm=SEX8(Imm);
622	604
623		se3208_state->R[Dst]=Imm;
	605	m_R[Dst]=Imm;
624	606
625	607	CLRFLAG(FLAG_E);
626	608	}
r26776	r26777
628	610	INST(LDBSP)
629	611	{
630	612	UINT32 Offset=EXTRACT(Opcode,0,3);
631		UINT32 Index=se3208_state->SP;
	613	UINT32 Index=m_SP;
632	614	UINT32 SrcDst=EXTRACT(Opcode,4,6);
633	615	UINT32 Val;
634	616
635	617	if(TESTFLAG(FLAG_E))
636		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	618	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
637	619
638		Val=SE3208_Read8(se3208_state, Index+Offset);
639		se3208_state->R[SrcDst]=SEX8(Val);
	620	Val=SE3208_Read8(Index+Offset);
	621	m_R[SrcDst]=SEX8(Val);
640	622
641	623	CLRFLAG(FLAG_E);
642	624	}
r26776	r26777
644	626	INST(STBSP)
645	627	{
646	628	UINT32 Offset=EXTRACT(Opcode,0,3);
647		UINT32 Index=se3208_state->SP;
	629	UINT32 Index=m_SP;
648	630	UINT32 SrcDst=EXTRACT(Opcode,4,6);
649	631
650	632	if(TESTFLAG(FLAG_E))
651		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	633	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
652	634
653		SE3208_Write8(se3208_state, Index+Offset,ZEX8(se3208_state->R[SrcDst]));
	635	SE3208_Write8(Index+Offset,ZEX8(m_R[SrcDst]));
654	636
655	637	CLRFLAG(FLAG_E);
656	638	}
r26776	r26777
658	640	INST(LDSSP)
659	641	{
660	642	UINT32 Offset=EXTRACT(Opcode,0,3);
661		UINT32 Index=se3208_state->SP;
	643	UINT32 Index=m_SP;
662	644	UINT32 SrcDst=EXTRACT(Opcode,4,6);
663	645	UINT32 Val;
664	646
665	647	Offset<<=1;
666	648
667	649	if(TESTFLAG(FLAG_E))
668		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	650	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
669	651
670		Val=SE3208_Read16(se3208_state, Index+Offset);
671		se3208_state->R[SrcDst]=SEX16(Val);
	652	Val=SE3208_Read16(Index+Offset);
	653	m_R[SrcDst]=SEX16(Val);
672	654
673	655	CLRFLAG(FLAG_E);
674	656	}
r26776	r26777
676	658	INST(STSSP)
677	659	{
678	660	UINT32 Offset=EXTRACT(Opcode,0,3);
679		UINT32 Index=se3208_state->SP;
	661	UINT32 Index=m_SP;
680	662	UINT32 SrcDst=EXTRACT(Opcode,4,6);
681	663
682	664	Offset<<=1;
683	665
684	666	if(TESTFLAG(FLAG_E))
685		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	667	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
686	668
687		SE3208_Write16(se3208_state, Index+Offset,ZEX16(se3208_state->R[SrcDst]));
	669	SE3208_Write16(Index+Offset,ZEX16(m_R[SrcDst]));
688	670
689	671	CLRFLAG(FLAG_E);
690	672	}
r26776	r26777
692	674	INST(LDBUSP)
693	675	{
694	676	UINT32 Offset=EXTRACT(Opcode,0,3);
695		UINT32 Index=se3208_state->SP;
	677	UINT32 Index=m_SP;
696	678	UINT32 SrcDst=EXTRACT(Opcode,4,6);
697	679	UINT32 Val;
698	680
699	681	if(TESTFLAG(FLAG_E))
700		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	682	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
701	683
702		Val=SE3208_Read8(se3208_state, Index+Offset);
703		se3208_state->R[SrcDst]=ZEX8(Val);
	684	Val=SE3208_Read8(Index+Offset);
	685	m_R[SrcDst]=ZEX8(Val);
704	686
705	687	CLRFLAG(FLAG_E);
706	688	}
r26776	r26777
708	690	INST(LDSUSP)
709	691	{
710	692	UINT32 Offset=EXTRACT(Opcode,0,3);
711		UINT32 Index=se3208_state->SP;
	693	UINT32 Index=m_SP;
712	694	UINT32 SrcDst=EXTRACT(Opcode,4,6);
713	695	UINT32 Val;
714	696
715	697	Offset<<=1;
716	698
717	699	if(TESTFLAG(FLAG_E))
718		Offset=(EXTRACT(se3208_state->ER,0,27)<<4)|(Offset&0xf);
	700	Offset=(EXTRACT(m_ER,0,27)<<4)|(Offset&0xf);
719	701
720		Val=SE3208_Read16(se3208_state, Index+Offset);
721		se3208_state->R[SrcDst]=ZEX16(Val);
	702	Val=SE3208_Read16(Index+Offset);
	703	m_R[SrcDst]=ZEX16(Val);
722	704
723	705	CLRFLAG(FLAG_E);
724	706	}
r26776	r26777
730	712	UINT32 Dst=EXTRACT(Opcode,0,2);
731	713
732	714	if(TESTFLAG(FLAG_E))
733		Imm=(EXTRACT(se3208_state->ER,0,27)<<4)|(Imm&0xf);
	715	Imm=(EXTRACT(m_ER,0,27)<<4)|(Imm&0xf);
734	716	else
735	717	Imm=SEX(4,Imm);
736	718
737		se3208_state->R[Dst]=AddWithFlags(se3208_state,se3208_state->R[Src],Imm);
	719	m_R[Dst]=AddWithFlags(m_R[Src],Imm);
738	720
739	721	CLRFLAG(FLAG_E);
740	722	}
r26776	r26777
746	728	UINT32 Dst=EXTRACT(Opcode,0,2);
747	729
748	730	if(TESTFLAG(FLAG_E))
749		Imm=(EXTRACT(se3208_state->ER,0,27)<<4)|(Imm&0xf);
	731	Imm=(EXTRACT(m_ER,0,27)<<4)|(Imm&0xf);
750	732	else
751	733	Imm=SEX(4,Imm);
752	734
753		se3208_state->R[Dst]=SubWithFlags(se3208_state,se3208_state->R[Src],Imm);
	735	m_R[Dst]=SubWithFlags(m_R[Src],Imm);
754	736
755	737	CLRFLAG(FLAG_E);
756	738	}
r26776	r26777
762	744	UINT32 Dst=EXTRACT(Opcode,0,2);
763	745
764	746	if(TESTFLAG(FLAG_E))
765		Imm=(EXTRACT(se3208_state->ER,0,27)<<4)|(Imm&0xf);
	747	Imm=(EXTRACT(m_ER,0,27)<<4)|(Imm&0xf);
766	748	else
767	749	Imm=SEX(4,Imm);
768	750
769		se3208_state->R[Dst]=AdcWithFlags(se3208_state,se3208_state->R[Src],Imm);
	751	m_R[Dst]=AdcWithFlags(m_R[Src],Imm);
770	752
771	753	CLRFLAG(FLAG_E);
772	754	}
r26776	r26777
778	760	UINT32 Dst=EXTRACT(Opcode,0,2);
779	761
780	762	if(TESTFLAG(FLAG_E))
781		Imm=(EXTRACT(se3208_state->ER,0,27)<<4)|(Imm&0xf);
	763	Imm=(EXTRACT(m_ER,0,27)<<4)|(Imm&0xf);
782	764	else
783	765	Imm=SEX(4,Imm);
784	766
785		se3208_state->R[Dst]=SbcWithFlags(se3208_state,se3208_state->R[Src],Imm);
	767	m_R[Dst]=SbcWithFlags(m_R[Src],Imm);
786	768
787	769	CLRFLAG(FLAG_E);
788	770	}
r26776	r26777
794	776	UINT32 Dst=EXTRACT(Opcode,0,2);
795	777
796	778	if(TESTFLAG(FLAG_E))
797		Imm=(EXTRACT(se3208_state->ER,0,27)<<4)|(Imm&0xf);
	779	Imm=(EXTRACT(m_ER,0,27)<<4)|(Imm&0xf);
798	780	else
799	781	Imm=SEX(4,Imm);
800	782
801		se3208_state->R[Dst]=se3208_state->R[Src]&Imm;
	783	m_R[Dst]=m_R[Src]&Imm;
802	784
803	785	CLRFLAG(FLAG_S|FLAG_Z|FLAG_E);
804		if(!se3208_state->R[Dst])
	786	if(!m_R[Dst])
805	787	SETFLAG(FLAG_Z);
806		if(se3208_state->R[Dst]&0x80000000)
	788	if(m_R[Dst]&0x80000000)
807	789	SETFLAG(FLAG_S);
808	790	}
809	791
r26776	r26777
814	796	UINT32 Dst=EXTRACT(Opcode,0,2);
815	797
816	798	if(TESTFLAG(FLAG_E))
817		Imm=(EXTRACT(se3208_state->ER,0,27)<<4)|(Imm&0xf);
	799	Imm=(EXTRACT(m_ER,0,27)<<4)|(Imm&0xf);
818	800	else
819	801	Imm=SEX(4,Imm);
820	802
821		se3208_state->R[Dst]=se3208_state->R[Src]|Imm;
	803	m_R[Dst]=m_R[Src]|Imm;
822	804
823	805	CLRFLAG(FLAG_S|FLAG_Z|FLAG_E);
824		if(!se3208_state->R[Dst])
	806	if(!m_R[Dst])
825	807	SETFLAG(FLAG_Z);
826		if(se3208_state->R[Dst]&0x80000000)
	808	if(m_R[Dst]&0x80000000)
827	809	SETFLAG(FLAG_S);
828	810	}
829	811
r26776	r26777
834	816	UINT32 Dst=EXTRACT(Opcode,0,2);
835	817
836	818	if(TESTFLAG(FLAG_E))
837		Imm=(EXTRACT(se3208_state->ER,0,27)<<4)|(Imm&0xf);
	819	Imm=(EXTRACT(m_ER,0,27)<<4)|(Imm&0xf);
838	820	else
839	821	Imm=SEX(4,Imm);
840	822
841		se3208_state->R[Dst]=se3208_state->R[Src]^Imm;
	823	m_R[Dst]=m_R[Src]^Imm;
842	824
843	825	CLRFLAG(FLAG_S|FLAG_Z|FLAG_E);
844		if(!se3208_state->R[Dst])
	826	if(!m_R[Dst])
845	827	SETFLAG(FLAG_Z);
846		if(se3208_state->R[Dst]&0x80000000)
	828	if(m_R[Dst]&0x80000000)
847	829	SETFLAG(FLAG_S);
848	830	}
849	831
r26776	r26777
853	835	UINT32 Src=EXTRACT(Opcode,3,5);
854	836
855	837	if(TESTFLAG(FLAG_E))
856		Imm=(EXTRACT(se3208_state->ER,0,27)<<4)|(Imm&0xf);
	838	Imm=(EXTRACT(m_ER,0,27)<<4)|(Imm&0xf);
857	839	else
858	840	Imm=SEX(4,Imm);
859	841
860		SubWithFlags(se3208_state,se3208_state->R[Src],Imm);
	842	SubWithFlags(m_R[Src],Imm);
861	843
862	844	CLRFLAG(FLAG_E);
863	845	}
r26776	r26777
869	851	UINT32 Dst;
870	852
871	853	if(TESTFLAG(FLAG_E))
872		Imm=(EXTRACT(se3208_state->ER,0,27)<<4)|(Imm&0xf);
	854	Imm=(EXTRACT(m_ER,0,27)<<4)|(Imm&0xf);
873	855	else
874	856	Imm=SEX(4,Imm);
875	857
876		Dst=se3208_state->R[Src]&Imm;
	858	Dst=m_R[Src]&Imm;
877	859
878	860	CLRFLAG(FLAG_S|FLAG_Z|FLAG_E);
879	861	if(!Dst)
r26776	r26777
888	870	UINT32 Src1=EXTRACT(Opcode,3,5);
889	871	UINT32 Dst=EXTRACT(Opcode,0,2);
890	872
891		se3208_state->R[Dst]=AddWithFlags(se3208_state,se3208_state->R[Src1],se3208_state->R[Src2]);
	873	m_R[Dst]=AddWithFlags(m_R[Src1],m_R[Src2]);
892	874	}
893	875
894	876	INST(SUB)
r26776	r26777
897	879	UINT32 Src1=EXTRACT(Opcode,3,5);
898	880	UINT32 Dst=EXTRACT(Opcode,0,2);
899	881
900		se3208_state->R[Dst]=SubWithFlags(se3208_state,se3208_state->R[Src1],se3208_state->R[Src2]);
	882	m_R[Dst]=SubWithFlags(m_R[Src1],m_R[Src2]);
901	883	}
902	884
903	885	INST(ADC)
r26776	r26777
906	888	UINT32 Src1=EXTRACT(Opcode,3,5);
907	889	UINT32 Dst=EXTRACT(Opcode,0,2);
908	890
909		se3208_state->R[Dst]=AdcWithFlags(se3208_state,se3208_state->R[Src1],se3208_state->R[Src2]);
	891	m_R[Dst]=AdcWithFlags(m_R[Src1],m_R[Src2]);
910	892	}
911	893
912	894	INST(SBC)
r26776	r26777
915	897	UINT32 Src1=EXTRACT(Opcode,3,5);
916	898	UINT32 Dst=EXTRACT(Opcode,0,2);
917	899
918		se3208_state->R[Dst]=SbcWithFlags(se3208_state,se3208_state->R[Src1],se3208_state->R[Src2]);
	900	m_R[Dst]=SbcWithFlags(m_R[Src1],m_R[Src2]);
919	901	}
920	902
921	903	INST(AND)
r26776	r26777
924	906	UINT32 Src1=EXTRACT(Opcode,3,5);
925	907	UINT32 Dst=EXTRACT(Opcode,0,2);
926	908
927		se3208_state->R[Dst]=se3208_state->R[Src1]&se3208_state->R[Src2];
	909	m_R[Dst]=m_R[Src1]&m_R[Src2];
928	910
929	911	CLRFLAG(FLAG_S|FLAG_Z);
930		if(!se3208_state->R[Dst])
	912	if(!m_R[Dst])
931	913	SETFLAG(FLAG_Z);
932		if(se3208_state->R[Dst]&0x80000000)
	914	if(m_R[Dst]&0x80000000)
933	915	SETFLAG(FLAG_S);
934	916	}
935	917
r26776	r26777
939	921	UINT32 Src1=EXTRACT(Opcode,3,5);
940	922	UINT32 Dst=EXTRACT(Opcode,0,2);
941	923
942		se3208_state->R[Dst]=se3208_state->R[Src1]|se3208_state->R[Src2];
	924	m_R[Dst]=m_R[Src1]|m_R[Src2];
943	925
944	926	CLRFLAG(FLAG_S|FLAG_Z);
945		if(!se3208_state->R[Dst])
	927	if(!m_R[Dst])
946	928	SETFLAG(FLAG_Z);
947		if(se3208_state->R[Dst]&0x80000000)
	929	if(m_R[Dst]&0x80000000)
948	930	SETFLAG(FLAG_S);
949	931
950	932	}
r26776	r26777
955	937	UINT32 Src1=EXTRACT(Opcode,3,5);
956	938	UINT32 Dst=EXTRACT(Opcode,0,2);
957	939
958		se3208_state->R[Dst]=se3208_state->R[Src1]^se3208_state->R[Src2];
	940	m_R[Dst]=m_R[Src1]^m_R[Src2];
959	941
960	942	CLRFLAG(FLAG_S|FLAG_Z);
961		if(!se3208_state->R[Dst])
	943	if(!m_R[Dst])
962	944	SETFLAG(FLAG_Z);
963		if(se3208_state->R[Dst]&0x80000000)
	945	if(m_R[Dst]&0x80000000)
964	946	SETFLAG(FLAG_S);
965	947
966	948	}
r26776	r26777
970	952	UINT32 Src2=EXTRACT(Opcode,9,11);
971	953	UINT32 Src1=EXTRACT(Opcode,3,5);
972	954
973		SubWithFlags(se3208_state,se3208_state->R[Src1],se3208_state->R[Src2]);
	955	SubWithFlags(m_R[Src1],m_R[Src2]);
974	956	}
975	957
976	958	INST(TST)
r26776	r26777
979	961	UINT32 Src1=EXTRACT(Opcode,3,5);
980	962	UINT32 Dst;
981	963
982		Dst=se3208_state->R[Src1]&se3208_state->R[Src2];
	964	Dst=m_R[Src1]&m_R[Src2];
983	965
984	966	CLRFLAG(FLAG_S|FLAG_Z);
985	967	if(!Dst)
r26776	r26777
994	976	UINT32 Src1=EXTRACT(Opcode,3,5);
995	977	UINT32 Dst=EXTRACT(Opcode,0,2);
996	978
997		se3208_state->R[Dst]=MulWithFlags(se3208_state,se3208_state->R[Src1],se3208_state->R[Src2]);
	979	m_R[Dst]=MulWithFlags(m_R[Src1],m_R[Src2]);
998	980
999	981	CLRFLAG(FLAG_E);
1000	982	}
r26776	r26777
1004	986	UINT32 Dst=EXTRACT(Opcode,9,11);
1005	987	UINT32 Src=EXTRACT(Opcode,3,5);
1006	988
1007		se3208_state->R[Dst]=NegWithFlags(se3208_state,se3208_state->R[Src]);
	989	m_R[Dst]=NegWithFlags(m_R[Src]);
1008	990	}
1009	991
1010	992	INST(CALL)
r26776	r26777
1012	994	UINT32 Offset=EXTRACT(Opcode,0,7);
1013	995
1014	996	if(TESTFLAG(FLAG_E))
1015		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	997	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1016	998	else
1017	999	Offset=SEX(8,Offset);
1018	1000	Offset<<=1;
1019		PushVal(se3208_state,se3208_state->PC+2);
1020		se3208_state->PC=se3208_state->PC+Offset;
	1001	PushVal(m_PC+2);
	1002	m_PC=m_PC+Offset;
1021	1003
1022	1004	CLRFLAG(FLAG_E);
1023	1005	}
r26776	r26777
1027	1009	UINT32 Offset=EXTRACT(Opcode,0,7);
1028	1010
1029	1011	if(TESTFLAG(FLAG_E))
1030		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1012	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1031	1013	else
1032	1014	Offset=SEX(8,Offset);
1033	1015	Offset<<=1;
1034	1016
1035	1017	if(TESTFLAG(FLAG_V))
1036	1018	{
1037		se3208_state->PC=se3208_state->PC+Offset;
	1019	m_PC=m_PC+Offset;
1038	1020	}
1039	1021
1040	1022	CLRFLAG(FLAG_E);
r26776	r26777
1046	1028	UINT32 Offset=EXTRACT(Opcode,0,7);
1047	1029
1048	1030	if(TESTFLAG(FLAG_E))
1049		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1031	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1050	1032	else
1051	1033	Offset=SEX(8,Offset);
1052	1034	Offset<<=1;
1053	1035
1054	1036	if(!TESTFLAG(FLAG_V))
1055	1037	{
1056		se3208_state->PC=se3208_state->PC+Offset;
	1038	m_PC=m_PC+Offset;
1057	1039	}
1058	1040
1059	1041	CLRFLAG(FLAG_E);
r26776	r26777
1064	1046	UINT32 Offset=EXTRACT(Opcode,0,7);
1065	1047
1066	1048	if(TESTFLAG(FLAG_E))
1067		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1049	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1068	1050	else
1069	1051	Offset=SEX(8,Offset);
1070	1052	Offset<<=1;
1071	1053
1072	1054	if(TESTFLAG(FLAG_C))
1073	1055	{
1074		se3208_state->PC=se3208_state->PC+Offset;
	1056	m_PC=m_PC+Offset;
1075	1057	}
1076	1058
1077	1059	CLRFLAG(FLAG_E);
r26776	r26777
1082	1064	UINT32 Offset=EXTRACT(Opcode,0,7);
1083	1065
1084	1066	if(TESTFLAG(FLAG_E))
1085		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1067	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1086	1068	else
1087	1069	Offset=SEX(8,Offset);
1088	1070	Offset<<=1;
1089	1071
1090	1072	if(!TESTFLAG(FLAG_C))
1091	1073	{
1092		se3208_state->PC=se3208_state->PC+Offset;
	1074	m_PC=m_PC+Offset;
1093	1075	}
1094	1076
1095	1077	CLRFLAG(FLAG_E);
r26776	r26777
1100	1082	UINT32 Offset=EXTRACT(Opcode,0,7);
1101	1083
1102	1084	if(TESTFLAG(FLAG_E))
1103		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1085	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1104	1086	else
1105	1087	Offset=SEX(8,Offset);
1106	1088	Offset<<=1;
1107	1089
1108	1090	if(!TESTFLAG(FLAG_S))
1109	1091	{
1110		se3208_state->PC=se3208_state->PC+Offset;
	1092	m_PC=m_PC+Offset;
1111	1093	}
1112	1094
1113	1095	CLRFLAG(FLAG_E);
r26776	r26777
1118	1100	UINT32 Offset=EXTRACT(Opcode,0,7);
1119	1101
1120	1102	if(TESTFLAG(FLAG_E))
1121		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1103	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1122	1104	else
1123	1105	Offset=SEX(8,Offset);
1124	1106	Offset<<=1;
1125	1107
1126	1108	if(TESTFLAG(FLAG_S))
1127	1109	{
1128		se3208_state->PC=se3208_state->PC+Offset;
	1110	m_PC=m_PC+Offset;
1129	1111	}
1130	1112
1131	1113	CLRFLAG(FLAG_E);
r26776	r26777
1136	1118	UINT32 Offset=EXTRACT(Opcode,0,7);
1137	1119
1138	1120	if(TESTFLAG(FLAG_E))
1139		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1121	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1140	1122	else
1141	1123	Offset=SEX(8,Offset);
1142	1124	Offset<<=1;
1143	1125
1144	1126	if(!TESTFLAG(FLAG_Z))
1145	1127	{
1146		se3208_state->PC=se3208_state->PC+Offset;
	1128	m_PC=m_PC+Offset;
1147	1129	}
1148	1130
1149	1131	CLRFLAG(FLAG_E);
r26776	r26777
1154	1136	UINT32 Offset=EXTRACT(Opcode,0,7);
1155	1137
1156	1138	if(TESTFLAG(FLAG_E))
1157		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1139	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1158	1140	else
1159	1141	Offset=SEX(8,Offset);
1160	1142	Offset<<=1;
1161	1143
1162	1144	if(TESTFLAG(FLAG_Z))
1163	1145	{
1164		se3208_state->PC=se3208_state->PC+Offset;
	1146	m_PC=m_PC+Offset;
1165	1147	}
1166	1148
1167	1149	CLRFLAG(FLAG_E);
r26776	r26777
1174	1156	UINT32 V=TESTFLAG(FLAG_V)?1:0;
1175	1157
1176	1158	if(TESTFLAG(FLAG_E))
1177		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1159	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1178	1160	else
1179	1161	Offset=SEX(8,Offset);
1180	1162	Offset<<=1;
1181	1163
1182	1164	if(!(S^V))
1183	1165	{
1184		se3208_state->PC=se3208_state->PC+Offset;
	1166	m_PC=m_PC+Offset;
1185	1167	}
1186	1168
1187	1169	CLRFLAG(FLAG_E);
r26776	r26777
1194	1176	UINT32 V=TESTFLAG(FLAG_V)?1:0;
1195	1177
1196	1178	if(TESTFLAG(FLAG_E))
1197		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1179	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1198	1180	else
1199	1181	Offset=SEX(8,Offset);
1200	1182	Offset<<=1;
1201	1183
1202	1184	if(TESTFLAG(FLAG_Z) || (S^V))
1203	1185	{
1204		se3208_state->PC=se3208_state->PC+Offset;
	1186	m_PC=m_PC+Offset;
1205	1187	}
1206	1188	CLRFLAG(FLAG_E);
1207	1189	}
r26776	r26777
1211	1193	UINT32 Offset=EXTRACT(Opcode,0,7);
1212	1194
1213	1195	if(TESTFLAG(FLAG_E))
1214		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1196	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1215	1197	else
1216	1198	Offset=SEX(8,Offset);
1217	1199	Offset<<=1;
1218	1200
1219	1201	if(!(TESTFLAG(FLAG_Z) || TESTFLAG(FLAG_C)))
1220	1202	{
1221		se3208_state->PC=se3208_state->PC+Offset;
	1203	m_PC=m_PC+Offset;
1222	1204	}
1223	1205
1224	1206	CLRFLAG(FLAG_E);
r26776	r26777
1229	1211	UINT32 Offset=EXTRACT(Opcode,0,7);
1230	1212
1231	1213	if(TESTFLAG(FLAG_E))
1232		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1214	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1233	1215	else
1234	1216	Offset=SEX(8,Offset);
1235	1217	Offset<<=1;
1236	1218
1237	1219	if(TESTFLAG(FLAG_Z) || TESTFLAG(FLAG_C))
1238	1220	{
1239		se3208_state->PC=se3208_state->PC+Offset;
	1221	m_PC=m_PC+Offset;
1240	1222	}
1241	1223
1242	1224	CLRFLAG(FLAG_E);
r26776	r26777
1249	1231	UINT32 V=TESTFLAG(FLAG_V)?1:0;
1250	1232
1251	1233	if(TESTFLAG(FLAG_E))
1252		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1234	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1253	1235	else
1254	1236	Offset=SEX(8,Offset);
1255	1237	Offset<<=1;
1256	1238
1257	1239	if(!(TESTFLAG(FLAG_Z) || (S^V)))
1258	1240	{
1259		se3208_state->PC=se3208_state->PC+Offset;
	1241	m_PC=m_PC+Offset;
1260	1242	}
1261	1243
1262	1244	CLRFLAG(FLAG_E);
r26776	r26777
1269	1251	UINT32 V=TESTFLAG(FLAG_V)?1:0;
1270	1252
1271	1253	if(TESTFLAG(FLAG_E))
1272		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1254	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1273	1255	else
1274	1256	Offset=SEX(8,Offset);
1275	1257	Offset<<=1;
1276	1258
1277	1259	if(S^V)
1278	1260	{
1279		se3208_state->PC=se3208_state->PC+Offset;
	1261	m_PC=m_PC+Offset;
1280	1262	}
1281	1263
1282	1264	CLRFLAG(FLAG_E);
r26776	r26777
1289	1271	UINT32 Offset=EXTRACT(Opcode,0,7);
1290	1272
1291	1273	if(TESTFLAG(FLAG_E))
1292		Offset=(EXTRACT(se3208_state->ER,0,22)<<8)|Offset;
	1274	Offset=(EXTRACT(m_ER,0,22)<<8)|Offset;
1293	1275	else
1294	1276	Offset=SEX(8,Offset);
1295	1277
1296	1278	Offset<<=1;
1297	1279
1298		se3208_state->PC=se3208_state->PC+Offset;
	1280	m_PC=m_PC+Offset;
1299	1281
1300	1282	CLRFLAG(FLAG_E);
1301	1283	}
r26776	r26777
1304	1286	{
1305	1287	UINT32 Src=EXTRACT(Opcode,0,3);
1306	1288
1307		se3208_state->PC=se3208_state->R[Src]-2;
	1289	m_PC=m_R[Src]-2;
1308	1290
1309	1291	CLRFLAG(FLAG_E);
1310	1292	}
r26776	r26777
1312	1294	INST(CALLR)
1313	1295	{
1314	1296	UINT32 Src=EXTRACT(Opcode,0,3);
1315		PushVal(se3208_state,se3208_state->PC+2);
1316		se3208_state->PC=se3208_state->R[Src]-2;
	1297	PushVal(m_PC+2);
	1298	m_PC=m_R[Src]-2;
1317	1299
1318	1300	CLRFLAG(FLAG_E);
1319	1301	}
r26776	r26777
1326	1308	UINT32 Cnt=EXTRACT(Opcode,5,7);
1327	1309
1328	1310	if(CS)
1329		se3208_state->R[Dst]=AsrWithFlags(se3208_state,se3208_state->R[Dst],se3208_state->R[Cnt]&0x1f);
	1311	m_R[Dst]=AsrWithFlags(m_R[Dst],m_R[Cnt]&0x1f);
1330	1312	else
1331		se3208_state->R[Dst]=AsrWithFlags(se3208_state,se3208_state->R[Dst],Imm&0x1f);
	1313	m_R[Dst]=AsrWithFlags(m_R[Dst],Imm&0x1f);
1332	1314
1333	1315	CLRFLAG(FLAG_E);
1334	1316	}
r26776	r26777
1341	1323	UINT32 Cnt=EXTRACT(Opcode,5,7);
1342	1324
1343	1325	if(CS)
1344		se3208_state->R[Dst]=LsrWithFlags(se3208_state,se3208_state->R[Dst],se3208_state->R[Cnt]&0x1f);
	1326	m_R[Dst]=LsrWithFlags(m_R[Dst],m_R[Cnt]&0x1f);
1345	1327	else
1346		se3208_state->R[Dst]=LsrWithFlags(se3208_state,se3208_state->R[Dst],Imm&0x1f);
	1328	m_R[Dst]=LsrWithFlags(m_R[Dst],Imm&0x1f);
1347	1329
1348	1330	CLRFLAG(FLAG_E);
1349	1331	}
r26776	r26777
1356	1338	UINT32 Cnt=EXTRACT(Opcode,5,7);
1357	1339
1358	1340	if(CS)
1359		se3208_state->R[Dst]=AslWithFlags(se3208_state,se3208_state->R[Dst],se3208_state->R[Cnt]&0x1f);
	1341	m_R[Dst]=AslWithFlags(m_R[Dst],m_R[Cnt]&0x1f);
1360	1342	else
1361		se3208_state->R[Dst]=AslWithFlags(se3208_state,se3208_state->R[Dst],Imm&0x1f);
	1343	m_R[Dst]=AslWithFlags(m_R[Dst],Imm&0x1f);
1362	1344
1363	1345	CLRFLAG(FLAG_E);
1364	1346	}
r26776	r26777
1366	1348	INST(EXTB)
1367	1349	{
1368	1350	UINT32 Dst=EXTRACT(Opcode,0,3);
1369		UINT32 Val=se3208_state->R[Dst];
	1351	UINT32 Val=m_R[Dst];
1370	1352
1371		se3208_state->R[Dst]=SEX8(Val);
	1353	m_R[Dst]=SEX8(Val);
1372	1354
1373	1355	CLRFLAG(FLAG_S|FLAG_Z|FLAG_E);
1374		if(!se3208_state->R[Dst])
	1356	if(!m_R[Dst])
1375	1357	SETFLAG(FLAG_Z);
1376		if(se3208_state->R[Dst]&0x80000000)
	1358	if(m_R[Dst]&0x80000000)
1377	1359	SETFLAG(FLAG_S);
1378	1360
1379	1361	}
r26776	r26777
1381	1363	INST(EXTS)
1382	1364	{
1383	1365	UINT32 Dst=EXTRACT(Opcode,0,3);
1384		UINT32 Val=se3208_state->R[Dst];
	1366	UINT32 Val=m_R[Dst];
1385	1367
1386		se3208_state->R[Dst]=SEX16(Val);
	1368	m_R[Dst]=SEX16(Val);
1387	1369
1388	1370	CLRFLAG(FLAG_S|FLAG_Z|FLAG_E);
1389		if(!se3208_state->R[Dst])
	1371	if(!m_R[Dst])
1390	1372	SETFLAG(FLAG_Z);
1391		if(se3208_state->R[Dst]&0x80000000)
	1373	if(m_R[Dst]&0x80000000)
1392	1374	SETFLAG(FLAG_S);
1393	1375	}
1394	1376
r26776	r26777
1396	1378	{
1397	1379	UINT32 Imm=EXTRACT(Opcode,0,3);
1398	1380
1399		se3208_state->SR|=(1<<Imm);
	1381	m_SR|=(1<<Imm);
1400	1382	}
1401	1383
1402	1384	INST(CLR)
1403	1385	{
1404	1386	UINT32 Imm=EXTRACT(Opcode,0,3);
1405	1387
1406		se3208_state->SR&=~(1<<Imm);
	1388	m_SR&=~(1<<Imm);
1407	1389	}
1408	1390
1409	1391	INST(SWI)
r26776	r26777
1412	1394
1413	1395	if(!TESTFLAG(FLAG_ENI))
1414	1396	return;
1415		PushVal(se3208_state,se3208_state->PC);
1416		PushVal(se3208_state,se3208_state->SR);
	1397	PushVal(m_PC);
	1398	PushVal(m_SR);
1417	1399
1418	1400	CLRFLAG(FLAG_ENI|FLAG_E|FLAG_M);
1419	1401
1420		se3208_state->PC=SE3208_Read32(se3208_state, 4*Imm+0x40)-2;
	1402	m_PC=SE3208_Read32(4*Imm+0x40)-2;
1421	1403	}
1422	1404
1423	1405	INST(HALT)
r26776	r26777
1442	1424	}
1443	1425
1444	1426
1445		static _OP DecodeOp(UINT16 Opcode)
	1427	se3208_device::_OP se3208_device::DecodeOp(UINT16 Opcode)
1446	1428	{
1447	1429	switch(EXTRACT(Opcode,14,15))
1448	1430	{
r26776	r26777
1452	1434	switch(Op)
1453	1435	{
1454	1436	case 0x0:
1455		return LDB;
	1437	return &se3208_device::LDB;
1456	1438	case 0x1:
1457		return LDS;
	1439	return &se3208_device::LDS;
1458	1440	case 0x2:
1459		return LD;
	1441	return &se3208_device::LD;
1460	1442	case 0x3:
1461		return LDBU;
	1443	return &se3208_device::LDBU;
1462	1444	case 0x4:
1463		return STB;
	1445	return &se3208_device::STB;
1464	1446	case 0x5:
1465		return STS;
	1447	return &se3208_device::STS;
1466	1448	case 0x6:
1467		return ST;
	1449	return &se3208_device::ST;
1468	1450	case 0x7:
1469		return LDSU;
	1451	return &se3208_device::LDSU;
1470	1452	}
1471	1453	}
1472	1454	break;
1473	1455	case 0x1:
1474		return LERI;
	1456	return &se3208_device::LERI;
1475	1457	case 0x2:
1476	1458	{
1477	1459	switch(EXTRACT(Opcode,11,13))
1478	1460	{
1479	1461	case 0:
1480		return LDSP;
	1462	return &se3208_device::LDSP;
1481	1463	case 1:
1482		return STSP;
	1464	return &se3208_device::STSP;
1483	1465	case 2:
1484		return PUSH;
	1466	return &se3208_device::PUSH;
1485	1467	case 3:
1486		return POP;
	1468	return &se3208_device::POP;
1487	1469	case 4:
1488	1470	case 5:
1489	1471	case 6:
r26776	r26777
1499	1481	switch(EXTRACT(Opcode,6,8))
1500	1482	{
1501	1483	case 0:
1502		return ADDI;
	1484	return &se3208_device::ADDI;
1503	1485	case 1:
1504		return ADCI;
	1486	return &se3208_device::ADCI;
1505	1487	case 2:
1506		return SUBI;
	1488	return &se3208_device::SUBI;
1507	1489	case 3:
1508		return SBCI;
	1490	return &se3208_device::SBCI;
1509	1491	case 4:
1510		return ANDI;
	1492	return &se3208_device::ANDI;
1511	1493	case 5:
1512		return ORI;
	1494	return &se3208_device::ORI;
1513	1495	case 6:
1514		return XORI;
	1496	return &se3208_device::XORI;
1515	1497	case 7:
1516	1498	switch(EXTRACT(Opcode,0,2))
1517	1499	{
1518	1500	case 0:
1519		return CMPI;
	1501	return &se3208_device::CMPI;
1520	1502	case 1:
1521		return TSTI;
	1503	return &se3208_device::TSTI;
1522	1504	case 2:
1523		return LEATOSP;
	1505	return &se3208_device::LEATOSP;
1524	1506	case 3:
1525		return LEAFROMSP;
	1507	return &se3208_device::LEAFROMSP;
1526	1508	}
1527	1509	break;
1528	1510	}
r26776	r26777
1537	1519	switch(EXTRACT(Opcode,6,8))
1538	1520	{
1539	1521	case 0:
1540		return ADD;
	1522	return &se3208_device::ADD;
1541	1523	case 1:
1542		return ADC;
	1524	return &se3208_device::ADC;
1543	1525	case 2:
1544		return SUB;
	1526	return &se3208_device::SUB;
1545	1527	case 3:
1546		return SBC;
	1528	return &se3208_device::SBC;
1547	1529	case 4:
1548		return AND;
	1530	return &se3208_device::AND;
1549	1531	case 5:
1550		return OR;
	1532	return &se3208_device::OR;
1551	1533	case 6:
1552		return XOR;
	1534	return &se3208_device::XOR;
1553	1535	case 7:
1554	1536	switch(EXTRACT(Opcode,0,2))
1555	1537	{
1556	1538	case 0:
1557		return CMP;
	1539	return &se3208_device::CMP;
1558	1540	case 1:
1559		return TST;
	1541	return &se3208_device::TST;
1560	1542	case 2:
1561		return MOV;
	1543	return &se3208_device::MOV;
1562	1544	case 3:
1563		return NEG;
	1545	return &se3208_device::NEG;
1564	1546	}
1565	1547	break;
1566	1548	}
r26776	r26777
1569	1551	switch(EXTRACT(Opcode,8,11))
1570	1552	{
1571	1553	case 0x0:
1572		return JNV;
	1554	return &se3208_device::JNV;
1573	1555	case 0x1:
1574		return JV;
	1556	return &se3208_device::JV;
1575	1557	case 0x2:
1576		return JP;
	1558	return &se3208_device::JP;
1577	1559	case 0x3:
1578		return JM;
	1560	return &se3208_device::JM;
1579	1561	case 0x4:
1580		return JNZ;
	1562	return &se3208_device::JNZ;
1581	1563	case 0x5:
1582		return JZ;
	1564	return &se3208_device::JZ;
1583	1565	case 0x6:
1584		return JNC;
	1566	return &se3208_device::JNC;
1585	1567	case 0x7:
1586		return JC;
	1568	return &se3208_device::JC;
1587	1569	case 0x8:
1588		return JGT;
	1570	return &se3208_device::JGT;
1589	1571	case 0x9:
1590		return JLT;
	1572	return &se3208_device::JLT;
1591	1573	case 0xa:
1592		return JGE;
	1574	return &se3208_device::JGE;
1593	1575	case 0xb:
1594		return JLE;
	1576	return &se3208_device::JLE;
1595	1577	case 0xc:
1596		return JHI;
	1578	return &se3208_device::JHI;
1597	1579	case 0xd:
1598		return JLS;
	1580	return &se3208_device::JLS;
1599	1581	case 0xe:
1600		return JMP;
	1582	return &se3208_device::JMP;
1601	1583	case 0xf:
1602		return CALL;
	1584	return &se3208_device::CALL;
1603	1585	}
1604	1586	break;
1605	1587	case 2:
1606	1588	if(Opcode&(1<<11))
1607		return LDI;
	1589	return &se3208_device::LDI;
1608	1590	else    //SP Ops
1609	1591	{
1610	1592	if(Opcode&(1<<10))
r26776	r26777
1612	1594	switch(EXTRACT(Opcode,7,9))
1613	1595	{
1614	1596	case 0:
1615		return LDBSP;
	1597	return &se3208_device::LDBSP;
1616	1598	case 1:
1617		return LDSSP;
	1599	return &se3208_device::LDSSP;
1618	1600	case 3:
1619		return LDBUSP;
	1601	return &se3208_device::LDBUSP;
1620	1602	case 4:
1621		return STBSP;
	1603	return &se3208_device::STBSP;
1622	1604	case 5:
1623		return STSSP;
	1605	return &se3208_device::STSSP;
1624	1606	case 7:
1625		return LDSUSP;
	1607	return &se3208_device::LDSUSP;
1626	1608	}
1627	1609	}
1628	1610	else
1629	1611	{
1630	1612	if(Opcode&(1<<9))
1631	1613	{
1632		return LEASPTOSP;
	1614	return &se3208_device::LEASPTOSP;
1633	1615	}
1634	1616	else
1635	1617	{
r26776	r26777
1641	1623	switch(EXTRACT(Opcode,4,7))
1642	1624	{
1643	1625	case 0:
1644		return EXTB;
	1626	return &se3208_device::EXTB;
1645	1627	case 1:
1646		return EXTS;
	1628	return &se3208_device::EXTS;
1647	1629	case 8:
1648		return JR;
	1630	return &se3208_device::JR;
1649	1631	case 9:
1650		return CALLR;
	1632	return &se3208_device::CALLR;
1651	1633	case 10:
1652		return SET;
	1634	return &se3208_device::SET;
1653	1635	case 11:
1654		return CLR;
	1636	return &se3208_device::CLR;
1655	1637	case 12:
1656		return SWI;
	1638	return &se3208_device::SWI;
1657	1639	case 13:
1658		return HALT;
	1640	return &se3208_device::HALT;
1659	1641	}
1660	1642	}
1661	1643	}
r26776	r26777
1672	1654	switch(EXTRACT(Opcode,3,4))
1673	1655	{
1674	1656	case 0:
1675		return ASR;
	1657	return &se3208_device::ASR;
1676	1658	case 1:
1677		return LSR;
	1659	return &se3208_device::LSR;
1678	1660	case 2:
1679		return ASL;
	1661	return &se3208_device::ASL;
1680	1662	//case 3:
1681		//  return LSL;
	1663	//  return &se3208_device::LSL;
1682	1664	}
1683	1665	break;
1684	1666	case 4:
1685		return MULS;
	1667	return &se3208_device::MULS;
1686	1668	case 6:
1687	1669	if(Opcode&(1<<3))
1688		return MVFC;
	1670	return &se3208_device::MVFC;
1689	1671	else
1690		return MVTC;
	1672	return &se3208_device::MVTC;
1691	1673	break;
1692	1674	}
1693	1675	break;
r26776	r26777
1695	1677	break;
1696	1678
1697	1679	}
1698		return INVALIDOP;
	1680	return &se3208_device::INVALIDOP;
1699	1681	}
1700	1682
1701	1683
1702		static void BuildTable(void)
	1684	void se3208_device::BuildTable(void)
1703	1685	{
1704	1686	int i;
1705		if(!OpTable)
1706		OpTable=global_alloc_array(_OP, 0x10000);
1707	1687	for(i=0;i<0x10000;++i)
1708	1688	OpTable[i]=DecodeOp(i);
1709	1689	}
1710	1690
1711		static CPU_RESET( se3208 )
	1691	void se3208_device::device_reset()
1712	1692	{
1713		se3208_state_t *se3208_state = get_safe_token(device);
1714
1715		device_irq_acknowledge_callback save_irqcallback = se3208_state->irq_callback;
1716		memset(se3208_state,0,sizeof(se3208_state_t));
1717		se3208_state->irq_callback = save_irqcallback;
1718		se3208_state->device = device;
1719		se3208_state->program = &device->space(AS_PROGRAM);
1720		se3208_state->direct = &se3208_state->program->direct();
1721		se3208_state->PC=SE3208_Read32(se3208_state, 0);
1722		se3208_state->SR=0;
1723		se3208_state->IRQ=CLEAR_LINE;
1724		se3208_state->NMI=CLEAR_LINE;
	1693	for ( int i = 0; i < 8; i++ )
	1694	{
	1695	m_R[i] = 0;
	1696	}
	1697	m_SP = 0;
	1698	m_ER = 0;
	1699	m_PPC = 0;
	1700	m_program = &space(AS_PROGRAM);
	1701	m_direct = &m_program->direct();
	1702	m_PC=SE3208_Read32(0);
	1703	m_SR=0;
	1704	m_IRQ=CLEAR_LINE;
	1705	m_NMI=CLEAR_LINE;
1725	1706	}
1726	1707
1727		static void SE3208_NMI(se3208_state_t *se3208_state)
	1708	void se3208_device::SE3208_NMI()
1728	1709	{
1729		PushVal(se3208_state,se3208_state->PC);
1730		PushVal(se3208_state,se3208_state->SR);
	1710	PushVal(m_PC);
	1711	PushVal(m_SR);
1731	1712
1732	1713	CLRFLAG(FLAG_NMI|FLAG_ENI|FLAG_E|FLAG_M);
1733	1714
1734		se3208_state->PC=SE3208_Read32(se3208_state, 4);
	1715	m_PC=SE3208_Read32(4);
1735	1716	}
1736	1717
1737		static void SE3208_Interrupt(se3208_state_t *se3208_state)
	1718	void se3208_device::SE3208_Interrupt()
1738	1719	{
1739	1720	if(!TESTFLAG(FLAG_ENI))
1740	1721	return;
1741	1722
1742		PushVal(se3208_state,se3208_state->PC);
1743		PushVal(se3208_state,se3208_state->SR);
	1723	PushVal(m_PC);
	1724	PushVal(m_SR);
1744	1725
1745	1726	CLRFLAG(FLAG_ENI|FLAG_E|FLAG_M);
1746	1727
1747	1728
1748	1729	if(!(TESTFLAG(FLAG_AUT)))
1749		se3208_state->PC=SE3208_Read32(se3208_state, 8);
	1730	m_PC=SE3208_Read32(8);
1750	1731	else
1751		se3208_state->PC=SE3208_Read32(se3208_state, 4*se3208_state->irq_callback(se3208_state->device, 0));
	1732	m_PC=SE3208_Read32(4*standard_irq_callback(0));
1752	1733	}
1753	1734
1754	1735
1755		static CPU_EXECUTE( se3208 )
	1736	void se3208_device::execute_run()
1756	1737	{
1757		se3208_state_t *se3208_state = get_safe_token(device);
1758
1759	1738	do
1760	1739	{
1761		UINT16 Opcode=se3208_state->direct->read_decrypted_word(se3208_state->PC, WORD_XOR_LE(0));
	1740	UINT16 Opcode=m_direct->read_decrypted_word(m_PC, WORD_XOR_LE(0));
1762	1741
1763		debugger_instruction_hook(device, se3208_state->PC);
	1742	debugger_instruction_hook(this, m_PC);
1764	1743
1765		OpTable[Opcode](se3208_state, Opcode);
1766		se3208_state->PPC=se3208_state->PC;
1767		se3208_state->PC+=2;
	1744	(this->*OpTable[Opcode])(Opcode);
	1745	m_PPC=m_PC;
	1746	m_PC+=2;
1768	1747	//Check interrupts
1769		if(se3208_state->NMI==ASSERT_LINE)
	1748	if(m_NMI==ASSERT_LINE)
1770	1749	{
1771		SE3208_NMI(se3208_state);
1772		se3208_state->NMI=CLEAR_LINE;
	1750	SE3208_NMI();
	1751	m_NMI=CLEAR_LINE;
1773	1752	}
1774		else if(se3208_state->IRQ==ASSERT_LINE && TESTFLAG(FLAG_ENI))
	1753	else if(m_IRQ==ASSERT_LINE && TESTFLAG(FLAG_ENI))
1775	1754	{
1776		SE3208_Interrupt(se3208_state);
	1755	SE3208_Interrupt();
1777	1756	}
1778		--(se3208_state->icount);
1779		} while(se3208_state->icount>0);
	1757	--(m_icount);
	1758	} while(m_icount>0);
1780	1759	}
1781	1760
1782		static CPU_INIT( se3208 )
	1761	void se3208_device::device_start()
1783	1762	{
1784		se3208_state_t *se3208_state = get_safe_token(device);
1785
1786	1763	BuildTable();
1787	1764
1788		se3208_state->irq_callback = irqcallback;
1789		se3208_state->device = device;
1790		se3208_state->program = &device->space(AS_PROGRAM);
1791		se3208_state->direct = &se3208_state->program->direct();
1792		}
	1765	m_program = &space(AS_PROGRAM);
	1766	m_direct = &m_program->direct();
1793	1767
1794		static CPU_EXIT( se3208 )
1795		{
1796		if(OpTable) {
1797		global_free(OpTable);
1798		OpTable = NULL;
1799		}
1800		}
	1768	save_item(NAME(m_R));
	1769	save_item(NAME(m_PC));
	1770	save_item(NAME(m_SR));
	1771	save_item(NAME(m_SP));
	1772	save_item(NAME(m_ER));
	1773	save_item(NAME(m_IRQ));
	1774	save_item(NAME(m_NMI));
1801	1775
	1776	state_add( SE3208_PC,  "PC", m_PC).formatstr("%08X");
	1777	state_add( SE3208_SR,  "SR", m_SR).formatstr("%08X");
	1778	state_add( SE3208_ER,  "ER", m_ER).formatstr("%08X");
	1779	state_add( SE3208_SP,  "SP", m_SP).formatstr("%08X");
	1780	state_add( SE3208_R0,  "R0", m_R[ 0]).formatstr("%08X");
	1781	state_add( SE3208_R1,  "R1", m_R[ 1]).formatstr("%08X");
	1782	state_add( SE3208_R2,  "R2", m_R[ 2]).formatstr("%08X");
	1783	state_add( SE3208_R3,  "R3", m_R[ 3]).formatstr("%08X");
	1784	state_add( SE3208_R4,  "R4", m_R[ 4]).formatstr("%08X");
	1785	state_add( SE3208_R5,  "R5", m_R[ 5]).formatstr("%08X");
	1786	state_add( SE3208_R6,  "R6", m_R[ 6]).formatstr("%08X");
	1787	state_add( SE3208_R7,  "R7", m_R[ 7]).formatstr("%08X");
	1788	state_add( SE3208_PPC, "PPC", m_PPC).formatstr("%08X");
1802	1789
1803		static void set_irq_line(se3208_state_t *se3208_state, int line,int state)
1804		{
1805		if(line==INPUT_LINE_NMI)    //NMI
1806		se3208_state->NMI=state;
1807		else
1808		se3208_state->IRQ=state;
	1790	state_add(STATE_GENPC, "GENPC", m_PC).noshow();
	1791	state_add(STATE_GENSP, "GENSP", m_SP).noshow();
	1792	state_add(STATE_GENFLAGS, "GENFLAGS", m_SR).formatstr("%10s").noshow();
	1793	state_add(STATE_GENPCBASE, "GENPCBASE", m_PPC).noshow();
	1794
	1795	m_icountptr = &m_icount;
1809	1796	}
1810	1797
1811	1798
1812		static CPU_SET_INFO( se3208 )
	1799	void se3208_device::state_string_export(const device_state_entry &entry, astring &string)
1813	1800	{
1814		se3208_state_t *se3208_state = get_safe_token(device);
1815
1816		switch (state)
	1801	switch (entry.index())
1817	1802	{
1818		/* --- the following bits of info are set as 64-bit signed integers --- */
1819		case CPUINFO_INT_INPUT_STATE + SE3208_INT:      set_irq_line(se3208_state, 0, info->i);             break;
1820		case CPUINFO_INT_INPUT_STATE + INPUT_LINE_NMI:  set_irq_line(se3208_state, INPUT_LINE_NMI, info->i);    break;
	1803	case STATE_GENFLAGS:
	1804	string.printf("%c%c%c%c %c%c%c%c%c",
	1805	m_SR&FLAG_C?'C':'.',
	1806	m_SR&FLAG_V?'V':'.',
	1807	m_SR&FLAG_S?'S':'.',
	1808	m_SR&FLAG_Z?'Z':'.',
1821	1809
1822		case CPUINFO_INT_REGISTER + SE3208_PC:
1823		case CPUINFO_INT_PC:                            se3208_state->PC = info->i;                 break;
1824		case CPUINFO_INT_REGISTER + SE3208_SP:
1825		case CPUINFO_INT_SP:                            se3208_state->SP = info->i;                 break;
1826		case CPUINFO_INT_REGISTER + SE3208_ER:          se3208_state->ER = info->i;                 break;
1827		case CPUINFO_INT_REGISTER + SE3208_SR:          se3208_state->SR = info->i;                 break;
1828		case CPUINFO_INT_REGISTER + SE3208_R0:          se3208_state->R[ 0] = info->i;              break;
1829		case CPUINFO_INT_REGISTER + SE3208_R1:          se3208_state->R[ 1] = info->i;              break;
1830		case CPUINFO_INT_REGISTER + SE3208_R2:          se3208_state->R[ 2] = info->i;              break;
1831		case CPUINFO_INT_REGISTER + SE3208_R3:          se3208_state->R[ 3] = info->i;              break;
1832		case CPUINFO_INT_REGISTER + SE3208_R4:          se3208_state->R[ 4] = info->i;              break;
1833		case CPUINFO_INT_REGISTER + SE3208_R5:          se3208_state->R[ 5] = info->i;              break;
1834		case CPUINFO_INT_REGISTER + SE3208_R6:          se3208_state->R[ 6] = info->i;              break;
1835		case CPUINFO_INT_REGISTER + SE3208_R7:          se3208_state->R[ 7] = info->i;              break;
	1810	m_SR&FLAG_M?'M':'.',
	1811	m_SR&FLAG_E?'E':'.',
	1812	m_SR&FLAG_AUT?'A':'.',
	1813	m_SR&FLAG_ENI?'I':'.',
	1814	m_SR&FLAG_NMI?'N':'.'
	1815	);
	1816	break;
1836	1817	}
1837	1818	}
1838	1819
1839
1840		CPU_GET_INFO( se3208 )
	1820	void se3208_device::execute_set_input( int line, int state )
1841	1821	{
1842		se3208_state_t *se3208_state = (device != NULL && device->token() != NULL) ? get_safe_token(device) : NULL;
	1822	if(line==INPUT_LINE_NMI)    //NMI
	1823	m_NMI=state;
	1824	else
	1825	m_IRQ=state;
	1826	}
1843	1827
1844		switch (state)
1845		{
1846		/* --- the following bits of info are returned as 64-bit signed integers --- */
1847		case CPUINFO_INT_CONTEXT_SIZE:                  info->i = sizeof(se3208_state_t);               break;
1848		case CPUINFO_INT_INPUT_LINES:                   info->i = 1;                            break;
1849		case CPUINFO_INT_DEFAULT_IRQ_VECTOR:            info->i = 0;                            break;
1850		case CPUINFO_INT_ENDIANNESS:                    info->i = ENDIANNESS_LITTLE;                    break;
1851		case CPUINFO_INT_CLOCK_MULTIPLIER:              info->i = 1;                            break;
1852		case CPUINFO_INT_CLOCK_DIVIDER:                 info->i = 1;                            break;
1853		case CPUINFO_INT_MIN_INSTRUCTION_BYTES:         info->i = 2;                            break;
1854		case CPUINFO_INT_MAX_INSTRUCTION_BYTES:         info->i = 2;                            break;
1855		case CPUINFO_INT_MIN_CYCLES:                    info->i = 1;                            break;
1856		case CPUINFO_INT_MAX_CYCLES:                    info->i = 1;                            break;
1857
1858		case CPUINFO_INT_DATABUS_WIDTH + AS_PROGRAM:    info->i = 32;                   break;
1859		case CPUINFO_INT_ADDRBUS_WIDTH + AS_PROGRAM: info->i = 32;                  break;
1860		case CPUINFO_INT_ADDRBUS_SHIFT + AS_PROGRAM: info->i = 0;                   break;
1861		case CPUINFO_INT_DATABUS_WIDTH + AS_DATA:   info->i = 0;                    break;
1862		case CPUINFO_INT_ADDRBUS_WIDTH + AS_DATA:   info->i = 0;                    break;
1863		case CPUINFO_INT_ADDRBUS_SHIFT + AS_DATA:   info->i = 0;                    break;
1864		case CPUINFO_INT_DATABUS_WIDTH + AS_IO:     info->i = 0;                    break;
1865		case CPUINFO_INT_ADDRBUS_WIDTH + AS_IO:     info->i = 0;                    break;
1866		case CPUINFO_INT_ADDRBUS_SHIFT + AS_IO:     info->i = 0;                    break;
1867
1868		case CPUINFO_INT_INPUT_STATE + SE3208_INT:      info->i = se3208_state->IRQ;                    break;
1869		case CPUINFO_INT_INPUT_STATE + INPUT_LINE_NMI:  info->i = se3208_state->NMI;                    break;
1870
1871		case CPUINFO_INT_PREVIOUSPC:                    info->i = se3208_state->PPC;                    break;
1872
1873		case CPUINFO_INT_PC:
1874		case CPUINFO_INT_REGISTER + SE3208_PC:          info->i = se3208_state->PC;                 break;
1875		case CPUINFO_INT_REGISTER + SE3208_SP:
1876		case CPUINFO_INT_SP:                            info->i = se3208_state->SP;                 break;
1877		case CPUINFO_INT_REGISTER + SE3208_SR:          info->i = se3208_state->SR;                 break;
1878		case CPUINFO_INT_REGISTER + SE3208_ER:          info->i = se3208_state->ER;                 break;
1879		case CPUINFO_INT_REGISTER + SE3208_R0:          info->i = se3208_state->R[ 0];              break;
1880		case CPUINFO_INT_REGISTER + SE3208_R1:          info->i = se3208_state->R[ 1];              break;
1881		case CPUINFO_INT_REGISTER + SE3208_R2:          info->i = se3208_state->R[ 2];              break;
1882		case CPUINFO_INT_REGISTER + SE3208_R3:          info->i = se3208_state->R[ 3];              break;
1883		case CPUINFO_INT_REGISTER + SE3208_R4:          info->i = se3208_state->R[ 4];              break;
1884		case CPUINFO_INT_REGISTER + SE3208_R5:          info->i = se3208_state->R[ 5];              break;
1885		case CPUINFO_INT_REGISTER + SE3208_R6:          info->i = se3208_state->R[ 6];              break;
1886		case CPUINFO_INT_REGISTER + SE3208_R7:          info->i = se3208_state->R[ 7];              break;
1887
1888		/* --- the following bits of info are returned as pointers to data or functions --- */
1889		case CPUINFO_FCT_SET_INFO:                      info->setinfo = CPU_SET_INFO_NAME(se3208);      break;
1890		case CPUINFO_FCT_INIT:                          info->init = CPU_INIT_NAME(se3208);     break;
1891		case CPUINFO_FCT_RESET:                         info->reset = CPU_RESET_NAME(se3208);   break;
1892		case CPUINFO_FCT_EXIT:                          info->exit = CPU_EXIT_NAME(se3208);     break;
1893		case CPUINFO_FCT_EXECUTE:                       info->execute = CPU_EXECUTE_NAME(se3208);break;
1894		case CPUINFO_FCT_BURN:                          info->burn = NULL;                      break;
1895		case CPUINFO_FCT_DISASSEMBLE:                   info->disassemble = CPU_DISASSEMBLE_NAME(se3208);       break;
1896		case CPUINFO_PTR_INSTRUCTION_COUNTER:           info->icount = &se3208_state->icount;           break;
1897
1898		/* --- the following bits of info are returned as NULL-terminated strings --- */
1899		case CPUINFO_STR_NAME:                          strcpy(info->s, "SE3208");              break;
1900		case CPUINFO_STR_SHORTNAME:                     strcpy(info->s, "se3208");              break;
1901		case CPUINFO_STR_FAMILY:                    strcpy(info->s, "Advanced Digital Chips Inc."); break;
1902		case CPUINFO_STR_VERSION:                   strcpy(info->s, "1.00");                break;
1903		case CPUINFO_STR_SOURCE_FILE:                       strcpy(info->s, __FILE__);              break;
1904		case CPUINFO_STR_CREDITS:                   strcpy(info->s, "Copyright Miguel Angel Horna, all rights reserved."); break;
1905
1906		case CPUINFO_STR_FLAGS:
1907		sprintf(info->s, "%c%c%c%c %c%c%c%c%c",
1908		se3208_state->SR&FLAG_C?'C':'.',
1909		se3208_state->SR&FLAG_V?'V':'.',
1910		se3208_state->SR&FLAG_S?'S':'.',
1911		se3208_state->SR&FLAG_Z?'Z':'.',
1912
1913		se3208_state->SR&FLAG_M?'M':'.',
1914		se3208_state->SR&FLAG_E?'E':'.',
1915		se3208_state->SR&FLAG_AUT?'A':'.',
1916		se3208_state->SR&FLAG_ENI?'I':'.',
1917		se3208_state->SR&FLAG_NMI?'N':'.'
1918
1919		);
1920
1921		break;
1922
1923		case CPUINFO_STR_REGISTER + SE3208_PC:              sprintf(info->s, "PC  :%08X", se3208_state->PC); break;
1924		case CPUINFO_STR_REGISTER + SE3208_SR:              sprintf(info->s, "SR  :%08X", se3208_state->SR); break;
1925		case CPUINFO_STR_REGISTER + SE3208_ER:              sprintf(info->s, "ER  :%08X", se3208_state->ER); break;
1926		case CPUINFO_STR_REGISTER + SE3208_SP:              sprintf(info->s, "SP  :%08X", se3208_state->SP); break;
1927		case CPUINFO_STR_REGISTER + SE3208_R0:              sprintf(info->s, "R0  :%08X", se3208_state->R[ 0]); break;
1928		case CPUINFO_STR_REGISTER + SE3208_R1:              sprintf(info->s, "R1  :%08X", se3208_state->R[ 1]); break;
1929		case CPUINFO_STR_REGISTER + SE3208_R2:              sprintf(info->s, "R2  :%08X", se3208_state->R[ 2]); break;
1930		case CPUINFO_STR_REGISTER + SE3208_R3:              sprintf(info->s, "R3  :%08X", se3208_state->R[ 3]); break;
1931		case CPUINFO_STR_REGISTER + SE3208_R4:              sprintf(info->s, "R4  :%08X", se3208_state->R[ 4]); break;
1932		case CPUINFO_STR_REGISTER + SE3208_R5:              sprintf(info->s, "R5  :%08X", se3208_state->R[ 5]); break;
1933		case CPUINFO_STR_REGISTER + SE3208_R6:              sprintf(info->s, "R6  :%08X", se3208_state->R[ 6]); break;
1934		case CPUINFO_STR_REGISTER + SE3208_R7:              sprintf(info->s, "R7  :%08X", se3208_state->R[ 7]); break;
1935		case CPUINFO_STR_REGISTER + SE3208_PPC:             sprintf(info->s, "PPC  :%08X", se3208_state->PPC); break;
1936		}
	1828	offs_t se3208_device::disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options)
	1829	{
	1830	extern CPU_DISASSEMBLE( se3208 );
	1831	return CPU_DISASSEMBLE_NAME(se3208)(this, buffer, pc, oprom, opram, options);
1937	1832	}
1938	1833
1939	1834
1940		DEFINE_LEGACY_CPU_DEVICE(SE3208, se3208);

trunk/src/emu/cpu/se3208/se3208.h

r26776	r26777
7	7
8	8	#define SE3208_INT  0
9	9
10		DECLARE_LEGACY_CPU_DEVICE(SE3208, se3208);
11	10
12		CPU_DISASSEMBLE( se3208 );
	11	class se3208_device :  public cpu_device
	12	{
	13	public:
	14	// construction/destruction
	15	se3208_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	16
	17	protected:
	18	// device-level overrides
	19	virtual void device_start();
	20	virtual void device_reset();
	21
	22	// device_execute_interface overrides
	23	virtual UINT32 execute_min_cycles() const { return 1; }
	24	virtual UINT32 execute_max_cycles() const { return 1; }
	25	virtual UINT32 execute_input_lines() const { return 1; }
	26	virtual void execute_run();
	27	virtual void execute_set_input(int inputnum, int state);
	28
	29	// device_memory_interface overrides
	30	virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : NULL; }
	31
	32	// device_state_interface overrides
	33	void state_string_export(const device_state_entry &entry, astring &string);
	34
	35	// device_disasm_interface overrides
	36	virtual UINT32 disasm_min_opcode_bytes() const { return 2; }
	37	virtual UINT32 disasm_max_opcode_bytes() const { return 2; }
	38	virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
	39
	40	private:
	41	address_space_config m_program_config;
	42
	43	//GPR
	44	UINT32 m_R[8];
	45	//SPR
	46	UINT32 m_PC;
	47	UINT32 m_SR;
	48	UINT32 m_SP;
	49	UINT32 m_ER;
	50	UINT32 m_PPC;
	51
	52	address_space *m_program;
	53	direct_read_data *m_direct;
	54	UINT8 m_IRQ;
	55	UINT8 m_NMI;
	56
	57	int m_icount;
	58
	59	inline UINT32 read_dword_unaligned(address_space &space, UINT32 address);
	60	inline UINT16 read_word_unaligned(address_space &space, UINT32 address);
	61	inline void write_dword_unaligned(address_space &space, UINT32 address, UINT32 data);
	62	inline void write_word_unaligned(address_space &space, UINT32 address, UINT16 data);
	63	inline UINT8 SE3208_Read8(UINT32 addr);
	64	inline UINT16 SE3208_Read16(UINT32 addr);
	65	inline UINT32 SE3208_Read32(UINT32 addr);
	66	inline void SE3208_Write8(UINT32 addr,UINT8 val);
	67	inline void SE3208_Write16(UINT32 addr,UINT16 val);
	68	inline void SE3208_Write32(UINT32 addr,UINT32 val);
	69	inline UINT32 AddWithFlags(UINT32 a,UINT32 b);
	70	inline UINT32 SubWithFlags(UINT32 a,UINT32 b);
	71	inline UINT32 AdcWithFlags(UINT32 a,UINT32 b);
	72	inline UINT32 SbcWithFlags(UINT32 a,UINT32 b);
	73	inline UINT32 MulWithFlags(UINT32 a,UINT32 b);
	74	inline UINT32 NegWithFlags(UINT32 a);
	75	inline UINT32 AsrWithFlags(UINT32 Val, UINT8 By);
	76	inline UINT32 LsrWithFlags(UINT32 Val, UINT8 By);
	77	inline UINT32 AslWithFlags(UINT32 Val, UINT8 By);
	78	inline void PushVal(UINT32 Val);
	79	inline UINT32 PopVal();
	80
	81	typedef void (se3208_device::*_OP)(UINT16 Opcode);
	82	_OP OpTable[0x10000];
	83
	84	void INVALIDOP(UINT16 Opcode);
	85	void LDB(UINT16 Opcode);
	86	void STB(UINT16 Opcode);
	87	void LDS(UINT16 Opcode);
	88	void STS(UINT16 Opcode);
	89	void LD(UINT16 Opcode);
	90	void ST(UINT16 Opcode);
	91	void LDBU(UINT16 Opcode);
	92	void LDSU(UINT16 Opcode);
	93	void LERI(UINT16 Opcode);
	94	void LDSP(UINT16 Opcode);
	95	void STSP(UINT16 Opcode);
	96	void PUSH(UINT16 Opcode);
	97	void POP(UINT16 Opcode);
	98	void LEATOSP(UINT16 Opcode);
	99	void LEAFROMSP(UINT16 Opcode);
	100	void LEASPTOSP(UINT16 Opcode);
	101	void MOV(UINT16 Opcode);
	102	void LDI(UINT16 Opcode);
	103	void LDBSP(UINT16 Opcode);
	104	void STBSP(UINT16 Opcode);
	105	void LDSSP(UINT16 Opcode);
	106	void STSSP(UINT16 Opcode);
	107	void LDBUSP(UINT16 Opcode);
	108	void LDSUSP(UINT16 Opcode);
	109	void ADDI(UINT16 Opcode);
	110	void SUBI(UINT16 Opcode);
	111	void ADCI(UINT16 Opcode);
	112	void SBCI(UINT16 Opcode);
	113	void ANDI(UINT16 Opcode);
	114	void ORI(UINT16 Opcode);
	115	void XORI(UINT16 Opcode);
	116	void CMPI(UINT16 Opcode);
	117	void TSTI(UINT16 Opcode);
	118	void ADD(UINT16 Opcode);
	119	void SUB(UINT16 Opcode);
	120	void ADC(UINT16 Opcode);
	121	void SBC(UINT16 Opcode);
	122	void AND(UINT16 Opcode);
	123	void OR(UINT16 Opcode);
	124	void XOR(UINT16 Opcode);
	125	void CMP(UINT16 Opcode);
	126	void TST(UINT16 Opcode);
	127	void MULS(UINT16 Opcode);
	128	void NEG(UINT16 Opcode);
	129	void CALL(UINT16 Opcode);
	130	void JV(UINT16 Opcode);
	131	void JNV(UINT16 Opcode);
	132	void JC(UINT16 Opcode);
	133	void JNC(UINT16 Opcode);
	134	void JP(UINT16 Opcode);
	135	void JM(UINT16 Opcode);
	136	void JNZ(UINT16 Opcode);
	137	void JZ(UINT16 Opcode);
	138	void JGE(UINT16 Opcode);
	139	void JLE(UINT16 Opcode);
	140	void JHI(UINT16 Opcode);
	141	void JLS(UINT16 Opcode);
	142	void JGT(UINT16 Opcode);
	143	void JLT(UINT16 Opcode);
	144	void JMP(UINT16 Opcode);
	145	void JR(UINT16 Opcode);
	146	void CALLR(UINT16 Opcode);
	147	void ASR(UINT16 Opcode);
	148	void LSR(UINT16 Opcode);
	149	void ASL(UINT16 Opcode);
	150	void EXTB(UINT16 Opcode);
	151	void EXTS(UINT16 Opcode);
	152	void SET(UINT16 Opcode);
	153	void CLR(UINT16 Opcode);
	154	void SWI(UINT16 Opcode);
	155	void HALT(UINT16 Opcode);
	156	void MVTC(UINT16 Opcode);
	157	void MVFC(UINT16 Opcode);
	158
	159	void BuildTable(void);
	160	_OP DecodeOp(UINT16 Opcode);
	161	void SE3208_NMI();
	162	void SE3208_Interrupt();
	163
	164	};
	165
	166
	167	extern const device_type SE3208;
	168

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team