sim/arm/armemu.c

   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 <jsmith@cygnus.com>.
   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 3 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, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include "armdefs.h"
  19 #include "armemu.h"
  20 #include "armos.h"
  21 #include "iwmmxt.h"
  22
  23 static ARMword  GetDPRegRHS         (ARMul_State *, ARMword);
  24 static ARMword  GetDPSRegRHS        (ARMul_State *, ARMword);
  25 static void     WriteR15            (ARMul_State *, ARMword);
  26 static void     WriteSR15           (ARMul_State *, ARMword);
  27 static void     WriteR15Branch      (ARMul_State *, ARMword);
  28 static void     WriteR15Load        (ARMul_State *, ARMword);
  29 static ARMword  GetLSRegRHS         (ARMul_State *, ARMword);
  30 static ARMword  GetLS7RHS           (ARMul_State *, ARMword);
  31 static unsigned LoadWord            (ARMul_State *, ARMword, ARMword);
  32 static unsigned LoadHalfWord        (ARMul_State *, ARMword, ARMword, int);
  33 static unsigned LoadByte            (ARMul_State *, ARMword, ARMword, int);
  34 static unsigned StoreWord           (ARMul_State *, ARMword, ARMword);
  35 static unsigned StoreHalfWord       (ARMul_State *, ARMword, ARMword);
  36 static unsigned StoreByte           (ARMul_State *, ARMword, ARMword);
  37 static void     LoadMult            (ARMul_State *, ARMword, ARMword, ARMword);
  38 static void     StoreMult           (ARMul_State *, ARMword, ARMword, ARMword);
  39 static void     LoadSMult           (ARMul_State *, ARMword, ARMword, ARMword);
  40 static void     StoreSMult          (ARMul_State *, ARMword, ARMword, ARMword);
  41 static unsigned Multiply64          (ARMul_State *, ARMword, int, int);
  42 static unsigned MultiplyAdd64       (ARMul_State *, ARMword, int, int);
  43 static void     Handle_Load_Double  (ARMul_State *, ARMword);
  44 static void     Handle_Store_Double (ARMul_State *, ARMword);
  45
  46 #define LUNSIGNED (0)           /* unsigned operation */
  47 #define LSIGNED   (1)           /* signed operation */
  48 #define LDEFAULT  (0)           /* default : do nothing */
  49 #define LSCC      (1)           /* set condition codes on result */
  50
  51 extern int stop_simulator;
  52
  53 /* Short-hand macros for LDR/STR.  */
  54
  55 /* Store post decrement writeback.  */
  56 #define SHDOWNWB()                                      \
  57   lhs = LHS ;                                           \
  58   if (StoreHalfWord (state, instr, lhs))                \
  59      LSBase = lhs - GetLS7RHS (state, instr);
  60
  61 /* Store post increment writeback.  */
  62 #define SHUPWB()                                        \
  63   lhs = LHS ;                                           \
  64   if (StoreHalfWord (state, instr, lhs))                \
  65      LSBase = lhs + GetLS7RHS (state, instr);
  66
  67 /* Store pre decrement.  */
  68 #define SHPREDOWN()                                     \
  69   (void)StoreHalfWord (state, instr, LHS - GetLS7RHS (state, instr));
  70
  71 /* Store pre decrement writeback.  */
  72 #define SHPREDOWNWB()                                   \
  73   temp = LHS - GetLS7RHS (state, instr);                \
  74   if (StoreHalfWord (state, instr, temp))               \
  75      LSBase = temp;
  76
  77 /* Store pre increment.  */
  78 #define SHPREUP()                                       \
  79   (void)StoreHalfWord (state, instr, LHS + GetLS7RHS (state, instr));
  80
  81 /* Store pre increment writeback.  */
  82 #define SHPREUPWB()                                     \
  83   temp = LHS + GetLS7RHS (state, instr);                \
  84   if (StoreHalfWord (state, instr, temp))               \
  85      LSBase = temp;
  86
  87 /* Load post decrement writeback.  */
  88 #define LHPOSTDOWN()                                    \
  89 {                                                       \
  90   int done = 1;                                         \
  91   lhs = LHS;                                            \
  92   temp = lhs - GetLS7RHS (state, instr);                \
  93                                                         \
  94   switch (BITS (5, 6))                                  \
  95     {                                                   \
  96     case 1: /* H */                                     \
  97       if (LoadHalfWord (state, instr, lhs, LUNSIGNED))  \
  98          LSBase = temp;                                 \
  99       break;                                            \
 100     case 2: /* SB */                                    \
 101       if (LoadByte (state, instr, lhs, LSIGNED))        \
 102          LSBase = temp;                                 \
 103       break;                                            \
 104     case 3: /* SH */                                    \
 105       if (LoadHalfWord (state, instr, lhs, LSIGNED))    \
 106          LSBase = temp;                                 \
 107       break;                                            \
 108     case 0: /* SWP handled elsewhere.  */               \
 109     default:                                            \
 110       done = 0;                                         \
 111       break;                                            \
 112     }                                                   \
 113   if (done)                                             \
 114      break;                                             \
 115 }
 116
 117 /* Load post increment writeback.  */
 118 #define LHPOSTUP()                                      \
 119 {                                                       \
 120   int done = 1;                                         \
 121   lhs = LHS;                                            \
 122   temp = lhs + GetLS7RHS (state, instr);                \
 123                                                         \
 124   switch (BITS (5, 6))                                  \
 125     {                                                   \
 126     case 1: /* H */                                     \
 127       if (LoadHalfWord (state, instr, lhs, LUNSIGNED))  \
 128          LSBase = temp;                                 \
 129       break;                                            \
 130     case 2: /* SB */                                    \
 131       if (LoadByte (state, instr, lhs, LSIGNED))        \
 132          LSBase = temp;                                 \
 133       break;                                            \
 134     case 3: /* SH */                                    \
 135       if (LoadHalfWord (state, instr, lhs, LSIGNED))    \
 136          LSBase = temp;                                 \
 137       break;                                            \
 138     case 0: /* SWP handled elsewhere.  */               \
 139     default:                                            \
 140       done = 0;                                         \
 141       break;                                            \
 142     }                                                   \
 143   if (done)                                             \
 144      break;                                             \
 145 }
 146
 147 /* Load pre decrement.  */
 148 #define LHPREDOWN()                                             \
 149 {                                                               \
 150   int done = 1;                                                 \
 151                                                                 \
 152   temp = LHS - GetLS7RHS (state, instr);                        \
 153   switch (BITS (5, 6))                                          \
 154     {                                                           \
 155     case 1: /* H */                                             \
 156       (void) LoadHalfWord (state, instr, temp, LUNSIGNED);      \
 157       break;                                                    \
 158     case 2: /* SB */                                            \
 159       (void) LoadByte (state, instr, temp, LSIGNED);            \
 160       break;                                                    \
 161     case 3: /* SH */                                            \
 162       (void) LoadHalfWord (state, instr, temp, LSIGNED);        \
 163       break;                                                    \
 164     case 0:                                                     \
 165       /* 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                                                                 \
 179   temp = LHS - GetLS7RHS (state, instr);                        \
 180   switch (BITS (5, 6))                                          \
 181     {                                                           \
 182     case 1: /* H */                                             \
 183       if (LoadHalfWord (state, instr, temp, LUNSIGNED))         \
 184          LSBase = temp;                                         \
 185       break;                                                    \
 186     case 2: /* SB */                                            \
 187       if (LoadByte (state, instr, temp, LSIGNED))               \
 188          LSBase = temp;                                         \
 189       break;                                                    \
 190     case 3: /* SH */                                            \
 191       if (LoadHalfWord (state, instr, temp, LSIGNED))           \
 192          LSBase = temp;                                         \
 193       break;                                                    \
 194     case 0:                                                     \
 195       /* SWP handled elsewhere.  */                             \
 196     default:                                                    \
 197       done = 0;                                                 \
 198       break;                                                    \
 199     }                                                           \
 200   if (done)                                                     \
 201      break;                                                     \
 202 }
 203
 204 /* Load pre increment.  */
 205 #define LHPREUP()                                               \
 206 {                                                               \
 207   int done = 1;                                                 \
 208                                                                 \
 209   temp = LHS + GetLS7RHS (state, instr);                        \
 210   switch (BITS (5, 6))                                          \
 211     {                                                           \
 212     case 1: /* H */                                             \
 213       (void) LoadHalfWord (state, instr, temp, LUNSIGNED);      \
 214       break;                                                    \
 215     case 2: /* SB */                                            \
 216       (void) LoadByte (state, instr, temp, LSIGNED);            \
 217       break;                                                    \
 218     case 3: /* SH */                                            \
 219       (void) LoadHalfWord (state, instr, temp, LSIGNED);        \
 220       break;                                                    \
 221     case 0:                                                     \
 222       /* SWP handled elsewhere.  */                             \
 223     default:                                                    \
 224       done = 0;                                                 \
 225       break;                                                    \
 226     }                                                           \
 227   if (done)                                                     \
 228      break;                                                     \
 229 }
 230
 231 /* Load pre increment writeback.  */
 232 #define LHPREUPWB()                                             \
 233 {                                                               \
 234   int done = 1;                                                 \
 235                                                                 \
 236   temp = LHS + GetLS7RHS (state, instr);                        \
 237   switch (BITS (5, 6))                                          \
 238     {                                                           \
 239     case 1: /* H */                                             \
 240       if (LoadHalfWord (state, instr, temp, LUNSIGNED))         \
 241         LSBase = temp;                                          \
 242       break;                                                    \
 243     case 2: /* SB */                                            \
 244       if (LoadByte (state, instr, temp, LSIGNED))               \
 245         LSBase = temp;                                          \
 246       break;                                                    \
 247     case 3: /* SH */                                            \
 248       if (LoadHalfWord (state, instr, temp, LSIGNED))           \
 249         LSBase = temp;                                          \
 250       break;                                                    \
 251     case 0:                                                     \
 252       /* SWP handled elsewhere.  */                             \
 253     default:                                                    \
 254       done = 0;                                                 \
 255       break;                                                    \
 256     }                                                           \
 257   if (done)                                                     \
 258      break;                                                     \
 259 }
 260
 261 /* Attempt to emulate an ARMv6 instruction.
 262    Returns non-zero upon success.  */
 263
 264 #ifdef MODE32
 265 static int
 266 handle_v6_insn (ARMul_State * state, ARMword instr)
 267 {
 268   ARMword val;
 269   ARMword Rd;
 270   ARMword Rm;
 271   ARMword Rn;
 272
 273   switch (BITS (20, 27))
 274     {
 275 #if 0
 276     case 0x03: printf ("Unhandled v6 insn: ldr\n"); break;
 277     case 0x04: printf ("Unhandled v6 insn: umaal\n"); break;
 278     case 0x06: printf ("Unhandled v6 insn: mls/str\n"); break;
 279     case 0x16: printf ("Unhandled v6 insn: smi\n"); break;
 280     case 0x18: printf ("Unhandled v6 insn: strex\n"); break;
 281     case 0x19: printf ("Unhandled v6 insn: ldrex\n"); break;
 282     case 0x1a: printf ("Unhandled v6 insn: strexd\n"); break;
 283     case 0x1b: printf ("Unhandled v6 insn: ldrexd\n"); break;
 284     case 0x1c: printf ("Unhandled v6 insn: strexb\n"); break;
 285     case 0x1d: printf ("Unhandled v6 insn: ldrexb\n"); break;
 286     case 0x1e: printf ("Unhandled v6 insn: strexh\n"); break;
 287     case 0x1f: printf ("Unhandled v6 insn: ldrexh\n"); break;
 288     case 0x32: printf ("Unhandled v6 insn: nop/sev/wfe/wfi/yield\n"); break;
 289     case 0x3f: printf ("Unhandled v6 insn: rbit\n"); break;
 290 #endif
 291     case 0x61: printf ("Unhandled v6 insn: sadd/ssub\n"); break;
 292     case 0x63: printf ("Unhandled v6 insn: shadd/shsub\n"); break;
 293     case 0x6c: printf ("Unhandled v6 insn: uxtb16/uxtab16\n"); break;
 294     case 0x70: printf ("Unhandled v6 insn: smuad/smusd/smlad/smlsd\n"); break;
 295     case 0x74: printf ("Unhandled v6 insn: smlald/smlsld\n"); break;
 296     case 0x75: printf ("Unhandled v6 insn: smmla/smmls/smmul\n"); break;
 297     case 0x78: printf ("Unhandled v6 insn: usad/usada8\n"); break;
 298
 299     case 0x30:
 300       {
 301         /* MOVW<c> <Rd>,#<imm16>
 302            instr[31,28] = cond
 303            instr[27,20] = 0011 0000
 304            instr[19,16] = imm4
 305            instr[15,12] = Rd
 306            instr[11, 0] = imm12.  */
 307         Rd = BITS (12, 15);
 308         val = (BITS (16, 19) << 12) | BITS (0, 11);
 309         state->Reg[Rd] = val;
 310         return 1;
 311       }
 312
 313     case 0x34:
 314       {
 315         /* MOVT<c> <Rd>,#<imm16>
 316            instr[31,28] = cond
 317            instr[27,20] = 0011 0100
 318            instr[19,16] = imm4
 319            instr[15,12] = Rd
 320            instr[11, 0] = imm12.  */
 321         Rd = BITS (12, 15);
 322         val = (BITS (16, 19) << 12) | BITS (0, 11);
 323         state->Reg[Rd] &= 0xFFFF;
 324         state->Reg[Rd] |= val << 16;
 325         return 1;
 326       }
 327
 328     case 0x62:
 329       {
 330         ARMword val1;
 331         ARMword val2;
 332         ARMsword n, m, r;
 333         int i;
 334
 335         Rd = BITS (12, 15);
 336         Rn = BITS (16, 19);
 337         Rm = BITS (0, 3);
 338
 339         if (Rd == 15 || Rn == 15 || Rm == 15)
 340           break;
 341
 342         val1 = state->Reg[Rn];
 343         val2 = state->Reg[Rm];
 344
 345         switch (BITS (4, 11))
 346           {
 347           case 0xF1: /* QADD16<c> <Rd>,<Rn>,<Rm>.  */
 348             state->Reg[Rd] = 0;
 349
 350             for (i = 0; i < 32; i+= 16)
 351               {
 352                 n = (val1 >> i) & 0xFFFF;
 353                 if (n & 0x8000)
 354                   n |= -(1 << 16);
 355
 356                 m = (val2 >> i) & 0xFFFF;
 357                 if (m & 0x8000)
 358                   m |= -(1 << 16);
 359
 360                 r = n + m;
 361
 362                 if (r > 0x7FFF)
 363                   r = 0x7FFF;
 364                 else if (r < -(0x8000))
 365                   r = - 0x8000;
 366
 367                 state->Reg[Rd] |= (r & 0xFFFF) << i;
 368               }
 369             return 1;
 370
 371           case 0xF3: /* QASX<c> <Rd>,<Rn>,<Rm>.  */
 372             n = val1 & 0xFFFF;
 373             if (n & 0x8000)
 374               n |= -(1 << 16);
 375
 376             m = (val2 >> 16) & 0xFFFF;
 377             if (m & 0x8000)
 378               m |= -(1 << 16);
 379
 380             r = n - m;
 381
 382             if (r > 0x7FFF)
 383               r = 0x7FFF;
 384             else if (r < -(0x8000))
 385               r = - 0x8000;
 386
 387             state->Reg[Rd] = (r & 0xFFFF);
 388
 389             n = (val1 >> 16) & 0xFFFF;
 390             if (n & 0x8000)
 391               n |= -(1 << 16);
 392
 393             m = val2 & 0xFFFF;
 394             if (m & 0x8000)
 395               m |= -(1 << 16);
 396
 397             r = n + m;
 398
 399             if (r > 0x7FFF)
 400               r = 0x7FFF;
 401             else if (r < -(0x8000))
 402               r = - 0x8000;
 403
 404             state->Reg[Rd] |= (r & 0xFFFF) << 16;
 405             return 1;
 406
 407           case 0xF5: /* QSAX<c> <Rd>,<Rn>,<Rm>.  */
 408             n = val1 & 0xFFFF;
 409             if (n & 0x8000)
 410               n |= -(1 << 16);
 411
 412             m = (val2 >> 16) & 0xFFFF;
 413             if (m & 0x8000)
 414               m |= -(1 << 16);
 415
 416             r = n + m;
 417
 418             if (r > 0x7FFF)
 419               r = 0x7FFF;
 420             else if (r < -(0x8000))
 421               r = - 0x8000;
 422
 423             state->Reg[Rd] = (r & 0xFFFF);
 424
 425             n = (val1 >> 16) & 0xFFFF;
 426             if (n & 0x8000)
 427               n |= -(1 << 16);
 428
 429             m = val2 & 0xFFFF;
 430             if (m & 0x8000)
 431               m |= -(1 << 16);
 432
 433             r = n - m;
 434
 435             if (r > 0x7FFF)
 436               r = 0x7FFF;
 437             else if (r < -(0x8000))
 438               r = - 0x8000;
 439
 440             state->Reg[Rd] |= (r & 0xFFFF) << 16;
 441             return 1;
 442
 443           case 0xF7: /* QSUB16<c> <Rd>,<Rn>,<Rm>.  */
 444             state->Reg[Rd] = 0;
 445
 446             for (i = 0; i < 32; i+= 16)
 447               {
 448                 n = (val1 >> i) & 0xFFFF;
 449                 if (n & 0x8000)
 450                   n |= -(1 << 16);
 451
 452                 m = (val2 >> i) & 0xFFFF;
 453                 if (m & 0x8000)
 454                   m |= -(1 << 16);
 455
 456                 r = n - m;
 457
 458                 if (r > 0x7FFF)
 459                   r = 0x7FFF;
 460                 else if (r < -(0x8000))
 461                   r = - 0x8000;
 462
 463                 state->Reg[Rd] |= (r & 0xFFFF) << i;
 464               }
 465             return 1;
 466
 467           case 0xF9: /* QADD8<c> <Rd>,<Rn>,<Rm>.  */
 468             state->Reg[Rd] = 0;
 469
 470             for (i = 0; i < 32; i+= 8)
 471               {
 472                 n = (val1 >> i) & 0xFF;
 473                 if (n & 0x80)
 474                   n |= - (1 << 8);
 475
 476                 m = (val2 >> i) & 0xFF;
 477                 if (m & 0x80)
 478                   m |= - (1 << 8);
 479
 480                 r = n + m;
 481
 482                 if (r > 127)
 483                   r = 127;
 484                 else if (r < -128)
 485                   r = -128;
 486
 487                 state->Reg[Rd] |= (r & 0xFF) << i;
 488               }
 489             return 1;
 490
 491           case 0xFF: /* QSUB8<c> <Rd>,<Rn>,<Rm>.  */
 492             state->Reg[Rd] = 0;
 493
 494             for (i = 0; i < 32; i+= 8)
 495               {
 496                 n = (val1 >> i) & 0xFF;
 497                 if (n & 0x80)
 498                   n |= - (1 << 8);
 499
 500                 m = (val2 >> i) & 0xFF;
 501                 if (m & 0x80)
 502                   m |= - (1 << 8);
 503
 504                 r = n - m;
 505
 506                 if (r > 127)
 507                   r = 127;
 508                 else if (r < -128)
 509                   r = -128;
 510
 511                 state->Reg[Rd] |= (r & 0xFF) << i;
 512               }
 513             return 1;
 514
 515           default:
 516             break;
 517           }
 518         break;
 519       }
 520
 521     case 0x65:
 522       {
 523         ARMword valn;
 524         ARMword valm;
 525         ARMword res1, res2, res3, res4;
 526
 527         /* U{ADD|SUB}{8|16}<c> <Rd>, <Rn>, <Rm>
 528            instr[31,28] = cond
 529            instr[27,20] = 0110 0101
 530            instr[19,16] = Rn
 531            instr[15,12] = Rd
 532            instr[11, 8] = 1111
 533            instr[ 7, 4] = opcode: UADD8 (1001), UADD16 (0001), USUB8 (1111), USUB16 (0111)
 534            instr[ 3, 0] = Rm.  */
 535         if (BITS (8, 11) != 0xF)
 536           break;
 537
 538         Rn = BITS (16, 19);
 539         Rd = BITS (12, 15);
 540         Rm = BITS (0, 3);
 541
 542         if (Rn == 15 || Rd == 15 || Rm == 15)
 543           {
 544             ARMul_UndefInstr (state, instr);
 545             state->Emulate = FALSE;
 546             break;
 547           }
 548
 549         valn = state->Reg[Rn];
 550         valm = state->Reg[Rm];
 551
 552         switch (BITS (4, 7))
 553           {
 554           case 1:  /* UADD16.  */
 555             res1 = (valn & 0xFFFF) + (valm & 0xFFFF);
 556             if (res1 > 0xFFFF)
 557               state->Cpsr |= (GE0 | GE1);
 558             else
 559               state->Cpsr &= ~ (GE0 | GE1);
 560
 561             res2 = (valn >> 16) + (valm >> 16);
 562             if (res2 > 0xFFFF)
 563               state->Cpsr |= (GE2 | GE3);
 564             else
 565               state->Cpsr &= ~ (GE2 | GE3);
 566
 567             state->Reg[Rd] = (res1 & 0xFFFF) | (res2 << 16);
 568             return 1;
 569
 570           case 7:  /* USUB16.  */
 571             res1 = (valn & 0xFFFF) - (valm & 0xFFFF);
 572             if (res1 & 0x800000)
 573               state->Cpsr |= (GE0 | GE1);
 574             else
 575               state->Cpsr &= ~ (GE0 | GE1);
 576
 577             res2 = (valn >> 16) - (valm >> 16);
 578             if (res2 & 0x800000)
 579               state->Cpsr |= (GE2 | GE3);
 580             else
 581               state->Cpsr &= ~ (GE2 | GE3);
 582
 583             state->Reg[Rd] = (res1 & 0xFFFF) | (res2 << 16);
 584             return 1;
 585
 586           case 9:  /* UADD8.  */
 587             res1 = (valn & 0xFF) + (valm & 0xFF);
 588             if (res1 > 0xFF)
 589               state->Cpsr |= GE0;
 590             else
 591               state->Cpsr &= ~ GE0;
 592
 593             res2 = ((valn >> 8) & 0xFF) + ((valm >> 8) & 0xFF);
 594             if (res2 > 0xFF)
 595               state->Cpsr |= GE1;
 596             else
 597               state->Cpsr &= ~ GE1;
 598
 599             res3 = ((valn >> 16) & 0xFF) + ((valm >> 16) & 0xFF);
 600             if (res3 > 0xFF)
 601               state->Cpsr |= GE2;
 602             else
 603               state->Cpsr &= ~ GE2;
 604
 605             res4 = (valn >> 24) + (valm >> 24);
 606             if (res4 > 0xFF)
 607               state->Cpsr |= GE3;
 608             else
 609               state->Cpsr &= ~ GE3;
 610
 611             state->Reg[Rd] = (res1 & 0xFF) | ((res2 << 8) & 0xFF00)
 612               | ((res3 << 16) & 0xFF0000) | (res4 << 24);
 613             return 1;
 614
 615           case 15: /* USUB8.  */
 616             res1 = (valn & 0xFF) - (valm & 0xFF);
 617             if (res1 & 0x800000)
 618               state->Cpsr |= GE0;
 619             else
 620               state->Cpsr &= ~ GE0;
 621
 622             res2 = ((valn >> 8) & 0XFF) - ((valm >> 8) & 0xFF);
 623             if (res2 & 0x800000)
 624               state->Cpsr |= GE1;
 625             else
 626               state->Cpsr &= ~ GE1;
 627
 628             res3 = ((valn >> 16) & 0XFF) - ((valm >> 16) & 0xFF);
 629             if (res3 & 0x800000)
 630               state->Cpsr |= GE2;
 631             else
 632               state->Cpsr &= ~ GE2;
 633
 634             res4 = (valn >> 24) - (valm >> 24) ;
 635             if (res4 & 0x800000)
 636               state->Cpsr |= GE3;
 637             else
 638               state->Cpsr &= ~ GE3;
 639
 640             state->Reg[Rd] = (res1 & 0xFF) | ((res2 << 8) & 0xFF00)
 641               | ((res3 << 16) & 0xFF0000) | (res4 << 24);
 642             return 1;
 643
 644           default:
 645             break;
 646           }
 647         break;
 648       }
 649
 650     case 0x68:
 651       {
 652         ARMword res;
 653
 654         /* PKHBT<c> <Rd>,<Rn>,<Rm>{,LSL #<imm>}
 655            PKHTB<c> <Rd>,<Rn>,<Rm>{,ASR #<imm>}
 656            SXTAB16<c> <Rd>,<Rn>,<Rm>{,<rotation>}
 657            SXTB16<c> <Rd>,<Rm>{,<rotation>}
 658            SEL<c> <Rd>,<Rn>,<Rm>
 659
 660            instr[31,28] = cond
 661            instr[27,20] = 0110 1000
 662            instr[19,16] = Rn
 663            instr[15,12] = Rd
 664            instr[11, 7] = imm5 (PKH), 11111 (SEL), rr000 (SXTAB16 & SXTB16),
 665            instr[6]     = tb (PKH), 0 (SEL), 1 (SXT)
 666            instr[5]     = opcode: PKH (0), SEL/SXT (1)
 667            instr[4]     = 1
 668            instr[ 3, 0] = Rm.  */
 669
 670         if (BIT (4) != 1)
 671           break;
 672
 673         if (BIT (5) == 0)
 674           {
 675             /* FIXME: Add implementation of PKH.  */
 676             fprintf (stderr, "PKH: NOT YET IMPLEMENTED\n");
 677             ARMul_UndefInstr (state, instr);
 678             break;
 679           }
 680
 681         if (BIT (6) == 1)
 682           {
 683             /* FIXME: Add implementation of SXT.  */
 684             fprintf (stderr, "SXT: NOT YET IMPLEMENTED\n");
 685             ARMul_UndefInstr (state, instr);
 686             break;
 687           }
 688
 689         Rn = BITS (16, 19);
 690         Rd = BITS (12, 15);
 691         Rm = BITS (0, 3);
 692         if (Rn == 15 || Rm == 15 || Rd == 15)
 693           {
 694             ARMul_UndefInstr (state, instr);
 695             state->Emulate = FALSE;
 696             break;
 697           }
 698
 699         res  = (state->Reg[(state->Cpsr & GE0) ? Rn : Rm]) & 0xFF;
 700         res |= (state->Reg[(state->Cpsr & GE1) ? Rn : Rm]) & 0xFF00;
 701         res |= (state->Reg[(state->Cpsr & GE2) ? Rn : Rm]) & 0xFF0000;
 702         res |= (state->Reg[(state->Cpsr & GE3) ? Rn : Rm]) & 0xFF000000;
 703         state->Reg[Rd] = res;
 704         return 1;
 705       }
 706
 707     case 0x6a:
 708       {
 709         int ror = -1;
 710
 711         switch (BITS (4, 11))
 712           {
 713           case 0x07: ror = 0; break;
 714           case 0x47: ror = 8; break;
 715           case 0x87: ror = 16; break;
 716           case 0xc7: ror = 24; break;
 717
 718           case 0x01:
 719           case 0xf3:
 720             printf ("Unhandled v6 insn: ssat\n");
 721             return 0;
 722
 723           default:
 724             break;
 725           }
 726
 727         if (ror == -1)
 728           {
 729             if (BITS (4, 6) == 0x7)
 730               {
 731                 printf ("Unhandled v6 insn: ssat\n");
 732                 return 0;
 733               }
 734             break;
 735           }
 736
 737         Rm = ((state->Reg[BITS (0, 3)] >> ror) & 0xFF);
 738         if (Rm & 0x80)
 739           Rm |= 0xffffff00;
 740
 741         if (BITS (16, 19) == 0xf)
 742            /* SXTB */
 743           state->Reg[BITS (12, 15)] = Rm;
 744         else
 745           /* SXTAB */
 746           state->Reg[BITS (12, 15)] += Rm;
 747       }
 748       return 1;
 749
 750     case 0x6b:
 751       {
 752         int ror = -1;
 753
 754         switch (BITS (4, 11))
 755           {
 756           case 0x07: ror = 0; break;
 757           case 0x47: ror = 8; break;
 758           case 0x87: ror = 16; break;
 759           case 0xc7: ror = 24; break;
 760
 761           case 0xf3:
 762             {
 763               /* REV<c> <Rd>,<Rm>
 764                  instr[31,28] = cond
 765                  instr[27,20] = 0110 1011
 766                  instr[19,16] = 1111
 767                  instr[15,12] = Rd
 768                  instr[11, 4] = 1111 0011
 769                  instr[ 3, 0] = Rm.  */
 770               if (BITS (16, 19) != 0xF)
 771                 break;
 772
 773               Rd = BITS (12, 15);
 774               Rm = BITS (0, 3);
 775               if (Rd == 15 || Rm == 15)
 776                 {
 777                   ARMul_UndefInstr (state, instr);
 778                   state->Emulate = FALSE;
 779                   break;
 780                 }
 781
 782               val = state->Reg[Rm] << 24;
 783               val |= ((state->Reg[Rm] << 8) & 0xFF0000);
 784               val |= ((state->Reg[Rm] >> 8) & 0xFF00);
 785               val |= ((state->Reg[Rm] >> 24));
 786               state->Reg[Rd] = val;
 787               return 1;
 788             }
 789
 790           case 0xfb:
 791             {
 792               /* REV16<c> <Rd>,<Rm>.  */
 793               if (BITS (16, 19) != 0xF)
 794                 break;
 795
 796               Rd = BITS (12, 15);
 797               Rm = BITS (0, 3);
 798               if (Rd == 15 || Rm == 15)
 799                 {
 800                   ARMul_UndefInstr (state, instr);
 801                   state->Emulate = FALSE;
 802                   break;
 803                 }
 804
 805               val = 0;
 806               val |= ((state->Reg[Rm] >> 8) & 0x00FF00FF);
 807               val |= ((state->Reg[Rm] << 8) & 0xFF00FF00);
 808               state->Reg[Rd] = val;
 809               return 1;
 810             }
 811
 812           default:
 813             break;
 814           }
 815
 816         if (ror == -1)
 817           break;
 818
 819         Rm = ((state->Reg[BITS (0, 3)] >> ror) & 0xFFFF);
 820         if (Rm & 0x8000)
 821           Rm |= 0xffff0000;
 822
 823         if (BITS (16, 19) == 0xf)
 824           /* SXTH */
 825           state->Reg[BITS (12, 15)] = Rm;
 826         else
 827           /* SXTAH */
 828           state->Reg[BITS (12, 15)] = state->Reg[BITS (16, 19)] + Rm;
 829       }
 830       return 1;
 831
 832     case 0x6e:
 833       {
 834         int ror = -1;
 835
 836         switch (BITS (4, 11))
 837           {
 838           case 0x07: ror = 0; break;
 839           case 0x47: ror = 8; break;
 840           case 0x87: ror = 16; break;
 841           case 0xc7: ror = 24; break;
 842
 843           case 0x01:
 844           case 0xf3:
 845             printf ("Unhandled v6 insn: usat\n");
 846             return 0;
 847
 848           default:
 849             break;
 850           }
 851
 852         if (ror == -1)
 853           {
 854             if (BITS (4, 6) == 0x7)
 855               {
 856                 printf ("Unhandled v6 insn: usat\n");
 857                 return 0;
 858               }
 859             break;
 860           }
 861
 862         Rm = ((state->Reg[BITS (0, 3)] >> ror) & 0xFF);
 863
 864         if (BITS (16, 19) == 0xf)
 865           /* UXTB */
 866           state->Reg[BITS (12, 15)] = Rm;
 867         else
 868           /* UXTAB */
 869           state->Reg[BITS (12, 15)] = state->Reg[BITS (16, 19)] + Rm;
 870       }
 871       return 1;
 872
 873     case 0x6f:
 874       {
 875         int i;
 876         int ror = -1;
 877
 878         switch (BITS (4, 11))
 879           {
 880           case 0x07: ror = 0; break;
 881           case 0x47: ror = 8; break;
 882           case 0x87: ror = 16; break;
 883           case 0xc7: ror = 24; break;
 884
 885           case 0xf3: /* RBIT */
 886             if (BITS (16, 19) != 0xF)
 887               break;
 888             Rd = BITS (12, 15);
 889             state->Reg[Rd] = 0;
 890             Rm = state->Reg[BITS (0, 3)];
 891             for (i = 0; i < 32; i++)
 892               if (Rm & (1 << i))
 893                 state->Reg[Rd] |= (1 << (31 - i));
 894             return 1;
 895
 896           case 0xfb:
 897             printf ("Unhandled v6 insn: revsh\n");
 898             return 0;
 899
 900           default:
 901             break;
 902           }
 903
 904         if (ror == -1)
 905           break;
 906
 907         Rm = ((state->Reg[BITS (0, 3)] >> ror) & 0xFFFF);
 908
 909         if (BITS (16, 19) == 0xf)
 910           /* UXT */
 911           state->Reg[BITS (12, 15)] = Rm;
 912         else
 913           /* UXTAH */
 914           state->Reg[BITS (12, 15)] = state->Reg [BITS (16, 19)] + Rm;
 915       }
 916       return 1;
 917
 918     case 0x7c:
 919     case 0x7d:
 920       {
 921         int lsb;
 922         int msb;
 923         ARMword mask;
 924
 925         /* BFC<c> <Rd>,#<lsb>,#<width>
 926            BFI<c> <Rd>,<Rn>,#<lsb>,#<width>
 927
 928            instr[31,28] = cond
 929            instr[27,21] = 0111 110
 930            instr[20,16] = msb
 931            instr[15,12] = Rd
 932            instr[11, 7] = lsb
 933            instr[ 6, 4] = 001 1111
 934            instr[ 3, 0] = Rn (BFI) / 1111 (BFC).  */
 935
 936         if (BITS (4, 6) != 0x1)
 937           break;
 938
 939         Rd = BITS (12, 15);
 940         if (Rd == 15)
 941           {
 942             ARMul_UndefInstr (state, instr);
 943             state->Emulate = FALSE;
 944           }
 945
 946         lsb = BITS (7, 11);
 947         msb = BITS (16, 20);
 948         if (lsb > msb)
 949           {
 950             ARMul_UndefInstr (state, instr);
 951             state->Emulate = FALSE;
 952           }
 953
 954         mask = -(1 << lsb);
 955         mask &= ~(-(1 << (msb + 1)));
 956         state->Reg[Rd] &= ~ mask;
 957
 958         Rn = BITS (0, 3);
 959         if (Rn != 0xF)
 960           {
 961             ARMword val = state->Reg[Rn] & ~(-(1 << ((msb + 1) - lsb)));
 962             state->Reg[Rd] |= val << lsb;
 963           }
 964         return 1;
 965       }
 966
 967     case 0x7b:
 968     case 0x7a: /* SBFX<c> <Rd>,<Rn>,#<lsb>,#<width>.  */
 969       {
 970         int lsb;
 971         int widthm1;
 972         ARMsword sval;
 973
 974         if (BITS (4, 6) != 0x5)
 975           break;
 976
 977         Rd = BITS (12, 15);
 978         if (Rd == 15)
 979           {
 980             ARMul_UndefInstr (state, instr);
 981             state->Emulate = FALSE;
 982           }
 983
 984         Rn = BITS (0, 3);
 985         if (Rn == 15)
 986           {
 987             ARMul_UndefInstr (state, instr);
 988             state->Emulate = FALSE;
 989           }
 990
 991         lsb = BITS (7, 11);
 992         widthm1 = BITS (16, 20);
 993
 994         sval = state->Reg[Rn];
 995         sval <<= (31 - (lsb + widthm1));
 996         sval >>= (31 - widthm1);
 997         state->Reg[Rd] = sval;
 998
 999         return 1;
1000       }
1001
1002     case 0x7f:
1003     case 0x7e:
1004       {
1005         int lsb;
1006         int widthm1;
1007
1008         /* UBFX<c> <Rd>,<Rn>,#<lsb>,#<width>
1009            instr[31,28] = cond
1010            instr[27,21] = 0111 111
1011            instr[20,16] = widthm1
1012            instr[15,12] = Rd
1013            instr[11, 7] = lsb
1014            instr[ 6, 4] = 101
1015            instr[ 3, 0] = Rn.  */
1016
1017         if (BITS (4, 6) != 0x5)
1018           break;
1019
1020         Rd = BITS (12, 15);
1021         if (Rd == 15)
1022           {
1023             ARMul_UndefInstr (state, instr);
1024             state->Emulate = FALSE;
1025           }
1026
1027         Rn = BITS (0, 3);
1028         if (Rn == 15)
1029           {
1030             ARMul_UndefInstr (state, instr);
1031             state->Emulate = FALSE;
1032           }
1033
1034         lsb = BITS (7, 11);
1035         widthm1 = BITS (16, 20);
1036
1037         val = state->Reg[Rn];
1038         val >>= lsb;
1039         val &= ~(-(1 << (widthm1 + 1)));
1040
1041         state->Reg[Rd] = val;
1042
1043         return 1;
1044       }
1045 #if 0
1046     case 0x84: printf ("Unhandled v6 insn: srs\n"); break;
1047 #endif
1048     default:
1049       break;
1050     }
1051   printf ("Unhandled v6 insn: UNKNOWN: %08x\n", instr);
1052   return 0;
1053 }
1054 #endif
1055
1056 static void
1057 handle_VFP_move (ARMul_State * state, ARMword instr)
1058 {
1059   switch (BITS (20, 27))
1060     {
1061     case 0xC4:
1062     case 0xC5:
1063       switch (BITS (4, 11))
1064         {
1065         case 0xA1:
1066         case 0xA3:
1067           {
1068             /* VMOV two core <-> two VFP single precision.  */
1069             int sreg = (BITS (0, 3) << 1) | BIT (5);
1070
1071             if (BIT (20))
1072               {
1073                 state->Reg[BITS (12, 15)] = VFP_uword (sreg);
1074                 state->Reg[BITS (16, 19)] = VFP_uword (sreg + 1);
1075               }
1076             else
1077               {
1078                 VFP_uword (sreg)     = state->Reg[BITS (12, 15)];
1079                 VFP_uword (sreg + 1) = state->Reg[BITS (16, 19)];
1080               }
1081           }
1082           break;
1083
1084         case 0xB1:
1085         case 0xB3:
1086           {
1087             /* VMOV two core <-> VFP double precision.  */
1088             int dreg = BITS (0, 3) | (BIT (5) << 4);
1089
1090             if (BIT (20))
1091               {
1092                 if (trace)
1093                   fprintf (stderr, " VFP: VMOV: r%d r%d <= d%d\n",
1094                            BITS (12, 15), BITS (16, 19), dreg);
1095
1096                 state->Reg[BITS (12, 15)] = VFP_dword (dreg);
1097                 state->Reg[BITS (16, 19)] = VFP_dword (dreg) >> 32;
1098               }
1099             else
1100               {
1101                 VFP_dword (dreg) = state->Reg[BITS (16, 19)];
1102                 VFP_dword (dreg) <<= 32;
1103                 VFP_dword (dreg) |= state->Reg[BITS (12, 15)];
1104
1105                 if (trace)
1106                   fprintf (stderr, " VFP: VMOV: d%d <= r%d r%d : %g\n",
1107                            dreg, BITS (16, 19), BITS (12, 15),
1108                            VFP_dval (dreg));
1109               }
1110           }
1111           break;
1112
1113         default:
1114           fprintf (stderr, "SIM: VFP: Unimplemented move insn %x\n", BITS (20, 27));
1115           break;
1116         }
1117       break;
1118
1119     case 0xe0:
1120     case 0xe1:
1121       /* VMOV single core <-> VFP single precision.  */
1122       if (BITS (0, 6) != 0x10 || BITS (8, 11) != 0xA)
1123         fprintf (stderr, "SIM: VFP: Unimplemented move insn %x\n", BITS (20, 27));
1124       else
1125         {
1126           int sreg = (BITS (16, 19) << 1) | BIT (7);
1127
1128           if (BIT (20))
1129             state->Reg[DESTReg] = VFP_uword (sreg);
1130           else
1131             VFP_uword (sreg) = state->Reg[DESTReg];
1132         }
1133       break;
1134
1135     default:
1136       fprintf (stderr, "SIM: VFP: Unimplemented move insn %x\n", BITS (20, 27));
1137       return;
1138     }
1139 }
1140
1141 /* EMULATION of ARM6.  */
1142
1143 /* The PC pipeline value depends on whether ARM
1144    or Thumb instructions are being executed.  */
1145 ARMword isize;
1146
1147 ARMword
1148 #ifdef MODE32
1149 ARMul_Emulate32 (ARMul_State * state)
1150 #else
1151 ARMul_Emulate26 (ARMul_State * state)
1152 #endif
1153 {
1154   ARMword instr;        /* The current instruction.  */
1155   ARMword dest = 0;     /* Almost the DestBus.  */
1156   ARMword temp;         /* Ubiquitous third hand.  */
1157   ARMword pc = 0;       /* The address of the current instruction.  */
1158   ARMword lhs;          /* Almost the ABus and BBus.  */
1159   ARMword rhs;
1160   ARMword decoded = 0;  /* Instruction pipeline.  */
1161   ARMword loaded = 0;
1162
1163   /* Execute the next instruction.  */
1164
1165   if (state->NextInstr < PRIMEPIPE)
1166     {
1167       decoded = state->decoded;
1168       loaded = state->loaded;
1169       pc = state->pc;
1170     }
1171
1172   do
1173     {
1174       /* Just keep going.  */
1175       isize = INSN_SIZE;
1176
1177       switch (state->NextInstr)
1178         {
1179         case SEQ:
1180           /* Advance the pipeline, and an S cycle.  */
1181           state->Reg[15] += isize;
1182           pc += isize;
1183           instr = decoded;
1184           decoded = loaded;
1185           loaded = ARMul_LoadInstrS (state, pc + (isize * 2), isize);
1186           break;
1187
1188         case NONSEQ:
1189           /* Advance the pipeline, and an N cycle.  */
1190           state->Reg[15] += isize;
1191           pc += isize;
1192           instr = decoded;
1193           decoded = loaded;
1194           loaded = ARMul_LoadInstrN (state, pc + (isize * 2), isize);
1195           NORMALCYCLE;
1196           break;
1197
1198         case PCINCEDSEQ:
1199           /* Program counter advanced, and an S cycle.  */
1200           pc += isize;
1201           instr = decoded;
1202           decoded = loaded;
1203           loaded = ARMul_LoadInstrS (state, pc + (isize * 2), isize);
1204           NORMALCYCLE;
1205           break;
1206
1207         case PCINCEDNONSEQ:
1208           /* Program counter advanced, and an N cycle.  */
1209           pc += isize;
1210           instr = decoded;
1211           decoded = loaded;
1212           loaded = ARMul_LoadInstrN (state, pc + (isize * 2), isize);
1213           NORMALCYCLE;
1214           break;
1215
1216         case RESUME:
1217           /* The program counter has been changed.  */
1218           pc = state->Reg[15];
1219 #ifndef MODE32
1220           pc = pc & R15PCBITS;
1221 #endif
1222           state->Reg[15] = pc + (isize * 2);
1223           state->Aborted = 0;
1224           instr   = ARMul_ReLoadInstr (state, pc, isize);
1225           decoded = ARMul_ReLoadInstr (state, pc + isize, isize);
1226           loaded  = ARMul_ReLoadInstr (state, pc + isize * 2, isize);
1227           NORMALCYCLE;
1228           break;
1229
1230         default:
1231           /* The program counter has been changed.  */
1232           pc = state->Reg[15];
1233 #ifndef MODE32
1234           pc = pc & R15PCBITS;
1235 #endif
1236           state->Reg[15] = pc + (isize * 2);
1237           state->Aborted = 0;
1238           instr   = ARMul_LoadInstrN (state, pc, isize);
1239           decoded = ARMul_LoadInstrS (state, pc + (isize), isize);
1240           loaded  = ARMul_LoadInstrS (state, pc + (isize * 2), isize);
1241           NORMALCYCLE;
1242           break;
1243         }
1244
1245       if (state->EventSet)
1246         ARMul_EnvokeEvent (state);
1247
1248       if (! TFLAG && trace)
1249         {
1250           fprintf (stderr, "pc: %x, ", pc & ~1);
1251           if (! disas)
1252             fprintf (stderr, "instr: %x\n", instr);
1253         }
1254
1255       if (instr == 0 || pc < 0x10)
1256         {
1257           ARMul_Abort (state, ARMUndefinedInstrV);
1258           state->Emulate = FALSE;
1259         }
1260
1261 #if 0 /* Enable this code to help track down stack alignment bugs.  */
1262       {
1263         static ARMword old_sp = -1;
1264
1265         if (old_sp != state->Reg[13])
1266           {
1267             old_sp = state->Reg[13];
1268             fprintf (stderr, "pc: %08x: SP set to %08x%s\n",
1269                      pc & ~1, old_sp, (old_sp % 8) ? " [UNALIGNED!]" : "");
1270           }
1271       }
1272 #endif
1273
1274       if (state->Exception)
1275         {
1276           /* Any exceptions ?  */
1277           if (state->NresetSig == LOW)
1278             {
1279               ARMul_Abort (state, ARMul_ResetV);
1280               break;
1281             }
1282           else if (!state->NfiqSig && !FFLAG)
1283             {
1284               ARMul_Abort (state, ARMul_FIQV);
1285               break;
1286             }
1287           else if (!state->NirqSig && !IFLAG)
1288             {
1289               ARMul_Abort (state, ARMul_IRQV);
1290               break;
1291             }
1292         }
1293
1294       if (state->CallDebug > 0)
1295         {
1296           if (state->Emulate < ONCE)
1297             {
1298               state->NextInstr = RESUME;
1299               break;
1300             }
1301           if (state->Debug)
1302             {
1303               fprintf (stderr, "sim: At %08lx Instr %08lx Mode %02lx\n",
1304                        (long) pc, (long) instr, (long) state->Mode);
1305               (void) fgetc (stdin);
1306             }
1307         }
1308       else if (state->Emulate < ONCE)
1309         {
1310           state->NextInstr = RESUME;
1311           break;
1312         }
1313
1314       state->NumInstrs++;
1315
1316 #ifdef MODET
1317       /* Provide Thumb instruction decoding. If the processor is in Thumb
1318          mode, then we can simply decode the Thumb instruction, and map it
1319          to the corresponding ARM instruction (by directly loading the
1320          instr variable, and letting the normal ARM simulator
1321          execute). There are some caveats to ensure that the correct
1322          pipelined PC value is used when executing Thumb code, and also for
1323          dealing with the BL instruction.  */
1324       if (TFLAG)
1325         {
1326           ARMword new;
1327
1328           /* Check if in Thumb mode.  */
1329           switch (ARMul_ThumbDecode (state, pc, instr, &new))
1330             {
1331             case t_undefined:
1332               /* This is a Thumb instruction.  */
1333               ARMul_UndefInstr (state, instr);
1334               goto donext;
1335
1336             case t_branch:
1337               /* Already processed.  */
1338               goto donext;
1339
1340             case t_decoded:
1341               /* ARM instruction available.  */
1342               if (disas || trace)
1343                 {
1344                   fprintf (stderr, "  emulate as: ");
1345                   if (trace)
1346                     fprintf (stderr, "%08x ", new);
1347                   if (! disas)
1348                     fprintf (stderr, "\n");
1349                 }
1350               instr = new;
1351               /* So continue instruction decoding.  */
1352               break;
1353             default:
1354               break;
1355             }
1356         }
1357 #endif
1358       if (disas)
1359         print_insn (instr);
1360
1361       /* Check the condition codes.  */
1362       if ((temp = TOPBITS (28)) == AL)
1363         /* Vile deed in the need for speed.  */
1364         goto mainswitch;
1365
1366       /* Check the condition code.  */
1367       switch ((int) TOPBITS (28))
1368         {
1369         case AL:
1370           temp = TRUE;
1371           break;
1372         case NV:
1373           if (state->is_v5)
1374             {
1375               if (BITS (25, 27) == 5) /* BLX(1) */
1376                 {
1377                   ARMword dest;
1378
1379                   state->Reg[14] = pc + 4;
1380
1381                   /* Force entry into Thumb mode.  */
1382                   dest = pc + 8 + 1;
1383                   if (BIT (23))
1384                     dest += (NEGBRANCH + (BIT (24) << 1));
1385                   else
1386                     dest += POSBRANCH + (BIT (24) << 1);
1387
1388                   WriteR15Branch (state, dest);
1389                   goto donext;
1390                 }
1391               else if ((instr & 0xFC70F000) == 0xF450F000)
1392                 /* The PLD instruction.  Ignored.  */
1393                 goto donext;
1394               else if (   ((instr & 0xfe500f00) == 0xfc100100)
1395                        || ((instr & 0xfe500f00) == 0xfc000100))
1396                 /* wldrw and wstrw are unconditional.  */
1397                 goto mainswitch;
1398               else
1399                 /* UNDEFINED in v5, UNPREDICTABLE in v3, v4, non executed in v1, v2.  */
1400                 ARMul_UndefInstr (state, instr);
1401             }
1402           temp = FALSE;
1403           break;
1404         case EQ:
1405           temp = ZFLAG;
1406           break;
1407         case NE:
1408           temp = !ZFLAG;
1409           break;
1410         case VS:
1411           temp = VFLAG;
1412           break;
1413         case VC:
1414           temp = !VFLAG;
1415           break;
1416         case MI:
1417           temp = NFLAG;
1418           break;
1419         case PL:
1420           temp = !NFLAG;
1421           break;
1422         case CS:
1423           temp = CFLAG;
1424           break;
1425         case CC:
1426           temp = !CFLAG;
1427           break;
1428         case HI:
1429           temp = (CFLAG && !ZFLAG);
1430           break;
1431         case LS:
1432           temp = (!CFLAG || ZFLAG);
1433           break;
1434         case GE:
1435           temp = ((!NFLAG && !VFLAG) || (NFLAG && VFLAG));
1436           break;
1437         case LT:
1438           temp = ((NFLAG && !VFLAG) || (!NFLAG && VFLAG));
1439           break;
1440         case GT:
1441           temp = ((!NFLAG && !VFLAG && !ZFLAG) || (NFLAG && VFLAG && !ZFLAG));
1442           break;
1443         case LE:
1444           temp = ((NFLAG && !VFLAG) || (!NFLAG && VFLAG)) || ZFLAG;
1445           break;
1446         }                       /* cc check */
1447
1448       /* Handle the Clock counter here.  */
1449       if (state->is_XScale)
1450         {
1451           ARMword cp14r0;
1452           int ok;
1453
1454           ok = state->CPRead[14] (state, 0, & cp14r0);
1455
1456           if (ok && (cp14r0 & ARMul_CP14_R0_ENABLE))
1457             {
1458               unsigned long newcycles, nowtime = ARMul_Time (state);
1459
1460               newcycles = nowtime - state->LastTime;
1461               state->LastTime = nowtime;
1462
1463               if (cp14r0 & ARMul_CP14_R0_CCD)
1464                 {
1465                   if (state->CP14R0_CCD == -1)
1466                     state->CP14R0_CCD = newcycles;
1467                   else
1468                     state->CP14R0_CCD += newcycles;
1469
1470                   if (state->CP14R0_CCD >= 64)
1471                     {
1472                       newcycles = 0;
1473
1474                       while (state->CP14R0_CCD >= 64)
1475                         state->CP14R0_CCD -= 64, newcycles++;
1476
1477                       goto check_PMUintr;
1478                     }
1479                 }
1480               else
1481                 {
1482                   ARMword cp14r1;
1483                   int do_int;
1484
1485                   state->CP14R0_CCD = -1;
1486 check_PMUintr:
1487                   do_int = 0;
1488                   cp14r0 |= ARMul_CP14_R0_FLAG2;
1489                   (void) state->CPWrite[14] (state, 0, cp14r0);
1490
1491                   ok = state->CPRead[14] (state, 1, & cp14r1);
1492
1493                   /* Coded like this for portability.  */
1494                   while (ok && newcycles)
1495                     {
1496                       if (cp14r1 == 0xffffffff)
1497                         {
1498                           cp14r1 = 0;
1499                           do_int = 1;
1500                         }
1501                       else
1502                         cp14r1 ++;
1503
1504                       newcycles --;
1505                     }
1506
1507                   (void) state->CPWrite[14] (state, 1, cp14r1);
1508
1509                   if (do_int && (cp14r0 & ARMul_CP14_R0_INTEN2))
1510                     {
1511                       ARMword temp;
1512
1513                       if (state->CPRead[13] (state, 8, & temp)
1514                           && (temp & ARMul_CP13_R8_PMUS))
1515                         ARMul_Abort (state, ARMul_FIQV);
1516                       else
1517                         ARMul_Abort (state, ARMul_IRQV);
1518                     }
1519                 }
1520             }
1521         }
1522
1523       /* Handle hardware instructions breakpoints here.  */
1524       if (state->is_XScale)
1525         {
1526           if (   (pc | 3) == (read_cp15_reg (14, 0, 8) | 2)
1527               || (pc | 3) == (read_cp15_reg (14, 0, 9) | 2))
1528             {
1529               if (XScale_debug_moe (state, ARMul_CP14_R10_MOE_IB))
1530                 ARMul_OSHandleSWI (state, SWI_Breakpoint);
1531             }
1532         }
1533
1534       /* Actual execution of instructions begins here.  */
1535       /* If the condition codes don't match, stop here.  */
1536       if (temp)
1537         {
1538         mainswitch:
1539
1540           if (state->is_XScale)
1541             {
1542               if (BIT (20) == 0 && BITS (25, 27) == 0)
1543                 {
1544                   if (BITS (4, 7) == 0xD)
1545                     {
1546                       /* XScale Load Consecutive insn.  */
1547                       ARMword temp = GetLS7RHS (state, instr);
1548                       ARMword temp2 = BIT (23) ? LHS + temp : LHS - temp;
1549                       ARMword addr = BIT (24) ? temp2 : LHS;
1550
1551                       if (BIT (12))
1552                         ARMul_UndefInstr (state, instr);
1553                       else if (addr & 7)
1554                         /* Alignment violation.  */
1555                         ARMul_Abort (state, ARMul_DataAbortV);
1556                       else
1557                         {
1558                           int wb = BIT (21) || (! BIT (24));
1559
1560                           state->Reg[BITS (12, 15)] =
1561                             ARMul_LoadWordN (state, addr);
1562                           state->Reg[BITS (12, 15) + 1] =
1563                             ARMul_LoadWordN (state, addr + 4);
1564                           if (wb)
1565                             LSBase = temp2;
1566                         }
1567
1568                       goto donext;
1569                     }
1570                   else if (BITS (4, 7) == 0xF)
1571                     {
1572                       /* XScale Store Consecutive insn.  */
1573                       ARMword temp = GetLS7RHS (state, instr);
1574                       ARMword temp2 = BIT (23) ? LHS + temp : LHS - temp;
1575                       ARMword addr = BIT (24) ? temp2 : LHS;
1576
1577                       if (BIT (12))
1578                         ARMul_UndefInstr (state, instr);
1579                       else if (addr & 7)
1580                         /* Alignment violation.  */
1581                         ARMul_Abort (state, ARMul_DataAbortV);
1582                       else
1583                         {
1584                           ARMul_StoreWordN (state, addr,
1585                                             state->Reg[BITS (12, 15)]);
1586                           ARMul_StoreWordN (state, addr + 4,
1587                                             state->Reg[BITS (12, 15) + 1]);
1588
1589                           if (BIT (21)|| ! BIT (24))
1590                             LSBase = temp2;
1591                         }
1592
1593                       goto donext;
1594                     }
1595                 }
1596
1597               if (ARMul_HandleIwmmxt (state, instr))
1598                 goto donext;
1599             }
1600
1601           switch ((int) BITS (20, 27))
1602             {
1603               /* Data Processing Register RHS Instructions.  */
1604
1605             case 0x00:          /* AND reg and MUL */
1606 #ifdef MODET
1607               if (BITS (4, 11) == 0xB)
1608                 {
1609                   /* STRH register offset, no write-back, down, post indexed.  */
1610                   SHDOWNWB ();
1611                   break;
1612                 }
1613               if (BITS (4, 7) == 0xD)
1614                 {
1615                   Handle_Load_Double (state, instr);
1616                   break;
1617                 }
1618               if (BITS (4, 7) == 0xF)
1619                 {
1620                   Handle_Store_Double (state, instr);
1621                   break;
1622                 }
1623 #endif
1624               if (BITS (4, 7) == 9)
1625                 {
1626                   /* MUL */
1627                   rhs = state->Reg[MULRHSReg];
1628                   if (MULLHSReg == MULDESTReg)
1629                     {
1630                       UNDEF_MULDestEQOp1;
1631                       state->Reg[MULDESTReg] = 0;
1632                     }
1633                   else if (MULDESTReg != 15)
1634                     state->Reg[MULDESTReg] = state->Reg[MULLHSReg] * rhs;
1635                   else
1636                     UNDEF_MULPCDest;
1637
1638                   for (dest = 0, temp = 0; dest < 32; dest ++)
1639                     if (rhs & (1L << dest))
1640                       temp = dest;
1641
1642                   /* Mult takes this many/2 I cycles.  */
1643                   ARMul_Icycles (state, ARMul_MultTable[temp], 0L);
1644                 }
1645               else
1646                 {
1647                   /* AND reg.  */
1648                   rhs = DPRegRHS;
1649                   dest = LHS & rhs;
1650                   WRITEDEST (dest);
1651                 }
1652               break;
1653
1654             case 0x01:          /* ANDS reg and MULS */
1655 #ifdef MODET
1656               if ((BITS (4, 11) & 0xF9) == 0x9)
1657                 /* LDR register offset, no write-back, down, post indexed.  */
1658                 LHPOSTDOWN ();
1659               /* Fall through to rest of decoding.  */
1660 #endif
1661               if (BITS (4, 7) == 9)
1662                 {
1663                   /* MULS */
1664                   rhs = state->Reg[MULRHSReg];
1665
1666                   if (MULLHSReg == MULDESTReg)
1667                     {
1668                       UNDEF_MULDestEQOp1;
1669                       state->Reg[MULDESTReg] = 0;
1670                       CLEARN;
1671                       SETZ;
1672                     }
1673                   else if (MULDESTReg != 15)
1674                     {
1675                       dest = state->Reg[MULLHSReg] * rhs;
1676                       ARMul_NegZero (state, dest);
1677                       state->Reg[MULDESTReg] = dest;
1678                     }
1679                   else
1680                     UNDEF_MULPCDest;
1681
1682                   for (dest = 0, temp = 0; dest < 32; dest ++)
1683                     if (rhs & (1L << dest))
1684                       temp = dest;
1685
1686                   /* Mult takes this many/2 I cycles.  */
1687                   ARMul_Icycles (state, ARMul_MultTable[temp], 0L);
1688                 }
1689               else
1690                 {
1691                   /* ANDS reg.  */
1692                   rhs = DPSRegRHS;
1693                   dest = LHS & rhs;
1694                   WRITESDEST (dest);
1695                 }
1696               break;
1697
1698             case 0x02:          /* EOR reg and MLA */
1699 #ifdef MODET
1700               if (BITS (4, 11) == 0xB)
1701                 {
1702                   /* STRH register offset, write-back, down, post indexed.  */
1703                   SHDOWNWB ();
1704                   break;
1705                 }
1706 #endif
1707               if (BITS (4, 7) == 9)
1708                 {               /* MLA */
1709                   rhs = state->Reg[MULRHSReg];
1710                   if (MULLHSReg == MULDESTReg)
1711                     {
1712                       UNDEF_MULDestEQOp1;
1713                       state->Reg[MULDESTReg] = state->Reg[MULACCReg];
1714                     }
1715                   else if (MULDESTReg != 15)
1716                     state->Reg[MULDESTReg] =
1717                       state->Reg[MULLHSReg] * rhs + state->Reg[MULACCReg];
1718                   else
1719                     UNDEF_MULPCDest;
1720
1721                   for (dest = 0, temp = 0; dest < 32; dest ++)
1722                     if (rhs & (1L << dest))
1723                       temp = dest;
1724
1725                   /* Mult takes this many/2 I cycles.  */
1726                   ARMul_Icycles (state, ARMul_MultTable[temp], 0L);
1727                 }
1728               else
1729                 {
1730                   rhs = DPRegRHS;
1731                   dest = LHS ^ rhs;
1732                   WRITEDEST (dest);
1733                 }
1734               break;
1735
1736             case 0x03:          /* EORS reg and MLAS */
1737 #ifdef MODET
1738               if ((BITS (4, 11) & 0xF9) == 0x9)
1739                 /* LDR register offset, write-back, down, post-indexed.  */
1740                 LHPOSTDOWN ();
1741               /* Fall through to rest of the decoding.  */
1742 #endif
1743               if (BITS (4, 7) == 9)
1744                 {
1745                   /* MLAS */
1746                   rhs = state->Reg[MULRHSReg];
1747
1748                   if (MULLHSReg == MULDESTReg)
1749                     {
1750                       UNDEF_MULDestEQOp1;
1751                       dest = state->Reg[MULACCReg];
1752                       ARMul_NegZero (state, dest);
1753                       state->Reg[MULDESTReg] = dest;
1754                     }
1755                   else if (MULDESTReg != 15)
1756                     {
1757                       dest =
1758                         state->Reg[MULLHSReg] * rhs + state->Reg[MULACCReg];
1759                       ARMul_NegZero (state, dest);
1760                       state->Reg[MULDESTReg] = dest;
1761                     }
1762                   else
1763                     UNDEF_MULPCDest;
1764
1765                   for (dest = 0, temp = 0; dest < 32; dest ++)
1766                     if (rhs & (1L << dest))
1767                       temp = dest;
1768
1769                   /* Mult takes this many/2 I cycles.  */
1770                   ARMul_Icycles (state, ARMul_MultTable[temp], 0L);
1771                 }
1772               else
1773                 {
1774                   /* EORS Reg.  */
1775                   rhs = DPSRegRHS;
1776                   dest = LHS ^ rhs;
1777                   WRITESDEST (dest);
1778                 }
1779               break;
1780
1781             case 0x04:          /* SUB reg */
1782 #ifdef MODET
1783               if (BITS (4, 7) == 0xB)
1784                 {
1785                   /* STRH immediate offset, no write-back, down, post indexed.  */
1786                   SHDOWNWB ();
1787                   break;
1788                 }
1789               if (BITS (4, 7) == 0xD)
1790                 {
1791                   Handle_Load_Double (state, instr);
1792                   break;
1793                 }
1794               if (BITS (4, 7) == 0xF)
1795                 {
1796                   Handle_Store_Double (state, instr);
1797                   break;
1798                 }
1799 #endif
1800               rhs = DPRegRHS;
1801               dest = LHS - rhs;
1802               WRITEDEST (dest);
1803               break;
1804
1805             case 0x05:          /* SUBS reg */
1806 #ifdef MODET
1807               if ((BITS (4, 7) & 0x9) == 0x9)
1808                 /* LDR immediate offset, no write-back, down, post indexed.  */
1809                 LHPOSTDOWN ();
1810               /* Fall through to the rest of the instruction decoding.  */
1811 #endif
1812               lhs = LHS;
1813               rhs = DPRegRHS;
1814               dest = lhs - rhs;
1815
1816               if ((lhs >= rhs) || ((rhs | lhs) >> 31))
1817                 {
1818                   ARMul_SubCarry (state, lhs, rhs, dest);
1819                   ARMul_SubOverflow (state, lhs, rhs, dest);
1820                 }
1821               else
1822                 {
1823                   CLEARC;
1824                   CLEARV;
1825                 }
1826               WRITESDEST (dest);
1827               break;
1828
1829             case 0x06:          /* RSB reg */
1830 #ifdef MODET
1831               if (BITS (4, 7) == 0xB)
1832                 {
1833                   /* STRH immediate offset, write-back, down, post indexed.  */
1834                   SHDOWNWB ();
1835                   break;
1836                 }
1837 #endif
1838               rhs = DPRegRHS;
1839               dest = rhs - LHS;
1840               WRITEDEST (dest);
1841               break;
1842
1843             case 0x07:          /* RSBS reg */
1844 #ifdef MODET
1845               if ((BITS (4, 7) & 0x9) == 0x9)
1846                 /* LDR immediate offset, write-back, down, post indexed.  */
1847                 LHPOSTDOWN ();
1848               /* Fall through to remainder of instruction decoding.  */
1849 #endif
1850               lhs = LHS;
1851               rhs = DPRegRHS;
1852               dest = rhs - lhs;
1853
1854               if ((rhs >= lhs) || ((rhs | lhs) >> 31))
1855                 {
1856                   ARMul_SubCarry (state, rhs, lhs, dest);
1857                   ARMul_SubOverflow (state, rhs, lhs, dest);
1858                 }
1859               else
1860                 {
1861                   CLEARC;
1862                   CLEARV;
1863                 }
1864               WRITESDEST (dest);
1865               break;
1866
1867             case 0x08:          /* ADD reg */
1868 #ifdef MODET
1869               if (BITS (4, 11) == 0xB)
1870                 {
1871                   /* STRH register offset, no write-back, up, post indexed.  */
1872                   SHUPWB ();
1873                   break;
1874                 }
1875               if (BITS (4, 7) == 0xD)
1876                 {
1877                   Handle_Load_Double (state, instr);
1878                   break;
1879                 }
1880               if (BITS (4, 7) == 0xF)
1881                 {
1882                   Handle_Store_Double (state, instr);
1883                   break;
1884                 }
1885 #endif
1886 #ifdef MODET
1887               if (BITS (4, 7) == 0x9)
1888                 {
1889                   /* MULL */
1890                   /* 32x32 = 64 */
1891                   ARMul_Icycles (state,
1892                                  Multiply64 (state, instr, LUNSIGNED,
1893                                              LDEFAULT), 0L);
1894                   break;
1895                 }
1896 #endif
1897               rhs = DPRegRHS;
1898               dest = LHS + rhs;
1899               WRITEDEST (dest);
1900               break;
1901
1902             case 0x09:          /* ADDS reg */
1903 #ifdef MODET
1904               if ((BITS (4, 11) & 0xF9) == 0x9)
1905                 /* LDR register offset, no write-back, up, post indexed.  */
1906                 LHPOSTUP ();
1907               /* Fall through to remaining instruction decoding.  */
1908 #endif
1909 #ifdef MODET
1910               if (BITS (4, 7) == 0x9)
1911                 {
1912                   /* MULL */
1913                   /* 32x32=64 */
1914                   ARMul_Icycles (state,
1915                                  Multiply64 (state, instr, LUNSIGNED, LSCC),
1916                                  0L);
1917                   break;
1918                 }
1919 #endif
1920               lhs = LHS;
1921               rhs = DPRegRHS;
1922               dest = lhs + rhs;
1923               ASSIGNZ (dest == 0);
1924               if ((lhs | rhs) >> 30)
1925                 {
1926                   /* Possible C,V,N to set.  */
1927                   ASSIGNN (NEG (dest));
1928                   ARMul_AddCarry (state, lhs, rhs, dest);
1929                   ARMul_AddOverflow (state, lhs, rhs, dest);
1930                 }
1931               else
1932                 {
1933                   CLEARN;
1934                   CLEARC;
1935                   CLEARV;
1936                 }
1937               WRITESDEST (dest);
1938               break;
1939
1940             case 0x0a:          /* ADC reg */
1941 #ifdef MODET
1942               if (BITS (4, 11) == 0xB)
1943                 {
1944                   /* STRH register offset, write-back, up, post-indexed.  */
1945                   SHUPWB ();
1946                   break;
1947                 }
1948               if (BITS (4, 7) == 0x9)
1949                 {
1950                   /* MULL */
1951                   /* 32x32=64 */
1952                   ARMul_Icycles (state,
1953                                  MultiplyAdd64 (state, instr, LUNSIGNED,
1954                                                 LDEFAULT), 0L);
1955                   break;
1956                 }
1957 #endif
1958               rhs = DPRegRHS;
1959               dest = LHS + rhs + CFLAG;
1960               WRITEDEST (dest);
1961               break;
1962
1963             case 0x0b:          /* ADCS reg */
1964 #ifdef MODET
1965               if ((BITS (4, 11) & 0xF9) == 0x9)
1966                 /* LDR register offset, write-back, up, post indexed.  */
1967                 LHPOSTUP ();
1968               /* Fall through to remaining instruction decoding.  */
1969               if (BITS (4, 7) == 0x9)
1970                 {
1971                   /* MULL */
1972                   /* 32x32=64 */
1973                   ARMul_Icycles (state,
1974                                  MultiplyAdd64 (state, instr, LUNSIGNED,
1975                                                 LSCC), 0L);
1976                   break;
1977                 }
1978 #endif
1979               lhs = LHS;
1980               rhs = DPRegRHS;
1981               dest = lhs + rhs + CFLAG;
1982               ASSIGNZ (dest == 0);
1983               if ((lhs | rhs) >> 30)
1984                 {
1985                   /* Possible C,V,N to set.  */
1986                   ASSIGNN (NEG (dest));
1987                   ARMul_AddCarry (state, lhs, rhs, dest);
1988                   ARMul_AddOverflow (state, lhs, rhs, dest);
1989                 }
1990               else
1991                 {
1992                   CLEARN;
1993                   CLEARC;
1994                   CLEARV;
1995                 }
1996               WRITESDEST (dest);
1997               break;
1998
1999             case 0x0c:          /* SBC reg */
2000 #ifdef MODET
2001               if (BITS (4, 7) == 0xB)
2002                 {
2003                   /* STRH immediate offset, no write-back, up post indexed.  */
2004                   SHUPWB ();
2005                   break;
2006                 }
2007               if (BITS (4, 7) == 0xD)
2008                 {
2009                   Handle_Load_Double (state, instr);
2010                   break;
2011                 }
2012               if (BITS (4, 7) == 0xF)
2013                 {
2014                   Handle_Store_Double (state, instr);
2015                   break;
2016                 }
2017               if (BITS (4, 7) == 0x9)
2018                 {
2019                   /* MULL */
2020                   /* 32x32=64 */
2021                   ARMul_Icycles (state,
2022                                  Multiply64 (state, instr, LSIGNED, LDEFAULT),
2023                                  0L);
2024                   break;
2025                 }
2026 #endif
2027               rhs = DPRegRHS;
2028               dest = LHS - rhs - !CFLAG;
2029               WRITEDEST (dest);
2030               break;
2031
2032             case 0x0d:          /* SBCS reg */
2033 #ifdef MODET
2034               if ((BITS (4, 7) & 0x9) == 0x9)
2035                 /* LDR immediate offset, no write-back, up, post indexed.  */
2036                 LHPOSTUP ();
2037
2038               if (BITS (4, 7) == 0x9)
2039                 {
2040                   /* MULL */
2041                   /* 32x32=64 */
2042                   ARMul_Icycles (state,
2043                                  Multiply64 (state, instr, LSIGNED, LSCC),
2044                                  0L);
2045                   break;
2046                 }
2047 #endif
2048               lhs = LHS;
2049               rhs = DPRegRHS;
2050               dest = lhs - rhs - !CFLAG;
2051               if ((lhs >= rhs) || ((rhs | lhs) >> 31))
2052                 {
2053                   ARMul_SubCarry (state, lhs, rhs, dest);
2054                   ARMul_SubOverflow (state, lhs, rhs, dest);
2055                 }
2056               else
2057                 {
2058                   CLEARC;
2059                   CLEARV;
2060                 }
2061               WRITESDEST (dest);
2062               break;
2063
2064             case 0x0e:          /* RSC reg */
2065 #ifdef MODET
2066               if (BITS (4, 7) == 0xB)
2067                 {
2068                   /* STRH immediate offset, write-back, up, post indexed.  */
2069                   SHUPWB ();
2070                   break;
2071                 }
2072
2073               if (BITS (4, 7) == 0x9)
2074                 {
2075                   /* MULL */
2076                   /* 32x32=64 */
2077                   ARMul_Icycles (state,
2078                                  MultiplyAdd64 (state, instr, LSIGNED,
2079                                                 LDEFAULT), 0L);
2080                   break;
2081                 }
2082 #endif
2083               rhs = DPRegRHS;
2084               dest = rhs - LHS - !CFLAG;
2085               WRITEDEST (dest);
2086               break;
2087
2088             case 0x0f:          /* RSCS reg */
2089 #ifdef MODET
2090               if ((BITS (4, 7) & 0x9) == 0x9)
2091                 /* LDR immediate offset, write-back, up, post indexed.  */
2092                 LHPOSTUP ();
2093               /* Fall through to remaining instruction decoding.  */
2094
2095               if (BITS (4, 7) == 0x9)
2096                 {
2097                   /* MULL */
2098                   /* 32x32=64 */
2099                   ARMul_Icycles (state,
2100                                  MultiplyAdd64 (state, instr, LSIGNED, LSCC),
2101                                  0L);
2102                   break;
2103                 }
2104 #endif
2105               lhs = LHS;
2106               rhs = DPRegRHS;
2107               dest = rhs - lhs - !CFLAG;
2108
2109               if ((rhs >= lhs) || ((rhs | lhs) >> 31))
2110                 {
2111                   ARMul_SubCarry (state, rhs, lhs, dest);
2112                   ARMul_SubOverflow (state, rhs, lhs, dest);
2113                 }
2114               else
2115                 {
2116                   CLEARC;
2117                   CLEARV;
2118                 }
2119               WRITESDEST (dest);
2120               break;
2121
2122             case 0x10:          /* TST reg and MRS CPSR and SWP word.  */
2123               if (state->is_v5e)
2124                 {
2125                   if (BIT (4) == 0 && BIT (7) == 1)
2126                     {
2127                       /* ElSegundo SMLAxy insn.  */
2128                       ARMword op1 = state->Reg[BITS (0, 3)];
2129                       ARMword op2 = state->Reg[BITS (8, 11)];
2130                       ARMword Rn = state->Reg[BITS (12, 15)];
2131
2132                       if (BIT (5))
2133                         op1 >>= 16;
2134                       if (BIT (6))
2135                         op2 >>= 16;
2136                       op1 &= 0xFFFF;
2137                       op2 &= 0xFFFF;
2138                       if (op1 & 0x8000)
2139                         op1 -= 65536;
2140                       if (op2 & 0x8000)
2141                         op2 -= 65536;
2142                       op1 *= op2;
2143
2144                       if (AddOverflow (op1, Rn, op1 + Rn))
2145                         SETS;
2146                       state->Reg[BITS (16, 19)] = op1 + Rn;
2147                       break;
2148                     }
2149
2150                   if (BITS (4, 11) == 5)
2151                     {
2152                       /* ElSegundo QADD insn.  */
2153                       ARMword op1 = state->Reg[BITS (0, 3)];
2154                       ARMword op2 = state->Reg[BITS (16, 19)];
2155                       ARMword result = op1 + op2;
2156                       if (AddOverflow (op1, op2, result))
2157                         {
2158                           result = POS (result) ? 0x80000000 : 0x7fffffff;
2159                           SETS;
2160                         }
2161                       state->Reg[BITS (12, 15)] = result;
2162                       break;
2163                     }
2164                 }
2165 #ifdef MODET
2166               if (BITS (4, 11) == 0xB)
2167                 {
2168                   /* STRH register offset, no write-back, down, pre indexed.  */
2169                   SHPREDOWN ();
2170                   break;
2171                 }
2172               if (BITS (4, 7) == 0xD)
2173                 {
2174                   Handle_Load_Double (state, instr);
2175                   break;
2176                 }
2177               if (BITS (4, 7) == 0xF)
2178                 {
2179                   Handle_Store_Double (state, instr);
2180                   break;
2181                 }
2182 #endif
2183               if (BITS (4, 11) == 9)
2184                 {
2185                   /* SWP */
2186                   UNDEF_SWPPC;
2187                   temp = LHS;
2188                   BUSUSEDINCPCS;
2189 #ifndef MODE32
2190                   if (VECTORACCESS (temp) || ADDREXCEPT (temp))
2191                     {
2192                       INTERNALABORT (temp);
2193                       (void) ARMul_LoadWordN (state, temp);
2194                       (void) ARMul_LoadWordN (state, temp);
2195                     }
2196                   else
2197 #endif
2198                     dest = ARMul_SwapWord (state, temp, state->Reg[RHSReg]);
2199                   if (temp & 3)
2200                     DEST = ARMul_Align (state, temp, dest);
2201                   else
2202                     DEST = dest;
2203                   if (state->abortSig || state->Aborted)
2204                     TAKEABORT;
2205                 }
2206               else if ((BITS (0, 11) == 0) && (LHSReg == 15))
2207                 {               /* MRS CPSR */
2208                   UNDEF_MRSPC;
2209                   DEST = ECC | EINT | EMODE;
2210                 }
2211               else
2212                 {
2213 #ifdef MODE32
2214                   if (state->is_v6
2215                       && handle_v6_insn (state, instr))
2216                     break;
2217 #endif
2218                   UNDEF_Test;
2219                 }
2220               break;
2221
2222             case 0x11:          /* TSTP reg */
2223 #ifdef MODET
2224               if ((BITS (4, 11) & 0xF9) == 0x9)
2225                 /* LDR register offset, no write-back, down, pre indexed.  */
2226                 LHPREDOWN ();
2227               /* Continue with remaining instruction decode.  */
2228 #endif
2229               if (DESTReg == 15)
2230                 {
2231                   /* TSTP reg */
2232 #ifdef MODE32
2233                   state->Cpsr = GETSPSR (state->Bank);
2234                   ARMul_CPSRAltered (state);
2235 #else
2236                   rhs = DPRegRHS;
2237                   temp = LHS & rhs;
2238                   SETR15PSR (temp);
2239 #endif
2240                 }
2241               else
2242                 {
2243                   /* TST reg */
2244                   rhs = DPSRegRHS;
2245                   dest = LHS & rhs;
2246                   ARMul_NegZero (state, dest);
2247                 }
2248               break;
2249
2250             case 0x12:          /* TEQ reg and MSR reg to CPSR (ARM6).  */
2251               if (state->is_v5)
2252                 {
2253                   if (BITS (4, 7) == 3)
2254                     {
2255                       /* BLX(2) */
2256                       ARMword temp;
2257
2258                       if (TFLAG)
2259                         temp = (pc + 2) | 1;
2260                       else
2261                         temp = pc + 4;
2262
2263                       WriteR15Branch (state, state->Reg[RHSReg]);
2264                       state->Reg[14] = temp;
2265                       break;
2266                     }
2267                 }
2268
2269               if (state->is_v5e)
2270                 {
2271                   if (BIT (4) == 0 && BIT (7) == 1
2272                       && (BIT (5) == 0 || BITS (12, 15) == 0))
2273                     {
2274                       /* ElSegundo SMLAWy/SMULWy insn.  */
2275                       ARMdword op1 = state->Reg[BITS (0, 3)];
2276                       ARMdword op2 = state->Reg[BITS (8, 11)];
2277                       ARMdword result;
2278
2279                       if (BIT (6))
2280                         op2 >>= 16;
2281                       if (op1 & 0x80000000)
2282                         op1 -= 1ULL << 32;
2283                       op2 &= 0xFFFF;
2284                       if (op2 & 0x8000)
2285                         op2 -= 65536;
2286                       result = (op1 * op2) >> 16;
2287
2288                       if (BIT (5) == 0)
2289                         {
2290                           ARMword Rn = state->Reg[BITS (12, 15)];
2291
2292                           if (AddOverflow (result, Rn, result + Rn))
2293                             SETS;
2294                           result += Rn;
2295                         }
2296                       state->Reg[BITS (16, 19)] = result;
2297                       break;
2298                     }
2299
2300                   if (BITS (4, 11) == 5)
2301                     {
2302                       /* ElSegundo QSUB insn.  */
2303                       ARMword op1 = state->Reg[BITS (0, 3)];
2304                       ARMword op2 = state->Reg[BITS (16, 19)];
2305                       ARMword result = op1 - op2;
2306
2307                       if (SubOverflow (op1, op2, result))
2308                         {
2309                           result = POS (result) ? 0x80000000 : 0x7fffffff;
2310                           SETS;
2311                         }
2312
2313                       state->Reg[BITS (12, 15)] = result;
2314                       break;
2315                     }
2316                 }
2317 #ifdef MODET
2318               if (BITS (4, 11) == 0xB)
2319                 {
2320                   /* STRH register offset, write-back, down, pre indexed.  */
2321                   SHPREDOWNWB ();
2322                   break;
2323                 }
2324               if (BITS (4, 27) == 0x12FFF1)
2325                 {
2326                   /* BX */
2327                   WriteR15Branch (state, state->Reg[RHSReg]);
2328                   break;
2329                 }
2330               if (BITS (4, 7) == 0xD)
2331                 {
2332                   Handle_Load_Double (state, instr);
2333                   break;
2334                 }
2335               if (BITS (4, 7) == 0xF)
2336                 {
2337                   Handle_Store_Double (state, instr);
2338                   break;
2339                 }
2340 #endif
2341               if (state->is_v5)
2342                 {
2343                   if (BITS (4, 7) == 0x7)
2344                     {
2345                       extern int SWI_vector_installed;
2346
2347                       /* Hardware is allowed to optionally override this
2348                          instruction and treat it as a breakpoint.  Since
2349                          this is a simulator not hardware, we take the position
2350                          that if a SWI vector was not installed, then an Abort
2351                          vector was probably not installed either, and so
2352                          normally this instruction would be ignored, even if an
2353                          Abort is generated.  This is a bad thing, since GDB
2354                          uses this instruction for its breakpoints (at least in
2355                          Thumb mode it does).  So intercept the instruction here
2356                          and generate a breakpoint SWI instead.  */
2357                       if (! SWI_vector_installed)
2358                         ARMul_OSHandleSWI (state, SWI_Breakpoint);
2359                       else
2360                         {
2361                           /* BKPT - normally this will cause an abort, but on the
2362                              XScale we must check the DCSR.  */
2363                           XScale_set_fsr_far (state, ARMul_CP15_R5_MMU_EXCPT, pc);
2364                           if (!XScale_debug_moe (state, ARMul_CP14_R10_MOE_BT))
2365                             break;
2366                         }
2367
2368                       /* Force the next instruction to be refetched.  */
2369                       state->NextInstr = RESUME;
2370                       break;
2371                     }
2372                 }
2373               if (DESTReg == 15)
2374                 {
2375                   /* MSR reg to CPSR.  */
2376                   UNDEF_MSRPC;
2377                   temp = DPRegRHS;
2378 #ifdef MODET
2379                   /* Don't allow TBIT to be set by MSR.  */
2380                   temp &= ~ TBIT;
2381 #endif
2382                   ARMul_FixCPSR (state, instr, temp);
2383                 }
2384 #ifdef MODE32
2385               else if (state->is_v6
2386                        && handle_v6_insn (state, instr))
2387                 break;
2388 #endif
2389               else
2390                 UNDEF_Test;
2391
2392               break;
2393
2394             case 0x13:          /* TEQP reg */
2395 #ifdef MODET
2396               if ((BITS (4, 11) & 0xF9) == 0x9)
2397                 /* LDR register offset, write-back, down, pre indexed.  */
2398                 LHPREDOWNWB ();
2399               /* Continue with remaining instruction decode.  */
2400 #endif
2401               if (DESTReg == 15)
2402                 {
2403                   /* TEQP reg */
2404 #ifdef MODE32
2405                   state->Cpsr = GETSPSR (state->Bank);
2406                   ARMul_CPSRAltered (state);
2407 #else
2408                   rhs = DPRegRHS;
2409                   temp = LHS ^ rhs;
2410                   SETR15PSR (temp);
2411 #endif
2412                 }
2413               else
2414                 {
2415                   /* TEQ Reg.  */
2416                   rhs = DPSRegRHS;
2417                   dest = LHS ^ rhs;
2418                   ARMul_NegZero (state, dest);
2419                 }
2420               break;
2421
2422             case 0x14:          /* CMP reg and MRS SPSR and SWP byte.  */
2423               if (state->is_v5e)
2424                 {
2425                   if (BIT (4) == 0 && BIT (7) == 1)
2426                     {
2427                       /* ElSegundo SMLALxy insn.  */
2428                       ARMdword op1 = state->Reg[BITS (0, 3)];
2429                       ARMdword op2 = state->Reg[BITS (8, 11)];
2430                       ARMdword dest;
2431
2432                       if (BIT (5))
2433                         op1 >>= 16;
2434                       if (BIT (6))
2435                         op2 >>= 16;
2436                       op1 &= 0xFFFF;
2437                       if (op1 & 0x8000)
2438                         op1 -= 65536;
2439                       op2 &= 0xFFFF;
2440                       if (op2 & 0x8000)
2441                         op2 -= 65536;
2442
2443                       dest = (ARMdword) state->Reg[BITS (16, 19)] << 32;
2444                       dest |= state->Reg[BITS (12, 15)];
2445                       dest += op1 * op2;
2446                       state->Reg[BITS (12, 15)] = dest;
2447                       state->Reg[BITS (16, 19)] = dest >> 32;
2448                       break;
2449                     }
2450
2451                   if (BITS (4, 11) == 5)
2452                     {
2453                       /* ElSegundo QDADD insn.  */
2454                       ARMword op1 = state->Reg[BITS (0, 3)];
2455                       ARMword op2 = state->Reg[BITS (16, 19)];
2456                       ARMword op2d = op2 + op2;
2457                       ARMword result;
2458
2459                       if (AddOverflow (op2, op2, op2d))
2460                         {
2461                           SETS;
2462                           op2d = POS (op2d) ? 0x80000000 : 0x7fffffff;
2463                         }
2464
2465                       result = op1 + op2d;
2466                       if (AddOverflow (op1, op2d, result))
2467                         {
2468                           SETS;
2469                           result = POS (result) ? 0x80000000 : 0x7fffffff;
2470                         }
2471
2472                       state->Reg[BITS (12, 15)] = result;
2473                       break;
2474                     }
2475                 }
2476 #ifdef MODET
2477               if (BITS (4, 7) == 0xB)
2478                 {
2479                   /* STRH immediate offset, no write-back, down, pre indexed.  */
2480                   SHPREDOWN ();
2481                   break;
2482                 }
2483               if (BITS (4, 7) == 0xD)
2484                 {
2485                   Handle_Load_Double (state, instr);
2486                   break;
2487                 }
2488               if (BITS (4, 7) == 0xF)
2489                 {
2490                   Handle_Store_Double (state, instr);
2491                   break;
2492                 }
2493 #endif
2494               if (BITS (4, 11) == 9)
2495                 {
2496                   /* SWP */
2497                   UNDEF_SWPPC;
2498                   temp = LHS;
2499                   BUSUSEDINCPCS;
2500 #ifndef MODE32
2501                   if (VECTORACCESS (temp) || ADDREXCEPT (temp))
2502                     {
2503                       INTERNALABORT (temp);
2504                       (void) ARMul_LoadByte (state, temp);
2505                       (void) ARMul_LoadByte (state, temp);
2506                     }
2507                   else
2508 #endif
2509                     DEST = ARMul_SwapByte (state, temp, state->Reg[RHSReg]);
2510                   if (state->abortSig || state->Aborted)
2511                     TAKEABORT;
2512                 }
2513               else if ((BITS (0, 11) == 0) && (LHSReg == 15))
2514                 {
2515                   /* MRS SPSR */
2516                   UNDEF_MRSPC;
2517                   DEST = GETSPSR (state->Bank);
2518                 }
2519 #ifdef MODE32
2520               else if (state->is_v6
2521                        && handle_v6_insn (state, instr))
2522                 break;
2523 #endif
2524               else
2525                 UNDEF_Test;
2526
2527               break;
2528
2529             case 0x15:          /* CMPP reg.  */
2530 #ifdef MODET
2531               if ((BITS (4, 7) & 0x9) == 0x9)
2532                 /* LDR immediate offset, no write-back, down, pre indexed.  */
2533                 LHPREDOWN ();
2534               /* Continue with remaining instruction decode.  */
2535 #endif
2536               if (DESTReg == 15)
2537                 {
2538                   /* CMPP reg.  */
2539 #ifdef MODE32
2540                   state->Cpsr = GETSPSR (state->Bank);
2541                   ARMul_CPSRAltered (state);
2542 #else
2543                   rhs = DPRegRHS;
2544                   temp = LHS - rhs;
2545                   SETR15PSR (temp);
2546 #endif
2547                 }
2548               else
2549                 {
2550                   /* CMP reg.  */
2551                   lhs = LHS;
2552                   rhs = DPRegRHS;
2553                   dest = lhs - rhs;
2554                   ARMul_NegZero (state, dest);
2555                   if ((lhs >= rhs) || ((rhs | lhs) >> 31))
2556                     {
2557                       ARMul_SubCarry (state, lhs, rhs, dest);
2558                       ARMul_SubOverflow (state, lhs, rhs, dest);
2559                     }
2560                   else
2561                     {
2562                       CLEARC;
2563                       CLEARV;
2564                     }
2565                 }
2566               break;
2567
2568             case 0x16:          /* CMN reg and MSR reg to SPSR */
2569               if (state->is_v5e)
2570                 {
2571                   if (BIT (4) == 0 && BIT (7) == 1 && BITS (12, 15) == 0)
2572                     {
2573                       /* ElSegundo SMULxy insn.  */
2574                       ARMword op1 = state->Reg[BITS (0, 3)];
2575                       ARMword op2 = state->Reg[BITS (8, 11)];
2576
2577                       if (BIT (5))
2578                         op1 >>= 16;
2579                       if (BIT (6))
2580                         op2 >>= 16;
2581                       op1 &= 0xFFFF;
2582                       op2 &= 0xFFFF;
2583                       if (op1 & 0x8000)
2584                         op1 -= 65536;
2585                       if (op2 & 0x8000)
2586                         op2 -= 65536;
2587
2588                       state->Reg[BITS (16, 19)] = op1 * op2;
2589                       break;
2590                     }
2591
2592                   if (BITS (4, 11) == 5)
2593                     {
2594                       /* ElSegundo QDSUB insn.  */
2595                       ARMword op1 = state->Reg[BITS (0, 3)];
2596                       ARMword op2 = state->Reg[BITS (16, 19)];
2597                       ARMword op2d = op2 + op2;
2598                       ARMword result;
2599
2600                       if (AddOverflow (op2, op2, op2d))
2601                         {
2602                           SETS;
2603                           op2d = POS (op2d) ? 0x80000000 : 0x7fffffff;
2604                         }
2605
2606                       result = op1 - op2d;
2607                       if (SubOverflow (op1, op2d, result))
2608                         {
2609                           SETS;
2610                           result = POS (result) ? 0x80000000 : 0x7fffffff;
2611                         }
2612
2613                       state->Reg[BITS (12, 15)] = result;
2614                       break;
2615                     }
2616                 }
2617
2618               if (state->is_v5)
2619                 {
2620                   if (BITS (4, 11) == 0xF1 && BITS (16, 19) == 0xF)
2621                     {
2622                       /* ARM5 CLZ insn.  */
2623                       ARMword op1 = state->Reg[BITS (0, 3)];
2624                       int result = 32;
2625
2626                       if (op1)
2627                         for (result = 0; (op1 & 0x80000000) == 0; op1 <<= 1)
2628                           result++;
2629
2630                       state->Reg[BITS (12, 15)] = result;
2631                       break;
2632                     }
2633                 }
2634 #ifdef MODET
2635               if (BITS (4, 7) == 0xB)
2636                 {
2637                   /* STRH immediate offset, write-back, down, pre indexed.  */
2638                   SHPREDOWNWB ();
2639                   break;
2640                 }
2641               if (BITS (4, 7) == 0xD)
2642                 {
2643                   Handle_Load_Double (state, instr);
2644                   break;
2645                 }
2646               if (BITS (4, 7) == 0xF)
2647                 {
2648                   Handle_Store_Double (state, instr);
2649                   break;
2650                 }
2651 #endif
2652               if (DESTReg == 15)
2653                 {
2654                   /* MSR */
2655                   UNDEF_MSRPC;
2656                   ARMul_FixSPSR (state, instr, DPRegRHS);
2657                 }
2658               else
2659                 {
2660 #ifdef MODE32
2661                   if (state->is_v6
2662                       && handle_v6_insn (state, instr))
2663                     break;
2664 #endif
2665                   UNDEF_Test;
2666                 }
2667               break;
2668
2669             case 0x17:          /* CMNP reg */
2670 #ifdef MODET
2671               if ((BITS (4, 7) & 0x9) == 0x9)
2672                 /* LDR immediate offset, write-back, down, pre indexed.  */
2673                 LHPREDOWNWB ();
2674               /* Continue with remaining instruction decoding.  */
2675 #endif
2676               if (DESTReg == 15)
2677                 {
2678 #ifdef MODE32
2679                   state->Cpsr = GETSPSR (state->Bank);
2680                   ARMul_CPSRAltered (state);
2681 #else
2682                   rhs = DPRegRHS;
2683                   temp = LHS + rhs;
2684                   SETR15PSR (temp);
2685 #endif
2686                   break;
2687                 }
2688               else
2689                 {
2690                   /* CMN reg.  */
2691                   lhs = LHS;
2692                   rhs = DPRegRHS;
2693                   dest = lhs + rhs;
2694                   ASSIGNZ (dest == 0);
2695                   if ((lhs | rhs) >> 30)
2696                     {
2697                       /* Possible C,V,N to set.  */
2698                       ASSIGNN (NEG (dest));
2699                       ARMul_AddCarry (state, lhs, rhs, dest);
2700                       ARMul_AddOverflow (state, lhs, rhs, dest);
2701                     }
2702                   else
2703                     {
2704                       CLEARN;
2705                       CLEARC;
2706                       CLEARV;
2707                     }
2708                 }
2709               break;
2710
2711             case 0x18:          /* ORR reg */
2712 #ifdef MODET
2713               if (BITS (4, 11) == 0xB)
2714                 {
2715                   /* STRH register offset, no write-back, up, pre indexed.  */
2716                   SHPREUP ();
2717                   break;
2718                 }
2719               if (BITS (4, 7) == 0xD)
2720                 {
2721                   Handle_Load_Double (state, instr);
2722                   break;
2723                 }
2724               if (BITS (4, 7) == 0xF)
2725                 {
2726                   Handle_Store_Double (state, instr);
2727                   break;
2728                 }
2729 #endif
2730               rhs = DPRegRHS;
2731               dest = LHS | rhs;
2732               WRITEDEST (dest);
2733               break;
2734
2735             case 0x19:          /* ORRS reg */
2736 #ifdef MODET
2737               if ((BITS (4, 11) & 0xF9) == 0x9)
2738                 /* LDR register offset, no write-back, up, pre indexed.  */
2739                 LHPREUP ();
2740               /* Continue with remaining instruction decoding.  */
2741 #endif
2742               rhs = DPSRegRHS;
2743               dest = LHS | rhs;
2744               WRITESDEST (dest);
2745               break;
2746
2747             case 0x1a:          /* MOV reg */
2748 #ifdef MODET
2749               if (BITS (4, 11) == 0xB)
2750                 {
2751                   /* STRH register offset, write-back, up, pre indexed.  */
2752                   SHPREUPWB ();
2753                   break;
2754                 }
2755               if (BITS (4, 7) == 0xD)
2756                 {
2757                   Handle_Load_Double (state, instr);
2758                   break;
2759                 }
2760               if (BITS (4, 7) == 0xF)
2761                 {
2762                   Handle_Store_Double (state, instr);
2763                   break;
2764                 }
2765 #endif
2766               dest = DPRegRHS;
2767               WRITEDEST (dest);
2768               break;
2769
2770             case 0x1b:          /* MOVS reg */
2771 #ifdef MODET
2772               if ((BITS (4, 11) & 0xF9) == 0x9)
2773                 /* LDR register offset, write-back, up, pre indexed.  */
2774                 LHPREUPWB ();
2775               /* Continue with remaining instruction decoding.  */
2776 #endif
2777               dest = DPSRegRHS;
2778               WRITESDEST (dest);
2779               break;
2780
2781             case 0x1c:          /* BIC reg */
2782 #ifdef MODET
2783               if (BITS (4, 7) == 0xB)
2784                 {
2785                   /* STRH immediate offset, no write-back, up, pre indexed.  */
2786                   SHPREUP ();
2787                   break;
2788                 }
2789               if (BITS (4, 7) == 0xD)
2790                 {
2791                   Handle_Load_Double (state, instr);
2792                   break;
2793                 }
2794               else if (BITS (4, 7) == 0xF)
2795                 {
2796                   Handle_Store_Double (state, instr);
2797                   break;
2798                 }
2799 #endif
2800               rhs = DPRegRHS;
2801               dest = LHS & ~rhs;
2802               WRITEDEST (dest);
2803               break;
2804
2805             case 0x1d:          /* BICS reg */
2806 #ifdef MODET
2807               if ((BITS (4, 7) & 0x9) == 0x9)
2808                 /* LDR immediate offset, no write-back, up, pre indexed.  */
2809                 LHPREUP ();
2810               /* Continue with instruction decoding.  */
2811 #endif
2812               rhs = DPSRegRHS;
2813               dest = LHS & ~rhs;
2814               WRITESDEST (dest);
2815               break;
2816
2817             case 0x1e:          /* MVN reg */
2818 #ifdef MODET
2819               if (BITS (4, 7) == 0xB)
2820                 {
2821                   /* STRH immediate offset, write-back, up, pre indexed.  */
2822                   SHPREUPWB ();
2823                   break;
2824                 }
2825               if (BITS (4, 7) == 0xD)
2826                 {
2827                   Handle_Load_Double (state, instr);
2828                   break;
2829                 }
2830               if (BITS (4, 7) == 0xF)
2831                 {
2832                   Handle_Store_Double (state, instr);
2833                   break;
2834                 }
2835 #endif
2836               dest = ~DPRegRHS;
2837               WRITEDEST (dest);
2838               break;
2839
2840             case 0x1f:          /* MVNS reg */
2841 #ifdef MODET
2842               if ((BITS (4, 7) & 0x9) == 0x9)
2843                 /* LDR immediate offset, write-back, up, pre indexed.  */
2844                 LHPREUPWB ();
2845               /* Continue instruction decoding.  */
2846 #endif
2847               dest = ~DPSRegRHS;
2848               WRITESDEST (dest);
2849               break;
2850
2851
2852               /* Data Processing Immediate RHS Instructions.  */
2853
2854             case 0x20:          /* AND immed */
2855               dest = LHS & DPImmRHS;
2856               WRITEDEST (dest);
2857               break;
2858
2859             case 0x21:          /* ANDS immed */
2860               DPSImmRHS;
2861               dest = LHS & rhs;
2862               WRITESDEST (dest);
2863               break;
2864
2865             case 0x22:          /* EOR immed */
2866               dest = LHS ^ DPImmRHS;
2867               WRITEDEST (dest);
2868               break;
2869
2870             case 0x23:          /* EORS immed */
2871               DPSImmRHS;
2872               dest = LHS ^ rhs;
2873               WRITESDEST (dest);
2874               break;
2875
2876             case 0x24:          /* SUB immed */
2877               dest = LHS - DPImmRHS;
2878               WRITEDEST (dest);
2879               break;
2880
2881             case 0x25:          /* SUBS immed */
2882               lhs = LHS;
2883               rhs = DPImmRHS;
2884               dest = lhs - rhs;
2885
2886               if ((lhs >= rhs) || ((rhs | lhs) >> 31))
2887                 {
2888                   ARMul_SubCarry (state, lhs, rhs, dest);
2889                   ARMul_SubOverflow (state, lhs, rhs, dest);
2890                 }
2891               else
2892                 {
2893                   CLEARC;
2894                   CLEARV;
2895                 }
2896               WRITESDEST (dest);
2897               break;
2898
2899             case 0x26:          /* RSB immed */
2900               dest = DPImmRHS - LHS;
2901               WRITEDEST (dest);
2902               break;
2903
2904             case 0x27:          /* RSBS immed */
2905               lhs = LHS;
2906               rhs = DPImmRHS;
2907               dest = rhs - lhs;
2908
2909               if ((rhs >= lhs) || ((rhs | lhs) >> 31))
2910                 {
2911                   ARMul_SubCarry (state, rhs, lhs, dest);
2912                   ARMul_SubOverflow (state, rhs, lhs, dest);
2913                 }
2914               else
2915                 {
2916                   CLEARC;
2917                   CLEARV;
2918                 }
2919               WRITESDEST (dest);
2920               break;
2921
2922             case 0x28:          /* ADD immed */
2923               dest = LHS + DPImmRHS;
2924               WRITEDEST (dest);
2925               break;
2926
2927             case 0x29:          /* ADDS immed */
2928               lhs = LHS;
2929               rhs = DPImmRHS;
2930               dest = lhs + rhs;
2931               ASSIGNZ (dest == 0);
2932
2933               if ((lhs | rhs) >> 30)
2934                 {
2935                   /* Possible C,V,N to set.  */
2936                   ASSIGNN (NEG (dest));
2937                   ARMul_AddCarry (state, lhs, rhs, dest);
2938                   ARMul_AddOverflow (state, lhs, rhs, dest);
2939                 }
2940               else
2941                 {
2942                   CLEARN;
2943                   CLEARC;
2944                   CLEARV;
2945                 }
2946               WRITESDEST (dest);
2947               break;
2948
2949             case 0x2a:          /* ADC immed */
2950               dest = LHS + DPImmRHS + CFLAG;
2951               WRITEDEST (dest);
2952               break;
2953
2954             case 0x2b:          /* ADCS immed */
2955               lhs = LHS;
2956               rhs = DPImmRHS;
2957               dest = lhs + rhs + CFLAG;
2958               ASSIGNZ (dest == 0);
2959               if ((lhs | rhs) >> 30)
2960                 {
2961                   /* Possible C,V,N to set.  */
2962                   ASSIGNN (NEG (dest));
2963                   ARMul_AddCarry (state, lhs, rhs, dest);
2964                   ARMul_AddOverflow (state, lhs, rhs, dest);
2965                 }
2966               else
2967                 {
2968                   CLEARN;
2969                   CLEARC;
2970                   CLEARV;
2971                 }
2972               WRITESDEST (dest);
2973               break;
2974
2975             case 0x2c:          /* SBC immed */
2976               dest = LHS - DPImmRHS - !CFLAG;
2977               WRITEDEST (dest);
2978               break;
2979
2980             case 0x2d:          /* SBCS immed */
2981               lhs = LHS;
2982               rhs = DPImmRHS;
2983               dest = lhs - rhs - !CFLAG;
2984               if ((lhs >= rhs) || ((rhs | lhs) >> 31))
2985                 {
2986                   ARMul_SubCarry (state, lhs, rhs, dest);
2987                   ARMul_SubOverflow (state, lhs, rhs, dest);
2988                 }
2989               else
2990                 {
2991                   CLEARC;
2992                   CLEARV;
2993                 }
2994               WRITESDEST (dest);
2995               break;
2996
2997             case 0x2e:          /* RSC immed */
2998               dest = DPImmRHS - LHS - !CFLAG;
2999               WRITEDEST (dest);
3000               break;
3001
3002             case 0x2f:          /* RSCS immed */
3003               lhs = LHS;
3004               rhs = DPImmRHS;
3005               dest = rhs - lhs - !CFLAG;
3006               if ((rhs >= lhs) || ((rhs | lhs) >> 31))
3007                 {
3008                   ARMul_SubCarry (state, rhs, lhs, dest);
3009                   ARMul_SubOverflow (state, rhs, lhs, dest);
3010                 }
3011               else
3012                 {
3013                   CLEARC;
3014                   CLEARV;
3015                 }
3016               WRITESDEST (dest);
3017               break;
3018
3019             case 0x30:          /* MOVW immed */
3020 #ifdef MODE32
3021               if (state->is_v6
3022                   && handle_v6_insn (state, instr))
3023                 break;
3024 #endif
3025               dest = BITS (0, 11);
3026               dest |= (BITS (16, 19) << 12);
3027               WRITEDEST (dest);
3028               break;
3029
3030             case 0x31:          /* TSTP immed */
3031               if (DESTReg == 15)
3032                 {
3033                   /* TSTP immed.  */
3034 #ifdef MODE32
3035                   state->Cpsr = GETSPSR (state->Bank);
3036                   ARMul_CPSRAltered (state);
3037 #else
3038                   temp = LHS & DPImmRHS;
3039                   SETR15PSR (temp);
3040 #endif
3041                 }
3042               else
3043                 {
3044                   /* TST immed.  */
3045                   DPSImmRHS;
3046                   dest = LHS & rhs;
3047                   ARMul_NegZero (state, dest);
3048                 }
3049               break;
3050
3051             case 0x32:          /* TEQ immed and MSR immed to CPSR */
3052               if (DESTReg == 15)
3053                 /* MSR immed to CPSR.  */
3054                 ARMul_FixCPSR (state, instr, DPImmRHS);
3055 #ifdef MODE32
3056               else if (state->is_v6
3057                        && handle_v6_insn (state, instr))
3058                 break;
3059 #endif
3060               else
3061                 UNDEF_Test;
3062               break;
3063
3064             case 0x33:          /* TEQP immed */
3065               if (DESTReg == 15)
3066                 {
3067                   /* TEQP immed.  */
3068 #ifdef MODE32
3069                   state->Cpsr = GETSPSR (state->Bank);
3070                   ARMul_CPSRAltered (state);
3071 #else
3072                   temp = LHS ^ DPImmRHS;
3073                   SETR15PSR (temp);
3074 #endif
3075                 }
3076               else
3077                 {
3078                   DPSImmRHS;    /* TEQ immed */
3079                   dest = LHS ^ rhs;
3080                   ARMul_NegZero (state, dest);
3081                 }
3082               break;
3083
3084             case 0x34:          /* MOVT immed */
3085 #ifdef MODE32
3086               if (state->is_v6
3087                   && handle_v6_insn (state, instr))
3088                 break;
3089 #endif
3090               DEST &= 0xFFFF;
3091               dest  = BITS (0, 11);
3092               dest |= (BITS (16, 19) << 12);
3093               DEST |= (dest << 16);
3094               break;
3095
3096             case 0x35:          /* CMPP immed */
3097               if (DESTReg == 15)
3098                 {
3099                   /* CMPP immed.  */
3100 #ifdef MODE32
3101                   state->Cpsr = GETSPSR (state->Bank);
3102                   ARMul_CPSRAltered (state);
3103 #else
3104                   temp = LHS - DPImmRHS;
3105                   SETR15PSR (temp);
3106 #endif
3107                   break;
3108                 }
3109               else
3110                 {
3111                   /* CMP immed.  */
3112                   lhs = LHS;
3113                   rhs = DPImmRHS;
3114                   dest = lhs - rhs;
3115                   ARMul_NegZero (state, dest);
3116
3117                   if ((lhs >= rhs) || ((rhs | lhs) >> 31))
3118                     {
3119                       ARMul_SubCarry (state, lhs, rhs, dest);
3120                       ARMul_SubOverflow (state, lhs, rhs, dest);
3121                     }
3122                   else
3123                     {
3124                       CLEARC;
3125                       CLEARV;
3126                     }
3127                 }
3128               break;
3129
3130             case 0x36:          /* CMN immed and MSR immed to SPSR */
3131               if (DESTReg == 15)
3132                 ARMul_FixSPSR (state, instr, DPImmRHS);
3133 #ifdef MODE32
3134               else if (state->is_v6
3135                        && handle_v6_insn (state, instr))
3136                 break;
3137 #endif
3138               else
3139                 UNDEF_Test;
3140               break;
3141
3142             case 0x37:          /* CMNP immed.  */
3143               if (DESTReg == 15)
3144                 {
3145                   /* CMNP immed.  */
3146 #ifdef MODE32
3147                   state->Cpsr = GETSPSR (state->Bank);
3148                   ARMul_CPSRAltered (state);
3149 #else
3150                   temp = LHS + DPImmRHS;
3151                   SETR15PSR (temp);
3152 #endif
3153                   break;
3154                 }
3155               else
3156                 {
3157                   /* CMN immed.  */
3158                   lhs = LHS;
3159                   rhs = DPImmRHS;
3160                   dest = lhs + rhs;
3161                   ASSIGNZ (dest == 0);
3162                   if ((lhs | rhs) >> 30)
3163                     {
3164                       /* Possible C,V,N to set.  */
3165                       ASSIGNN (NEG (dest));
3166                       ARMul_AddCarry (state, lhs, rhs, dest);
3167                       ARMul_AddOverflow (state, lhs, rhs, dest);
3168                     }
3169                   else
3170                     {
3171                       CLEARN;
3172                       CLEARC;
3173                       CLEARV;
3174                     }
3175                 }
3176               break;
3177
3178             case 0x38:          /* ORR immed.  */
3179               dest = LHS | DPImmRHS;
3180               WRITEDEST (dest);
3181               break;
3182
3183             case 0x39:          /* ORRS immed.  */
3184               DPSImmRHS;
3185               dest = LHS | rhs;
3186               WRITESDEST (dest);
3187               break;
3188
3189             case 0x3a:          /* MOV immed.  */
3190               dest = DPImmRHS;
3191               WRITEDEST (dest);
3192               break;
3193
3194             case 0x3b:          /* MOVS immed.  */
3195               DPSImmRHS;
3196               WRITESDEST (rhs);
3197               break;
3198
3199             case 0x3c:          /* BIC immed.  */
3200               dest = LHS & ~DPImmRHS;
3201               WRITEDEST (dest);
3202               break;
3203
3204             case 0x3d:          /* BICS immed.  */
3205               DPSImmRHS;
3206               dest = LHS & ~rhs;
3207               WRITESDEST (dest);
3208               break;
3209
3210             case 0x3e:          /* MVN immed.  */
3211               dest = ~DPImmRHS;
3212               WRITEDEST (dest);
3213               break;
3214
3215             case 0x3f:          /* MVNS immed.  */
3216               DPSImmRHS;
3217               WRITESDEST (~rhs);
3218               break;
3219
3220
3221               /* Single Data Transfer Immediate RHS Instructions.  */
3222
3223             case 0x40:          /* Store Word, No WriteBack, Post Dec, Immed.  */
3224               lhs = LHS;
3225               if (StoreWord (state, instr, lhs))
3226                 LSBase = lhs - LSImmRHS;
3227               break;
3228
3229             case 0x41:          /* Load Word, No WriteBack, Post Dec, Immed.  */
3230               lhs = LHS;
3231               if (LoadWord (state, instr, lhs))
3232                 LSBase = lhs - LSImmRHS;
3233               break;
3234
3235             case 0x42:          /* Store Word, WriteBack, Post Dec, Immed.  */
3236               UNDEF_LSRBaseEQDestWb;
3237               UNDEF_LSRPCBaseWb;
3238               lhs = LHS;
3239               temp = lhs - LSImmRHS;
3240               state->NtransSig = LOW;
3241               if (StoreWord (state, instr, lhs))
3242                 LSBase = temp;
3243               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3244               break;
3245
3246             case 0x43:          /* Load Word, WriteBack, Post Dec, Immed.  */
3247               UNDEF_LSRBaseEQDestWb;
3248               UNDEF_LSRPCBaseWb;
3249               lhs = LHS;
3250               state->NtransSig = LOW;
3251               if (LoadWord (state, instr, lhs))
3252                 LSBase = lhs - LSImmRHS;
3253               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3254               break;
3255
3256             case 0x44:          /* Store Byte, No WriteBack, Post Dec, Immed.  */
3257               lhs = LHS;
3258               if (StoreByte (state, instr, lhs))
3259                 LSBase = lhs - LSImmRHS;
3260               break;
3261
3262             case 0x45:          /* Load Byte, No WriteBack, Post Dec, Immed.  */
3263               lhs = LHS;
3264               if (LoadByte (state, instr, lhs, LUNSIGNED))
3265                 LSBase = lhs - LSImmRHS;
3266               break;
3267
3268             case 0x46:          /* Store Byte, WriteBack, Post Dec, Immed.  */
3269               UNDEF_LSRBaseEQDestWb;
3270               UNDEF_LSRPCBaseWb;
3271               lhs = LHS;
3272               state->NtransSig = LOW;
3273               if (StoreByte (state, instr, lhs))
3274                 LSBase = lhs - LSImmRHS;
3275               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3276               break;
3277
3278             case 0x47:          /* Load Byte, WriteBack, Post Dec, Immed.  */
3279               UNDEF_LSRBaseEQDestWb;
3280               UNDEF_LSRPCBaseWb;
3281               lhs = LHS;
3282               state->NtransSig = LOW;
3283               if (LoadByte (state, instr, lhs, LUNSIGNED))
3284                 LSBase = lhs - LSImmRHS;
3285               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3286               break;
3287
3288             case 0x48:          /* Store Word, No WriteBack, Post Inc, Immed.  */
3289               lhs = LHS;
3290               if (StoreWord (state, instr, lhs))
3291                 LSBase = lhs + LSImmRHS;
3292               break;
3293
3294             case 0x49:          /* Load Word, No WriteBack, Post Inc, Immed.  */
3295               lhs = LHS;
3296               if (LoadWord (state, instr, lhs))
3297                 LSBase = lhs + LSImmRHS;
3298               break;
3299
3300             case 0x4a:          /* Store Word, WriteBack, Post Inc, Immed.  */
3301               UNDEF_LSRBaseEQDestWb;
3302               UNDEF_LSRPCBaseWb;
3303               lhs = LHS;
3304               state->NtransSig = LOW;
3305               if (StoreWord (state, instr, lhs))
3306                 LSBase = lhs + LSImmRHS;
3307               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3308               break;
3309
3310             case 0x4b:          /* Load Word, WriteBack, Post Inc, Immed.  */
3311               UNDEF_LSRBaseEQDestWb;
3312               UNDEF_LSRPCBaseWb;
3313               lhs = LHS;
3314               state->NtransSig = LOW;
3315               if (LoadWord (state, instr, lhs))
3316                 LSBase = lhs + LSImmRHS;
3317               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3318               break;
3319
3320             case 0x4c:          /* Store Byte, No WriteBack, Post Inc, Immed.  */
3321               lhs = LHS;
3322               if (StoreByte (state, instr, lhs))
3323                 LSBase = lhs + LSImmRHS;
3324               break;
3325
3326             case 0x4d:          /* Load Byte, No WriteBack, Post Inc, Immed.  */
3327               lhs = LHS;
3328               if (LoadByte (state, instr, lhs, LUNSIGNED))
3329                 LSBase = lhs + LSImmRHS;
3330               break;
3331
3332             case 0x4e:          /* Store Byte, WriteBack, Post Inc, Immed.  */
3333               UNDEF_LSRBaseEQDestWb;
3334               UNDEF_LSRPCBaseWb;
3335               lhs = LHS;
3336               state->NtransSig = LOW;
3337               if (StoreByte (state, instr, lhs))
3338                 LSBase = lhs + LSImmRHS;
3339               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3340               break;
3341
3342             case 0x4f:          /* Load Byte, WriteBack, Post Inc, Immed.  */
3343               UNDEF_LSRBaseEQDestWb;
3344               UNDEF_LSRPCBaseWb;
3345               lhs = LHS;
3346               state->NtransSig = LOW;
3347               if (LoadByte (state, instr, lhs, LUNSIGNED))
3348                 LSBase = lhs + LSImmRHS;
3349               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3350               break;
3351
3352
3353             case 0x50:          /* Store Word, No WriteBack, Pre Dec, Immed.  */
3354               (void) StoreWord (state, instr, LHS - LSImmRHS);
3355               break;
3356
3357             case 0x51:          /* Load Word, No WriteBack, Pre Dec, Immed.  */
3358               (void) LoadWord (state, instr, LHS - LSImmRHS);
3359               break;
3360
3361             case 0x52:          /* Store Word, WriteBack, Pre Dec, Immed.  */
3362               UNDEF_LSRBaseEQDestWb;
3363               UNDEF_LSRPCBaseWb;
3364               temp = LHS - LSImmRHS;
3365               if (StoreWord (state, instr, temp))
3366                 LSBase = temp;
3367               break;
3368
3369             case 0x53:          /* Load Word, WriteBack, Pre Dec, Immed.  */
3370               UNDEF_LSRBaseEQDestWb;
3371               UNDEF_LSRPCBaseWb;
3372               temp = LHS - LSImmRHS;
3373               if (LoadWord (state, instr, temp))
3374                 LSBase = temp;
3375               break;
3376
3377             case 0x54:          /* Store Byte, No WriteBack, Pre Dec, Immed.  */
3378               (void) StoreByte (state, instr, LHS - LSImmRHS);
3379               break;
3380
3381             case 0x55:          /* Load Byte, No WriteBack, Pre Dec, Immed.  */
3382               (void) LoadByte (state, instr, LHS - LSImmRHS, LUNSIGNED);
3383               break;
3384
3385             case 0x56:          /* Store Byte, WriteBack, Pre Dec, Immed.  */
3386               UNDEF_LSRBaseEQDestWb;
3387               UNDEF_LSRPCBaseWb;
3388               temp = LHS - LSImmRHS;
3389               if (StoreByte (state, instr, temp))
3390                 LSBase = temp;
3391               break;
3392
3393             case 0x57:          /* Load Byte, WriteBack, Pre Dec, Immed.  */
3394               UNDEF_LSRBaseEQDestWb;
3395               UNDEF_LSRPCBaseWb;
3396               temp = LHS - LSImmRHS;
3397               if (LoadByte (state, instr, temp, LUNSIGNED))
3398                 LSBase = temp;
3399               break;
3400
3401             case 0x58:          /* Store Word, No WriteBack, Pre Inc, Immed.  */
3402               (void) StoreWord (state, instr, LHS + LSImmRHS);
3403               break;
3404
3405             case 0x59:          /* Load Word, No WriteBack, Pre Inc, Immed.  */
3406               (void) LoadWord (state, instr, LHS + LSImmRHS);
3407               break;
3408
3409             case 0x5a:          /* Store Word, WriteBack, Pre Inc, Immed.  */
3410               UNDEF_LSRBaseEQDestWb;
3411               UNDEF_LSRPCBaseWb;
3412               temp = LHS + LSImmRHS;
3413               if (StoreWord (state, instr, temp))
3414                 LSBase = temp;
3415               break;
3416
3417             case 0x5b:          /* Load Word, WriteBack, Pre Inc, Immed.  */
3418               UNDEF_LSRBaseEQDestWb;
3419               UNDEF_LSRPCBaseWb;
3420               temp = LHS + LSImmRHS;
3421               if (LoadWord (state, instr, temp))
3422                 LSBase = temp;
3423               break;
3424
3425             case 0x5c:          /* Store Byte, No WriteBack, Pre Inc, Immed.  */
3426               (void) StoreByte (state, instr, LHS + LSImmRHS);
3427               break;
3428
3429             case 0x5d:          /* Load Byte, No WriteBack, Pre Inc, Immed.  */
3430               (void) LoadByte (state, instr, LHS + LSImmRHS, LUNSIGNED);
3431               break;
3432
3433             case 0x5e:          /* Store Byte, WriteBack, Pre Inc, Immed.  */
3434               UNDEF_LSRBaseEQDestWb;
3435               UNDEF_LSRPCBaseWb;
3436               temp = LHS + LSImmRHS;
3437               if (StoreByte (state, instr, temp))
3438                 LSBase = temp;
3439               break;
3440
3441             case 0x5f:          /* Load Byte, WriteBack, Pre Inc, Immed.  */
3442               UNDEF_LSRBaseEQDestWb;
3443               UNDEF_LSRPCBaseWb;
3444               temp = LHS + LSImmRHS;
3445               if (LoadByte (state, instr, temp, LUNSIGNED))
3446                 LSBase = temp;
3447               break;
3448
3449
3450               /* Single Data Transfer Register RHS Instructions.  */
3451
3452             case 0x60:          /* Store Word, No WriteBack, Post Dec, Reg.  */
3453               if (BIT (4))
3454                 {
3455 #ifdef MODE32
3456                   if (state->is_v6
3457                       && handle_v6_insn (state, instr))
3458                     break;
3459 #endif
3460                   ARMul_UndefInstr (state, instr);
3461                   break;
3462                 }
3463               UNDEF_LSRBaseEQOffWb;
3464               UNDEF_LSRBaseEQDestWb;
3465               UNDEF_LSRPCBaseWb;
3466               UNDEF_LSRPCOffWb;
3467               lhs = LHS;
3468               if (StoreWord (state, instr, lhs))
3469                 LSBase = lhs - LSRegRHS;
3470               break;
3471
3472             case 0x61:          /* Load Word, No WriteBack, Post Dec, Reg.  */
3473               if (BIT (4))
3474                 {
3475 #ifdef MODE32
3476                   if (state->is_v6
3477                       && handle_v6_insn (state, instr))
3478                     break;
3479 #endif
3480                   ARMul_UndefInstr (state, instr);
3481                   break;
3482                 }
3483               UNDEF_LSRBaseEQOffWb;
3484               UNDEF_LSRBaseEQDestWb;
3485               UNDEF_LSRPCBaseWb;
3486               UNDEF_LSRPCOffWb;
3487               lhs = LHS;
3488               temp = lhs - LSRegRHS;
3489               if (LoadWord (state, instr, lhs))
3490                 LSBase = temp;
3491               break;
3492
3493             case 0x62:          /* Store Word, WriteBack, Post Dec, Reg.  */
3494               if (BIT (4))
3495                 {
3496 #ifdef MODE32
3497                   if (state->is_v6
3498                       && handle_v6_insn (state, instr))
3499                     break;
3500 #endif
3501                   ARMul_UndefInstr (state, instr);
3502                   break;
3503                 }
3504               UNDEF_LSRBaseEQOffWb;
3505               UNDEF_LSRBaseEQDestWb;
3506               UNDEF_LSRPCBaseWb;
3507               UNDEF_LSRPCOffWb;
3508               lhs = LHS;
3509               state->NtransSig = LOW;
3510               if (StoreWord (state, instr, lhs))
3511                 LSBase = lhs - LSRegRHS;
3512               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3513               break;
3514
3515             case 0x63:          /* Load Word, WriteBack, Post Dec, Reg.  */
3516               if (BIT (4))
3517                 {
3518 #ifdef MODE32
3519                   if (state->is_v6
3520                       && handle_v6_insn (state, instr))
3521                     break;
3522 #endif
3523                   ARMul_UndefInstr (state, instr);
3524                   break;
3525                 }
3526               UNDEF_LSRBaseEQOffWb;
3527               UNDEF_LSRBaseEQDestWb;
3528               UNDEF_LSRPCBaseWb;
3529               UNDEF_LSRPCOffWb;
3530               lhs = LHS;
3531               temp = lhs - LSRegRHS;
3532               state->NtransSig = LOW;
3533               if (LoadWord (state, instr, lhs))
3534                 LSBase = temp;
3535               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3536               break;
3537
3538             case 0x64:          /* Store Byte, No WriteBack, Post Dec, Reg.  */
3539               if (BIT (4))
3540                 {
3541 #ifdef MODE32
3542                   if (state->is_v6
3543                       && handle_v6_insn (state, instr))
3544                     break;
3545 #endif
3546                   ARMul_UndefInstr (state, instr);
3547                   break;
3548                 }
3549               UNDEF_LSRBaseEQOffWb;
3550               UNDEF_LSRBaseEQDestWb;
3551               UNDEF_LSRPCBaseWb;
3552               UNDEF_LSRPCOffWb;
3553               lhs = LHS;
3554               if (StoreByte (state, instr, lhs))
3555                 LSBase = lhs - LSRegRHS;
3556               break;
3557
3558             case 0x65:          /* Load Byte, No WriteBack, Post Dec, Reg.  */
3559               if (BIT (4))
3560                 {
3561 #ifdef MODE32
3562                   if (state->is_v6
3563                       && handle_v6_insn (state, instr))
3564                     break;
3565 #endif
3566                   ARMul_UndefInstr (state, instr);
3567                   break;
3568                 }
3569               UNDEF_LSRBaseEQOffWb;
3570               UNDEF_LSRBaseEQDestWb;
3571               UNDEF_LSRPCBaseWb;
3572               UNDEF_LSRPCOffWb;
3573               lhs = LHS;
3574               temp = lhs - LSRegRHS;
3575               if (LoadByte (state, instr, lhs, LUNSIGNED))
3576                 LSBase = temp;
3577               break;
3578
3579             case 0x66:          /* Store Byte, WriteBack, Post Dec, Reg.  */
3580               if (BIT (4))
3581                 {
3582 #ifdef MODE32
3583                   if (state->is_v6
3584                       && handle_v6_insn (state, instr))
3585                     break;
3586 #endif
3587                   ARMul_UndefInstr (state, instr);
3588                   break;
3589                 }
3590               UNDEF_LSRBaseEQOffWb;
3591               UNDEF_LSRBaseEQDestWb;
3592               UNDEF_LSRPCBaseWb;
3593               UNDEF_LSRPCOffWb;
3594               lhs = LHS;
3595               state->NtransSig = LOW;
3596               if (StoreByte (state, instr, lhs))
3597                 LSBase = lhs - LSRegRHS;
3598               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3599               break;
3600
3601             case 0x67:          /* Load Byte, WriteBack, Post Dec, Reg.  */
3602               if (BIT (4))
3603                 {
3604 #ifdef MODE32
3605                   if (state->is_v6
3606                       && handle_v6_insn (state, instr))
3607                     break;
3608 #endif
3609                   ARMul_UndefInstr (state, instr);
3610                   break;
3611                 }
3612               UNDEF_LSRBaseEQOffWb;
3613               UNDEF_LSRBaseEQDestWb;
3614               UNDEF_LSRPCBaseWb;
3615               UNDEF_LSRPCOffWb;
3616               lhs = LHS;
3617               temp = lhs - LSRegRHS;
3618               state->NtransSig = LOW;
3619               if (LoadByte (state, instr, lhs, LUNSIGNED))
3620                 LSBase = temp;
3621               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3622               break;
3623
3624             case 0x68:          /* Store Word, No WriteBack, Post Inc, Reg.  */
3625               if (BIT (4))
3626                 {
3627 #ifdef MODE32
3628                   if (state->is_v6
3629                       && handle_v6_insn (state, instr))
3630                     break;
3631 #endif
3632                   ARMul_UndefInstr (state, instr);
3633                   break;
3634                 }
3635               UNDEF_LSRBaseEQOffWb;
3636               UNDEF_LSRBaseEQDestWb;
3637               UNDEF_LSRPCBaseWb;
3638               UNDEF_LSRPCOffWb;
3639               lhs = LHS;
3640               if (StoreWord (state, instr, lhs))
3641                 LSBase = lhs + LSRegRHS;
3642               break;
3643
3644             case 0x69:          /* Load Word, No WriteBack, Post Inc, Reg.  */
3645               if (BIT (4))
3646                 {
3647 #ifdef MODE32
3648                   if (state->is_v6
3649                       && handle_v6_insn (state, instr))
3650                     break;
3651 #endif
3652                   ARMul_UndefInstr (state, instr);
3653                   break;
3654                 }
3655               UNDEF_LSRBaseEQOffWb;
3656               UNDEF_LSRBaseEQDestWb;
3657               UNDEF_LSRPCBaseWb;
3658               UNDEF_LSRPCOffWb;
3659               lhs = LHS;
3660               temp = lhs + LSRegRHS;
3661               if (LoadWord (state, instr, lhs))
3662                 LSBase = temp;
3663               break;
3664
3665             case 0x6a:          /* Store Word, WriteBack, Post Inc, Reg.  */
3666               if (BIT (4))
3667                 {
3668 #ifdef MODE32
3669                   if (state->is_v6
3670                       && handle_v6_insn (state, instr))
3671                     break;
3672 #endif
3673                   ARMul_UndefInstr (state, instr);
3674                   break;
3675                 }
3676               UNDEF_LSRBaseEQOffWb;
3677               UNDEF_LSRBaseEQDestWb;
3678               UNDEF_LSRPCBaseWb;
3679               UNDEF_LSRPCOffWb;
3680               lhs = LHS;
3681               state->NtransSig = LOW;
3682               if (StoreWord (state, instr, lhs))
3683                 LSBase = lhs + LSRegRHS;
3684               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3685               break;
3686
3687             case 0x6b:          /* Load Word, WriteBack, Post Inc, Reg.  */
3688               if (BIT (4))
3689                 {
3690 #ifdef MODE32
3691                   if (state->is_v6
3692                       && handle_v6_insn (state, instr))
3693                     break;
3694 #endif
3695                   ARMul_UndefInstr (state, instr);
3696                   break;
3697                 }
3698               UNDEF_LSRBaseEQOffWb;
3699               UNDEF_LSRBaseEQDestWb;
3700               UNDEF_LSRPCBaseWb;
3701               UNDEF_LSRPCOffWb;
3702               lhs = LHS;
3703               temp = lhs + LSRegRHS;
3704               state->NtransSig = LOW;
3705               if (LoadWord (state, instr, lhs))
3706                 LSBase = temp;
3707               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3708               break;
3709
3710             case 0x6c:          /* Store Byte, No WriteBack, Post Inc, Reg.  */
3711               if (BIT (4))
3712                 {
3713 #ifdef MODE32
3714                   if (state->is_v6
3715                       && handle_v6_insn (state, instr))
3716                     break;
3717 #endif
3718                   ARMul_UndefInstr (state, instr);
3719                   break;
3720                 }
3721               UNDEF_LSRBaseEQOffWb;
3722               UNDEF_LSRBaseEQDestWb;
3723               UNDEF_LSRPCBaseWb;
3724               UNDEF_LSRPCOffWb;
3725               lhs = LHS;
3726               if (StoreByte (state, instr, lhs))
3727                 LSBase = lhs + LSRegRHS;
3728               break;
3729
3730             case 0x6d:          /* Load Byte, No WriteBack, Post Inc, Reg.  */
3731               if (BIT (4))
3732                 {
3733 #ifdef MODE32
3734                   if (state->is_v6
3735                       && handle_v6_insn (state, instr))
3736                     break;
3737 #endif
3738                   ARMul_UndefInstr (state, instr);
3739                   break;
3740                 }
3741               UNDEF_LSRBaseEQOffWb;
3742               UNDEF_LSRBaseEQDestWb;
3743               UNDEF_LSRPCBaseWb;
3744               UNDEF_LSRPCOffWb;
3745               lhs = LHS;
3746               temp = lhs + LSRegRHS;
3747               if (LoadByte (state, instr, lhs, LUNSIGNED))
3748                 LSBase = temp;
3749               break;
3750
3751             case 0x6e:          /* Store Byte, WriteBack, Post Inc, Reg.  */
3752               if (BIT (4))
3753                 {
3754 #ifdef MODE32
3755                   if (state->is_v6
3756                       && handle_v6_insn (state, instr))
3757                     break;
3758 #endif
3759                   ARMul_UndefInstr (state, instr);
3760                   break;
3761                 }
3762               UNDEF_LSRBaseEQOffWb;
3763               UNDEF_LSRBaseEQDestWb;
3764               UNDEF_LSRPCBaseWb;
3765               UNDEF_LSRPCOffWb;
3766               lhs = LHS;
3767               state->NtransSig = LOW;
3768               if (StoreByte (state, instr, lhs))
3769                 LSBase = lhs + LSRegRHS;
3770               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3771               break;
3772
3773             case 0x6f:          /* Load Byte, WriteBack, Post Inc, Reg.  */
3774               if (BIT (4))
3775                 {
3776 #ifdef MODE32
3777                   if (state->is_v6
3778                       && handle_v6_insn (state, instr))
3779                     break;
3780 #endif
3781                   ARMul_UndefInstr (state, instr);
3782                   break;
3783                 }
3784               UNDEF_LSRBaseEQOffWb;
3785               UNDEF_LSRBaseEQDestWb;
3786               UNDEF_LSRPCBaseWb;
3787               UNDEF_LSRPCOffWb;
3788               lhs = LHS;
3789               temp = lhs + LSRegRHS;
3790               state->NtransSig = LOW;
3791               if (LoadByte (state, instr, lhs, LUNSIGNED))
3792                 LSBase = temp;
3793               state->NtransSig = (state->Mode & 3) ? HIGH : LOW;
3794               break;
3795
3796
3797             case 0x70:          /* Store Word, No WriteBack, Pre Dec, Reg.  */
3798               if (BIT (4))
3799                 {
3800 #ifdef MODE32
3801                   if (state->is_v6
3802                       && handle_v6_insn (state, instr))
3803                     break;
3804 #endif
3805                   ARMul_UndefInstr (state, instr);
3806                   break;
3807                 }
3808               (void) StoreWord (state, instr, LHS - LSRegRHS);
3809               break;
3810
3811             case 0x71:          /* Load Word, No WriteBack, Pre Dec, Reg.  */
3812               if (BIT (4))
3813                 {
3814 #ifdef MODE32
3815                   if (state->is_v6
3816                       && handle_v6_insn (state, instr))
3817                     break;
3818 #endif
3819                   ARMul_UndefInstr (state, instr);
3820                   break;
3821                 }
3822               (void) LoadWord (state, instr, LHS - LSRegRHS);
3823               break;
3824
3825             case 0x72:          /* Store Word, WriteBack, Pre Dec, Reg.  */
3826               if (BIT (4))
3827                 {
3828 #ifdef MODE32
3829                   if (state->is_v6
3830                       && handle_v6_insn (state, instr))
3831                     break;
3832 #endif
3833                   ARMul_UndefInstr (state, instr);
3834                   break;
3835                 }
3836               UNDEF_LSRBaseEQOffWb;
3837               UNDEF_LSRBaseEQDestWb;
3838               UNDEF_LSRPCBaseWb;
3839               UNDEF_LSRPCOffWb;
3840               temp = LHS - LSRegRHS;
3841               if (StoreWord (state, instr, temp))
3842                 LSBase = temp;
3843               break;
3844
3845             case 0x73:          /* Load Word, WriteBack, Pre Dec, Reg.  */
3846               if (BIT (4))
3847                 {
3848 #ifdef MODE32
3849                   if (state->is_v6
3850                       && handle_v6_insn (state, instr))
3851                     break;
3852 #endif
3853                   ARMul_UndefInstr (state, instr);
3854                   break;
3855                 }
3856               UNDEF_LSRBaseEQOffWb;
3857               UNDEF_LSRBaseEQDestWb;
3858               UNDEF_LSRPCBaseWb;
3859               UNDEF_LSRPCOffWb;
3860               temp = LHS - LSRegRHS;
3861               if (LoadWord (state, instr, temp))
3862                 LSBase = temp;
3863               break;
3864
3865             case 0x74:          /* Store Byte, No WriteBack, Pre Dec, Reg.  */
3866               if (BIT (4))
3867                 {
3868 #ifdef MODE32
3869                   if (state->is_v6
3870                       && handle_v6_insn (state, instr))
3871                     break;
3872 #endif
3873                   ARMul_UndefInstr (state, instr);
3874                   break;
3875                 }
3876               (void) StoreByte (state, instr, LHS - LSRegRHS);
3877               break;
3878
3879             case 0x75:          /* Load Byte, No WriteBack, Pre Dec, Reg.  */
3880               if (BIT (4))
3881                 {
3882 #ifdef MODE32
3883                   if (state->is_v6
3884                       && handle_v6_insn (state, instr))
3885                     break;
3886 #endif
3887                   ARMul_UndefInstr (state, instr);
3888                   break;
3889                 }
3890               (void) LoadByte (state, instr, LHS - LSRegRHS, LUNSIGNED);
3891               break;
3892
3893             case 0x76:          /* Store Byte, WriteBack, Pre Dec, Reg.  */
3894               if (BIT (4))
3895                 {
3896 #ifdef MODE32
3897                   if (state->is_v6
3898                       && handle_v6_insn (state, instr))
3899                     break;
3900 #endif
3901                   ARMul_UndefInstr (state, instr);
3902                   break;
3903                 }
3904               UNDEF_LSRBaseEQOffWb;
3905               UNDEF_LSRBaseEQDestWb;
3906               UNDEF_LSRPCBaseWb;
3907               UNDEF_LSRPCOffWb;
3908               temp = LHS - LSRegRHS;
3909               if (StoreByte (state, instr, temp))
3910                 LSBase = temp;
3911               break;
3912
3913             case 0x77:          /* Load Byte, WriteBack, Pre Dec, Reg.  */
3914               if (BIT (4))
3915                 {
3916 #ifdef MODE32
3917                   if (state->is_v6
3918                       && handle_v6_insn (state, instr))
3919                     break;
3920 #endif
3921                   ARMul_UndefInstr (state, instr);
3922                   break;
3923                 }
3924               UNDEF_LSRBaseEQOffWb;
3925               UNDEF_LSRBaseEQDestWb;
3926               UNDEF_LSRPCBaseWb;
3927               UNDEF_LSRPCOffWb;
3928               temp = LHS - LSRegRHS;
3929               if (LoadByte (state, instr, temp, LUNSIGNED))
3930                 LSBase = temp;
3931               break;
3932
3933             case 0x78:          /* Store Word, No WriteBack, Pre Inc, Reg.  */
3934               if (BIT (4))
3935                 {
3936 #ifdef MODE32
3937                   if (state->is_v6
3938                       && handle_v6_insn (state, instr))
3939                     break;
3940 #endif
3941                   ARMul_UndefInstr (state, instr);
3942                   break;
3943                 }
3944               (void) StoreWord (state, instr, LHS + LSRegRHS);
3945               break;
3946
3947             case 0x79:          /* Load Word, No WriteBack, Pre Inc, Reg.  */
3948               if (BIT (4))
3949                 {
3950 #ifdef MODE32
3951                   if (state->is_v6
3952                       && handle_v6_insn (state, instr))
3953                     break;
3954 #endif
3955                   ARMul_UndefInstr (state, instr);
3956                   break;
3957                 }
3958               (void) LoadWord (state, instr, LHS + LSRegRHS);
3959               break;
3960
3961             case 0x7a:          /* Store Word, WriteBack, Pre Inc, Reg.  */
3962               if (BIT (4))
3963                 {
3964 #ifdef MODE32
3965                   if (state->is_v6
3966                       && handle_v6_insn (state, instr))
3967                     break;
3968 #endif
3969                   ARMul_UndefInstr (state, instr);
3970                   break;
3971                 }
3972               UNDEF_LSRBaseEQOffWb;
3973               UNDEF_LSRBaseEQDestWb;
3974               UNDEF_LSRPCBaseWb;
3975               UNDEF_LSRPCOffWb;
3976               temp = LHS + LSRegRHS;
3977               if (StoreWord (state, instr, temp))
3978                 LSBase = temp;
3979               break;
3980
3981             case 0x7b:          /* Load Word, WriteBack, Pre Inc, Reg.  */
3982               if (BIT (4))
3983                 {
3984 #ifdef MODE32
3985                   if (state->is_v6
3986                       && handle_v6_insn (state, instr))
3987                     break;
3988 #endif
3989                   ARMul_UndefInstr (state, instr);
3990                   break;
3991                 }
3992               UNDEF_LSRBaseEQOffWb;
3993               UNDEF_LSRBaseEQDestWb;
3994               UNDEF_LSRPCBaseWb;
3995               UNDEF_LSRPCOffWb;
3996               temp = LHS + LSRegRHS;
3997               if (LoadWord (state, instr, temp))
3998                 LSBase = temp;
3999               break;
4000
4001             case 0x7c:          /* Store Byte, No WriteBack, Pre Inc, Reg.  */
4002               if (BIT (4))
4003                 {
4004 #ifdef MODE32
4005                   if (state->is_v6
4006                       && handle_v6_insn (state, instr))
4007                     break;
4008 #endif
4009                   ARMul_UndefInstr (state, instr);
4010                   break;
4011                 }
4012               (void) StoreByte (state, instr, LHS + LSRegRHS);
4013               break;
4014
4015             case 0x7d:          /* Load Byte, No WriteBack, Pre Inc, Reg.  */
4016               if (BIT (4))
4017                 {
4018 #ifdef MODE32
4019                   if (state->is_v6
4020                       && handle_v6_insn (state, instr))
4021                     break;
4022 #endif
4023                   ARMul_UndefInstr (state, instr);
4024                   break;
4025                 }
4026               (void) LoadByte (state, instr, LHS + LSRegRHS, LUNSIGNED);
4027               break;
4028
4029             case 0x7e:          /* Store Byte, WriteBack, Pre Inc, Reg.  */
4030               if (BIT (4))
4031                 {
4032 #ifdef MODE32
4033                   if (state->is_v6
4034                       && handle_v6_insn (state, instr))
4035                     break;
4036 #endif
4037                   ARMul_UndefInstr (state, instr);
4038                   break;
4039                 }
4040               UNDEF_LSRBaseEQOffWb;
4041               UNDEF_LSRBaseEQDestWb;
4042               UNDEF_LSRPCBaseWb;
4043               UNDEF_LSRPCOffWb;
4044               temp = LHS + LSRegRHS;
4045               if (StoreByte (state, instr, temp))
4046                 LSBase = temp;
4047               break;
4048
4049             case 0x7f:          /* Load Byte, WriteBack, Pre Inc, Reg.  */
4050               if (BIT (4))
4051                 {
4052                   /* Check for the special breakpoint opcode.
4053                      This value should correspond to the value defined
4054                      as ARM_BE_BREAKPOINT in gdb/arm/tm-arm.h.  */
4055                   if (BITS (0, 19) == 0xfdefe)
4056                     {
4057                       if (!ARMul_OSHandleSWI (state, SWI_Breakpoint))
4058                         ARMul_Abort (state, ARMul_SWIV);
4059                     }
4060 #ifdef MODE32
4061                   else if (state->is_v6
4062                            && handle_v6_insn (state, instr))
4063                     break;
4064 #endif
4065                   else
4066                     ARMul_UndefInstr (state, instr);
4067                   break;
4068                 }
4069               UNDEF_LSRBaseEQOffWb;
4070               UNDEF_LSRBaseEQDestWb;
4071               UNDEF_LSRPCBaseWb;
4072               UNDEF_LSRPCOffWb;
4073               temp = LHS + LSRegRHS;
4074               if (LoadByte (state, instr, temp, LUNSIGNED))
4075                 LSBase = temp;
4076               break;
4077
4078
4079               /* Multiple Data Transfer Instructions.  */
4080
4081             case 0x80:          /* Store, No WriteBack, Post Dec.  */
4082               STOREMULT (instr, LSBase - LSMNumRegs + 4L, 0L);
4083               break;
4084
4085             case 0x81:          /* Load, No WriteBack, Post Dec.  */
4086               LOADMULT (instr, LSBase - LSMNumRegs + 4L, 0L);
4087               break;
4088
4089             case 0x82:          /* Store, WriteBack, Post Dec.  */
4090               temp = LSBase - LSMNumRegs;
4091               STOREMULT (instr, temp + 4L, temp);
4092               break;
4093
4094             case 0x83:          /* Load, WriteBack, Post Dec.  */
4095               temp = LSBase - LSMNumRegs;
4096               LOADMULT (instr, temp + 4L, temp);
4097               break;
4098
4099             case 0x84:          /* Store, Flags, No WriteBack, Post Dec.  */
4100               STORESMULT (instr, LSBase - LSMNumRegs + 4L, 0L);
4101               break;
4102
4103             case 0x85:          /* Load, Flags, No WriteBack, Post Dec.  */
4104               LOADSMULT (instr, LSBase - LSMNumRegs + 4L, 0L);
4105               break;
4106
4107             case 0x86:          /* Store, Flags, WriteBack, Post Dec.  */
4108               temp = LSBase - LSMNumRegs;
4109               STORESMULT (instr, temp + 4L, temp);
4110               break;
4111
4112             case 0x87:          /* Load, Flags, WriteBack, Post Dec.  */
4113               temp = LSBase - LSMNumRegs;
4114               LOADSMULT (instr, temp + 4L, temp);
4115               break;
4116
4117             case 0x88:          /* Store, No WriteBack, Post Inc.  */
4118               STOREMULT (instr, LSBase, 0L);
4119               break;
4120
4121             case 0x89:          /* Load, No WriteBack, Post Inc.  */
4122               LOADMULT (instr, LSBase, 0L);
4123               break;
4124
4125             case 0x8a:          /* Store, WriteBack, Post Inc.  */
4126               temp = LSBase;
4127               STOREMULT (instr, temp, temp + LSMNumRegs);
4128               break;
4129
4130             case 0x8b:          /* Load, WriteBack, Post Inc.  */
4131               temp = LSBase;
4132               LOADMULT (instr, temp, temp + LSMNumRegs);
4133               break;
4134
4135             case 0x8c:          /* Store, Flags, No WriteBack, Post Inc.  */
4136               STORESMULT (instr, LSBase, 0L);
4137               break;
4138
4139             case 0x8d:          /* Load, Flags, No WriteBack, Post Inc.  */
4140               LOADSMULT (instr, LSBase, 0L);
4141               break;
4142
4143             case 0x8e:          /* Store, Flags, WriteBack, Post Inc.  */
4144               temp = LSBase;
4145               STORESMULT (instr, temp, temp + LSMNumRegs);
4146               break;
4147
4148             case 0x8f:          /* Load, Flags, WriteBack, Post Inc.  */
4149               temp = LSBase;
4150               LOADSMULT (instr, temp, temp + LSMNumRegs);
4151               break;
4152
4153             case 0x90:          /* Store, No WriteBack, Pre Dec.  */
4154               STOREMULT (instr, LSBase - LSMNumRegs, 0L);
4155               break;
4156
4157             case 0x91:          /* Load, No WriteBack, Pre Dec.  */
4158               LOADMULT (instr, LSBase - LSMNumRegs, 0L);
4159               break;
4160
4161             case 0x92:          /* Store, WriteBack, Pre Dec.  */
4162               temp = LSBase - LSMNumRegs;
4163               STOREMULT (instr, temp, temp);
4164               break;
4165
4166             case 0x93:          /* Load, WriteBack, Pre Dec.  */
4167               temp = LSBase - LSMNumRegs;
4168               LOADMULT (instr, temp, temp);
4169               break;
4170
4171             case 0x94:          /* Store, Flags, No WriteBack, Pre Dec.  */
4172               STORESMULT (instr, LSBase - LSMNumRegs, 0L);
4173               break;
4174
4175             case 0x95:          /* Load, Flags, No WriteBack, Pre Dec.  */
4176               LOADSMULT (instr, LSBase - LSMNumRegs, 0L);
4177               break;
4178
4179             case 0x96:          /* Store, Flags, WriteBack, Pre Dec.  */
4180               temp = LSBase - LSMNumRegs;
4181               STORESMULT (instr, temp, temp);
4182               break;
4183
4184             case 0x97:          /* Load, Flags, WriteBack, Pre Dec.  */
4185               temp = LSBase - LSMNumRegs;
4186               LOADSMULT (instr, temp, temp);
4187               break;
4188
4189             case 0x98:          /* Store, No WriteBack, Pre Inc.  */
4190               STOREMULT (instr, LSBase + 4L, 0L);
4191               break;
4192
4193             case 0x99:          /* Load, No WriteBack, Pre Inc.  */
4194               LOADMULT (instr, LSBase + 4L, 0L);
4195               break;
4196
4197             case 0x9a:          /* Store, WriteBack, Pre Inc.  */
4198               temp = LSBase;
4199               STOREMULT (instr, temp + 4L, temp + LSMNumRegs);
4200               break;
4201
4202             case 0x9b:          /* Load, WriteBack, Pre Inc.  */
4203               temp = LSBase;
4204               LOADMULT (instr, temp + 4L, temp + LSMNumRegs);
4205               break;
4206
4207             case 0x9c:          /* Store, Flags, No WriteBack, Pre Inc.  */
4208               STORESMULT (instr, LSBase + 4L, 0L);
4209               break;
4210
4211             case 0x9d:          /* Load, Flags, No WriteBack, Pre Inc.  */
4212               LOADSMULT (instr, LSBase + 4L, 0L);
4213               break;
4214
4215             case 0x9e:          /* Store, Flags, WriteBack, Pre Inc.  */
4216               temp = LSBase;
4217               STORESMULT (instr, temp + 4L, temp + LSMNumRegs);
4218               break;
4219
4220             case 0x9f:          /* Load, Flags, WriteBack, Pre Inc.  */
4221               temp = LSBase;
4222               LOADSMULT (instr, temp + 4L, temp + LSMNumRegs);
4223               break;
4224
4225
4226               /* Branch forward.  */
4227             case 0xa0:
4228             case 0xa1:
4229             case 0xa2:
4230             case 0xa3:
4231             case 0xa4:
4232             case 0xa5:
4233             case 0xa6:
4234             case 0xa7:
4235               state->Reg[15] = pc + 8 + POSBRANCH;
4236               FLUSHPIPE;
4237               break;
4238
4239
4240               /* Branch backward.  */
4241             case 0xa8:
4242             case 0xa9:
4243             case 0xaa:
4244             case 0xab:
4245             case 0xac:
4246             case 0xad:
4247             case 0xae:
4248             case 0xaf:
4249               state->Reg[15] = pc + 8 + NEGBRANCH;
4250               FLUSHPIPE;
4251               break;
4252
4253               /* Branch and Link forward.  */
4254             case 0xb0:
4255             case 0xb1:
4256             case 0xb2:
4257             case 0xb3:
4258             case 0xb4:
4259             case 0xb5:
4260             case 0xb6:
4261             case 0xb7:
4262               /* Put PC into Link.  */
4263 #ifdef MODE32
4264               state->Reg[14] = pc + 4;
4265 #else
4266               state->Reg[14] = (pc + 4) | ECC | ER15INT | EMODE;
4267 #endif
4268               state->Reg[15] = pc + 8 + POSBRANCH;
4269               FLUSHPIPE;
4270               if (trace_funcs)
4271                 fprintf (stderr, " pc changed to %x\n", state->Reg[15]);
4272               break;
4273
4274               /* Branch and Link backward.  */
4275             case 0xb8:
4276             case 0xb9:
4277             case 0xba:
4278             case 0xbb:
4279             case 0xbc:
4280             case 0xbd:
4281             case 0xbe:
4282             case 0xbf:
4283               /* Put PC into Link.  */
4284 #ifdef MODE32
4285               state->Reg[14] = pc + 4;
4286 #else
4287               state->Reg[14] = (pc + 4) | ECC | ER15INT | EMODE;
4288 #endif
4289               state->Reg[15] = pc + 8 + NEGBRANCH;
4290               FLUSHPIPE;
4291               if (trace_funcs)
4292                 fprintf (stderr, " pc changed to %x\n", state->Reg[15]);
4293               break;
4294
4295               /* Co-Processor Data Transfers.  */
4296             case 0xc4:
4297               if (state->is_v5)
4298                 {
4299                   if (CPNum == 10 || CPNum == 11)
4300                     handle_VFP_move (state, instr);
4301                   /* Reading from R15 is UNPREDICTABLE.  */
4302                   else if (BITS (12, 15) == 15 || BITS (16, 19) == 15)
4303                     ARMul_UndefInstr (state, instr);
4304                   /* Is access to coprocessor 0 allowed ?  */
4305                   else if (! CP_ACCESS_ALLOWED (state, CPNum))
4306                     ARMul_UndefInstr (state, instr);
4307                   /* Special treatment for XScale coprocessors.  */
4308                   else if (state->is_XScale)
4309                     {
4310                       /* Only opcode 0 is supported.  */
4311                       if (BITS (4, 7) != 0x00)
4312                         ARMul_UndefInstr (state, instr);
4313                       /* Only coporcessor 0 is supported.  */
4314                       else if (CPNum != 0x00)
4315                         ARMul_UndefInstr (state, instr);
4316                       /* Only accumulator 0 is supported.  */
4317                       else if (BITS (0, 3) != 0x00)
4318                         ARMul_UndefInstr (state, instr);
4319                       else
4320                         {
4321                           /* XScale MAR insn.  Move two registers into accumulator.  */
4322                           state->Accumulator = state->Reg[BITS (12, 15)];
4323                           state->Accumulator += (ARMdword) state->Reg[BITS (16, 19)] << 32;
4324                         }
4325                     }
4326                   else
4327                     /* FIXME: Not sure what to do for other v5 processors.  */
4328                     ARMul_UndefInstr (state, instr);
4329                   break;
4330                 }
4331               /* Drop through.  */
4332
4333             case 0xc0:          /* Store , No WriteBack , Post Dec.  */
4334               ARMul_STC (state, instr, LHS);
4335               break;
4336
4337             case 0xc5:
4338               if (state->is_v5)
4339                 {
4340                   if (CPNum == 10 || CPNum == 11)
4341                     handle_VFP_move (state, instr);
4342                   /* Writes to R15 are UNPREDICATABLE.  */
4343                   else if (DESTReg == 15 || LHSReg == 15)
4344                     ARMul_UndefInstr (state, instr);
4345                   /* Is access to the coprocessor allowed ?  */
4346                   else if (! CP_ACCESS_ALLOWED (state, CPNum))
4347                     ARMul_UndefInstr (state, instr);
4348                   /* Special handling for XScale coprcoessors.  */
4349                   else if (state->is_XScale)
4350                     {
4351                       /* Only opcode 0 is supported.  */
4352                       if (BITS (4, 7) != 0x00)
4353                         ARMul_UndefInstr (state, instr);
4354                       /* Only coprocessor 0 is supported.  */
4355                       else if (CPNum != 0x00)
4356                         ARMul_UndefInstr (state, instr);
4357                       /* Only accumulator 0 is supported.  */
4358                       else if (BITS (0, 3) != 0x00)
4359                         ARMul_UndefInstr (state, instr);
4360                       else
4361                         {
4362                           /* XScale MRA insn.  Move accumulator into two registers.  */
4363                           ARMword t1 = (state->Accumulator >> 32) & 255;
4364
4365                           if (t1 & 128)
4366                             t1 -= 256;
4367
4368                           state->Reg[BITS (12, 15)] = state->Accumulator;
4369                           state->Reg[BITS (16, 19)] = t1;
4370                           break;
4371                         }
4372                     }
4373                   else
4374                     /* FIXME: Not sure what to do for other v5 processors.  */
4375                     ARMul_UndefInstr (state, instr);
4376                   break;
4377                 }
4378               /* Drop through.  */
4379
4380             case 0xc1:          /* Load , No WriteBack , Post Dec.  */
4381               ARMul_LDC (state, instr, LHS);
4382               break;
4383
4384             case 0xc2:
4385             case 0xc6:          /* Store , WriteBack , Post Dec.  */
4386               lhs = LHS;
4387               state->Base = lhs - LSCOff;
4388               ARMul_STC (state, instr, lhs);
4389               break;
4390
4391             case 0xc3:
4392             case 0xc7:          /* Load , WriteBack , Post Dec.  */
4393               lhs = LHS;
4394               state->Base = lhs - LSCOff;
4395               ARMul_LDC (state, instr, lhs);
4396               break;
4397
4398             case 0xc8:
4399             case 0xcc:          /* Store , No WriteBack , Post Inc.  */
4400               ARMul_STC (state, instr, LHS);
4401               break;
4402
4403             case 0xc9:
4404             case 0xcd:          /* Load , No WriteBack , Post Inc.  */
4405               ARMul_LDC (state, instr, LHS);
4406               break;
4407
4408             case 0xca:
4409             case 0xce:          /* Store , WriteBack , Post Inc.  */
4410               lhs = LHS;
4411               state->Base = lhs + LSCOff;
4412               ARMul_STC (state, instr, LHS);
4413               break;
4414
4415             case 0xcb:
4416             case 0xcf:          /* Load , WriteBack , Post Inc.  */
4417               lhs = LHS;
4418               state->Base = lhs + LSCOff;
4419               ARMul_LDC (state, instr, LHS);
4420               break;
4421
4422             case 0xd0:
4423             case 0xd4:          /* Store , No WriteBack , Pre Dec.  */
4424               ARMul_STC (state, instr, LHS - LSCOff);
4425               break;
4426
4427             case 0xd1:
4428             case 0xd5:          /* Load , No WriteBack , Pre Dec.  */
4429               ARMul_LDC (state, instr, LHS - LSCOff);
4430               break;
4431
4432             case 0xd2:
4433             case 0xd6:          /* Store , WriteBack , Pre Dec.  */
4434               lhs = LHS - LSCOff;
4435               state->Base = lhs;
4436               ARMul_STC (state, instr, lhs);
4437               break;
4438
4439             case 0xd3:
4440             case 0xd7:          /* Load , WriteBack , Pre Dec.  */
4441               lhs = LHS - LSCOff;
4442               state->Base = lhs;
4443               ARMul_LDC (state, instr, lhs);
4444               break;
4445
4446             case 0xd8:
4447             case 0xdc:          /* Store , No WriteBack , Pre Inc.  */
4448               ARMul_STC (state, instr, LHS + LSCOff);
4449               break;
4450
4451             case 0xd9:
4452             case 0xdd:          /* Load , No WriteBack , Pre Inc.  */
4453               ARMul_LDC (state, instr, LHS + LSCOff);
4454               break;
4455
4456             case 0xda:
4457             case 0xde:          /* Store , WriteBack , Pre Inc.  */
4458               lhs = LHS + LSCOff;
4459               state->Base = lhs;
4460               ARMul_STC (state, instr, lhs);
4461               break;
4462
4463             case 0xdb:
4464             case 0xdf:          /* Load , WriteBack , Pre Inc.  */
4465               lhs = LHS + LSCOff;
4466               state->Base = lhs;
4467               ARMul_LDC (state, instr, lhs);
4468               break;
4469
4470
4471               /* Co-Processor Register Transfers (MCR) and Data Ops.  */
4472
4473             case 0xe2:
4474               if (! CP_ACCESS_ALLOWED (state, CPNum))
4475                 {
4476                   ARMul_UndefInstr (state, instr);
4477                   break;
4478                 }
4479               if (state->is_XScale)
4480                 switch (BITS (18, 19))
4481                   {
4482                   case 0x0:
4483                     if (BITS (4, 11) == 1 && BITS (16, 17) == 0)
4484                       {
4485                         /* XScale MIA instruction.  Signed multiplication of
4486                            two 32 bit values and addition to 40 bit accumulator.  */
4487                         ARMsdword Rm = state->Reg[MULLHSReg];
4488                         ARMsdword Rs = state->Reg[MULACCReg];
4489
4490                         if (Rm & (1 << 31))
4491                           Rm -= 1ULL << 32;
4492                         if (Rs & (1 << 31))
4493                           Rs -= 1ULL << 32;
4494                         state->Accumulator += Rm * Rs;
4495                         goto donext;
4496                       }
4497                     break;
4498
4499                   case 0x2:
4500                     if (BITS (4, 11) == 1 && BITS (16, 17) == 0)
4501                       {
4502                         /* XScale MIAPH instruction.  */
4503                         ARMword t1 = state->Reg[MULLHSReg] >> 16;
4504                         ARMword t2 = state->Reg[MULACCReg] >> 16;
4505                         ARMword t3 = state->Reg[MULLHSReg] & 0xffff;
4506                         ARMword t4 = state->Reg[MULACCReg] & 0xffff;
4507                         ARMsdword t5;
4508
4509                         if (t1 & (1 << 15))
4510                           t1 -= 1 << 16;
4511                         if (t2 & (1 << 15))
4512                           t2 -= 1 << 16;
4513                         if (t3 & (1 << 15))
4514                           t3 -= 1 << 16;
4515                         if (t4 & (1 << 15))
4516                           t4 -= 1 << 16;
4517                         t1 *= t2;
4518                         t5 = t1;
4519                         if (t5 & (1 << 31))
4520                           t5 -= 1ULL << 32;
4521                         state->Accumulator += t5;
4522                         t3 *= t4;
4523                         t5 = t3;
4524                         if (t5 & (1 << 31))
4525                           t5 -= 1ULL << 32;
4526                         state->Accumulator += t5;
4527                         goto donext;
4528                       }
4529                     break;
4530
4531                   case 0x3:
4532                     if (BITS (4, 11) == 1)
4533                       {
4534                         /* XScale MIAxy instruction.  */
4535                         ARMword t1;
4536                         ARMword t2;
4537                         ARMsdword t5;
4538
4539                         if (BIT (17))
4540                           t1 = state->Reg[MULLHSReg] >> 16;
4541                         else
4542                           t1 = state->Reg[MULLHSReg] & 0xffff;
4543
4544                         if (BIT (16))
4545                           t2 = state->Reg[MULACCReg] >> 16;
4546                         else
4547                           t2 = state->Reg[MULACCReg] & 0xffff;
4548
4549                         if (t1 & (1 << 15))
4550                           t1 -= 1 << 16;
4551                         if (t2 & (1 << 15))
4552                           t2 -= 1 << 16;
4553                         t1 *= t2;
4554                         t5 = t1;
4555                         if (t5 & (1 << 31))
4556                           t5 -= 1ULL << 32;
4557                         state->Accumulator += t5;
4558                         goto donext;
4559                       }
4560                     break;
4561
4562                   default:
4563                     break;
4564                   }
4565               /* Drop through.  */
4566
4567             case 0xe0:
4568             case 0xe4:
4569             case 0xe6:
4570             case 0xe8:
4571             case 0xea:
4572             case 0xec:
4573             case 0xee:
4574               if (BIT (4))
4575                 {
4576                   if (CPNum == 10 || CPNum == 11)
4577                     handle_VFP_move (state, instr);
4578                   /* MCR.  */
4579                   else if (DESTReg == 15)
4580                     {
4581                       UNDEF_MCRPC;
4582 #ifdef MODE32
4583                       ARMul_MCR (state, instr, state->Reg[15] + isize);
4584 #else
4585                       ARMul_MCR (state, instr, ECC | ER15INT | EMODE |
4586                                  ((state->Reg[15] + isize) & R15PCBITS));
4587 #endif
4588                     }
4589                   else
4590                     ARMul_MCR (state, instr, DEST);
4591                 }
4592               else
4593                 /* CDP Part 1.  */
4594                 ARMul_CDP (state, instr);
4595               break;
4596
4597
4598               /* Co-Processor Register Transfers (MRC) and Data Ops.  */
4599             case 0xe1:
4600             case 0xe3:
4601             case 0xe5:
4602             case 0xe7:
4603             case 0xe9:
4604             case 0xeb:
4605             case 0xed:
4606             case 0xef:
4607               if (BIT (4))
4608                 {
4609                   if (CPNum == 10 || CPNum == 11)
4610                     {
4611                       switch (BITS (20, 27))
4612                         {
4613                         case 0xEF:
4614                           if (BITS (16, 19) == 0x1
4615                               && BITS (0, 11) == 0xA10)
4616                             {
4617                               /* VMRS  */
4618                               if (DESTReg == 15)
4619                                 {
4620                                   ARMul_SetCPSR (state, (state->FPSCR & 0xF0000000)
4621                                                  | (ARMul_GetCPSR (state) & 0x0FFFFFFF));
4622
4623                                   if (trace)
4624                                     fprintf (stderr, " VFP: VMRS: set flags to %c%c%c%c\n",
4625                                              ARMul_GetCPSR (state) & NBIT ? 'N' : '-',
4626                                              ARMul_GetCPSR (state) & ZBIT ? 'Z' : '-',
4627                                              ARMul_GetCPSR (state) & CBIT ? 'C' : '-',
4628                                              ARMul_GetCPSR (state) & VBIT ? 'V' : '-');
4629                                 }
4630                               else
4631                                 {
4632                                   state->Reg[DESTReg] = state->FPSCR;
4633
4634                                   if (trace)
4635                                     fprintf (stderr, " VFP: VMRS: r%d = %x\n", DESTReg, state->Reg[DESTReg]);
4636                                 }
4637                             }
4638                           else
4639                             fprintf (stderr, "SIM: VFP: Unimplemented: Compare op\n");
4640                           break;
4641
4642                         case 0xE0:
4643                         case 0xE1:
4644                           /* VMOV reg <-> single precision.  */
4645                           if (BITS (0,6) != 0x10 || BITS (8,11) != 0xA)
4646                             fprintf (stderr, "SIM: VFP: Unimplemented: move op\n");
4647                           else if (BIT (20))
4648                             state->Reg[BITS (12, 15)] = VFP_uword (BITS (16, 19) << 1 | BIT (7));
4649                           else
4650                             VFP_uword (BITS (16, 19) << 1 | BIT (7)) = state->Reg[BITS (12, 15)];
4651                           break;
4652
4653                         default:
4654                           fprintf (stderr, "SIM: VFP: Unimplemented: CDP op\n");
4655                           break;
4656                         }
4657                     }
4658                   else
4659                     {
4660                       /* MRC */
4661                       temp = ARMul_MRC (state, instr);
4662                       if (DESTReg == 15)
4663                         {
4664                           ASSIGNN ((temp & NBIT) != 0);
4665                           ASSIGNZ ((temp & ZBIT) != 0);
4666                           ASSIGNC ((temp & CBIT) != 0);
4667                           ASSIGNV ((temp & VBIT) != 0);
4668                         }
4669                       else
4670                         DEST = temp;
4671                     }
4672                 }
4673               else
4674                 /* CDP Part 2.  */
4675                 ARMul_CDP (state, instr);
4676               break;
4677
4678
4679               /* SWI instruction.  */
4680             case 0xf0:
4681             case 0xf1:
4682             case 0xf2:
4683             case 0xf3:
4684             case 0xf4:
4685             case 0xf5:
4686             case 0xf6:
4687             case 0xf7:
4688             case 0xf8:
4689             case 0xf9:
4690             case 0xfa:
4691             case 0xfb:
4692             case 0xfc:
4693             case 0xfd:
4694             case 0xfe:
4695             case 0xff:
4696               if (instr == ARMul_ABORTWORD && state->AbortAddr == pc)
4697                 {
4698                   /* A prefetch abort.  */
4699                   XScale_set_fsr_far (state, ARMul_CP15_R5_MMU_EXCPT, pc);
4700                   ARMul_Abort (state, ARMul_PrefetchAbortV);
4701                   break;
4702                 }
4703
4704               if (!ARMul_OSHandleSWI (state, BITS (0, 23)))
4705                 ARMul_Abort (state, ARMul_SWIV);
4706
4707               break;
4708             }
4709         }
4710
4711 #ifdef MODET
4712     donext:
4713 #endif
4714
4715       if (state->Emulate == ONCE)
4716         state->Emulate = STOP;
4717       /* If we have changed mode, allow the PC to advance before stopping.  */
4718       else if (state->Emulate == CHANGEMODE)
4719         continue;
4720       else if (state->Emulate != RUN)
4721         break;
4722     }
4723   while (!stop_simulator);
4724
4725   state->decoded = decoded;
4726   state->loaded = loaded;
4727   state->pc = pc;
4728
4729   return pc;
4730 }
4731
4732 /* This routine evaluates most Data Processing register RHS's with the S
4733    bit clear.  It is intended to be called from the macro DPRegRHS, which
4734    filters the common case of an unshifted register with in line code.  */
4735
4736 static ARMword
4737 GetDPRegRHS (ARMul_State * state, ARMword instr)
4738 {
4739   ARMword shamt, base;
4740
4741   base = RHSReg;
4742   if (BIT (4))
4743     {
4744       /* Shift amount in a register.  */
4745       UNDEF_Shift;
4746       INCPC;
4747 #ifndef MODE32
4748       if (base == 15)
4749         base = ECC | ER15INT | R15PC | EMODE;
4750       else
4751 #endif
4752         base = state->Reg[base];
4753       ARMul_Icycles (state, 1, 0L);
4754       shamt = state->Reg[BITS (8, 11)] & 0xff;
4755       switch ((int) BITS (5, 6))
4756         {
4757         case LSL:
4758           if (shamt == 0)
4759             return (base);
4760           else if (shamt >= 32)
4761             return (0);
4762           else
4763             return (base << shamt);
4764         case LSR:
4765           if (shamt == 0)
4766             return (base);
4767           else if (shamt >= 32)
4768             return (0);
4769           else
4770             return (base >> shamt);
4771         case ASR:
4772           if (shamt == 0)
4773             return (base);
4774           else if (shamt >= 32)
4775             return ((ARMword) ((ARMsword) base >> 31L));
4776           else
4777             return ((ARMword) ((ARMsword) base >> (int) shamt));
4778         case ROR:
4779           shamt &= 0x1f;
4780           if (shamt == 0)
4781             return (base);
4782           else
4783             return ((base << (32 - shamt)) | (base >> shamt));
4784         }
4785     }
4786   else
4787     {
4788       /* Shift amount is a constant.  */
4789 #ifndef MODE32
4790       if (base == 15)
4791         base = ECC | ER15INT | R15PC | EMODE;
4792       else
4793 #endif
4794         base = state->Reg[base];
4795       shamt = BITS (7, 11);
4796       switch ((int) BITS (5, 6))
4797         {
4798         case LSL:
4799           return (base << shamt);
4800         case LSR:
4801           if (shamt == 0)
4802             return (0);
4803           else
4804             return (base >> shamt);
4805         case ASR:
4806           if (shamt == 0)
4807             return ((ARMword) ((ARMsword) base >> 31L));
4808           else
4809             return ((ARMword) ((ARMsword) base >> (int) shamt));
4810         case ROR:
4811           if (shamt == 0)
4812             /* It's an RRX.  */
4813             return ((base >> 1) | (CFLAG << 31));
4814           else
4815             return ((base << (32 - shamt)) | (base >> shamt));
4816         }
4817     }
4818
4819   return 0;
4820 }
4821
4822 /* This routine evaluates most Logical Data Processing register RHS's
4823    with the S bit set.  It is intended to be called from the macro
4824    DPSRegRHS, which filters the common case of an unshifted register
4825    with in line code.  */
4826
4827 static ARMword
4828 GetDPSRegRHS (ARMul_State * state, ARMword instr)
4829 {
4830   ARMword shamt, base;
4831
4832   base = RHSReg;
4833   if (BIT (4))
4834     {
4835       /* Shift amount in a register.  */
4836       UNDEF_Shift;
4837       INCPC;
4838 #ifndef MODE32
4839       if (base == 15)
4840         base = ECC | ER15INT | R15PC | EMODE;
4841       else
4842 #endif
4843         base = state->Reg[base];
4844       ARMul_Icycles (state, 1, 0L);
4845       shamt = state->Reg[BITS (8, 11)] & 0xff;
4846       switch ((int) BITS (5, 6))
4847         {
4848         case LSL:
4849           if (shamt == 0)
4850             return (base);
4851           else if (shamt == 32)
4852             {
4853               ASSIGNC (base & 1);
4854               return (0);
4855             }
4856           else if (shamt > 32)
4857             {
4858               CLEARC;
4859               return (0);
4860             }
4861           else
4862             {
4863               ASSIGNC ((base >> (32 - shamt)) & 1);
4864               return (base << shamt);
4865             }
4866         case LSR:
4867           if (shamt == 0)
4868             return (base);
4869           else if (shamt == 32)
4870             {
4871               ASSIGNC (base >> 31);
4872               return (0);
4873             }
4874           else if (shamt > 32)
4875             {
4876               CLEARC;
4877               return (0);
4878             }
4879           else
4880             {
4881               ASSIGNC ((base >> (shamt - 1)) & 1);
4882               return (base >> shamt);
4883             }
4884         case ASR:
4885           if (shamt == 0)
4886             return (base);
4887           else if (shamt >= 32)
4888             {
4889               ASSIGNC (base >> 31L);
4890               return ((ARMword) ((ARMsword) base >> 31L));
4891             }
4892           else
4893             {
4894               ASSIGNC ((ARMword) ((ARMsword) base >> (int) (shamt - 1)) & 1);
4895               return ((ARMword) ((ARMsword) base >> (int) shamt));
4896             }
4897         case ROR:
4898           if (shamt == 0)
4899             return (base);
4900           shamt &= 0x1f;
4901           if (shamt == 0)
4902             {
4903               ASSIGNC (base >> 31);
4904               return (base);
4905             }
4906           else
4907             {
4908               ASSIGNC ((base >> (shamt - 1)) & 1);
4909               return ((base << (32 - shamt)) | (base >> shamt));
4910             }
4911         }
4912     }
4913   else
4914     {
4915       /* Shift amount is a constant.  */
4916 #ifndef MODE32
4917       if (base == 15)
4918         base = ECC | ER15INT | R15PC | EMODE;
4919       else
4920 #endif
4921         base = state->Reg[base];
4922       shamt = BITS (7, 11);
4923
4924       switch ((int) BITS (5, 6))
4925         {
4926         case LSL:
4927           ASSIGNC ((base >> (32 - shamt)) & 1);
4928           return (base << shamt);
4929         case LSR:
4930           if (shamt == 0)
4931             {
4932               ASSIGNC (base >> 31);
4933               return (0);
4934             }
4935           else
4936             {
4937               ASSIGNC ((base >> (shamt - 1)) & 1);
4938               return (base >> shamt);
4939             }
4940         case ASR:
4941           if (shamt == 0)
4942             {
4943               ASSIGNC (base >> 31L);
4944               return ((ARMword) ((ARMsword) base >> 31L));
4945             }
4946           else
4947             {
4948               ASSIGNC ((ARMword) ((ARMsword) base >> (int) (shamt - 1)) & 1);
4949               return ((ARMword) ((ARMsword) base >> (int) shamt));
4950             }
4951         case ROR:
4952           if (shamt == 0)
4953             {
4954               /* It's an RRX.  */
4955               shamt = CFLAG;
4956               ASSIGNC (base & 1);
4957               return ((base >> 1) | (shamt << 31));
4958             }
4959           else
4960             {
4961               ASSIGNC ((base >> (shamt - 1)) & 1);
4962               return ((base << (32 - shamt)) | (base >> shamt));
4963             }
4964         }
4965     }
4966
4967   return 0;
4968 }
4969
4970 /* This routine handles writes to register 15 when the S bit is not set.  */
4971
4972 static void
4973 WriteR15 (ARMul_State * state, ARMword src)
4974 {
4975   /* The ARM documentation states that the two least significant bits
4976      are discarded when setting PC, except in the cases handled by
4977      WriteR15Branch() below.  It's probably an oversight: in THUMB
4978      mode, the second least significant bit should probably not be
4979      discarded.  */
4980 #ifdef MODET
4981   if (TFLAG)
4982     src &= 0xfffffffe;
4983   else
4984 #endif
4985     src &= 0xfffffffc;
4986
4987 #ifdef MODE32
4988   state->Reg[15] = src & PCBITS;
4989 #else
4990   state->Reg[15] = (src & R15PCBITS) | ECC | ER15INT | EMODE;
4991   ARMul_R15Altered (state);
4992 #endif
4993
4994   FLUSHPIPE;
4995   if (trace_funcs)
4996     fprintf (stderr, " pc changed to %x\n", state->Reg[15]);
4997 }
4998
4999 /* This routine handles writes to register 15 when the S bit is set.  */
5000
5001 static void
5002 WriteSR15 (ARMul_State * state, ARMword src)
5003 {
5004 #ifdef MODE32
5005   if (state->Bank > 0)
5006     {
5007       state->Cpsr = state->Spsr[state->Bank];
5008       ARMul_CPSRAltered (state);
5009     }
5010 #ifdef MODET
5011   if (TFLAG)
5012     src &= 0xfffffffe;
5013   else
5014 #endif
5015     src &= 0xfffffffc;
5016   state->Reg[15] = src & PCBITS;
5017 #else
5018 #ifdef MODET
5019   if (TFLAG)
5020     /* ARMul_R15Altered would have to support it.  */
5021     abort ();
5022   else
5023 #endif
5024     src &= 0xfffffffc;
5025
5026   if (state->Bank == USERBANK)
5027     state->Reg[15] = (src & (CCBITS | R15PCBITS)) | ER15INT | EMODE;
5028   else
5029     state->Reg[15] = src;
5030
5031   ARMul_R15Altered (state);
5032 #endif
5033   FLUSHPIPE;
5034   if (trace_funcs)
5035     fprintf (stderr, " pc changed to %x\n", state->Reg[15]);
5036 }
5037
5038 /* In machines capable of running in Thumb mode, BX, BLX, LDR and LDM
5039    will switch to Thumb mode if the least significant bit is set.  */
5040
5041 static void
5042 WriteR15Branch (ARMul_State * state, ARMword src)
5043 {
5044 #ifdef MODET
5045   if (src & 1)
5046     {
5047       /* Thumb bit.  */
5048       SETT;
5049       state->Reg[15] = src & 0xfffffffe;
5050     }
5051   else
5052     {
5053       CLEART;
5054       state->Reg[15] = src & 0xfffffffc;
5055     }
5056   FLUSHPIPE;
5057   if (trace_funcs)
5058     fprintf (stderr, " pc changed to %x\n", state->Reg[15]);
5059 #else
5060   WriteR15 (state, src);
5061 #endif
5062 }
5063
5064 /* Before ARM_v5 LDR and LDM of pc did not change mode.  */
5065
5066 static void
5067 WriteR15Load (ARMul_State * state, ARMword src)
5068 {
5069   if (state->is_v5)
5070     WriteR15Branch (state, src);
5071   else
5072     WriteR15 (state, src);
5073 }
5074
5075 /* This routine evaluates most Load and Store register RHS's.  It is
5076    intended to be called from the macro LSRegRHS, which filters the
5077    common case of an unshifted register with in line code.  */
5078
5079 static ARMword
5080 GetLSRegRHS (ARMul_State * state, ARMword instr)
5081 {
5082   ARMword shamt, base;
5083
5084   base = RHSReg;
5085 #ifndef MODE32
5086   if (base == 15)
5087     /* Now forbidden, but ...  */
5088     base = ECC | ER15INT | R15PC | EMODE;
5089   else
5090 #endif
5091     base = state->Reg[base];
5092
5093   shamt = BITS (7, 11);
5094   switch ((int) BITS (5, 6))
5095     {
5096     case LSL:
5097       return (base << shamt);
5098     case LSR:
5099       if (shamt == 0)
5100         return (0);
5101       else
5102         return (base >> shamt);
5103     case ASR:
5104       if (shamt == 0)
5105         return ((ARMword) ((ARMsword) base >> 31L));
5106       else
5107         return ((ARMword) ((ARMsword) base >> (int) shamt));
5108     case ROR:
5109       if (shamt == 0)
5110         /* It's an RRX.  */
5111         return ((base >> 1) | (CFLAG << 31));
5112       else
5113         return ((base << (32 - shamt)) | (base >> shamt));
5114     default:
5115       break;
5116     }
5117   return 0;
5118 }
5119
5120 /* This routine evaluates the ARM7T halfword and signed transfer RHS's.  */
5121
5122 static ARMword
5123 GetLS7RHS (ARMul_State * state, ARMword instr)
5124 {
5125   if (BIT (22) == 0)
5126     {
5127       /* Register.  */
5128 #ifndef MODE32
5129       if (RHSReg == 15)
5130         /* Now forbidden, but ...  */
5131         return ECC | ER15INT | R15PC | EMODE;
5132 #endif
5133       return state->Reg[RHSReg];
5134     }
5135
5136   /* Immediate.  */
5137   return BITS (0, 3) | (BITS (8, 11) << 4);
5138 }
5139
5140 /* This function does the work of loading a word for a LDR instruction.  */
5141
5142 static unsigned
5143 LoadWord (ARMul_State * state, ARMword instr, ARMword address)
5144 {
5145   ARMword dest;
5146
5147   BUSUSEDINCPCS;
5148 #ifndef MODE32
5149   if (ADDREXCEPT (address))
5150     INTERNALABORT (address);
5151 #endif
5152
5153   dest = ARMul_LoadWordN (state, address);
5154
5155   if (state->Aborted)
5156     {
5157       TAKEABORT;
5158       return state->lateabtSig;
5159     }
5160   if (address & 3)
5161     dest = ARMul_Align (state, address, dest);
5162   WRITEDESTB (dest);
5163   ARMul_Icycles (state, 1, 0L);
5164
5165   return (DESTReg != LHSReg);
5166 }
5167
5168 #ifdef MODET
5169 /* This function does the work of loading a halfword.  */
5170
5171 static unsigned
5172 LoadHalfWord (ARMul_State * state, ARMword instr, ARMword address,
5173               int signextend)
5174 {
5175   ARMword dest;
5176
5177   BUSUSEDINCPCS;
5178 #ifndef MODE32
5179   if (ADDREXCEPT (address))
5180     INTERNALABORT (address);
5181 #endif
5182   dest = ARMul_LoadHalfWord (state, address);
5183   if (state->Aborted)
5184     {
5185       TAKEABORT;
5186       return state->lateabtSig;
5187     }
5188   UNDEF_LSRBPC;
5189   if (signextend)
5190     if (dest & 1 << (16 - 1))
5191       dest = (dest & ((1 << 16) - 1)) - (1 << 16);
5192
5193   WRITEDEST (dest);
5194   ARMul_Icycles (state, 1, 0L);
5195   return (DESTReg != LHSReg);
5196 }
5197
5198 #endif /* MODET */
5199
5200 /* This function does the work of loading a byte for a LDRB instruction.  */
5201
5202 static unsigned
5203 LoadByte (ARMul_State * state, ARMword instr, ARMword address, int signextend)
5204 {
5205   ARMword dest;
5206
5207   BUSUSEDINCPCS;
5208 #ifndef MODE32
5209   if (ADDREXCEPT (address))
5210     INTERNALABORT (address);
5211 #endif
5212   dest = ARMul_LoadByte (state, address);
5213   if (state->Aborted)
5214     {
5215       TAKEABORT;
5216       return state->lateabtSig;
5217     }
5218   UNDEF_LSRBPC;
5219   if (signextend)
5220     if (dest & 1 << (8 - 1))
5221       dest = (dest & ((1 << 8) - 1)) - (1 << 8);
5222
5223   WRITEDEST (dest);
5224   ARMul_Icycles (state, 1, 0L);
5225
5226   return (DESTReg != LHSReg);
5227 }
5228
5229 /* This function does the work of loading two words for a LDRD instruction.  */
5230
5231 static void
5232 Handle_Load_Double (ARMul_State * state, ARMword instr)
5233 {
5234   ARMword dest_reg;
5235   ARMword addr_reg;
5236   ARMword write_back  = BIT (21);
5237   ARMword immediate   = BIT (22);
5238   ARMword add_to_base = BIT (23);
5239   ARMword pre_indexed = BIT (24);
5240   ARMword offset;
5241   ARMword addr;
5242   ARMword sum;
5243   ARMword base;
5244   ARMword value1;
5245   ARMword value2;
5246
5247   BUSUSEDINCPCS;
5248
5249   /* If the writeback bit is set, the pre-index bit must be clear.  */
5250   if (write_back && ! pre_indexed)
5251     {
5252       ARMul_UndefInstr (state, instr);
5253       return;
5254     }
5255
5256   /* Extract the base address register.  */
5257   addr_reg = LHSReg;
5258
5259   /* Extract the destination register and check it.  */
5260   dest_reg = DESTReg;
5261
5262   /* Destination register must be even.  */
5263   if ((dest_reg & 1)
5264     /* Destination register cannot be LR.  */
5265       || (dest_reg == 14))
5266     {
5267       ARMul_UndefInstr (state, instr);
5268       return;
5269     }
5270
5271   /* Compute the base address.  */
5272   base = state->Reg[addr_reg];
5273
5274   /* Compute the offset.  */
5275   offset = immediate ? ((BITS (8, 11) << 4) | BITS (0, 3)) : state->Reg[RHSReg];
5276
5277   /* Compute the sum of the two.  */
5278   if (add_to_base)
5279     sum = base + offset;
5280   else
5281     sum = base - offset;
5282
5283   /* If this is a pre-indexed mode use the sum.  */
5284   if (pre_indexed)
5285     addr = sum;
5286   else
5287     addr = base;
5288
5289   if (state->is_v6 && (addr & 0x3) == 0)
5290     /* Word alignment is enough for v6.  */
5291     ;
5292   /* The address must be aligned on a 8 byte boundary.  */
5293   else if (addr & 0x7)
5294     {
5295 #ifdef ABORTS
5296       ARMul_DATAABORT (addr);
5297 #else
5298       ARMul_UndefInstr (state, instr);
5299 #endif
5300       return;
5301     }
5302
5303   /* For pre indexed or post indexed addressing modes,
5304      check that the destination registers do not overlap
5305      the address registers.  */
5306   if ((! pre_indexed || write_back)
5307       && (   addr_reg == dest_reg
5308           || addr_reg == dest_reg + 1))
5309     {
5310       ARMul_UndefInstr (state, instr);
5311       return;
5312     }
5313
5314   /* Load the words.  */
5315   value1 = ARMul_LoadWordN (state, addr);
5316   value2 = ARMul_LoadWordN (state, addr + 4);
5317
5318   /* Check for data aborts.  */
5319   if (state->Aborted)
5320     {
5321       TAKEABORT;
5322       return;
5323     }
5324
5325   ARMul_Icycles (state, 2, 0L);
5326
5327   /* Store the values.  */
5328   state->Reg[dest_reg] = value1;
5329   state->Reg[dest_reg + 1] = value2;
5330
5331   /* Do the post addressing and writeback.  */
5332   if (! pre_indexed)
5333     addr = sum;
5334
5335   if (! pre_indexed || write_back)
5336     state->Reg[addr_reg] = addr;
5337 }
5338
5339 /* This function does the work of storing two words for a STRD instruction.  */
5340
5341 static void
5342 Handle_Store_Double (ARMul_State * state, ARMword instr)
5343 {
5344   ARMword src_reg;
5345   ARMword addr_reg;
5346   ARMword write_back  = BIT (21);
5347   ARMword immediate   = BIT (22);
5348   ARMword add_to_base = BIT (23);
5349   ARMword pre_indexed = BIT (24);
5350   ARMword offset;
5351   ARMword addr;
5352   ARMword sum;
5353   ARMword base;
5354
5355   BUSUSEDINCPCS;
5356
5357   /* If the writeback bit is set, the pre-index bit must be clear.  */
5358   if (write_back && ! pre_indexed)
5359     {
5360       ARMul_UndefInstr (state, instr);
5361       return;
5362     }
5363
5364   /* Extract the base address register.  */
5365   addr_reg = LHSReg;
5366
5367   /* Base register cannot be PC.  */
5368   if (addr_reg == 15)
5369     {
5370       ARMul_UndefInstr (state, instr);
5371       return;
5372     }
5373
5374   /* Extract the source register.  */
5375   src_reg = DESTReg;
5376
5377   /* Source register must be even.  */
5378   if (src_reg & 1)
5379     {
5380       ARMul_UndefInstr (state, instr);
5381       return;
5382     }
5383
5384   /* Compute the base address.  */
5385   base = state->Reg[addr_reg];
5386
5387   /* Compute the offset.  */
5388   offset = immediate ? ((BITS (8, 11) << 4) | BITS (0, 3)) : state->Reg[RHSReg];
5389
5390   /* Compute the sum of the two.  */
5391   if (add_to_base)
5392     sum = base + offset;
5393   else
5394     sum = base - offset;
5395
5396   /* If this is a pre-indexed mode use the sum.  */
5397   if (pre_indexed)
5398     addr = sum;
5399   else
5400     addr = base;
5401
5402   /* The address must be aligned on a 8 byte boundary.  */
5403   if (addr & 0x7)
5404     {
5405 #ifdef ABORTS
5406       ARMul_DATAABORT (addr);
5407 #else
5408       ARMul_UndefInstr (state, instr);
5409 #endif
5410       return;
5411     }
5412
5413   /* For pre indexed or post indexed addressing modes,
5414      check that the destination registers do not overlap
5415      the address registers.  */
5416   if ((! pre_indexed || write_back)
5417       && (   addr_reg == src_reg
5418           || addr_reg == src_reg + 1))
5419     {
5420       ARMul_UndefInstr (state, instr);
5421       return;
5422     }
5423
5424   /* Load the words.  */
5425   ARMul_StoreWordN (state, addr, state->Reg[src_reg]);
5426   ARMul_StoreWordN (state, addr + 4, state->Reg[src_reg + 1]);
5427
5428   if (state->Aborted)
5429     {
5430       TAKEABORT;
5431       return;
5432     }
5433
5434   /* Do the post addressing and writeback.  */
5435   if (! pre_indexed)
5436     addr = sum;
5437
5438   if (! pre_indexed || write_back)
5439     state->Reg[addr_reg] = addr;
5440 }
5441
5442 /* This function does the work of storing a word from a STR instruction.  */
5443
5444 static unsigned
5445 StoreWord (ARMul_State * state, ARMword instr, ARMword address)
5446 {
5447   BUSUSEDINCPCN;
5448 #ifndef MODE32
5449   if (DESTReg == 15)
5450     state->Reg[15] = ECC | ER15INT | R15PC | EMODE;
5451 #endif
5452 #ifdef MODE32
5453   ARMul_StoreWordN (state, address, DEST);
5454 #else
5455   if (VECTORACCESS (address) || ADDREXCEPT (address))
5456     {
5457       INTERNALABORT (address);
5458       (void) ARMul_LoadWordN (state, address);
5459     }
5460   else
5461     ARMul_StoreWordN (state, address, DEST);
5462 #endif
5463   if (state->Aborted)
5464     {
5465       TAKEABORT;
5466       return state->lateabtSig;
5467     }
5468   return TRUE;
5469 }
5470
5471 #ifdef MODET
5472 /* This function does the work of storing a byte for a STRH instruction.  */
5473
5474 static unsigned
5475 StoreHalfWord (ARMul_State * state, ARMword instr, ARMword address)
5476 {
5477   BUSUSEDINCPCN;
5478
5479 #ifndef MODE32
5480   if (DESTReg == 15)
5481     state->Reg[15] = ECC | ER15INT | R15PC | EMODE;
5482 #endif
5483
5484 #ifdef MODE32
5485   ARMul_StoreHalfWord (state, address, DEST);
5486 #else
5487   if (VECTORACCESS (address) || ADDREXCEPT (address))
5488     {
5489       INTERNALABORT (address);
5490       (void) ARMul_LoadHalfWord (state, address);
5491     }
5492   else
5493     ARMul_StoreHalfWord (state, address, DEST);
5494 #endif
5495
5496   if (state->Aborted)
5497     {
5498       TAKEABORT;
5499       return state->lateabtSig;
5500     }
5501   return TRUE;
5502 }
5503
5504 #endif /* MODET */
5505
5506 /* This function does the work of storing a byte for a STRB instruction.  */
5507
5508 static unsigned
5509 StoreByte (ARMul_State * state, ARMword instr, ARMword address)
5510 {
5511   BUSUSEDINCPCN;
5512 #ifndef MODE32
5513   if (DESTReg == 15)
5514     state->Reg[15] = ECC | ER15INT | R15PC | EMODE;
5515 #endif
5516 #ifdef MODE32
5517   ARMul_StoreByte (state, address, DEST);
5518 #else
5519   if (VECTORACCESS (address) || ADDREXCEPT (address))
5520     {
5521       INTERNALABORT (address);
5522       (void) ARMul_LoadByte (state, address);
5523     }
5524   else
5525     ARMul_StoreByte (state, address, DEST);
5526 #endif
5527   if (state->Aborted)
5528     {
5529       TAKEABORT;
5530       return state->lateabtSig;
5531     }
5532   UNDEF_LSRBPC;
5533   return TRUE;
5534 }
5535
5536 /* This function does the work of loading the registers listed in an LDM
5537    instruction, when the S bit is clear.  The code here is always increment
5538    after, it's up to the caller to get the input address correct and to
5539    handle base register modification.  */
5540
5541 static void
5542 LoadMult (ARMul_State * state, ARMword instr, ARMword address, ARMword WBBase)
5543 {
5544   ARMword dest, temp;
5545
5546   UNDEF_LSMNoRegs;
5547   UNDEF_LSMPCBase;
5548   UNDEF_LSMBaseInListWb;
5549   BUSUSEDINCPCS;
5550 #ifndef MODE32
5551   if (ADDREXCEPT (address))
5552     INTERNALABORT (address);
5553 #endif
5554   if (BIT (21) && LHSReg != 15)
5555     LSBase = WBBase;
5556
5557   /* N cycle first.  */
5558   for (temp = 0; !BIT (temp); temp++)
5559     ;
5560
5561   dest = ARMul_LoadWordN (state, address);
5562
5563   if (!state->abortSig && !state->Aborted)
5564     state->Reg[temp++] = dest;
5565   else if (!state->Aborted)
5566     {
5567       XScale_set_fsr_far (state, ARMul_CP15_R5_ST_ALIGN, address);
5568       state->Aborted = ARMul_DataAbortV;
5569     }
5570
5571   /* S cycles from here on.  */
5572   for (; temp < 16; temp ++)
5573     if (BIT (temp))
5574       {
5575         /* Load this register.  */
5576         address += 4;
5577         dest = ARMul_LoadWordS (state, address);
5578
5579         if (!state->abortSig && !state->Aborted)
5580           state->Reg[temp] = dest;
5581         else if (!state->Aborted)
5582           {
5583             XScale_set_fsr_far (state, ARMul_CP15_R5_ST_ALIGN, address);
5584             state->Aborted = ARMul_DataAbortV;
5585           }
5586       }
5587
5588   if (BIT (15) && !state->Aborted)
5589     /* PC is in the reg list.  */
5590     WriteR15Load (state, PC);
5591
5592   /* To write back the final register.  */
5593   ARMul_Icycles (state, 1, 0L);
5594
5595   if (state->Aborted)
5596     {
5597       if (BIT (21) && LHSReg != 15)
5598         LSBase = WBBase;
5599       TAKEABORT;
5600     }
5601 }
5602
5603 /* This function does the work of loading the registers listed in an LDM
5604    instruction, when the S bit is set. The code here is always increment
5605    after, it's up to the caller to get the input address correct and to
5606    handle base register modification.  */
5607
5608 static void
5609 LoadSMult (ARMul_State * state,
5610            ARMword       instr,
5611            ARMword       address,
5612            ARMword       WBBase)
5613 {
5614   ARMword dest, temp;
5615
5616   UNDEF_LSMNoRegs;
5617   UNDEF_LSMPCBase;
5618   UNDEF_LSMBaseInListWb;
5619
5620   BUSUSEDINCPCS;
5621
5622 #ifndef MODE32
5623   if (ADDREXCEPT (address))
5624     INTERNALABORT (address);
5625 #endif
5626
5627   if (BIT (21) && LHSReg != 15)
5628     LSBase = WBBase;
5629
5630   if (!BIT (15) && state->Bank != USERBANK)
5631     {
5632       /* Temporary reg bank switch.  */
5633       (void) ARMul_SwitchMode (state, state->Mode, USER26MODE);
5634       UNDEF_LSMUserBankWb;
5635     }
5636
5637   /* N cycle first.  */
5638   for (temp = 0; !BIT (temp); temp ++)
5639     ;
5640
5641   dest = ARMul_LoadWordN (state, address);
5642
5643   if (!state->abortSig)
5644     state->Reg[temp++] = dest;
5645   else if (!state->Aborted)
5646     {
5647       XScale_set_fsr_far (state, ARMul_CP15_R5_ST_ALIGN, address);
5648       state->Aborted = ARMul_DataAbortV;
5649     }
5650
5651   /* S cycles from here on.  */
5652   for (; temp < 16; temp++)
5653     if (BIT (temp))
5654       {
5655         /* Load this register.  */
5656         address += 4;
5657         dest = ARMul_LoadWordS (state, address);
5658
5659         if (!state->abortSig && !state->Aborted)
5660           state->Reg[temp] = dest;
5661         else if (!state->Aborted)
5662           {
5663             XScale_set_fsr_far (state, ARMul_CP15_R5_ST_ALIGN, address);
5664             state->Aborted = ARMul_DataAbortV;
5665           }
5666       }
5667
5668   if (BIT (15) && !state->Aborted)
5669     {
5670       /* PC is in the reg list.  */
5671 #ifdef MODE32
5672       if (state->Mode != USER26MODE && state->Mode != USER32MODE)
5673         {
5674           state->Cpsr = GETSPSR (state->Bank);
5675           ARMul_CPSRAltered (state);
5676         }
5677
5678       WriteR15 (state, PC);
5679 #else
5680       if (state->Mode == USER26MODE || state->Mode == USER32MODE)
5681         {
5682           /* Protect bits in user mode.  */
5683           ASSIGNN ((state->Reg[15] & NBIT) != 0);
5684           ASSIGNZ ((state->Reg[15] & ZBIT) != 0);
5685           ASSIGNC ((state->Reg[15] & CBIT) != 0);
5686           ASSIGNV ((state->Reg[15] & VBIT) != 0);
5687         }
5688       else
5689         ARMul_R15Altered (state);
5690
5691       FLUSHPIPE;
5692 #endif
5693     }
5694
5695   if (!BIT (15) && state->Mode != USER26MODE && state->Mode != USER32MODE)
5696     /* Restore the correct bank.  */
5697     (void) ARMul_SwitchMode (state, USER26MODE, state->Mode);
5698
5699   /* To write back the final register.  */
5700   ARMul_Icycles (state, 1, 0L);
5701
5702   if (state->Aborted)
5703     {
5704       if (BIT (21) && LHSReg != 15)
5705         LSBase = WBBase;
5706
5707       TAKEABORT;
5708     }
5709 }
5710
5711 /* This function does the work of storing the registers listed in an STM
5712    instruction, when the S bit is clear.  The code here is always increment
5713    after, it's up to the caller to get the input address correct and to
5714    handle base register modification.  */
5715
5716 static void
5717 StoreMult (ARMul_State * state,
5718            ARMword instr,
5719            ARMword address,
5720            ARMword WBBase)
5721 {
5722   ARMword temp;
5723
5724   UNDEF_LSMNoRegs;
5725   UNDEF_LSMPCBase;
5726   UNDEF_LSMBaseInListWb;
5727
5728   if (!TFLAG)
5729     /* N-cycle, increment the PC and update the NextInstr state.  */
5730     BUSUSEDINCPCN;
5731
5732 #ifndef MODE32
5733   if (VECTORACCESS (address) || ADDREXCEPT (address))
5734     INTERNALABORT (address);
5735
5736   if (BIT (15))
5737     PATCHR15;
5738 #endif
5739
5740   /* N cycle first.  */
5741   for (temp = 0; !BIT (temp); temp ++)
5742     ;
5743
5744 #ifdef MODE32
5745   ARMul_StoreWordN (state, address, state->Reg[temp++]);
5746 #else
5747   if (state->Aborted)
5748     {
5749       (void) ARMul_LoadWordN (state, address);
5750
5751       /* Fake the Stores as Loads.  */
5752       for (; temp < 16; temp++)
5753         if (BIT (temp))
5754           {
5755             /* Save this register.  */
5756             address += 4;
5757             (void) ARMul_LoadWordS (state, address);
5758           }
5759
5760       if (BIT (21) && LHSReg != 15)
5761         LSBase = WBBase;
5762       TAKEABORT;
5763       return;
5764     }
5765   else
5766     ARMul_StoreWordN (state, address, state->Reg[temp++]);
5767 #endif
5768
5769   if (state->abortSig && !state->Aborted)
5770     {
5771       XScale_set_fsr_far (state, ARMul_CP15_R5_ST_ALIGN, address);
5772       state->Aborted = ARMul_DataAbortV;
5773     }
5774
5775   if (BIT (21) && LHSReg != 15)
5776     LSBase = WBBase;
5777
5778   /* S cycles from here on.  */
5779   for (; temp < 16; temp ++)
5780     if (BIT (temp))
5781       {
5782         /* Save this register.  */
5783         address += 4;
5784
5785         ARMul_StoreWordS (state, address, state->Reg[temp]);
5786
5787         if (state->abortSig && !state->Aborted)
5788           {
5789             XScale_set_fsr_far (state, ARMul_CP15_R5_ST_ALIGN, address);
5790             state->Aborted = ARMul_DataAbortV;
5791           }
5792       }
5793
5794   if (state->Aborted)
5795     TAKEABORT;
5796 }
5797
5798 /* This function does the work of storing the registers listed in an STM
5799    instruction when the S bit is set.  The code here is always increment
5800    after, it's up to the caller to get the input address correct and to
5801    handle base register modification.  */
5802
5803 static void
5804 StoreSMult (ARMul_State * state,
5805             ARMword       instr,
5806             ARMword       address,
5807             ARMword       WBBase)
5808 {
5809   ARMword temp;
5810
5811   UNDEF_LSMNoRegs;
5812   UNDEF_LSMPCBase;
5813   UNDEF_LSMBaseInListWb;
5814
5815   BUSUSEDINCPCN;
5816
5817 #ifndef MODE32
5818   if (VECTORACCESS (address) || ADDREXCEPT (address))
5819     INTERNALABORT (address);
5820
5821   if (BIT (15))
5822     PATCHR15;
5823 #endif
5824
5825   if (state->Bank != USERBANK)
5826     {
5827       /* Force User Bank.  */
5828       (void) ARMul_SwitchMode (state, state->Mode, USER26MODE);
5829       UNDEF_LSMUserBankWb;
5830     }
5831
5832   for (temp = 0; !BIT (temp); temp++)
5833     ;   /* N cycle first.  */
5834
5835 #ifdef MODE32
5836   ARMul_StoreWordN (state, address, state->Reg[temp++]);
5837 #else
5838   if (state->Aborted)
5839     {
5840       (void) ARMul_LoadWordN (state, address);
5841
5842       for (; temp < 16; temp++)
5843         /* Fake the Stores as Loads.  */
5844         if (BIT (temp))
5845           {
5846             /* Save this register.  */
5847             address += 4;
5848
5849             (void) ARMul_LoadWordS (state, address);
5850           }
5851
5852       if (BIT (21) && LHSReg != 15)
5853         LSBase = WBBase;
5854
5855       TAKEABORT;
5856       return;
5857     }
5858   else
5859     ARMul_StoreWordN (state, address, state->Reg[temp++]);
5860 #endif
5861
5862   if (state->abortSig && !state->Aborted)
5863     {
5864       XScale_set_fsr_far (state, ARMul_CP15_R5_ST_ALIGN, address);
5865       state->Aborted = ARMul_DataAbortV;
5866     }
5867
5868   /* S cycles from here on.  */
5869   for (; temp < 16; temp++)
5870     if (BIT (temp))
5871       {
5872         /* Save this register.  */
5873         address += 4;
5874
5875         ARMul_StoreWordS (state, address, state->Reg[temp]);
5876
5877         if (state->abortSig && !state->Aborted)
5878           {
5879             XScale_set_fsr_far (state, ARMul_CP15_R5_ST_ALIGN, address);
5880             state->Aborted = ARMul_DataAbortV;
5881           }
5882       }
5883
5884   if (state->Mode != USER26MODE && state->Mode != USER32MODE)
5885     /* Restore the correct bank.  */
5886     (void) ARMul_SwitchMode (state, USER26MODE, state->Mode);
5887
5888   if (BIT (21) && LHSReg != 15)
5889     LSBase = WBBase;
5890
5891   if (state->Aborted)
5892     TAKEABORT;
5893 }
5894
5895 /* This function does the work of adding two 32bit values
5896    together, and calculating if a carry has occurred.  */
5897
5898 static ARMword
5899 Add32 (ARMword a1, ARMword a2, int *carry)
5900 {
5901   ARMword result = (a1 + a2);
5902   unsigned int uresult = (unsigned int) result;
5903   unsigned int ua1 = (unsigned int) a1;
5904
5905   /* If (result == RdLo) and (state->Reg[nRdLo] == 0),
5906      or (result > RdLo) then we have no carry.  */
5907   if ((uresult == ua1) ? (a2 != 0) : (uresult < ua1))
5908     *carry = 1;
5909   else
5910     *carry = 0;
5911
5912   return result;
5913 }
5914
5915 /* This function does the work of multiplying
5916    two 32bit values to give a 64bit result.  */
5917
5918 static unsigned
5919 Multiply64 (ARMul_State * state, ARMword instr, int msigned, int scc)
5920 {
5921   /* Operand register numbers.  */
5922   int nRdHi, nRdLo, nRs, nRm;
5923   ARMword RdHi = 0, RdLo = 0, Rm;
5924   /* Cycle count.  */
5925   int scount;
5926
5927   nRdHi = BITS (16, 19);
5928   nRdLo = BITS (12, 15);
5929   nRs = BITS (8, 11);
5930   nRm = BITS (0, 3);
5931
5932   /* Needed to calculate the cycle count.  */
5933   Rm = state->Reg[nRm];
5934
5935   /* Check for illegal operand combinations first.  */
5936   if (   nRdHi != 15
5937       && nRdLo != 15
5938       && nRs   != 15
5939       && nRm   != 15
5940       && nRdHi != nRdLo)
5941     {
5942       /* Intermediate results.  */
5943       ARMword lo, mid1, mid2, hi;
5944       int carry;
5945       ARMword Rs = state->Reg[nRs];
5946       int sign = 0;
5947
5948 #ifdef MODE32
5949       if (state->is_v6)
5950         ;
5951       else
5952 #endif
5953         /* BAD code can trigger this result.  So only complain if debugging.  */
5954         if (state->Debug && (nRdHi == nRm || nRdLo == nRm))
5955           fprintf (stderr, "sim: MULTIPLY64 - INVALID ARGUMENTS: %d %d %d\n",
5956                    nRdHi, nRdLo, nRm);
5957       if (msigned)
5958         {
5959           /* Compute sign of result and adjust operands if necessary.  */
5960           sign = (Rm ^ Rs) & 0x80000000;
5961
5962           if (((ARMsword) Rm) < 0)
5963             Rm = -Rm;
5964
5965           if (((ARMsword) Rs) < 0)
5966             Rs = -Rs;
5967         }
5968
5969       /* We can split the 32x32 into four 16x16 operations. This
5970          ensures that we do not lose precision on 32bit only hosts.  */
5971       lo = ((Rs & 0xFFFF) * (Rm & 0xFFFF));
5972       mid1 = ((Rs & 0xFFFF) * ((Rm >> 16) & 0xFFFF));
5973       mid2 = (((Rs >> 16) & 0xFFFF) * (Rm & 0xFFFF));
5974       hi = (((Rs >> 16) & 0xFFFF) * ((Rm >> 16) & 0xFFFF));
5975
5976       /* We now need to add all of these results together, taking
5977          care to propogate the carries from the additions.  */
5978       RdLo = Add32 (lo, (mid1 << 16), &carry);
5979       RdHi = carry;
5980       RdLo = Add32 (RdLo, (mid2 << 16), &carry);
5981       RdHi +=
5982         (carry + ((mid1 >> 16) & 0xFFFF) + ((mid2 >> 16) & 0xFFFF) + hi);
5983
5984       if (sign)
5985         {
5986           /* Negate result if necessary.  */
5987           RdLo = ~RdLo;
5988           RdHi = ~RdHi;
5989           if (RdLo == 0xFFFFFFFF)
5990             {
5991               RdLo = 0;
5992               RdHi += 1;
5993             }
5994           else
5995             RdLo += 1;
5996         }
5997
5998       state->Reg[nRdLo] = RdLo;
5999       state->Reg[nRdHi] = RdHi;
6000     }
6001   else if (state->Debug)
6002     fprintf (stderr, "sim: MULTIPLY64 - INVALID ARGUMENTS\n");
6003
6004   if (scc)
6005     /* Ensure that both RdHi and RdLo are used to compute Z,
6006        but don't let RdLo's sign bit make it to N.  */
6007     ARMul_NegZero (state, RdHi | (RdLo >> 16) | (RdLo & 0xFFFF));
6008
6009   /* The cycle count depends on whether the instruction is a signed or
6010      unsigned multiply, and what bits are clear in the multiplier.  */
6011   if (msigned && (Rm & ((unsigned) 1 << 31)))
6012     /* Invert the bits to make the check against zero.  */
6013     Rm = ~Rm;
6014
6015   if ((Rm & 0xFFFFFF00) == 0)
6016     scount = 1;
6017   else if ((Rm & 0xFFFF0000) == 0)
6018     scount = 2;
6019   else if ((Rm & 0xFF000000) == 0)
6020     scount = 3;
6021   else
6022     scount = 4;
6023
6024   return 2 + scount;
6025 }
6026
6027 /* This function does the work of multiplying two 32bit
6028    values and adding a 64bit value to give a 64bit result.  */
6029
6030 static unsigned
6031 MultiplyAdd64 (ARMul_State * state, ARMword instr, int msigned, int scc)
6032 {
6033   unsigned scount;
6034   ARMword RdLo, RdHi;
6035   int nRdHi, nRdLo;
6036   int carry = 0;
6037
6038   nRdHi = BITS (16, 19);
6039   nRdLo = BITS (12, 15);
6040
6041   RdHi = state->Reg[nRdHi];
6042   RdLo = state->Reg[nRdLo];
6043
6044   scount = Multiply64 (state, instr, msigned, LDEFAULT);
6045
6046   RdLo = Add32 (RdLo, state->Reg[nRdLo], &carry);
6047   RdHi = (RdHi + state->Reg[nRdHi]) + carry;
6048
6049   state->Reg[nRdLo] = RdLo;
6050   state->Reg[nRdHi] = RdHi;
6051
6052   if (scc)
6053     /* Ensure that both RdHi and RdLo are used to compute Z,
6054        but don't let RdLo's sign bit make it to N.  */
6055     ARMul_NegZero (state, RdHi | (RdLo >> 16) | (RdLo & 0xFFFF));
6056
6057   /* Extra cycle for addition.  */
6058   return scount + 1;
6059 }