sim/rx/rx.c

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