sim/mips/vr.igen

   1 // -*- C -*-
   2 //
   3 // NEC specific instructions
   4 //
   5
   6 // Integer Instructions
   7 // --------------------
   8 //
   9 // MulAcc is the Multiply Accumulator.
  10 //     This register is mapped on the the HI and LO registers.
  11 //     Upper 32 bits of MulAcc is mapped on to lower 32 bits of HI register.
  12 //     Lower 32 bits of MulAcc is mapped on to lower 32 bits of LO register.
  13
  14
  15 :function:::unsigned64:MulAcc:
  16 {
  17   unsigned64 result = U8_4 (HI, LO);
  18   return result;
  19 }
  20
  21 :function:::void:SET_MulAcc:unsigned64 value
  22 {
  23   *AL4_8 (&HI) = VH4_8 (value);
  24   *AL4_8 (&LO) = VL4_8 (value);
  25 }
  26
  27 :function:::signed64:SignedMultiply:signed32 l, signed32 r
  28 {
  29   signed64 result = (signed64) l * (signed64) r;
  30   return result;
  31 }
  32
  33 :function:::unsigned64:UnsignedMultiply:unsigned32 l, unsigned32 r
  34 {
  35   unsigned64 result = (unsigned64) l * (unsigned64) r;
  36   return result;
  37 }
  38
  39 :function:::unsigned64:Low32Bits:unsigned64 value
  40 {
  41   unsigned64 result = (signed64) (signed32) VL4_8 (value);
  42   return result;
  43 }
  44
  45 :function:::unsigned64:High32Bits:unsigned64 value
  46 {
  47   unsigned64 result = (signed64) (signed32) VH4_8 (value);
  48   return result;
  49 }
  50
  51
  52
  53 // Multiply, Accumulate
  54 000000,5.RS,5.RT,00000,00000,101000::::MAC
  55 "mac r<RS>, r<RT>"
  56 *vr4100:
  57 // start-sanitize-vr4320
  58 *vr4320:
  59 // end-sanitize-vr4320
  60 {
  61   SET_MulAcc (SD_, MulAcc (SD_) + SignedMultiply (SD_, GPR[RS], GPR[RT]));
  62 }
  63
  64
  65 // D-Multiply, Accumulate
  66 000000,5.RS,5.RT,00000,00000,101001::::DMAC
  67 "dmac r<RS>, r<RT>"
  68 *vr4100:
  69 // start-sanitize-vr4320
  70 *vr4320:
  71 // end-sanitize-vr4320
  72 {
  73   LO = LO + SignedMultiply (SD_, GPR[RS], GPR[RT]);
  74 }
  75
  76
  77 // start-sanitize-vr4320
  78 // Count Leading Zeros
  79 000000,5.RS,00000,5.RD,00000,110101::::CLZ
  80 "clz r<RD>, r<RS>"
  81 // end-sanitize-vr4320
  82 // start-sanitize-vr4320
  83 *vr4320:
  84 // end-sanitize-vr4320
  85 // start-sanitize-vr4320
  86 {
  87   unsigned32 t = Low32Bits (SD_, GPR[RS]);
  88   signed64 c = 0;
  89
  90   while (! (t & ( 1 << 31))
  91         && c < 32)
  92     {
  93     c++;
  94     t <<= 1;
  95     }
  96
  97   GPR[RD] = c;
  98 }
  99
 100
 101 // end-sanitize-vr4320
 102 // start-sanitize-vr4320
 103 // D-Count Leading Zeros
 104 000000,5.RS,00000,5.RD,00000,111101::::DCLZ
 105 "dclz r<RD>, r<RS>"
 106 // end-sanitize-vr4320
 107 // start-sanitize-vr4320
 108 *vr4320:
 109 // end-sanitize-vr4320
 110 // start-sanitize-vr4320
 111 {
 112   unsigned64 t = GPR[RS];
 113   signed64 c = 0;
 114
 115   while (! (t & ( (unsigned64)1 << 63))
 116         && c < 64)
 117     {
 118     c++;
 119     t <<= 1;
 120     }
 121
 122   printf("lo %d\n", (int) c);
 123   GPR[RD] = c;
 124 }
 125
 126
 127
 128
 129
 130
 131
 132 // end-sanitize-vr4320
 133 // start-sanitize-vrXXXX
 134 // Multiply and Move LO.
 135 000000,5.RS,5.RT,5.RD,00100,101000::::MUL
 136 "mul r<RD>, r<RS>, r<RT>"
 137 // end-sanitize-vrXXXX
 138 // start-sanitize-vr4320
 139 *vr4320:
 140 // end-sanitize-vr4320
 141 // start-sanitze-vr5400
 142 *vr5400:
 143 // end-sanitze-vr5400
 144 // start-sanitize-vrXXXX
 145 {
 146   SET_MulAcc (SD_, 0 + SignedMultiply (SD_, GPR[RS], GPR[RT]));
 147   GPR[RD] = Low32Bits (SD_, MulAcc (SD_));
 148 }
 149
 150
 151 // end-sanitize-vrXXXX
 152 // start-sanitize-vrXXXX
 153 // Unsigned Multiply and Move LO.
 154 000000,5.RS,5.RT,5.RD,00101,101000::::MULU
 155 "mulu r<RD>, r<RS>, r<RT>"
 156 // end-sanitize-vrXXXX
 157 // start-sanitize-vr4320
 158 *vr4320:
 159 // end-sanitize-vr4320
 160 // start-sanitze-vr5400
 161 *vr5400:
 162 // end-sanitze-vr5400
 163 // start-sanitize-vrXXXX
 164 {
 165   SET_MulAcc (SD_, 0 + UnsignedMultiply (SD_, GPR[RS], GPR[RT]));
 166   GPR[RD] = Low32Bits  (SD_, MulAcc (SD_));
 167 }
 168
 169
 170 // end-sanitize-vrXXXX
 171 // start-sanitize-vrXXXX
 172 // Multiply and Move HI.
 173 000000,5.RS,5.RT,5.RD,01100,101000::::MULHI
 174 "mulhi r<RD>, r<RS>, r<RT>"
 175 // end-sanitize-vrXXXX
 176 // start-sanitize-vr4320
 177 *vr4320:
 178 // end-sanitize-vr4320
 179 // start-sanitze-vr5400
 180 *vr5400:
 181 // end-sanitze-vr5400
 182 // start-sanitize-vrXXXX
 183 {
 184   SET_MulAcc (SD_, 0 + SignedMultiply (SD_, GPR[RS], GPR[RT]));
 185   GPR[RD] = High32Bits (SD_, MulAcc (SD_));
 186 }
 187
 188
 189 // end-sanitize-vrXXXX
 190 // start-sanitize-vrXXXX
 191 // Unsigned Multiply and Move HI.
 192 000000,5.RS,5.RT,5.RD,01101,101000::::MULHIU
 193 "mulhiu r<RD>, r<RS>, r<RT>"
 194 // end-sanitize-vrXXXX
 195 // start-sanitize-vr4320
 196 *vr4320:
 197 // end-sanitize-vr4320
 198 // start-sanitze-vr5400
 199 *vr5400:
 200 // end-sanitze-vr5400
 201 // start-sanitize-vrXXXX
 202 {
 203   SET_MulAcc (SD_, 0 + UnsignedMultiply (SD_, GPR[RS], GPR[RT]));
 204   GPR[RD] = High32Bits (SD_, MulAcc (SD_));
 205 }
 206
 207
 208 // end-sanitize-vrXXXX
 209 // start-sanitze-vr5400
 210 // Multiply, Negate and Move LO.
 211 000000,5.RS,5.RT,5.RD,00011,011000::::MULS
 212 "muls r<RD>, r<RS>, r<RT>"
 213 // end-sanitze-vr5400
 214 // start-sanitze-vr5400
 215 *vr5400:
 216 // end-sanitze-vr5400
 217 // start-sanitze-vr5400
 218 {
 219   SET_MulAcc (SD_, 0 - SignedMultiply   (SD_, GPR[RS], GPR[RT]));
 220   GPR[RD] = Low32Bits  (SD_, MulAcc (SD_));
 221 }
 222
 223
 224 // end-sanitze-vr5400
 225 // start-sanitze-vr5400
 226 // Unsigned Multiply, Negate and Move LO.
 227 000000,5.RS,5.RT,5.RD,00011,011001::::MULSU
 228 "mulsu r<RD>, r<RS>, r<RT>"
 229 // end-sanitze-vr5400
 230 // start-sanitze-vr5400
 231 *vr5400:
 232 // end-sanitze-vr5400
 233 // start-sanitze-vr5400
 234 {
 235   SET_MulAcc (SD_, 0 - UnsignedMultiply (SD_, GPR[RS], GPR[RT]));
 236   GPR[RD] = Low32Bits  (SD_, MulAcc (SD_));
 237 }
 238
 239
 240 // end-sanitze-vr5400
 241 // start-sanitze-vr5400
 242 // Multiply, Negate and Move HI.
 243 000000,5.RS,5.RT,5.RD,01011,011000::::MULSHI
 244 "mulshi r<RD>, r<RS>, r<RT>"
 245 // end-sanitze-vr5400
 246 // start-sanitze-vr5400
 247 *vr5400:
 248 // end-sanitze-vr5400
 249 // start-sanitze-vr5400
 250 {
 251   SET_MulAcc (SD_, 0 - SignedMultiply   (SD_, GPR[RS], GPR[RT]));
 252   GPR[RD] = High32Bits (SD_, MulAcc (SD_));
 253 }
 254
 255
 256 // end-sanitze-vr5400
 257 // start-sanitze-vr5400
 258 // Unsigned Multiply, Negate and Move HI.
 259 000000,5.RS,5.RT,5.RD,01011,011001::::MULSHIU
 260 "mulshiu r<RD>, r<RS>, r<RT>"
 261 // end-sanitze-vr5400
 262 // start-sanitze-vr5400
 263 *vr5400:
 264 // end-sanitze-vr5400
 265 // start-sanitze-vr5400
 266 {
 267   SET_MulAcc (SD_, 0 - UnsignedMultiply (SD_, GPR[RS], GPR[RT]));
 268   GPR[RD] = High32Bits (SD_, MulAcc (SD_));
 269 }
 270
 271
 272
 273
 274
 275 // end-sanitze-vr5400
 276 // Multiply, Accumulate and Move LO.
 277 000000,5.RS,5.RT,5.RD,00010,101000::::MACC
 278 "macc r<RD>, r<RS>, r<RT>"
 279 // start-sanitize-vr4320
 280 *vr4320:
 281 // end-sanitize-vr4320
 282 // start-sanitze-vr5400
 283 *vr5400:
 284 // end-sanitze-vr5400
 285 {
 286   SET_MulAcc (SD_, MulAcc (SD_) + SignedMultiply (SD_, GPR[RS], GPR[RT]));
 287   GPR[RD] = Low32Bits  (SD_, MulAcc (SD_));
 288 }
 289
 290
 291 // end-sanitize-vr4320
 292 // start-sanitize-vrXXXX
 293 // Unsigned Multiply, Accumulate and Move LO.
 294 000000,5.RS,5.RT,5.RD,00011,101000::::MACCU
 295 "maccu r<RD>, r<RS>, r<RT>"
 296 // end-sanitize-vrXXXX
 297 // start-sanitize-vr4320
 298 *vr4320:
 299 // end-sanitize-vr4320
 300 // start-sanitze-vr5400
 301 *vr5400:
 302 // end-sanitze-vr5400
 303 // start-sanitize-vrXXXX
 304 {
 305   SET_MulAcc (SD_, MulAcc (SD_) + UnsignedMultiply (SD_, GPR[RS], GPR[RT]));
 306   GPR[RD] = Low32Bits  (SD_, MulAcc (SD_));
 307 }
 308
 309
 310 // end-sanitize-vrXXXX
 311 // start-sanitize-vrXXXX
 312 // Multiply, Accumulate and Move HI.
 313 000000,5.RS,5.RT,5.RD,01010,101000::::MACCHI
 314 "macchi r<RD>, r<RS>, r<RT>"
 315 // end-sanitize-vrXXXX
 316 // start-sanitize-vr4320
 317 *vr4320:
 318 // end-sanitize-vr4320
 319 // start-sanitze-vr5400
 320 *vr5400:
 321 // end-sanitze-vr5400
 322 // start-sanitize-vrXXXX
 323 {
 324   SET_MulAcc (SD_, MulAcc (SD_) + SignedMultiply (SD_, GPR[RS], GPR[RT]));
 325   GPR[RD] = High32Bits (SD_, MulAcc (SD_));
 326 }
 327
 328
 329 // end-sanitize-vrXXXX
 330 // start-sanitize-vrXXXX
 331 // Unsigned Multiply, Accumulate and Move HI.
 332 000000,5.RS,5.RT,5.RD,01011,101000::::MACCHIU
 333 "macchiu r<RD>, r<RS>, r<RT>"
 334 // start-sanitize-vr4320
 335 *vr4320:
 336 // end-sanitize-vr4320
 337 // start-sanitze-vr5400
 338 *vr5400:
 339 // end-sanitze-vr5400
 340 {
 341   SET_MulAcc (SD_, MulAcc (SD_) + UnsignedMultiply (SD_, GPR[RS], GPR[RT]));
 342   GPR[RD] = High32Bits (SD_, MulAcc (SD_));
 343
 344 }
 345
 346
 347
 348 // end-sanitize-vrXXXX
 349 // start-sanitize-vr5400
 350 // Multiply, Negate, Accumulate and Move LO.
 351 000000,5.RS,5.RT,5.RD,00111,011000::::MSAC
 352 "msac r<RD>, r<RS>, r<RT>"
 353 // end-sanitize-vr5400
 354 // start-sanitize-vr5400
 355 *vr5400:
 356 // end-sanitize-vr5400
 357 // start-sanitize-vr5400
 358 {
 359   SET_MulAcc (SD_, MulAcc (SD_) - SignedMultiply (SD_, GPR[RS], GPR[RT]));
 360   GPR[RD] = Low32Bits  (SD_, MulAcc (SD_));
 361 }
 362
 363
 364 // end-sanitize-vr5400
 365 // start-sanitize-vr5400
 366 // Unsigned Multiply, Negate, Accumulate and Move LO.
 367 000000,5.RS,5.RT,5.RD,00111,011001::::MSACU
 368 "msacu r<RD>, r<RS>, r<RT>"
 369 // end-sanitize-vr5400
 370 // start-sanitize-vr5400
 371 *vr5400:
 372 // end-sanitize-vr5400
 373 // start-sanitize-vr5400
 374 {
 375   SET_MulAcc (SD_, MulAcc (SD_) - UnsignedMultiply (SD_, GPR[RS], GPR[RT]));
 376   GPR[RD] = Low32Bits  (SD_, MulAcc (SD_));
 377 }
 378
 379
 380 // end-sanitize-vr5400
 381 // start-sanitize-vr5400
 382 // Multiply, Negate, Accumulate and Move HI.
 383 000000,5.RS,5.RT,5.RD,01111,011000::::MSACHI
 384 "msachi r<RD>, r<RS>, r<RT>"
 385 // end-sanitize-vr5400
 386 // start-sanitize-vr5400
 387 *vr5400:
 388 // end-sanitize-vr5400
 389 // start-sanitize-vr5400
 390 {
 391   SET_MulAcc (SD_, MulAcc (SD_) - SignedMultiply (SD_, GPR[RS], GPR[RT]));
 392   GPR[RD] = High32Bits (SD_, MulAcc (SD_));
 393 }
 394
 395 // end-sanitize-vr5400
 396 // start-sanitize-vr5400
 397 // Unsigned Multiply, Negate, Accumulate and Move HI.
 398 000000,5.RS,5.RT,5.RD,01111,011001::::MSACHIU
 399 "msachiu r<RD>, r<RS>, r<RT>"
 400 // end-sanitize-vr5400
 401 // start-sanitize-vr5400
 402 *vr5400:
 403 // end-sanitize-vr5400
 404 // start-sanitize-vr5400
 405 {
 406   SET_MulAcc (SD_, MulAcc (SD_) - UnsignedMultiply (SD_, GPR[RS], GPR[RT]));
 407   GPR[RD] = High32Bits (SD_, MulAcc (SD_));
 408 }
 409
 410
 411 // end-sanitize-vr5400
 412 // start-sanitize-vr5400
 413 // Rotate Right.
 414 000000,00001,5.RT,5.RD,5.SHIFT,000010::::ROR
 415 "ror r<RD>, r<RT>, <SHIFT>"
 416 // end-sanitize-vr5400
 417 // start-sanitize-vr5400
 418 *vr5400:
 419 // end-sanitize-vr5400
 420 // start-sanitize-vr5400
 421 {
 422   int s = SHIFT;
 423   GPR[RD] = ROTR32 (GPR[RT], s);
 424 }
 425
 426
 427 // end-sanitize-vr5400
 428 // start-sanitize-vr5400
 429 // Rotate Right Variable.
 430 000000,5.RS,5.RT,5.RD,00001,000110::::RORV
 431 "rorv r<RD>, r<RT>, <RS>"
 432 // end-sanitize-vr5400
 433 // start-sanitize-vr5400
 434 *vr5400:
 435 // end-sanitize-vr5400
 436 // start-sanitize-vr5400
 437 {
 438   int s = MASKED (GPR[RS], 4, 0);
 439   GPR[RD] = ROTR32 (GPR[RT], s);
 440 }
 441
 442
 443 // end-sanitize-vr5400
 444 // start-sanitize-vr5400
 445 // Double Rotate Right.
 446 000000,00001,5.RT,5.RD,5.SHIFT,111010::::DROR
 447 "dror r<RD>, r<RT>, <SHIFT>"
 448 // end-sanitize-vr5400
 449 // start-sanitize-vr5400
 450 *vr5400:
 451 // end-sanitize-vr5400
 452 // start-sanitize-vr5400
 453 {
 454   int s = SHIFT;
 455   GPR[RD] = ROTR64 (GPR[RT], s);
 456 }
 457
 458
 459 // end-sanitize-vr5400
 460 // start-sanitize-vr5400
 461 // Double Rotate Right Plus 32.
 462 000000,00001,5.RT,5.RD,5.SHIFT,111110::::DROR32
 463 "dror32 r<RD>, r<RT>, <SHIFT>"
 464 // end-sanitize-vr5400
 465 // start-sanitize-vr5400
 466 *vr5400:
 467 // end-sanitize-vr5400
 468 // start-sanitize-vr5400
 469 {
 470   int s = SHIFT + 32;
 471   GPR[RD] = ROTR64 (GPR[RT], s);
 472 }
 473
 474
 475 // end-sanitize-vr5400
 476 // start-sanitize-vr5400
 477 // Double Rotate Right Variable.
 478 000000,5.RS,5.RT,5.RD,00001,010110::::DRORV
 479 "drorv r<RD>, r<RT>, <RS>"
 480 // end-sanitize-vr5400
 481 // start-sanitize-vr5400
 482 *vr5400:
 483 // end-sanitize-vr5400
 484 // start-sanitize-vr5400
 485 {
 486   int s = MASKED (GPR[RS], 5, 0);
 487   GPR[RD] = ROTR64 (GPR[RT], s);
 488 }
 489
 490
 491 // end-sanitize-vr5400