sim/v850/simops.c

   1 #include <signal.h>
   2 #include "sim-main.h"
   3 #include "v850_sim.h"
   4 #include "simops.h"
   5
   6 #ifdef HAVE_UTIME_H
   7 #include <utime.h>
   8 #endif
   9
  10 #ifdef HAVE_TIME_H
  11 #include <time.h>
  12 #endif
  13
  14 #ifdef HAVE_UNISTD_H
  15 #include <unistd.h>
  16 #endif
  17
  18 #ifdef HAVE_STRING_H
  19 #include <string.h>
  20 #else
  21 #ifdef HAVE_STRINGS_H
  22 #include <strings.h>
  23 #endif
  24 #endif
  25
  26
  27
  28
  29
  30  /* FIXME - should be including a version of syscall.h that does not
  31     pollute the name space */
  32 #include "../../libgloss/v850/sys/syscall.h"
  33
  34 #include "bfd.h"
  35 #include "libiberty.h"
  36
  37 #include <errno.h>
  38 #if !defined(__GO32__) && !defined(_WIN32)
  39 #include <sys/stat.h>
  40 #include <sys/times.h>
  41 #include <sys/time.h>
  42 #endif
  43
  44 /* start-sanitize-v850e */
  45 /* This is an array of the bit positions of registers r20 .. r31 in that order in a prepare/dispose instruction.  */
  46 static int type1_regs[12] = { 27, 26, 25, 24, 31, 30, 29, 28, 23, 22, 0, 21 };
  47 /* end-sanitize-v850e */
  48 /* start-sanitize-v850eq */
  49 /* This is an array of the bit positions of registers r16 .. r31 in that order in a push/pop instruction.  */
  50 static int type2_regs[16] = { 3, 2, 1, 0, 27, 26, 25, 24, 31, 30, 29, 28, 23, 22, 20, 21};
  51 /* This is an array of the bit positions of registers r1 .. r15 in that order in a push/pop instruction.  */
  52 static int type3_regs[15] = { 2, 1, 0, 27, 26, 25, 24, 31, 30, 29, 28, 23, 22, 20, 21};
  53 /* end-sanitize-v850eq */
  54
  55 #ifdef DEBUG
  56 #ifndef SIZE_INSTRUCTION
  57 #define SIZE_INSTRUCTION 6
  58 #endif
  59
  60 #ifndef SIZE_OPERANDS
  61 #define SIZE_OPERANDS 16
  62 #endif
  63
  64 #ifndef SIZE_VALUES
  65 #define SIZE_VALUES 11
  66 #endif
  67
  68 #ifndef SIZE_LOCATION
  69 #define SIZE_LOCATION 40
  70 #endif
  71
  72
  73 void
  74 trace_input (name, type, size)
  75      char *name;
  76      enum op_types type;
  77      int size;
  78 {
  79   char buf[1024];
  80   char *p;
  81   uint32 values[3];
  82   int num_values, i;
  83   const char *filename;
  84   const char *functionname;
  85   unsigned int linenumber;
  86
  87   if (!TRACE_ALU_P (STATE_CPU (simulator, 0)))
  88     return;
  89
  90   buf[0] = '\0';
  91
  92   if (STATE_TEXT_SECTION (simulator)
  93       && PC >= STATE_TEXT_START (simulator)
  94       && PC < STATE_TEXT_END (simulator))
  95     {
  96       filename = (const char *)0;
  97       functionname = (const char *)0;
  98       linenumber = 0;
  99       if (bfd_find_nearest_line (STATE_PROG_BFD (simulator),
 100                                  STATE_TEXT_SECTION (simulator),
 101                                  (struct symbol_cache_entry **)0,
 102                                  PC - STATE_TEXT_START (simulator),
 103                                  &filename, &functionname, &linenumber))
 104         {
 105           p = buf;
 106           if (linenumber)
 107             {
 108               sprintf (p, "Line %5d ", linenumber);
 109               p += strlen (p);
 110             }
 111
 112           if (functionname)
 113             {
 114               sprintf (p, "Func %s ", functionname);
 115               p += strlen (p);
 116             }
 117           else if (filename)
 118             {
 119               char *q = (char *) strrchr (filename, '/');
 120               sprintf (p, "File %s ", (q) ? q+1 : filename);
 121               p += strlen (p);
 122             }
 123
 124           if (*p == ' ')
 125             *p = '\0';
 126         }
 127     }
 128
 129   trace_printf (simulator, STATE_CPU (simulator, 0),
 130                 "0x%.8x: %-*.*s %-*s",
 131                 (unsigned)PC,
 132                 SIZE_LOCATION, SIZE_LOCATION, buf,
 133                 SIZE_INSTRUCTION, name);
 134
 135   switch (type)
 136     {
 137     default:
 138     case OP_UNKNOWN:
 139     case OP_NONE:
 140     case OP_TRAP:
 141       num_values = 0;
 142       break;
 143
 144     case OP_REG:
 145     case OP_REG_REG_MOVE:
 146       values[0] = State.regs[OP[0]];
 147       num_values = 1;
 148       break;
 149
 150       /* start-sanitize-v850e */
 151     case OP_BIT_CHANGE:
 152       /* end-sanitize-v850e */
 153     case OP_REG_REG:
 154     case OP_REG_REG_CMP:
 155       values[0] = State.regs[OP[1]];
 156       values[1] = State.regs[OP[0]];
 157       num_values = 2;
 158       break;
 159
 160     case OP_IMM_REG:
 161     case OP_IMM_REG_CMP:
 162       values[0] = SEXT5 (OP[0]);
 163       values[1] = OP[1];
 164       num_values = 2;
 165       break;
 166
 167     case OP_IMM_REG_MOVE:
 168       values[0] = SEXT5 (OP[0]);
 169       num_values = 1;
 170       break;
 171
 172     case OP_COND_BR:
 173       values[0] = State.pc;
 174       values[1] = SEXT9 (OP[0]);
 175       values[2] = PSW;
 176       num_values = 3;
 177       break;
 178
 179     case OP_LOAD16:
 180       values[0] = OP[1] * size;
 181       values[1] = State.regs[30];
 182       num_values = 2;
 183       break;
 184
 185     case OP_STORE16:
 186       values[0] = State.regs[OP[0]];
 187       values[1] = OP[1] * size;
 188       values[2] = State.regs[30];
 189       num_values = 3;
 190       break;
 191
 192     case OP_LOAD32:
 193       values[0] = EXTEND16 (OP[2]);
 194       values[1] = State.regs[OP[0]];
 195       num_values = 2;
 196       break;
 197
 198     case OP_STORE32:
 199       values[0] = State.regs[OP[1]];
 200       values[1] = EXTEND16 (OP[2]);
 201       values[2] = State.regs[OP[0]];
 202       num_values = 3;
 203       break;
 204
 205     case OP_JUMP:
 206       values[0] = SEXT22 (OP[0]);
 207       values[1] = State.pc;
 208       num_values = 2;
 209       break;
 210
 211     case OP_IMM_REG_REG:
 212       values[0] = EXTEND16 (OP[0]) << size;
 213       values[1] = State.regs[OP[1]];
 214       num_values = 2;
 215       break;
 216
 217     case OP_UIMM_REG_REG:
 218       values[0] = (OP[0] & 0xffff) << size;
 219       values[1] = State.regs[OP[1]];
 220       num_values = 2;
 221       break;
 222
 223     case OP_BIT:
 224       num_values = 0;
 225       break;
 226
 227     case OP_EX1:
 228       values[0] = PSW;
 229       num_values = 1;
 230       break;
 231
 232     case OP_EX2:
 233       num_values = 0;
 234       break;
 235
 236     case OP_LDSR:
 237       values[0] = State.regs[OP[0]];
 238       num_values = 1;
 239       break;
 240
 241     case OP_STSR:
 242       values[0] = State.sregs[OP[1]];
 243       num_values = 1;
 244     }
 245
 246   for (i = 0; i < num_values; i++)
 247     trace_printf (simulator, STATE_CPU (simulator, 0),
 248                   "%*s0x%.8lx", SIZE_VALUES - 10, "", values[i]);
 249
 250   while (i++ < 3)
 251     trace_printf (simulator, STATE_CPU (simulator, 0),
 252                   "%*s", SIZE_VALUES, "");
 253 }
 254
 255 void
 256 trace_output (result)
 257      enum op_types result;
 258 {
 259   if (TRACE_ALU_P (STATE_CPU (simulator, 0)))
 260     {
 261       switch (result)
 262         {
 263         default:
 264         case OP_UNKNOWN:
 265         case OP_NONE:
 266         case OP_TRAP:
 267         case OP_REG:
 268         case OP_REG_REG_CMP:
 269         case OP_IMM_REG_CMP:
 270         case OP_COND_BR:
 271         case OP_STORE16:
 272         case OP_STORE32:
 273         case OP_BIT:
 274         case OP_EX2:
 275           break;
 276
 277         case OP_LOAD16:
 278         case OP_STSR:
 279           trace_printf (simulator, STATE_CPU (simulator, 0),
 280                         " :: 0x%.8lx", (unsigned long)State.regs[OP[0]]);
 281           break;
 282
 283         case OP_REG_REG:
 284         case OP_REG_REG_MOVE:
 285         case OP_IMM_REG:
 286         case OP_IMM_REG_MOVE:
 287         case OP_LOAD32:
 288         case OP_EX1:
 289           trace_printf (simulator, STATE_CPU (simulator, 0),
 290                         " :: 0x%.8lx", (unsigned long)State.regs[OP[1]]);
 291           break;
 292
 293         case OP_IMM_REG_REG:
 294         case OP_UIMM_REG_REG:
 295           trace_printf (simulator, STATE_CPU (simulator, 0),
 296                         " :: 0x%.8lx", (unsigned long)State.regs[OP[2]]);
 297           break;
 298
 299         case OP_JUMP:
 300           if (OP[1] != 0)
 301             trace_printf (simulator, STATE_CPU (simulator, 0),
 302                           " :: 0x%.8lx", (unsigned long)State.regs[OP[1]]);
 303           break;
 304
 305         case OP_LDSR:
 306           trace_printf (simulator, STATE_CPU (simulator, 0),
 307                         " :: 0x%.8lx", (unsigned long)State.sregs[OP[1]]);
 308           break;
 309         }
 310
 311       trace_printf (simulator, STATE_CPU (simulator, 0),
 312                     "\n");
 313     }
 314 }
 315
 316 #endif
 317
 318 \f
 319 /* Returns 1 if the specific condition is met, returns 0 otherwise.  */
 320 static unsigned int
 321 condition_met (unsigned code)
 322 {
 323   unsigned int psw = PSW;
 324
 325   switch (code & 0xf)
 326     {
 327       case 0x0: return ((psw & PSW_OV) != 0);
 328       case 0x1: return ((psw & PSW_CY) != 0);
 329       case 0x2: return ((psw & PSW_Z) != 0);
 330       case 0x3: return ((((psw & PSW_CY) != 0) | ((psw & PSW_Z) != 0)) != 0);
 331       case 0x4: return ((psw & PSW_S) != 0);
 332     /*case 0x5: return 1;*/
 333       case 0x6: return ((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) != 0);
 334       case 0x7: return (((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) || ((psw & PSW_Z) != 0)) != 0);
 335       case 0x8: return ((psw & PSW_OV) == 0);
 336       case 0x9: return ((psw & PSW_CY) == 0);
 337       case 0xa: return ((psw & PSW_Z) == 0);
 338       case 0xb: return ((((psw & PSW_CY) != 0) | ((psw & PSW_Z) != 0)) == 0);
 339       case 0xc: return ((psw & PSW_S) == 0);
 340       case 0xd: return ((psw & PSW_SAT) != 0);
 341       case 0xe: return ((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) == 0);
 342       case 0xf: return (((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) || ((psw & PSW_Z) != 0)) == 0);
 343     }
 344
 345   return 1;
 346 }
 347 /* start-sanitize-v850e */
 348
 349 static unsigned long
 350 Add32 (unsigned long a1, unsigned long a2, int * carry)
 351 {
 352   unsigned long result = (a1 + a2);
 353
 354   * carry = (result < a1);
 355
 356   return result;
 357 }
 358
 359 static void
 360 Multiply64 (boolean sign, unsigned long op0)
 361 {
 362   unsigned long op1;
 363   unsigned long lo;
 364   unsigned long mid1;
 365   unsigned long mid2;
 366   unsigned long hi;
 367   unsigned long RdLo;
 368   unsigned long RdHi;
 369   int           carry;
 370
 371   op1 = State.regs[ OP[1] ];
 372
 373   if (sign)
 374     {
 375       /* Compute sign of result and adjust operands if necessary.  */
 376
 377       sign = (op0 ^ op1) & 0x80000000;
 378
 379       if (((signed long) op0) < 0)
 380         op0 = - op0;
 381
 382       if (((signed long) op1) < 0)
 383         op1 = - op1;
 384     }
 385
 386   /* We can split the 32x32 into four 16x16 operations. This ensures
 387      that we do not lose precision on 32bit only hosts: */
 388   lo   = ( (op0        & 0xFFFF) *  (op1        & 0xFFFF));
 389   mid1 = ( (op0        & 0xFFFF) * ((op1 >> 16) & 0xFFFF));
 390   mid2 = (((op0 >> 16) & 0xFFFF) *  (op1        & 0xFFFF));
 391   hi   = (((op0 >> 16) & 0xFFFF) * ((op1 >> 16) & 0xFFFF));
 392
 393   /* We now need to add all of these results together, taking care
 394      to propogate the carries from the additions: */
 395   RdLo = Add32 (lo, (mid1 << 16), & carry);
 396   RdHi = carry;
 397   RdLo = Add32 (RdLo, (mid2 << 16), & carry);
 398   RdHi += (carry + ((mid1 >> 16) & 0xFFFF) + ((mid2 >> 16) & 0xFFFF) + hi);
 399
 400   if (sign)
 401     {
 402       /* Negate result if necessary.  */
 403
 404       RdLo = ~ RdLo;
 405       RdHi = ~ RdHi;
 406       if (RdLo == 0xFFFFFFFF)
 407         {
 408           RdLo = 0;
 409           RdHi += 1;
 410         }
 411       else
 412         RdLo += 1;
 413     }
 414
 415   State.regs[ OP[1]       ] = RdLo;
 416   State.regs[ OP[2] >> 11 ] = RdHi;
 417
 418   return;
 419 }
 420
 421 /* end-sanitize-v850e */
 422 \f
 423 /* Read a null terminated string from memory, return in a buffer */
 424 static char *
 425 fetch_str (sd, addr)
 426      SIM_DESC sd;
 427      address_word addr;
 428 {
 429   char *buf;
 430   int nr = 0;
 431   while (sim_core_read_1 (STATE_CPU (sd, 0),
 432                           PC, sim_core_read_map, addr + nr) != 0)
 433     nr++;
 434   buf = NZALLOC (char, nr + 1);
 435   sim_read (simulator, addr, buf, nr);
 436   return buf;
 437 }
 438
 439 /* Read a null terminated argument vector from memory, return in a
 440    buffer */
 441 static char **
 442 fetch_argv (sd, addr)
 443      SIM_DESC sd;
 444      address_word addr;
 445 {
 446   int max_nr = 64;
 447   int nr = 0;
 448   char **buf = xmalloc (max_nr * sizeof (char*));
 449   while (1)
 450     {
 451       unsigned32 a = sim_core_read_4 (STATE_CPU (sd, 0),
 452                                       PC, sim_core_read_map, addr + nr * 4);
 453       if (a == 0) break;
 454       buf[nr] = fetch_str (sd, a);
 455       nr ++;
 456       if (nr == max_nr - 1)
 457         {
 458           max_nr += 50;
 459           buf = xrealloc (buf, max_nr * sizeof (char*));
 460         }
 461     }
 462   buf[nr] = 0;
 463   return buf;
 464 }
 465
 466 \f
 467 /* sld.b */
 468 int
 469 OP_300 ()
 470 {
 471   unsigned long result;
 472
 473   result = load_mem (State.regs[30] + (OP[3] & 0x7f), 1);
 474
 475 /* start-sanitize-v850eq */
 476 #ifdef ARCH_v850eq
 477   trace_input ("sld.bu", OP_LOAD16, 1);
 478
 479   State.regs[ OP[1] ] = result;
 480 #else
 481 /* end-sanitize-v850eq */
 482   trace_input ("sld.b", OP_LOAD16, 1);
 483
 484   State.regs[ OP[1] ] = EXTEND8 (result);
 485 /* start-sanitize-v850eq */
 486 #endif
 487 /* end-sanitize-v850eq */
 488
 489   trace_output (OP_LOAD16);
 490
 491   return 2;
 492 }
 493
 494 /* sld.h */
 495 int
 496 OP_400 ()
 497 {
 498   unsigned long result;
 499
 500   result = load_mem (State.regs[30] + ((OP[3] & 0x7f) << 1), 2);
 501
 502 /* start-sanitize-v850eq */
 503 #ifdef ARCH_v850eq
 504   trace_input ("sld.hu", OP_LOAD16, 2);
 505
 506   State.regs[ OP[1] ] = result;
 507 #else
 508 /* end-sanitize-v850eq */
 509   trace_input ("sld.h", OP_LOAD16, 2);
 510
 511   State.regs[ OP[1] ] = EXTEND16 (result);
 512 /* start-sanitize-v850eq */
 513 #endif
 514 /* end-sanitize-v850eq */
 515
 516   trace_output (OP_LOAD16);
 517
 518   return 2;
 519 }
 520
 521 /* sld.w */
 522 int
 523 OP_500 ()
 524 {
 525   trace_input ("sld.w", OP_LOAD16, 4);
 526
 527   State.regs[ OP[1] ] = load_mem (State.regs[30] + ((OP[3] & 0x7f) << 1), 4);
 528
 529   trace_output (OP_LOAD16);
 530
 531   return 2;
 532 }
 533
 534 /* sst.b */
 535 int
 536 OP_380 ()
 537 {
 538   trace_input ("sst.b", OP_STORE16, 1);
 539
 540   store_mem (State.regs[30] + (OP[3] & 0x7f), 1, State.regs[ OP[1] ]);
 541
 542   trace_output (OP_STORE16);
 543
 544   return 2;
 545 }
 546
 547 /* sst.h */
 548 int
 549 OP_480 ()
 550 {
 551   trace_input ("sst.h", OP_STORE16, 2);
 552
 553   store_mem (State.regs[30] + ((OP[3] & 0x7f) << 1), 2, State.regs[ OP[1] ]);
 554
 555   trace_output (OP_STORE16);
 556
 557   return 2;
 558 }
 559
 560 /* sst.w */
 561 int
 562 OP_501 ()
 563 {
 564   trace_input ("sst.w", OP_STORE16, 4);
 565
 566   store_mem (State.regs[30] + ((OP[3] & 0x7e) << 1), 4, State.regs[ OP[1] ]);
 567
 568   trace_output (OP_STORE16);
 569
 570   return 2;
 571 }
 572
 573 /* ld.b */
 574 int
 575 OP_700 ()
 576 {
 577   int adr;
 578
 579   trace_input ("ld.b", OP_LOAD32, 1);
 580
 581   adr = State.regs[ OP[0] ] + EXTEND16 (OP[2]);
 582
 583   State.regs[ OP[1] ] = EXTEND8 (load_mem (adr, 1));
 584
 585   trace_output (OP_LOAD32);
 586
 587   return 4;
 588 }
 589
 590 /* ld.h */
 591 int
 592 OP_720 ()
 593 {
 594   int adr;
 595
 596   trace_input ("ld.h", OP_LOAD32, 2);
 597
 598   adr = State.regs[ OP[0] ] + EXTEND16 (OP[2]);
 599   adr &= ~0x1;
 600
 601   State.regs[ OP[1] ] = EXTEND16 (load_mem (adr, 2));
 602
 603   trace_output (OP_LOAD32);
 604
 605   return 4;
 606 }
 607
 608 /* ld.w */
 609 int
 610 OP_10720 ()
 611 {
 612   int adr;
 613
 614   trace_input ("ld.w", OP_LOAD32, 4);
 615
 616   adr = State.regs[ OP[0] ] + EXTEND16 (OP[2] & ~1);
 617   adr &= ~0x3;
 618
 619   State.regs[ OP[1] ] = load_mem (adr, 4);
 620
 621   trace_output (OP_LOAD32);
 622
 623   return 4;
 624 }
 625
 626 /* st.b */
 627 int
 628 OP_740 ()
 629 {
 630   trace_input ("st.b", OP_STORE32, 1);
 631
 632   store_mem (State.regs[ OP[0] ] + EXTEND16 (OP[2]), 1, State.regs[ OP[1] ]);
 633
 634   trace_output (OP_STORE32);
 635
 636   return 4;
 637 }
 638
 639 /* st.h */
 640 int
 641 OP_760 ()
 642 {
 643   int adr;
 644
 645   trace_input ("st.h", OP_STORE32, 2);
 646
 647   adr = State.regs[ OP[0] ] + EXTEND16 (OP[2]);
 648   adr &= ~1;
 649
 650   store_mem (adr, 2, State.regs[ OP[1] ]);
 651
 652   trace_output (OP_STORE32);
 653
 654   return 4;
 655 }
 656
 657 /* st.w */
 658 int
 659 OP_10760 ()
 660 {
 661   int adr;
 662
 663   trace_input ("st.w", OP_STORE32, 4);
 664
 665   adr = State.regs[ OP[0] ] + EXTEND16 (OP[2] & ~1);
 666   adr &= ~3;
 667
 668   store_mem (adr, 4, State.regs[ OP[1] ]);
 669
 670   trace_output (OP_STORE32);
 671
 672   return 4;
 673 }
 674
 675 static int
 676 branch (int code)
 677 {
 678   trace_input ("Bcond", OP_COND_BR, 0);
 679   trace_output (OP_COND_BR);
 680
 681   if (condition_met (code))
 682     return SEXT9 (((OP[3] & 0x70) >> 3) | ((OP[3] & 0xf800) >> 7));
 683   else
 684     return 2;
 685 }
 686
 687 /* bv disp9 */
 688 int
 689 OP_580 ()
 690 {
 691   return branch (0);
 692 }
 693
 694 /* bl disp9 */
 695 int
 696 OP_581 ()
 697 {
 698   return branch (1);
 699 }
 700
 701 /* be disp9 */
 702 int
 703 OP_582 ()
 704 {
 705   return branch (2);
 706 }
 707
 708 /* bnh disp 9*/
 709 int
 710 OP_583 ()
 711 {
 712   return branch (3);
 713 }
 714
 715 /* bn disp9 */
 716 int
 717 OP_584 ()
 718 {
 719   return branch (4);
 720 }
 721
 722 /* br disp9 */
 723 int
 724 OP_585 ()
 725 {
 726   return branch (5);
 727 }
 728
 729 /* blt disp9 */
 730 int
 731 OP_586 ()
 732 {
 733   return branch (6);
 734 }
 735
 736 /* ble disp9 */
 737 int
 738 OP_587 ()
 739 {
 740   return branch (7);
 741 }
 742
 743 /* bnv disp9 */
 744 int
 745 OP_588 ()
 746 {
 747   return branch (8);
 748 }
 749
 750 /* bnl disp9 */
 751 int
 752 OP_589 ()
 753 {
 754   return branch (9);
 755 }
 756
 757 /* bne disp9 */
 758 int
 759 OP_58A ()
 760 {
 761   return branch (10);
 762 }
 763
 764 /* bh disp9 */
 765 int
 766 OP_58B ()
 767 {
 768   return branch (11);
 769 }
 770
 771 /* bp disp9 */
 772 int
 773 OP_58C ()
 774 {
 775   return branch (12);
 776 }
 777
 778 /* bsa disp9 */
 779 int
 780 OP_58D ()
 781 {
 782   return branch (13);
 783 }
 784
 785 /* bge disp9 */
 786 int
 787 OP_58E ()
 788 {
 789   return branch (14);
 790 }
 791
 792 /* bgt disp9 */
 793 int
 794 OP_58F ()
 795 {
 796   return branch (15);
 797 }
 798
 799 /* jarl/jr disp22, reg */
 800 int
 801 OP_780 ()
 802 {
 803   trace_input ("jarl/jr", OP_JUMP, 0);
 804
 805   if (OP[ 1 ] != 0)
 806     State.regs[ OP[1] ] = PC + 4;
 807
 808   trace_output (OP_JUMP);
 809
 810   return SEXT22 (((OP[3] & 0x3f) << 16) | OP[2]);
 811 }
 812
 813 /* add reg, reg */
 814 int
 815 OP_1C0 ()
 816 {
 817   unsigned int op0, op1, result, z, s, cy, ov;
 818
 819   trace_input ("add", OP_REG_REG, 0);
 820
 821   /* Compute the result.  */
 822
 823   op0 = State.regs[ OP[0] ];
 824   op1 = State.regs[ OP[1] ];
 825
 826   result = op0 + op1;
 827
 828   /* Compute the condition codes.  */
 829   z = (result == 0);
 830   s = (result & 0x80000000);
 831   cy = (result < op0 || result < op1);
 832   ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
 833         && (op0 & 0x80000000) != (result & 0x80000000));
 834
 835   /* Store the result and condition codes.  */
 836   State.regs[OP[1]] = result;
 837   PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 838   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 839                      | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
 840   trace_output (OP_REG_REG);
 841
 842   return 2;
 843 }
 844
 845 /* add sign_extend(imm5), reg */
 846 int
 847 OP_240 ()
 848 {
 849   unsigned int op0, op1, result, z, s, cy, ov;
 850   int temp;
 851
 852   trace_input ("add", OP_IMM_REG, 0);
 853
 854   /* Compute the result.  */
 855   temp = SEXT5 (OP[0]);
 856   op0 = temp;
 857   op1 = State.regs[OP[1]];
 858   result = op0 + op1;
 859
 860   /* Compute the condition codes.  */
 861   z = (result == 0);
 862   s = (result & 0x80000000);
 863   cy = (result < op0 || result < op1);
 864   ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
 865         && (op0 & 0x80000000) != (result & 0x80000000));
 866
 867   /* Store the result and condition codes.  */
 868   State.regs[OP[1]] = result;
 869   PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 870   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 871                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
 872   trace_output (OP_IMM_REG);
 873
 874   return 2;
 875 }
 876
 877 /* addi sign_extend(imm16), reg, reg */
 878 int
 879 OP_600 ()
 880 {
 881   unsigned int op0, op1, result, z, s, cy, ov;
 882
 883   trace_input ("addi", OP_IMM_REG_REG, 0);
 884
 885   /* Compute the result.  */
 886
 887   op0 = EXTEND16 (OP[2]);
 888   op1 = State.regs[ OP[0] ];
 889   result = op0 + op1;
 890
 891   /* Compute the condition codes.  */
 892   z = (result == 0);
 893   s = (result & 0x80000000);
 894   cy = (result < op0 || result < op1);
 895   ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
 896         && (op0 & 0x80000000) != (result & 0x80000000));
 897
 898   /* Store the result and condition codes.  */
 899   State.regs[OP[1]] = result;
 900   PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 901   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 902                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
 903   trace_output (OP_IMM_REG_REG);
 904
 905   return 4;
 906 }
 907
 908 /* sub reg1, reg2 */
 909 int
 910 OP_1A0 ()
 911 {
 912   unsigned int op0, op1, result, z, s, cy, ov;
 913
 914   trace_input ("sub", OP_REG_REG, 0);
 915   /* Compute the result.  */
 916   op0 = State.regs[ OP[0] ];
 917   op1 = State.regs[ OP[1] ];
 918   result = op1 - op0;
 919
 920   /* Compute the condition codes.  */
 921   z = (result == 0);
 922   s = (result & 0x80000000);
 923   cy = (op1 < op0);
 924   ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
 925         && (op1 & 0x80000000) != (result & 0x80000000));
 926
 927   /* Store the result and condition codes.  */
 928   State.regs[OP[1]] = result;
 929   PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 930   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 931                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
 932   trace_output (OP_REG_REG);
 933
 934   return 2;
 935 }
 936
 937 /* subr reg1, reg2 */
 938 int
 939 OP_180 ()
 940 {
 941   unsigned int op0, op1, result, z, s, cy, ov;
 942
 943   trace_input ("subr", OP_REG_REG, 0);
 944   /* Compute the result.  */
 945   op0 = State.regs[ OP[0] ];
 946   op1 = State.regs[ OP[1] ];
 947   result = op0 - op1;
 948
 949   /* Compute the condition codes.  */
 950   z = (result == 0);
 951   s = (result & 0x80000000);
 952   cy = (op0 < op1);
 953   ov = ((op0 & 0x80000000) != (op1 & 0x80000000)
 954         && (op0 & 0x80000000) != (result & 0x80000000));
 955
 956   /* Store the result and condition codes.  */
 957   State.regs[OP[1]] = result;
 958   PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 959   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 960                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
 961   trace_output (OP_REG_REG);
 962
 963   return 2;
 964 }
 965
 966 /* sxh reg1 */
 967 /* mulh reg1, reg2 */
 968 int
 969 OP_E0 ()
 970 {
 971 /* start-sanitize-v850e */
 972   if (OP[1] == 0)
 973     {
 974       trace_input ("sxh", OP_REG, 0);
 975
 976       State.regs[ OP[0] ] = EXTEND16 (State.regs[ OP[0] ]);
 977
 978       trace_output (OP_REG);
 979     }
 980   else
 981 /* end-sanitize-v850e */
 982     {
 983       trace_input ("mulh", OP_REG_REG, 0);
 984
 985       State.regs[ OP[1] ] = (EXTEND16 (State.regs[ OP[1] ]) * EXTEND16 (State.regs[ OP[0] ]));
 986
 987       trace_output (OP_REG_REG);
 988     }
 989
 990   return 2;
 991 }
 992
 993 /* mulh sign_extend(imm5), reg2 */
 994 int
 995 OP_2E0 ()
 996 {
 997   trace_input ("mulh", OP_IMM_REG, 0);
 998
 999   State.regs[ OP[1] ] = EXTEND16 (State.regs[ OP[1] ]) * SEXT5 (OP[0]);
1000
1001   trace_output (OP_IMM_REG);
1002
1003   return 2;
1004 }
1005
1006 /* mulhi imm16, reg1, reg2 */
1007 int
1008 OP_6E0 ()
1009 {
1010   if (OP[1] == 0)
1011     {
1012     }
1013   else
1014     {
1015       trace_input ("mulhi", OP_IMM_REG_REG, 0);
1016
1017       State.regs[ OP[1] ] = EXTEND16 (State.regs[ OP[0] ]) * EXTEND16 (OP[2]);
1018
1019       trace_output (OP_IMM_REG_REG);
1020     }
1021
1022   return 4;
1023 }
1024
1025 /* divh reg1, reg2 */
1026 /* switch  reg1 */
1027 int
1028 OP_40 ()
1029 {
1030 /* start-sanitize-v850e */
1031   if (OP[1] == 0)
1032     {
1033       unsigned long adr;
1034
1035       trace_input ("switch", OP_REG, 0);
1036
1037       adr      = State.pc + 2 + (State.regs[ OP[0] ] << 1);
1038       State.pc = State.pc + 2 + (EXTEND16 (load_mem (adr, 2)) << 1);
1039
1040       trace_output (OP_REG);
1041     }
1042   else
1043 /* end-sanitize-v850e */
1044     {
1045       unsigned int op0, op1, result, ov, s, z;
1046       int temp;
1047
1048       trace_input ("divh", OP_REG_REG, 0);
1049
1050       /* Compute the result.  */
1051       temp = EXTEND16 (State.regs[ OP[0] ]);
1052       op0 = temp;
1053       op1 = State.regs[OP[1]];
1054
1055       if (op0 == 0xffffffff && op1 == 0x80000000)
1056         {
1057           result = 0x80000000;
1058           ov = 1;
1059         }
1060       else if (op0 != 0)
1061         {
1062           result = op1 / op0;
1063           ov = 0;
1064         }
1065       else
1066         {
1067           result = 0x0;
1068           ov = 1;
1069         }
1070
1071       /* Compute the condition codes.  */
1072       z = (result == 0);
1073       s = (result & 0x80000000);
1074
1075       /* Store the result and condition codes.  */
1076       State.regs[OP[1]] = result;
1077       PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1078       PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1079               | (ov ? PSW_OV : 0));
1080       trace_output (OP_REG_REG);
1081     }
1082
1083   return 2;
1084 }
1085
1086 /* cmp reg, reg */
1087 int
1088 OP_1E0 ()
1089 {
1090   unsigned int op0, op1, result, z, s, cy, ov;
1091
1092   trace_input ("cmp", OP_REG_REG_CMP, 0);
1093   /* Compute the result.  */
1094   op0 = State.regs[ OP[0] ];
1095   op1 = State.regs[ OP[1] ];
1096   result = op1 - op0;
1097
1098   /* Compute the condition codes.  */
1099   z = (result == 0);
1100   s = (result & 0x80000000);
1101   cy = (op1 < op0);
1102   ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
1103         && (op1 & 0x80000000) != (result & 0x80000000));
1104
1105   /* Set condition codes.  */
1106   PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
1107   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1108                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
1109   trace_output (OP_REG_REG_CMP);
1110
1111   return 2;
1112 }
1113
1114 /* cmp sign_extend(imm5), reg */
1115 int
1116 OP_260 ()
1117 {
1118   unsigned int op0, op1, result, z, s, cy, ov;
1119   int temp;
1120
1121   /* Compute the result.  */
1122   trace_input ("cmp", OP_IMM_REG_CMP, 0);
1123   temp = SEXT5 (OP[0]);
1124   op0 = temp;
1125   op1 = State.regs[OP[1]];
1126   result = op1 - op0;
1127
1128   /* Compute the condition codes.  */
1129   z = (result == 0);
1130   s = (result & 0x80000000);
1131   cy = (op1 < op0);
1132   ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
1133         && (op1 & 0x80000000) != (result & 0x80000000));
1134
1135   /* Set condition codes.  */
1136   PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
1137   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1138                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
1139   trace_output (OP_IMM_REG_CMP);
1140
1141   return 2;
1142 }
1143
1144 /* setf cccc,reg2 */
1145 int
1146 OP_7E0 ()
1147 {
1148   trace_input ("setf", OP_EX1, 0);
1149
1150   State.regs[ OP[1] ] = condition_met (OP[0]);
1151
1152   trace_output (OP_EX1);
1153
1154   return 4;
1155 }
1156
1157 /* zxh reg1 */
1158 /* satadd reg,reg */
1159 int
1160 OP_C0 ()
1161 {
1162 /* start-sanitize-v850e */
1163   if (OP[1] == 0)
1164     {
1165       trace_input ("zxh", OP_REG, 0);
1166
1167       State.regs[ OP[0] ] &= 0xffff;
1168
1169       trace_output (OP_REG);
1170     }
1171   else
1172 /* end-sanitize-v850e */
1173     {
1174       unsigned int op0, op1, result, z, s, cy, ov, sat;
1175
1176       trace_input ("satadd", OP_REG_REG, 0);
1177       /* Compute the result.  */
1178       op0 = State.regs[ OP[0] ];
1179       op1 = State.regs[ OP[1] ];
1180       result = op0 + op1;
1181
1182       /* Compute the condition codes.  */
1183       z = (result == 0);
1184       s = (result & 0x80000000);
1185       cy = (result < op0 || result < op1);
1186       ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
1187             && (op0 & 0x80000000) != (result & 0x80000000));
1188       sat = ov;
1189
1190       /* Store the result and condition codes.  */
1191       State.regs[OP[1]] = result;
1192       PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
1193       PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1194               | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
1195               | (sat ? PSW_SAT : 0));
1196
1197       /* Handle saturated results.  */
1198       if (sat && s)
1199         State.regs[OP[1]] = 0x80000000;
1200       else if (sat)
1201         State.regs[OP[1]] = 0x7fffffff;
1202       trace_output (OP_REG_REG);
1203     }
1204
1205   return 2;
1206 }
1207
1208 /* satadd sign_extend(imm5), reg */
1209 int
1210 OP_220 ()
1211 {
1212   unsigned int op0, op1, result, z, s, cy, ov, sat;
1213
1214   int temp;
1215
1216   trace_input ("satadd", OP_IMM_REG, 0);
1217
1218   /* Compute the result.  */
1219   temp = SEXT5 (OP[0]);
1220   op0 = temp;
1221   op1 = State.regs[OP[1]];
1222   result = op0 + op1;
1223
1224   /* Compute the condition codes.  */
1225   z = (result == 0);
1226   s = (result & 0x80000000);
1227   cy = (result < op0 || result < op1);
1228   ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
1229         && (op0 & 0x80000000) != (result & 0x80000000));
1230   sat = ov;
1231
1232   /* Store the result and condition codes.  */
1233   State.regs[OP[1]] = result;
1234   PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
1235   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1236                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
1237                 | (sat ? PSW_SAT : 0));
1238
1239   /* Handle saturated results.  */
1240   if (sat && s)
1241     State.regs[OP[1]] = 0x80000000;
1242   else if (sat)
1243     State.regs[OP[1]] = 0x7fffffff;
1244   trace_output (OP_IMM_REG);
1245
1246   return 2;
1247 }
1248
1249 /* satsub reg1, reg2 */
1250 /* sxb reg1 */
1251 int
1252 OP_A0 ()
1253 {
1254 /* start-sanitize-v850e */
1255   if (OP[1] == 0)
1256     {
1257       trace_input ("sxb", OP_REG, 0);
1258
1259       State.regs[ OP[0] ] = EXTEND8 (State.regs[ OP[0] ]);
1260
1261       trace_output (OP_REG);
1262     }
1263   else
1264 /* end-sanitize-v850e */
1265     {
1266       unsigned int op0, op1, result, z, s, cy, ov, sat;
1267
1268       trace_input ("satsub", OP_REG_REG, 0);
1269
1270       /* Compute the result.  */
1271       op0 = State.regs[ OP[0] ];
1272       op1 = State.regs[ OP[1] ];
1273       result = op1 - op0;
1274
1275       /* Compute the condition codes.  */
1276       z = (result == 0);
1277       s = (result & 0x80000000);
1278       cy = (op1 < op0);
1279       ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
1280             && (op1 & 0x80000000) != (result & 0x80000000));
1281       sat = ov;
1282
1283       /* Store the result and condition codes.  */
1284       State.regs[OP[1]] = result;
1285       PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
1286       PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1287               | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
1288               | (sat ? PSW_SAT : 0));
1289
1290       /* Handle saturated results.  */
1291       if (sat && s)
1292         State.regs[OP[1]] = 0x80000000;
1293       else if (sat)
1294         State.regs[OP[1]] = 0x7fffffff;
1295       trace_output (OP_REG_REG);
1296     }
1297
1298   return 2;
1299 }
1300
1301 /* satsubi sign_extend(imm16), reg */
1302 int
1303 OP_660 ()
1304 {
1305   unsigned int op0, op1, result, z, s, cy, ov, sat;
1306   int temp;
1307
1308   trace_input ("satsubi", OP_IMM_REG, 0);
1309
1310   /* Compute the result.  */
1311   temp = EXTEND16 (OP[2]);
1312   op0 = temp;
1313   op1 = State.regs[ OP[0] ];
1314   result = op1 - op0;
1315
1316   /* Compute the condition codes.  */
1317   z = (result == 0);
1318   s = (result & 0x80000000);
1319   cy = (op1 < op0);
1320   ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
1321         && (op1 & 0x80000000) != (result & 0x80000000));
1322   sat = ov;
1323
1324   /* Store the result and condition codes.  */
1325   State.regs[OP[1]] = result;
1326   PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
1327   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1328                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
1329                 | (sat ? PSW_SAT : 0));
1330
1331   /* Handle saturated results.  */
1332   if (sat && s)
1333     State.regs[OP[1]] = 0x80000000;
1334   else if (sat)
1335     State.regs[OP[1]] = 0x7fffffff;
1336   trace_output (OP_IMM_REG);
1337
1338   return 4;
1339 }
1340
1341 /* satsubr reg,reg */
1342 /* zxb reg1 */
1343 int
1344 OP_80 ()
1345 {
1346 /* start-sanitize-v850e */
1347   if (OP[1] == 0)
1348     {
1349       trace_input ("zxb", OP_REG, 0);
1350
1351       State.regs[ OP[0] ] &= 0xff;
1352
1353       trace_output (OP_REG);
1354     }
1355   else
1356 /* end-sanitize-v850e */
1357     {
1358       unsigned int op0, op1, result, z, s, cy, ov, sat;
1359
1360       trace_input ("satsubr", OP_REG_REG, 0);
1361
1362       /* Compute the result.  */
1363       op0 = State.regs[ OP[0] ];
1364       op1 = State.regs[ OP[1] ];
1365       result = op0 - op1;
1366
1367       /* Compute the condition codes.  */
1368       z = (result == 0);
1369       s = (result & 0x80000000);
1370       cy = (result < op0);
1371       ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
1372             && (op1 & 0x80000000) != (result & 0x80000000));
1373       sat = ov;
1374
1375       /* Store the result and condition codes.  */
1376       State.regs[OP[1]] = result;
1377       PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
1378       PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1379               | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
1380               | (sat ? PSW_SAT : 0));
1381
1382       /* Handle saturated results.  */
1383       if (sat && s)
1384         State.regs[OP[1]] = 0x80000000;
1385       else if (sat)
1386         State.regs[OP[1]] = 0x7fffffff;
1387       trace_output (OP_REG_REG);
1388     }
1389
1390   return 2;
1391 }
1392
1393 /* tst reg,reg */
1394 int
1395 OP_160 ()
1396 {
1397   unsigned int op0, op1, result, z, s;
1398
1399   trace_input ("tst", OP_REG_REG_CMP, 0);
1400
1401   /* Compute the result.  */
1402   op0 = State.regs[ OP[0] ];
1403   op1 = State.regs[ OP[1] ];
1404   result = op0 & op1;
1405
1406   /* Compute the condition codes.  */
1407   z = (result == 0);
1408   s = (result & 0x80000000);
1409
1410   /* Store the condition codes.  */
1411   PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1412   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1413   trace_output (OP_REG_REG_CMP);
1414
1415   return 2;
1416 }
1417
1418 /* mov reg, reg */
1419 int
1420 OP_0 ()
1421 {
1422   trace_input ("mov", OP_REG_REG_MOVE, 0);
1423
1424   State.regs[ OP[1] ] = State.regs[ OP[0] ];
1425
1426   trace_output (OP_REG_REG_MOVE);
1427
1428   return 2;
1429 }
1430
1431 /* mov sign_extend(imm5), reg */
1432 /* callt imm6 */
1433 int
1434 OP_200 ()
1435 {
1436 /* start-sanitize-v850e */
1437   if (OP[1] == 0)
1438     {
1439       unsigned long adr;
1440
1441       trace_input ("callt", OP_LOAD16, 1);
1442
1443       CTPC  = PC + 2;
1444       CTPSW = PSW;
1445
1446       adr = CTBP + ((OP[3] & 0x3f) << 1);
1447
1448       PC = CTBP + load_mem (adr, 1);
1449
1450       trace_output (OP_LOAD16);
1451
1452       return 0;
1453     }
1454   else
1455 /* end-sanitize-v850e */
1456     {
1457       int value = SEXT5 (OP[0]);
1458
1459       trace_input ("mov", OP_IMM_REG_MOVE, 0);
1460
1461       State.regs[ OP[1] ] = value;
1462
1463       trace_output (OP_IMM_REG_MOVE);
1464
1465       return 2;
1466     }
1467 }
1468
1469 /* mov imm32, reg1 */
1470 /* movea sign_extend(imm16), reg, reg  */
1471 int
1472 OP_620 ()
1473 {
1474 /* start-sanitize-v850e */
1475   if (OP[1] == 0)
1476     {
1477       trace_input ("mov", OP_IMM_REG, 4);
1478
1479       State.regs[ OP[0] ] = load_mem (PC + 2, 4);
1480
1481       trace_output (OP_IMM_REG);
1482
1483       return 6;
1484     }
1485   else
1486 /* end-sanitize-v850e */
1487     {
1488       trace_input ("movea", OP_IMM_REG_REG, 0);
1489
1490       State.regs[ OP[1] ] = State.regs[ OP[0] ] + EXTEND16 (OP[2]);
1491
1492       trace_output (OP_IMM_REG_REG);
1493
1494       return 4;
1495     }
1496 }
1497
1498 /* dispose imm5, list12 [, reg1] */
1499 /* movhi imm16, reg, reg */
1500 int
1501 OP_640 ()
1502 {
1503 /* start-sanitize-v850e */
1504
1505   if (OP[1] == 0)
1506     {
1507       int        i;
1508
1509       trace_input ("dispose", OP_PUSHPOP1, 0);
1510
1511       SP += (OP[3] & 0x3e) << 1;
1512
1513       /* Load the registers with lower number registers being retrieved from higher addresses.  */
1514       for (i = 12; i--;)
1515         if ((OP[3] & (1 << type1_regs[ i ])))
1516           {
1517             State.regs[ 20 + i ] = load_mem (SP, 4);
1518             SP += 4;
1519           }
1520
1521       if ((OP[3] & 0x1f0000) != 0)
1522         {
1523           PC = State.regs[ (OP[3] >> 16) & 0x1f];
1524           return 0;
1525         }
1526
1527       trace_output (OP_PUSHPOP1);
1528     }
1529   else
1530 /* end-sanitize-v850e */
1531     {
1532       trace_input ("movhi", OP_UIMM_REG_REG, 16);
1533
1534       State.regs[ OP[1] ] = State.regs[ OP[0] ] + (OP[2] << 16);
1535
1536       trace_output (OP_UIMM_REG_REG);
1537     }
1538
1539   return 4;
1540 }
1541
1542 /* sar zero_extend(imm5),reg1 */
1543 int
1544 OP_2A0 ()
1545 {
1546   unsigned int op0, op1, result, z, s, cy;
1547
1548   trace_input ("sar", OP_IMM_REG, 0);
1549   op0 = OP[0];
1550   op1 = State.regs[ OP[1] ];
1551   result = (signed)op1 >> op0;
1552
1553   /* Compute the condition codes.  */
1554   z = (result == 0);
1555   s = (result & 0x80000000);
1556   cy = (op1 & (1 << (op0 - 1)));
1557
1558   /* Store the result and condition codes.  */
1559   State.regs[ OP[1] ] = result;
1560   PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1561   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1562                 | (cy ? PSW_CY : 0));
1563   trace_output (OP_IMM_REG);
1564
1565   return 2;
1566 }
1567
1568 /* sar reg1, reg2 */
1569 int
1570 OP_A007E0 ()
1571 {
1572   unsigned int op0, op1, result, z, s, cy;
1573
1574   trace_input ("sar", OP_REG_REG, 0);
1575
1576   op0 = State.regs[ OP[0] ] & 0x1f;
1577   op1 = State.regs[ OP[1] ];
1578   result = (signed)op1 >> op0;
1579
1580   /* Compute the condition codes.  */
1581   z = (result == 0);
1582   s = (result & 0x80000000);
1583   cy = (op1 & (1 << (op0 - 1)));
1584
1585   /* Store the result and condition codes.  */
1586   State.regs[OP[1]] = result;
1587   PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1588   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1589                 | (cy ? PSW_CY : 0));
1590   trace_output (OP_REG_REG);
1591
1592   return 4;
1593 }
1594
1595 /* shl zero_extend(imm5),reg1 */
1596 int
1597 OP_2C0 ()
1598 {
1599   unsigned int op0, op1, result, z, s, cy;
1600
1601   trace_input ("shl", OP_IMM_REG, 0);
1602   op0 = OP[0];
1603   op1 = State.regs[ OP[1] ];
1604   result = op1 << op0;
1605
1606   /* Compute the condition codes.  */
1607   z = (result == 0);
1608   s = (result & 0x80000000);
1609   cy = (op1 & (1 << (32 - op0)));
1610
1611   /* Store the result and condition codes.  */
1612   State.regs[OP[1]] = result;
1613   PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1614   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1615                 | (cy ? PSW_CY : 0));
1616   trace_output (OP_IMM_REG);
1617
1618   return 2;
1619 }
1620
1621 /* shl reg1, reg2 */
1622 int
1623 OP_C007E0 ()
1624 {
1625   unsigned int op0, op1, result, z, s, cy;
1626
1627   trace_input ("shl", OP_REG_REG, 0);
1628   op0 = State.regs[ OP[0] ] & 0x1f;
1629   op1 = State.regs[ OP[1] ];
1630   result = op1 << op0;
1631
1632   /* Compute the condition codes.  */
1633   z = (result == 0);
1634   s = (result & 0x80000000);
1635   cy = (op1 & (1 << (32 - op0)));
1636
1637   /* Store the result and condition codes.  */
1638   State.regs[OP[1]] = result;
1639   PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1640   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1641                 | (cy ? PSW_CY : 0));
1642   trace_output (OP_REG_REG);
1643
1644   return 4;
1645 }
1646
1647 /* shr zero_extend(imm5),reg1 */
1648 int
1649 OP_280 ()
1650 {
1651   unsigned int op0, op1, result, z, s, cy;
1652
1653   trace_input ("shr", OP_IMM_REG, 0);
1654   op0 = OP[0];
1655   op1 = State.regs[ OP[1] ];
1656   result = op1 >> op0;
1657
1658   /* Compute the condition codes.  */
1659   z = (result == 0);
1660   s = (result & 0x80000000);
1661   cy = (op1 & (1 << (op0 - 1)));
1662
1663   /* Store the result and condition codes.  */
1664   State.regs[OP[1]] = result;
1665   PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1666   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1667                 | (cy ? PSW_CY : 0));
1668   trace_output (OP_IMM_REG);
1669
1670   return 2;
1671 }
1672
1673 /* shr reg1, reg2 */
1674 int
1675 OP_8007E0 ()
1676 {
1677   unsigned int op0, op1, result, z, s, cy;
1678
1679   trace_input ("shr", OP_REG_REG, 0);
1680   op0 = State.regs[ OP[0] ] & 0x1f;
1681   op1 = State.regs[ OP[1] ];
1682   result = op1 >> op0;
1683
1684   /* Compute the condition codes.  */
1685   z = (result == 0);
1686   s = (result & 0x80000000);
1687   cy = (op1 & (1 << (op0 - 1)));
1688
1689   /* Store the result and condition codes.  */
1690   State.regs[OP[1]] = result;
1691   PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1692   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1693                 | (cy ? PSW_CY : 0));
1694   trace_output (OP_REG_REG);
1695
1696   return 4;
1697 }
1698
1699 /* or reg, reg */
1700 int
1701 OP_100 ()
1702 {
1703   unsigned int op0, op1, result, z, s;
1704
1705   trace_input ("or", OP_REG_REG, 0);
1706
1707   /* Compute the result.  */
1708   op0 = State.regs[ OP[0] ];
1709   op1 = State.regs[ OP[1] ];
1710   result = op0 | op1;
1711
1712   /* Compute the condition codes.  */
1713   z = (result == 0);
1714   s = (result & 0x80000000);
1715
1716   /* Store the result and condition codes.  */
1717   State.regs[OP[1]] = result;
1718   PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1719   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1720   trace_output (OP_REG_REG);
1721
1722   return 2;
1723 }
1724
1725 /* ori zero_extend(imm16), reg, reg */
1726 int
1727 OP_680 ()
1728 {
1729   unsigned int op0, op1, result, z, s;
1730
1731   trace_input ("ori", OP_UIMM_REG_REG, 0);
1732   op0 = OP[2];
1733   op1 = State.regs[ OP[0] ];
1734   result = op0 | op1;
1735
1736   /* Compute the condition codes.  */
1737   z = (result == 0);
1738   s = (result & 0x80000000);
1739
1740   /* Store the result and condition codes.  */
1741   State.regs[OP[1]] = result;
1742   PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1743   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1744   trace_output (OP_UIMM_REG_REG);
1745
1746   return 4;
1747 }
1748
1749 /* and reg, reg */
1750 int
1751 OP_140 ()
1752 {
1753   unsigned int op0, op1, result, z, s;
1754
1755   trace_input ("and", OP_REG_REG, 0);
1756
1757   /* Compute the result.  */
1758   op0 = State.regs[ OP[0] ];
1759   op1 = State.regs[ OP[1] ];
1760   result = op0 & op1;
1761
1762   /* Compute the condition codes.  */
1763   z = (result == 0);
1764   s = (result & 0x80000000);
1765
1766   /* Store the result and condition codes.  */
1767   State.regs[OP[1]] = result;
1768   PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1769   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1770   trace_output (OP_REG_REG);
1771
1772   return 2;
1773 }
1774
1775 /* andi zero_extend(imm16), reg, reg */
1776 int
1777 OP_6C0 ()
1778 {
1779   unsigned int result, z;
1780
1781   trace_input ("andi", OP_UIMM_REG_REG, 0);
1782
1783   result = OP[2] & State.regs[ OP[0] ];
1784
1785   /* Compute the condition codes.  */
1786   z = (result == 0);
1787
1788   /* Store the result and condition codes.  */
1789   State.regs[ OP[1] ] = result;
1790
1791   PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1792   PSW |= (z ? PSW_Z : 0);
1793
1794   trace_output (OP_UIMM_REG_REG);
1795
1796   return 4;
1797 }
1798
1799 /* xor reg, reg */
1800 int
1801 OP_120 ()
1802 {
1803   unsigned int op0, op1, result, z, s;
1804
1805   trace_input ("xor", OP_REG_REG, 0);
1806
1807   /* Compute the result.  */
1808   op0 = State.regs[ OP[0] ];
1809   op1 = State.regs[ OP[1] ];
1810   result = op0 ^ op1;
1811
1812   /* Compute the condition codes.  */
1813   z = (result == 0);
1814   s = (result & 0x80000000);
1815
1816   /* Store the result and condition codes.  */
1817   State.regs[OP[1]] = result;
1818   PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1819   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1820   trace_output (OP_REG_REG);
1821
1822   return 2;
1823 }
1824
1825 /* xori zero_extend(imm16), reg, reg */
1826 int
1827 OP_6A0 ()
1828 {
1829   unsigned int op0, op1, result, z, s;
1830
1831   trace_input ("xori", OP_UIMM_REG_REG, 0);
1832   op0 = OP[2];
1833   op1 = State.regs[ OP[0] ];
1834   result = op0 ^ op1;
1835
1836   /* Compute the condition codes.  */
1837   z = (result == 0);
1838   s = (result & 0x80000000);
1839
1840   /* Store the result and condition codes.  */
1841   State.regs[OP[1]] = result;
1842   PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1843   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1844   trace_output (OP_UIMM_REG_REG);
1845
1846   return 4;
1847 }
1848
1849 /* not reg1, reg2 */
1850 int
1851 OP_20 ()
1852 {
1853   unsigned int op0, result, z, s;
1854
1855   trace_input ("not", OP_REG_REG_MOVE, 0);
1856   /* Compute the result.  */
1857   op0 = State.regs[ OP[0] ];
1858   result = ~op0;
1859
1860   /* Compute the condition codes.  */
1861   z = (result == 0);
1862   s = (result & 0x80000000);
1863
1864   /* Store the result and condition codes.  */
1865   State.regs[OP[1]] = result;
1866   PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1867   PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1868   trace_output (OP_REG_REG_MOVE);
1869
1870   return 2;
1871 }
1872
1873 /* set1 */
1874 int
1875 OP_7C0 ()
1876 {
1877   unsigned int op0, op1, op2;
1878   int temp;
1879
1880   trace_input ("set1", OP_BIT, 0);
1881   op0 = State.regs[ OP[0] ];
1882   op1 = OP[1] & 0x7;
1883   temp = EXTEND16 (OP[2]);
1884   op2 = temp;
1885   temp = load_mem (op0 + op2, 1);
1886   PSW &= ~PSW_Z;
1887   if ((temp & (1 << op1)) == 0)
1888     PSW |= PSW_Z;
1889   temp |= (1 << op1);
1890   store_mem (op0 + op2, 1, temp);
1891   trace_output (OP_BIT);
1892
1893   return 4;
1894 }
1895
1896 /* not1 */
1897 int
1898 OP_47C0 ()
1899 {
1900   unsigned int op0, op1, op2;
1901   int temp;
1902
1903   trace_input ("not1", OP_BIT, 0);
1904   op0 = State.regs[ OP[0] ];
1905   op1 = OP[1] & 0x7;
1906   temp = EXTEND16 (OP[2]);
1907   op2 = temp;
1908   temp = load_mem (op0 + op2, 1);
1909   PSW &= ~PSW_Z;
1910   if ((temp & (1 << op1)) == 0)
1911     PSW |= PSW_Z;
1912   temp ^= (1 << op1);
1913   store_mem (op0 + op2, 1, temp);
1914   trace_output (OP_BIT);
1915
1916   return 4;
1917 }
1918
1919 /* clr1 */
1920 int
1921 OP_87C0 ()
1922 {
1923   unsigned int op0, op1, op2;
1924   int temp;
1925
1926   trace_input ("clr1", OP_BIT, 0);
1927   op0 = State.regs[ OP[0] ];
1928   op1 = OP[1] & 0x7;
1929   temp = EXTEND16 (OP[2]);
1930   op2 = temp;
1931   temp = load_mem (op0 + op2, 1);
1932   PSW &= ~PSW_Z;
1933   if ((temp & (1 << op1)) == 0)
1934     PSW |= PSW_Z;
1935   temp &= ~(1 << op1);
1936   store_mem (op0 + op2, 1, temp);
1937   trace_output (OP_BIT);
1938
1939   return 4;
1940 }
1941
1942 /* tst1 */
1943 int
1944 OP_C7C0 ()
1945 {
1946   unsigned int op0, op1, op2;
1947   int temp;
1948
1949   trace_input ("tst1", OP_BIT, 0);
1950   op0 = State.regs[ OP[0] ];
1951   op1 = OP[1] & 0x7;
1952   temp = EXTEND16 (OP[2]);
1953   op2 = temp;
1954   temp = load_mem (op0 + op2, 1);
1955   PSW &= ~PSW_Z;
1956   if ((temp & (1 << op1)) == 0)
1957     PSW |= PSW_Z;
1958   trace_output (OP_BIT);
1959
1960   return 4;
1961 }
1962
1963 /* breakpoint */
1964 int
1965 OP_FFFF ()
1966 {
1967   sim_engine_halt (simulator, STATE_CPU (simulator, 0), NULL, PC,
1968                    sim_stopped, SIGTRAP);
1969   return 0;
1970 }
1971
1972 /* di */
1973 int
1974 OP_16007E0 ()
1975 {
1976   trace_input ("di", OP_NONE, 0);
1977   PSW |= PSW_ID;
1978   trace_output (OP_NONE);
1979
1980   return 4;
1981 }
1982
1983 /* ei */
1984 int
1985 OP_16087E0 ()
1986 {
1987   trace_input ("ei", OP_NONE, 0);
1988   PSW &= ~PSW_ID;
1989   trace_output (OP_NONE);
1990
1991   return 4;
1992 }
1993
1994 /* halt */
1995 int
1996 OP_12007E0 ()
1997 {
1998   trace_input ("halt", OP_NONE, 0);
1999   /* FIXME this should put processor into a mode where NMI still handled */
2000   trace_output (OP_NONE);
2001   sim_engine_halt (simulator, STATE_CPU (simulator, 0), NULL, PC,
2002                    sim_stopped, SIGTRAP);
2003   return 0;
2004 }
2005
2006 /* reti */
2007 int
2008 OP_14007E0 ()
2009 {
2010   trace_input ("reti", OP_NONE, 0);
2011   trace_output (OP_NONE);
2012
2013   /* Restore for NMI if only NP on, otherwise is interrupt or exception.  */
2014   if ((PSW & (PSW_NP | PSW_EP)) == PSW_NP)
2015     {
2016       PC = FEPC - 4;
2017       PSW = FEPSW;
2018     }
2019   else
2020     {
2021       PC = EIPC - 4;
2022       PSW = EIPSW;
2023     }
2024
2025   return 0;
2026 }
2027
2028 /* trap */
2029 int
2030 OP_10007E0 ()
2031 {
2032   trace_input ("trap", OP_TRAP, 0);
2033   trace_output (OP_TRAP);
2034
2035   /* Trap 31 is used for simulating OS I/O functions */
2036
2037   if (OP[0] == 31)
2038     {
2039       int save_errno = errno;
2040       errno = 0;
2041
2042 /* Registers passed to trap 0 */
2043
2044 #define FUNC   State.regs[6]    /* function number, return value */
2045 #define PARM1  State.regs[7]    /* optional parm 1 */
2046 #define PARM2  State.regs[8]    /* optional parm 2 */
2047 #define PARM3  State.regs[9]    /* optional parm 3 */
2048
2049 /* Registers set by trap 0 */
2050
2051 #define RETVAL State.regs[10]   /* return value */
2052 #define RETERR State.regs[11]   /* return error code */
2053
2054 /* Turn a pointer in a register into a pointer into real memory. */
2055
2056 #define MEMPTR(x) (map (x))
2057
2058       switch (FUNC)
2059         {
2060
2061 #ifdef HAVE_FORK
2062 #ifdef SYS_fork
2063         case SYS_fork:
2064           RETVAL = fork ();
2065           break;
2066 #endif
2067 #endif
2068
2069 #ifdef HAVE_EXECVE
2070 #ifdef SYS_execv
2071         case SYS_execve:
2072           {
2073             char *path = fetch_str (simulator, PARM1);
2074             char **argv = fetch_argv (simulator, PARM2);
2075             char **envp = fetch_argv (simulator, PARM3);
2076             RETVAL = execve (path, argv, envp);
2077             zfree (path);
2078             freeargv (argv);
2079             freeargv (envp);
2080             break;
2081           }
2082 #endif
2083 #endif
2084
2085 #if HAVE_EXECV
2086 #ifdef SYS_execv
2087         case SYS_execv:
2088           {
2089             char *path = fetch_str (simulator, PARM1);
2090             char **argv = fetch_argv (simulator, PARM2);
2091             RETVAL = execv (path, argv);
2092             zfree (path);
2093             freeargv (argv);
2094             break;
2095           }
2096 #endif
2097 #endif
2098
2099 #if 0
2100 #ifdef SYS_pipe
2101         case SYS_pipe:
2102           {
2103             reg_t buf;
2104             int host_fd[2];
2105
2106             buf = PARM1;
2107             RETVAL = pipe (host_fd);
2108             SW (buf, host_fd[0]);
2109             buf += sizeof(uint16);
2110             SW (buf, host_fd[1]);
2111           }
2112           break;
2113 #endif
2114 #endif
2115
2116 #if 0
2117 #ifdef SYS_wait
2118         case SYS_wait:
2119           {
2120             int status;
2121
2122             RETVAL = wait (&status);
2123             SW (PARM1, status);
2124           }
2125           break;
2126 #endif
2127 #endif
2128
2129 #ifdef SYS_read
2130         case SYS_read:
2131           {
2132             char *buf = zalloc (PARM3);
2133             RETVAL = sim_io_read (simulator, PARM1, buf, PARM3);
2134             sim_write (simulator, PARM2, buf, PARM3);
2135             zfree (buf);
2136             break;
2137           }
2138 #endif
2139
2140 #ifdef SYS_write
2141         case SYS_write:
2142           {
2143             char *buf = zalloc (PARM3);
2144             sim_read (simulator, PARM2, buf, PARM3);
2145             if (PARM1 == 1)
2146               RETVAL = sim_io_write_stdout (simulator, buf, PARM3);
2147             else
2148               RETVAL = sim_io_write (simulator, PARM1, buf, PARM3);
2149             zfree (buf);
2150             break;
2151           }
2152 #endif
2153
2154 #ifdef SYS_lseek
2155         case SYS_lseek:
2156           RETVAL = sim_io_lseek (simulator, PARM1, PARM2, PARM3);
2157           break;
2158 #endif
2159
2160 #ifdef SYS_close
2161         case SYS_close:
2162           RETVAL = sim_io_close (simulator, PARM1);
2163           break;
2164 #endif
2165
2166 #ifdef SYS_open
2167         case SYS_open:
2168           {
2169             char *buf = fetch_str (simulator, PARM1);
2170             RETVAL = sim_io_open (simulator, buf, PARM2);
2171             zfree (buf);
2172             break;
2173           }
2174 #endif
2175
2176 #ifdef SYS_exit
2177         case SYS_exit:
2178           if ((PARM1 & 0xffff0000) == 0xdead0000 && (PARM1 & 0xffff) != 0)
2179             /* get signal encoded by kill */
2180             sim_engine_halt (simulator, STATE_CPU (simulator, 0), NULL, PC,
2181                              sim_signalled, PARM1 & 0xffff);
2182           else if (PARM1 == 0xdead)
2183             /* old libraries */
2184             sim_engine_halt (simulator, STATE_CPU (simulator, 0), NULL, PC,
2185                              sim_exited, SIGABRT);
2186           else
2187             /* PARM1 has exit status */
2188             sim_engine_halt (simulator, STATE_CPU (simulator, 0), NULL, PC,
2189                              sim_exited, PARM1);
2190           break;
2191 #endif
2192
2193 #if !defined(__GO32__) && !defined(_WIN32)
2194 #ifdef SYS_stat
2195         case SYS_stat:  /* added at hmsi */
2196           /* stat system call */
2197           {
2198             struct stat host_stat;
2199             reg_t buf;
2200             char *path = fetch_str (simulator, PARM1);
2201
2202             RETVAL = stat (path, &host_stat);
2203
2204             zfree (path);
2205             buf = PARM2;
2206
2207             /* Just wild-assed guesses.  */
2208             store_mem (buf, 2, host_stat.st_dev);
2209             store_mem (buf + 2, 2, host_stat.st_ino);
2210             store_mem (buf + 4, 4, host_stat.st_mode);
2211             store_mem (buf + 8, 2, host_stat.st_nlink);
2212             store_mem (buf + 10, 2, host_stat.st_uid);
2213             store_mem (buf + 12, 2, host_stat.st_gid);
2214             store_mem (buf + 14, 2, host_stat.st_rdev);
2215             store_mem (buf + 16, 4, host_stat.st_size);
2216             store_mem (buf + 20, 4, host_stat.st_atime);
2217             store_mem (buf + 28, 4, host_stat.st_mtime);
2218             store_mem (buf + 36, 4, host_stat.st_ctime);
2219           }
2220           break;
2221 #endif
2222 #endif
2223
2224 #ifdef HAVE_CHOWN
2225 #ifdef SYS_chown
2226         case SYS_chown:
2227           {
2228             char *path = fetch_str (simulator, PARM1);
2229             RETVAL = chown (path, PARM2, PARM3);
2230             zfree (path);
2231           }
2232           break;
2233 #endif
2234 #endif
2235
2236 #if HAVE_CHMOD
2237 #ifdef SYS_chmod
2238         case SYS_chmod:
2239           {
2240             char *path = fetch_str (simulator, PARM1);
2241             RETVAL = chmod (path, PARM2);
2242             zfree (path);
2243           }
2244           break;
2245 #endif
2246 #endif
2247
2248 #ifdef SYS_time
2249 #if HAVE_TIME
2250         case SYS_time:
2251           {
2252             time_t now;
2253             RETVAL = time (&now);
2254             store_mem (PARM1, 4, now);
2255           }
2256           break;
2257 #endif
2258 #endif
2259
2260 #if !defined(__GO32__) && !defined(_WIN32)
2261 #ifdef SYS_times
2262         case SYS_times:
2263           {
2264             struct tms tms;
2265             RETVAL = times (&tms);
2266             store_mem (PARM1, 4, tms.tms_utime);
2267             store_mem (PARM1 + 4, 4, tms.tms_stime);
2268             store_mem (PARM1 + 8, 4, tms.tms_cutime);
2269             store_mem (PARM1 + 12, 4, tms.tms_cstime);
2270             break;
2271           }
2272 #endif
2273 #endif
2274
2275 #ifdef SYS_gettimeofday
2276 #if !defined(__GO32__) && !defined(_WIN32)
2277         case SYS_gettimeofday:
2278           {
2279             struct timeval t;
2280             struct timezone tz;
2281             RETVAL = gettimeofday (&t, &tz);
2282             store_mem (PARM1, 4, t.tv_sec);
2283             store_mem (PARM1 + 4, 4, t.tv_usec);
2284             store_mem (PARM2, 4, tz.tz_minuteswest);
2285             store_mem (PARM2 + 4, 4, tz.tz_dsttime);
2286             break;
2287           }
2288 #endif
2289 #endif
2290
2291 #ifdef SYS_utime
2292 #if HAVE_UTIME
2293         case SYS_utime:
2294           {
2295             /* Cast the second argument to void *, to avoid type mismatch
2296                if a prototype is present.  */
2297             sim_io_error (simulator, "Utime not supported");
2298             /* RETVAL = utime (path, (void *) MEMPTR (PARM2)); */
2299           }
2300           break;
2301 #endif
2302 #endif
2303
2304         default:
2305           abort ();
2306         }
2307       RETERR = errno;
2308       errno = save_errno;
2309
2310       return 4;
2311     }
2312   else
2313     {                           /* Trap 0 -> 30 */
2314       EIPC = PC + 4;
2315       EIPSW = PSW;
2316       /* Mask out EICC */
2317       ECR &= 0xffff0000;
2318       ECR |= 0x40 + OP[0];
2319       /* Flag that we are now doing exception processing.  */
2320       PSW |= PSW_EP | PSW_ID;
2321       PC = ((OP[0] < 0x10) ? 0x40 : 0x50) - 4;
2322
2323       return 0;
2324     }
2325 }
2326
2327 /* ldsr, reg,reg */
2328 int
2329 OP_2007E0 ()
2330 {
2331   trace_input ("ldsr", OP_LDSR, 0);
2332
2333   State.sregs[ OP[1] ] = State.regs[ OP[0] ];
2334
2335   trace_output (OP_LDSR);
2336
2337   return 4;
2338 }
2339
2340 /* stsr */
2341 int
2342 OP_4007E0 ()
2343 {
2344   trace_input ("stsr", OP_STSR, 0);
2345
2346   State.regs[ OP[1] ] = State.sregs[ OP[0] ];
2347
2348   trace_output (OP_STSR);
2349
2350   return 4;
2351 }
2352
2353 /* start-sanitize-v850e */
2354 /* tst1 reg2, [reg1] */
2355 int
2356 OP_E607E0 (void)
2357 {
2358   int temp;
2359
2360   trace_input ("tst1", OP_BIT, 1);
2361
2362   temp = load_mem (State.regs[ OP[0] ], 1);
2363
2364   PSW &= ~PSW_Z;
2365   if ((temp & (1 << State.regs[ OP[1] & 0x7 ])) == 0)
2366     PSW |= PSW_Z;
2367
2368   trace_output (OP_BIT);
2369
2370   return 4;
2371 }
2372
2373 /* end-sanitize-v850e */
2374 /* start-sanitize-v850e */
2375 /* mulu reg1, reg2, reg3 */
2376 int
2377 OP_22207E0 (void)
2378 {
2379   trace_input ("mulu", OP_REG_REG_REG, 0);
2380
2381   Multiply64 (false, State.regs[ OP[0] ]);
2382
2383   trace_output (OP_REG_REG_REG);
2384
2385   return 4;
2386 }
2387
2388 /* end-sanitize-v850e */
2389 /* start-sanitize-v850e */
2390
2391 #define BIT_CHANGE_OP( name, binop )            \
2392   unsigned int bit;                             \
2393   unsigned int temp;                            \
2394                                                 \
2395   trace_input (name, OP_BIT_CHANGE, 0);         \
2396                                                 \
2397   bit  = 1 << State.regs[ OP[1] & 0x7 ];        \
2398   temp = load_mem (State.regs[ OP[0] ], 1);     \
2399                                                 \
2400   PSW &= ~PSW_Z;                                \
2401   if ((temp & bit) == 0)                        \
2402     PSW |= PSW_Z;                               \
2403   temp binop bit;                               \
2404                                                 \
2405   store_mem (State.regs[ OP[0] ], 1, temp);     \
2406                                                 \
2407   trace_output (OP_BIT_CHANGE);                 \
2408                                                 \
2409   return 4;
2410
2411 /* clr1 reg2, [reg1] */
2412 int
2413 OP_E407E0 (void)
2414 {
2415   BIT_CHANGE_OP ("clr1", &= ~ );
2416 }
2417
2418 /* not1 reg2, [reg1] */
2419 int
2420 OP_E207E0 (void)
2421 {
2422   BIT_CHANGE_OP ("not1", ^= );
2423 }
2424
2425 /* set1 */
2426 int
2427 OP_E007E0 (void)
2428 {
2429   BIT_CHANGE_OP ("set1", |= );
2430 }
2431
2432 /* sasf */
2433 int
2434 OP_20007E0 (void)
2435 {
2436   trace_input ("sasf", OP_EX1, 0);
2437
2438   State.regs[ OP[1] ] = (State.regs[ OP[1] ] << 1) | condition_met (OP[0]);
2439
2440   trace_output (OP_EX1);
2441
2442   return 4;
2443 }
2444 /* end-sanitize-v850e */
2445 /* start-sanitize-v850eq */
2446 /* This function is courtesy of Sugimoto at NEC, via Seow Tan (Soew_Tan@el.nec.com) */
2447 static void
2448 divun
2449 (
2450   unsigned int       N,
2451   unsigned long int  als,
2452   unsigned long int  sfi,
2453   unsigned long int *  quotient_ptr,
2454   unsigned long int *  remainder_ptr,
2455   boolean *          overflow_ptr
2456 )
2457 {
2458   unsigned long   ald = sfi >> (N - 1);
2459   unsigned long   alo = als;
2460   unsigned int    Q   = 1;
2461   unsigned int    C;
2462   unsigned int    S   = 0;
2463   unsigned int    i;
2464   unsigned int    R1  = 1;
2465   unsigned int    DBZ = (als == 0) ? 1 : 0;
2466   unsigned long   alt = Q ? ~als : als;
2467
2468   /* 1st Loop */
2469   alo = ald + alt + Q;
2470   C   = (((alt >> 31) & (ald >> 31))
2471          | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2472   C   = C ^ Q;
2473   Q   = ~(C ^ S) & 1;
2474   R1  = (alo == 0) ? 0 : (R1 & Q);
2475   if ((S ^ (alo>>31)) && !C)
2476     {
2477       DBZ = 1;
2478     }
2479   S   = alo >> 31;
2480   sfi = (sfi << (32-N+1)) | Q;
2481   ald = (alo << 1) | (sfi >> 31);
2482
2483   /* 2nd - N-1th Loop */
2484   for (i = 2; i < N; i++)
2485     {
2486       alt = Q ? ~als : als;
2487       alo = ald + alt + Q;
2488       C   = (((alt >> 31) & (ald >> 31))
2489              | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2490       C   = C ^ Q;
2491       Q   = ~(C ^ S) & 1;
2492       R1  = (alo == 0) ? 0 : (R1 & Q);
2493       if ((S ^ (alo>>31)) && !C && !DBZ)
2494         {
2495           DBZ = 1;
2496         }
2497       S   = alo >> 31;
2498       sfi = (sfi << 1) | Q;
2499       ald = (alo << 1) | (sfi >> 31);
2500     }
2501
2502   /* Nth Loop */
2503   alt = Q ? ~als : als;
2504   alo = ald + alt + Q;
2505   C   = (((alt >> 31) & (ald >> 31))
2506          | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2507   C   = C ^ Q;
2508   Q   = ~(C ^ S) & 1;
2509   R1  = (alo == 0) ? 0 : (R1 & Q);
2510   if ((S ^ (alo>>31)) && !C)
2511     {
2512       DBZ = 1;
2513     }
2514
2515   * quotient_ptr  = (sfi << 1) | Q;
2516   * remainder_ptr = Q ? alo : (alo + als);
2517   * overflow_ptr  = DBZ | R1;
2518 }
2519
2520 /* This function is courtesy of Sugimoto at NEC, via Seow Tan (Soew_Tan@el.nec.com) */
2521 static void
2522 divn
2523 (
2524   unsigned int       N,
2525   unsigned long int  als,
2526   unsigned long int  sfi,
2527   signed long int *  quotient_ptr,
2528   signed long int *  remainder_ptr,
2529   boolean *          overflow_ptr
2530 )
2531 {
2532   unsigned long   ald = (signed long) sfi >> (N - 1);
2533   unsigned long   alo = als;
2534   unsigned int    SS  = als >> 31;
2535   unsigned int    SD  = sfi >> 31;
2536   unsigned int    R1  = 1;
2537   unsigned int    OV;
2538   unsigned int    DBZ = als == 0 ? 1 : 0;
2539   unsigned int    Q   = ~(SS ^ SD) & 1;
2540   unsigned int    C;
2541   unsigned int    S;
2542   unsigned int    i;
2543   unsigned long   alt = Q ? ~als : als;
2544
2545
2546   /* 1st Loop */
2547
2548   alo = ald + alt + Q;
2549   C   = (((alt >> 31) & (ald >> 31))
2550          | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2551   Q   = C ^ SS;
2552   R1  = (alo == 0) ? 0 : (R1 & (Q ^ (SS ^ SD)));
2553   S   = alo >> 31;
2554   sfi = (sfi << (32-N+1)) | Q;
2555   ald = (alo << 1) | (sfi >> 31);
2556   if ((alo >> 31) ^ (ald >> 31))
2557     {
2558       DBZ = 1;
2559     }
2560
2561   /* 2nd - N-1th Loop */
2562
2563   for (i = 2; i < N; i++)
2564     {
2565       alt = Q ? ~als : als;
2566       alo = ald + alt + Q;
2567       C   = (((alt >> 31) & (ald >> 31))
2568              | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2569       Q   = C ^ SS;
2570       R1  = (alo == 0) ? 0 : (R1 & (Q ^ (SS ^ SD)));
2571       S   = alo >> 31;
2572       sfi = (sfi << 1) | Q;
2573       ald = (alo << 1) | (sfi >> 31);
2574       if ((alo >> 31) ^ (ald >> 31))
2575         {
2576           DBZ = 1;
2577         }
2578     }
2579
2580   /* Nth Loop */
2581   alt = Q ? ~als : als;
2582   alo = ald + alt + Q;
2583   C   = (((alt >> 31) & (ald >> 31))
2584          | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2585   Q   = C ^ SS;
2586   R1  = (alo == 0) ? 0 : (R1 & (Q ^ (SS ^ SD)));
2587   sfi = (sfi << (32-N+1));
2588   ald = alo;
2589
2590   /* End */
2591   if (alo != 0)
2592     {
2593       alt = Q ? ~als : als;
2594       alo = ald + alt + Q;
2595     }
2596   R1  = R1 & ((~alo >> 31) ^ SD);
2597   if ((alo != 0) && ((Q ^ (SS ^ SD)) ^ R1)) alo = ald;
2598   if (N != 32)
2599     ald = sfi = (long) ((sfi >> 1) | (SS ^ SD) << 31) >> (32-N-1) | Q;
2600   else
2601     ald = sfi = sfi | Q;
2602
2603   OV = DBZ | ((alo == 0) ? 0 : R1);
2604
2605   * remainder_ptr = alo;
2606
2607   /* Adj */
2608   if (((alo != 0) && ((SS ^ SD) ^ R1))
2609       || ((alo == 0) && (SS ^ R1)))
2610     alo = ald + 1;
2611   else
2612     alo = ald;
2613
2614   OV  = (DBZ | R1) ? OV : ((alo >> 31) & (~ald >> 31));
2615
2616   * quotient_ptr  = alo;
2617   * overflow_ptr  = OV;
2618 }
2619
2620 /* sdivun imm5, reg1, reg2, reg3 */
2621 int
2622 OP_1C207E0 (void)
2623 {
2624   unsigned long int  quotient;
2625   unsigned long int  remainder;
2626   unsigned long int  divide_by;
2627   unsigned long int  divide_this;
2628   boolean            overflow = false;
2629   unsigned int       imm5;
2630
2631   trace_input ("sdivun", OP_IMM_REG_REG_REG, 0);
2632
2633   imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2634
2635   divide_by   = State.regs[ OP[0] ];
2636   divide_this = State.regs[ OP[1] ] << imm5;
2637
2638   divun (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2639
2640   State.regs[ OP[1]       ] = quotient;
2641   State.regs[ OP[2] >> 11 ] = remainder;
2642
2643   /* Set condition codes.  */
2644   PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2645
2646   if (overflow)      PSW |= PSW_OV;
2647   if (quotient == 0) PSW |= PSW_Z;
2648   if (quotient & 0x80000000) PSW |= PSW_S;
2649
2650   trace_output (OP_IMM_REG_REG_REG);
2651
2652   return 4;
2653 }
2654
2655 /* sdivn imm5, reg1, reg2, reg3 */
2656 int
2657 OP_1C007E0 (void)
2658 {
2659   signed long int  quotient;
2660   signed long int  remainder;
2661   signed long int  divide_by;
2662   signed long int  divide_this;
2663   boolean          overflow = false;
2664   unsigned int     imm5;
2665
2666   trace_input ("sdivn", OP_IMM_REG_REG_REG, 0);
2667
2668   imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2669
2670   divide_by   = State.regs[ OP[0] ];
2671   divide_this = State.regs[ OP[1] ] << imm5;
2672
2673   divn (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2674
2675   State.regs[ OP[1]       ] = quotient;
2676   State.regs[ OP[2] >> 11 ] = remainder;
2677
2678   /* Set condition codes.  */
2679   PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2680
2681   if (overflow)      PSW |= PSW_OV;
2682   if (quotient == 0) PSW |= PSW_Z;
2683   if (quotient <  0) PSW |= PSW_S;
2684
2685   trace_output (OP_IMM_REG_REG_REG);
2686
2687   return 4;
2688 }
2689
2690 /* sdivhun imm5, reg1, reg2, reg3 */
2691 int
2692 OP_18207E0 (void)
2693 {
2694   unsigned long int  quotient;
2695   unsigned long int  remainder;
2696   unsigned long int  divide_by;
2697   unsigned long int  divide_this;
2698   boolean            overflow = false;
2699   unsigned int       imm5;
2700
2701   trace_input ("sdivhun", OP_IMM_REG_REG_REG, 0);
2702
2703   imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2704
2705   divide_by   = State.regs[ OP[0] ] & 0xffff;
2706   divide_this = State.regs[ OP[1] ] << imm5;
2707
2708   divun (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2709
2710   State.regs[ OP[1]       ] = quotient;
2711   State.regs[ OP[2] >> 11 ] = remainder;
2712
2713   /* Set condition codes.  */
2714   PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2715
2716   if (overflow)      PSW |= PSW_OV;
2717   if (quotient == 0) PSW |= PSW_Z;
2718   if (quotient & 0x80000000) PSW |= PSW_S;
2719
2720   trace_output (OP_IMM_REG_REG_REG);
2721
2722   return 4;
2723 }
2724
2725 /* sdivhn imm5, reg1, reg2, reg3 */
2726 int
2727 OP_18007E0 (void)
2728 {
2729   signed long int  quotient;
2730   signed long int  remainder;
2731   signed long int  divide_by;
2732   signed long int  divide_this;
2733   boolean          overflow = false;
2734   unsigned int     imm5;
2735
2736   trace_input ("sdivhn", OP_IMM_REG_REG_REG, 0);
2737
2738   imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2739
2740   divide_by   = EXTEND16 (State.regs[ OP[0] ]);
2741   divide_this = State.regs[ OP[1] ] << imm5;
2742
2743   divn (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2744
2745   State.regs[ OP[1]       ] = quotient;
2746   State.regs[ OP[2] >> 11 ] = remainder;
2747
2748   /* Set condition codes.  */
2749   PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2750
2751   if (overflow)      PSW |= PSW_OV;
2752   if (quotient == 0) PSW |= PSW_Z;
2753   if (quotient <  0) PSW |= PSW_S;
2754
2755   trace_output (OP_IMM_REG_REG_REG);
2756
2757   return 4;
2758 }
2759
2760 /* end-sanitize-v850eq */
2761 /* start-sanitize-v850e */
2762 /* divu  reg1, reg2, reg3 */
2763 int
2764 OP_2C207E0 (void)
2765 {
2766   unsigned long int quotient;
2767   unsigned long int remainder;
2768   unsigned long int divide_by;
2769   unsigned long int divide_this;
2770   boolean           overflow = false;
2771
2772   if ((OP[3] & 0x3c0000) == 0)
2773     {
2774       trace_input ("divu", OP_REG_REG_REG, 0);
2775
2776       /* Compute the result.  */
2777
2778       divide_by   = State.regs[ OP[0] ];
2779       divide_this = State.regs[ OP[1] ];
2780
2781       if (divide_by == 0)
2782         {
2783           overflow = true;
2784           divide_by  = 1;
2785         }
2786
2787       State.regs[ OP[1]       ] = quotient  = divide_this / divide_by;
2788       State.regs[ OP[2] >> 11 ] = remainder = divide_this % divide_by;
2789
2790       /* Set condition codes.  */
2791       PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2792
2793       if (overflow)      PSW |= PSW_OV;
2794       if (quotient == 0) PSW |= PSW_Z;
2795       if (quotient & 0x80000000) PSW |= PSW_S;
2796
2797       trace_output (OP_REG_REG_REG);
2798     }
2799 /* start-sanitize-v850eq */
2800 /* divun imm5, reg1, reg2, reg3 */
2801   else
2802     {
2803       unsigned int imm5;
2804
2805       trace_input ("divun", OP_IMM_REG_REG_REG, 0);
2806
2807       imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2808
2809       divide_by   = State.regs[ OP[0] ];
2810       divide_this = State.regs[ OP[1] ];
2811
2812       divun (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2813
2814       State.regs[ OP[1]       ] = quotient;
2815       State.regs[ OP[2] >> 11 ] = remainder;
2816
2817       /* Set condition codes.  */
2818       PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2819
2820       if (overflow)      PSW |= PSW_OV;
2821       if (quotient == 0) PSW |= PSW_Z;
2822       if (quotient & 0x80000000) PSW |= PSW_S;
2823
2824       trace_output (OP_IMM_REG_REG_REG);
2825     }
2826 /* end-sanitize-v850eq */
2827
2828   return 4;
2829 }
2830
2831 /* end-sanitize-v850e */
2832 /* start-sanitize-v850e */
2833 /* div  reg1, reg2, reg3 */
2834 int
2835 OP_2C007E0 (void)
2836 {
2837   signed long int quotient;
2838   signed long int remainder;
2839   signed long int divide_by;
2840   signed long int divide_this;
2841   boolean         overflow = false;
2842
2843   if ((OP[3] & 0x3c0000) == 0)
2844     {
2845       trace_input ("div", OP_REG_REG_REG, 0);
2846
2847       /* Compute the result.  */
2848
2849       divide_by   = State.regs[ OP[0] ];
2850       divide_this = State.regs[ OP[1] ];
2851
2852       if (divide_by == 0 || (divide_by == -1 && divide_this == (1 << 31)))
2853         {
2854           overflow  = true;
2855           divide_by = 1;
2856         }
2857
2858       State.regs[ OP[1]       ] = quotient  = divide_this / divide_by;
2859       State.regs[ OP[2] >> 11 ] = remainder = divide_this % divide_by;
2860
2861       /* Set condition codes.  */
2862       PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2863
2864       if (overflow)      PSW |= PSW_OV;
2865       if (quotient == 0) PSW |= PSW_Z;
2866       if (quotient <  0) PSW |= PSW_S;
2867
2868       trace_output (OP_REG_REG_REG);
2869     }
2870 /* start-sanitize-v850eq */
2871 /* divn imm5, reg1, reg2, reg3 */
2872   else
2873     {
2874       unsigned int imm5;
2875
2876       trace_input ("divn", OP_IMM_REG_REG_REG, 0);
2877
2878       imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2879
2880       divide_by   = State.regs[ OP[0] ];
2881       divide_this = State.regs[ OP[1] ];
2882
2883       divn (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2884
2885       State.regs[ OP[1]       ] = quotient;
2886       State.regs[ OP[2] >> 11 ] = remainder;
2887
2888       /* Set condition codes.  */
2889       PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2890
2891       if (overflow)      PSW |= PSW_OV;
2892       if (quotient == 0) PSW |= PSW_Z;
2893       if (quotient <  0) PSW |= PSW_S;
2894
2895       trace_output (OP_IMM_REG_REG_REG);
2896     }
2897 /* end-sanitize-v850eq */
2898
2899   return 4;
2900 }
2901
2902 /* end-sanitize-v850e */
2903 /* start-sanitize-v850e */
2904 /* divhu  reg1, reg2, reg3 */
2905 int
2906 OP_28207E0 (void)
2907 {
2908   unsigned long int quotient;
2909   unsigned long int remainder;
2910   unsigned long int divide_by;
2911   unsigned long int divide_this;
2912   boolean           overflow = false;
2913
2914   if ((OP[3] & 0x3c0000) == 0)
2915     {
2916       trace_input ("divhu", OP_REG_REG_REG, 0);
2917
2918       /* Compute the result.  */
2919
2920       divide_by   = State.regs[ OP[0] ] & 0xffff;
2921       divide_this = State.regs[ OP[1] ];
2922
2923       if (divide_by == 0)
2924         {
2925           overflow = true;
2926           divide_by  = 1;
2927         }
2928
2929       State.regs[ OP[1]       ] = quotient  = divide_this / divide_by;
2930       State.regs[ OP[2] >> 11 ] = remainder = divide_this % divide_by;
2931
2932       /* Set condition codes.  */
2933       PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2934
2935       if (overflow)      PSW |= PSW_OV;
2936       if (quotient == 0) PSW |= PSW_Z;
2937       if (quotient & 0x80000000) PSW |= PSW_S;
2938
2939       trace_output (OP_REG_REG_REG);
2940     }
2941 /* start-sanitize-v850eq */
2942 /* divhun imm5, reg1, reg2, reg3 */
2943   else
2944     {
2945       unsigned int imm5;
2946
2947       trace_input ("divhun", OP_IMM_REG_REG_REG, 0);
2948
2949       imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2950
2951       divide_by   = State.regs[ OP[0] ] & 0xffff;
2952       divide_this = State.regs[ OP[1] ];
2953
2954       divun (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2955
2956       State.regs[ OP[1]       ] = quotient;
2957       State.regs[ OP[2] >> 11 ] = remainder;
2958
2959       /* Set condition codes.  */
2960       PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2961
2962       if (overflow)      PSW |= PSW_OV;
2963       if (quotient == 0) PSW |= PSW_Z;
2964       if (quotient & 0x80000000) PSW |= PSW_S;
2965
2966       trace_output (OP_IMM_REG_REG_REG);
2967     }
2968 /* end-sanitize-v850eq */
2969
2970   return 4;
2971 }
2972
2973 /* end-sanitize-v850e */
2974 /* start-sanitize-v850e */
2975 /* divh  reg1, reg2, reg3 */
2976 int
2977 OP_28007E0 (void)
2978 {
2979   signed long int quotient;
2980   signed long int remainder;
2981   signed long int divide_by;
2982   signed long int divide_this;
2983   boolean         overflow = false;
2984
2985   if ((OP[3] & 0x3c0000) == 0)
2986     {
2987       trace_input ("divh", OP_REG_REG_REG, 0);
2988
2989       /* Compute the result.  */
2990
2991       divide_by  = State.regs[ OP[0] ];
2992       divide_this = EXTEND16 (State.regs[ OP[1] ]);
2993
2994       if (divide_by == 0 || (divide_by == -1 && divide_this == (1 << 31)))
2995         {
2996           overflow = true;
2997           divide_by  = 1;
2998         }
2999
3000       State.regs[ OP[1]       ] = quotient  = divide_this / divide_by;
3001       State.regs[ OP[2] >> 11 ] = remainder = divide_this % divide_by;
3002
3003       /* Set condition codes.  */
3004       PSW &= ~(PSW_Z | PSW_S | PSW_OV);
3005
3006       if (overflow)      PSW |= PSW_OV;
3007       if (quotient == 0) PSW |= PSW_Z;
3008       if (quotient <  0) PSW |= PSW_S;
3009
3010       trace_output (OP_REG_REG_REG);
3011     }
3012 /* start-sanitize-v850eq */
3013 /* divhn imm5, reg1, reg2, reg3 */
3014   else
3015     {
3016       unsigned int imm5;
3017
3018       trace_input ("divhn", OP_IMM_REG_REG_REG, 0);
3019
3020       imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
3021
3022       divide_by   = EXTEND16 (State.regs[ OP[0] ]);
3023       divide_this = State.regs[ OP[1] ];
3024
3025       divn (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
3026
3027       State.regs[ OP[1]       ] = quotient;
3028       State.regs[ OP[2] >> 11 ] = remainder;
3029
3030       /* Set condition codes.  */
3031       PSW &= ~(PSW_Z | PSW_S | PSW_OV);
3032
3033       if (overflow)      PSW |= PSW_OV;
3034       if (quotient == 0) PSW |= PSW_Z;
3035       if (quotient <  0) PSW |= PSW_S;
3036
3037       trace_output (OP_IMM_REG_REG_REG);
3038     }
3039 /* end-sanitize-v850eq */
3040
3041   return 4;
3042 }
3043
3044 /* end-sanitize-v850e */
3045 /* start-sanitize-v850e */
3046 /* mulu imm9, reg2, reg3 */
3047 int
3048 OP_24207E0 (void)
3049 {
3050   trace_input ("mulu", OP_IMM_REG_REG, 0);
3051
3052   Multiply64 (false, (OP[3] & 0x1f) | ((OP[3] >> 13) & 0x1e0));
3053
3054   trace_output (OP_IMM_REG_REG);
3055
3056   return 4;
3057 }
3058
3059 /* end-sanitize-v850e */
3060 /* start-sanitize-v850e */
3061 /* mul imm9, reg2, reg3 */
3062 int
3063 OP_24007E0 (void)
3064 {
3065   trace_input ("mul", OP_IMM_REG_REG, 0);
3066
3067   Multiply64 (true, (OP[3] & 0x1f) | ((OP[3] >> 13) & 0x1e0));
3068
3069   trace_output (OP_IMM_REG_REG);
3070
3071   return 4;
3072 }
3073
3074 /* end-sanitize-v850e */
3075 /* start-sanitize-v850e */
3076 /* cmov imm5, reg2, reg3 */
3077 int
3078 OP_30007E0 (void)
3079 {
3080   trace_input ("cmov", OP_IMM_REG_REG, 0);
3081
3082   State.regs[ OP[2] >> 11 ] = condition_met (OP[0]) ? SEXT5( OP[0] ) : State.regs[ OP[1] ];
3083
3084   trace_output (OP_IMM_REG_REG);
3085
3086   return 4;
3087
3088 }
3089
3090 /* end-sanitize-v850e */
3091 /* start-sanitize-v850e */
3092 /* ctret */
3093 int
3094 OP_14407E0 (void)
3095 {
3096   trace_input ("ctret", OP_NONE, 0);
3097
3098   PC  = CTPC;
3099   PSW = CTPSW;
3100
3101   trace_output (OP_NONE);
3102
3103   return 0;
3104 }
3105
3106 /* end-sanitize-v850e */
3107 /* start-sanitize-v850e */
3108 /* hsw */
3109 int
3110 OP_34407E0 (void)
3111 {
3112   unsigned long value;
3113
3114   trace_input ("hsw", OP_REG_REG3, 0);
3115
3116   value = State.regs[ OP[ 1 ] ];
3117   value >>= 16;
3118   value |= (State.regs[ OP[ 1 ] ] << 16);
3119
3120   State.regs[ OP[2] >> 11 ] = value;
3121
3122   PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
3123
3124   if (value == 0) PSW |= PSW_Z;
3125   if (value & 0x80000000) PSW |= PSW_S;
3126   if (((value & 0xffff) == 0) || (value & 0xffff0000) == 0) PSW |= PSW_CY;
3127
3128   trace_output (OP_REG_REG3);
3129
3130   return 4;
3131 }
3132
3133 /* end-sanitize-v850e */
3134 /* start-sanitize-v850e */
3135 #define WORDHASNULLBYTE(x) (((x) - 0x01010101) & ~(x)&0x80808080)
3136
3137 /* bsw */
3138 int
3139 OP_34007E0 (void)
3140 {
3141   unsigned long value;
3142
3143   trace_input ("bsw", OP_REG_REG3, 0);
3144
3145   value = State.regs[ OP[ 1 ] ];
3146   value >>= 24;
3147   value |= (State.regs[ OP[ 1 ] ] << 24);
3148   value |= ((State.regs[ OP[ 1 ] ] << 8) & 0x00ff0000);
3149   value |= ((State.regs[ OP[ 1 ] ] >> 8) & 0x0000ff00);
3150
3151   State.regs[ OP[2] >> 11 ] = value;
3152
3153   PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
3154
3155   if (value == 0) PSW |= PSW_Z;
3156   if (value & 0x80000000) PSW |= PSW_S;
3157   if (WORDHASNULLBYTE (value)) PSW |= PSW_CY;
3158
3159   trace_output (OP_REG_REG3);
3160
3161   return 4;
3162 }
3163
3164 /* end-sanitize-v850e */
3165 /* start-sanitize-v850e */
3166 /* bsh */
3167 int
3168 OP_34207E0 (void)
3169 {
3170   unsigned long value;
3171
3172   trace_input ("bsh", OP_REG_REG3, 0);
3173
3174   value   = State.regs[ OP[ 1 ] ];
3175   value >>= 8;
3176   value  |= ((State.regs[ OP[ 1 ] ] << 8) & 0xff00ff00);
3177   value  |= ((State.regs[ OP[ 1 ] ] >> 8) & 0x000000ff);
3178
3179   State.regs[ OP[2] >> 11 ] = value;
3180
3181   PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
3182
3183   if (value == 0) PSW |= PSW_Z;
3184   if (value & 0x80000000) PSW |= PSW_S;
3185   if (((value & 0xff) == 0) || (value & 0x00ff) == 0) PSW |= PSW_CY;
3186
3187   trace_output (OP_REG_REG3);
3188
3189   return 4;
3190 }
3191
3192 /* end-sanitize-v850e */
3193 /* start-sanitize-v850e */
3194 /* pushml list18 */
3195 /* ld.hu */
3196 int
3197 OP_107E0 (void)
3198 {
3199   if (OP[ 1 ] == 0)
3200     {
3201       int i;
3202
3203       trace_input ("pushml", OP_PUSHPOP3, 0);
3204
3205       /* Store the registers with lower number registers being placed at higher addresses.  */
3206       for (i = 0; i < 15; i++)
3207         if ((OP[3] & (1 << type3_regs[ i ])))
3208           {
3209             SP -= 4;
3210             store_mem (SP & ~ 3, 4, State.regs[ i + 1 ]);
3211           }
3212
3213       if (OP[3] & (1 << 3))
3214         {
3215           SP -= 4;
3216
3217           store_mem (SP & ~ 3, 4, PSW);
3218         }
3219
3220       if (OP[3] & (1 << 19))
3221         {
3222           SP -= 8;
3223
3224           if ((PSW & PSW_NP) && ((PSW & PSW_EP) == 0))
3225             {
3226               store_mem ((SP + 4) & ~ 3, 4, FEPC);
3227               store_mem ( SP      & ~ 3, 4, FEPSW);
3228             }
3229           else
3230             {
3231               store_mem ((SP + 4) & ~ 3, 4, EIPC);
3232               store_mem ( SP      & ~ 3, 4, EIPSW);
3233             }
3234         }
3235
3236       trace_output (OP_PUSHPOP2);
3237     }
3238   else
3239     {
3240       int adr;
3241
3242       trace_input ("ld.hu", OP_LOAD32, 2);
3243
3244       adr = State.regs[ OP[0] ] + EXTEND16 (OP[2] & ~1);
3245       adr &= ~0x1;
3246
3247       State.regs[ OP[1] ] = load_mem (adr, 2);
3248
3249       trace_output (OP_LOAD32);
3250     }
3251
3252   return 4;
3253 }
3254
3255 /* end-sanitize-v850e */
3256 /* start-sanitize-v850e */
3257 /* prepare list12, imm5 */
3258 /* ld.bu */
3259 int
3260 OP_10780 (void)
3261 {
3262   if (OP[ 1 ] == 0)
3263     {
3264       int  i;
3265
3266       trace_input ("prepare", OP_PUSHPOP1, 0);
3267
3268       /* Store the registers with lower number registers being placed at higher addresses.  */
3269       for (i = 0; i < 12; i++)
3270         if ((OP[3] & (1 << type1_regs[ i ])))
3271           {
3272             SP -= 4;
3273             store_mem (SP, 4, State.regs[ 20 + i ]);
3274           }
3275
3276       SP -= (OP[3] & 0x3e) << 1;
3277
3278       trace_output (OP_PUSHPOP1);
3279     }
3280   else
3281     {
3282       int adr;
3283
3284       trace_input ("ld.bu", OP_LOAD32, 1);
3285
3286       adr = (State.regs[ OP[0] ]
3287              + (EXTEND16 (OP[2] & ~1) | ((OP[3] >> 5) & 1)));
3288
3289       State.regs[ OP[1] ] = load_mem (adr, 1);
3290
3291       trace_output (OP_LOAD32);
3292     }
3293
3294   return 4;
3295 }
3296
3297 /* prepare list12, imm5, imm32 */
3298 int
3299 OP_1B0780 (void)
3300 {
3301   int  i;
3302
3303   trace_input ("prepare", OP_PUSHPOP1, 0);
3304
3305   /* Store the registers with lower number registers being placed at higher addresses.  */
3306   for (i = 0; i < 12; i++)
3307     if ((OP[3] & (1 << type1_regs[ i ])))
3308       {
3309         SP -= 4;
3310         store_mem (SP, 4, State.regs[ 20 + i ]);
3311       }
3312
3313   SP -= (OP[3] & 0x3e) << 1;
3314
3315   EP = load_mem (PC + 4, 4);
3316
3317   trace_output (OP_PUSHPOP1);
3318
3319   return 8;
3320 }
3321
3322 /* prepare list12, imm5, imm16-32 */
3323 int
3324 OP_130780 (void)
3325 {
3326   int  i;
3327
3328   trace_input ("prepare", OP_PUSHPOP1, 0);
3329
3330   /* Store the registers with lower number registers being placed at higher addresses.  */
3331   for (i = 0; i < 12; i++)
3332     if ((OP[3] & (1 << type1_regs[ i ])))
3333       {
3334         SP -= 4;
3335         store_mem (SP, 4, State.regs[ 20 + i ]);
3336       }
3337
3338   SP -= (OP[3] & 0x3e) << 1;
3339
3340   EP = load_mem (PC + 4, 2) << 16;
3341
3342   trace_output (OP_PUSHPOP1);
3343
3344   return 6;
3345 }
3346
3347 /* prepare list12, imm5, imm16 */
3348 int
3349 OP_B0780 (void)
3350 {
3351   int  i;
3352
3353   trace_input ("prepare", OP_PUSHPOP1, 0);
3354
3355   /* Store the registers with lower number registers being placed at higher addresses.  */
3356   for (i = 0; i < 12; i++)
3357     if ((OP[3] & (1 << type1_regs[ i ])))
3358       {
3359         SP -= 4;
3360         store_mem (SP, 4, State.regs[ 20 + i ]);
3361       }
3362
3363   SP -= (OP[3] & 0x3e) << 1;
3364
3365   EP = EXTEND16 (load_mem (PC + 4, 2));
3366
3367   trace_output (OP_PUSHPOP1);
3368
3369   return 6;
3370 }
3371
3372 /* prepare list12, imm5, sp */
3373 int
3374 OP_30780 (void)
3375 {
3376   int  i;
3377
3378   trace_input ("prepare", OP_PUSHPOP1, 0);
3379
3380   /* Store the registers with lower number registers being placed at higher addresses.  */
3381   for (i = 0; i < 12; i++)
3382     if ((OP[3] & (1 << type1_regs[ i ])))
3383       {
3384         SP -= 4;
3385         store_mem (SP, 4, State.regs[ 20 + i ]);
3386       }
3387
3388   SP -= (OP[3] & 0x3e) << 1;
3389
3390   EP = SP;
3391
3392   trace_output (OP_PUSHPOP1);
3393
3394   return 4;
3395 }
3396
3397 /* end-sanitize-v850e */
3398 /* start-sanitize-v850e */
3399 /* sld.hu */
3400 int
3401 OP_70 (void)
3402 {
3403   unsigned long result;
3404
3405   result  = load_mem (State.regs[30] + ((OP[3] & 0xf) << 1), 2);
3406
3407 /* start-sanitize-v850eq */
3408 #ifdef ARCH_v850eq
3409   trace_input ("sld.h", OP_LOAD16, 2);
3410
3411   State.regs[ OP[1] ] = EXTEND16 (result);
3412 #else
3413 /* end-sanitize-v850eq */
3414   trace_input ("sld.hu", OP_LOAD16, 2);
3415
3416   State.regs[ OP[1] ] = result;
3417 /* start-sanitize-v850eq */
3418 #endif
3419 /* end-sanitize-v850eq */
3420
3421   trace_output (OP_LOAD16);
3422
3423   return 2;
3424 }
3425
3426 /* end-sanitize-v850e */
3427 /* start-sanitize-v850e */
3428 /* cmov reg1, reg2, reg3 */
3429 int
3430 OP_32007E0 (void)
3431 {
3432   trace_input ("cmov", OP_REG_REG_REG, 0);
3433
3434   State.regs[ OP[2] >> 11 ] = condition_met (OP[0]) ? State.regs[ OP[0] ] : State.regs[ OP[1] ];
3435
3436   trace_output (OP_REG_REG_REG);
3437
3438   return 4;
3439 }
3440
3441 /* end-sanitize-v850e */
3442 /* start-sanitize-v850e */
3443 /* mul reg1, reg2, reg3 */
3444 int
3445 OP_22007E0 (void)
3446 {
3447   trace_input ("mul", OP_REG_REG_REG, 0);
3448
3449   Multiply64 (true, State.regs[ OP[0] ]);
3450
3451   trace_output (OP_REG_REG_REG);
3452
3453   return 4;
3454 }
3455
3456 /* end-sanitize-v850e */
3457 /* start-sanitize-v850eq */
3458
3459 /* popmh list18 */
3460 int
3461 OP_307F0 (void)
3462 {
3463   int i;
3464
3465   trace_input ("popmh", OP_PUSHPOP2, 0);
3466
3467   if (OP[3] & (1 << 19))
3468     {
3469       if ((PSW & PSW_NP) && ((PSW & PSW_EP) == 0))
3470         {
3471           FEPSW = load_mem ( SP      & ~ 3, 4);
3472           FEPC  = load_mem ((SP + 4) & ~ 3, 4);
3473         }
3474       else
3475         {
3476           EIPSW = load_mem ( SP      & ~ 3, 4);
3477           EIPC  = load_mem ((SP + 4) & ~ 3, 4);
3478         }
3479
3480       SP += 8;
3481     }
3482
3483   /* Load the registers with lower number registers being retrieved from higher addresses.  */
3484   for (i = 16; i--;)
3485     if ((OP[3] & (1 << type2_regs[ i ])))
3486       {
3487         State.regs[ i + 16 ] = load_mem (SP & ~ 3, 4);
3488         SP += 4;
3489       }
3490
3491   trace_output (OP_PUSHPOP2);
3492
3493   return 4;
3494 }
3495
3496 /* popml lsit18 */
3497 int
3498 OP_107F0 (void)
3499 {
3500   int i;
3501
3502   trace_input ("popml", OP_PUSHPOP3, 0);
3503
3504   if (OP[3] & (1 << 19))
3505     {
3506       if ((PSW & PSW_NP) && ((PSW & PSW_EP) == 0))
3507         {
3508           FEPSW = load_mem ( SP      & ~ 3, 4);
3509           FEPC =  load_mem ((SP + 4) & ~ 3, 4);
3510         }
3511       else
3512         {
3513           EIPSW = load_mem ( SP      & ~ 3, 4);
3514           EIPC  = load_mem ((SP + 4) & ~ 3, 4);
3515         }
3516
3517       SP += 8;
3518     }
3519
3520   if (OP[3] & (1 << 3))
3521     {
3522       PSW = load_mem (SP & ~ 3, 4);
3523       SP += 4;
3524     }
3525
3526   /* Load the registers with lower number registers being retrieved from higher addresses.  */
3527   for (i = 15; i--;)
3528     if ((OP[3] & (1 << type3_regs[ i ])))
3529       {
3530         State.regs[ i + 1 ] = load_mem (SP & ~ 3, 4);
3531         SP += 4;
3532       }
3533
3534   trace_output (OP_PUSHPOP2);
3535
3536   return 4;
3537 }
3538
3539 /* pushmh list18 */
3540 int
3541 OP_307E0 (void)
3542 {
3543   int i;
3544
3545   trace_input ("pushmh", OP_PUSHPOP2, 0);
3546
3547   /* Store the registers with lower number registers being placed at higher addresses.  */
3548   for (i = 0; i < 16; i++)
3549     if ((OP[3] & (1 << type2_regs[ i ])))
3550       {
3551         SP -= 4;
3552         store_mem (SP & ~ 3, 4, State.regs[ i + 16 ]);
3553       }
3554
3555   if (OP[3] & (1 << 19))
3556     {
3557       SP -= 8;
3558
3559       if ((PSW & PSW_NP) && ((PSW & PSW_EP) == 0))
3560         {
3561           store_mem ((SP + 4) & ~ 3, 4, FEPC);
3562           store_mem ( SP      & ~ 3, 4, FEPSW);
3563         }
3564       else
3565         {
3566           store_mem ((SP + 4) & ~ 3, 4, EIPC);
3567           store_mem ( SP      & ~ 3, 4, EIPSW);
3568         }
3569     }
3570
3571   trace_output (OP_PUSHPOP2);
3572
3573   return 4;
3574 }
3575
3576 /* end-sanitize-v850eq */