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