sim/rx/rx.c

   1 /* rx.c --- opcode semantics for stand-alone RX simulator.
   2
   3 Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
   4 Contributed by Red Hat, Inc.
   5
   6 This file is part of the GNU simulators.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <signal.h>
  26
  27 #include "opcode/rx.h"
  28 #include "cpu.h"
  29 #include "mem.h"
  30 #include "syscalls.h"
  31 #include "fpu.h"
  32 #include "err.h"
  33 #include "misc.h"
  34
  35 #ifdef CYCLE_STATS
  36 static const char * id_names[] = {
  37   "RXO_unknown",
  38   "RXO_mov",    /* d = s (signed) */
  39   "RXO_movbi",  /* d = [s,s2] (signed) */
  40   "RXO_movbir", /* [s,s2] = d (signed) */
  41   "RXO_pushm",  /* s..s2 */
  42   "RXO_popm",   /* s..s2 */
  43   "RXO_xchg",   /* s <-> d */
  44   "RXO_stcc",   /* d = s if cond(s2) */
  45   "RXO_rtsd",   /* rtsd, 1=imm, 2-0 = reg if reg type */
  46
  47   /* These are all either d OP= s or, if s2 is set, d = s OP s2.  Note
  48      that d may be "None".  */
  49   "RXO_and",
  50   "RXO_or",
  51   "RXO_xor",
  52   "RXO_add",
  53   "RXO_sub",
  54   "RXO_mul",
  55   "RXO_div",
  56   "RXO_divu",
  57   "RXO_shll",
  58   "RXO_shar",
  59   "RXO_shlr",
  60
  61   "RXO_adc",    /* d = d + s + carry */
  62   "RXO_sbb",    /* d = d - s - ~carry */
  63   "RXO_abs",    /* d = |s| */
  64   "RXO_max",    /* d = max(d,s) */
  65   "RXO_min",    /* d = min(d,s) */
  66   "RXO_emul",   /* d:64 = d:32 * s */
  67   "RXO_emulu",  /* d:64 = d:32 * s (unsigned) */
  68
  69   "RXO_rolc",   /* d <<= 1 through carry */
  70   "RXO_rorc",   /* d >>= 1 through carry*/
  71   "RXO_rotl",   /* d <<= #s without carry */
  72   "RXO_rotr",   /* d >>= #s without carry*/
  73   "RXO_revw",   /* d = revw(s) */
  74   "RXO_revl",   /* d = revl(s) */
  75   "RXO_branch", /* pc = d if cond(s) */
  76   "RXO_branchrel",/* pc += d if cond(s) */
  77   "RXO_jsr",    /* pc = d */
  78   "RXO_jsrrel", /* pc += d */
  79   "RXO_rts",
  80   "RXO_nop",
  81   "RXO_nop2",
  82   "RXO_nop3",
  83
  84   "RXO_scmpu",
  85   "RXO_smovu",
  86   "RXO_smovb",
  87   "RXO_suntil",
  88   "RXO_swhile",
  89   "RXO_smovf",
  90   "RXO_sstr",
  91
  92   "RXO_rmpa",
  93   "RXO_mulhi",
  94   "RXO_mullo",
  95   "RXO_machi",
  96   "RXO_maclo",
  97   "RXO_mvtachi",
  98   "RXO_mvtaclo",
  99   "RXO_mvfachi",
 100   "RXO_mvfacmi",
 101   "RXO_mvfaclo",
 102   "RXO_racw",
 103
 104   "RXO_sat",    /* sat(d) */
 105   "RXO_satr",
 106
 107   "RXO_fadd",   /* d op= s */
 108   "RXO_fcmp",
 109   "RXO_fsub",
 110   "RXO_ftoi",
 111   "RXO_fmul",
 112   "RXO_fdiv",
 113   "RXO_round",
 114   "RXO_itof",
 115
 116   "RXO_bset",   /* d |= (1<<s) */
 117   "RXO_bclr",   /* d &= ~(1<<s) */
 118   "RXO_btst",   /* s & (1<<s2) */
 119   "RXO_bnot",   /* d ^= (1<<s) */
 120   "RXO_bmcc",   /* d<s> = cond(s2) */
 121
 122   "RXO_clrpsw", /* flag index in d */
 123   "RXO_setpsw", /* flag index in d */
 124   "RXO_mvtipl", /* new IPL in s */
 125
 126   "RXO_rtfi",
 127   "RXO_rte",
 128   "RXO_rtd",    /* undocumented */
 129   "RXO_brk",
 130   "RXO_dbt",    /* undocumented */
 131   "RXO_int",    /* vector id in s */
 132   "RXO_stop",
 133   "RXO_wait",
 134
 135   "RXO_sccnd",  /* d = cond(s) ? 1 : 0 */
 136 };
 137
 138 static const char * optype_names[] = {
 139   "    ",
 140   "#Imm",       /* #addend */
 141   " Rn ",       /* Rn */
 142   "[Rn]",       /* [Rn + addend] */
 143   "Ps++",       /* [Rn+] */
 144   "--Pr",       /* [-Rn] */
 145   " cc ",       /* eq, gtu, etc */
 146   "Flag",       /* [UIOSZC] */
 147   "RbRi"        /* [Rb + scale * Ri] */
 148 };
 149
 150 #define N_RXO (sizeof(id_names)/sizeof(id_names[0]))
 151 #define N_RXT (sizeof(optype_names)/sizeof(optype_names[0]))
 152 #define N_MAP 30
 153
 154 static unsigned long long benchmark_start_cycle;
 155 static unsigned long long benchmark_end_cycle;
 156
 157 static int op_cache[N_RXT][N_RXT][N_RXT];
 158 static int op_cache_rev[N_MAP];
 159 static int op_cache_idx = 0;
 160
 161 static int
 162 op_lookup (int a, int b, int c)
 163 {
 164   if (op_cache[a][b][c])
 165     return op_cache[a][b][c];
 166   op_cache_idx ++;
 167   if (op_cache_idx >= N_MAP)
 168     {
 169       printf("op_cache_idx exceeds %d\n", N_MAP);
 170       exit(1);
 171     }
 172   op_cache[a][b][c] = op_cache_idx;
 173   op_cache_rev[op_cache_idx] = (a<<8) | (b<<4) | c;
 174   return op_cache_idx;
 175 }
 176
 177 static char *
 178 op_cache_string (int map)
 179 {
 180   static int ci;
 181   static char cb[5][20];
 182   int a, b, c;
 183
 184   map = op_cache_rev[map];
 185   a = (map >> 8) & 15;
 186   b = (map >> 4) & 15;
 187   c = (map >> 0) & 15;
 188   ci = (ci + 1) % 5;
 189   sprintf(cb[ci], "%s %s %s", optype_names[a], optype_names[b], optype_names[c]);
 190   return cb[ci];
 191 }
 192
 193 static unsigned long long cycles_per_id[N_RXO][N_MAP];
 194 static unsigned long long times_per_id[N_RXO][N_MAP];
 195 static unsigned long long memory_stalls;
 196 static unsigned long long register_stalls;
 197 static unsigned long long branch_stalls;
 198 static unsigned long long branch_alignment_stalls;
 199 static unsigned long long fast_returns;
 200
 201 static unsigned long times_per_pair[N_RXO][N_MAP][N_RXO][N_MAP];
 202 static int prev_opcode_id = RXO_unknown;
 203 static int po0;
 204
 205 #define STATS(x) x
 206
 207 #else
 208 #define STATS(x)
 209 #endif /* CYCLE_STATS */
 210
 211
 212 #ifdef CYCLE_ACCURATE
 213
 214 static int new_rt = -1;
 215
 216 /* Number of cycles to add if an insn spans an 8-byte boundary.  */
 217 static int branch_alignment_penalty = 0;
 218
 219 #endif
 220
 221 static int running_benchmark = 1;
 222
 223 #define tprintf if (trace && running_benchmark) printf
 224
 225 jmp_buf decode_jmp_buf;
 226 unsigned int rx_cycles = 0;
 227
 228 #ifdef CYCLE_ACCURATE
 229 /* If nonzero, memory was read at some point and cycle latency might
 230    take effect.  */
 231 static int memory_source = 0;
 232 /* If nonzero, memory was written and extra cycles might be
 233    needed.  */
 234 static int memory_dest = 0;
 235
 236 static void
 237 cycles (int throughput)
 238 {
 239   tprintf("%d cycles\n", throughput);
 240   regs.cycle_count += throughput;
 241 }
 242
 243 /* Number of execution (E) cycles the op uses.  For memory sources, we
 244    include the load micro-op stall as two extra E cycles.  */
 245 #define E(c) cycles (memory_source ? c + 2 : c)
 246 #define E1 cycles (1)
 247 #define E2 cycles (2)
 248 #define EBIT cycles (memory_source ? 2 : 1)
 249
 250 /* Check to see if a read latency must be applied for a given register.  */
 251 #define RL(r) \
 252   if (regs.rt == r )                                                    \
 253     {                                                                   \
 254       tprintf("register %d load stall\n", r);                           \
 255       regs.cycle_count ++;                                              \
 256       STATS(register_stalls ++);                                        \
 257       regs.rt = -1;                                                     \
 258     }
 259
 260 #define RLD(r)                                  \
 261   if (memory_source)                            \
 262     {                                           \
 263       tprintf ("Rt now %d\n", r);               \
 264       new_rt = r;                               \
 265     }
 266
 267 #else /* !CYCLE_ACCURATE */
 268
 269 #define cycles(t)
 270 #define E(c)
 271 #define E1
 272 #define E2
 273 #define EBIT
 274 #define RL(r)
 275 #define RLD(r)
 276
 277 #endif /* else CYCLE_ACCURATE */
 278
 279 static int size2bytes[] = {
 280   4, 1, 1, 1, 2, 2, 2, 3, 4
 281 };
 282
 283 typedef struct {
 284   unsigned long dpc;
 285 } RX_Data;
 286
 287 #define rx_abort() _rx_abort(__FILE__, __LINE__)
 288 static void
 289 _rx_abort (const char *file, int line)
 290 {
 291   if (strrchr (file, '/'))
 292     file = strrchr (file, '/') + 1;
 293   fprintf(stderr, "abort at %s:%d\n", file, line);
 294   abort();
 295 }
 296
 297 static unsigned char *get_byte_base;
 298 static RX_Opcode_Decoded **decode_cache_base;
 299 static SI get_byte_page;
 300
 301 void
 302 reset_decoder (void)
 303 {
 304   get_byte_base = 0;
 305   decode_cache_base = 0;
 306   get_byte_page = 0;
 307 }
 308
 309 static inline void
 310 maybe_get_mem_page (SI tpc)
 311 {
 312   if (((tpc ^ get_byte_page) & NONPAGE_MASK) || enable_counting)
 313     {
 314       get_byte_page = tpc & NONPAGE_MASK;
 315       get_byte_base = rx_mem_ptr (get_byte_page, MPA_READING) - get_byte_page;
 316       decode_cache_base = rx_mem_decode_cache (get_byte_page) - get_byte_page;
 317     }
 318 }
 319
 320 /* This gets called a *lot* so optimize it.  */
 321 static int
 322 rx_get_byte (void *vdata)
 323 {
 324   RX_Data *rx_data = (RX_Data *)vdata;
 325   SI tpc = rx_data->dpc;
 326
 327   /* See load.c for an explanation of this.  */
 328   if (rx_big_endian)
 329     tpc ^= 3;
 330
 331   maybe_get_mem_page (tpc);
 332
 333   rx_data->dpc ++;
 334   return get_byte_base [tpc];
 335 }
 336
 337 static int
 338 get_op (const RX_Opcode_Decoded *rd, int i)
 339 {
 340   const RX_Opcode_Operand *o = rd->op + i;
 341   int addr, rv = 0;
 342
 343   switch (o->type)
 344     {
 345     case RX_Operand_None:
 346       rx_abort ();
 347
 348     case RX_Operand_Immediate:  /* #addend */
 349       return o->addend;
 350
 351     case RX_Operand_Register:   /* Rn */
 352       RL (o->reg);
 353       rv = get_reg (o->reg);
 354       break;
 355
 356     case RX_Operand_Predec:     /* [-Rn] */
 357       put_reg (o->reg, get_reg (o->reg) - size2bytes[o->size]);
 358       /* fall through */
 359     case RX_Operand_Postinc:    /* [Rn+] */
 360     case RX_Operand_Indirect:   /* [Rn + addend] */
 361     case RX_Operand_TwoReg:     /* [Rn + scale * R2] */
 362 #ifdef CYCLE_ACCURATE
 363       RL (o->reg);
 364       if (o->type == RX_Operand_TwoReg)
 365         RL (rd->op[2].reg);
 366       regs.rt = -1;
 367       if (regs.m2m == M2M_BOTH)
 368         {
 369           tprintf("src memory stall\n");
 370 #ifdef CYCLE_STATS
 371           memory_stalls ++;
 372 #endif
 373           regs.cycle_count ++;
 374           regs.m2m = 0;
 375         }
 376
 377       memory_source = 1;
 378 #endif
 379
 380       if (o->type == RX_Operand_TwoReg)
 381         addr = get_reg (o->reg) * size2bytes[rd->size] + get_reg (rd->op[2].reg);
 382       else
 383         addr = get_reg (o->reg) + o->addend;
 384
 385       switch (o->size)
 386         {
 387         case RX_AnySize:
 388           rx_abort ();
 389
 390         case RX_Byte: /* undefined extension */
 391         case RX_UByte:
 392         case RX_SByte:
 393           rv = mem_get_qi (addr);
 394           break;
 395
 396         case RX_Word: /* undefined extension */
 397         case RX_UWord:
 398         case RX_SWord:
 399           rv = mem_get_hi (addr);
 400           break;
 401
 402         case RX_3Byte:
 403           rv = mem_get_psi (addr);
 404           break;
 405
 406         case RX_Long:
 407           rv = mem_get_si (addr);
 408           break;
 409         }
 410
 411       if (o->type == RX_Operand_Postinc)
 412         put_reg (o->reg, get_reg (o->reg) + size2bytes[o->size]);
 413
 414       break;
 415
 416     case RX_Operand_Condition:  /* eq, gtu, etc */
 417       return condition_true (o->reg);
 418
 419     case RX_Operand_Flag:       /* [UIOSZC] */
 420       return (regs.r_psw & (1 << o->reg)) ? 1 : 0;
 421     }
 422
 423   /* if we've gotten here, we need to clip/extend the value according
 424      to the size.  */
 425   switch (o->size)
 426     {
 427     case RX_AnySize:
 428       rx_abort ();
 429
 430     case RX_Byte: /* undefined extension */
 431       rv |= 0xdeadbe00; /* keep them honest */
 432       break;
 433
 434     case RX_UByte:
 435       rv &= 0xff;
 436       break;
 437
 438     case RX_SByte:
 439       rv = sign_ext (rv, 8);
 440       break;
 441
 442     case RX_Word: /* undefined extension */
 443       rv |= 0xdead0000; /* keep them honest */
 444       break;
 445
 446     case RX_UWord:
 447       rv &=  0xffff;
 448       break;
 449
 450     case RX_SWord:
 451       rv = sign_ext (rv, 16);
 452       break;
 453
 454     case RX_3Byte:
 455       rv &= 0xffffff;
 456       break;
 457
 458     case RX_Long:
 459       break;
 460     }
 461   return rv;
 462 }
 463
 464 static void
 465 put_op (const RX_Opcode_Decoded *rd, int i, int v)
 466 {
 467   const RX_Opcode_Operand *o = rd->op + i;
 468   int addr;
 469
 470   switch (o->size)
 471     {
 472     case RX_AnySize:
 473       if (o->type != RX_Operand_Register)
 474         rx_abort ();
 475       break;
 476
 477     case RX_Byte: /* undefined extension */
 478       v |= 0xdeadbe00; /* keep them honest */
 479       break;
 480
 481     case RX_UByte:
 482       v &= 0xff;
 483       break;
 484
 485     case RX_SByte:
 486       v = sign_ext (v, 8);
 487       break;
 488
 489     case RX_Word: /* undefined extension */
 490       v |= 0xdead0000; /* keep them honest */
 491       break;
 492
 493     case RX_UWord:
 494       v &=  0xffff;
 495       break;
 496
 497     case RX_SWord:
 498       v = sign_ext (v, 16);
 499       break;
 500
 501     case RX_3Byte:
 502       v &= 0xffffff;
 503       break;
 504
 505     case RX_Long:
 506       break;
 507     }
 508
 509   switch (o->type)
 510     {
 511     case RX_Operand_None:
 512       /* Opcodes like TST and CMP use this.  */
 513       break;
 514
 515     case RX_Operand_Immediate:  /* #addend */
 516     case RX_Operand_Condition:  /* eq, gtu, etc */
 517       rx_abort ();
 518
 519     case RX_Operand_Register:   /* Rn */
 520       put_reg (o->reg, v);
 521       RLD (o->reg);
 522       break;
 523
 524     case RX_Operand_Predec:     /* [-Rn] */
 525       put_reg (o->reg, get_reg (o->reg) - size2bytes[o->size]);
 526       /* fall through */
 527     case RX_Operand_Postinc:    /* [Rn+] */
 528     case RX_Operand_Indirect:   /* [Rn + addend] */
 529     case RX_Operand_TwoReg:     /* [Rn + scale * R2] */
 530
 531 #ifdef CYCLE_ACCURATE
 532       if (regs.m2m == M2M_BOTH)
 533         {
 534           tprintf("dst memory stall\n");
 535           regs.cycle_count ++;
 536 #ifdef CYCLE_STATS
 537           memory_stalls ++;
 538 #endif
 539           regs.m2m = 0;
 540         }
 541       memory_dest = 1;
 542 #endif
 543
 544       if (o->type == RX_Operand_TwoReg)
 545         addr = get_reg (o->reg) * size2bytes[rd->size] + get_reg (rd->op[2].reg);
 546       else
 547         addr = get_reg (o->reg) + o->addend;
 548
 549       switch (o->size)
 550         {
 551         case RX_AnySize:
 552           rx_abort ();
 553
 554         case RX_Byte: /* undefined extension */
 555         case RX_UByte:
 556         case RX_SByte:
 557           mem_put_qi (addr, v);
 558           break;
 559
 560         case RX_Word: /* undefined extension */
 561         case RX_UWord:
 562         case RX_SWord:
 563           mem_put_hi (addr, v);
 564           break;
 565
 566         case RX_3Byte:
 567           mem_put_psi (addr, v);
 568           break;
 569
 570         case RX_Long:
 571           mem_put_si (addr, v);
 572           break;
 573         }
 574
 575       if (o->type == RX_Operand_Postinc)
 576         put_reg (o->reg, get_reg (o->reg) + size2bytes[o->size]);
 577
 578       break;
 579
 580     case RX_Operand_Flag:       /* [UIOSZC] */
 581       if (v)
 582         regs.r_psw |= (1 << o->reg);
 583       else
 584         regs.r_psw &= ~(1 << o->reg);
 585       break;
 586     }
 587 }
 588
 589 #define PD(x) put_op (opcode, 0, x)
 590 #define PS(x) put_op (opcode, 1, x)
 591 #define PS2(x) put_op (opcode, 2, x)
 592 #define GD() get_op (opcode, 0)
 593 #define GS() get_op (opcode, 1)
 594 #define GS2() get_op (opcode, 2)
 595 #define DSZ() size2bytes[opcode->op[0].size]
 596 #define SSZ() size2bytes[opcode->op[0].size]
 597 #define S2SZ() size2bytes[opcode->op[0].size]
 598
 599 /* "Universal" sources.  */
 600 #define US1() ((opcode->op[2].type == RX_Operand_None) ? GD() : GS())
 601 #define US2() ((opcode->op[2].type == RX_Operand_None) ? GS() : GS2())
 602
 603 static void
 604 push(int val)
 605 {
 606   int rsp = get_reg (sp);
 607   rsp -= 4;
 608   put_reg (sp, rsp);
 609   mem_put_si (rsp, val);
 610 }
 611
 612 /* Just like the above, but tag the memory as "pushed pc" so if anyone
 613    tries to write to it, it will cause an error.  */
 614 static void
 615 pushpc(int val)
 616 {
 617   int rsp = get_reg (sp);
 618   rsp -= 4;
 619   put_reg (sp, rsp);
 620   mem_put_si (rsp, val);
 621   mem_set_content_range (rsp, rsp+3, MC_PUSHED_PC);
 622 }
 623
 624 static int
 625 pop()
 626 {
 627   int rv;
 628   int rsp = get_reg (sp);
 629   rv = mem_get_si (rsp);
 630   rsp += 4;
 631   put_reg (sp, rsp);
 632   return rv;
 633 }
 634
 635 static int
 636 poppc()
 637 {
 638   int rv;
 639   int rsp = get_reg (sp);
 640   if (mem_get_content_type (rsp) != MC_PUSHED_PC)
 641     execution_error (SIM_ERR_CORRUPT_STACK, rsp);
 642   rv = mem_get_si (rsp);
 643   mem_set_content_range (rsp, rsp+3, MC_UNINIT);
 644   rsp += 4;
 645   put_reg (sp, rsp);
 646   return rv;
 647 }
 648
 649 #define MATH_OP(vop,c)                          \
 650 { \
 651   umb = US2(); \
 652   uma = US1(); \
 653   ll = (unsigned long long) uma vop (unsigned long long) umb vop c; \
 654   tprintf ("0x%x " #vop " 0x%x " #vop " 0x%x = 0x%llx\n", uma, umb, c, ll); \
 655   ma = sign_ext (uma, DSZ() * 8);                                       \
 656   mb = sign_ext (umb, DSZ() * 8);                                       \
 657   sll = (long long) ma vop (long long) mb vop c; \
 658   tprintf ("%d " #vop " %d " #vop " %d = %lld\n", ma, mb, c, sll); \
 659   set_oszc (sll, DSZ(), (long long) ll > ((1 vop 1) ? (long long) b2mask[DSZ()] : (long long) -1)); \
 660   PD (sll); \
 661   E (1);    \
 662 }
 663
 664 #define LOGIC_OP(vop) \
 665 { \
 666   mb = US2(); \
 667   ma = US1(); \
 668   v = ma vop mb; \
 669   tprintf("0x%x " #vop " 0x%x = 0x%x\n", ma, mb, v); \
 670   set_sz (v, DSZ()); \
 671   PD(v); \
 672   E (1); \
 673 }
 674
 675 #define SHIFT_OP(val, type, count, OP, carry_mask)      \
 676 { \
 677   int i, c=0; \
 678   count = US2(); \
 679   val = (type)US1();                            \
 680   tprintf("%lld " #OP " %d\n", val, count); \
 681   for (i = 0; i < count; i ++) \
 682     { \
 683       c = val & carry_mask; \
 684       val OP 1; \
 685     } \
 686   if (count) \
 687     set_oszc (val, 4, c); \
 688   PD (val); \
 689 }
 690
 691 typedef union {
 692   int i;
 693   float f;
 694 } FloatInt;
 695
 696 static inline int
 697 float2int (float f)
 698 {
 699   FloatInt fi;
 700   fi.f = f;
 701   return fi.i;
 702 }
 703
 704 static inline float
 705 int2float (int i)
 706 {
 707   FloatInt fi;
 708   fi.i = i;
 709   return fi.f;
 710 }
 711
 712 static int
 713 fop_fadd (fp_t s1, fp_t s2, fp_t *d)
 714 {
 715   *d = rxfp_add (s1, s2);
 716   return 1;
 717 }
 718
 719 static int
 720 fop_fmul (fp_t s1, fp_t s2, fp_t *d)
 721 {
 722   *d = rxfp_mul (s1, s2);
 723   return 1;
 724 }
 725
 726 static int
 727 fop_fdiv (fp_t s1, fp_t s2, fp_t *d)
 728 {
 729   *d = rxfp_div (s1, s2);
 730   return 1;
 731 }
 732
 733 static int
 734 fop_fsub (fp_t s1, fp_t s2, fp_t *d)
 735 {
 736   *d = rxfp_sub (s1, s2);
 737   return 1;
 738 }
 739
 740 #define FPPENDING() (regs.r_fpsw & (FPSWBITS_CE | (FPSWBITS_FMASK & (regs.r_fpsw << FPSW_EFSH))))
 741 #define FPCLEAR() regs.r_fpsw &= FPSWBITS_CLEAR
 742 #define FPCHECK() \
 743   if (FPPENDING()) \
 744     return do_fp_exception (opcode_pc)
 745
 746 #define FLOAT_OP(func) \
 747 { \
 748   int do_store;   \
 749   fp_t fa, fb, fc; \
 750   FPCLEAR(); \
 751   fb = GS (); \
 752   fa = GD (); \
 753   do_store = fop_##func (fa, fb, &fc); \
 754   tprintf("%g " #func " %g = %g %08x\n", int2float(fa), int2float(fb), int2float(fc), fc); \
 755   FPCHECK(); \
 756   if (do_store) \
 757     PD (fc);    \
 758   mb = 0; \
 759   if ((fc & 0x80000000UL) != 0) \
 760     mb |= FLAGBIT_S; \
 761   if ((fc & 0x7fffffffUL) == 0)                 \
 762     mb |= FLAGBIT_Z; \
 763   set_flags (FLAGBIT_S | FLAGBIT_Z, mb); \
 764 }
 765
 766 #define carry (FLAG_C ? 1 : 0)
 767
 768 static struct {
 769   unsigned long vaddr;
 770   const char *str;
 771   int signal;
 772 } exception_info[] = {
 773   { 0xFFFFFFD0UL, "priviledged opcode", SIGILL },
 774   { 0xFFFFFFD4UL, "access violation", SIGSEGV },
 775   { 0xFFFFFFDCUL, "undefined opcode", SIGILL },
 776   { 0xFFFFFFE4UL, "floating point", SIGFPE }
 777 };
 778 #define EX_PRIVILEDGED  0
 779 #define EX_ACCESS       1
 780 #define EX_UNDEFINED    2
 781 #define EX_FLOATING     3
 782 #define EXCEPTION(n)  \
 783   return generate_exception (n, opcode_pc)
 784
 785 #define PRIVILEDGED() \
 786   if (FLAG_PM) \
 787     EXCEPTION (EX_PRIVILEDGED)
 788
 789 static int
 790 generate_exception (unsigned long type, SI opcode_pc)
 791 {
 792   SI old_psw, old_pc, new_pc;
 793
 794   new_pc = mem_get_si (exception_info[type].vaddr);
 795   /* 0x00020000 is the value used to initialise the known
 796      exception vectors (see rx.ld), but it is a reserved
 797      area of memory so do not try to access it, and if the
 798      value has not been changed by the program then the
 799      vector has not been installed.  */
 800   if (new_pc == 0 || new_pc == 0x00020000)
 801     {
 802       if (rx_in_gdb)
 803         return RX_MAKE_STOPPED (exception_info[type].signal);
 804
 805       fprintf(stderr, "Unhandled %s exception at pc = %#lx\n",
 806               exception_info[type].str, (unsigned long) opcode_pc);
 807       if (type == EX_FLOATING)
 808         {
 809           int mask = FPPENDING ();
 810           fprintf (stderr, "Pending FP exceptions:");
 811           if (mask & FPSWBITS_FV)
 812             fprintf(stderr, " Invalid");
 813           if (mask & FPSWBITS_FO)
 814             fprintf(stderr, " Overflow");
 815           if (mask & FPSWBITS_FZ)
 816             fprintf(stderr, " Division-by-zero");
 817           if (mask & FPSWBITS_FU)
 818             fprintf(stderr, " Underflow");
 819           if (mask & FPSWBITS_FX)
 820             fprintf(stderr, " Inexact");
 821           if (mask & FPSWBITS_CE)
 822             fprintf(stderr, " Unimplemented");
 823           fprintf(stderr, "\n");
 824         }
 825       return RX_MAKE_EXITED (1);
 826     }
 827
 828   tprintf ("Triggering %s exception\n", exception_info[type].str);
 829
 830   old_psw = regs.r_psw;
 831   regs.r_psw &= ~ (FLAGBIT_I | FLAGBIT_U | FLAGBIT_PM);
 832   old_pc = opcode_pc;
 833   regs.r_pc = new_pc;
 834   pushpc (old_psw);
 835   pushpc (old_pc);
 836   return RX_MAKE_STEPPED ();
 837 }
 838
 839 void
 840 generate_access_exception (void)
 841 {
 842   int rv;
 843
 844   rv = generate_exception (EX_ACCESS, regs.r_pc);
 845   if (RX_EXITED (rv))
 846     longjmp (decode_jmp_buf, rv);
 847 }
 848
 849 static int
 850 do_fp_exception (unsigned long opcode_pc)
 851 {
 852   while (FPPENDING())
 853     EXCEPTION (EX_FLOATING);
 854   return RX_MAKE_STEPPED ();
 855 }
 856
 857 static int
 858 op_is_memory (const RX_Opcode_Decoded *rd, int i)
 859 {
 860   switch (rd->op[i].type)
 861     {
 862     case RX_Operand_Predec:
 863     case RX_Operand_Postinc:
 864     case RX_Operand_Indirect:
 865       return 1;
 866     default:
 867       return 0;
 868     }
 869 }
 870 #define OM(i) op_is_memory (opcode, i)
 871
 872 #define DO_RETURN(x) { longjmp (decode_jmp_buf, x); }
 873
 874 int
 875 decode_opcode ()
 876 {
 877   unsigned int uma=0, umb=0;
 878   int ma=0, mb=0;
 879   int opcode_size, v;
 880   unsigned long long ll;
 881   long long sll;
 882   unsigned long opcode_pc;
 883   RX_Data rx_data;
 884   const RX_Opcode_Decoded *opcode;
 885 #ifdef CYCLE_STATS
 886   unsigned long long prev_cycle_count;
 887 #endif
 888 #ifdef CYCLE_ACCURATE
 889   unsigned int tx;
 890 #endif
 891
 892 #ifdef CYCLE_STATS
 893   prev_cycle_count = regs.cycle_count;
 894 #endif
 895
 896 #ifdef CYCLE_ACCURATE
 897   memory_source = 0;
 898   memory_dest = 0;
 899 #endif
 900
 901   rx_cycles ++;
 902
 903   maybe_get_mem_page (regs.r_pc);
 904
 905   opcode_pc = regs.r_pc;
 906
 907   /* Note that we don't word-swap this point, there's no point.  */
 908   if (decode_cache_base[opcode_pc] == NULL)
 909     {
 910       RX_Opcode_Decoded *opcode_w;
 911       rx_data.dpc = opcode_pc;
 912       opcode_w = decode_cache_base[opcode_pc] = calloc (1, sizeof (RX_Opcode_Decoded));
 913       opcode_size = rx_decode_opcode (opcode_pc, opcode_w,
 914                                       rx_get_byte, &rx_data);
 915       opcode = opcode_w;
 916     }
 917   else
 918     {
 919       opcode = decode_cache_base[opcode_pc];
 920       opcode_size = opcode->n_bytes;
 921     }
 922
 923 #ifdef CYCLE_ACCURATE
 924   if (branch_alignment_penalty)
 925     {
 926       if ((regs.r_pc ^ (regs.r_pc + opcode_size - 1)) & ~7)
 927         {
 928           tprintf("1 cycle branch alignment penalty\n");
 929           cycles (branch_alignment_penalty);
 930 #ifdef CYCLE_STATS
 931           branch_alignment_stalls ++;
 932 #endif
 933         }
 934       branch_alignment_penalty = 0;
 935     }
 936 #endif
 937
 938   regs.r_pc += opcode_size;
 939
 940   rx_flagmask = opcode->flags_s;
 941   rx_flagand = ~(int)opcode->flags_0;
 942   rx_flagor = opcode->flags_1;
 943
 944   switch (opcode->id)
 945     {
 946     case RXO_abs:
 947       sll = GS ();
 948       tprintf("|%lld| = ", sll);
 949       if (sll < 0)
 950         sll = -sll;
 951       tprintf("%lld\n", sll);
 952       PD (sll);
 953       set_osz (sll, 4);
 954       E (1);
 955       break;
 956
 957     case RXO_adc:
 958       MATH_OP (+,carry);
 959       break;
 960
 961     case RXO_add:
 962       MATH_OP (+,0);
 963       break;
 964
 965     case RXO_and:
 966       LOGIC_OP (&);
 967       break;
 968
 969     case RXO_bclr:
 970       ma = GD ();
 971       mb = GS ();
 972       if (opcode->op[0].type == RX_Operand_Register)
 973         mb &= 0x1f;
 974       else
 975         mb &= 0x07;
 976       ma &= ~(1 << mb);
 977       PD (ma);
 978       EBIT;
 979       break;
 980
 981     case RXO_bmcc:
 982       ma = GD ();
 983       mb = GS ();
 984       if (opcode->op[0].type == RX_Operand_Register)
 985         mb &= 0x1f;
 986       else
 987         mb &= 0x07;
 988       if (GS2 ())
 989         ma |= (1 << mb);
 990       else
 991         ma &= ~(1 << mb);
 992       PD (ma);
 993       EBIT;
 994       break;
 995
 996     case RXO_bnot:
 997       ma = GD ();
 998       mb = GS ();
 999       if (opcode->op[0].type == RX_Operand_Register)
1000         mb &= 0x1f;
1001       else
1002         mb &= 0x07;
1003       ma ^= (1 << mb);
1004       PD (ma);
1005       EBIT;
1006       break;
1007
1008     case RXO_branch:
1009       if (opcode->op[1].type == RX_Operand_None || GS())
1010         {
1011 #ifdef CYCLE_ACCURATE
1012           SI old_pc = regs.r_pc;
1013           int delta;
1014 #endif
1015           regs.r_pc = GD();
1016 #ifdef CYCLE_ACCURATE
1017           delta = regs.r_pc - old_pc;
1018           if (delta >= 0 && delta < 16
1019               && opcode_size > 1)
1020             {
1021               tprintf("near forward branch bonus\n");
1022               cycles (2);
1023             }
1024           else
1025             {
1026               cycles (3);
1027               branch_alignment_penalty = 1;
1028             }
1029 #ifdef CYCLE_STATS
1030           branch_stalls ++;
1031 #endif
1032 #endif
1033         }
1034 #ifdef CYCLE_ACCURATE
1035       else
1036         cycles (1);
1037 #endif
1038       break;
1039
1040     case RXO_branchrel:
1041       if (GS())
1042         {
1043           int delta = GD();
1044           regs.r_pc += delta;
1045 #ifdef CYCLE_ACCURATE
1046           /* Note: specs say 3, chip says 2.  */
1047           if (delta >= 0 && delta < 16
1048               && opcode_size > 1)
1049             {
1050               tprintf("near forward branch bonus\n");
1051               cycles (2);
1052             }
1053           else
1054             {
1055               cycles (3);
1056               branch_alignment_penalty = 1;
1057             }
1058 #ifdef CYCLE_STATS
1059           branch_stalls ++;
1060 #endif
1061 #endif
1062         }
1063 #ifdef CYCLE_ACCURATE
1064       else
1065         cycles (1);
1066 #endif
1067       break;
1068
1069     case RXO_brk:
1070       {
1071         int old_psw = regs.r_psw;
1072         if (rx_in_gdb)
1073           DO_RETURN (RX_MAKE_HIT_BREAK ());
1074         if (regs.r_intb == 0)
1075           {
1076             tprintf("BREAK hit, no vector table.\n");
1077             DO_RETURN (RX_MAKE_EXITED(1));
1078           }
1079         regs.r_psw &= ~(FLAGBIT_I | FLAGBIT_U | FLAGBIT_PM);
1080         pushpc (old_psw);
1081         pushpc (regs.r_pc);
1082         regs.r_pc = mem_get_si (regs.r_intb);
1083         cycles(6);
1084       }
1085       break;
1086
1087     case RXO_bset:
1088       ma = GD ();
1089       mb = GS ();
1090       if (opcode->op[0].type == RX_Operand_Register)
1091         mb &= 0x1f;
1092       else
1093         mb &= 0x07;
1094       ma |= (1 << mb);
1095       PD (ma);
1096       EBIT;
1097       break;
1098
1099     case RXO_btst:
1100       ma = GS ();
1101       mb = GS2 ();
1102       if (opcode->op[1].type == RX_Operand_Register)
1103         mb &= 0x1f;
1104       else
1105         mb &= 0x07;
1106       umb = ma & (1 << mb);
1107       set_zc (! umb, umb);
1108       EBIT;
1109       break;
1110
1111     case RXO_clrpsw:
1112       v = 1 << opcode->op[0].reg;
1113       if (FLAG_PM
1114           && (v == FLAGBIT_I
1115               || v == FLAGBIT_U))
1116         break;
1117       regs.r_psw &= ~v;
1118       cycles (1);
1119       break;
1120
1121     case RXO_div: /* d = d / s */
1122       ma = GS();
1123       mb = GD();
1124       tprintf("%d / %d = ", mb, ma);
1125       if (ma == 0 || (ma == -1 && (unsigned int) mb == 0x80000000))
1126         {
1127           tprintf("#NAN\n");
1128           set_flags (FLAGBIT_O, FLAGBIT_O);
1129         }
1130       else
1131         {
1132           v = mb/ma;
1133           tprintf("%d\n", v);
1134           set_flags (FLAGBIT_O, 0);
1135           PD (v);
1136         }
1137       /* Note: spec says 3 to 22 cycles, we are pessimistic.  */
1138       cycles (22);
1139       break;
1140
1141     case RXO_divu: /* d = d / s */
1142       uma = GS();
1143       umb = GD();
1144       tprintf("%u / %u = ", umb, uma);
1145       if (uma == 0)
1146         {
1147           tprintf("#NAN\n");
1148           set_flags (FLAGBIT_O, FLAGBIT_O);
1149         }
1150       else
1151         {
1152           v = umb / uma;
1153           tprintf("%u\n", v);
1154           set_flags (FLAGBIT_O, 0);
1155           PD (v);
1156         }
1157       /* Note: spec says 2 to 20 cycles, we are pessimistic.  */
1158       cycles (20);
1159       break;
1160
1161     case RXO_emul:
1162       ma = GD ();
1163       mb = GS ();
1164       sll = (long long)ma * (long long)mb;
1165       tprintf("%d * %d = %lld\n", ma, mb, sll);
1166       put_reg (opcode->op[0].reg, sll);
1167       put_reg (opcode->op[0].reg + 1, sll >> 32);
1168       E2;
1169       break;
1170
1171     case RXO_emulu:
1172       uma = GD ();
1173       umb = GS ();
1174       ll = (long long)uma * (long long)umb;
1175       tprintf("%#x * %#x = %#llx\n", uma, umb, ll);
1176       put_reg (opcode->op[0].reg, ll);
1177       put_reg (opcode->op[0].reg + 1, ll >> 32);
1178       E2;
1179       break;
1180
1181     case RXO_fadd:
1182       FLOAT_OP (fadd);
1183       E (4);
1184       break;
1185
1186     case RXO_fcmp:
1187       ma = GD();
1188       mb = GS();
1189       FPCLEAR ();
1190       rxfp_cmp (ma, mb);
1191       FPCHECK ();
1192       E (1);
1193       break;
1194
1195     case RXO_fdiv:
1196       FLOAT_OP (fdiv);
1197       E (16);
1198       break;
1199
1200     case RXO_fmul:
1201       FLOAT_OP (fmul);
1202       E (3);
1203       break;
1204
1205     case RXO_rtfi:
1206       PRIVILEDGED ();
1207       regs.r_psw = regs.r_bpsw;
1208       regs.r_pc = regs.r_bpc;
1209 #ifdef CYCLE_ACCURATE
1210       regs.fast_return = 0;
1211       cycles(3);
1212 #endif
1213       break;
1214
1215     case RXO_fsub:
1216       FLOAT_OP (fsub);
1217       E (4);
1218       break;
1219
1220     case RXO_ftoi:
1221       ma = GS ();
1222       FPCLEAR ();
1223       mb = rxfp_ftoi (ma, FPRM_ZERO);
1224       FPCHECK ();
1225       PD (mb);
1226       tprintf("(int) %g = %d\n", int2float(ma), mb);
1227       set_sz (mb, 4);
1228       E (2);
1229       break;
1230
1231     case RXO_int:
1232       v = GS ();
1233       if (v == 255)
1234         {
1235           int rc = rx_syscall (regs.r[5]);
1236           if (! RX_STEPPED (rc))
1237             DO_RETURN (rc);
1238         }
1239       else
1240         {
1241           int old_psw = regs.r_psw;
1242           regs.r_psw &= ~(FLAGBIT_I | FLAGBIT_U | FLAGBIT_PM);
1243           pushpc (old_psw);
1244           pushpc (regs.r_pc);
1245           regs.r_pc = mem_get_si (regs.r_intb + 4 * v);
1246         }
1247       cycles (6);
1248       break;
1249
1250     case RXO_itof:
1251       ma = GS ();
1252       FPCLEAR ();
1253       mb = rxfp_itof (ma, regs.r_fpsw);
1254       FPCHECK ();
1255       tprintf("(float) %d = %x\n", ma, mb);
1256       PD (mb);
1257       set_sz (ma, 4);
1258       E (2);
1259       break;
1260
1261     case RXO_jsr:
1262     case RXO_jsrrel:
1263       {
1264 #ifdef CYCLE_ACCURATE
1265         int delta;
1266         regs.m2m = 0;
1267 #endif
1268         v = GD ();
1269 #ifdef CYCLE_ACCURATE
1270         regs.link_register = regs.r_pc;
1271 #endif
1272         pushpc (get_reg (pc));
1273         if (opcode->id == RXO_jsrrel)
1274           v += regs.r_pc;
1275 #ifdef CYCLE_ACCURATE
1276         delta = v - regs.r_pc;
1277 #endif
1278         put_reg (pc, v);
1279 #ifdef CYCLE_ACCURATE
1280         /* Note: docs say 3, chip says 2 */
1281         if (delta >= 0 && delta < 16)
1282           {
1283             tprintf ("near forward jsr bonus\n");
1284             cycles (2);
1285           }
1286         else
1287           {
1288             branch_alignment_penalty = 1;
1289             cycles (3);
1290           }
1291         regs.fast_return = 1;
1292 #endif
1293       }
1294       break;
1295
1296     case RXO_machi:
1297       ll = (long long)(signed short)(GS() >> 16) * (long long)(signed short)(GS2 () >> 16);
1298       ll <<= 16;
1299       put_reg64 (acc64, ll + regs.r_acc);
1300       E1;
1301       break;
1302
1303     case RXO_maclo:
1304       ll = (long long)(signed short)(GS()) * (long long)(signed short)(GS2 ());
1305       ll <<= 16;
1306       put_reg64 (acc64, ll + regs.r_acc);
1307       E1;
1308       break;
1309
1310     case RXO_max:
1311       mb = GS();
1312       ma = GD();
1313       if (ma > mb)
1314         PD (ma);
1315       else
1316         PD (mb);
1317       E (1);
1318       break;
1319
1320     case RXO_min:
1321       mb = GS();
1322       ma = GD();
1323       if (ma < mb)
1324         PD (ma);
1325       else
1326         PD (mb);
1327       E (1);
1328       break;
1329
1330     case RXO_mov:
1331       v = GS ();
1332
1333       if (opcode->op[0].type == RX_Operand_Register
1334           && opcode->op[0].reg == 16 /* PSW */)
1335         {
1336           /* Special case, LDC and POPC can't ever modify PM.  */
1337           int pm = regs.r_psw & FLAGBIT_PM;
1338           v &= ~ FLAGBIT_PM;
1339           v |= pm;
1340           if (pm)
1341             {
1342               v &= ~ (FLAGBIT_I | FLAGBIT_U | FLAGBITS_IPL);
1343               v |= pm;
1344             }
1345         }
1346       if (FLAG_PM)
1347         {
1348           /* various things can't be changed in user mode.  */
1349           if (opcode->op[0].type == RX_Operand_Register)
1350             if (opcode->op[0].reg == 32)
1351               {
1352                 v &= ~ (FLAGBIT_I | FLAGBIT_U | FLAGBITS_IPL);
1353                 v |= regs.r_psw & (FLAGBIT_I | FLAGBIT_U | FLAGBITS_IPL);
1354               }
1355           if (opcode->op[0].reg == 34 /* ISP */
1356               || opcode->op[0].reg == 37 /* BPSW */
1357               || opcode->op[0].reg == 39 /* INTB */
1358               || opcode->op[0].reg == 38 /* VCT */)
1359             /* These are ignored.  */
1360             break;
1361         }
1362       if (OM(0) && OM(1))
1363         cycles (2);
1364       else
1365         cycles (1);
1366
1367       PD (v);
1368
1369 #ifdef CYCLE_ACCURATE
1370       if ((opcode->op[0].type == RX_Operand_Predec
1371            && opcode->op[1].type == RX_Operand_Register)
1372           || (opcode->op[0].type == RX_Operand_Postinc
1373               && opcode->op[1].type == RX_Operand_Register))
1374         {
1375           /* Special case: push reg doesn't cause a memory stall.  */
1376           memory_dest = 0;
1377           tprintf("push special case\n");
1378         }
1379 #endif
1380
1381       set_sz (v, DSZ());
1382       break;
1383
1384     case RXO_movbi:
1385       PD (GS ());
1386       cycles (1);
1387       break;
1388
1389     case RXO_movbir:
1390       PS (GD ());
1391       cycles (1);
1392       break;
1393
1394     case RXO_mul:
1395       v = US2 ();
1396       ll = (unsigned long long) US1() * (unsigned long long) v;
1397       PD(ll);
1398       E (1);
1399       break;
1400
1401     case RXO_mulhi:
1402       v = GS2 ();
1403       ll = (long long)(signed short)(GS() >> 16) * (long long)(signed short)(v >> 16);
1404       ll <<= 16;
1405       put_reg64 (acc64, ll);
1406       E1;
1407       break;
1408
1409     case RXO_mullo:
1410       v = GS2 ();
1411       ll = (long long)(signed short)(GS()) * (long long)(signed short)(v);
1412       ll <<= 16;
1413       put_reg64 (acc64, ll);
1414       E1;
1415       break;
1416
1417     case RXO_mvfachi:
1418       PD (get_reg (acchi));
1419       E1;
1420       break;
1421
1422     case RXO_mvfaclo:
1423       PD (get_reg (acclo));
1424       E1;
1425       break;
1426
1427     case RXO_mvfacmi:
1428       PD (get_reg (accmi));
1429       E1;
1430       break;
1431
1432     case RXO_mvtachi:
1433       put_reg (acchi, GS ());
1434       E1;
1435       break;
1436
1437     case RXO_mvtaclo:
1438       put_reg (acclo, GS ());
1439       E1;
1440       break;
1441
1442     case RXO_mvtipl:
1443       regs.r_psw &= ~ FLAGBITS_IPL;
1444       regs.r_psw |= (GS () << FLAGSHIFT_IPL) & FLAGBITS_IPL;
1445       E1;
1446       break;
1447
1448     case RXO_nop:
1449     case RXO_nop2:
1450     case RXO_nop3:
1451       E1;
1452       break;
1453
1454     case RXO_or:
1455       LOGIC_OP (|);
1456       break;
1457
1458     case RXO_popm:
1459       /* POPM cannot pop R0 (sp).  */
1460       if (opcode->op[1].reg == 0 || opcode->op[2].reg == 0)
1461         EXCEPTION (EX_UNDEFINED);
1462       if (opcode->op[1].reg >= opcode->op[2].reg)
1463         {
1464           regs.r_pc = opcode_pc;
1465           DO_RETURN (RX_MAKE_STOPPED (SIGILL));
1466         }
1467       for (v = opcode->op[1].reg; v <= opcode->op[2].reg; v++)
1468         {
1469           cycles (1);
1470           RLD (v);
1471           put_reg (v, pop ());
1472         }
1473       break;
1474
1475     case RXO_pushm:
1476       /* PUSHM cannot push R0 (sp).  */
1477       if (opcode->op[1].reg == 0 || opcode->op[2].reg == 0)
1478         EXCEPTION (EX_UNDEFINED);
1479       if (opcode->op[1].reg >= opcode->op[2].reg)
1480         {
1481           regs.r_pc = opcode_pc;
1482           return RX_MAKE_STOPPED (SIGILL);
1483         }
1484       for (v = opcode->op[2].reg; v >= opcode->op[1].reg; v--)
1485         {
1486           RL (v);
1487           push (get_reg (v));
1488         }
1489       cycles (opcode->op[2].reg - opcode->op[1].reg + 1);
1490       break;
1491
1492     case RXO_racw:
1493       ll = get_reg64 (acc64) << GS ();
1494       ll += 0x80000000ULL;
1495       if ((signed long long)ll > (signed long long)0x00007fff00000000ULL)
1496         ll = 0x00007fff00000000ULL;
1497       else if ((signed long long)ll < (signed long long)0xffff800000000000ULL)
1498         ll = 0xffff800000000000ULL;
1499       else
1500         ll &= 0xffffffff00000000ULL;
1501       put_reg64 (acc64, ll);
1502       E1;
1503       break;
1504
1505     case RXO_rte:
1506       PRIVILEDGED ();
1507       regs.r_pc = poppc ();
1508       regs.r_psw = poppc ();
1509       if (FLAG_PM)
1510         regs.r_psw |= FLAGBIT_U;
1511 #ifdef CYCLE_ACCURATE
1512       regs.fast_return = 0;
1513       cycles (6);
1514 #endif
1515       break;
1516
1517     case RXO_revl:
1518       uma = GS ();
1519       umb = (((uma >> 24) & 0xff)
1520              | ((uma >> 8) & 0xff00)
1521              | ((uma << 8) & 0xff0000)
1522              | ((uma << 24) & 0xff000000UL));
1523       PD (umb);
1524       E1;
1525       break;
1526
1527     case RXO_revw:
1528       uma = GS ();
1529       umb = (((uma >> 8) & 0x00ff00ff)
1530              | ((uma << 8) & 0xff00ff00UL));
1531       PD (umb);
1532       E1;
1533       break;
1534
1535     case RXO_rmpa:
1536       RL(4);
1537       RL(5);
1538 #ifdef CYCLE_ACCURATE
1539       tx = regs.r[3];
1540 #endif
1541
1542       while (regs.r[3] != 0)
1543         {
1544           long long tmp;
1545
1546           switch (opcode->size)
1547             {
1548             case RX_Long:
1549               ma = mem_get_si (regs.r[1]);
1550               mb = mem_get_si (regs.r[2]);
1551               regs.r[1] += 4;
1552               regs.r[2] += 4;
1553               break;
1554             case RX_Word:
1555               ma = sign_ext (mem_get_hi (regs.r[1]), 16);
1556               mb = sign_ext (mem_get_hi (regs.r[2]), 16);
1557               regs.r[1] += 2;
1558               regs.r[2] += 2;
1559               break;
1560             case RX_Byte:
1561               ma = sign_ext (mem_get_qi (regs.r[1]), 8);
1562               mb = sign_ext (mem_get_qi (regs.r[2]), 8);
1563               regs.r[1] += 1;
1564               regs.r[2] += 1;
1565               break;
1566             default:
1567               abort ();
1568             }
1569           /* We do the multiply as a signed value.  */
1570           sll = (long long)ma * (long long)mb;
1571           tprintf("        %016llx = %d * %d\n", sll, ma, mb);
1572           /* but we do the sum as unsigned, while sign extending the operands.  */
1573           tmp = regs.r[4] + (sll & 0xffffffffUL);
1574           regs.r[4] = tmp & 0xffffffffUL;
1575           tmp >>= 32;
1576           sll >>= 32;
1577           tmp += regs.r[5] + (sll & 0xffffffffUL);
1578           regs.r[5] = tmp & 0xffffffffUL;
1579           tmp >>= 32;
1580           sll >>= 32;
1581           tmp += regs.r[6] + (sll & 0xffffffffUL);
1582           regs.r[6] = tmp & 0xffffffffUL;
1583           tprintf("%08lx\033[36m%08lx\033[0m%08lx\n",
1584                   (unsigned long) regs.r[6],
1585                   (unsigned long) regs.r[5],
1586                   (unsigned long) regs.r[4]);
1587
1588           regs.r[3] --;
1589         }
1590       if (regs.r[6] & 0x00008000)
1591         regs.r[6] |= 0xffff0000UL;
1592       else
1593         regs.r[6] &= 0x0000ffff;
1594       ma = (regs.r[6] & 0x80000000UL) ? FLAGBIT_S : 0;
1595       if (regs.r[6] != 0 && regs.r[6] != 0xffffffffUL)
1596         set_flags (FLAGBIT_O|FLAGBIT_S, ma | FLAGBIT_O);
1597       else
1598         set_flags (FLAGBIT_O|FLAGBIT_S, ma);
1599 #ifdef CYCLE_ACCURATE
1600       switch (opcode->size)
1601         {
1602         case RX_Long:
1603           cycles (6 + 4 * tx);
1604           break;
1605         case RX_Word:
1606           cycles (6 + 5 * (tx / 2) + 4 * (tx % 2));
1607           break;
1608         case RX_Byte:
1609           cycles (6 + 7 * (tx / 4) + 4 * (tx % 4));
1610           break;
1611         default:
1612           abort ();
1613         }
1614 #endif
1615       break;
1616
1617     case RXO_rolc:
1618       v = GD ();
1619       ma = v & 0x80000000UL;
1620       v <<= 1;
1621       v |= carry;
1622       set_szc (v, 4, ma);
1623       PD (v);
1624       E1;
1625       break;
1626
1627     case RXO_rorc:
1628       uma = GD ();
1629       mb = uma & 1;
1630       uma >>= 1;
1631       uma |= (carry ? 0x80000000UL : 0);
1632       set_szc (uma, 4, mb);
1633       PD (uma);
1634       E1;
1635       break;
1636
1637     case RXO_rotl:
1638       mb = GS ();
1639       uma = GD ();
1640       if (mb)
1641         {
1642           uma = (uma << mb) | (uma >> (32-mb));
1643           mb = uma & 1;
1644         }
1645       set_szc (uma, 4, mb);
1646       PD (uma);
1647       E1;
1648       break;
1649
1650     case RXO_rotr:
1651       mb = GS ();
1652       uma = GD ();
1653       if (mb)
1654         {
1655           uma = (uma >> mb) | (uma << (32-mb));
1656           mb = uma & 0x80000000;
1657         }
1658       set_szc (uma, 4, mb);
1659       PD (uma);
1660       E1;
1661       break;
1662
1663     case RXO_round:
1664       ma = GS ();
1665       FPCLEAR ();
1666       mb = rxfp_ftoi (ma, regs.r_fpsw);
1667       FPCHECK ();
1668       PD (mb);
1669       tprintf("(int) %g = %d\n", int2float(ma), mb);
1670       set_sz (mb, 4);
1671       E (2);
1672       break;
1673
1674     case RXO_rts:
1675       {
1676 #ifdef CYCLE_ACCURATE
1677         int cyc = 5;
1678 #endif
1679         regs.r_pc = poppc ();
1680 #ifdef CYCLE_ACCURATE
1681         /* Note: specs say 5, chip says 3.  */
1682         if (regs.fast_return && regs.link_register == regs.r_pc)
1683           {
1684 #ifdef CYCLE_STATS
1685             fast_returns ++;
1686 #endif
1687             tprintf("fast return bonus\n");
1688             cyc -= 2;
1689           }
1690         cycles (cyc);
1691         regs.fast_return = 0;
1692         branch_alignment_penalty = 1;
1693 #endif
1694       }
1695       break;
1696
1697     case RXO_rtsd:
1698       if (opcode->op[2].type == RX_Operand_Register)
1699         {
1700           int i;
1701           /* RTSD cannot pop R0 (sp).  */
1702           put_reg (0, get_reg (0) + GS() - (opcode->op[0].reg-opcode->op[2].reg+1)*4);
1703           if (opcode->op[2].reg == 0)
1704             EXCEPTION (EX_UNDEFINED);
1705 #ifdef CYCLE_ACCURATE
1706           tx = opcode->op[0].reg - opcode->op[2].reg + 1;
1707 #endif
1708           for (i = opcode->op[2].reg; i <= opcode->op[0].reg; i ++)
1709             {
1710               RLD (i);
1711               put_reg (i, pop ());
1712             }
1713         }
1714       else
1715         {
1716 #ifdef CYCLE_ACCURATE
1717           tx = 0;
1718 #endif
1719           put_reg (0, get_reg (0) + GS());
1720         }
1721       put_reg (pc, poppc());
1722 #ifdef CYCLE_ACCURATE
1723       if (regs.fast_return && regs.link_register == regs.r_pc)
1724         {
1725           tprintf("fast return bonus\n");
1726 #ifdef CYCLE_STATS
1727           fast_returns ++;
1728 #endif
1729           cycles (tx < 3 ? 3 : tx + 1);
1730         }
1731       else
1732         {
1733           cycles (tx < 5 ? 5 : tx + 1);
1734         }
1735       regs.fast_return = 0;
1736       branch_alignment_penalty = 1;
1737 #endif
1738       break;
1739
1740     case RXO_sat:
1741       if (FLAG_O && FLAG_S)
1742         PD (0x7fffffffUL);
1743       else if (FLAG_O && ! FLAG_S)
1744         PD (0x80000000UL);
1745       E1;
1746       break;
1747
1748     case RXO_sbb:
1749       MATH_OP (-, ! carry);
1750       break;
1751
1752     case RXO_sccnd:
1753       if (GS())
1754         PD (1);
1755       else
1756         PD (0);
1757       E1;
1758       break;
1759
1760     case RXO_scmpu:
1761 #ifdef CYCLE_ACCURATE
1762       tx = regs.r[3];
1763 #endif
1764       while (regs.r[3] != 0)
1765         {
1766           uma = mem_get_qi (regs.r[1] ++);
1767           umb = mem_get_qi (regs.r[2] ++);
1768           regs.r[3] --;
1769           if (uma != umb || uma == 0)
1770             break;
1771         }
1772       if (uma == umb)
1773         set_zc (1, 1);
1774       else
1775         set_zc (0, ((int)uma - (int)umb) >= 0);
1776       cycles (2 + 4 * (tx / 4) + 4 * (tx % 4));
1777       break;
1778
1779     case RXO_setpsw:
1780       v = 1 << opcode->op[0].reg;
1781       if (FLAG_PM
1782           && (v == FLAGBIT_I
1783               || v == FLAGBIT_U))
1784         break;
1785       regs.r_psw |= v;
1786       cycles (1);
1787       break;
1788
1789     case RXO_smovb:
1790       RL (3);
1791 #ifdef CYCLE_ACCURATE
1792       tx = regs.r[3];
1793 #endif
1794       while (regs.r[3])
1795         {
1796           uma = mem_get_qi (regs.r[2] --);
1797           mem_put_qi (regs.r[1]--, uma);
1798           regs.r[3] --;
1799         }
1800 #ifdef CYCLE_ACCURATE
1801       if (tx > 3)
1802         cycles (6 + 3 * (tx / 4) + 3 * (tx % 4));
1803       else
1804         cycles (2 + 3 * (tx % 4));
1805 #endif
1806       break;
1807
1808     case RXO_smovf:
1809       RL (3);
1810 #ifdef CYCLE_ACCURATE
1811       tx = regs.r[3];
1812 #endif
1813       while (regs.r[3])
1814         {
1815           uma = mem_get_qi (regs.r[2] ++);
1816           mem_put_qi (regs.r[1]++, uma);
1817           regs.r[3] --;
1818         }
1819       cycles (2 + 3 * (int)(tx / 4) + 3 * (tx % 4));
1820       break;
1821
1822     case RXO_smovu:
1823 #ifdef CYCLE_ACCURATE
1824       tx = regs.r[3];
1825 #endif
1826       while (regs.r[3] != 0)
1827         {
1828           uma = mem_get_qi (regs.r[2] ++);
1829           mem_put_qi (regs.r[1]++, uma);
1830           regs.r[3] --;
1831           if (uma == 0)
1832             break;
1833         }
1834       cycles (2 + 3 * (int)(tx / 4) + 3 * (tx % 4));
1835       break;
1836
1837     case RXO_shar: /* d = ma >> mb */
1838       SHIFT_OP (sll, int, mb, >>=, 1);
1839       E (1);
1840       break;
1841
1842     case RXO_shll: /* d = ma << mb */
1843       SHIFT_OP (ll, int, mb, <<=, 0x80000000UL);
1844       E (1);
1845       break;
1846
1847     case RXO_shlr: /* d = ma >> mb */
1848       SHIFT_OP (ll, unsigned int, mb, >>=, 1);
1849       E (1);
1850       break;
1851
1852     case RXO_sstr:
1853       RL (3);
1854 #ifdef CYCLE_ACCURATE
1855       tx = regs.r[3];
1856 #endif
1857       switch (opcode->size)
1858         {
1859         case RX_Long:
1860           while (regs.r[3] != 0)
1861             {
1862               mem_put_si (regs.r[1], regs.r[2]);
1863               regs.r[1] += 4;
1864               regs.r[3] --;
1865             }
1866           cycles (2 + tx);
1867           break;
1868         case RX_Word:
1869           while (regs.r[3] != 0)
1870             {
1871               mem_put_hi (regs.r[1], regs.r[2]);
1872               regs.r[1] += 2;
1873               regs.r[3] --;
1874             }
1875           cycles (2 + (int)(tx / 2) + tx % 2);
1876           break;
1877         case RX_Byte:
1878           while (regs.r[3] != 0)
1879             {
1880               mem_put_qi (regs.r[1], regs.r[2]);
1881               regs.r[1] ++;
1882               regs.r[3] --;
1883             }
1884           cycles (2 + (int)(tx / 4) + tx % 4);
1885           break;
1886         default:
1887           abort ();
1888         }
1889       break;
1890
1891     case RXO_stcc:
1892       if (GS2())
1893         PD (GS ());
1894       E1;
1895       break;
1896
1897     case RXO_stop:
1898       PRIVILEDGED ();
1899       regs.r_psw |= FLAGBIT_I;
1900       DO_RETURN (RX_MAKE_STOPPED(0));
1901
1902     case RXO_sub:
1903       MATH_OP (-, 0);
1904       break;
1905
1906     case RXO_suntil:
1907       RL(3);
1908 #ifdef CYCLE_ACCURATE
1909       tx = regs.r[3];
1910 #endif
1911       if (regs.r[3] == 0)
1912         {
1913           cycles (3);
1914           break;
1915         }
1916       switch (opcode->size)
1917         {
1918         case RX_Long:
1919           uma = get_reg (2);
1920           while (regs.r[3] != 0)
1921             {
1922               regs.r[3] --;
1923               umb = mem_get_si (get_reg (1));
1924               regs.r[1] += 4;
1925               if (umb == uma)
1926                 break;
1927             }
1928           cycles (3 + 3 * tx);
1929           break;
1930         case RX_Word:
1931           uma = get_reg (2) & 0xffff;
1932           while (regs.r[3] != 0)
1933             {
1934               regs.r[3] --;
1935               umb = mem_get_hi (get_reg (1));
1936               regs.r[1] += 2;
1937               if (umb == uma)
1938                 break;
1939             }
1940           cycles (3 + 3 * (tx / 2) + 3 * (tx % 2));
1941           break;
1942         case RX_Byte:
1943           uma = get_reg (2) & 0xff;
1944           while (regs.r[3] != 0)
1945             {
1946               regs.r[3] --;
1947               umb = mem_get_qi (regs.r[1]);
1948               regs.r[1] += 1;
1949               if (umb == uma)
1950                 break;
1951             }
1952           cycles (3 + 3 * (tx / 4) + 3 * (tx % 4));
1953           break;
1954         default:
1955           abort();
1956         }
1957       if (uma == umb)
1958         set_zc (1, 1);
1959       else
1960         set_zc (0, ((int)uma - (int)umb) >= 0);
1961       break;
1962
1963     case RXO_swhile:
1964       RL(3);
1965 #ifdef CYCLE_ACCURATE
1966       tx = regs.r[3];
1967 #endif
1968       if (regs.r[3] == 0)
1969         break;
1970       switch (opcode->size)
1971         {
1972         case RX_Long:
1973           uma = get_reg (2);
1974           while (regs.r[3] != 0)
1975             {
1976               regs.r[3] --;
1977               umb = mem_get_si (get_reg (1));
1978               regs.r[1] += 4;
1979               if (umb != uma)
1980                 break;
1981             }
1982           cycles (3 + 3 * tx);
1983           break;
1984         case RX_Word:
1985           uma = get_reg (2) & 0xffff;
1986           while (regs.r[3] != 0)
1987             {
1988               regs.r[3] --;
1989               umb = mem_get_hi (get_reg (1));
1990               regs.r[1] += 2;
1991               if (umb != uma)
1992                 break;
1993             }
1994           cycles (3 + 3 * (tx / 2) + 3 * (tx % 2));
1995           break;
1996         case RX_Byte:
1997           uma = get_reg (2) & 0xff;
1998           while (regs.r[3] != 0)
1999             {
2000               regs.r[3] --;
2001               umb = mem_get_qi (regs.r[1]);
2002               regs.r[1] += 1;
2003               if (umb != uma)
2004                 break;
2005             }
2006           cycles (3 + 3 * (tx / 4) + 3 * (tx % 4));
2007           break;
2008         default:
2009           abort();
2010         }
2011       if (uma == umb)
2012         set_zc (1, 1);
2013       else
2014         set_zc (0, ((int)uma - (int)umb) >= 0);
2015       break;
2016
2017     case RXO_wait:
2018       PRIVILEDGED ();
2019       regs.r_psw |= FLAGBIT_I;
2020       DO_RETURN (RX_MAKE_STOPPED(0));
2021
2022     case RXO_xchg:
2023 #ifdef CYCLE_ACCURATE
2024       regs.m2m = 0;
2025 #endif
2026       v = GS (); /* This is the memory operand, if any.  */
2027       PS (GD ()); /* and this may change the address register.  */
2028       PD (v);
2029       E2;
2030 #ifdef CYCLE_ACCURATE
2031       /* all M cycles happen during xchg's cycles.  */
2032       memory_dest = 0;
2033       memory_source = 0;
2034 #endif
2035       break;
2036
2037     case RXO_xor:
2038       LOGIC_OP (^);
2039       break;
2040
2041     default:
2042       EXCEPTION (EX_UNDEFINED);
2043     }
2044
2045 #ifdef CYCLE_ACCURATE
2046   regs.m2m = 0;
2047   if (memory_source)
2048     regs.m2m |= M2M_SRC;
2049   if (memory_dest)
2050     regs.m2m |= M2M_DST;
2051
2052   regs.rt = new_rt;
2053   new_rt = -1;
2054 #endif
2055
2056 #ifdef CYCLE_STATS
2057   if (prev_cycle_count == regs.cycle_count)
2058     {
2059       printf("Cycle count not updated! id %s\n", id_names[opcode->id]);
2060       abort ();
2061     }
2062 #endif
2063
2064 #ifdef CYCLE_STATS
2065   if (running_benchmark)
2066     {
2067       int omap = op_lookup (opcode->op[0].type, opcode->op[1].type, opcode->op[2].type);
2068
2069
2070       cycles_per_id[opcode->id][omap] += regs.cycle_count - prev_cycle_count;
2071       times_per_id[opcode->id][omap] ++;
2072
2073       times_per_pair[prev_opcode_id][po0][opcode->id][omap] ++;
2074
2075       prev_opcode_id = opcode->id;
2076       po0 = omap;
2077     }
2078 #endif
2079
2080   return RX_MAKE_STEPPED ();
2081 }
2082
2083 #ifdef CYCLE_STATS
2084 void
2085 reset_pipeline_stats (void)
2086 {
2087   memset (cycles_per_id, 0, sizeof(cycles_per_id));
2088   memset (times_per_id, 0, sizeof(times_per_id));
2089   memory_stalls = 0;
2090   register_stalls = 0;
2091   branch_stalls = 0;
2092   branch_alignment_stalls = 0;
2093   fast_returns = 0;
2094   memset (times_per_pair, 0, sizeof(times_per_pair));
2095   running_benchmark = 1;
2096
2097   benchmark_start_cycle = regs.cycle_count;
2098 }
2099
2100 void
2101 halt_pipeline_stats (void)
2102 {
2103   running_benchmark = 0;
2104   benchmark_end_cycle = regs.cycle_count;
2105 }
2106 #endif
2107
2108 void
2109 pipeline_stats (void)
2110 {
2111 #ifdef CYCLE_STATS
2112   int i, o1;
2113   int p, p1;
2114 #endif
2115
2116 #ifdef CYCLE_ACCURATE
2117   if (verbose == 1)
2118     {
2119       printf ("cycles: %llu\n", regs.cycle_count);
2120       return;
2121     }
2122
2123   printf ("cycles: %13s\n", comma (regs.cycle_count));
2124 #endif
2125
2126 #ifdef CYCLE_STATS
2127   if (benchmark_start_cycle)
2128     printf ("bmark:  %13s\n", comma (benchmark_end_cycle - benchmark_start_cycle));
2129
2130   printf("\n");
2131   for (i = 0; i < N_RXO; i++)
2132     for (o1 = 0; o1 < N_MAP; o1 ++)
2133       if (times_per_id[i][o1])
2134         printf("%13s %13s %7.2f  %s %s\n",
2135                comma (cycles_per_id[i][o1]),
2136                comma (times_per_id[i][o1]),
2137                (double)cycles_per_id[i][o1] / times_per_id[i][o1],
2138                op_cache_string(o1),
2139                id_names[i]+4);
2140
2141   printf("\n");
2142   for (p = 0; p < N_RXO; p ++)
2143     for (p1 = 0; p1 < N_MAP; p1 ++)
2144       for (i = 0; i < N_RXO; i ++)
2145         for (o1 = 0; o1 < N_MAP; o1 ++)
2146           if (times_per_pair[p][p1][i][o1])
2147             {
2148               printf("%13s   %s %-9s  ->  %s %s\n",
2149                      comma (times_per_pair[p][p1][i][o1]),
2150                      op_cache_string(p1),
2151                      id_names[p]+4,
2152                      op_cache_string(o1),
2153                      id_names[i]+4);
2154             }
2155
2156   printf("\n");
2157   printf("%13s memory stalls\n", comma (memory_stalls));
2158   printf("%13s register stalls\n", comma (register_stalls));
2159   printf("%13s branches taken (non-return)\n", comma (branch_stalls));
2160   printf("%13s branch alignment stalls\n", comma (branch_alignment_stalls));
2161   printf("%13s fast returns\n", comma (fast_returns));
2162 #endif
2163 }