sim/v850/simops.c

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