lib/Target/Hexagon/HexagonImmediates.td

   1 //===- HexagonImmediates.td - Hexagon immediate processing -*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illnois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // From IA64's InstrInfo file
  11 def s32Imm : Operand<i32> {
  12   // For now, we use a generic print function for all operands.
  13   let PrintMethod = "printImmOperand";
  14 }
  15
  16 // f32Ext type is used to identify constant extended floating point
  17 // Immediate operands.
  18 def f32Ext : Operand<f32> {
  19   let PrintMethod = "printImmOperand";
  20 }
  21
  22 def s16Imm : Operand<i32> {
  23   let PrintMethod = "printImmOperand";
  24 }
  25
  26 def s12Imm : Operand<i32> {
  27   // For now, we use a generic print function for all operands.
  28   let PrintMethod = "printImmOperand";
  29 }
  30
  31 def s11Imm : Operand<i32> {
  32   // For now, we use a generic print function for all operands.
  33   let PrintMethod = "printImmOperand";
  34 }
  35
  36 def s11_0Imm : Operand<i32> {
  37   // For now, we use a generic print function for all operands.
  38   let PrintMethod = "printImmOperand";
  39 }
  40
  41 def s11_1Imm : Operand<i32> {
  42   // For now, we use a generic print function for all operands.
  43   let PrintMethod = "printImmOperand";
  44 }
  45
  46 def s11_2Imm : Operand<i32> {
  47   // For now, we use a generic print function for all operands.
  48   let PrintMethod = "printImmOperand";
  49 }
  50
  51 def s11_3Imm : Operand<i32> {
  52   // For now, we use a generic print function for all operands.
  53   let PrintMethod = "printImmOperand";
  54 }
  55
  56 def s10Imm : Operand<i32> {
  57   // For now, we use a generic print function for all operands.
  58   let PrintMethod = "printImmOperand";
  59 }
  60
  61 def s9Imm : Operand<i32> {
  62   // For now, we use a generic print function for all operands.
  63   let PrintMethod = "printImmOperand";
  64 }
  65
  66 def s8Imm : Operand<i32> {
  67   // For now, we use a generic print function for all operands.
  68   let PrintMethod = "printImmOperand";
  69 }
  70
  71 def s8Imm64 : Operand<i64> {
  72   // For now, we use a generic print function for all operands.
  73   let PrintMethod = "printImmOperand";
  74 }
  75
  76 def s6Imm : Operand<i32> {
  77   // For now, we use a generic print function for all operands.
  78   let PrintMethod = "printImmOperand";
  79 }
  80
  81 def s4Imm : Operand<i32> {
  82   // For now, we use a generic print function for all operands.
  83   let PrintMethod = "printImmOperand";
  84 }
  85
  86 def s4_0Imm : Operand<i32> {
  87   // For now, we use a generic print function for all operands.
  88   let PrintMethod = "printImmOperand";
  89 }
  90
  91 def s4_1Imm : Operand<i32> {
  92   // For now, we use a generic print function for all operands.
  93   let PrintMethod = "printImmOperand";
  94 }
  95
  96 def s4_2Imm : Operand<i32> {
  97   // For now, we use a generic print function for all operands.
  98   let PrintMethod = "printImmOperand";
  99 }
 100
 101 def s4_3Imm : Operand<i32> {
 102   // For now, we use a generic print function for all operands.
 103   let PrintMethod = "printImmOperand";
 104 }
 105
 106 def u64Imm : Operand<i64> {
 107   // For now, we use a generic print function for all operands.
 108   let PrintMethod = "printImmOperand";
 109 }
 110
 111 def u32Imm : Operand<i32> {
 112   // For now, we use a generic print function for all operands.
 113   let PrintMethod = "printImmOperand";
 114 }
 115
 116 def u16Imm : Operand<i32> {
 117   // For now, we use a generic print function for all operands.
 118   let PrintMethod = "printImmOperand";
 119 }
 120
 121 def u16_0Imm : Operand<i32> {
 122   // For now, we use a generic print function for all operands.
 123   let PrintMethod = "printImmOperand";
 124 }
 125
 126 def u16_1Imm : Operand<i32> {
 127   // For now, we use a generic print function for all operands.
 128   let PrintMethod = "printImmOperand";
 129 }
 130
 131 def u16_2Imm : Operand<i32> {
 132   // For now, we use a generic print function for all operands.
 133   let PrintMethod = "printImmOperand";
 134 }
 135
 136 def u11_3Imm : Operand<i32> {
 137   // For now, we use a generic print function for all operands.
 138   let PrintMethod = "printImmOperand";
 139 }
 140
 141 def u10Imm : Operand<i32> {
 142   // For now, we use a generic print function for all operands.
 143   let PrintMethod = "printImmOperand";
 144 }
 145
 146 def u9Imm : Operand<i32> {
 147   // For now, we use a generic print function for all operands.
 148   let PrintMethod = "printImmOperand";
 149 }
 150
 151 def u8Imm : Operand<i32> {
 152   // For now, we use a generic print function for all operands.
 153   let PrintMethod = "printImmOperand";
 154 }
 155
 156 def u7Imm : Operand<i32> {
 157   // For now, we use a generic print function for all operands.
 158   let PrintMethod = "printImmOperand";
 159 }
 160
 161 def u6Imm : Operand<i32> {
 162   // For now, we use a generic print function for all operands.
 163   let PrintMethod = "printImmOperand";
 164 }
 165
 166 def u6_0Imm : Operand<i32> {
 167   // For now, we use a generic print function for all operands.
 168   let PrintMethod = "printImmOperand";
 169 }
 170
 171 def u6_1Imm : Operand<i32> {
 172   // For now, we use a generic print function for all operands.
 173   let PrintMethod = "printImmOperand";
 174 }
 175
 176 def u6_2Imm : Operand<i32> {
 177   // For now, we use a generic print function for all operands.
 178   let PrintMethod = "printImmOperand";
 179 }
 180
 181 def u6_3Imm : Operand<i32> {
 182   // For now, we use a generic print function for all operands.
 183   let PrintMethod = "printImmOperand";
 184 }
 185
 186 def u5Imm : Operand<i32> {
 187   // For now, we use a generic print function for all operands.
 188   let PrintMethod = "printImmOperand";
 189 }
 190
 191 def u4Imm : Operand<i32> {
 192   // For now, we use a generic print function for all operands.
 193   let PrintMethod = "printImmOperand";
 194 }
 195
 196 def u3Imm : Operand<i32> {
 197   // For now, we use a generic print function for all operands.
 198   let PrintMethod = "printImmOperand";
 199 }
 200
 201 def u2Imm : Operand<i32> {
 202   // For now, we use a generic print function for all operands.
 203   let PrintMethod = "printImmOperand";
 204 }
 205
 206 def u1Imm : Operand<i32> {
 207   // For now, we use a generic print function for all operands.
 208   let PrintMethod = "printImmOperand";
 209 }
 210
 211 def n8Imm : Operand<i32> {
 212   // For now, we use a generic print function for all operands.
 213   let PrintMethod = "printImmOperand";
 214 }
 215
 216 def m6Imm : Operand<i32> {
 217   // For now, we use a generic print function for all operands.
 218   let PrintMethod = "printImmOperand";
 219 }
 220
 221 def nOneImm : Operand<i32> {
 222   // For now, we use a generic print function for all operands.
 223   let PrintMethod = "printNOneImmOperand";
 224 }
 225
 226 //
 227 // Immediate predicates
 228 //
 229 def s32ImmPred  : PatLeaf<(i32 imm), [{
 230   // immS16 predicate - True if the immediate fits in a 16-bit sign extended
 231   // field.
 232   int64_t v = (int64_t)N->getSExtValue();
 233   return isInt<32>(v);
 234 }]>;
 235
 236 def s32_24ImmPred  : PatLeaf<(i32 imm), [{
 237   // s32_24ImmPred predicate - True if the immediate fits in a 32-bit sign
 238   // extended field that is a multiple of 0x1000000.
 239   int64_t v = (int64_t)N->getSExtValue();
 240   return isShiftedInt<32,24>(v);
 241 }]>;
 242
 243 def s32_16s8ImmPred  : PatLeaf<(i32 imm), [{
 244   // s32_16s8ImmPred predicate - True if the immediate fits in a 32-bit sign
 245   // extended field that is a multiple of 0x10000.
 246   int64_t v = (int64_t)N->getSExtValue();
 247   return isShiftedInt<24,16>(v);
 248 }]>;
 249
 250 def s16ImmPred  : PatLeaf<(i32 imm), [{
 251   // immS16 predicate - True if the immediate fits in a 16-bit sign extended
 252   // field.
 253   int64_t v = (int64_t)N->getSExtValue();
 254   return isInt<16>(v);
 255 }]>;
 256
 257
 258 def s13ImmPred  : PatLeaf<(i32 imm), [{
 259   // immS13 predicate - True if the immediate fits in a 13-bit sign extended
 260   // field.
 261   int64_t v = (int64_t)N->getSExtValue();
 262   return isInt<13>(v);
 263 }]>;
 264
 265
 266 def s12ImmPred  : PatLeaf<(i32 imm), [{
 267   // immS16 predicate - True if the immediate fits in a 16-bit sign extended
 268   // field.
 269   int64_t v = (int64_t)N->getSExtValue();
 270   return isInt<12>(v);
 271 }]>;
 272
 273 def s11_0ImmPred  : PatLeaf<(i32 imm), [{
 274   // immS16 predicate - True if the immediate fits in a 16-bit sign extended
 275   // field.
 276   int64_t v = (int64_t)N->getSExtValue();
 277   return isInt<11>(v);
 278 }]>;
 279
 280
 281 def s11_1ImmPred  : PatLeaf<(i32 imm), [{
 282   // immS16 predicate - True if the immediate fits in a 16-bit sign extended
 283   // field.
 284   int64_t v = (int64_t)N->getSExtValue();
 285   return isShiftedInt<11,1>(v);
 286 }]>;
 287
 288
 289 def s11_2ImmPred  : PatLeaf<(i32 imm), [{
 290   // immS16 predicate - True if the immediate fits in a 16-bit sign extended
 291   // field.
 292   int64_t v = (int64_t)N->getSExtValue();
 293   return isShiftedInt<11,2>(v);
 294 }]>;
 295
 296
 297 def s11_3ImmPred  : PatLeaf<(i32 imm), [{
 298   // immS16 predicate - True if the immediate fits in a 16-bit sign extended
 299   // field.
 300   int64_t v = (int64_t)N->getSExtValue();
 301   return isShiftedInt<11,3>(v);
 302 }]>;
 303
 304
 305 def s10ImmPred  : PatLeaf<(i32 imm), [{
 306   // s10ImmPred predicate - True if the immediate fits in a 10-bit sign extended
 307   // field.
 308   int64_t v = (int64_t)N->getSExtValue();
 309   return isInt<10>(v);
 310 }]>;
 311
 312
 313 def s9ImmPred  : PatLeaf<(i32 imm), [{
 314   // s9ImmPred predicate - True if the immediate fits in a 9-bit sign extended
 315   // field.
 316   int64_t v = (int64_t)N->getSExtValue();
 317   return isInt<9>(v);
 318 }]>;
 319
 320
 321 def s8ImmPred  : PatLeaf<(i32 imm), [{
 322   // s8ImmPred predicate - True if the immediate fits in a 8-bit sign extended
 323   // field.
 324   int64_t v = (int64_t)N->getSExtValue();
 325   return isInt<8>(v);
 326 }]>;
 327
 328
 329 def s8Imm64Pred  : PatLeaf<(i64 imm), [{
 330   // s8ImmPred predicate - True if the immediate fits in a 8-bit sign extended
 331   // field.
 332   int64_t v = (int64_t)N->getSExtValue();
 333   return isInt<8>(v);
 334 }]>;
 335
 336
 337 def s6ImmPred  : PatLeaf<(i32 imm), [{
 338   // s6ImmPred predicate - True if the immediate fits in a 6-bit sign extended
 339   // field.
 340   int64_t v = (int64_t)N->getSExtValue();
 341   return isInt<6>(v);
 342 }]>;
 343
 344
 345 def s4_0ImmPred  : PatLeaf<(i32 imm), [{
 346   // s4_0ImmPred predicate - True if the immediate fits in a 4-bit sign extended
 347   // field.
 348   int64_t v = (int64_t)N->getSExtValue();
 349   return isInt<4>(v);
 350 }]>;
 351
 352
 353 def s4_1ImmPred  : PatLeaf<(i32 imm), [{
 354   // s4_1ImmPred predicate - True if the immediate fits in a 4-bit sign extended
 355   // field of 2.
 356   int64_t v = (int64_t)N->getSExtValue();
 357   return isShiftedInt<4,1>(v);
 358 }]>;
 359
 360
 361 def s4_2ImmPred  : PatLeaf<(i32 imm), [{
 362   // s4_2ImmPred predicate - True if the immediate fits in a 4-bit sign extended
 363   // field that is a multiple of 4.
 364   int64_t v = (int64_t)N->getSExtValue();
 365   return isShiftedInt<4,2>(v);
 366 }]>;
 367
 368
 369 def s4_3ImmPred  : PatLeaf<(i32 imm), [{
 370   // s4_3ImmPred predicate - True if the immediate fits in a 4-bit sign extended
 371   // field that is a multiple of 8.
 372   int64_t v = (int64_t)N->getSExtValue();
 373   return isShiftedInt<4,3>(v);
 374 }]>;
 375
 376
 377 def u64ImmPred  : PatLeaf<(i64 imm), [{
 378   // immS16 predicate - True if the immediate fits in a 16-bit sign extended
 379   // field.
 380   // Adding "N ||" to supress gcc unused warning.
 381   return (N || true);
 382 }]>;
 383
 384 def u32ImmPred  : PatLeaf<(i32 imm), [{
 385   // immS16 predicate - True if the immediate fits in a 16-bit sign extended
 386   // field.
 387   int64_t v = (int64_t)N->getSExtValue();
 388   return isUInt<32>(v);
 389 }]>;
 390
 391 def u16ImmPred  : PatLeaf<(i32 imm), [{
 392   // u16ImmPred predicate - True if the immediate fits in a 16-bit unsigned
 393   // field.
 394   int64_t v = (int64_t)N->getSExtValue();
 395   return isUInt<16>(v);
 396 }]>;
 397
 398 def u16_s8ImmPred  : PatLeaf<(i32 imm), [{
 399   // u16_s8ImmPred predicate - True if the immediate fits in a 16-bit sign
 400   // extended s8 field.
 401   int64_t v = (int64_t)N->getSExtValue();
 402   return isShiftedUInt<16,8>(v);
 403 }]>;
 404
 405 def u9ImmPred  : PatLeaf<(i32 imm), [{
 406   // u9ImmPred predicate - True if the immediate fits in a 9-bit unsigned
 407   // field.
 408   int64_t v = (int64_t)N->getSExtValue();
 409   return isUInt<9>(v);
 410 }]>;
 411
 412
 413 def u8ImmPred  : PatLeaf<(i32 imm), [{
 414   // u8ImmPred predicate - True if the immediate fits in a 8-bit unsigned
 415   // field.
 416   int64_t v = (int64_t)N->getSExtValue();
 417   return isUInt<8>(v);
 418 }]>;
 419
 420 def u7ImmPred  : PatLeaf<(i32 imm), [{
 421   // u7ImmPred predicate - True if the immediate fits in a 8-bit unsigned
 422   // field.
 423   int64_t v = (int64_t)N->getSExtValue();
 424   return isUInt<7>(v);
 425 }]>;
 426
 427
 428 def u6ImmPred  : PatLeaf<(i32 imm), [{
 429   // u6ImmPred predicate - True if the immediate fits in a 6-bit unsigned
 430   // field.
 431   int64_t v = (int64_t)N->getSExtValue();
 432   return isUInt<6>(v);
 433 }]>;
 434
 435 def u6_0ImmPred  : PatLeaf<(i32 imm), [{
 436   // u6_0ImmPred predicate - True if the immediate fits in a 6-bit unsigned
 437   // field. Same as u6ImmPred.
 438   int64_t v = (int64_t)N->getSExtValue();
 439   return isUInt<6>(v);
 440 }]>;
 441
 442 def u6_1ImmPred  : PatLeaf<(i32 imm), [{
 443   // u6_1ImmPred predicate - True if the immediate fits in a 6-bit unsigned
 444   // field that is 1 bit alinged - multiple of 2.
 445   int64_t v = (int64_t)N->getSExtValue();
 446   return isShiftedUInt<6,1>(v);
 447 }]>;
 448
 449 def u6_2ImmPred  : PatLeaf<(i32 imm), [{
 450   // u6_2ImmPred predicate - True if the immediate fits in a 6-bit unsigned
 451   // field that is 2 bits alinged - multiple of 4.
 452   int64_t v = (int64_t)N->getSExtValue();
 453   return isShiftedUInt<6,2>(v);
 454 }]>;
 455
 456 def u6_3ImmPred  : PatLeaf<(i32 imm), [{
 457   // u6_3ImmPred predicate - True if the immediate fits in a 6-bit unsigned
 458   // field that is 3 bits alinged - multiple of 8.
 459   int64_t v = (int64_t)N->getSExtValue();
 460   return isShiftedUInt<6,3>(v);
 461 }]>;
 462
 463 def u5ImmPred  : PatLeaf<(i32 imm), [{
 464   // u5ImmPred predicate - True if the immediate fits in a 5-bit unsigned
 465   // field.
 466   int64_t v = (int64_t)N->getSExtValue();
 467   return isUInt<5>(v);
 468 }]>;
 469
 470
 471 def u3ImmPred  : PatLeaf<(i32 imm), [{
 472   // u3ImmPred predicate - True if the immediate fits in a 3-bit unsigned
 473   // field.
 474   int64_t v = (int64_t)N->getSExtValue();
 475   return isUInt<3>(v);
 476 }]>;
 477
 478
 479 def u2ImmPred  : PatLeaf<(i32 imm), [{
 480   // u2ImmPred predicate - True if the immediate fits in a 2-bit unsigned
 481   // field.
 482   int64_t v = (int64_t)N->getSExtValue();
 483   return isUInt<2>(v);
 484 }]>;
 485
 486
 487 def u1ImmPred  : PatLeaf<(i1 imm), [{
 488   // u1ImmPred predicate - True if the immediate fits in a 1-bit unsigned
 489   // field.
 490   int64_t v = (int64_t)N->getSExtValue();
 491   return isUInt<1>(v);
 492 }]>;
 493
 494 def m6ImmPred  : PatLeaf<(i32 imm), [{
 495   // m6ImmPred predicate - True if the immediate is negative and fits in
 496   // a 6-bit negative number.
 497   int64_t v = (int64_t)N->getSExtValue();
 498   return isInt<6>(v);
 499 }]>;
 500
 501 //InN means negative integers in [-(2^N - 1), 0]
 502 def n8ImmPred  : PatLeaf<(i32 imm), [{
 503   // n8ImmPred predicate - True if the immediate fits in a 8-bit signed
 504   // field.
 505   int64_t v = (int64_t)N->getSExtValue();
 506   return (-255 <= v && v <= 0);
 507 }]>;
 508
 509 def nOneImmPred  : PatLeaf<(i32 imm), [{
 510   // nOneImmPred predicate - True if the immediate is -1.
 511   int64_t v = (int64_t)N->getSExtValue();
 512   return (-1 == v);
 513 }]>;
 514
 515 // Operand types for constant extendable operands
 516 def s16Ext : Operand<i32> {
 517   let PrintMethod = "printExtOperand";
 518 }
 519
 520 def s12Ext : Operand<i32> {
 521   let PrintMethod = "printExtOperand";
 522 }
 523
 524 def s10Ext : Operand<i32> {
 525   let PrintMethod = "printExtOperand";
 526 }
 527
 528 def s9Ext : Operand<i32> {
 529   let PrintMethod = "printExtOperand";
 530 }
 531
 532 def s8Ext : Operand<i32> {
 533   let PrintMethod = "printExtOperand";
 534 }
 535
 536 def s6Ext : Operand<i32> {
 537   let PrintMethod = "printExtOperand";
 538 }
 539
 540 def s11_0Ext : Operand<i32> {
 541   let PrintMethod = "printExtOperand";
 542 }
 543
 544 def s11_1Ext : Operand<i32> {
 545   let PrintMethod = "printExtOperand";
 546 }
 547
 548 def s11_2Ext : Operand<i32> {
 549   let PrintMethod = "printExtOperand";
 550 }
 551
 552 def s11_3Ext : Operand<i32> {
 553   let PrintMethod = "printExtOperand";
 554 }
 555
 556 def u6Ext : Operand<i32> {
 557   let PrintMethod = "printExtOperand";
 558 }
 559
 560 def u7Ext : Operand<i32> {
 561   let PrintMethod = "printExtOperand";
 562 }
 563
 564 def u8Ext : Operand<i32> {
 565   let PrintMethod = "printExtOperand";
 566 }
 567
 568 def u9Ext : Operand<i32> {
 569   let PrintMethod = "printExtOperand";
 570 }
 571
 572 def u10Ext : Operand<i32> {
 573   let PrintMethod = "printExtOperand";
 574 }
 575
 576 def u6_0Ext : Operand<i32> {
 577   let PrintMethod = "printExtOperand";
 578 }
 579
 580 def u6_1Ext : Operand<i32> {
 581   let PrintMethod = "printExtOperand";
 582 }
 583
 584 def u6_2Ext : Operand<i32> {
 585   let PrintMethod = "printExtOperand";
 586 }
 587
 588 def u6_3Ext : Operand<i32> {
 589   let PrintMethod = "printExtOperand";
 590 }
 591
 592 // Predicates for constant extendable operands
 593 def s16ExtPred  : PatLeaf<(i32 imm), [{
 594   int64_t v = (int64_t)N->getSExtValue();
 595   if (!Subtarget.hasV4TOps())
 596     // Return true if the immediate can fit in a 16-bit sign extended field.
 597     return isInt<16>(v);
 598   else {
 599     if (isInt<16>(v))
 600       return true;
 601
 602     // Return true if extending this immediate is profitable and the value
 603     // can fit in a 32-bit signed field.
 604     if (isConstExtProfitable(Node) && isInt<32>(v))
 605       return true;
 606     else
 607       return false;
 608   }
 609 }]>;
 610
 611 def s10ExtPred  : PatLeaf<(i32 imm), [{
 612   int64_t v = (int64_t)N->getSExtValue();
 613   if (!Subtarget.hasV4TOps())
 614     // Return true if the immediate can fit in a 10-bit sign extended field.
 615     return isInt<10>(v);
 616   else {
 617     if (isInt<10>(v))
 618       return true;
 619
 620     // Return true if extending this immediate is profitable and the value
 621     // can fit in a 32-bit signed field.
 622     if (isConstExtProfitable(Node) && isInt<32>(v))
 623       return true;
 624     else
 625       return false;
 626   }
 627 }]>;
 628
 629 def s9ExtPred  : PatLeaf<(i32 imm), [{
 630   int64_t v = (int64_t)N->getSExtValue();
 631   if (!Subtarget.hasV4TOps())
 632     // Return true if the immediate can fit in a 9-bit sign extended field.
 633     return isInt<9>(v);
 634   else {
 635     if (isInt<9>(v))
 636       return true;
 637
 638     // Return true if extending this immediate is profitable and the value
 639     // can fit in a 32-bit unsigned field.
 640     if (isConstExtProfitable(Node) && isInt<32>(v))
 641       return true;
 642     else
 643       return false;
 644   }
 645 }]>;
 646
 647 def s8ExtPred  : PatLeaf<(i32 imm), [{
 648   int64_t v = (int64_t)N->getSExtValue();
 649   if (!Subtarget.hasV4TOps())
 650     // Return true if the immediate can fit in a 8-bit sign extended field.
 651     return isInt<8>(v);
 652   else {
 653     if (isInt<8>(v))
 654       return true;
 655
 656     // Return true if extending this immediate is profitable and the value
 657     // can fit in a 32-bit signed field.
 658     if (isConstExtProfitable(Node) && isInt<32>(v))
 659       return true;
 660     else
 661       return false;
 662   }
 663 }]>;
 664
 665 def s8_16ExtPred  : PatLeaf<(i32 imm), [{
 666   int64_t v = (int64_t)N->getSExtValue();
 667   if (!Subtarget.hasV4TOps())
 668     // Return true if the immediate fits in a 8-bit sign extended field.
 669     return isInt<8>(v);
 670   else {
 671     if (isInt<8>(v))
 672       return true;
 673
 674     // Return true if extending this immediate is profitable and the value
 675     // can't fit in a 16-bit signed field. This is required to avoid
 676     // unnecessary constant extenders.
 677     if (isConstExtProfitable(Node) && !isInt<16>(v))
 678       return true;
 679     else
 680       return false;
 681   }
 682 }]>;
 683
 684 def s6ExtPred  : PatLeaf<(i32 imm), [{
 685   int64_t v = (int64_t)N->getSExtValue();
 686   if (!Subtarget.hasV4TOps())
 687     // Return true if the immediate can fit in a 6-bit sign extended field.
 688     return isInt<6>(v);
 689   else {
 690     if (isInt<6>(v))
 691       return true;
 692
 693     // Return true if extending this immediate is profitable and the value
 694     // can fit in a 32-bit unsigned field.
 695     if (isConstExtProfitable(Node) && isInt<32>(v))
 696       return true;
 697     else
 698       return false;
 699   }
 700 }]>;
 701
 702 def s6_16ExtPred  : PatLeaf<(i32 imm), [{
 703   int64_t v = (int64_t)N->getSExtValue();
 704   if (!Subtarget.hasV4TOps())
 705     // Return true if the immediate fits in a 6-bit sign extended field.
 706     return isInt<6>(v);
 707   else {
 708     if (isInt<6>(v))
 709       return true;
 710
 711     // Return true if extending this immediate is profitable and the value
 712     // can't fit in a 16-bit signed field. This is required to avoid
 713     // unnecessary constant extenders.
 714     if (isConstExtProfitable(Node) && !isInt<16>(v))
 715       return true;
 716     else
 717       return false;
 718   }
 719 }]>;
 720
 721 def s6_10ExtPred  : PatLeaf<(i32 imm), [{
 722   int64_t v = (int64_t)N->getSExtValue();
 723   if (!Subtarget.hasV4TOps())
 724     // Return true if the immediate can fit in a 6-bit sign extended field.
 725     return isInt<6>(v);
 726   else {
 727     if (isInt<6>(v))
 728       return true;
 729
 730     // Return true if extending this immediate is profitable and the value
 731     // can't fit in a 10-bit signed field. This is required to avoid
 732     // unnecessary constant extenders.
 733     if (isConstExtProfitable(Node) && !isInt<10>(v))
 734       return true;
 735     else
 736       return false;
 737   }
 738 }]>;
 739
 740 def s11_0ExtPred  : PatLeaf<(i32 imm), [{
 741   int64_t v = (int64_t)N->getSExtValue();
 742   if (!Subtarget.hasV4TOps())
 743     // Return true if the immediate can fit in a 11-bit sign extended field.
 744     return isShiftedInt<11,0>(v);
 745   else {
 746     if (isInt<11>(v))
 747       return true;
 748
 749     // Return true if extending this immediate is profitable and the value
 750     // can fit in a 32-bit signed field.
 751     if (isConstExtProfitable(Node) && isInt<32>(v))
 752       return true;
 753     else
 754       return false;
 755   }
 756 }]>;
 757
 758 def s11_1ExtPred  : PatLeaf<(i32 imm), [{
 759   int64_t v = (int64_t)N->getSExtValue();
 760   if (!Subtarget.hasV4TOps())
 761     // Return true if the immediate can fit in a 12-bit sign extended field and
 762     // is 2 byte aligned.
 763     return isShiftedInt<11,1>(v);
 764   else {
 765     if (isInt<12>(v))
 766       return isShiftedInt<11,1>(v);
 767
 768     // Return true if extending this immediate is profitable and the low 1 bit
 769     // is zero (2-byte aligned).
 770     if (isConstExtProfitable(Node) && isInt<32>(v) && ((v % 2) == 0))
 771       return true;
 772     else
 773       return false;
 774   }
 775 }]>;
 776
 777 def s11_2ExtPred  : PatLeaf<(i32 imm), [{
 778   int64_t v = (int64_t)N->getSExtValue();
 779   if (!Subtarget.hasV4TOps())
 780     // Return true if the immediate can fit in a 13-bit sign extended field and
 781     // is 4-byte aligned.
 782     return isShiftedInt<11,2>(v);
 783   else {
 784     if (isInt<13>(v))
 785       return isShiftedInt<11,2>(v);
 786
 787     // Return true if extending this immediate is profitable and the low 2-bits
 788     // are zero (4-byte aligned).
 789     if (isConstExtProfitable(Node)  && isInt<32>(v) && ((v % 4) == 0))
 790       return true;
 791     else
 792       return false;
 793   }
 794 }]>;
 795
 796 def s11_3ExtPred  : PatLeaf<(i32 imm), [{
 797   int64_t v = (int64_t)N->getSExtValue();
 798   if (!Subtarget.hasV4TOps())
 799     // Return true if the immediate can fit in a 14-bit sign extended field and
 800     // is 8-byte aligned.
 801     return isShiftedInt<11,3>(v);
 802   else {
 803     if (isInt<14>(v))
 804      return isShiftedInt<11,3>(v);
 805
 806     // Return true if extending this immediate is profitable and the low 3-bits
 807     // are zero (8-byte aligned).
 808     if (isConstExtProfitable(Node)  && isInt<32>(v) && ((v % 8) == 0))
 809       return true;
 810     else
 811       return false;
 812   }
 813 }]>;
 814
 815 def u6ExtPred  : PatLeaf<(i32 imm), [{
 816   int64_t v = (int64_t)N->getSExtValue();
 817   if (!Subtarget.hasV4TOps())
 818     // Return true if the immediate can fit in a 6-bit unsigned field.
 819     return isUInt<6>(v);
 820   else {
 821     if (isUInt<6>(v))
 822       return true;
 823
 824     // Return true if extending this immediate is profitable and the value
 825     // can fit in a 32-bit unsigned field.
 826     if (isConstExtProfitable(Node) && isUInt<32>(v))
 827       return true;
 828     else
 829       return false;
 830   }
 831 }]>;
 832
 833 def u7ExtPred  : PatLeaf<(i32 imm), [{
 834   int64_t v = (int64_t)N->getSExtValue();
 835   if (!Subtarget.hasV4TOps())
 836     // Return true if the immediate can fit in a 7-bit unsigned field.
 837     return isUInt<7>(v);
 838   else {
 839     if (isUInt<7>(v))
 840       return true;
 841
 842     // Return true if extending this immediate is profitable and the value
 843     // can fit in a 32-bit unsigned field.
 844     if (isConstExtProfitable(Node) && isUInt<32>(v))
 845       return true;
 846     else
 847       return false;
 848   }
 849 }]>;
 850
 851 def u8ExtPred  : PatLeaf<(i32 imm), [{
 852   int64_t v = (int64_t)N->getSExtValue();
 853   if (!Subtarget.hasV4TOps())
 854     // Return true if the immediate can fit in a 8-bit unsigned field.
 855     return isUInt<8>(v);
 856   else {
 857     if (isUInt<8>(v))
 858       return true;
 859
 860     // Return true if extending this immediate is profitable and the value
 861     // can fit in a 32-bit unsigned field.
 862     if (isConstExtProfitable(Node) && isUInt<32>(v))
 863       return true;
 864     else
 865       return false;
 866   }
 867 }]>;
 868
 869 def u9ExtPred  : PatLeaf<(i32 imm), [{
 870   int64_t v = (int64_t)N->getSExtValue();
 871   if (!Subtarget.hasV4TOps())
 872     // Return true if the immediate can fit in a 9-bit unsigned field.
 873     return isUInt<9>(v);
 874   else {
 875     if (isUInt<9>(v))
 876       return true;
 877
 878     // Return true if extending this immediate is profitable and the value
 879     // can fit in a 32-bit unsigned field.
 880     if (isConstExtProfitable(Node) && isUInt<32>(v))
 881       return true;
 882     else
 883       return false;
 884   }
 885 }]>;
 886
 887 def u6_2ExtPred  : PatLeaf<(i32 imm), [{
 888   int64_t v = (int64_t)N->getSExtValue();
 889   if (!Subtarget.hasV4TOps())
 890     // Return true if the immediate can fit in a 8-bit unsigned field and
 891     // is 4-byte aligned.
 892     return isShiftedUInt<6,2>(v);
 893   else {
 894     if (isUInt<9>(v))
 895       return isShiftedUInt<6,2>(v);
 896
 897     // Return true if extending this immediate is profitable and the value
 898     // can fit in a 32-bit unsigned field.
 899     if (isConstExtProfitable(Node) && isUInt<32>(v) && ((v % 4) == 0))
 900       return true;
 901     else
 902       return false;
 903   }
 904 }]>;
 905
 906 def u6_3ExtPred  : PatLeaf<(i32 imm), [{
 907   int64_t v = (int64_t)N->getSExtValue();
 908   if (!Subtarget.hasV4TOps())
 909     // Return true if the immediate can fit in a 9-bit unsigned field and
 910     // is 8-byte aligned.
 911     return isShiftedUInt<6,3>(v);
 912   else {
 913     if (isUInt<9>(v))
 914       return isShiftedUInt<6,3>(v);
 915
 916     // Return true if extending this immediate is profitable and the value
 917     // can fit in a 32-bit unsigned field.
 918     if (isConstExtProfitable(Node) && isUInt<32>(v) && ((v % 8) == 0))
 919       return true;
 920     else
 921       return false;
 922   }
 923 }]>;