sim/v850/simops.c

   1 #include <signal.h>
   2 #include "v850_sim.h"
   3 #include "simops.h"
   4
   5 void
   6 OP_220 ()
   7 {
   8 }
   9
  10 void
  11 OP_10760 ()
  12 {
  13 }
  14
  15 void
  16 OP_C7C0 ()
  17 {
  18 }
  19
  20 void
  21 OP_760 ()
  22 {
  23 }
  24
  25 void
  26 OP_580 ()
  27 {
  28 }
  29
  30 void
  31 OP_700 ()
  32 {
  33 }
  34
  35 void
  36 OP_581 ()
  37 {
  38 }
  39
  40 void
  41 OP_582 ()
  42 {
  43 }
  44
  45 void
  46 OP_583 ()
  47 {
  48 }
  49
  50 void
  51 OP_584 ()
  52 {
  53 }
  54
  55 void
  56 OP_585 ()
  57 {
  58 }
  59
  60 void
  61 OP_586 ()
  62 {
  63 }
  64
  65 void
  66 OP_587 ()
  67 {
  68 }
  69
  70 void
  71 OP_588 ()
  72 {
  73 }
  74
  75 void
  76 OP_589 ()
  77 {
  78 }
  79
  80 void
  81 OP_58A ()
  82 {
  83 }
  84
  85 void
  86 OP_58B ()
  87 {
  88 }
  89
  90 void
  91 OP_58C ()
  92 {
  93 }
  94
  95 void
  96 OP_400 ()
  97 {
  98 }
  99
 100 void
 101 OP_160 ()
 102 {
 103 }
 104
 105 void
 106 OP_58D ()
 107 {
 108 }
 109
 110 void
 111 OP_58E ()
 112 {
 113 }
 114
 115 void
 116 OP_58F ()
 117 {
 118 }
 119
 120 void
 121 OP_660 ()
 122 {
 123 }
 124
 125
 126 /* add reg, reg
 127
 128    XXX condition codes.  */
 129 void
 130 OP_1C0 ()
 131 {
 132   State.regs[OP[1]] += State.regs[OP[0]];
 133 }
 134
 135 /* add sign_extend(imm5), reg
 136
 137    XXX condition codes.  */
 138 void
 139 OP_240 ()
 140 {
 141   int value = OP[0];
 142
 143   value = (value << 27) >> 27;
 144
 145   State.regs[OP[1]] += value;
 146 }
 147
 148 /* addi sign_extend(imm16), reg, reg
 149
 150    XXX condition codes.  */
 151 void
 152 OP_600 ()
 153 {
 154   int value = OP[0];
 155
 156   value = (value << 16) >> 16;
 157
 158   State.regs[OP[2]] = State.regs[OP[1]] + value;
 159 }
 160
 161 /* sub reg1, reg2
 162
 163    XXX condition codes  */
 164 void
 165 OP_1A0 ()
 166 {
 167   State.regs[OP[1]] -= State.regs[OP[0]];
 168 }
 169
 170 /* subr reg1, reg2
 171
 172    XXX condition codes */
 173 void
 174 OP_180 ()
 175 {
 176   State.regs[OP[1]] = State.regs[OP[0]] - State.regs[OP[1]];
 177 }
 178
 179 /* mulh reg1, reg2
 180
 181    XXX condition codes */
 182 void
 183 OP_E0 ()
 184 {
 185   State.regs[OP[1]] = ((State.regs[OP[1]] & 0xffff)
 186                        * (State.regs[OP[0]] & 0xffff));
 187 }
 188
 189 /* mulh sign_extend(imm5), reg2
 190
 191    Condition codes */
 192 void
 193 OP_2E0 ()
 194 {
 195   int value = OP[0];
 196
 197   value = (value << 27) >> 27;
 198
 199   State.regs[OP[1]] = (State.regs[OP[1]] & 0xffff) * value;
 200 }
 201
 202 /* mulhi imm16, reg1, reg2
 203
 204    XXX condition codes */
 205 void
 206 OP_6E0 ()
 207 {
 208   int value = OP[0];
 209
 210   value = value & 0xffff;
 211
 212   State.regs[OP[2]] = (State.regs[OP[1]] & 0xffff) * value;
 213 }
 214
 215 /* divh reg1, reg2
 216
 217    XXX condition codes.
 218    XXX Is this signed or unsigned?  */
 219 void
 220 OP_40 ()
 221 {
 222   State.regs[OP[1]] /= (State.regs[OP[0]] & 0xffff);
 223 }
 224
 225 void
 226 OP_10720 ()
 227 {
 228 }
 229
 230 void
 231 OP_780 ()
 232 {
 233 }
 234
 235 void
 236 OP_720 ()
 237 {
 238 }
 239
 240 void
 241 OP_60 ()
 242 {
 243 }
 244
 245 void
 246 OP_87C0 ()
 247 {
 248 }
 249
 250 void
 251 OP_300 ()
 252 {
 253 }
 254
 255 /* mov reg, reg */
 256 void
 257 OP_0 ()
 258 {
 259   State.regs[OP[1]] = State.regs[OP[0]];
 260 }
 261
 262 /* mov sign_extend(imm5), reg */
 263 void
 264 OP_200 ()
 265 {
 266   int value = OP[0];
 267
 268   value = (value << 27) >> 27;
 269   State.regs[OP[1]] = value;
 270 }
 271
 272 /* movea sign_extend(imm16), reg, reg  */
 273
 274 void
 275 OP_620 ()
 276 {
 277   int value = OP[0];
 278
 279   value = (value << 16) >> 16;
 280
 281   State.regs[OP[2]] = State.regs[OP[1]] + value;
 282 }
 283
 284 /* movhi imm16, reg, reg */
 285 void
 286 OP_640 ()
 287 {
 288   int value = OP[0];
 289
 290   value = (value & 0xffff) << 16;
 291
 292   State.regs[OP[2]] = State.regs[OP[1]] + value;
 293 }
 294
 295 void
 296 OP_7C0 ()
 297 {
 298 }
 299
 300 void
 301 OP_1687E0 ()
 302 {
 303 }
 304
 305 void
 306 OP_1E0 ()
 307 {
 308 }
 309
 310 void
 311 OP_A0 ()
 312 {
 313 }
 314
 315 void
 316 OP_260 ()
 317 {
 318 }
 319
 320 void
 321 OP_740 ()
 322 {
 323 }
 324
 325 void
 326 OP_80 ()
 327 {
 328 }
 329
 330 /* not reg1, reg2
 331
 332    XXX condition codes */
 333 void
 334 OP_20 ()
 335 {
 336   State.regs[OP[1]] = ~State.regs[OP[0]];
 337 }
 338
 339 /* sar zero_extend(imm5),reg1
 340
 341    XXX condition codes.  */
 342 void
 343 OP_2A0 ()
 344 {
 345   int temp = State.regs[OP[1]];
 346
 347   temp >>= (OP[0] & 0x1f);
 348
 349   State.regs[OP[1]] = temp;
 350 }
 351
 352 /* sar reg1, reg2
 353
 354    XXX condition codes.  */
 355 void
 356 OP_A007E0 ()
 357 {
 358   int temp = State.regs[OP[1]];
 359
 360   temp >>= (State.regs[OP[0]] & 0x1f);
 361
 362   State.regs[OP[1]] = temp;
 363 }
 364
 365 /* shl zero_extend(imm5),reg1
 366
 367    XXX condition codes.  */
 368 void
 369 OP_2C0 ()
 370 {
 371   State.regs[OP[1]] <<= (OP[0] & 0x1f);
 372 }
 373
 374 /* shl reg1, reg2
 375
 376    XXX condition codes.  */
 377 void
 378 OP_C007E0 ()
 379 {
 380   State.regs[OP[1]] <<= (State.regs[OP[0]] & 0x1f);
 381 }
 382
 383 /* shr zero_extend(imm5),reg1
 384
 385    XXX condition codes.  */
 386 void
 387 OP_280 ()
 388 {
 389   State.regs[OP[1]] >>= (OP[0] & 0x1f);
 390 }
 391
 392 /* shr reg1, reg2
 393
 394    XXX condition codes.  */
 395 void
 396 OP_8007E0 ()
 397 {
 398   State.regs[OP[1]] >>= (State.regs[OP[0]] & 0x1f);
 399 }
 400
 401 void
 402 OP_500 ()
 403 {
 404 }
 405
 406 void
 407 OP_47C0 ()
 408 {
 409 }
 410
 411 void
 412 OP_7E0 ()
 413 {
 414 }
 415
 416 /* or reg, reg
 417
 418    XXX condition codes.  */
 419 void
 420 OP_100 ()
 421 {
 422   State.regs[OP[1]] |= State.regs[OP[0]];
 423 }
 424
 425 /* ori zero_extend(imm16), reg, reg
 426
 427    XXX condition codes */
 428 void
 429 OP_680 ()
 430 {
 431   int value = OP[0];
 432
 433   value &= 0xffff;
 434
 435   State.regs[OP[2]] = State.regs[OP[1]] | value;
 436 }
 437
 438 /* and reg, reg
 439
 440    XXX condition codes.  */
 441 void
 442 OP_140 ()
 443 {
 444   State.regs[OP[1]] &= State.regs[OP[0]];
 445 }
 446
 447 /* andi zero_extend(imm16), reg, reg
 448
 449    XXX condition codes.  */
 450 void
 451 OP_6C0 ()
 452 {
 453   int value = OP[0];
 454
 455   value &= 0xffff;
 456
 457   State.regs[OP[2]] = State.regs[OP[1]] & value;
 458 }
 459
 460 /* xor reg, reg
 461
 462    XXX condition codes.  */
 463 void
 464 OP_120 ()
 465 {
 466   State.regs[OP[1]] ^= State.regs[OP[0]];
 467 }
 468
 469 /* xori zero_extend(imm16), reg, reg
 470
 471    XXX condition codes.  */
 472 void
 473 OP_6A0 ()
 474 {
 475   int value = OP[0];
 476
 477   value &= 0xffff;
 478
 479   State.regs[OP[2]] = State.regs[OP[1]] ^ value;
 480 }
 481
 482 void
 483 OP_C0 ()
 484 {
 485 }
 486
 487 void
 488 OP_480 ()
 489 {
 490 }
 491
 492 void
 493 OP_380 ()
 494 {
 495 }
 496
 497 void
 498 OP_501 ()
 499 {
 500 }
 501
 502 /* di, not supported */
 503 void
 504 OP_16007E0 ()
 505 {
 506   abort ();
 507 }
 508
 509 /* ei, not supported */
 510 void
 511 OP_16087E0 ()
 512 {
 513   abort ();
 514 }
 515
 516 /* halt, not supported */
 517 void
 518 OP_12007E0 ()
 519 {
 520   abort ();
 521 }
 522
 523 /* reti, not supported */
 524 void
 525 OP_14007E0 ()
 526 {
 527   abort ();
 528 }
 529
 530 /* trap, not supportd */
 531 void
 532 OP_10007E0 ()
 533 {
 534   abort ();
 535 }
 536
 537 /* ldsr, not supported */
 538 void
 539 OP_2007E0 ()
 540 {
 541   abort ();
 542 }
 543
 544 /* stsr, not supported */
 545 void
 546 OP_4007E0 ()
 547 {
 548   abort ();
 549 }
 550