sim/v850/simops.c

   1 #include <signal.h>
   2 #include "v850_sim.h"
   3 #include "simops.h"
   4 #include "sys/syscall.h"
   5
   6 /* sld.b */
   7 void
   8 OP_300 ()
   9 {
  10   unsigned int op2;
  11   int result, temp;
  12
  13   temp = OP[1];
  14   temp = (temp << 25) >> 25;
  15   op2 = temp;
  16   result = get_byte (State.mem + State.regs[30] + op2);
  17   result = (result << 24) >> 24;
  18   State.regs[OP[0]] = result;
  19 }
  20
  21 /* sld.h */
  22 void
  23 OP_400 ()
  24 {
  25   unsigned int op2;
  26   int result, temp;
  27
  28   temp = OP[1];
  29   temp = (temp << 25) >> 25;
  30   op2 = temp << 1;
  31   result = get_half (State.mem + State.regs[30] + op2);
  32   result = (result << 16) >> 16;
  33   State.regs[OP[0]] = result;
  34 }
  35
  36 /* sld.w */
  37 void
  38 OP_500 ()
  39 {
  40   unsigned int op2;
  41   int result, temp;
  42
  43   temp = OP[1];
  44   temp = (temp << 25) >> 25;
  45   op2 = temp << 2;
  46   result = get_word (State.mem + State.regs[30] + op2);
  47   State.regs[OP[0]] = result;
  48 }
  49
  50 /* sst.b */
  51 void
  52 OP_380 ()
  53 {
  54   unsigned int op0, op1;
  55   int temp;
  56
  57   op0 = State.regs[OP[0]];
  58   temp = OP[1];
  59   temp = (temp << 25) >> 25;
  60   op1 = temp;
  61   put_byte (State.mem + State.regs[30] + op1, op0);
  62 }
  63
  64 /* sst.h */
  65 void
  66 OP_480 ()
  67 {
  68   unsigned int op0, op1;
  69   int temp;
  70
  71   op0 = State.regs[OP[0]];
  72   temp = OP[1];
  73   temp = (temp << 25) >> 25;
  74   op1 = temp << 1;
  75   put_half (State.mem + State.regs[30] + op1, op0);
  76 }
  77
  78 /* sst.w */
  79 void
  80 OP_501 ()
  81 {
  82   unsigned int op0, op1;
  83   int temp;
  84
  85   op0 = State.regs[OP[0]];
  86   temp = OP[1];
  87   temp = (temp << 25) >> 25;
  88   op1 = temp << 2;
  89   put_word (State.mem + State.regs[30] + op1, op0);
  90 }
  91
  92 /* ld.b */
  93 void
  94 OP_700 ()
  95 {
  96   unsigned int op0, op2;
  97   int result, temp;
  98
  99   op0 = State.regs[OP[0]];
 100   temp = OP[2];
 101   temp = (temp << 16) >> 16;
 102   op2 = temp;
 103   result = get_byte (State.mem + op0 + op2);
 104   result = (result << 24) >> 24;
 105   State.regs[OP[1]] = result;
 106 }
 107
 108 /* ld.h */
 109 void
 110 OP_720 ()
 111 {
 112   unsigned int op0, op2;
 113   int result, temp;
 114
 115   op0 = State.regs[OP[0]];
 116   temp = OP[2];
 117   temp = (temp << 16) >> 16;
 118   temp &= ~0x1;
 119   op2 = temp;
 120   result = get_half (State.mem + op0 + op2);
 121   result = (result << 16) >> 16;
 122   State.regs[OP[1]] = result;
 123 }
 124
 125 /* ld.w */
 126 void
 127 OP_10720 ()
 128 {
 129   unsigned int op0,  op2;
 130   int result, temp;
 131
 132   op0 = State.regs[OP[0]];
 133   temp = OP[2];
 134   temp = (temp << 16) >> 16;
 135   temp &= ~0x1;
 136   op2 = temp;
 137   result = get_word (State.mem + op0 + op2);
 138   State.regs[OP[1]] = result;
 139 }
 140
 141 /* st.b */
 142 void
 143 OP_740 ()
 144 {
 145   unsigned int op0, op1, op2;
 146   int temp;
 147
 148   op0 = State.regs[OP[0]];
 149   op1 = State.regs[OP[1]];
 150   temp = OP[2];
 151   temp = (temp << 16) >> 16;
 152   op2 = temp;
 153   put_byte (State.mem + op0 + op2, op1);
 154 }
 155
 156 /* st.h */
 157 void
 158 OP_760 ()
 159 {
 160   unsigned int op0, op1, op2;
 161   int temp;
 162
 163   op0 = State.regs[OP[0]];
 164   op1 = State.regs[OP[1]];
 165   temp = OP[2];
 166   temp &= ~0x1;
 167   temp = (temp << 16) >> 16;
 168   op2 = temp;
 169   put_half (State.mem + op0 + op2, op1);
 170 }
 171
 172 /* st.w */
 173 void
 174 OP_10760 ()
 175 {
 176   unsigned int op0, op1, op2;
 177   int temp;
 178
 179   op0 = State.regs[OP[0]];
 180   op1 = State.regs[OP[1]];
 181   temp = OP[2];
 182   temp &= ~0x1;
 183   temp = (temp << 16) >> 16;
 184   op2 = temp;
 185   put_word (State.mem + op0 + op2, op1);
 186 }
 187
 188 /* bv disp9 */
 189 void
 190 OP_580 ()
 191 {
 192   unsigned int op0, psw;
 193
 194   op0 = ((signed)OP[0] << 23) >> 23;
 195   psw = State.sregs[5];
 196
 197   if ((psw & PSW_OV) != 0)
 198     State.pc += op0;
 199   else
 200     State.pc += 2;
 201 }
 202
 203 /* bl disp9 */
 204 void
 205 OP_581 ()
 206 {
 207   unsigned int op0, psw;
 208
 209   op0 = ((signed)OP[0] << 23) >> 23;
 210   psw = State.sregs[5];
 211
 212   if ((psw & PSW_CY) != 0)
 213     State.pc += op0;
 214   else
 215     State.pc += 2;
 216 }
 217
 218 /* be disp9 */
 219 void
 220 OP_582 ()
 221 {
 222   unsigned int op0, psw;
 223
 224   op0 = ((signed)OP[0] << 23) >> 23;
 225   psw = State.sregs[5];
 226
 227   if ((psw & PSW_Z) != 0)
 228     State.pc += op0;
 229   else
 230     State.pc += 2;
 231 }
 232
 233 /* bnh disp 9*/
 234 void
 235 OP_583 ()
 236 {
 237   unsigned int op0, psw;
 238
 239   op0 = ((signed)OP[0] << 23) >> 23;
 240   psw = State.sregs[5];
 241
 242   if ((((psw & PSW_CY) != 0) | ((psw & PSW_Z) != 0)) != 0)
 243     State.pc += op0;
 244   else
 245     State.pc += 2;
 246 }
 247
 248 /* bn disp9 */
 249 void
 250 OP_584 ()
 251 {
 252   unsigned int op0, psw;
 253
 254   op0 = ((signed)OP[0] << 23) >> 23;
 255   psw = State.sregs[5];
 256
 257   if ((psw & PSW_S) != 0)
 258     State.pc += op0;
 259   else
 260     State.pc += 2;
 261 }
 262
 263 /* br disp9 */
 264 void
 265 OP_585 ()
 266 {
 267   unsigned int op0;
 268
 269   op0 = ((signed)OP[0] << 23) >> 23;
 270   State.pc += op0;
 271 }
 272
 273 /* blt disp9 */
 274 void
 275 OP_586 ()
 276 {
 277   unsigned int op0, psw;
 278
 279   op0 = ((signed)OP[0] << 23) >> 23;
 280   psw = State.sregs[5];
 281
 282   if ((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) != 0)
 283     State.pc += op0;
 284   else
 285     State.pc += 2;
 286 }
 287
 288 /* ble disp9 */
 289 void
 290 OP_587 ()
 291 {
 292   unsigned int op0, psw;
 293
 294   op0 = ((signed)OP[0] << 23) >> 23;
 295   psw = State.sregs[5];
 296
 297   if ((((psw & PSW_Z) != 0)
 298        || (((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0))) != 0)
 299     State.pc += op0;
 300   else
 301     State.pc += 2;
 302 }
 303
 304 /* bnv disp9 */
 305 void
 306 OP_588 ()
 307 {
 308   unsigned int op0, psw;
 309
 310   op0 = ((signed)OP[0] << 23) >> 23;
 311   psw = State.sregs[5];
 312
 313   if ((psw & PSW_OV) == 0)
 314     State.pc += op0;
 315   else
 316     State.pc += 2;
 317 }
 318
 319 /* bnl disp9 */
 320 void
 321 OP_589 ()
 322 {
 323   unsigned int op0, psw;
 324
 325   op0 = ((signed)OP[0] << 23) >> 23;
 326   psw = State.sregs[5];
 327
 328   if ((psw & PSW_CY) == 0)
 329     State.pc += op0;
 330   else
 331     State.pc += 2;
 332 }
 333
 334 /* bne disp9 */
 335 void
 336 OP_58A ()
 337 {
 338   unsigned int op0, psw;
 339
 340   op0 = ((signed)OP[0] << 23) >> 23;
 341   psw = State.sregs[5];
 342
 343   if ((psw & PSW_Z) == 0)
 344     State.pc += op0;
 345   else
 346     State.pc += 2;
 347 }
 348
 349 /* bh disp9 */
 350 void
 351 OP_58B ()
 352 {
 353   unsigned int op0, psw;
 354
 355   op0 = ((signed)OP[0] << 23) >> 23;
 356   psw = State.sregs[5];
 357
 358   if ((((psw & PSW_CY) != 0) | ((psw & PSW_Z) != 0)) == 0)
 359     State.pc += op0;
 360   else
 361     State.pc += 2;
 362 }
 363
 364 /* bp disp9 */
 365 void
 366 OP_58C ()
 367 {
 368   unsigned int op0, psw;
 369
 370   op0 = ((signed)OP[0] << 23) >> 23;
 371   psw = State.sregs[5];
 372
 373   if ((psw & PSW_S) == 0)
 374     State.pc += op0;
 375   else
 376     State.pc += 2;
 377 }
 378
 379 /* bsa disp9 */
 380 void
 381 OP_58D ()
 382 {
 383   unsigned int op0, psw;
 384
 385   op0 = ((signed)OP[0] << 23) >> 23;
 386   psw = State.sregs[5];
 387
 388   if ((psw & PSW_SAT) != 0)
 389     State.pc += op0;
 390   else
 391     State.pc += 2;
 392 }
 393
 394 /* bge disp9 */
 395 void
 396 OP_58E ()
 397 {
 398   unsigned int op0, psw;
 399
 400   op0 = ((signed)OP[0] << 23) >> 23;
 401   psw = State.sregs[5];
 402
 403   if ((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) == 0)
 404     State.pc += op0;
 405   else
 406     State.pc += 2;
 407 }
 408
 409 /* bgt disp9 */
 410 void
 411 OP_58F ()
 412 {
 413   unsigned int op0, psw;
 414
 415   op0 = ((signed)OP[0] << 23) >> 23;
 416   psw = State.sregs[5];
 417
 418   if ((((psw & PSW_Z) != 0)
 419        || (((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0))) == 0)
 420     State.pc += op0;
 421   else
 422     State.pc += 2;
 423 }
 424
 425 /* jmp [reg1] */
 426 void
 427 OP_60 ()
 428 {
 429   /* interp.c will bump this by +2, so correct for it here.  */
 430   State.pc = State.regs[OP[0]] - 2;
 431 }
 432
 433 /* jarl disp22, reg */
 434 void
 435 OP_780 ()
 436 {
 437   unsigned int op0, opc;
 438   int temp;
 439
 440   temp = OP[0];
 441   temp = (temp << 10) >> 10;
 442   op0 = temp;
 443   opc = State.pc;
 444
 445   State.pc += temp;
 446
 447   /* Gross.  jarl X,r0 is really jr and doesn't save its result.  */
 448   if (OP[1] != 0)
 449     State.regs[OP[1]] = opc + 4;
 450 }
 451
 452 /* add reg, reg */
 453 void
 454 OP_1C0 ()
 455 {
 456   unsigned int op0, op1, result, z, s, cy, ov;
 457
 458   /* Compute the result.  */
 459   op0 = State.regs[OP[0]];
 460   op1 = State.regs[OP[1]];
 461   result = op0 + op1;
 462
 463   /* Compute the condition codes.  */
 464   z = (result == 0);
 465   s = (result & 0x80000000);
 466   cy = (result < op0 || result < op1);
 467   ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
 468         && (op0 & 0x80000000) != (result & 0x80000000));
 469
 470   /* Store the result and condition codes.  */
 471   State.regs[OP[1]] = result;
 472   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 473   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 474                      | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
 475 }
 476
 477 /* add sign_extend(imm5), reg */
 478 void
 479 OP_240 ()
 480 {
 481   unsigned int op0, op1, result, z, s, cy, ov;
 482   int temp;
 483
 484   /* Compute the result.  */
 485   temp = (OP[0] & 0x1f);
 486   temp = (temp << 27) >> 27;
 487   op0 = temp;
 488   op1 = State.regs[OP[1]];
 489   result = op0 + op1;
 490
 491   /* Compute the condition codes.  */
 492   z = (result == 0);
 493   s = (result & 0x80000000);
 494   cy = (result < op0 || result < op1);
 495   ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
 496         && (op0 & 0x80000000) != (result & 0x80000000));
 497
 498   /* Store the result and condition codes.  */
 499   State.regs[OP[1]] = result;
 500   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 501   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 502                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
 503 }
 504
 505 /* addi sign_extend(imm16), reg, reg */
 506 void
 507 OP_600 ()
 508 {
 509   unsigned int op0, op1, result, z, s, cy, ov;
 510   int temp;
 511
 512   /* Compute the result.  */
 513   temp = (OP[0] & 0xffff);
 514   temp = (temp << 16) >> 16;
 515   op0 = temp;
 516   op1 = State.regs[OP[1]];
 517   result = op0 + op1;
 518
 519   /* Compute the condition codes.  */
 520   z = (result == 0);
 521   s = (result & 0x80000000);
 522   cy = (result < op0 || result < op1);
 523   ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
 524         && (op0 & 0x80000000) != (result & 0x80000000));
 525
 526   /* Store the result and condition codes.  */
 527   State.regs[OP[2]] = result;
 528   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 529   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 530                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
 531 }
 532
 533 /* sub reg1, reg2 */
 534 void
 535 OP_1A0 ()
 536 {
 537   unsigned int op0, op1, result, z, s, cy, ov;
 538
 539   /* Compute the result.  */
 540   op0 = State.regs[OP[0]];
 541   op1 = State.regs[OP[1]];
 542   result = op1 - op0;
 543
 544   /* Compute the condition codes.  */
 545   z = (result == 0);
 546   s = (result & 0x80000000);
 547   cy = (op1 < op0);
 548   ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
 549         && (op1 & 0x80000000) != (result & 0x80000000));
 550
 551   /* Store the result and condition codes.  */
 552   State.regs[OP[1]] = result;
 553   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 554   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 555                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
 556 }
 557
 558 /* subr reg1, reg2 */
 559 void
 560 OP_180 ()
 561 {
 562   unsigned int op0, op1, result, z, s, cy, ov;
 563
 564   /* Compute the result.  */
 565   op0 = State.regs[OP[0]];
 566   op1 = State.regs[OP[1]];
 567   result = op0 - op1;
 568
 569   /* Compute the condition codes.  */
 570   z = (result == 0);
 571   s = (result & 0x80000000);
 572   cy = (op0 < op1);
 573   ov = ((op0 & 0x80000000) != (op1 & 0x80000000)
 574         && (op0 & 0x80000000) != (result & 0x80000000));
 575
 576   /* Store the result and condition codes.  */
 577   State.regs[OP[1]] = result;
 578   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 579   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 580                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
 581 }
 582
 583 /* mulh reg1, reg2 */
 584 void
 585 OP_E0 ()
 586 {
 587   State.regs[OP[1]] = ((State.regs[OP[1]] & 0xffff)
 588                        * (State.regs[OP[0]] & 0xffff));
 589 }
 590
 591 /* mulh sign_extend(imm5), reg2
 592
 593    Condition codes */
 594 void
 595 OP_2E0 ()
 596 {
 597   int value = OP[0];
 598
 599   value = (value << 27) >> 27;
 600
 601   State.regs[OP[1]] = (State.regs[OP[1]] & 0xffff) * value;
 602 }
 603
 604 /* mulhi imm16, reg1, reg2 */
 605 void
 606 OP_6E0 ()
 607 {
 608   int value = OP[0];
 609
 610   value = value & 0xffff;
 611
 612   State.regs[OP[2]] = (State.regs[OP[1]] & 0xffff) * value;
 613 }
 614
 615 /* divh reg1, reg2 */
 616 void
 617 OP_40 ()
 618 {
 619   unsigned int op0, op1, result, ov, s, z;
 620   int temp;
 621
 622   /* Compute the result.  */
 623   temp = State.regs[OP[0]] & 0xffff;
 624   temp = (temp << 16) >> 16;
 625   op0 = temp;
 626   op1 = State.regs[OP[1]];
 627
 628   if (op0 == 0xffffffff && op1 == 0x80000000)
 629     {
 630       result = 0x80000000;
 631       ov = 1;
 632     }
 633   else if (op0 != 0)
 634     {
 635       result = op1 / op0;
 636       ov = 0;
 637     }
 638   else
 639     {
 640       result = 0x0;
 641       ov = 1;
 642     }
 643
 644   /* Compute the condition codes.  */
 645   z = (result == 0);
 646   s = (result & 0x80000000);
 647
 648   /* Store the result and condition codes.  */
 649   State.regs[OP[1]] = result;
 650   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV);
 651   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 652                 | (ov ? PSW_OV : 0));
 653 }
 654
 655 /* cmp reg, reg */
 656 void
 657 OP_1E0 ()
 658 {
 659   unsigned int op0, op1, result, z, s, cy, ov;
 660
 661   /* Compute the result.  */
 662   op0 = State.regs[OP[0]];
 663   op1 = State.regs[OP[1]];
 664   result = op1 - op0;
 665
 666   /* Compute the condition codes.  */
 667   z = (result == 0);
 668   s = (result & 0x80000000);
 669   cy = (op1 < op0);
 670   ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
 671         && (op1 & 0x80000000) != (result & 0x80000000));
 672
 673   /* Set condition codes.  */
 674   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 675   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 676                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
 677 }
 678
 679 /* cmp sign_extend(imm5), reg */
 680 void
 681 OP_260 ()
 682 {
 683   unsigned int op0, op1, result, z, s, cy, ov;
 684   int temp;
 685
 686   /* Compute the result.  */
 687   temp = OP[0];
 688   temp = (temp << 27) >> 27;
 689   op0 = temp;
 690   op1 = State.regs[OP[1]];
 691   result = op1 - op0;
 692
 693   /* Compute the condition codes.  */
 694   z = (result == 0);
 695   s = (result & 0x80000000);
 696   cy = (op1 < op0);
 697   ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
 698         && (op1 & 0x80000000) != (result & 0x80000000));
 699
 700   /* Set condition codes.  */
 701   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 702   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 703                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
 704 }
 705
 706 /* setf cccc,reg2 */
 707 void
 708 OP_7E0 ()
 709 {
 710   /* Hack alert.  We turn off a bit in op0 since we really only
 711      wanted 4 bits.  */
 712   unsigned int op0, psw, result = 0;
 713
 714   op0 = OP[0] & 0xf;
 715   psw = State.sregs[5];
 716
 717   switch (op0)
 718     {
 719       case 0x0:
 720         result = ((psw & PSW_OV) != 0);
 721         break;
 722       case 0x1:
 723         result = ((psw & PSW_CY) != 0);
 724         break;
 725       case 0x2:
 726         result = ((psw & PSW_Z) != 0);
 727         break;
 728       case 0x3:
 729         result = ((((psw & PSW_CY) != 0) | ((psw & PSW_Z) != 0)) != 0);
 730         break;
 731       case 0x4:
 732         result = ((psw & PSW_S) != 0);
 733         break;
 734       case 0x5:
 735         result = 1;
 736         break;
 737       case 0x6:
 738         result = ((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) != 0);
 739         break;
 740       case 0x7:
 741         result = (((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0))
 742                   || ((psw & PSW_Z) != 0)) != 0);
 743         break;
 744       case 0x8:
 745         result = ((psw & PSW_OV) == 0);
 746         break;
 747       case 0x9:
 748         result = ((psw & PSW_CY) == 0);
 749         break;
 750       case 0xa:
 751         result = ((psw & PSW_Z) == 0);
 752         break;
 753       case 0xb:
 754         result = ((((psw & PSW_CY) != 0) | ((psw & PSW_Z) != 0)) == 0);
 755         break;
 756       case 0xc:
 757         result = ((psw & PSW_S) == 0);
 758         break;
 759       case 0xd:
 760         result = ((psw & PSW_SAT) != 0);
 761         break;
 762       case 0xe:
 763         result = ((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) == 0);
 764         break;
 765       case 0xf:
 766         result = (((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0))
 767                   || ((psw & PSW_Z) != 0)) == 0);
 768         break;
 769     }
 770
 771   State.regs[OP[1]] = result;
 772 }
 773
 774 /* satadd reg,reg */
 775 void
 776 OP_C0 ()
 777 {
 778   unsigned int op0, op1, result, z, s, cy, ov, sat;
 779
 780   /* Compute the result.  */
 781   op0 = State.regs[OP[0]];
 782   op1 = State.regs[OP[1]];
 783   result = op0 + op1;
 784
 785   /* Compute the condition codes.  */
 786   z = (result == 0);
 787   s = (result & 0x80000000);
 788   cy = (result < op0 || result < op1);
 789   ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
 790         && (op0 & 0x80000000) != (result & 0x80000000));
 791   sat = ov;
 792
 793   /* Store the result and condition codes.  */
 794   State.regs[OP[1]] = result;
 795   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 796   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 797                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
 798                 | (sat ? PSW_SAT : 0));
 799
 800   /* Handle saturated results.  */
 801   if (sat && s)
 802     State.regs[OP[1]] = 0x80000000;
 803   else if (sat)
 804     State.regs[OP[1]] = 0x7fffffff;
 805 }
 806
 807 /* satadd sign_extend(imm5), reg */
 808 void
 809 OP_220 ()
 810 {
 811   unsigned int op0, op1, result, z, s, cy, ov, sat;
 812
 813   int temp;
 814
 815   /* Compute the result.  */
 816   temp = (OP[0] & 0x1f);
 817   temp = (temp << 27) >> 27;
 818   op0 = temp;
 819   op1 = State.regs[OP[1]];
 820   result = op0 + op1;
 821
 822   /* Compute the condition codes.  */
 823   z = (result == 0);
 824   s = (result & 0x80000000);
 825   cy = (result < op0 || result < op1);
 826   ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
 827         && (op0 & 0x80000000) != (result & 0x80000000));
 828   sat = ov;
 829
 830   /* Store the result and condition codes.  */
 831   State.regs[OP[1]] = result;
 832   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 833   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 834                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
 835                 | (sat ? PSW_SAT : 0));
 836
 837   /* Handle saturated results.  */
 838   if (sat && s)
 839     State.regs[OP[1]] = 0x80000000;
 840   else if (sat)
 841     State.regs[OP[1]] = 0x7fffffff;
 842 }
 843
 844 /* satsub reg1, reg2 */
 845 void
 846 OP_A0 ()
 847 {
 848   unsigned int op0, op1, result, z, s, cy, ov, sat;
 849
 850   /* Compute the result.  */
 851   op0 = State.regs[OP[0]];
 852   op1 = State.regs[OP[1]];
 853   result = op1 - op0;
 854
 855   /* Compute the condition codes.  */
 856   z = (result == 0);
 857   s = (result & 0x80000000);
 858   cy = (op1 < op0);
 859   ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
 860         && (op1 & 0x80000000) != (result & 0x80000000));
 861   sat = ov;
 862
 863   /* Store the result and condition codes.  */
 864   State.regs[OP[1]] = result;
 865   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 866   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 867                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
 868                 | (sat ? PSW_SAT : 0));
 869
 870   /* Handle saturated results.  */
 871   if (sat && s)
 872     State.regs[OP[1]] = 0x80000000;
 873   else if (sat)
 874     State.regs[OP[1]] = 0x7fffffff;
 875 }
 876
 877 /* satsubi sign_extend(imm16), reg */
 878 void
 879 OP_660 ()
 880 {
 881   unsigned int op0, op1, result, z, s, cy, ov, sat;
 882   int temp;
 883
 884   /* Compute the result.  */
 885   temp = (OP[0] & 0xffff);
 886   temp = (temp << 16) >> 16;
 887   op0 = temp;
 888   op1 = State.regs[OP[1]];
 889   result = op1 - op0;
 890
 891   /* Compute the condition codes.  */
 892   z = (result == 0);
 893   s = (result & 0x80000000);
 894   cy = (op1 < op0);
 895   ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
 896         && (op1 & 0x80000000) != (result & 0x80000000));
 897   sat = ov;
 898
 899   /* Store the result and condition codes.  */
 900   State.regs[OP[1]] = result;
 901   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 902   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 903                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
 904                 | (sat ? PSW_SAT : 0));
 905
 906   /* Handle saturated results.  */
 907   if (sat && s)
 908     State.regs[OP[1]] = 0x80000000;
 909   else if (sat)
 910     State.regs[OP[1]] = 0x7fffffff;
 911 }
 912
 913 void
 914 OP_80 ()
 915 {
 916   unsigned int op0, op1, result, z, s, cy, ov, sat;
 917
 918   /* Compute the result.  */
 919   op0 = State.regs[OP[0]];
 920   op1 = State.regs[OP[1]];
 921   result = op0 - op1;
 922
 923   /* Compute the condition codes.  */
 924   z = (result == 0);
 925   s = (result & 0x80000000);
 926   cy = (result < op0);
 927   ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
 928         && (op1 & 0x80000000) != (result & 0x80000000));
 929   sat = ov;
 930
 931   /* Store the result and condition codes.  */
 932   State.regs[OP[1]] = result;
 933   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
 934   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
 935                 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
 936                 | (sat ? PSW_SAT : 0));
 937
 938   /* Handle saturated results.  */
 939   if (sat && s)
 940     State.regs[OP[1]] = 0x80000000;
 941   else if (sat)
 942     State.regs[OP[1]] = 0x7fffffff;
 943 }
 944
 945 /* tst reg,reg */
 946 void
 947 OP_160 ()
 948 {
 949   unsigned int op0, op1, result, z, s;
 950
 951   /* Compute the result.  */
 952   op0 = State.regs[OP[0]];
 953   op1 = State.regs[OP[1]];
 954   result = op0 & op1;
 955
 956   /* Compute the condition codes.  */
 957   z = (result == 0);
 958   s = (result & 0x80000000);
 959
 960   /* Store the condition codes.  */
 961   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV);
 962   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
 963 }
 964
 965 /* mov reg, reg */
 966 void
 967 OP_0 ()
 968 {
 969   State.regs[OP[1]] = State.regs[OP[0]];
 970 }
 971
 972 /* mov sign_extend(imm5), reg */
 973 void
 974 OP_200 ()
 975 {
 976   int value = OP[0];
 977
 978   value = (value << 27) >> 27;
 979   State.regs[OP[1]] = value;
 980 }
 981
 982 /* movea sign_extend(imm16), reg, reg  */
 983
 984 void
 985 OP_620 ()
 986 {
 987   int value = OP[0];
 988
 989   value = (value << 16) >> 16;
 990
 991   State.regs[OP[2]] = State.regs[OP[1]] + value;
 992 }
 993
 994 /* movhi imm16, reg, reg */
 995 void
 996 OP_640 ()
 997 {
 998   int value = OP[0];
 999
1000   value = (value & 0xffff) << 16;
1001
1002   State.regs[OP[2]] = State.regs[OP[1]] + value;
1003 }
1004
1005 /* sar zero_extend(imm5),reg1 */
1006 void
1007 OP_2A0 ()
1008 {
1009   unsigned int op0, op1, result, z, s, cy;
1010
1011   op0 = OP[0] & 0x1f;
1012   op1 = State.regs[OP[1]];
1013   result = (signed)op1 >> op0;
1014
1015   /* Compute the condition codes.  */
1016   z = (result == 0);
1017   s = (result & 0x80000000);
1018   cy = (op1 & (1 << (op0 - 1)));
1019
1020   /* Store the result and condition codes.  */
1021   State.regs[OP[1]] = result;
1022   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1023   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1024                 | (cy ? PSW_CY : 0));
1025 }
1026
1027 /* sar reg1, reg2 */
1028 void
1029 OP_A007E0 ()
1030 {
1031   unsigned int op0, op1, result, z, s, cy;
1032
1033   op0 = State.regs[OP[0]] & 0x1f;
1034   op1 = State.regs[OP[1]];
1035   result = (signed)op1 >> op0;
1036
1037   /* Compute the condition codes.  */
1038   z = (result == 0);
1039   s = (result & 0x80000000);
1040   cy = (op1 & (1 << (op0 - 1)));
1041
1042   /* Store the result and condition codes.  */
1043   State.regs[OP[1]] = result;
1044   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1045   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1046                 | (cy ? PSW_CY : 0));
1047 }
1048
1049 /* shl zero_extend(imm5),reg1 */
1050 void
1051 OP_2C0 ()
1052 {
1053   unsigned int op0, op1, result, z, s, cy;
1054
1055   op0 = OP[0] & 0x1f;
1056   op1 = State.regs[OP[1]];
1057   result = op1 << op0;
1058
1059   /* Compute the condition codes.  */
1060   z = (result == 0);
1061   s = (result & 0x80000000);
1062   cy = (op1 & (1 << (32 - op0)));
1063
1064   /* Store the result and condition codes.  */
1065   State.regs[OP[1]] = result;
1066   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1067   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1068                 | (cy ? PSW_CY : 0));
1069 }
1070
1071 /* shl reg1, reg2 */
1072 void
1073 OP_C007E0 ()
1074 {
1075   unsigned int op0, op1, result, z, s, cy;
1076
1077   op0 = State.regs[OP[0]] & 0x1f;
1078   op1 = State.regs[OP[1]];
1079   result = op1 << op0;
1080
1081   /* Compute the condition codes.  */
1082   z = (result == 0);
1083   s = (result & 0x80000000);
1084   cy = (op1 & (1 << (32 - op0)));
1085
1086   /* Store the result and condition codes.  */
1087   State.regs[OP[1]] = result;
1088   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1089   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1090                 | (cy ? PSW_CY : 0));
1091 }
1092
1093 /* shr zero_extend(imm5),reg1 */
1094 void
1095 OP_280 ()
1096 {
1097   unsigned int op0, op1, result, z, s, cy;
1098
1099   op0 = OP[0] & 0x1f;
1100   op1 = State.regs[OP[1]];
1101   result = op1 >> op0;
1102
1103   /* Compute the condition codes.  */
1104   z = (result == 0);
1105   s = (result & 0x80000000);
1106   cy = (op1 & (1 << (op0 - 1)));
1107
1108   /* Store the result and condition codes.  */
1109   State.regs[OP[1]] = result;
1110   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1111   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1112                 | (cy ? PSW_CY : 0));
1113 }
1114
1115 /* shr reg1, reg2 */
1116 void
1117 OP_8007E0 ()
1118 {
1119   unsigned int op0, op1, result, z, s, cy;
1120
1121   op0 = State.regs[OP[0]] & 0x1f;
1122   op1 = State.regs[OP[1]];
1123   result = op1 >> op0;
1124
1125   /* Compute the condition codes.  */
1126   z = (result == 0);
1127   s = (result & 0x80000000);
1128   cy = (op1 & (1 << (op0 - 1)));
1129
1130   /* Store the result and condition codes.  */
1131   State.regs[OP[1]] = result;
1132   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1133   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1134                 | (cy ? PSW_CY : 0));
1135 }
1136
1137 /* or reg, reg */
1138 void
1139 OP_100 ()
1140 {
1141   unsigned int op0, op1, result, z, s;
1142
1143   /* Compute the result.  */
1144   op0 = State.regs[OP[0]];
1145   op1 = State.regs[OP[1]];
1146   result = op0 | op1;
1147
1148   /* Compute the condition codes.  */
1149   z = (result == 0);
1150   s = (result & 0x80000000);
1151
1152   /* Store the result and condition codes.  */
1153   State.regs[OP[1]] = result;
1154   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV);
1155   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1156 }
1157
1158 /* ori zero_extend(imm16), reg, reg */
1159 void
1160 OP_680 ()
1161 {
1162   unsigned int op0, op1, result, z, s;
1163
1164   op0 = OP[0] & 0xffff;
1165   op1 = State.regs[OP[1]];
1166   result = op0 | op1;
1167
1168   /* Compute the condition codes.  */
1169   z = (result == 0);
1170   s = (result & 0x80000000);
1171
1172   /* Store the result and condition codes.  */
1173   State.regs[OP[2]] = result;
1174   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV);
1175   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1176 }
1177
1178 /* and reg, reg */
1179 void
1180 OP_140 ()
1181 {
1182   unsigned int op0, op1, result, z, s;
1183
1184   /* Compute the result.  */
1185   op0 = State.regs[OP[0]];
1186   op1 = State.regs[OP[1]];
1187   result = op0 & op1;
1188
1189   /* Compute the condition codes.  */
1190   z = (result == 0);
1191   s = (result & 0x80000000);
1192
1193   /* Store the result and condition codes.  */
1194   State.regs[OP[1]] = result;
1195   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV);
1196   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1197 }
1198
1199 /* andi zero_extend(imm16), reg, reg */
1200 void
1201 OP_6C0 ()
1202 {
1203   unsigned int op0, op1, result, z;
1204
1205   op0 = OP[0] & 0xffff;
1206   op1 = State.regs[OP[1]];
1207   result = op0 & op1;
1208
1209   /* Compute the condition codes.  */
1210   z = (result == 0);
1211
1212   /* Store the result and condition codes.  */
1213   State.regs[OP[2]] = result;
1214   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV);
1215   State.sregs[5] |= (z ? PSW_Z : 0);
1216 }
1217
1218 /* xor reg, reg */
1219 void
1220 OP_120 ()
1221 {
1222   unsigned int op0, op1, result, z, s;
1223
1224   /* Compute the result.  */
1225   op0 = State.regs[OP[0]];
1226   op1 = State.regs[OP[1]];
1227   result = op0 ^ op1;
1228
1229   /* Compute the condition codes.  */
1230   z = (result == 0);
1231   s = (result & 0x80000000);
1232
1233   /* Store the result and condition codes.  */
1234   State.regs[OP[1]] = result;
1235   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV);
1236   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1237 }
1238
1239 /* xori zero_extend(imm16), reg, reg */
1240 void
1241 OP_6A0 ()
1242 {
1243   unsigned int op0, op1, result, z, s;
1244
1245   op0 = OP[0] & 0xffff;
1246   op1 = State.regs[OP[1]];
1247   result = op0 ^ op1;
1248
1249   /* Compute the condition codes.  */
1250   z = (result == 0);
1251   s = (result & 0x80000000);
1252
1253   /* Store the result and condition codes.  */
1254   State.regs[OP[2]] = result;
1255   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV);
1256   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1257 }
1258
1259 /* not reg1, reg2 */
1260 void
1261 OP_20 ()
1262 {
1263   unsigned int op0, result, z, s;
1264
1265   /* Compute the result.  */
1266   op0 = State.regs[OP[0]];
1267   result = ~op0;
1268
1269   /* Compute the condition codes.  */
1270   z = (result == 0);
1271   s = (result & 0x80000000);
1272
1273   /* Store the result and condition codes.  */
1274   State.regs[OP[1]] = result;
1275   State.sregs[5] &= ~(PSW_Z | PSW_S | PSW_OV);
1276   State.sregs[5] |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1277 }
1278
1279 /* set1 */
1280 void
1281 OP_7C0 ()
1282 {
1283   unsigned int op0, op1, op2;
1284   int temp;
1285
1286   op0 = State.regs[OP[0]];
1287   op1 = OP[1] & 0x7;
1288   temp = OP[2];
1289   temp = (temp << 16) >> 16;
1290   op2 = temp;
1291   temp = get_byte (State.mem + op0 + op2);
1292   State.sregs[5] &= ~PSW_Z;
1293   if ((temp & (1 << op1)) == 0)
1294     State.sregs[5] |= PSW_Z;
1295   temp |= (1 << op1);
1296   put_byte (State.mem + op0 + op2, temp);
1297 }
1298
1299 /* not1 */
1300 void
1301 OP_47C0 ()
1302 {
1303   unsigned int op0, op1, op2;
1304   int temp;
1305
1306   op0 = State.regs[OP[0]];
1307   op1 = OP[1] & 0x7;
1308   temp = OP[2];
1309   temp = (temp << 16) >> 16;
1310   op2 = temp;
1311   temp = get_byte (State.mem + op0 + op2);
1312   State.sregs[5] &= ~PSW_Z;
1313   if ((temp & (1 << op1)) == 0)
1314     State.sregs[5] |= PSW_Z;
1315   temp ^= (1 << op1);
1316   put_byte (State.mem + op0 + op2, temp);
1317 }
1318
1319 /* clr1 */
1320 void
1321 OP_87C0 ()
1322 {
1323   unsigned int op0, op1, op2;
1324   int temp;
1325
1326   op0 = State.regs[OP[0]];
1327   op1 = OP[1] & 0x7;
1328   temp = OP[2];
1329   temp = (temp << 16) >> 16;
1330   op2 = temp;
1331   temp = get_byte (State.mem + op0 + op2);
1332   State.sregs[5] &= ~PSW_Z;
1333   if ((temp & (1 << op1)) == 0)
1334     State.sregs[5] |= PSW_Z;
1335   temp &= ~(1 << op1);
1336   put_byte (State.mem + op0 + op2, temp);
1337 }
1338
1339 /* tst1 */
1340 void
1341 OP_C7C0 ()
1342 {
1343   unsigned int op0, op1, op2;
1344   int temp;
1345
1346   op0 = State.regs[OP[0]];
1347   op1 = OP[1] & 0x7;
1348   temp = OP[2];
1349   temp = (temp << 16) >> 16;
1350   op2 = temp;
1351   temp = get_byte (State.mem + op0 + op2);
1352   State.sregs[5] &= ~PSW_Z;
1353   if ((temp & (1 << op1)) == 0)
1354     State.sregs[5] |= PSW_Z;
1355 }
1356
1357 /* di */
1358 void
1359 OP_16007E0 ()
1360 {
1361   State.sregs[5] |= PSW_ID;
1362 }
1363
1364 /* ei */
1365 void
1366 OP_16087E0 ()
1367 {
1368   State.sregs[5] &= ~PSW_ID;
1369 }
1370
1371 /* halt, not supported */
1372 void
1373 OP_12007E0 ()
1374 {
1375   State.exception = SIGQUIT;
1376 }
1377
1378 /* reti, not supported */
1379 void
1380 OP_14007E0 ()
1381 {
1382   abort ();
1383 }
1384
1385 /* trap, not supportd */
1386 void
1387 OP_10007E0 ()
1388 {
1389   extern int errno;
1390
1391   /* Trap 0 is used for simulating low-level I/O */
1392
1393   if (OP[0] == 0)
1394     {
1395       int save_errno = errno;
1396       errno = 0;
1397
1398 /* Registers passed to trap 0 */
1399
1400 #define FUNC   State.regs[6]    /* function number, return value */
1401 #define PARM1  State.regs[7]    /* optional parm 1 */
1402 #define PARM2  State.regs[8]    /* optional parm 2 */
1403 #define PARM3  State.regs[9]    /* optional parm 3 */
1404
1405 /* Registers set by trap 0 */
1406
1407 #define RETVAL State.regs[10]   /* return value */
1408 #define RETERR State.regs[11]   /* return error code */
1409
1410 /* Turn a pointer in a register into a pointer into real memory. */
1411
1412 #define MEMPTR(x) ((char *)((x) + State.mem))
1413
1414
1415       switch (FUNC)
1416         {
1417 #if !defined(__GO32__) && !defined(_WIN32)
1418         case SYS_fork:
1419           RETVAL = fork ();
1420           break;
1421         case SYS_execve:
1422           RETVAL = execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2),
1423                            (char **)MEMPTR (PARM3));
1424           break;
1425         case SYS_execv:
1426           RETVAL = execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2), NULL);
1427           break;
1428 #if 0
1429         case SYS_pipe:
1430           {
1431             reg_t buf;
1432             int host_fd[2];
1433
1434             buf = PARM1;
1435             RETVAL = pipe (host_fd);
1436             SW (buf, host_fd[0]);
1437             buf += sizeof(uint16);
1438             SW (buf, host_fd[1]);
1439           }
1440           break;
1441
1442         case SYS_wait:
1443           {
1444             int status;
1445
1446             RETVAL = wait (&status);
1447             SW (PARM1, status);
1448           }
1449           break;
1450 #endif
1451 #endif
1452
1453         case SYS_read:
1454           RETVAL = v850_callback->read (v850_callback, PARM1, MEMPTR (PARM2),
1455                                         PARM3);
1456           break;
1457         case SYS_write:
1458           if (PARM1 == 1)
1459             RETVAL = (int)v850_callback->write_stdout (v850_callback,
1460                                                        MEMPTR (PARM2), PARM3);
1461           else
1462             RETVAL = (int)v850_callback->write (v850_callback, PARM1,
1463                                                 MEMPTR (PARM2), PARM3);
1464           break;
1465         case SYS_lseek:
1466           RETVAL = v850_callback->lseek (v850_callback, PARM1, PARM2, PARM3);
1467           break;
1468         case SYS_close:
1469           RETVAL = v850_callback->close (v850_callback, PARM1);
1470           break;
1471         case SYS_open:
1472           RETVAL = v850_callback->open (v850_callback, MEMPTR (PARM1), PARM2);
1473           break;
1474         case SYS_exit:
1475           /* EXIT - caller can look in PARM1 to work out the
1476              reason */
1477           if (PARM1 == 0xdead || PARM1 == 0x1)
1478             State.exception = SIGABRT;
1479           else
1480             State.exception = SIGQUIT;
1481           break;
1482
1483 #if 0
1484         case SYS_stat:  /* added at hmsi */
1485           /* stat system call */
1486           {
1487             struct stat host_stat;
1488             reg_t buf;
1489
1490             RETVAL = stat (MEMPTR (PARM1), &host_stat);
1491
1492             buf = PARM2;
1493
1494             /* The hard-coded offsets and sizes were determined by using
1495              * the D10V compiler on a test program that used struct stat.
1496              */
1497             SW  (buf,    host_stat.st_dev);
1498             SW  (buf+2,  host_stat.st_ino);
1499             SW  (buf+4,  host_stat.st_mode);
1500             SW  (buf+6,  host_stat.st_nlink);
1501             SW  (buf+8,  host_stat.st_uid);
1502             SW  (buf+10, host_stat.st_gid);
1503             SW  (buf+12, host_stat.st_rdev);
1504             SLW (buf+16, host_stat.st_size);
1505             SLW (buf+20, host_stat.st_atime);
1506             SLW (buf+28, host_stat.st_mtime);
1507             SLW (buf+36, host_stat.st_ctime);
1508           }
1509 #endif
1510           break;
1511
1512         case SYS_chown:
1513           RETVAL = chown (MEMPTR (PARM1), PARM2, PARM3);
1514           break;
1515         case SYS_chmod:
1516           RETVAL = chmod (MEMPTR (PARM1), PARM2);
1517           break;
1518         case SYS_utime:
1519           /* Cast the second argument to void *, to avoid type mismatch
1520              if a prototype is present.  */
1521           RETVAL = utime (MEMPTR (PARM1), (void *) MEMPTR (PARM2));
1522           break;
1523         default:
1524           abort ();
1525         }
1526       RETERR = errno;
1527       errno = save_errno;
1528     }
1529   else if (OP[0] == 1 )
1530     {
1531       char *fstr = State.regs[2] + State.mem;
1532       puts (fstr);
1533     }
1534 }
1535
1536 /* ldsr, reg,reg */
1537 void
1538 OP_2007E0 ()
1539 {
1540   unsigned int op0;
1541
1542   op0 = State.regs[OP[0]];
1543   State.sregs[OP[1]] = op0;
1544 }
1545
1546 /* stsr, not supported */
1547 void
1548 OP_4007E0 ()
1549 {
1550   unsigned int op0;
1551
1552   op0 = State.sregs[OP[1]];
1553   State.regs[OP[0]] = op0;
1554 }
1555