]> Git Repo - binutils.git/blame - sim/arm/armemu.c
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* aout64.h (N_SHARED_LIB): Define as 0 if TEXT_START_ADDR is
[binutils.git] / sim / arm / armemu.c
CommitLineData
c906108c
SS		 1/* armemu.c -- Main instruction emulation: ARM7 Instruction Emulator.
2 Copyright (C) 1994 Advanced RISC Machines Ltd.
3 Modifications to add arch. v4 support by <[email protected]>.
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
18
19#include "armdefs.h"
20#include "armemu.h"
7a292a7a 21#include "armos.h"
c906108c
SS		 22
23static ARMword GetDPRegRHS(ARMul_State *state, ARMword instr) ;
24static ARMword GetDPSRegRHS(ARMul_State *state, ARMword instr) ;
25static void WriteR15(ARMul_State *state, ARMword src) ;
26static void WriteSR15(ARMul_State *state, ARMword src) ;
27static ARMword GetLSRegRHS(ARMul_State *state, ARMword instr) ;
28static ARMword GetLS7RHS(ARMul_State *state, ARMword instr) ;
29static unsigned LoadWord(ARMul_State *state, ARMword instr, ARMword address) ;
30static unsigned LoadHalfWord(ARMul_State *state, ARMword instr, ARMword address,int signextend) ;
31static unsigned LoadByte(ARMul_State *state, ARMword instr, ARMword address,int signextend) ;
32static unsigned StoreWord(ARMul_State *state, ARMword instr, ARMword address) ;
33static unsigned StoreHalfWord(ARMul_State *state, ARMword instr, ARMword address) ;
34static unsigned StoreByte(ARMul_State *state, ARMword instr, ARMword address) ;
35static void LoadMult(ARMul_State *state, ARMword address, ARMword instr, ARMword WBBase) ;
36static void StoreMult(ARMul_State *state, ARMword address, ARMword instr, ARMword WBBase) ;
37static void LoadSMult(ARMul_State *state, ARMword address, ARMword instr, ARMword WBBase) ;
38static void StoreSMult(ARMul_State *state, ARMword address, ARMword instr, ARMword WBBase) ;
39static unsigned Multiply64(ARMul_State *state, ARMword instr,int signextend,int scc) ;
40static unsigned MultiplyAdd64(ARMul_State *state, ARMword instr,int signextend,int scc) ;
41
42#define LUNSIGNED (0) /* unsigned operation */
43#define LSIGNED (1) /* signed operation */
44#define LDEFAULT (0) /* default : do nothing */
45#define LSCC (1) /* set condition codes on result */
46
7a292a7a
SS		 47#ifdef NEED_UI_LOOP_HOOK
48/* How often to run the ui_loop update, when in use */
49#define UI_LOOP_POLL_INTERVAL 0x32000
50
51/* Counter for the ui_loop_hook update */
52static long ui_loop_hook_counter = UI_LOOP_POLL_INTERVAL;
53
54/* Actual hook to call to run through gdb's gui event loop */
55extern int (*ui_loop_hook) (int);
56#endif /* NEED_UI_LOOP_HOOK */
57
58extern int stop_simulator;
59
c906108c
SS		 60/***************************************************************************\
61* short-hand macros for LDR/STR *
62\***************************************************************************/
63
64/* store post decrement writeback */
65#define SHDOWNWB() \
66 lhs = LHS ; \
67 if (StoreHalfWord(state, instr, lhs)) \
68 LSBase = lhs - GetLS7RHS(state, instr) ;
69
70/* store post increment writeback */
71#define SHUPWB() \
72 lhs = LHS ; \
73 if (StoreHalfWord(state, instr, lhs)) \
74 LSBase = lhs + GetLS7RHS(state, instr) ;
75
76/* store pre decrement */
77#define SHPREDOWN() \
78 (void)StoreHalfWord(state, instr, LHS - GetLS7RHS(state, instr)) ;
79
80/* store pre decrement writeback */
81#define SHPREDOWNWB() \
82 temp = LHS - GetLS7RHS(state, instr) ; \
83 if (StoreHalfWord(state, instr, temp)) \
84 LSBase = temp ;
85
86/* store pre increment */
87#define SHPREUP() \
88 (void)StoreHalfWord(state, instr, LHS + GetLS7RHS(state, instr)) ;
89
90/* store pre increment writeback */
91#define SHPREUPWB() \
92 temp = LHS + GetLS7RHS(state, instr) ; \
93 if (StoreHalfWord(state, instr, temp)) \
94 LSBase = temp ;
95
96/* load post decrement writeback */
97#define LHPOSTDOWN() \
98{ \
99 int done = 1 ; \
100 lhs = LHS ; \
101 switch (BITS(5,6)) { \
102 case 1: /* H */ \
103 if (LoadHalfWord(state,instr,lhs,LUNSIGNED)) \
104 LSBase = lhs - GetLS7RHS(state,instr) ; \
105 break ; \
106 case 2: /* SB */ \
107 if (LoadByte(state,instr,lhs,LSIGNED)) \
108 LSBase = lhs - GetLS7RHS(state,instr) ; \
109 break ; \
110 case 3: /* SH */ \
111 if (LoadHalfWord(state,instr,lhs,LSIGNED)) \
112 LSBase = lhs - GetLS7RHS(state,instr) ; \
113 break ; \
114 case 0: /* SWP handled elsewhere */ \
115 default: \
116 done = 0 ; \
117 break ; \
118 } \
119 if (done) \
120 break ; \
121}
122
123/* load post increment writeback */
124#define LHPOSTUP() \
125{ \
126 int done = 1 ; \
127 lhs = LHS ; \
128 switch (BITS(5,6)) { \
129 case 1: /* H */ \
130 if (LoadHalfWord(state,instr,lhs,LUNSIGNED)) \
131 LSBase = lhs + GetLS7RHS(state,instr) ; \
132 break ; \
133 case 2: /* SB */ \
134 if (LoadByte(state,instr,lhs,LSIGNED)) \
135 LSBase = lhs + GetLS7RHS(state,instr) ; \
136 break ; \
137 case 3: /* SH */ \
138 if (LoadHalfWord(state,instr,lhs,LSIGNED)) \
139 LSBase = lhs + GetLS7RHS(state,instr) ; \
140 break ; \
141 case 0: /* SWP handled elsewhere */ \
142 default: \
143 done = 0 ; \
144 break ; \
145 } \
146 if (done) \
147 break ; \
148}
149
150/* load pre decrement */
151#define LHPREDOWN() \
152{ \
153 int done = 1 ; \
154 temp = LHS - GetLS7RHS(state,instr) ; \
155 switch (BITS(5,6)) { \
156 case 1: /* H */ \
157 (void)LoadHalfWord(state,instr,temp,LUNSIGNED) ; \
158 break ; \
159 case 2: /* SB */ \
160 (void)LoadByte(state,instr,temp,LSIGNED) ; \
161 break ; \
162 case 3: /* SH */ \
163 (void)LoadHalfWord(state,instr,temp,LSIGNED) ; \
164 break ; \
165 case 0: /* SWP handled elsewhere */ \
166 default: \
167 done = 0 ; \
168 break ; \
169 } \
170 if (done) \
171 break ; \
172}
173
174/* load pre decrement writeback */
175#define LHPREDOWNWB() \
176{ \
177 int done = 1 ; \
178 temp = LHS - GetLS7RHS(state, instr) ; \
179 switch (BITS(5,6)) { \
180 case 1: /* H */ \
181 if (LoadHalfWord(state,instr,temp,LUNSIGNED)) \
182 LSBase = temp ; \
183 break ; \
184 case 2: /* SB */ \
185 if (LoadByte(state,instr,temp,LSIGNED)) \
186 LSBase = temp ; \
187 break ; \
188 case 3: /* SH */ \
189 if (LoadHalfWord(state,instr,temp,LSIGNED)) \
190 LSBase = temp ; \
191 break ; \
192 case 0: /* SWP handled elsewhere */ \
193 default: \
194 done = 0 ; \
195 break ; \
196 } \
197 if (done) \
198 break ; \
199}
200
201/* load pre increment */
202#define LHPREUP() \
203{ \
204 int done = 1 ; \
205 temp = LHS + GetLS7RHS(state,instr) ; \
206 switch (BITS(5,6)) { \
207 case 1: /* H */ \
208 (void)LoadHalfWord(state,instr,temp,LUNSIGNED) ; \
209 break ; \
210 case 2: /* SB */ \
211 (void)LoadByte(state,instr,temp,LSIGNED) ; \
212 break ; \
213 case 3: /* SH */ \
214 (void)LoadHalfWord(state,instr,temp,LSIGNED) ; \
215 break ; \
216 case 0: /* SWP handled elsewhere */ \
217 default: \
218 done = 0 ; \
219 break ; \
220 } \
221 if (done) \
222 break ; \
223}
224
225/* load pre increment writeback */
226#define LHPREUPWB() \
227{ \
228 int done = 1 ; \
229 temp = LHS + GetLS7RHS(state, instr) ; \
230 switch (BITS(5,6)) { \
231 case 1: /* H */ \
232 if (LoadHalfWord(state,instr,temp,LUNSIGNED)) \
233 LSBase = temp ; \
234 break ; \
235 case 2: /* SB */ \
236 if (LoadByte(state,instr,temp,LSIGNED)) \
237 LSBase = temp ; \
238 break ; \
239 case 3: /* SH */ \
240 if (LoadHalfWord(state,instr,temp,LSIGNED)) \
241 LSBase = temp ; \
242 break ; \
243 case 0: /* SWP handled elsewhere */ \
244 default: \
245 done = 0 ; \
246 break ; \
247 } \
248 if (done) \
249 break ; \
250}
251
252/***************************************************************************\
253* EMULATION of ARM6 *
254\***************************************************************************/
255
256/* The PC pipeline value depends on whether ARM or Thumb instructions
257 are being executed: */
258ARMword isize;
259
260#ifdef MODE32
261ARMword ARMul_Emulate32(register ARMul_State *state)
262{
263#else
264ARMword ARMul_Emulate26(register ARMul_State *state)
265{
266#endif
267 register ARMword instr, /* the current instruction */
268 dest, /* almost the DestBus */
269 temp, /* ubiquitous third hand */
270 pc ; /* the address of the current instruction */
271 ARMword lhs, rhs ; /* almost the ABus and BBus */
272 ARMword decoded, loaded ; /* instruction pipeline */
273
274/***************************************************************************\
275* Execute the next instruction *
276\***************************************************************************/
277
278 if (state->NextInstr < PRIMEPIPE) {
279 decoded = state->decoded ;
280 loaded = state->loaded ;
281 pc = state->pc ;
282 }
283
284 do { /* just keep going */
285#ifdef MODET
286 if (TFLAG) {
287 isize = 2;
288 } else
289#endif
290 isize = 4;
291 switch (state->NextInstr) {
292 case SEQ :
293 state->Reg[15] += isize ; /* Advance the pipeline, and an S cycle */
294 pc += isize ;
295 instr = decoded ;
296 decoded = loaded ;
297 loaded = ARMul_LoadInstrS(state,pc+(isize * 2),isize) ;
298 break ;
299
300 case NONSEQ :
301 state->Reg[15] += isize ; /* Advance the pipeline, and an N cycle */
302 pc += isize ;
303 instr = decoded ;
304 decoded = loaded ;
305 loaded = ARMul_LoadInstrN(state,pc+(isize * 2),isize) ;
306 NORMALCYCLE ;
307 break ;
308
309 case PCINCEDSEQ :
310 pc += isize ; /* Program counter advanced, and an S cycle */
311 instr = decoded ;
312 decoded = loaded ;
313 loaded = ARMul_LoadInstrS(state,pc+(isize * 2),isize) ;
314 NORMALCYCLE ;
315 break ;
316
317 case PCINCEDNONSEQ :
318 pc += isize ; /* Program counter advanced, and an N cycle */
319 instr = decoded ;
320 decoded = loaded ;
321 loaded = ARMul_LoadInstrN(state,pc+(isize * 2),isize) ;
322 NORMALCYCLE ;
323 break ;
324
325 case RESUME : /* The program counter has been changed */
326 pc = state->Reg[15] ;
327#ifndef MODE32
328 pc = pc & R15PCBITS ;
329#endif
330 state->Reg[15] = pc + (isize * 2) ;
331 state->Aborted = 0 ;
332 instr = ARMul_ReLoadInstr(state,pc,isize) ;
333 decoded = ARMul_ReLoadInstr(state,pc + isize,isize) ;
334 loaded = ARMul_ReLoadInstr(state,pc + isize * 2,isize) ;
335 NORMALCYCLE ;
336 break ;
337
338 default : /* The program counter has been changed */
339 pc = state->Reg[15] ;
340#ifndef MODE32
341 pc = pc & R15PCBITS ;
342#endif
343 state->Reg[15] = pc + (isize * 2) ;
344 state->Aborted = 0 ;
345 instr = ARMul_LoadInstrN(state,pc,isize) ;
346 decoded = ARMul_LoadInstrS(state,pc + (isize),isize) ;
347 loaded = ARMul_LoadInstrS(state,pc + (isize * 2),isize) ;
348 NORMALCYCLE ;
349 break ;
350 }
351 if (state->EventSet)
352 ARMul_EnvokeEvent(state) ;
353
354#if 0
355 /* Enable this for a helpful bit of debugging when tracing is needed. */
356 fprintf (stderr, "pc: %x, instr: %x\n", pc & ~1, instr);
357 if (instr == 0) abort ();
358#endif
359
360 if (state->Exception) { /* Any exceptions */
361 if (state->NresetSig == LOW) {
362 ARMul_Abort(state,ARMul_ResetV) ;
363 break ;
364 }
365 else if (!state->NfiqSig && !FFLAG) {
366 ARMul_Abort(state,ARMul_FIQV) ;
367 break ;
368 }
369 else if (!state->NirqSig && !IFLAG) {
370 ARMul_Abort(state,ARMul_IRQV) ;
371 break ;
372 }
373 }
374
375 if (state->CallDebug > 0) {
376 instr = ARMul_Debug(state,pc,instr) ;
377 if (state->Emulate < ONCE) {
378 state->NextInstr = RESUME ;
379 break ;
380 }
381 if (state->Debug) {
382 fprintf(stderr,"At %08lx Instr %08lx Mode %02lx\n",pc,instr,state->Mode) ;
383 (void)fgetc(stdin) ;
384 }
385 }
386 else
387 if (state->Emulate < ONCE) {
388 state->NextInstr = RESUME ;
389 break ;
390 }
391
392 state->NumInstrs++ ;
393
394#ifdef MODET
395 /* Provide Thumb instruction decoding. If the processor is in Thumb
396 mode, then we can simply decode the Thumb instruction, and map it
397 to the corresponding ARM instruction (by directly loading the
398 instr variable, and letting the normal ARM simulator
399 execute). There are some caveats to ensure that the correct
400 pipelined PC value is used when executing Thumb code, and also for
401 dealing with the BL instruction. */
402 if (TFLAG) { /* check if in Thumb mode */
403 ARMword new;
404 switch (ARMul_ThumbDecode(state,pc,instr,&new)) {
405 case t_undefined:
406 ARMul_UndefInstr(state,instr); /* This is a Thumb instruction */
407 break;
408
409 case t_branch: /* already processed */
410 goto donext;
411
412 case t_decoded: /* ARM instruction available */
413 instr = new; /* so continue instruction decoding */
414 break;
415 }
416 }
417#endif
418
419/***************************************************************************\
420* Check the condition codes *
421\***************************************************************************/
422 if ((temp = TOPBITS(28)) == AL)
423 goto mainswitch ; /* vile deed in the need for speed */
424
425 switch ((int)TOPBITS(28)) { /* check the condition code */
426 case AL : temp=TRUE ;
427 break ;
428 case NV : temp=FALSE ;
429 break ;
430 case EQ : temp=ZFLAG ;
431 break ;
432 case NE : temp=!ZFLAG ;
433 break ;
434 case VS : temp=VFLAG ;
435 break ;
436 case VC : temp=!VFLAG ;
437 break ;
438 case MI : temp=NFLAG ;
439 break ;
440 case PL : temp=!NFLAG ;
441 break ;
442 case CS : temp=CFLAG ;
443 break ;
444 case CC : temp=!CFLAG ;
445 break ;
446 case HI : temp=(CFLAG && !ZFLAG) ;
447 break ;
448 case LS : temp=(!CFLAG || ZFLAG) ;
449 break ;
450 case GE : temp=((!NFLAG && !VFLAG) || (NFLAG && VFLAG)) ;
451 break ;
452 case LT : temp=((NFLAG && !VFLAG) || (!NFLAG && VFLAG)) ;
453 break ;
454 case GT : temp=((!NFLAG && !VFLAG && !ZFLAG) || (NFLAG && VFLAG && !ZFLAG)) ;
455 break ;
456 case LE : temp=((NFLAG && !VFLAG) || (!NFLAG && VFLAG)) || ZFLAG ;
457 break ;
458 } /* cc check */
459
460/***************************************************************************\
461* Actual execution of instructions begins here *
462\***************************************************************************/
463
464 if (temp) { /* if the condition codes don't match, stop here */
465mainswitch:
466
467 switch ((int)BITS(20,27)) {
468
469/***************************************************************************\
470* Data Processing Register RHS Instructions *
471\***************************************************************************/
472
473 case 0x00 : /* AND reg and MUL */
474#ifdef MODET
475 if (BITS(4,11) == 0xB) {
476 /* STRH register offset, no write-back, down, post indexed */
477 SHDOWNWB() ;
478 break ;
479 }
480 /* TODO: CHECK: should 0xD and 0xF generate undefined intruction aborts? */
481#endif
482 if (BITS(4,7) == 9) { /* MUL */
483 rhs = state->Reg[MULRHSReg] ;
484 if (MULLHSReg == MULDESTReg) {
485 UNDEF_MULDestEQOp1 ;
486 state->Reg[MULDESTReg] = 0 ;
487 }
488 else if (MULDESTReg != 15)
489 state->Reg[MULDESTReg] = state->Reg[MULLHSReg] * rhs ;
490 else {
491 UNDEF_MULPCDest ;
492 }
493 for (dest = 0, temp = 0 ; dest < 32 ; dest++)
494 if (rhs & (1L << dest))
495 temp = dest ; /* mult takes this many/2 I cycles */
496 ARMul_Icycles(state,ARMul_MultTable[temp],0L) ;
497 }
498 else { /* AND reg */
499 rhs = DPRegRHS ;
500 dest = LHS & rhs ;
501 WRITEDEST(dest) ;
502 }
503 break ;
504
505 case 0x01 : /* ANDS reg and MULS */
506#ifdef MODET
507 if ((BITS(4,11) & 0xF9) == 0x9) {
508 /* LDR register offset, no write-back, down, post indexed */
509 LHPOSTDOWN() ;
510 /* fall through to rest of decoding */
511 }
512#endif
513 if (BITS(4,7) == 9) { /* MULS */
514 rhs = state->Reg[MULRHSReg] ;
515 if (MULLHSReg == MULDESTReg) {
516 UNDEF_MULDestEQOp1 ;
517 state->Reg[MULDESTReg] = 0 ;
518 CLEARN ;
519 SETZ ;
520 }
521 else if (MULDESTReg != 15) {
522 dest = state->Reg[MULLHSReg] * rhs ;
523 ARMul_NegZero(state,dest) ;
524 state->Reg[MULDESTReg] = dest ;
525 }
526 else {
527 UNDEF_MULPCDest ;
528 }
529 for (dest = 0, temp = 0 ; dest < 32 ; dest++)
530 if (rhs & (1L << dest))
531 temp = dest ; /* mult takes this many/2 I cycles */
532 ARMul_Icycles(state,ARMul_MultTable[temp],0L) ;
533 }
534 else { /* ANDS reg */
535 rhs = DPSRegRHS ;
536 dest = LHS & rhs ;
537 WRITESDEST(dest) ;
538 }
539 break ;
540
541 case 0x02 : /* EOR reg and MLA */
542#ifdef MODET
543 if (BITS(4,11) == 0xB) {
544 /* STRH register offset, write-back, down, post indexed */
545 SHDOWNWB() ;
546 break ;
547 }
548#endif
549 if (BITS(4,7) == 9) { /* MLA */
550 rhs = state->Reg[MULRHSReg] ;
551 if (MULLHSReg == MULDESTReg) {
552 UNDEF_MULDestEQOp1 ;
553 state->Reg[MULDESTReg] = state->Reg[MULACCReg] ;
554 }
555 else if (MULDESTReg != 15)
556 state->Reg[MULDESTReg] = state->Reg[MULLHSReg] * rhs + state->Reg[MULACCReg] ;
557 else {
558 UNDEF_MULPCDest ;
559 }
560 for (dest = 0, temp = 0 ; dest < 32 ; dest++)
561 if (rhs & (1L << dest))
562 temp = dest ; /* mult takes this many/2 I cycles */
563 ARMul_Icycles(state,ARMul_MultTable[temp],0L) ;
564 }
565 else {
566 rhs = DPRegRHS ;
567 dest = LHS ^ rhs ;
568 WRITEDEST(dest) ;
569 }
570 break ;
571
572 case 0x03 : /* EORS reg and MLAS */
573#ifdef MODET
574 if ((BITS(4,11) & 0xF9) == 0x9) {
575 /* LDR register offset, write-back, down, post-indexed */
576 LHPOSTDOWN() ;
577 /* fall through to rest of the decoding */
578 }
579#endif
580 if (BITS(4,7) == 9) { /* MLAS */
581 rhs = state->Reg[MULRHSReg] ;
582 if (MULLHSReg == MULDESTReg) {
583 UNDEF_MULDestEQOp1 ;
584 dest = state->Reg[MULACCReg] ;
585 ARMul_NegZero(state,dest) ;
586 state->Reg[MULDESTReg] = dest ;
587 }
588 else if (MULDESTReg != 15) {
589 dest = state->Reg[MULLHSReg] * rhs + state->Reg[MULACCReg] ;
590 ARMul_NegZero(state,dest) ;
591 state->Reg[MULDESTReg] = dest ;
592 }
593 else {
594 UNDEF_MULPCDest ;
595 }
596 for (dest = 0, temp = 0 ; dest < 32 ; dest++)
597 if (rhs & (1L << dest))
598 temp = dest ; /* mult takes this many/2 I cycles */
599 ARMul_Icycles(state,ARMul_MultTable[temp],0L) ;
600 }
601 else { /* EORS Reg */
602 rhs = DPSRegRHS ;
603 dest = LHS ^ rhs ;
604 WRITESDEST(dest) ;
605 }
606 break ;
607
608 case 0x04 : /* SUB reg */
609#ifdef MODET
610 if (BITS(4,7) == 0xB) {
611 /* STRH immediate offset, no write-back, down, post indexed */
612 SHDOWNWB() ;
613 break ;
614 }
615#endif
616 rhs = DPRegRHS;
617 dest = LHS - rhs ;
618 WRITEDEST(dest) ;
619 break ;
620
621 case 0x05 : /* SUBS reg */
622#ifdef MODET
623 if ((BITS(4,7) & 0x9) == 0x9) {
624 /* LDR immediate offset, no write-back, down, post indexed */
625 LHPOSTDOWN() ;
626 /* fall through to the rest of the instruction decoding */
627 }
628#endif
629 lhs = LHS ;
630 rhs = DPRegRHS ;
631 dest = lhs - rhs ;
632 if ((lhs >= rhs) || ((rhs | lhs) >> 31)) {
633 ARMul_SubCarry(state,lhs,rhs,dest) ;
634 ARMul_SubOverflow(state,lhs,rhs,dest) ;
635 }
636 else {
637 CLEARC ;
638 CLEARV ;
639 }
640 WRITESDEST(dest) ;
641 break ;
642
643 case 0x06 : /* RSB reg */
644#ifdef MODET
645 if (BITS(4,7) == 0xB) {
646 /* STRH immediate offset, write-back, down, post indexed */
647 SHDOWNWB() ;
648 break ;
649 }
650#endif
651 rhs = DPRegRHS ;
652 dest = rhs - LHS ;
653 WRITEDEST(dest) ;
654 break ;
655
656 case 0x07 : /* RSBS reg */
657#ifdef MODET
658 if ((BITS(4,7) & 0x9) == 0x9) {
659 /* LDR immediate offset, write-back, down, post indexed */
660 LHPOSTDOWN() ;
661 /* fall through to remainder of instruction decoding */
662 }
663#endif
664 lhs = LHS ;
665 rhs = DPRegRHS ;
666 dest = rhs - lhs ;
667 if ((rhs >= lhs) || ((rhs | lhs) >> 31)) {
668 ARMul_SubCarry(state,rhs,lhs,dest) ;
669 ARMul_SubOverflow(state,rhs,lhs,dest) ;
670 }
671 else {
672 CLEARC ;
673 CLEARV ;
674 }
675 WRITESDEST(dest) ;
676 break ;
677
678 case 0x08 : /* ADD reg */
679#ifdef MODET
680 if (BITS(4,11) == 0xB) {
681 /* STRH register offset, no write-back, up, post indexed */
682 SHUPWB() ;
683 break ;
684 }
685#endif
686#ifdef MODET
687 if (BITS(4,7) == 0x9) { /* MULL */
688 /* 32x32 = 64 */
689 ARMul_Icycles(state,Multiply64(state,instr,LUNSIGNED,LDEFAULT),0L) ;
690 break ;
691 }
692#endif
693 rhs = DPRegRHS ;
694 dest = LHS + rhs ;
695 WRITEDEST(dest) ;
696 break ;
697
698 case 0x09 : /* ADDS reg */
699#ifdef MODET
700 if ((BITS(4,11) & 0xF9) == 0x9) {
701 /* LDR register offset, no write-back, up, post indexed */
702 LHPOSTUP() ;
703 /* fall through to remaining instruction decoding */
704 }
705#endif
706#ifdef MODET
707 if (BITS(4,7) == 0x9) { /* MULL */
708 /* 32x32=64 */
709 ARMul_Icycles(state,Multiply64(state,instr,LUNSIGNED,LSCC),0L) ;
710 break ;
711 }
712#endif
713 lhs = LHS ;
714 rhs = DPRegRHS ;
715 dest = lhs + rhs ;
716 ASSIGNZ(dest==0) ;
717 if ((lhs | rhs) >> 30) { /* possible C,V,N to set */
718 ASSIGNN(NEG(dest)) ;
719 ARMul_AddCarry(state,lhs,rhs,dest) ;
720 ARMul_AddOverflow(state,lhs,rhs,dest) ;
721 }
722 else {
723 CLEARN ;
724 CLEARC ;
725 CLEARV ;
726 }
727 WRITESDEST(dest) ;
728 break ;
729
730 case 0x0a : /* ADC reg */
731#ifdef MODET
732 if (BITS(4,11) == 0xB) {
733 /* STRH register offset, write-back, up, post-indexed */
734 SHUPWB() ;
735 break ;
736 }
737#endif
738#ifdef MODET
739 if (BITS(4,7) == 0x9) { /* MULL */
740 /* 32x32=64 */
741 ARMul_Icycles(state,MultiplyAdd64(state,instr,LUNSIGNED,LDEFAULT),0L) ;
742 break ;
743 }
744#endif
745 rhs = DPRegRHS ;
746 dest = LHS + rhs + CFLAG ;
747 WRITEDEST(dest) ;
748 break ;
749
750 case 0x0b : /* ADCS reg */
751#ifdef MODET
752 if ((BITS(4,11) & 0xF9) == 0x9) {
753 /* LDR register offset, write-back, up, post indexed */
754 LHPOSTUP() ;
755 /* fall through to remaining instruction decoding */
756 }
757#endif
758#ifdef MODET
759 if (BITS(4,7) == 0x9) { /* MULL */
760 /* 32x32=64 */
761 ARMul_Icycles(state,MultiplyAdd64(state,instr,LUNSIGNED,LSCC),0L) ;
762 break ;
763 }
764#endif
765 lhs = LHS ;
766 rhs = DPRegRHS ;
767 dest = lhs + rhs + CFLAG ;
768 ASSIGNZ(dest==0) ;
769 if ((lhs | rhs) >> 30) { /* possible C,V,N to set */
770 ASSIGNN(NEG(dest)) ;
771 ARMul_AddCarry(state,lhs,rhs,dest) ;
772 ARMul_AddOverflow(state,lhs,rhs,dest) ;
773 }
774 else {
775 CLEARN ;
776 CLEARC ;
777 CLEARV ;
778 }
779 WRITESDEST(dest) ;
780 break ;
781
782 case 0x0c : /* SBC reg */
783#ifdef MODET
784 if (BITS(4,7) == 0xB) {
785 /* STRH immediate offset, no write-back, up post indexed */
786 SHUPWB() ;
787 break ;
788 }
789#endif
790#ifdef MODET
791 if (BITS(4,7) == 0x9) { /* MULL */
792 /* 32x32=64 */
793 ARMul_Icycles(state,Multiply64(state,instr,LSIGNED,LDEFAULT),0L) ;
794 break ;
795 }
796#endif
797 rhs = DPRegRHS ;
798 dest = LHS - rhs - !CFLAG ;
799 WRITEDEST(dest) ;
800 break ;
801
802 case 0x0d : /* SBCS reg */
803#ifdef MODET
804 if ((BITS(4,7) & 0x9) == 0x9) {
805 /* LDR immediate offset, no write-back, up, post indexed */
806 LHPOSTUP() ;
807 }
808#endif
809#ifdef MODET
810 if (BITS(4,7) == 0x9) { /* MULL */
811 /* 32x32=64 */
812 ARMul_Icycles(state,Multiply64(state,instr,LSIGNED,LSCC),0L) ;
813 break ;
814 }
815#endif
816 lhs = LHS ;
817 rhs = DPRegRHS ;
818 dest = lhs - rhs - !CFLAG ;
819 if ((lhs >= rhs) || ((rhs | lhs) >> 31)) {
820 ARMul_SubCarry(state,lhs,rhs,dest) ;
821 ARMul_SubOverflow(state,lhs,rhs,dest) ;
822 }
823 else {
824 CLEARC ;
825 CLEARV ;
826 }
827 WRITESDEST(dest) ;
828 break ;
829
830 case 0x0e : /* RSC reg */
831#ifdef MODET
832 if (BITS(4,7) == 0xB) {
833 /* STRH immediate offset, write-back, up, post indexed */
834 SHUPWB() ;
835 break ;
836 }
837#endif
838#ifdef MODET
839 if (BITS(4,7) == 0x9) { /* MULL */
840 /* 32x32=64 */
841 ARMul_Icycles(state,MultiplyAdd64(state,instr,LSIGNED,LDEFAULT),0L) ;
842 break ;
843 }
844#endif
845 rhs = DPRegRHS ;
846 dest = rhs - LHS - !CFLAG ;
847 WRITEDEST(dest) ;
848 break ;
849
850 case 0x0f : /* RSCS reg */
851#ifdef MODET
852 if ((BITS(4,7) & 0x9) == 0x9) {
853 /* LDR immediate offset, write-back, up, post indexed */
854 LHPOSTUP() ;
855 /* fall through to remaining instruction decoding */
856 }
857#endif
858#ifdef MODET
859 if (BITS(4,7) == 0x9) { /* MULL */
860 /* 32x32=64 */
861 ARMul_Icycles(state,MultiplyAdd64(state,instr,LSIGNED,LSCC),0L) ;
862 break ;
863 }
864#endif
865 lhs = LHS ;
866 rhs = DPRegRHS ;
867 dest = rhs - lhs - !CFLAG ;
868 if ((rhs >= lhs) || ((rhs | lhs) >> 31)) {
869 ARMul_SubCarry(state,rhs,lhs,dest) ;
870 ARMul_SubOverflow(state,rhs,lhs,dest) ;
871 }
872 else {
873 CLEARC ;
874 CLEARV ;
875 }
876 WRITESDEST(dest) ;
877 break ;
878
879 case 0x10 : /* TST reg and MRS CPSR and SWP word */
880#ifdef MODET
881 if (BITS(4,11) == 0xB) {
882 /* STRH register offset, no write-back, down, pre indexed */
883 SHPREDOWN() ;
884 break ;
885 }
886#endif
887 if (BITS(4,11) == 9) { /* SWP */
888 UNDEF_SWPPC ;
889 temp = LHS ;
890 BUSUSEDINCPCS ;
891#ifndef MODE32
892 if (VECTORACCESS(temp) || ADDREXCEPT(temp)) {
893 INTERNALABORT(temp) ;
894 (void)ARMul_LoadWordN(state,temp) ;
895 (void)ARMul_LoadWordN(state,temp) ;
896 }
897 else
898#endif
899 dest = ARMul_SwapWord(state,temp,state->Reg[RHSReg]) ;
900 if (temp & 3)
901 DEST = ARMul_Align(state,temp,dest) ;
902 else
903 DEST = dest ;
904 if (state->abortSig || state->Aborted) {
905 TAKEABORT ;
906 }
907 }
908 else if ((BITS(0,11)==0) && (LHSReg==15)) { /* MRS CPSR */
909 UNDEF_MRSPC ;
910 DEST = ECC | EINT | EMODE ;
911 }
912 else {
913 UNDEF_Test ;
914 }
915 break ;
916
917 case 0x11 : /* TSTP reg */
918#ifdef MODET
919 if ((BITS(4,11) & 0xF9) == 0x9) {
920 /* LDR register offset, no write-back, down, pre indexed */
921 LHPREDOWN() ;
922 /* continue with remaining instruction decode */
923 }
924#endif
925 if (DESTReg == 15) { /* TSTP reg */
926#ifdef MODE32
927 state->Cpsr = GETSPSR(state->Bank) ;
928 ARMul_CPSRAltered(state) ;
929#else
930 rhs = DPRegRHS ;
931 temp = LHS & rhs ;
932 SETR15PSR(temp) ;
933#endif
934 }
935 else { /* TST reg */
936 rhs = DPSRegRHS ;
937 dest = LHS & rhs ;
938 ARMul_NegZero(state,dest) ;
939 }
940 break ;
941
942 case 0x12 : /* TEQ reg and MSR reg to CPSR (ARM6) */
943#ifdef MODET
944 if (BITS(4,11) == 0xB) {
945 /* STRH register offset, write-back, down, pre indexed */
946 SHPREDOWNWB() ;
947 break ;
948 }
949#endif
950#ifdef MODET
951 if (BITS(4,27)==0x12FFF1) { /* BX */
952 /* Branch to the address in RHSReg. If bit0 of
953 destination address is 1 then switch to Thumb mode: */
954 ARMword addr = state->Reg[RHSReg];
955
956 /* If we read the PC then the bottom bit is clear */
957 if (RHSReg == 15) addr &= ~1;
958
959 /* Enable this for a helpful bit of debugging when
960 GDB is not yet fully working...
961 fprintf (stderr, "BX at %x to %x (go %s)\n",
962 state->Reg[15], addr, (addr & 1) ? "thumb": "arm" ); */
963
964 if (addr & (1 << 0)) { /* Thumb bit */
965 SETT;
966 state->Reg[15] = addr & 0xfffffffe;
967 /* NOTE: The other CPSR flag setting blocks do not
968 seem to update the state->Cpsr state, but just do
969 the explicit flag. The copy from the seperate
970 flags to the register must happen later. */
971 FLUSHPIPE;
972 } else {
973 CLEART;
974 state->Reg[15] = addr & 0xfffffffc;
975 FLUSHPIPE;
976 }
977 }
978#endif
979 if (DESTReg==15 && BITS(17,18)==0) { /* MSR reg to CPSR */
980 UNDEF_MSRPC ;
981 temp = DPRegRHS ;
982 ARMul_FixCPSR(state,instr,temp) ;
983 }
984 else {
985 UNDEF_Test ;
986 }
987 break ;
988
989 case 0x13 : /* TEQP reg */
990#ifdef MODET
991 if ((BITS(4,11) & 0xF9) == 0x9) {
992 /* LDR register offset, write-back, down, pre indexed */
993 LHPREDOWNWB() ;
994 /* continue with remaining instruction decode */
995 }
996#endif
997 if (DESTReg == 15) { /* TEQP reg */
998#ifdef MODE32
999 state->Cpsr = GETSPSR(state->Bank) ;
1000 ARMul_CPSRAltered(state) ;
1001#else
1002 rhs = DPRegRHS ;
1003 temp = LHS ^ rhs ;
1004 SETR15PSR(temp) ;
1005#endif
1006 }
1007 else { /* TEQ Reg */
1008 rhs = DPSRegRHS ;
1009 dest = LHS ^ rhs ;
1010 ARMul_NegZero(state,dest) ;
1011 }
1012 break ;
1013
1014 case 0x14 : /* CMP reg and MRS SPSR and SWP byte */
1015#ifdef MODET
1016 if (BITS(4,7) == 0xB) {
1017 /* STRH immediate offset, no write-back, down, pre indexed */
1018 SHPREDOWN() ;
1019 break ;
1020 }
1021#endif
1022 if (BITS(4,11) == 9) { /* SWP */
1023 UNDEF_SWPPC ;
1024 temp = LHS ;
1025 BUSUSEDINCPCS ;
1026#ifndef MODE32
1027 if (VECTORACCESS(temp) || ADDREXCEPT(temp)) {
1028 INTERNALABORT(temp) ;
1029 (void)ARMul_LoadByte(state,temp) ;
1030 (void)ARMul_LoadByte(state,temp) ;
1031 }
1032 else
1033#endif
1034 DEST = ARMul_SwapByte(state,temp,state->Reg[RHSReg]) ;
1035 if (state->abortSig || state->Aborted) {
1036 TAKEABORT ;
1037 }
1038 }
1039 else if ((BITS(0,11)==0) && (LHSReg==15)) { /* MRS SPSR */
1040 UNDEF_MRSPC ;
1041 DEST = GETSPSR(state->Bank) ;
1042 }
1043 else {
1044 UNDEF_Test ;
1045 }
1046 break ;
1047
1048 case 0x15 : /* CMPP reg */
1049#ifdef MODET
1050 if ((BITS(4,7) & 0x9) == 0x9) {
1051 /* LDR immediate offset, no write-back, down, pre indexed */
1052 LHPREDOWN() ;
1053 /* continue with remaining instruction decode */
1054 }
1055#endif
1056 if (DESTReg == 15) { /* CMPP reg */
1057#ifdef MODE32
1058 state->Cpsr = GETSPSR(state->Bank) ;
1059 ARMul_CPSRAltered(state) ;
1060#else
1061 rhs = DPRegRHS ;
1062 temp = LHS - rhs ;
1063 SETR15PSR(temp) ;
1064#endif
1065 }
1066 else { /* CMP reg */
1067 lhs = LHS ;
1068 rhs = DPRegRHS ;
1069 dest = lhs - rhs ;
1070 ARMul_NegZero(state,dest) ;
1071 if ((lhs >= rhs) || ((rhs | lhs) >> 31)) {
1072 ARMul_SubCarry(state,lhs,rhs,dest) ;
1073 ARMul_SubOverflow(state,lhs,rhs,dest) ;
1074 }
1075 else {
1076 CLEARC ;
1077 CLEARV ;
1078 }
1079 }
1080 break ;
1081
1082 case 0x16 : /* CMN reg and MSR reg to SPSR */
1083#ifdef MODET
1084 if (BITS(4,7) == 0xB) {
1085 /* STRH immediate offset, write-back, down, pre indexed */
1086 SHPREDOWNWB() ;
1087 break ;
1088 }
1089#endif
1090 if (DESTReg==15 && BITS(17,18)==0) { /* MSR */
1091 UNDEF_MSRPC ;
1092 ARMul_FixSPSR(state,instr,DPRegRHS);
1093 }
1094 else {
1095 UNDEF_Test ;
1096 }
1097 break ;
1098
1099 case 0x17 : /* CMNP reg */
1100#ifdef MODET
1101 if ((BITS(4,7) & 0x9) == 0x9) {
1102 /* LDR immediate offset, write-back, down, pre indexed */
1103 LHPREDOWNWB() ;
1104 /* continue with remaining instruction decoding */
1105 }
1106#endif
1107 if (DESTReg == 15) {
1108#ifdef MODE32
1109 state->Cpsr = GETSPSR(state->Bank) ;
1110 ARMul_CPSRAltered(state) ;
1111#else
1112 rhs = DPRegRHS ;
1113 temp = LHS + rhs ;
1114 SETR15PSR(temp) ;
1115#endif
1116 break ;
1117 }
1118 else { /* CMN reg */
1119 lhs = LHS ;
1120 rhs = DPRegRHS ;
1121 dest = lhs + rhs ;
1122 ASSIGNZ(dest==0) ;
1123 if ((lhs | rhs) >> 30) { /* possible C,V,N to set */
1124 ASSIGNN(NEG(dest)) ;
1125 ARMul_AddCarry(state,lhs,rhs,dest) ;
1126 ARMul_AddOverflow(state,lhs,rhs,dest) ;
1127 }
1128 else {
1129 CLEARN ;
1130 CLEARC ;
1131 CLEARV ;
1132 }
1133 }
1134 break ;
1135
1136 case 0x18 : /* ORR reg */
1137#ifdef MODET
1138 if (BITS(4,11) == 0xB) {
1139 /* STRH register offset, no write-back, up, pre indexed */
1140 SHPREUP() ;
1141 break ;
1142 }
1143#endif
1144 rhs = DPRegRHS ;
1145 dest = LHS | rhs ;
1146 WRITEDEST(dest) ;
1147 break ;
1148
1149 case 0x19 : /* ORRS reg */
1150#ifdef MODET
1151 if ((BITS(4,11) & 0xF9) == 0x9) {
1152 /* LDR register offset, no write-back, up, pre indexed */
1153 LHPREUP() ;
1154 /* continue with remaining instruction decoding */
1155 }
1156#endif
1157 rhs = DPSRegRHS ;
1158 dest = LHS | rhs ;
1159 WRITESDEST(dest) ;
1160 break ;
1161
1162 case 0x1a : /* MOV reg */
1163#ifdef MODET
1164 if (BITS(4,11) == 0xB) {
1165 /* STRH register offset, write-back, up, pre indexed */
1166 SHPREUPWB() ;
1167 break ;
1168 }
1169#endif
1170 dest = DPRegRHS ;
1171 WRITEDEST(dest) ;
1172 break ;
1173
1174 case 0x1b : /* MOVS reg */
1175#ifdef MODET
1176 if ((BITS(4,11) & 0xF9) == 0x9) {
1177 /* LDR register offset, write-back, up, pre indexed */
1178 LHPREUPWB() ;
1179 /* continue with remaining instruction decoding */
1180 }
1181#endif
1182 dest = DPSRegRHS ;
1183 WRITESDEST(dest) ;
1184 break ;
1185
1186 case 0x1c : /* BIC reg */
1187#ifdef MODET
1188 if (BITS(4,7) == 0xB) {
1189 /* STRH immediate offset, no write-back, up, pre indexed */
1190 SHPREUP() ;
1191 break ;
1192 }
1193#endif
1194 rhs = DPRegRHS ;
1195 dest = LHS & ~rhs ;
1196 WRITEDEST(dest) ;
1197 break ;
1198
1199 case 0x1d : /* BICS reg */
1200#ifdef MODET
1201 if ((BITS(4,7) & 0x9) == 0x9) {
1202 /* LDR immediate offset, no write-back, up, pre indexed */
1203 LHPREUP() ;
1204 /* continue with instruction decoding */
1205 }
1206#endif
1207 rhs = DPSRegRHS ;
1208 dest = LHS & ~rhs ;
1209 WRITESDEST(dest) ;
1210 break ;
1211
1212 case 0x1e : /* MVN reg */
1213#ifdef MODET
1214 if (BITS(4,7) == 0xB) {
1215 /* STRH immediate offset, write-back, up, pre indexed */
1216 SHPREUPWB() ;
1217 break ;
1218 }
1219#endif
1220 dest = ~DPRegRHS ;
1221 WRITEDEST(dest) ;
1222 break ;
1223
1224 case 0x1f : /* MVNS reg */
1225#ifdef MODET
1226 if ((BITS(4,7) & 0x9) == 0x9) {
1227 /* LDR immediate offset, write-back, up, pre indexed */
1228 LHPREUPWB() ;
1229 /* continue instruction decoding */
1230 }
1231#endif
1232 dest = ~DPSRegRHS ;
1233 WRITESDEST(dest) ;
1234 break ;
1235
1236/***************************************************************************\
1237* Data Processing Immediate RHS Instructions *
1238\***************************************************************************/
1239
1240 case 0x20 : /* AND immed */
1241 dest = LHS & DPImmRHS ;
1242 WRITEDEST(dest) ;
1243 break ;
1244
1245 case 0x21 : /* ANDS immed */
1246 DPSImmRHS ;
1247 dest = LHS & rhs ;
1248 WRITESDEST(dest) ;
1249 break ;
1250
1251 case 0x22 : /* EOR immed */
1252 dest = LHS ^ DPImmRHS ;
1253 WRITEDEST(dest) ;
1254 break ;
1255
1256 case 0x23 : /* EORS immed */
1257 DPSImmRHS ;
1258 dest = LHS ^ rhs ;
1259 WRITESDEST(dest) ;
1260 break ;
1261
1262 case 0x24 : /* SUB immed */
1263 dest = LHS - DPImmRHS ;
1264 WRITEDEST(dest) ;
1265 break ;
1266
1267 case 0x25 : /* SUBS immed */
1268 lhs = LHS ;
1269 rhs = DPImmRHS ;
1270 dest = lhs - rhs ;
1271 if ((lhs >= rhs) || ((rhs | lhs) >> 31)) {
1272 ARMul_SubCarry(state,lhs,rhs,dest) ;
1273 ARMul_SubOverflow(state,lhs,rhs,dest) ;
1274 }
1275 else {
1276 CLEARC ;
1277 CLEARV ;
1278 }
1279 WRITESDEST(dest) ;
1280 break ;
1281
1282 case 0x26 : /* RSB immed */
1283 dest = DPImmRHS - LHS ;
1284 WRITEDEST(dest) ;
1285 break ;
1286
1287 case 0x27 : /* RSBS immed */
1288 lhs = LHS ;
1289 rhs = DPImmRHS ;
1290 dest = rhs - lhs ;
1291 if ((rhs >= lhs) || ((rhs | lhs) >> 31)) {
1292 ARMul_SubCarry(state,rhs,lhs,dest) ;
1293 ARMul_SubOverflow(state,rhs,lhs,dest) ;
1294 }
1295 else {
1296 CLEARC ;
1297 CLEARV ;
1298 }
1299 WRITESDEST(dest) ;
1300 break ;
1301
1302 case 0x28 : /* ADD immed */
1303 dest = LHS + DPImmRHS ;
1304 WRITEDEST(dest) ;
1305 break ;
1306
1307 case 0x29 : /* ADDS immed */
1308 lhs = LHS ;
1309 rhs = DPImmRHS ;
1310 dest = lhs + rhs ;
1311 ASSIGNZ(dest==0) ;
1312 if ((lhs | rhs) >> 30) { /* possible C,V,N to set */
1313 ASSIGNN(NEG(dest)) ;
1314 ARMul_AddCarry(state,lhs,rhs,dest) ;
1315 ARMul_AddOverflow(state,lhs,rhs,dest) ;
1316 }
1317 else {
1318 CLEARN ;
1319 CLEARC ;
1320 CLEARV ;
1321 }
1322 WRITESDEST(dest) ;
1323 break ;
1324
1325 case 0x2a : /* ADC immed */
1326 dest = LHS + DPImmRHS + CFLAG ;
1327 WRITEDEST(dest) ;
1328 break ;
1329
1330 case 0x2b : /* ADCS immed */
1331 lhs = LHS ;
1332 rhs = DPImmRHS ;
1333 dest = lhs + rhs + CFLAG ;
1334 ASSIGNZ(dest==0) ;
1335 if ((lhs | rhs) >> 30) { /* possible C,V,N to set */
1336 ASSIGNN(NEG(dest)) ;
1337 ARMul_AddCarry(state,lhs,rhs,dest) ;
1338 ARMul_AddOverflow(state,lhs,rhs,dest) ;
1339 }
1340 else {
1341 CLEARN ;
1342 CLEARC ;
1343 CLEARV ;
1344 }
1345 WRITESDEST(dest) ;
1346 break ;
1347
1348 case 0x2c : /* SBC immed */
1349 dest = LHS - DPImmRHS - !CFLAG ;
1350 WRITEDEST(dest) ;
1351 break ;
1352
1353 case 0x2d : /* SBCS immed */
1354 lhs = LHS ;
1355 rhs = DPImmRHS ;
1356 dest = lhs - rhs - !CFLAG ;
1357 if ((lhs >= rhs) || ((rhs | lhs) >> 31)) {
1358 ARMul_SubCarry(state,lhs,rhs,dest) ;
1359 ARMul_SubOverflow(state,lhs,rhs,dest) ;
1360 }
1361 else {
1362 CLEARC ;
1363 CLEARV ;
1364 }
1365 WRITESDEST(dest) ;
1366 break ;
1367
1368 case 0x2e : /* RSC immed */
1369 dest = DPImmRHS - LHS - !CFLAG ;
1370 WRITEDEST(dest) ;
1371 break ;
1372
1373 case 0x2f : /* RSCS immed */
1374 lhs = LHS ;
1375 rhs = DPImmRHS ;
1376 dest = rhs - lhs - !CFLAG ;
1377 if ((rhs >= lhs) || ((rhs | lhs) >> 31)) {
1378 ARMul_SubCarry(state,rhs,lhs,dest) ;
1379 ARMul_SubOverflow(state,rhs,lhs,dest) ;
1380 }
1381 else {
1382 CLEARC ;
1383 CLEARV ;
1384 }
1385 WRITESDEST(dest) ;
1386 break ;
1387
1388 case 0x30 : /* TST immed */
1389 UNDEF_Test ;
1390 break ;
1391
1392 case 0x31 : /* TSTP immed */
1393 if (DESTReg == 15) { /* TSTP immed */
1394#ifdef MODE32
1395 state->Cpsr = GETSPSR(state->Bank) ;
1396 ARMul_CPSRAltered(state) ;
1397#else
1398 temp = LHS & DPImmRHS ;
1399 SETR15PSR(temp) ;
1400#endif
1401 }
1402 else {
1403 DPSImmRHS ; /* TST immed */
1404 dest = LHS & rhs ;
1405 ARMul_NegZero(state,dest) ;
1406 }
1407 break ;
1408
1409 case 0x32 : /* TEQ immed and MSR immed to CPSR */
1410 if (DESTReg==15 && BITS(17,18)==0) { /* MSR immed to CPSR */
1411 ARMul_FixCPSR(state,instr,DPImmRHS) ;
1412 }
1413 else {
1414 UNDEF_Test ;
1415 }
1416 break ;
1417
1418 case 0x33 : /* TEQP immed */
1419 if (DESTReg == 15) { /* TEQP immed */
1420#ifdef MODE32
1421 state->Cpsr = GETSPSR(state->Bank) ;
1422 ARMul_CPSRAltered(state) ;
1423#else
1424 temp = LHS ^ DPImmRHS ;
1425 SETR15PSR(temp) ;
1426#endif
1427 }
1428 else {
1429 DPSImmRHS ; /* TEQ immed */
1430 dest = LHS ^ rhs ;
1431 ARMul_NegZero(state,dest) ;
1432 }
1433 break ;
1434
1435 case 0x34 : /* CMP immed */
1436 UNDEF_Test ;
1437 break ;
1438
1439 case 0x35 : /* CMPP immed */
1440 if (DESTReg == 15) { /* CMPP immed */
1441#ifdef MODE32
1442 state->Cpsr = GETSPSR(state->Bank) ;
1443 ARMul_CPSRAltered(state) ;
1444#else
1445 temp = LHS - DPImmRHS ;
1446 SETR15PSR(temp) ;
1447#endif
1448 break ;
1449 }
1450 else {
1451 lhs = LHS ; /* CMP immed */
1452 rhs = DPImmRHS ;
1453 dest = lhs - rhs ;
1454 ARMul_NegZero(state,dest) ;
1455 if ((lhs >= rhs) || ((rhs | lhs) >> 31)) {
1456 ARMul_SubCarry(state,lhs,rhs,dest) ;
1457 ARMul_SubOverflow(state,lhs,rhs,dest) ;
1458 }
1459 else {
1460 CLEARC ;
1461 CLEARV ;
1462 }
1463 }
1464 break ;
1465
1466 case 0x36 : /* CMN immed and MSR immed to SPSR */
1467 if (DESTReg==15 && BITS(17,18)==0) /* MSR */
1468 ARMul_FixSPSR(state, instr, DPImmRHS) ;
1469 else {
1470 UNDEF_Test ;
1471 }
1472 break ;
1473
1474 case 0x37 : /* CMNP immed */
1475 if (DESTReg == 15) { /* CMNP immed */
1476#ifdef MODE32
1477 state->Cpsr = GETSPSR(state->Bank) ;
1478 ARMul_CPSRAltered(state) ;
1479#else
1480 temp = LHS + DPImmRHS ;
1481 SETR15PSR(temp) ;
1482#endif
1483 break ;
1484 }
1485 else {
1486 lhs = LHS ; /* CMN immed */
1487 rhs = DPImmRHS ;
1488 dest = lhs + rhs ;
1489 ASSIGNZ(dest==0) ;
1490 if ((lhs | rhs) >> 30) { /* possible C,V,N to set */
1491 ASSIGNN(NEG(dest)) ;
1492 ARMul_AddCarry(state,lhs,rhs,dest) ;
1493 ARMul_AddOverflow(state,lhs,rhs,dest) ;
1494 }
1495 else {
1496 CLEARN ;
1497 CLEARC ;
1498 CLEARV ;
1499 }
1500 }
1501 break ;
1502
1503 case 0x38 : /* ORR immed */
1504 dest = LHS | DPImmRHS ;
1505 WRITEDEST(dest) ;
1506 break ;
1507
1508 case 0x39 : /* ORRS immed */
1509 DPSImmRHS ;
1510 dest = LHS | rhs ;
1511 WRITESDEST(dest) ;
1512 break ;
1513
1514 case 0x3a : /* MOV immed */
1515 dest = DPImmRHS ;
1516 WRITEDEST(dest) ;
1517 break ;
1518
1519 case 0x3b : /* MOVS immed */
1520 DPSImmRHS ;
1521 WRITESDEST(rhs) ;
1522 break ;
1523
1524 case 0x3c : /* BIC immed */
1525 dest = LHS & ~DPImmRHS ;
1526 WRITEDEST(dest) ;
1527 break ;
1528
1529 case 0x3d : /* BICS immed */
1530 DPSImmRHS ;
1531 dest = LHS & ~rhs ;
1532 WRITESDEST(dest) ;
1533 break ;
1534
1535 case 0x3e : /* MVN immed */
1536 dest = ~DPImmRHS ;
1537 WRITEDEST(dest) ;
1538 break ;
1539
1540 case 0x3f : /* MVNS immed */
1541 DPSImmRHS ;
1542 WRITESDEST(~rhs) ;
1543 break ;
1544
1545/***************************************************************************\
1546* Single Data Transfer Immediate RHS Instructions *
1547\***************************************************************************/
1548
1549 case 0x40 : /* Store Word, No WriteBack, Post Dec, Immed */
1550 lhs = LHS ;
1551 if (StoreWord(state,instr,lhs))
1552 LSBase = lhs - LSImmRHS ;
1553 break ;
1554
1555 case 0x41 : /* Load Word, No WriteBack, Post Dec, Immed */
1556 lhs = LHS ;
1557 if (LoadWord(state,instr,lhs))
1558 LSBase = lhs - LSImmRHS ;
1559 break ;
1560
1561 case 0x42 : /* Store Word, WriteBack, Post Dec, Immed */
1562 UNDEF_LSRBaseEQDestWb ;
1563 UNDEF_LSRPCBaseWb ;
1564 lhs = LHS ;
1565 temp = lhs - LSImmRHS ;
1566 state->NtransSig = LOW ;
1567 if (StoreWord(state,instr,lhs))
1568 LSBase = temp ;
1569 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1570 break ;
1571
1572 case 0x43 : /* Load Word, WriteBack, Post Dec, Immed */
1573 UNDEF_LSRBaseEQDestWb ;
1574 UNDEF_LSRPCBaseWb ;
1575 lhs = LHS ;
1576 state->NtransSig = LOW ;
1577 if (LoadWord(state,instr,lhs))
1578 LSBase = lhs - LSImmRHS ;
1579 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1580 break ;
1581
1582 case 0x44 : /* Store Byte, No WriteBack, Post Dec, Immed */
1583 lhs = LHS ;
1584 if (StoreByte(state,instr,lhs))
1585 LSBase = lhs - LSImmRHS ;
1586 break ;
1587
1588 case 0x45 : /* Load Byte, No WriteBack, Post Dec, Immed */
1589 lhs = LHS ;
1590 if (LoadByte(state,instr,lhs,LUNSIGNED))
1591 LSBase = lhs - LSImmRHS ;
1592 break ;
1593
1594 case 0x46 : /* Store Byte, WriteBack, Post Dec, Immed */
1595 UNDEF_LSRBaseEQDestWb ;
1596 UNDEF_LSRPCBaseWb ;
1597 lhs = LHS ;
1598 state->NtransSig = LOW ;
1599 if (StoreByte(state,instr,lhs))
1600 LSBase = lhs - LSImmRHS ;
1601 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1602 break ;
1603
1604 case 0x47 : /* Load Byte, WriteBack, Post Dec, Immed */
1605 UNDEF_LSRBaseEQDestWb ;
1606 UNDEF_LSRPCBaseWb ;
1607 lhs = LHS ;
1608 state->NtransSig = LOW ;
1609 if (LoadByte(state,instr,lhs,LUNSIGNED))
1610 LSBase = lhs - LSImmRHS ;
1611 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1612 break ;
1613
1614 case 0x48 : /* Store Word, No WriteBack, Post Inc, Immed */
1615 lhs = LHS ;
1616 if (StoreWord(state,instr,lhs))
1617 LSBase = lhs + LSImmRHS ;
1618 break ;
1619
1620 case 0x49 : /* Load Word, No WriteBack, Post Inc, Immed */
1621 lhs = LHS ;
1622 if (LoadWord(state,instr,lhs))
1623 LSBase = lhs + LSImmRHS ;
1624 break ;
1625
1626 case 0x4a : /* Store Word, WriteBack, Post Inc, Immed */
1627 UNDEF_LSRBaseEQDestWb ;
1628 UNDEF_LSRPCBaseWb ;
1629 lhs = LHS ;
1630 state->NtransSig = LOW ;
1631 if (StoreWord(state,instr,lhs))
1632 LSBase = lhs + LSImmRHS ;
1633 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1634 break ;
1635
1636 case 0x4b : /* Load Word, WriteBack, Post Inc, Immed */
1637 UNDEF_LSRBaseEQDestWb ;
1638 UNDEF_LSRPCBaseWb ;
1639 lhs = LHS ;
1640 state->NtransSig = LOW ;
1641 if (LoadWord(state,instr,lhs))
1642 LSBase = lhs + LSImmRHS ;
1643 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1644 break ;
1645
1646 case 0x4c : /* Store Byte, No WriteBack, Post Inc, Immed */
1647 lhs = LHS ;
1648 if (StoreByte(state,instr,lhs))
1649 LSBase = lhs + LSImmRHS ;
1650 break ;
1651
1652 case 0x4d : /* Load Byte, No WriteBack, Post Inc, Immed */
1653 lhs = LHS ;
1654 if (LoadByte(state,instr,lhs,LUNSIGNED))
1655 LSBase = lhs + LSImmRHS ;
1656 break ;
1657
1658 case 0x4e : /* Store Byte, WriteBack, Post Inc, Immed */
1659 UNDEF_LSRBaseEQDestWb ;
1660 UNDEF_LSRPCBaseWb ;
1661 lhs = LHS ;
1662 state->NtransSig = LOW ;
1663 if (StoreByte(state,instr,lhs))
1664 LSBase = lhs + LSImmRHS ;
1665 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1666 break ;
1667
1668 case 0x4f : /* Load Byte, WriteBack, Post Inc, Immed */
1669 UNDEF_LSRBaseEQDestWb ;
1670 UNDEF_LSRPCBaseWb ;
1671 lhs = LHS ;
1672 state->NtransSig = LOW ;
1673 if (LoadByte(state,instr,lhs,LUNSIGNED))
1674 LSBase = lhs + LSImmRHS ;
1675 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1676 break ;
1677
1678
1679 case 0x50 : /* Store Word, No WriteBack, Pre Dec, Immed */
1680 (void)StoreWord(state,instr,LHS - LSImmRHS) ;
1681 break ;
1682
1683 case 0x51 : /* Load Word, No WriteBack, Pre Dec, Immed */
1684 (void)LoadWord(state,instr,LHS - LSImmRHS) ;
1685 break ;
1686
1687 case 0x52 : /* Store Word, WriteBack, Pre Dec, Immed */
1688 UNDEF_LSRBaseEQDestWb ;
1689 UNDEF_LSRPCBaseWb ;
1690 temp = LHS - LSImmRHS ;
1691 if (StoreWord(state,instr,temp))
1692 LSBase = temp ;
1693 break ;
1694
1695 case 0x53 : /* Load Word, WriteBack, Pre Dec, Immed */
1696 UNDEF_LSRBaseEQDestWb ;
1697 UNDEF_LSRPCBaseWb ;
1698 temp = LHS - LSImmRHS ;
1699 if (LoadWord(state,instr,temp))
1700 LSBase = temp ;
1701 break ;
1702
1703 case 0x54 : /* Store Byte, No WriteBack, Pre Dec, Immed */
1704 (void)StoreByte(state,instr,LHS - LSImmRHS) ;
1705 break ;
1706
1707 case 0x55 : /* Load Byte, No WriteBack, Pre Dec, Immed */
1708 (void)LoadByte(state,instr,LHS - LSImmRHS,LUNSIGNED) ;
1709 break ;
1710
1711 case 0x56 : /* Store Byte, WriteBack, Pre Dec, Immed */
1712 UNDEF_LSRBaseEQDestWb ;
1713 UNDEF_LSRPCBaseWb ;
1714 temp = LHS - LSImmRHS ;
1715 if (StoreByte(state,instr,temp))
1716 LSBase = temp ;
1717 break ;
1718
1719 case 0x57 : /* Load Byte, WriteBack, Pre Dec, Immed */
1720 UNDEF_LSRBaseEQDestWb ;
1721 UNDEF_LSRPCBaseWb ;
1722 temp = LHS - LSImmRHS ;
1723 if (LoadByte(state,instr,temp,LUNSIGNED))
1724 LSBase = temp ;
1725 break ;
1726
1727 case 0x58 : /* Store Word, No WriteBack, Pre Inc, Immed */
1728 (void)StoreWord(state,instr,LHS + LSImmRHS) ;
1729 break ;
1730
1731 case 0x59 : /* Load Word, No WriteBack, Pre Inc, Immed */
1732 (void)LoadWord(state,instr,LHS + LSImmRHS) ;
1733 break ;
1734
1735 case 0x5a : /* Store Word, WriteBack, Pre Inc, Immed */
1736 UNDEF_LSRBaseEQDestWb ;
1737 UNDEF_LSRPCBaseWb ;
1738 temp = LHS + LSImmRHS ;
1739 if (StoreWord(state,instr,temp))
1740 LSBase = temp ;
1741 break ;
1742
1743 case 0x5b : /* Load Word, WriteBack, Pre Inc, Immed */
1744 UNDEF_LSRBaseEQDestWb ;
1745 UNDEF_LSRPCBaseWb ;
1746 temp = LHS + LSImmRHS ;
1747 if (LoadWord(state,instr,temp))
1748 LSBase = temp ;
1749 break ;
1750
1751 case 0x5c : /* Store Byte, No WriteBack, Pre Inc, Immed */
1752 (void)StoreByte(state,instr,LHS + LSImmRHS) ;
1753 break ;
1754
1755 case 0x5d : /* Load Byte, No WriteBack, Pre Inc, Immed */
1756 (void)LoadByte(state,instr,LHS + LSImmRHS,LUNSIGNED) ;
1757 break ;
1758
1759 case 0x5e : /* Store Byte, WriteBack, Pre Inc, Immed */
1760 UNDEF_LSRBaseEQDestWb ;
1761 UNDEF_LSRPCBaseWb ;
1762 temp = LHS + LSImmRHS ;
1763 if (StoreByte(state,instr,temp))
1764 LSBase = temp ;
1765 break ;
1766
1767 case 0x5f : /* Load Byte, WriteBack, Pre Inc, Immed */
1768 UNDEF_LSRBaseEQDestWb ;
1769 UNDEF_LSRPCBaseWb ;
1770 temp = LHS + LSImmRHS ;
1771 if (LoadByte(state,instr,temp,LUNSIGNED))
1772 LSBase = temp ;
1773 break ;
1774
1775/***************************************************************************\
1776* Single Data Transfer Register RHS Instructions *
1777\***************************************************************************/
1778
1779 case 0x60 : /* Store Word, No WriteBack, Post Dec, Reg */
1780 if (BIT(4)) {
1781 ARMul_UndefInstr(state,instr) ;
1782 break ;
1783 }
1784 UNDEF_LSRBaseEQOffWb ;
1785 UNDEF_LSRBaseEQDestWb ;
1786 UNDEF_LSRPCBaseWb ;
1787 UNDEF_LSRPCOffWb ;
1788 lhs = LHS ;
1789 if (StoreWord(state,instr,lhs))
1790 LSBase = lhs - LSRegRHS ;
1791 break ;
1792
1793 case 0x61 : /* Load Word, No WriteBack, Post Dec, Reg */
1794 if (BIT(4)) {
1795 ARMul_UndefInstr(state,instr) ;
1796 break ;
1797 }
1798 UNDEF_LSRBaseEQOffWb ;
1799 UNDEF_LSRBaseEQDestWb ;
1800 UNDEF_LSRPCBaseWb ;
1801 UNDEF_LSRPCOffWb ;
1802 lhs = LHS ;
1803 if (LoadWord(state,instr,lhs))
1804 LSBase = lhs - LSRegRHS ;
1805 break ;
1806
1807 case 0x62 : /* Store Word, WriteBack, Post Dec, Reg */
1808 if (BIT(4)) {
1809 ARMul_UndefInstr(state,instr) ;
1810 break ;
1811 }
1812 UNDEF_LSRBaseEQOffWb ;
1813 UNDEF_LSRBaseEQDestWb ;
1814 UNDEF_LSRPCBaseWb ;
1815 UNDEF_LSRPCOffWb ;
1816 lhs = LHS ;
1817 state->NtransSig = LOW ;
1818 if (StoreWord(state,instr,lhs))
1819 LSBase = lhs - LSRegRHS ;
1820 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1821 break ;
1822
1823 case 0x63 : /* Load Word, WriteBack, Post Dec, Reg */
1824 if (BIT(4)) {
1825 ARMul_UndefInstr(state,instr) ;
1826 break ;
1827 }
1828 UNDEF_LSRBaseEQOffWb ;
1829 UNDEF_LSRBaseEQDestWb ;
1830 UNDEF_LSRPCBaseWb ;
1831 UNDEF_LSRPCOffWb ;
1832 lhs = LHS ;
1833 state->NtransSig = LOW ;
1834 if (LoadWord(state,instr,lhs))
1835 LSBase = lhs - LSRegRHS ;
1836 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1837 break ;
1838
1839 case 0x64 : /* Store Byte, No WriteBack, Post Dec, Reg */
1840 if (BIT(4)) {
1841 ARMul_UndefInstr(state,instr) ;
1842 break ;
1843 }
1844 UNDEF_LSRBaseEQOffWb ;
1845 UNDEF_LSRBaseEQDestWb ;
1846 UNDEF_LSRPCBaseWb ;
1847 UNDEF_LSRPCOffWb ;
1848 lhs = LHS ;
1849 if (StoreByte(state,instr,lhs))
1850 LSBase = lhs - LSRegRHS ;
1851 break ;
1852
1853 case 0x65 : /* Load Byte, No WriteBack, Post Dec, Reg */
1854 if (BIT(4)) {
1855 ARMul_UndefInstr(state,instr) ;
1856 break ;
1857 }
1858 UNDEF_LSRBaseEQOffWb ;
1859 UNDEF_LSRBaseEQDestWb ;
1860 UNDEF_LSRPCBaseWb ;
1861 UNDEF_LSRPCOffWb ;
1862 lhs = LHS ;
1863 if (LoadByte(state,instr,lhs,LUNSIGNED))
1864 LSBase = lhs - LSRegRHS ;
1865 break ;
1866
1867 case 0x66 : /* Store Byte, WriteBack, Post Dec, Reg */
1868 if (BIT(4)) {
1869 ARMul_UndefInstr(state,instr) ;
1870 break ;
1871 }
1872 UNDEF_LSRBaseEQOffWb ;
1873 UNDEF_LSRBaseEQDestWb ;
1874 UNDEF_LSRPCBaseWb ;
1875 UNDEF_LSRPCOffWb ;
1876 lhs = LHS ;
1877 state->NtransSig = LOW ;
1878 if (StoreByte(state,instr,lhs))
1879 LSBase = lhs - LSRegRHS ;
1880 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1881 break ;
1882
1883 case 0x67 : /* Load Byte, WriteBack, Post Dec, Reg */
1884 if (BIT(4)) {
1885 ARMul_UndefInstr(state,instr) ;
1886 break ;
1887 }
1888 UNDEF_LSRBaseEQOffWb ;
1889 UNDEF_LSRBaseEQDestWb ;
1890 UNDEF_LSRPCBaseWb ;
1891 UNDEF_LSRPCOffWb ;
1892 lhs = LHS ;
1893 state->NtransSig = LOW ;
1894 if (LoadByte(state,instr,lhs,LUNSIGNED))
1895 LSBase = lhs - LSRegRHS ;
1896 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1897 break ;
1898
1899 case 0x68 : /* Store Word, No WriteBack, Post Inc, Reg */
1900 if (BIT(4)) {
1901 ARMul_UndefInstr(state,instr) ;
1902 break ;
1903 }
1904 UNDEF_LSRBaseEQOffWb ;
1905 UNDEF_LSRBaseEQDestWb ;
1906 UNDEF_LSRPCBaseWb ;
1907 UNDEF_LSRPCOffWb ;
1908 lhs = LHS ;
1909 if (StoreWord(state,instr,lhs))
1910 LSBase = lhs + LSRegRHS ;
1911 break ;
1912
1913 case 0x69 : /* Load Word, No WriteBack, Post Inc, Reg */
1914 if (BIT(4)) {
1915 ARMul_UndefInstr(state,instr) ;
1916 break ;
1917 }
1918 UNDEF_LSRBaseEQOffWb ;
1919 UNDEF_LSRBaseEQDestWb ;
1920 UNDEF_LSRPCBaseWb ;
1921 UNDEF_LSRPCOffWb ;
1922 lhs = LHS ;
1923 if (LoadWord(state,instr,lhs))
1924 LSBase = lhs + LSRegRHS ;
1925 break ;
1926
1927 case 0x6a : /* Store Word, WriteBack, Post Inc, Reg */
1928 if (BIT(4)) {
1929 ARMul_UndefInstr(state,instr) ;
1930 break ;
1931 }
1932 UNDEF_LSRBaseEQOffWb ;
1933 UNDEF_LSRBaseEQDestWb ;
1934 UNDEF_LSRPCBaseWb ;
1935 UNDEF_LSRPCOffWb ;
1936 lhs = LHS ;
1937 state->NtransSig = LOW ;
1938 if (StoreWord(state,instr,lhs))
1939 LSBase = lhs + LSRegRHS ;
1940 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1941 break ;
1942
1943 case 0x6b : /* Load Word, WriteBack, Post Inc, Reg */
1944 if (BIT(4)) {
1945 ARMul_UndefInstr(state,instr) ;
1946 break ;
1947 }
1948 UNDEF_LSRBaseEQOffWb ;
1949 UNDEF_LSRBaseEQDestWb ;
1950 UNDEF_LSRPCBaseWb ;
1951 UNDEF_LSRPCOffWb ;
1952 lhs = LHS ;
1953 state->NtransSig = LOW ;
1954 if (LoadWord(state,instr,lhs))
1955 LSBase = lhs + LSRegRHS ;
1956 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
1957 break ;
1958
1959 case 0x6c : /* Store Byte, No WriteBack, Post Inc, Reg */
1960 if (BIT(4)) {
1961 ARMul_UndefInstr(state,instr) ;
1962 break ;
1963 }
1964 UNDEF_LSRBaseEQOffWb ;
1965 UNDEF_LSRBaseEQDestWb ;
1966 UNDEF_LSRPCBaseWb ;
1967 UNDEF_LSRPCOffWb ;
1968 lhs = LHS ;
1969 if (StoreByte(state,instr,lhs))
1970 LSBase = lhs + LSRegRHS ;
1971 break ;
1972
1973 case 0x6d : /* Load Byte, No WriteBack, Post Inc, Reg */
1974 if (BIT(4)) {
1975 ARMul_UndefInstr(state,instr) ;
1976 break ;
1977 }
1978 UNDEF_LSRBaseEQOffWb ;
1979 UNDEF_LSRBaseEQDestWb ;
1980 UNDEF_LSRPCBaseWb ;
1981 UNDEF_LSRPCOffWb ;
1982 lhs = LHS ;
1983 if (LoadByte(state,instr,lhs,LUNSIGNED))
1984 LSBase = lhs + LSRegRHS ;
1985 break ;
1986
1987 case 0x6e : /* Store Byte, WriteBack, Post Inc, Reg */
1988 if (BIT(4)) {
1989 ARMul_UndefInstr(state,instr) ;
1990 break ;
1991 }
1992 UNDEF_LSRBaseEQOffWb ;
1993 UNDEF_LSRBaseEQDestWb ;
1994 UNDEF_LSRPCBaseWb ;
1995 UNDEF_LSRPCOffWb ;
1996 lhs = LHS ;
1997 state->NtransSig = LOW ;
1998 if (StoreByte(state,instr,lhs))
1999 LSBase = lhs + LSRegRHS ;
2000 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
2001 break ;
2002
2003 case 0x6f : /* Load Byte, WriteBack, Post Inc, Reg */
2004 if (BIT(4)) {
2005 ARMul_UndefInstr(state,instr) ;
2006 break ;
2007 }
2008 UNDEF_LSRBaseEQOffWb ;
2009 UNDEF_LSRBaseEQDestWb ;
2010 UNDEF_LSRPCBaseWb ;
2011 UNDEF_LSRPCOffWb ;
2012 lhs = LHS ;
2013 state->NtransSig = LOW ;
2014 if (LoadByte(state,instr,lhs,LUNSIGNED))
2015 LSBase = lhs + LSRegRHS ;
2016 state->NtransSig = (state->Mode & 3)?HIGH:LOW ;
2017 break ;
2018
2019
2020 case 0x70 : /* Store Word, No WriteBack, Pre Dec, Reg */
2021 if (BIT(4)) {
2022 ARMul_UndefInstr(state,instr) ;
2023 break ;
2024 }
2025 (void)StoreWord(state,instr,LHS - LSRegRHS) ;
2026 break ;
2027
2028 case 0x71 : /* Load Word, No WriteBack, Pre Dec, Reg */
2029 if (BIT(4)) {
2030 ARMul_UndefInstr(state,instr) ;
2031 break ;
2032 }
2033 (void)LoadWord(state,instr,LHS - LSRegRHS) ;
2034 break ;
2035
2036 case 0x72 : /* Store Word, WriteBack, Pre Dec, Reg */
2037 if (BIT(4)) {
2038 ARMul_UndefInstr(state,instr) ;
2039 break ;
2040 }
2041 UNDEF_LSRBaseEQOffWb ;
2042 UNDEF_LSRBaseEQDestWb ;
2043 UNDEF_LSRPCBaseWb ;
2044 UNDEF_LSRPCOffWb ;
2045 temp = LHS - LSRegRHS ;
2046 if (StoreWord(state,instr,temp))
2047 LSBase = temp ;
2048 break ;
2049
2050 case 0x73 : /* Load Word, WriteBack, Pre Dec, Reg */
2051 if (BIT(4)) {
2052 ARMul_UndefInstr(state,instr) ;
2053 break ;
2054 }
2055 UNDEF_LSRBaseEQOffWb ;
2056 UNDEF_LSRBaseEQDestWb ;
2057 UNDEF_LSRPCBaseWb ;
2058 UNDEF_LSRPCOffWb ;
2059 temp = LHS - LSRegRHS ;
2060 if (LoadWord(state,instr,temp))
2061 LSBase = temp ;
2062 break ;
2063
2064 case 0x74 : /* Store Byte, No WriteBack, Pre Dec, Reg */
2065 if (BIT(4)) {
2066 ARMul_UndefInstr(state,instr) ;
2067 break ;
2068 }
2069 (void)StoreByte(state,instr,LHS - LSRegRHS) ;
2070 break ;
2071
2072 case 0x75 : /* Load Byte, No WriteBack, Pre Dec, Reg */
2073 if (BIT(4)) {
2074 ARMul_UndefInstr(state,instr) ;
2075 break ;
2076 }
2077 (void)LoadByte(state,instr,LHS - LSRegRHS,LUNSIGNED) ;
2078 break ;
2079
2080 case 0x76 : /* Store Byte, WriteBack, Pre Dec, Reg */
2081 if (BIT(4)) {
2082 ARMul_UndefInstr(state,instr) ;
2083 break ;
2084 }
2085 UNDEF_LSRBaseEQOffWb ;
2086 UNDEF_LSRBaseEQDestWb ;
2087 UNDEF_LSRPCBaseWb ;
2088 UNDEF_LSRPCOffWb ;
2089 temp = LHS - LSRegRHS ;
2090 if (StoreByte(state,instr,temp))
2091 LSBase = temp ;
2092 break ;
2093
2094 case 0x77 : /* Load Byte, WriteBack, Pre Dec, Reg */
2095 if (BIT(4)) {
2096 ARMul_UndefInstr(state,instr) ;
2097 break ;
2098 }
2099 UNDEF_LSRBaseEQOffWb ;
2100 UNDEF_LSRBaseEQDestWb ;
2101 UNDEF_LSRPCBaseWb ;
2102 UNDEF_LSRPCOffWb ;
2103 temp = LHS - LSRegRHS ;
2104 if (LoadByte(state,instr,temp,LUNSIGNED))
2105 LSBase = temp ;
2106 break ;
2107
2108 case 0x78 : /* Store Word, No WriteBack, Pre Inc, Reg */
2109 if (BIT(4)) {
2110 ARMul_UndefInstr(state,instr) ;
2111 break ;
2112 }
2113 (void)StoreWord(state,instr,LHS + LSRegRHS) ;
2114 break ;
2115
2116 case 0x79 : /* Load Word, No WriteBack, Pre Inc, Reg */
2117 if (BIT(4)) {
2118 ARMul_UndefInstr(state,instr) ;
2119 break ;
2120 }
2121 (void)LoadWord(state,instr,LHS + LSRegRHS) ;
2122 break ;
2123
2124 case 0x7a : /* Store Word, WriteBack, Pre Inc, Reg */
2125 if (BIT(4)) {
2126 ARMul_UndefInstr(state,instr) ;
2127 break ;
2128 }
2129 UNDEF_LSRBaseEQOffWb ;
2130 UNDEF_LSRBaseEQDestWb ;
2131 UNDEF_LSRPCBaseWb ;
2132 UNDEF_LSRPCOffWb ;
2133 temp = LHS + LSRegRHS ;
2134 if (StoreWord(state,instr,temp))
2135 LSBase = temp ;
2136 break ;
2137
2138 case 0x7b : /* Load Word, WriteBack, Pre Inc, Reg */
2139 if (BIT(4)) {
2140 ARMul_UndefInstr(state,instr) ;
2141 break ;
2142 }
2143 UNDEF_LSRBaseEQOffWb ;
2144 UNDEF_LSRBaseEQDestWb ;
2145 UNDEF_LSRPCBaseWb ;
2146 UNDEF_LSRPCOffWb ;
2147 temp = LHS + LSRegRHS ;
2148 if (LoadWord(state,instr,temp))
2149 LSBase = temp ;
2150 break ;
2151
2152 case 0x7c : /* Store Byte, No WriteBack, Pre Inc, Reg */
2153 if (BIT(4)) {
2154 ARMul_UndefInstr(state,instr) ;
2155 break ;
2156 }
2157 (void)StoreByte(state,instr,LHS + LSRegRHS) ;
2158 break ;
2159
2160 case 0x7d : /* Load Byte, No WriteBack, Pre Inc, Reg */
2161 if (BIT(4)) {
2162 ARMul_UndefInstr(state,instr) ;
2163 break ;
2164 }
2165 (void)LoadByte(state,instr,LHS + LSRegRHS,LUNSIGNED) ;
2166 break ;
2167
2168 case 0x7e : /* Store Byte, WriteBack, Pre Inc, Reg */
2169 if (BIT(4)) {
2170 ARMul_UndefInstr(state,instr) ;
2171 break ;
2172 }
2173 UNDEF_LSRBaseEQOffWb ;
2174 UNDEF_LSRBaseEQDestWb ;
2175 UNDEF_LSRPCBaseWb ;
2176 UNDEF_LSRPCOffWb ;
2177 temp = LHS + LSRegRHS ;
2178 if (StoreByte(state,instr,temp))
2179 LSBase = temp ;
2180 break ;
2181
2182 case 0x7f : /* Load Byte, WriteBack, Pre Inc, Reg */
7a292a7a
SS		 2183 if (BIT(4))
2184 {
2185 /* Check for the special breakpoint opcode.
2186 This value should correspond to the value defined
2187 as ARM_BE_BREAKPOINT in gdb/arm-tdep.c. */
2188 if (BITS (0,19) == 0xfdefe)
2189 {
2190 if (! ARMul_OSHandleSWI (state, SWI_Breakpoint))
2191 ARMul_Abort (state, ARMul_SWIV);
2192 }
2193 else
2194 ARMul_UndefInstr(state,instr) ;
2195 break ;
2196 }
c906108c
SS		 2197 UNDEF_LSRBaseEQOffWb ;
2198 UNDEF_LSRBaseEQDestWb ;
2199 UNDEF_LSRPCBaseWb ;
2200 UNDEF_LSRPCOffWb ;
2201 temp = LHS + LSRegRHS ;
2202 if (LoadByte(state,instr,temp,LUNSIGNED))
2203 LSBase = temp ;
2204 break ;
2205
2206/***************************************************************************\
2207* Multiple Data Transfer Instructions *
2208\***************************************************************************/
2209
2210 case 0x80 : /* Store, No WriteBack, Post Dec */
2211 STOREMULT(instr,LSBase - LSMNumRegs + 4L,0L) ;
2212 break ;
2213
2214 case 0x81 : /* Load, No WriteBack, Post Dec */
2215 LOADMULT(instr,LSBase - LSMNumRegs + 4L,0L) ;
2216 break ;
2217
2218 case 0x82 : /* Store, WriteBack, Post Dec */
2219 temp = LSBase - LSMNumRegs ;
2220 STOREMULT(instr,temp + 4L,temp) ;
2221 break ;
2222
2223 case 0x83 : /* Load, WriteBack, Post Dec */
2224 temp = LSBase - LSMNumRegs ;
2225 LOADMULT(instr,temp + 4L,temp) ;
2226 break ;
2227
2228 case 0x84 : /* Store, Flags, No WriteBack, Post Dec */
2229 STORESMULT(instr,LSBase - LSMNumRegs + 4L,0L) ;
2230 break ;
2231
2232 case 0x85 : /* Load, Flags, No WriteBack, Post Dec */
2233 LOADSMULT(instr,LSBase - LSMNumRegs + 4L,0L) ;
2234 break ;
2235
2236 case 0x86 : /* Store, Flags, WriteBack, Post Dec */
2237 temp = LSBase - LSMNumRegs ;
2238 STORESMULT(instr,temp + 4L,temp) ;
2239 break ;
2240
2241 case 0x87 : /* Load, Flags, WriteBack, Post Dec */
2242 temp = LSBase - LSMNumRegs ;
2243 LOADSMULT(instr,temp + 4L,temp) ;
2244 break ;
2245
2246
2247 case 0x88 : /* Store, No WriteBack, Post Inc */
2248 STOREMULT(instr,LSBase,0L) ;
2249 break ;
2250
2251 case 0x89 : /* Load, No WriteBack, Post Inc */
2252 LOADMULT(instr,LSBase,0L) ;
2253 break ;
2254
2255 case 0x8a : /* Store, WriteBack, Post Inc */
2256 temp = LSBase ;
2257 STOREMULT(instr,temp,temp + LSMNumRegs) ;
2258 break ;
2259
2260 case 0x8b : /* Load, WriteBack, Post Inc */
2261 temp = LSBase ;
2262 LOADMULT(instr,temp,temp + LSMNumRegs) ;
2263 break ;
2264
2265 case 0x8c : /* Store, Flags, No WriteBack, Post Inc */
2266 STORESMULT(instr,LSBase,0L) ;
2267 break ;
2268
2269 case 0x8d : /* Load, Flags, No WriteBack, Post Inc */
2270 LOADSMULT(instr,LSBase,0L) ;
2271 break ;
2272
2273 case 0x8e : /* Store, Flags, WriteBack, Post Inc */
2274 temp = LSBase ;
2275 STORESMULT(instr,temp,temp + LSMNumRegs) ;
2276 break ;
2277
2278 case 0x8f : /* Load, Flags, WriteBack, Post Inc */
2279 temp = LSBase ;
2280 LOADSMULT(instr,temp,temp + LSMNumRegs) ;
2281 break ;
2282
2283
2284 case 0x90 : /* Store, No WriteBack, Pre Dec */
2285 STOREMULT(instr,LSBase - LSMNumRegs,0L) ;
2286 break ;
2287
2288 case 0x91 : /* Load, No WriteBack, Pre Dec */
2289 LOADMULT(instr,LSBase - LSMNumRegs,0L) ;
2290 break ;
2291
2292 case 0x92 : /* Store, WriteBack, Pre Dec */
2293 temp = LSBase - LSMNumRegs ;
2294 STOREMULT(instr,temp,temp) ;
2295 break ;
2296
2297 case 0x93 : /* Load, WriteBack, Pre Dec */
2298 temp = LSBase - LSMNumRegs ;
2299 LOADMULT(instr,temp,temp) ;
2300 break ;
2301
2302 case 0x94 : /* Store, Flags, No WriteBack, Pre Dec */
2303 STORESMULT(instr,LSBase - LSMNumRegs,0L) ;
2304 break ;
2305
2306 case 0x95 : /* Load, Flags, No WriteBack, Pre Dec */
2307 LOADSMULT(instr,LSBase - LSMNumRegs,0L) ;
2308 break ;
2309
2310 case 0x96 : /* Store, Flags, WriteBack, Pre Dec */
2311 temp = LSBase - LSMNumRegs ;
2312 STORESMULT(instr,temp,temp) ;
2313 break ;
2314
2315 case 0x97 : /* Load, Flags, WriteBack, Pre Dec */
2316 temp = LSBase - LSMNumRegs ;
2317 LOADSMULT(instr,temp,temp) ;
2318 break ;
2319
2320
2321 case 0x98 : /* Store, No WriteBack, Pre Inc */
2322 STOREMULT(instr,LSBase + 4L,0L) ;
2323 break ;
2324
2325 case 0x99 : /* Load, No WriteBack, Pre Inc */
2326 LOADMULT(instr,LSBase + 4L,0L) ;
2327 break ;
2328
2329 case 0x9a : /* Store, WriteBack, Pre Inc */
2330 temp = LSBase ;
2331 STOREMULT(instr,temp + 4L,temp + LSMNumRegs) ;
2332 break ;
2333
2334 case 0x9b : /* Load, WriteBack, Pre Inc */
2335 temp = LSBase ;
2336 LOADMULT(instr,temp + 4L,temp + LSMNumRegs) ;
2337 break ;
2338
2339 case 0x9c : /* Store, Flags, No WriteBack, Pre Inc */
2340 STORESMULT(instr,LSBase + 4L,0L) ;
2341 break ;
2342
2343 case 0x9d : /* Load, Flags, No WriteBack, Pre Inc */
2344 LOADSMULT(instr,LSBase + 4L,0L) ;
2345 break ;
2346
2347 case 0x9e : /* Store, Flags, WriteBack, Pre Inc */
2348 temp = LSBase ;
2349 STORESMULT(instr,temp + 4L,temp + LSMNumRegs) ;
2350 break ;
2351
2352 case 0x9f : /* Load, Flags, WriteBack, Pre Inc */
2353 temp = LSBase ;
2354 LOADSMULT(instr,temp + 4L,temp + LSMNumRegs) ;
2355 break ;
2356
2357/***************************************************************************\
2358* Branch forward *
2359\***************************************************************************/
2360
2361 case 0xa0 : case 0xa1 : case 0xa2 : case 0xa3 :
2362 case 0xa4 : case 0xa5 : case 0xa6 : case 0xa7 :
2363 state->Reg[15] = pc + 8 + POSBRANCH ;
2364 FLUSHPIPE ;
2365 break ;
2366
2367/***************************************************************************\
2368* Branch backward *
2369\***************************************************************************/
2370
2371 case 0xa8 : case 0xa9 : case 0xaa : case 0xab :
2372 case 0xac : case 0xad : case 0xae : case 0xaf :
2373 state->Reg[15] = pc + 8 + NEGBRANCH ;
2374 FLUSHPIPE ;
2375 break ;
2376
2377/***************************************************************************\
2378* Branch and Link forward *
2379\***************************************************************************/
2380
2381 case 0xb0 : case 0xb1 : case 0xb2 : case 0xb3 :
2382 case 0xb4 : case 0xb5 : case 0xb6 : case 0xb7 :
2383#ifdef MODE32
2384 state->Reg[14] = pc + 4 ; /* put PC into Link */
2385#else
2386 state->Reg[14] = pc + 4 | ECC | ER15INT | EMODE ; /* put PC into Link */
2387#endif
2388 state->Reg[15] = pc + 8 + POSBRANCH ;
2389 FLUSHPIPE ;
2390 break ;
2391
2392/***************************************************************************\
2393* Branch and Link backward *
2394\***************************************************************************/
2395
2396 case 0xb8 : case 0xb9 : case 0xba : case 0xbb :
2397 case 0xbc : case 0xbd : case 0xbe : case 0xbf :
2398#ifdef MODE32
2399 state->Reg[14] = pc + 4 ; /* put PC into Link */
2400#else
2401 state->Reg[14] = (pc + 4) | ECC | ER15INT | EMODE ; /* put PC into Link */
2402#endif
2403 state->Reg[15] = pc + 8 + NEGBRANCH ;
2404 FLUSHPIPE ;
2405 break ;
2406
2407/***************************************************************************\
2408* Co-Processor Data Transfers *
2409\***************************************************************************/
2410
2411 case 0xc0 :
2412 case 0xc4 : /* Store , No WriteBack , Post Dec */
2413 ARMul_STC(state,instr,LHS) ;
2414 break ;
2415
2416 case 0xc1 :
2417 case 0xc5 : /* Load , No WriteBack , Post Dec */
2418 ARMul_LDC(state,instr,LHS) ;
2419 break ;
2420
2421 case 0xc2 :
2422 case 0xc6 : /* Store , WriteBack , Post Dec */
2423 lhs = LHS ;
2424 state->Base = lhs - LSCOff ;
2425 ARMul_STC(state,instr,lhs) ;
2426 break ;
2427
2428 case 0xc3 :
2429 case 0xc7 : /* Load , WriteBack , Post Dec */
2430 lhs = LHS ;
2431 state->Base = lhs - LSCOff ;
2432 ARMul_LDC(state,instr,lhs) ;
2433 break ;
2434
2435 case 0xc8 :
2436 case 0xcc : /* Store , No WriteBack , Post Inc */
2437 ARMul_STC(state,instr,LHS) ;
2438 break ;
2439
2440 case 0xc9 :
2441 case 0xcd : /* Load , No WriteBack , Post Inc */
2442 ARMul_LDC(state,instr,LHS) ;
2443 break ;
2444
2445 case 0xca :
2446 case 0xce : /* Store , WriteBack , Post Inc */
2447 lhs = LHS ;
2448 state->Base = lhs + LSCOff ;
2449 ARMul_STC(state,instr,LHS) ;
2450 break ;
2451
2452 case 0xcb :
2453 case 0xcf : /* Load , WriteBack , Post Inc */
2454 lhs = LHS ;
2455 state->Base = lhs + LSCOff ;
2456 ARMul_LDC(state,instr,LHS) ;
2457 break ;
2458
2459
2460 case 0xd0 :
2461 case 0xd4 : /* Store , No WriteBack , Pre Dec */
2462 ARMul_STC(state,instr,LHS - LSCOff) ;
2463 break ;
2464
2465 case 0xd1 :
2466 case 0xd5 : /* Load , No WriteBack , Pre Dec */
2467 ARMul_LDC(state,instr,LHS - LSCOff) ;
2468 break ;
2469
2470 case 0xd2 :
2471 case 0xd6 : /* Store , WriteBack , Pre Dec */
2472 lhs = LHS - LSCOff ;
2473 state->Base = lhs ;
2474 ARMul_STC(state,instr,lhs) ;
2475 break ;
2476
2477 case 0xd3 :
2478 case 0xd7 : /* Load , WriteBack , Pre Dec */
2479 lhs = LHS - LSCOff ;
2480 state->Base = lhs ;
2481 ARMul_LDC(state,instr,lhs) ;
2482 break ;
2483
2484 case 0xd8 :
2485 case 0xdc : /* Store , No WriteBack , Pre Inc */
2486 ARMul_STC(state,instr,LHS + LSCOff) ;
2487 break ;
2488
2489 case 0xd9 :
2490 case 0xdd : /* Load , No WriteBack , Pre Inc */
2491 ARMul_LDC(state,instr,LHS + LSCOff) ;
2492 break ;
2493
2494 case 0xda :
2495 case 0xde : /* Store , WriteBack , Pre Inc */
2496 lhs = LHS + LSCOff ;
2497 state->Base = lhs ;
2498 ARMul_STC(state,instr,lhs) ;
2499 break ;
2500
2501 case 0xdb :
2502 case 0xdf : /* Load , WriteBack , Pre Inc */
2503 lhs = LHS + LSCOff ;
2504 state->Base = lhs ;
2505 ARMul_LDC(state,instr,lhs) ;
2506 break ;
2507
2508/***************************************************************************\
2509* Co-Processor Register Transfers (MCR) and Data Ops *
2510\***************************************************************************/
2511
2512 case 0xe0 : case 0xe2 : case 0xe4 : case 0xe6 :
2513 case 0xe8 : case 0xea : case 0xec : case 0xee :
2514 if (BIT(4)) { /* MCR */
2515 if (DESTReg == 15) {
2516 UNDEF_MCRPC ;
2517#ifdef MODE32
2518 ARMul_MCR(state,instr,state->Reg[15] + isize) ;
2519#else
2520 ARMul_MCR(state,instr,ECC | ER15INT | EMODE |
2521 ((state->Reg[15] + isize) & R15PCBITS) ) ;
2522#endif
2523 }
2524 else
2525 ARMul_MCR(state,instr,DEST) ;
2526 }
2527 else /* CDP Part 1 */
2528 ARMul_CDP(state,instr) ;
2529 break ;
2530
2531/***************************************************************************\
2532* Co-Processor Register Transfers (MRC) and Data Ops *
2533\***************************************************************************/
2534
2535 case 0xe1 : case 0xe3 : case 0xe5 : case 0xe7 :
2536 case 0xe9 : case 0xeb : case 0xed : case 0xef :
2537 if (BIT(4)) { /* MRC */
2538 temp = ARMul_MRC(state,instr) ;
2539 if (DESTReg == 15) {
2540 ASSIGNN((temp & NBIT) != 0) ;
2541 ASSIGNZ((temp & ZBIT) != 0) ;
2542 ASSIGNC((temp & CBIT) != 0) ;
2543 ASSIGNV((temp & VBIT) != 0) ;
2544 }
2545 else
2546 DEST = temp ;
2547 }
2548 else /* CDP Part 2 */
2549 ARMul_CDP(state,instr) ;
2550 break ;
2551
2552/***************************************************************************\
2553* SWI instruction *
2554\***************************************************************************/
2555
2556 case 0xf0 : case 0xf1 : case 0xf2 : case 0xf3 :
2557 case 0xf4 : case 0xf5 : case 0xf6 : case 0xf7 :
2558 case 0xf8 : case 0xf9 : case 0xfa : case 0xfb :
2559 case 0xfc : case 0xfd : case 0xfe : case 0xff :
2560 if (instr == ARMul_ABORTWORD && state->AbortAddr == pc) { /* a prefetch abort */
2561 ARMul_Abort(state,ARMul_PrefetchAbortV) ;
2562 break ;
2563 }
2564
2565 if (!ARMul_OSHandleSWI(state,BITS(0,23))) {
2566 ARMul_Abort(state,ARMul_SWIV) ;
2567 }
2568 break ;
2569 } /* 256 way main switch */
2570 } /* if temp */
2571
2572#ifdef MODET
2573donext:
2574#endif
2575
7a292a7a
SS		 2576#ifdef NEED_UI_LOOP_HOOK
2577 if (ui_loop_hook != NULL && ui_loop_hook_counter-- < 0)
2578 {
2579 ui_loop_hook_counter = UI_LOOP_POLL_INTERVAL;
2580 ui_loop_hook (0);
2581 }
2582#endif /* NEED_UI_LOOP_HOOK */
2583
c906108c
SS		 2584 if (state->Emulate == ONCE)
2585 state->Emulate = STOP;
2586 else if (state->Emulate != RUN)
2587 break;
7a292a7a 2588 } while (!stop_simulator) ; /* do loop */
c906108c
SS		 2589
2590 state->decoded = decoded ;
2591 state->loaded = loaded ;
2592 state->pc = pc ;
2593 return(pc) ;
2594 } /* Emulate 26/32 in instruction based mode */
2595
2596
2597/***************************************************************************\
2598* This routine evaluates most Data Processing register RHS's with the S *
2599* bit clear. It is intended to be called from the macro DPRegRHS, which *
2600* filters the common case of an unshifted register with in line code *
2601\***************************************************************************/
2602
2603static ARMword GetDPRegRHS(ARMul_State *state, ARMword instr)
2604{ARMword shamt , base ;
2605
2606 base = RHSReg ;
2607 if (BIT(4)) { /* shift amount in a register */
2608 UNDEF_Shift ;
2609 INCPC ;
2610#ifndef MODE32
2611 if (base == 15)
2612 base = ECC | ER15INT | R15PC | EMODE ;
2613 else
2614#endif
2615 base = state->Reg[base] ;
2616 ARMul_Icycles(state,1,0L) ;
2617 shamt = state->Reg[BITS(8,11)] & 0xff ;
2618 switch ((int)BITS(5,6)) {
2619 case LSL : if (shamt == 0)
2620 return(base) ;
2621 else if (shamt >= 32)
2622 return(0) ;
2623 else
2624 return(base << shamt) ;
2625 case LSR : if (shamt == 0)
2626 return(base) ;
2627 else if (shamt >= 32)
2628 return(0) ;
2629 else
2630 return(base >> shamt) ;
2631 case ASR : if (shamt == 0)
2632 return(base) ;
2633 else if (shamt >= 32)
2634 return((ARMword)((long int)base >> 31L)) ;
2635 else
2636 return((ARMword)((long int)base >> (int)shamt)) ;
2637 case ROR : shamt &= 0x1f ;
2638 if (shamt == 0)
2639 return(base) ;
2640 else
2641 return((base << (32 - shamt)) | (base >> shamt)) ;
2642 }
2643 }
2644 else { /* shift amount is a constant */
2645#ifndef MODE32
2646 if (base == 15)
2647 base = ECC | ER15INT | R15PC | EMODE ;
2648 else
2649#endif
2650 base = state->Reg[base] ;
2651 shamt = BITS(7,11) ;
2652 switch ((int)BITS(5,6)) {
2653 case LSL : return(base<<shamt) ;
2654 case LSR : if (shamt == 0)
2655 return(0) ;
2656 else
2657 return(base >> shamt) ;
2658 case ASR : if (shamt == 0)
2659 return((ARMword)((long int)base >> 31L)) ;
2660 else
2661 return((ARMword)((long int)base >> (int)shamt)) ;
2662 case ROR : if (shamt==0) /* its an RRX */
2663 return((base >> 1) | (CFLAG << 31)) ;
2664 else
2665 return((base << (32 - shamt)) | (base >> shamt)) ;
2666 }
2667 }
2668 return(0) ; /* just to shut up lint */
2669 }
2670/***************************************************************************\
2671* This routine evaluates most Logical Data Processing register RHS's *
2672* with the S bit set. It is intended to be called from the macro *
2673* DPSRegRHS, which filters the common case of an unshifted register *
2674* with in line code *
2675\***************************************************************************/
2676
2677static ARMword GetDPSRegRHS(ARMul_State *state, ARMword instr)
2678{ARMword shamt , base ;
2679
2680 base = RHSReg ;
2681 if (BIT(4)) { /* shift amount in a register */
2682 UNDEF_Shift ;
2683 INCPC ;
2684#ifndef MODE32
2685 if (base == 15)
2686 base = ECC | ER15INT | R15PC | EMODE ;
2687 else
2688#endif
2689 base = state->Reg[base] ;
2690 ARMul_Icycles(state,1,0L) ;
2691 shamt = state->Reg[BITS(8,11)] & 0xff ;
2692 switch ((int)BITS(5,6)) {
2693 case LSL : if (shamt == 0)
2694 return(base) ;
2695 else if (shamt == 32) {
2696 ASSIGNC(base & 1) ;
2697 return(0) ;
2698 }
2699 else if (shamt > 32) {
2700 CLEARC ;
2701 return(0) ;
2702 }
2703 else {
2704 ASSIGNC((base >> (32-shamt)) & 1) ;
2705 return(base << shamt) ;
2706 }
2707 case LSR : if (shamt == 0)
2708 return(base) ;
2709 else if (shamt == 32) {
2710 ASSIGNC(base >> 31) ;
2711 return(0) ;
2712 }
2713 else if (shamt > 32) {
2714 CLEARC ;
2715 return(0) ;
2716 }
2717 else {
2718 ASSIGNC((base >> (shamt - 1)) & 1) ;
2719 return(base >> shamt) ;
2720 }
2721 case ASR : if (shamt == 0)
2722 return(base) ;
2723 else if (shamt >= 32) {
2724 ASSIGNC(base >> 31L) ;
2725 return((ARMword)((long int)base >> 31L)) ;
2726 }
2727 else {
2728 ASSIGNC((ARMword)((long int)base >> (int)(shamt-1)) & 1) ;
2729 return((ARMword)((long int)base >> (int)shamt)) ;
2730 }
2731 case ROR : if (shamt == 0)
2732 return(base) ;
2733 shamt &= 0x1f ;
2734 if (shamt == 0) {
2735 ASSIGNC(base >> 31) ;
2736 return(base) ;
2737 }
2738 else {
2739 ASSIGNC((base >> (shamt-1)) & 1) ;
2740 return((base << (32-shamt)) | (base >> shamt)) ;
2741 }
2742 }
2743 }
2744 else { /* shift amount is a constant */
2745#ifndef MODE32
2746 if (base == 15)
2747 base = ECC | ER15INT | R15PC | EMODE ;
2748 else
2749#endif
2750 base = state->Reg[base] ;
2751 shamt = BITS(7,11) ;
2752 switch ((int)BITS(5,6)) {
2753 case LSL : ASSIGNC((base >> (32-shamt)) & 1) ;
2754 return(base << shamt) ;
2755 case LSR : if (shamt == 0) {
2756 ASSIGNC(base >> 31) ;
2757 return(0) ;
2758 }
2759 else {
2760 ASSIGNC((base >> (shamt - 1)) & 1) ;
2761 return(base >> shamt) ;
2762 }
2763 case ASR : if (shamt == 0) {
2764 ASSIGNC(base >> 31L) ;
2765 return((ARMword)((long int)base >> 31L)) ;
2766 }
2767 else {
2768 ASSIGNC((ARMword)((long int)base >> (int)(shamt-1)) & 1) ;
2769 return((ARMword)((long int)base >> (int)shamt)) ;
2770 }
2771 case ROR : if (shamt == 0) { /* its an RRX */
2772 shamt = CFLAG ;
2773 ASSIGNC(base & 1) ;
2774 return((base >> 1) | (shamt << 31)) ;
2775 }
2776 else {
2777 ASSIGNC((base >> (shamt - 1)) & 1) ;
2778 return((base << (32-shamt)) | (base >> shamt)) ;
2779 }
2780 }
2781 }
2782 return(0) ; /* just to shut up lint */
2783 }
2784
2785/***************************************************************************\
2786* This routine handles writes to register 15 when the S bit is not set. *
2787\***************************************************************************/
2788
2789static void WriteR15(ARMul_State *state, ARMword src)
2790{
2791 /* The ARM documentation implies (but doe snot state) that the bottom bit of the PC is never set */
2792#ifdef MODE32
2793 state->Reg[15] = src & PCBITS & ~ 0x1 ;
2794#else
2795 state->Reg[15] = (src & R15PCBITS & ~ 0x1) | ECC | ER15INT | EMODE ;
2796 ARMul_R15Altered(state) ;
2797#endif
2798 FLUSHPIPE ;
2799 }
2800
2801/***************************************************************************\
2802* This routine handles writes to register 15 when the S bit is set. *
2803\***************************************************************************/
2804
2805static void WriteSR15(ARMul_State *state, ARMword src)
2806{
2807#ifdef MODE32
2808 state->Reg[15] = src & PCBITS ;
2809 if (state->Bank > 0) {
2810 state->Cpsr = state->Spsr[state->Bank] ;
2811 ARMul_CPSRAltered(state) ;
2812 }
2813#else
2814 if (state->Bank == USERBANK)
2815 state->Reg[15] = (src & (CCBITS | R15PCBITS)) | ER15INT | EMODE ;
2816 else
2817 state->Reg[15] = src ;
2818 ARMul_R15Altered(state) ;
2819#endif
2820 FLUSHPIPE ;
2821 }
2822
2823/***************************************************************************\
2824* This routine evaluates most Load and Store register RHS's. It is *
2825* intended to be called from the macro LSRegRHS, which filters the *
2826* common case of an unshifted register with in line code *
2827\***************************************************************************/
2828
2829static ARMword GetLSRegRHS(ARMul_State *state, ARMword instr)
2830{ARMword shamt, base ;
2831
2832 base = RHSReg ;
2833#ifndef MODE32
2834 if (base == 15)
2835 base = ECC | ER15INT | R15PC | EMODE ; /* Now forbidden, but .... */
2836 else
2837#endif
2838 base = state->Reg[base] ;
2839
2840 shamt = BITS(7,11) ;
2841 switch ((int)BITS(5,6)) {
2842 case LSL : return(base << shamt) ;
2843 case LSR : if (shamt == 0)
2844 return(0) ;
2845 else
2846 return(base >> shamt) ;
2847 case ASR : if (shamt == 0)
2848 return((ARMword)((long int)base >> 31L)) ;
2849 else
2850 return((ARMword)((long int)base >> (int)shamt)) ;
2851 case ROR : if (shamt==0) /* its an RRX */
2852 return((base >> 1) | (CFLAG << 31)) ;
2853 else
2854 return((base << (32-shamt)) | (base >> shamt)) ;
2855 }
2856 return(0) ; /* just to shut up lint */
2857 }
2858
2859/***************************************************************************\
2860* This routine evaluates the ARM7T halfword and signed transfer RHS's. *
2861\***************************************************************************/
2862
2863static ARMword GetLS7RHS(ARMul_State *state, ARMword instr)
2864{
2865 if (BIT(22) == 0) { /* register */
2866#ifndef MODE32
2867 if (RHSReg == 15)
2868 return ECC | ER15INT | R15PC | EMODE ; /* Now forbidden, but ... */
2869#endif
2870 return state->Reg[RHSReg] ;
2871 }
2872
2873 /* else immediate */
2874 return BITS(0,3) | (BITS(8,11) << 4) ;
2875 }
2876
2877/***************************************************************************\
2878* This function does the work of loading a word for a LDR instruction. *
2879\***************************************************************************/
2880
2881static unsigned LoadWord(ARMul_State *state, ARMword instr, ARMword address)
2882{
2883 ARMword dest ;
2884
2885 BUSUSEDINCPCS ;
2886#ifndef MODE32
2887 if (ADDREXCEPT(address)) {
2888 INTERNALABORT(address) ;
2889 }
2890#endif
2891 dest = ARMul_LoadWordN(state,address) ;
2892 if (state->Aborted) {
2893 TAKEABORT ;
2894 return(state->lateabtSig) ;
2895 }
2896 if (address & 3)
2897 dest = ARMul_Align(state,address,dest) ;
2898 WRITEDEST(dest) ;
2899 ARMul_Icycles(state,1,0L) ;
2900
2901 return(DESTReg != LHSReg) ;
2902}
2903
2904#ifdef MODET
2905/***************************************************************************\
2906* This function does the work of loading a halfword. *
2907\***************************************************************************/
2908
2909static unsigned LoadHalfWord(ARMul_State *state, ARMword instr, ARMword address,int signextend)
2910{
2911 ARMword dest ;
2912
2913 BUSUSEDINCPCS ;
2914#ifndef MODE32
2915 if (ADDREXCEPT(address)) {
2916 INTERNALABORT(address) ;
2917 }
2918#endif
2919 dest = ARMul_LoadHalfWord(state,address) ;
2920 if (state->Aborted) {
2921 TAKEABORT ;
2922 return(state->lateabtSig) ;
2923 }
2924 UNDEF_LSRBPC ;
2925 if (signextend)
2926 {
2927 if (dest & 1 << (16 - 1))
2928 dest = (dest & ((1 << 16) - 1)) - (1 << 16) ;
2929 }
2930 WRITEDEST(dest) ;
2931 ARMul_Icycles(state,1,0L) ;
2932 return(DESTReg != LHSReg) ;
2933}
2934#endif /* MODET */
2935
2936/***************************************************************************\
2937* This function does the work of loading a byte for a LDRB instruction. *
2938\***************************************************************************/
2939
2940static unsigned LoadByte(ARMul_State *state, ARMword instr, ARMword address,int signextend)
2941{
2942 ARMword dest ;
2943
2944 BUSUSEDINCPCS ;
2945#ifndef MODE32
2946 if (ADDREXCEPT(address)) {
2947 INTERNALABORT(address) ;
2948 }
2949#endif
2950 dest = ARMul_LoadByte(state,address) ;
2951 if (state->Aborted) {
2952 TAKEABORT ;
2953 return(state->lateabtSig) ;
2954 }
2955 UNDEF_LSRBPC ;
2956 if (signextend)
2957 {
2958 if (dest & 1 << (8 - 1))
2959 dest = (dest & ((1 << 8) - 1)) - (1 << 8) ;
2960 }
2961 WRITEDEST(dest) ;
2962 ARMul_Icycles(state,1,0L) ;
2963 return(DESTReg != LHSReg) ;
2964}
2965
2966/***************************************************************************\
2967* This function does the work of storing a word from a STR instruction. *
2968\***************************************************************************/
2969
2970static unsigned StoreWord(ARMul_State *state, ARMword instr, ARMword address)
2971{BUSUSEDINCPCN ;
2972#ifndef MODE32
2973 if (DESTReg == 15)
2974 state->Reg[15] = ECC | ER15INT | R15PC | EMODE ;
2975#endif
2976#ifdef MODE32
2977 ARMul_StoreWordN(state,address,DEST) ;
2978#else
2979 if (VECTORACCESS(address) || ADDREXCEPT(address)) {
2980 INTERNALABORT(address) ;
2981 (void)ARMul_LoadWordN(state,address) ;
2982 }
2983 else
2984 ARMul_StoreWordN(state,address,DEST) ;
2985#endif
2986 if (state->Aborted) {
2987 TAKEABORT ;
2988 return(state->lateabtSig) ;
2989 }
2990 return(TRUE) ;
2991}
2992
2993#ifdef MODET
2994/***************************************************************************\
2995* This function does the work of storing a byte for a STRH instruction. *
2996\***************************************************************************/
2997
2998static unsigned StoreHalfWord(ARMul_State *state, ARMword instr, ARMword address)
2999{BUSUSEDINCPCN ;
3000
3001#ifndef MODE32
3002 if (DESTReg == 15)
3003 state->Reg[15] = ECC | ER15INT | R15PC | EMODE ;
3004#endif
3005
3006#ifdef MODE32
3007 ARMul_StoreHalfWord(state,address,DEST);
3008#else
3009 if (VECTORACCESS(address) || ADDREXCEPT(address)) {
3010 INTERNALABORT(address) ;
3011 (void)ARMul_LoadHalfWord(state,address) ;
3012 }
3013 else
3014 ARMul_StoreHalfWord(state,address,DEST) ;
3015#endif
3016
3017 if (state->Aborted) {
3018 TAKEABORT ;
3019 return(state->lateabtSig) ;
3020 }
3021
3022 return(TRUE) ;
3023}
3024#endif /* MODET */
3025
3026/***************************************************************************\
3027* This function does the work of storing a byte for a STRB instruction. *
3028\***************************************************************************/
3029
3030static unsigned StoreByte(ARMul_State *state, ARMword instr, ARMword address)
3031{BUSUSEDINCPCN ;
3032#ifndef MODE32
3033 if (DESTReg == 15)
3034 state->Reg[15] = ECC | ER15INT | R15PC | EMODE ;
3035#endif
3036#ifdef MODE32
3037 ARMul_StoreByte(state,address,DEST) ;
3038#else
3039 if (VECTORACCESS(address) || ADDREXCEPT(address)) {
3040 INTERNALABORT(address) ;
3041 (void)ARMul_LoadByte(state,address) ;
3042 }
3043 else
3044 ARMul_StoreByte(state,address,DEST) ;
3045#endif
3046 if (state->Aborted) {
3047 TAKEABORT ;
3048 return(state->lateabtSig) ;
3049 }
3050 UNDEF_LSRBPC ;
3051 return(TRUE) ;
3052}
3053
3054/***************************************************************************\
3055* This function does the work of loading the registers listed in an LDM *
3056* instruction, when the S bit is clear. The code here is always increment *
3057* after, it's up to the caller to get the input address correct and to *
3058* handle base register modification. *
3059\***************************************************************************/
3060
3061static void LoadMult(ARMul_State *state, ARMword instr,
3062 ARMword address, ARMword WBBase)
3063{ARMword dest, temp ;
3064
3065 UNDEF_LSMNoRegs ;
3066 UNDEF_LSMPCBase ;
3067 UNDEF_LSMBaseInListWb ;
3068 BUSUSEDINCPCS ;
3069#ifndef MODE32
3070 if (ADDREXCEPT(address)) {
3071 INTERNALABORT(address) ;
3072 }
3073#endif
3074 if (BIT(21) && LHSReg != 15)
3075 LSBase = WBBase ;
3076
3077 for (temp = 0 ; !BIT(temp) ; temp++) ; /* N cycle first */
3078 dest = ARMul_LoadWordN(state,address) ;
3079 if (!state->abortSig && !state->Aborted)
3080 state->Reg[temp++] = dest ;
3081 else
3082 if (!state->Aborted)
3083 state->Aborted = ARMul_DataAbortV ;
3084
3085 for (; temp < 16 ; temp++) /* S cycles from here on */
3086 if (BIT(temp)) { /* load this register */
3087 address += 4 ;
3088 dest = ARMul_LoadWordS(state,address) ;
3089 if (!state->abortSig && !state->Aborted)
3090 state->Reg[temp] = dest ;
3091 else
3092 if (!state->Aborted)
3093 state->Aborted = ARMul_DataAbortV ;
3094 }
3095
3096 if (BIT(15)) { /* PC is in the reg list */
3097#ifdef MODE32
3098 state->Reg[15] = PC ;
3099#endif
3100 FLUSHPIPE ;
3101 }
3102
3103 ARMul_Icycles(state,1,0L) ; /* to write back the final register */
3104
3105 if (state->Aborted) {
3106 if (BIT(21) && LHSReg != 15)
3107 LSBase = WBBase ;
3108 TAKEABORT ;
3109 }
3110 }
3111
3112/***************************************************************************\
3113* This function does the work of loading the registers listed in an LDM *
3114* instruction, when the S bit is set. The code here is always increment *
3115* after, it's up to the caller to get the input address correct and to *
3116* handle base register modification. *
3117\***************************************************************************/
3118
3119static void LoadSMult(ARMul_State *state, ARMword instr,
3120 ARMword address, ARMword WBBase)
3121{ARMword dest, temp ;
3122
3123 UNDEF_LSMNoRegs ;
3124 UNDEF_LSMPCBase ;
3125 UNDEF_LSMBaseInListWb ;
3126 BUSUSEDINCPCS ;
3127#ifndef MODE32
3128 if (ADDREXCEPT(address)) {
3129 INTERNALABORT(address) ;
3130 }
3131#endif
3132
3133 if (!BIT(15) && state->Bank != USERBANK) {
3134 (void)ARMul_SwitchMode(state,state->Mode,USER26MODE) ; /* temporary reg bank switch */
3135 UNDEF_LSMUserBankWb ;
3136 }
3137
3138 if (BIT(21) && LHSReg != 15)
3139 LSBase = WBBase ;
3140
3141 for (temp = 0 ; !BIT(temp) ; temp++) ; /* N cycle first */
3142 dest = ARMul_LoadWordN(state,address) ;
3143 if (!state->abortSig)
3144 state->Reg[temp++] = dest ;
3145 else
3146 if (!state->Aborted)
3147 state->Aborted = ARMul_DataAbortV ;
3148
3149 for (; temp < 16 ; temp++) /* S cycles from here on */
3150 if (BIT(temp)) { /* load this register */
3151 address += 4 ;
3152 dest = ARMul_LoadWordS(state,address) ;
3153 if (!state->abortSig || state->Aborted)
3154 state->Reg[temp] = dest ;
3155 else
3156 if (!state->Aborted)
3157 state->Aborted = ARMul_DataAbortV ;
3158 }
3159
3160 if (BIT(15)) { /* PC is in the reg list */
3161#ifdef MODE32
3162 if (state->Mode != USER26MODE && state->Mode != USER32MODE) {
3163 state->Cpsr = GETSPSR(state->Bank) ;
3164 ARMul_CPSRAltered(state) ;
3165 }
3166 state->Reg[15] = PC ;
3167#else
3168 if (state->Mode == USER26MODE || state->Mode == USER32MODE) { /* protect bits in user mode */
3169 ASSIGNN((state->Reg[15] & NBIT) != 0) ;
3170 ASSIGNZ((state->Reg[15] & ZBIT) != 0) ;
3171 ASSIGNC((state->Reg[15] & CBIT) != 0) ;
3172 ASSIGNV((state->Reg[15] & VBIT) != 0) ;
3173 }
3174 else
3175 ARMul_R15Altered(state) ;
3176#endif
3177 FLUSHPIPE ;
3178 }
3179
3180 if (!BIT(15) && state->Mode != USER26MODE && state->Mode != USER32MODE)
3181 (void)ARMul_SwitchMode(state,USER26MODE,state->Mode) ; /* restore the correct bank */
3182
3183 ARMul_Icycles(state,1,0L) ; /* to write back the final register */
3184
3185 if (state->Aborted) {
3186 if (BIT(21) && LHSReg != 15)
3187 LSBase = WBBase ;
3188 TAKEABORT ;
3189 }
3190
3191}
3192
3193/***************************************************************************\
3194* This function does the work of storing the registers listed in an STM *
3195* instruction, when the S bit is clear. The code here is always increment *
3196* after, it's up to the caller to get the input address correct and to *
3197* handle base register modification. *
3198\***************************************************************************/
3199
3200static void StoreMult(ARMul_State *state, ARMword instr,
3201 ARMword address, ARMword WBBase)
3202{ARMword temp ;
3203
3204 UNDEF_LSMNoRegs ;
3205 UNDEF_LSMPCBase ;
3206 UNDEF_LSMBaseInListWb ;
3207 if (!TFLAG) {
3208 BUSUSEDINCPCN ; /* N-cycle, increment the PC and update the NextInstr state */
3209 }
3210
3211#ifndef MODE32
3212 if (VECTORACCESS(address) || ADDREXCEPT(address)) {
3213 INTERNALABORT(address) ;
3214 }
3215 if (BIT(15))
3216 PATCHR15 ;
3217#endif
3218
3219 for (temp = 0 ; !BIT(temp) ; temp++) ; /* N cycle first */
3220#ifdef MODE32
3221 ARMul_StoreWordN(state,address,state->Reg[temp++]) ;
3222#else
3223 if (state->Aborted) {
3224 (void)ARMul_LoadWordN(state,address) ;
3225 for ( ; temp < 16 ; temp++) /* Fake the Stores as Loads */
3226 if (BIT(temp)) { /* save this register */
3227 address += 4 ;
3228 (void)ARMul_LoadWordS(state,address) ;
3229 }
3230 if (BIT(21) && LHSReg != 15)
3231 LSBase = WBBase ;
3232 TAKEABORT ;
3233 return ;
3234 }
3235 else
3236 ARMul_StoreWordN(state,address,state->Reg[temp++]) ;
3237#endif
3238 if (state->abortSig && !state->Aborted)
3239 state->Aborted = ARMul_DataAbortV ;
3240
3241 if (BIT(21) && LHSReg != 15)
3242 LSBase = WBBase ;
3243
3244 for ( ; temp < 16 ; temp++) /* S cycles from here on */
3245 if (BIT(temp)) { /* save this register */
3246 address += 4 ;
3247 ARMul_StoreWordS(state,address,state->Reg[temp]) ;
3248 if (state->abortSig && !state->Aborted)
3249 state->Aborted = ARMul_DataAbortV ;
3250 }
3251 if (state->Aborted) {
3252 TAKEABORT ;
3253 }
3254 }
3255
3256/***************************************************************************\
3257* This function does the work of storing the registers listed in an STM *
3258* instruction when the S bit is set. The code here is always increment *
3259* after, it's up to the caller to get the input address correct and to *
3260* handle base register modification. *
3261\***************************************************************************/
3262
3263static void StoreSMult(ARMul_State *state, ARMword instr,
3264 ARMword address, ARMword WBBase)
3265{ARMword temp ;
3266
3267 UNDEF_LSMNoRegs ;
3268 UNDEF_LSMPCBase ;
3269 UNDEF_LSMBaseInListWb ;
3270 BUSUSEDINCPCN ;
3271#ifndef MODE32
3272 if (VECTORACCESS(address) || ADDREXCEPT(address)) {
3273 INTERNALABORT(address) ;
3274 }
3275 if (BIT(15))
3276 PATCHR15 ;
3277#endif
3278
3279 if (state->Bank != USERBANK) {
3280 (void)ARMul_SwitchMode(state,state->Mode,USER26MODE) ; /* Force User Bank */
3281 UNDEF_LSMUserBankWb ;
3282 }
3283
3284 for (temp = 0 ; !BIT(temp) ; temp++) ; /* N cycle first */
3285#ifdef MODE32
3286 ARMul_StoreWordN(state,address,state->Reg[temp++]) ;
3287#else
3288 if (state->Aborted) {
3289 (void)ARMul_LoadWordN(state,address) ;
3290 for ( ; temp < 16 ; temp++) /* Fake the Stores as Loads */
3291 if (BIT(temp)) { /* save this register */
3292 address += 4 ;
3293 (void)ARMul_LoadWordS(state,address) ;
3294 }
3295 if (BIT(21) && LHSReg != 15)
3296 LSBase = WBBase ;
3297 TAKEABORT ;
3298 return ;
3299 }
3300 else
3301 ARMul_StoreWordN(state,address,state->Reg[temp++]) ;
3302#endif
3303 if (state->abortSig && !state->Aborted)
3304 state->Aborted = ARMul_DataAbortV ;
3305
3306 if (BIT(21) && LHSReg != 15)
3307 LSBase = WBBase ;
3308
3309 for (; temp < 16 ; temp++) /* S cycles from here on */
3310 if (BIT(temp)) { /* save this register */
3311 address += 4 ;
3312 ARMul_StoreWordS(state,address,state->Reg[temp]) ;
3313 if (state->abortSig && !state->Aborted)
3314 state->Aborted = ARMul_DataAbortV ;
3315 }
3316
3317 if (state->Mode != USER26MODE && state->Mode != USER32MODE)
3318 (void)ARMul_SwitchMode(state,USER26MODE,state->Mode) ; /* restore the correct bank */
3319
3320 if (state->Aborted) {
3321 TAKEABORT ;
3322 }
3323}
3324
3325/***************************************************************************\
3326* This function does the work of adding two 32bit values together, and *
3327* calculating if a carry has occurred. *
3328\***************************************************************************/
3329
3330static ARMword Add32(ARMword a1,ARMword a2,int *carry)
3331{
3332 ARMword result = (a1 + a2);
3333 unsigned int uresult = (unsigned int)result;
3334 unsigned int ua1 = (unsigned int)a1;
3335
3336 /* If (result == RdLo) and (state->Reg[nRdLo] == 0),
3337 or (result > RdLo) then we have no carry: */
3338 if ((uresult == ua1) ? (a2 != 0) : (uresult < ua1))
3339 *carry = 1;
3340 else
3341 *carry = 0;
3342
3343 return(result);
3344}
3345
3346/***************************************************************************\
3347* This function does the work of multiplying two 32bit values to give a *
3348* 64bit result. *
3349\***************************************************************************/
3350
3351static unsigned Multiply64(ARMul_State *state,ARMword instr,int msigned,int scc)
3352{
3353 int nRdHi, nRdLo, nRs, nRm; /* operand register numbers */
3354 ARMword RdHi, RdLo, Rm;
3355 int scount; /* cycle count */
3356
3357 nRdHi = BITS(16,19);
3358 nRdLo = BITS(12,15);
3359 nRs = BITS(8,11);
3360 nRm = BITS(0,3);
3361
3362 /* Needed to calculate the cycle count: */
3363 Rm = state->Reg[nRm];
3364
3365 /* Check for illegal operand combinations first: */
3366 if ( nRdHi != 15
3367 && nRdLo != 15
3368 && nRs != 15
3369 && nRm != 15
3370 && nRdHi != nRdLo
3371 && nRdHi != nRm
3372 && nRdLo != nRm)
3373 {
3374 ARMword lo, mid1, mid2, hi; /* intermediate results */
3375 int carry;
3376 ARMword Rs = state->Reg[ nRs ];
3377 int sign = 0;
3378
3379 if (msigned)
3380 {
3381 /* Compute sign of result and adjust operands if necessary. */
3382
3383 sign = (Rm ^ Rs) & 0x80000000;
3384
3385 if (((signed long)Rm) < 0)
3386 Rm = -Rm;
3387
3388 if (((signed long)Rs) < 0)
3389 Rs = -Rs;
3390 }
3391
3392 /* We can split the 32x32 into four 16x16 operations. This ensures
3393 that we do not lose precision on 32bit only hosts: */
3394 lo = ((Rs & 0xFFFF) * (Rm & 0xFFFF));
3395 mid1 = ((Rs & 0xFFFF) * ((Rm >> 16) & 0xFFFF));
3396 mid2 = (((Rs >> 16) & 0xFFFF) * (Rm & 0xFFFF));
3397 hi = (((Rs >> 16) & 0xFFFF) * ((Rm >> 16) & 0xFFFF));
3398
3399 /* We now need to add all of these results together, taking care
3400 to propogate the carries from the additions: */
3401 RdLo = Add32(lo,(mid1 << 16),&carry);
3402 RdHi = carry;
3403 RdLo = Add32(RdLo,(mid2 << 16),&carry);
3404 RdHi += (carry + ((mid1 >> 16) & 0xFFFF) + ((mid2 >> 16) & 0xFFFF) + hi);
3405
3406 if (sign)
3407 {
3408 /* Negate result if necessary. */
3409
3410 RdLo = ~ RdLo;
3411 RdHi = ~ RdHi;
3412 if (RdLo == 0xFFFFFFFF)
3413 {
3414 RdLo = 0;
3415 RdHi += 1;
3416 }
3417 else
3418 RdLo += 1;
3419 }
3420
3421 state->Reg[nRdLo] = RdLo;
3422 state->Reg[nRdHi] = RdHi;
3423
3424 } /* else undefined result */
3425 else fprintf (stderr, "MULTIPLY64 - INVALID ARGUMENTS\n");
3426
3427 if (scc)
3428 {
3429 if ((RdHi == 0) && (RdLo == 0))
3430 ARMul_NegZero(state,RdHi); /* zero value */
3431 else
3432 ARMul_NegZero(state,scc); /* non-zero value */
3433 }
3434
3435 /* The cycle count depends on whether the instruction is a signed or
3436 unsigned multiply, and what bits are clear in the multiplier: */
3437 if (msigned && (Rm & ((unsigned)1 << 31)))
3438 Rm = ~Rm; /* invert the bits to make the check against zero */
3439
3440 if ((Rm & 0xFFFFFF00) == 0)
3441 scount = 1 ;
3442 else if ((Rm & 0xFFFF0000) == 0)
3443 scount = 2 ;
3444 else if ((Rm & 0xFF000000) == 0)
3445 scount = 3 ;
3446 else
3447 scount = 4 ;
3448
3449 return 2 + scount ;
3450}
3451
3452/***************************************************************************\
3453* This function does the work of multiplying two 32bit values and adding *
3454* a 64bit value to give a 64bit result. *
3455\***************************************************************************/
3456
3457static unsigned MultiplyAdd64(ARMul_State *state,ARMword instr,int msigned,int scc)
3458{
3459 unsigned scount;
3460 ARMword RdLo, RdHi;
3461 int nRdHi, nRdLo;
3462 int carry = 0;
3463
3464 nRdHi = BITS(16,19);
3465 nRdLo = BITS(12,15);
3466
3467 RdHi = state->Reg[nRdHi] ;
3468 RdLo = state->Reg[nRdLo] ;
3469
3470 scount = Multiply64(state,instr,msigned,LDEFAULT);
3471
3472 RdLo = Add32(RdLo,state->Reg[nRdLo],&carry);
3473 RdHi = (RdHi + state->Reg[nRdHi]) + carry;
3474
3475 state->Reg[nRdLo] = RdLo;
3476 state->Reg[nRdHi] = RdHi;
3477
3478 if (scc) {
3479 if ((RdHi == 0) && (RdLo == 0))
3480 ARMul_NegZero(state,RdHi); /* zero value */
3481 else
3482 ARMul_NegZero(state,scc); /* non-zero value */
3483 }
3484
3485 return scount + 1; /* extra cycle for addition */
3486}
Empty description
This page took 0.387505 seconds and 4 git commands to generate.