lib/Target/CellSPU/SPUInstrInfo.td

   1 //==- SPUInstrInfo.td - Describe the Cell SPU Instructions -*- tablegen -*-==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by a team from the Computer Systems Research
   6 // Department at The Aerospace Corporation and is distributed under the
   7 // University of Illinois Open Source License. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10 // Cell SPU Instructions:
  11 //===----------------------------------------------------------------------===//
  12
  13 //===----------------------------------------------------------------------===//
  14 // TODO Items (not urgent today, but would be nice, low priority)
  15 //
  16 // ANDBI, ORBI: SPU constructs a 4-byte constant for these instructions by
  17 // concatenating the byte argument b as "bbbb". Could recognize this bit pattern
  18 // in 16-bit and 32-bit constants and reduce instruction count.
  19 //===----------------------------------------------------------------------===//
  20
  21 //===----------------------------------------------------------------------===//
  22 // Pseudo instructions:
  23 //===----------------------------------------------------------------------===//
  24
  25 let hasCtrlDep = 1, Defs = [R1], Uses = [R1] in {
  26   def ADJCALLSTACKDOWN : Pseudo<(outs), (ins u16imm:$amt),
  27                                 "${:comment} ADJCALLSTACKDOWN",
  28                                 [(callseq_start imm:$amt)]>;
  29   def ADJCALLSTACKUP   : Pseudo<(outs), (ins u16imm:$amt),
  30                                 "${:comment} ADJCALLSTACKUP",
  31                                 [(callseq_end imm:$amt)]>;
  32 }
  33
  34 //===----------------------------------------------------------------------===//
  35 // DWARF debugging Pseudo Instructions
  36 //===----------------------------------------------------------------------===//
  37
  38 def DWARF_LOC        : Pseudo<(outs), (ins i32imm:$line, i32imm:$col, i32imm:$file),
  39                               "${:comment} .loc $file, $line, $col",
  40                       [(dwarf_loc (i32 imm:$line), (i32 imm:$col),
  41                                   (i32 imm:$file))]>;
  42
  43 //===----------------------------------------------------------------------===//
  44 // Loads:
  45 // NB: The ordering is actually important, since the instruction selection
  46 // will try each of the instructions in sequence, i.e., the D-form first with
  47 // the 10-bit displacement, then the A-form with the 16 bit displacement, and
  48 // finally the X-form with the register-register.
  49 //===----------------------------------------------------------------------===//
  50
  51 let isLoad = 1 in {
  52   def LQDv16i8:
  53       RI10Form<0b00101100, (outs VECREG:$rT), (ins memri10:$src),
  54         "lqd\t$rT, $src", LoadStore,
  55         [(set (v16i8 VECREG:$rT), (load dform_addr:$src))]>;
  56
  57   def LQDv8i16:
  58       RI10Form<0b00101100, (outs VECREG:$rT), (ins memri10:$src),
  59         "lqd\t$rT, $src", LoadStore,
  60         [(set (v8i16 VECREG:$rT), (load dform_addr:$src))]>;
  61
  62   def LQDv4i32:
  63       RI10Form<0b00101100, (outs VECREG:$rT), (ins memri10:$src),
  64         "lqd\t$rT, $src", LoadStore,
  65         [(set (v4i32 VECREG:$rT), (load dform_addr:$src))]>;
  66
  67   def LQDv2i64:
  68       RI10Form<0b00101100, (outs VECREG:$rT), (ins memri10:$src),
  69         "lqd\t$rT, $src", LoadStore,
  70         [(set (v2i64 VECREG:$rT), (load dform_addr:$src))]>;
  71
  72   def LQDv4f32:
  73       RI10Form<0b00101100, (outs VECREG:$rT), (ins memri10:$src),
  74         "lqd\t$rT, $src", LoadStore,
  75         [(set (v4f32 VECREG:$rT), (load dform_addr:$src))]>;
  76
  77   def LQDv2f64:
  78       RI10Form<0b00101100, (outs VECREG:$rT), (ins memri10:$src),
  79         "lqd\t$rT, $src", LoadStore,
  80         [(set (v2f64 VECREG:$rT), (load dform_addr:$src))]>;
  81
  82   def LQDr128:
  83       RI10Form<0b00101100, (outs GPRC:$rT), (ins memri10:$src),
  84         "lqd\t$rT, $src", LoadStore,
  85         [(set GPRC:$rT, (load dform_addr:$src))]>;
  86
  87   def LQDr64:
  88       RI10Form<0b00101100, (outs R64C:$rT), (ins memri10:$src),
  89         "lqd\t$rT, $src", LoadStore,
  90          [(set R64C:$rT, (load dform_addr:$src))]>;
  91
  92   def LQDr32:
  93       RI10Form<0b00101100, (outs R32C:$rT), (ins memri10:$src),
  94         "lqd\t$rT, $src", LoadStore,
  95         [(set R32C:$rT, (load dform_addr:$src))]>;
  96
  97   // Floating Point
  98   def LQDf32:
  99       RI10Form<0b00101100, (outs R32FP:$rT), (ins memri10:$src),
 100         "lqd\t$rT, $src", LoadStore,
 101         [(set R32FP:$rT, (load dform_addr:$src))]>;
 102
 103   def LQDf64:
 104       RI10Form<0b00101100, (outs R64FP:$rT), (ins memri10:$src),
 105         "lqd\t$rT, $src", LoadStore,
 106         [(set R64FP:$rT, (load dform_addr:$src))]>;
 107   // END Floating Point
 108
 109   def LQDr16:
 110       RI10Form<0b00101100, (outs R16C:$rT), (ins memri10:$src),
 111         "lqd\t$rT, $src", LoadStore,
 112         [(set R16C:$rT, (load dform_addr:$src))]>;
 113
 114   def LQDr8:
 115       RI10Form<0b00101100, (outs R8C:$rT), (ins memri10:$src),
 116         "lqd\t$rT, $src", LoadStore,
 117         [(set R8C:$rT, (load dform_addr:$src))]>;
 118
 119   def LQAv16i8:
 120       RI16Form<0b100001100, (outs VECREG:$rT), (ins addr256k:$src),
 121         "lqa\t$rT, $src", LoadStore,
 122         [(set (v16i8 VECREG:$rT), (load aform_addr:$src))]>;
 123
 124   def LQAv8i16:
 125       RI16Form<0b100001100, (outs VECREG:$rT), (ins addr256k:$src),
 126         "lqa\t$rT, $src", LoadStore,
 127         [(set (v8i16 VECREG:$rT), (load aform_addr:$src))]>;
 128
 129   def LQAv4i32:
 130       RI16Form<0b100001100, (outs VECREG:$rT), (ins addr256k:$src),
 131         "lqa\t$rT, $src", LoadStore,
 132         [(set (v4i32 VECREG:$rT), (load aform_addr:$src))]>;
 133
 134   def LQAv2i64:
 135       RI16Form<0b100001100, (outs VECREG:$rT), (ins addr256k:$src),
 136         "lqa\t$rT, $src", LoadStore,
 137         [(set (v2i64 VECREG:$rT), (load aform_addr:$src))]>;
 138
 139   def LQAv4f32:
 140       RI16Form<0b100001100, (outs VECREG:$rT), (ins addr256k:$src),
 141         "lqa\t$rT, $src", LoadStore,
 142         [(set (v4f32 VECREG:$rT), (load aform_addr:$src))]>;
 143
 144   def LQAv2f64:
 145       RI16Form<0b100001100, (outs VECREG:$rT), (ins addr256k:$src),
 146         "lqa\t$rT, $src", LoadStore,
 147         [(set (v2f64 VECREG:$rT), (load aform_addr:$src))]>;
 148
 149   def LQAr128:
 150       RI16Form<0b100001100, (outs GPRC:$rT), (ins addr256k:$src),
 151         "lqa\t$rT, $src", LoadStore,
 152         [(set GPRC:$rT, (load aform_addr:$src))]>;
 153
 154   def LQAr64:
 155       RI16Form<0b100001100, (outs R64C:$rT), (ins addr256k:$src),
 156         "lqa\t$rT, $src", LoadStore,
 157         [(set R64C:$rT, (load aform_addr:$src))]>;
 158
 159   def LQAr32:
 160       RI16Form<0b100001100, (outs R32C:$rT), (ins addr256k:$src),
 161         "lqa\t$rT, $src", LoadStore,
 162         [(set R32C:$rT, (load aform_addr:$src))]>;
 163
 164   def LQAf32:
 165       RI16Form<0b100001100, (outs R32FP:$rT), (ins addr256k:$src),
 166         "lqa\t$rT, $src", LoadStore,
 167         [(set R32FP:$rT, (load aform_addr:$src))]>;
 168
 169   def LQAf64:
 170       RI16Form<0b100001100, (outs R64FP:$rT), (ins addr256k:$src),
 171         "lqa\t$rT, $src", LoadStore,
 172         [(set R64FP:$rT, (load aform_addr:$src))]>;
 173
 174   def LQAr16:
 175       RI16Form<0b100001100, (outs R16C:$rT), (ins addr256k:$src),
 176         "lqa\t$rT, $src", LoadStore,
 177         [(set R16C:$rT, (load aform_addr:$src))]>;
 178
 179  def LQAr8:
 180       RI16Form<0b100001100, (outs R8C:$rT), (ins addr256k:$src),
 181         "lqa\t$rT, $src", LoadStore,
 182         [(set R8C:$rT, (load aform_addr:$src))]>;
 183
 184   def LQXv16i8:
 185       RRForm<0b00100011100, (outs VECREG:$rT), (ins memrr:$src),
 186         "lqx\t$rT, $src", LoadStore,
 187         [(set (v16i8 VECREG:$rT), (load xform_addr:$src))]>;
 188
 189   def LQXv8i16:
 190       RRForm<0b00100011100, (outs VECREG:$rT), (ins memrr:$src),
 191         "lqx\t$rT, $src", LoadStore,
 192         [(set (v8i16 VECREG:$rT), (load xform_addr:$src))]>;
 193
 194   def LQXv4i32:
 195       RRForm<0b00100011100, (outs VECREG:$rT), (ins memrr:$src),
 196         "lqx\t$rT, $src", LoadStore,
 197         [(set (v4i32 VECREG:$rT), (load xform_addr:$src))]>;
 198
 199   def LQXv2i64:
 200       RRForm<0b00100011100, (outs VECREG:$rT), (ins memrr:$src),
 201         "lqx\t$rT, $src", LoadStore,
 202         [(set (v2i64 VECREG:$rT), (load xform_addr:$src))]>;
 203
 204   def LQXv4f32:
 205       RRForm<0b00100011100, (outs VECREG:$rT), (ins memrr:$src),
 206         "lqx\t$rT, $src", LoadStore,
 207         [(set (v4f32 VECREG:$rT), (load xform_addr:$src))]>;
 208
 209   def LQXv2f64:
 210       RRForm<0b00100011100, (outs VECREG:$rT), (ins memrr:$src),
 211         "lqx\t$rT, $src", LoadStore,
 212         [(set (v2f64 VECREG:$rT), (load xform_addr:$src))]>;
 213
 214   def LQXr128:
 215       RRForm<0b00100011100, (outs GPRC:$rT), (ins memrr:$src),
 216         "lqx\t$rT, $src", LoadStore,
 217         [(set GPRC:$rT, (load xform_addr:$src))]>;
 218
 219   def LQXr64:
 220       RRForm<0b00100011100, (outs R64C:$rT), (ins memrr:$src),
 221         "lqx\t$rT, $src", LoadStore,
 222         [(set R64C:$rT, (load xform_addr:$src))]>;
 223
 224   def LQXr32:
 225       RRForm<0b00100011100, (outs R32C:$rT), (ins memrr:$src),
 226         "lqx\t$rT, $src", LoadStore,
 227         [(set R32C:$rT, (load xform_addr:$src))]>;
 228
 229   def LQXf32:
 230       RRForm<0b00100011100, (outs R32FP:$rT), (ins memrr:$src),
 231         "lqx\t$rT, $src", LoadStore,
 232         [(set R32FP:$rT, (load xform_addr:$src))]>;
 233
 234   def LQXf64:
 235       RRForm<0b00100011100, (outs R64FP:$rT), (ins memrr:$src),
 236         "lqx\t$rT, $src", LoadStore,
 237         [(set R64FP:$rT, (load xform_addr:$src))]>;
 238
 239   def LQXr16:
 240       RRForm<0b00100011100, (outs R16C:$rT), (ins memrr:$src),
 241         "lqx\t$rT, $src", LoadStore,
 242         [(set R16C:$rT, (load xform_addr:$src))]>;
 243
 244   def LQXr8:
 245       RRForm<0b00100011100, (outs R8C:$rT), (ins memrr:$src),
 246         "lqx\t$rT, $src", LoadStore,
 247         [(set R8C:$rT, (load xform_addr:$src))]>;
 248
 249 /* Load quadword, PC relative: Not much use at this point in time.
 250    Might be of use later for relocatable code.
 251   def LQR : RI16Form<0b111001100, (outs VECREG:$rT), (ins s16imm:$disp),
 252                      "lqr\t$rT, $disp", LoadStore,
 253                      [(set VECREG:$rT, (load iaddr:$disp))]>;
 254  */
 255 }
 256
 257 //===----------------------------------------------------------------------===//
 258 // Stores:
 259 //===----------------------------------------------------------------------===//
 260
 261 let isStore = 1 in {
 262   def STQDv16i8 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memri10:$src),
 263       "stqd\t$rT, $src", LoadStore,
 264       [(store (v16i8 VECREG:$rT), dform_addr:$src)]>;
 265
 266   def STQDv8i16 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memri10:$src),
 267       "stqd\t$rT, $src", LoadStore,
 268       [(store (v8i16 VECREG:$rT), dform_addr:$src)]>;
 269
 270   def STQDv4i32 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memri10:$src),
 271       "stqd\t$rT, $src", LoadStore,
 272       [(store (v4i32 VECREG:$rT), dform_addr:$src)]>;
 273
 274   def STQDv2i64 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memri10:$src),
 275       "stqd\t$rT, $src", LoadStore,
 276       [(store (v2i64 VECREG:$rT), dform_addr:$src)]>;
 277
 278   def STQDv4f32 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memri10:$src),
 279       "stqd\t$rT, $src", LoadStore,
 280       [(store (v4f32 VECREG:$rT), dform_addr:$src)]>;
 281
 282   def STQDv2f64 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memri10:$src),
 283       "stqd\t$rT, $src", LoadStore,
 284       [(store (v2f64 VECREG:$rT), dform_addr:$src)]>;
 285
 286   def STQDr128 : RI10Form<0b00100100, (outs), (ins GPRC:$rT, memri10:$src),
 287       "stqd\t$rT, $src", LoadStore,
 288       [(store GPRC:$rT, dform_addr:$src)]>;
 289
 290   def STQDr64 : RI10Form<0b00100100, (outs), (ins R64C:$rT, memri10:$src),
 291       "stqd\t$rT, $src", LoadStore,
 292       [(store R64C:$rT, dform_addr:$src)]>;
 293
 294   def STQDr32 : RI10Form<0b00100100, (outs), (ins R32C:$rT, memri10:$src),
 295       "stqd\t$rT, $src", LoadStore,
 296       [(store R32C:$rT, dform_addr:$src)]>;
 297
 298   // Floating Point
 299   def STQDf32 : RI10Form<0b00100100, (outs), (ins R32FP:$rT, memri10:$src),
 300       "stqd\t$rT, $src", LoadStore,
 301       [(store R32FP:$rT, dform_addr:$src)]>;
 302
 303   def STQDf64 : RI10Form<0b00100100, (outs), (ins R64FP:$rT, memri10:$src),
 304       "stqd\t$rT, $src", LoadStore,
 305       [(store R64FP:$rT, dform_addr:$src)]>;
 306
 307   def STQDr16 : RI10Form<0b00100100, (outs), (ins R16C:$rT, memri10:$src),
 308       "stqd\t$rT, $src", LoadStore,
 309       [(store R16C:$rT, dform_addr:$src)]>;
 310
 311   def STQDr8 : RI10Form<0b00100100, (outs), (ins R8C:$rT, memri10:$src),
 312       "stqd\t$rT, $src", LoadStore,
 313       [(store R8C:$rT, dform_addr:$src)]>;
 314
 315   def STQAv16i8 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, addr256k:$src),
 316       "stqa\t$rT, $src", LoadStore,
 317       [(store (v16i8 VECREG:$rT), aform_addr:$src)]>;
 318
 319   def STQAv8i16 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, addr256k:$src),
 320       "stqa\t$rT, $src", LoadStore,
 321       [(store (v8i16 VECREG:$rT), aform_addr:$src)]>;
 322
 323   def STQAv4i32 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, addr256k:$src),
 324       "stqa\t$rT, $src", LoadStore,
 325       [(store (v4i32 VECREG:$rT), aform_addr:$src)]>;
 326
 327   def STQAv2i64 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, addr256k:$src),
 328       "stqa\t$rT, $src", LoadStore,
 329       [(store (v2i64 VECREG:$rT), aform_addr:$src)]>;
 330
 331   def STQAv4f32 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, addr256k:$src),
 332       "stqa\t$rT, $src", LoadStore,
 333       [(store (v4f32 VECREG:$rT), aform_addr:$src)]>;
 334
 335   def STQAv2f64 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, addr256k:$src),
 336       "stqa\t$rT, $src", LoadStore,
 337       [(store (v2f64 VECREG:$rT), aform_addr:$src)]>;
 338
 339   def STQAr128 : RI10Form<0b00100100, (outs), (ins GPRC:$rT, addr256k:$src),
 340       "stqa\t$rT, $src", LoadStore,
 341       [(store GPRC:$rT, aform_addr:$src)]>;
 342
 343   def STQAr64 : RI10Form<0b00100100, (outs), (ins R64C:$rT, addr256k:$src),
 344       "stqa\t$rT, $src", LoadStore,
 345       [(store R64C:$rT, aform_addr:$src)]>;
 346
 347   def STQAr32 : RI10Form<0b00100100, (outs), (ins R32C:$rT, addr256k:$src),
 348       "stqa\t$rT, $src", LoadStore,
 349       [(store R32C:$rT, aform_addr:$src)]>;
 350
 351   // Floating Point
 352   def STQAf32 : RI10Form<0b00100100, (outs), (ins R32FP:$rT, addr256k:$src),
 353       "stqa\t$rT, $src", LoadStore,
 354       [(store R32FP:$rT, aform_addr:$src)]>;
 355
 356   def STQAf64 : RI10Form<0b00100100, (outs), (ins R64FP:$rT, addr256k:$src),
 357       "stqa\t$rT, $src", LoadStore,
 358       [(store R64FP:$rT, aform_addr:$src)]>;
 359
 360   def STQAr16 : RI10Form<0b00100100, (outs), (ins R16C:$rT, addr256k:$src),
 361       "stqa\t$rT, $src", LoadStore,
 362       [(store R16C:$rT, aform_addr:$src)]>;
 363
 364   def STQAr8 : RI10Form<0b00100100, (outs), (ins R8C:$rT, addr256k:$src),
 365       "stqa\t$rT, $src", LoadStore,
 366       [(store R8C:$rT, aform_addr:$src)]>;
 367
 368   def STQXv16i8 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memrr:$src),
 369       "stqx\t$rT, $src", LoadStore,
 370       [(store (v16i8 VECREG:$rT), xform_addr:$src)]>;
 371
 372   def STQXv8i16 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memrr:$src),
 373       "stqx\t$rT, $src", LoadStore,
 374       [(store (v8i16 VECREG:$rT), xform_addr:$src)]>;
 375
 376   def STQXv4i32 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memrr:$src),
 377       "stqx\t$rT, $src", LoadStore,
 378       [(store (v4i32 VECREG:$rT), xform_addr:$src)]>;
 379
 380   def STQXv2i64 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memrr:$src),
 381       "stqx\t$rT, $src", LoadStore,
 382       [(store (v2i64 VECREG:$rT), xform_addr:$src)]>;
 383
 384   def STQXv4f32 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memrr:$src),
 385       "stqx\t$rT, $src", LoadStore,
 386       [(store (v4f32 VECREG:$rT), xform_addr:$src)]>;
 387
 388   def STQXv2f64 : RI10Form<0b00100100, (outs), (ins VECREG:$rT, memrr:$src),
 389       "stqx\t$rT, $src", LoadStore,
 390       [(store (v2f64 VECREG:$rT), xform_addr:$src)]>;
 391
 392   def STQXr128 : RI10Form<0b00100100, (outs), (ins GPRC:$rT, memrr:$src),
 393       "stqx\t$rT, $src", LoadStore,
 394       [(store GPRC:$rT, xform_addr:$src)]>;
 395
 396   def STQXr64:
 397     RI10Form<0b00100100, (outs), (ins R64C:$rT, memrr:$src),
 398       "stqx\t$rT, $src", LoadStore,
 399       [(store R64C:$rT, xform_addr:$src)]>;
 400
 401   def STQXr32:
 402     RI10Form<0b00100100, (outs), (ins R32C:$rT, memrr:$src),
 403       "stqx\t$rT, $src", LoadStore,
 404       [(store R32C:$rT, xform_addr:$src)]>;
 405
 406   // Floating Point
 407   def STQXf32:
 408     RI10Form<0b00100100, (outs), (ins R32FP:$rT, memrr:$src),
 409       "stqx\t$rT, $src", LoadStore,
 410       [(store R32FP:$rT, xform_addr:$src)]>;
 411
 412   def STQXf64:
 413     RI10Form<0b00100100, (outs), (ins R64FP:$rT, memrr:$src),
 414       "stqx\t$rT, $src", LoadStore,
 415       [(store R64FP:$rT, xform_addr:$src)]>;
 416
 417   def STQXr16:
 418     RI10Form<0b00100100, (outs), (ins R16C:$rT, memrr:$src),
 419       "stqx\t$rT, $src", LoadStore,
 420       [(store R16C:$rT, xform_addr:$src)]>;
 421
 422   def STQXr8:
 423      RI10Form<0b00100100, (outs), (ins R8C:$rT, memrr:$src),
 424        "stqx\t$rT, $src", LoadStore,
 425        [(store R8C:$rT, xform_addr:$src)]>;
 426
 427 /* Store quadword, PC relative: Not much use at this point in time. Might
 428    be useful for relocatable code.
 429   def STQR : RI16Form<0b111000100, (outs), (ins VECREG:$rT, s16imm:$disp),
 430                      "stqr\t$rT, $disp", LoadStore,
 431                      [(store VECREG:$rT, iaddr:$disp)]>;
 432  */
 433 }
 434
 435 //===----------------------------------------------------------------------===//
 436 // Generate Controls for Insertion:
 437 //===----------------------------------------------------------------------===//
 438
 439 def CBD :
 440     RI7Form<0b10101111100, (outs VECREG:$rT), (ins memri7:$src),
 441       "cbd\t$rT, $src", ShuffleOp,
 442       [(set (v16i8 VECREG:$rT), (SPUvecinsmask dform2_addr:$src))]>;
 443
 444 def CBX : RRForm<0b00101011100, (outs VECREG:$rT), (ins memrr:$src),
 445     "cbx\t$rT, $src", ShuffleOp,
 446     [(set (v16i8 VECREG:$rT), (SPUvecinsmask xform_addr:$src))]>;
 447
 448 def CHD : RI7Form<0b10101111100, (outs VECREG:$rT), (ins memri7:$src),
 449     "chd\t$rT, $src", ShuffleOp,
 450     [(set (v8i16 VECREG:$rT), (SPUvecinsmask dform2_addr:$src))]>;
 451
 452 def CHX : RRForm<0b10101011100, (outs VECREG:$rT), (ins memrr:$src),
 453     "chx\t$rT, $src", ShuffleOp,
 454     [(set (v8i16 VECREG:$rT), (SPUvecinsmask xform_addr:$src))]>;
 455
 456 def CWD : RI7Form<0b01101111100, (outs VECREG:$rT), (ins memri7:$src),
 457     "cwd\t$rT, $src", ShuffleOp,
 458     [(set (v4i32 VECREG:$rT), (SPUvecinsmask dform2_addr:$src))]>;
 459
 460 def CWX : RRForm<0b01101011100, (outs VECREG:$rT), (ins memrr:$src),
 461     "cwx\t$rT, $src", ShuffleOp,
 462     [(set (v4i32 VECREG:$rT), (SPUvecinsmask xform_addr:$src))]>;
 463
 464 def CDD : RI7Form<0b11101111100, (outs VECREG:$rT), (ins memri7:$src),
 465     "cdd\t$rT, $src", ShuffleOp,
 466     [(set (v2i64 VECREG:$rT), (SPUvecinsmask dform2_addr:$src))]>;
 467
 468 def CDX : RRForm<0b11101011100, (outs VECREG:$rT), (ins memrr:$src),
 469     "cdx\t$rT, $src", ShuffleOp,
 470     [(set (v2i64 VECREG:$rT), (SPUvecinsmask xform_addr:$src))]>;
 471
 472 //===----------------------------------------------------------------------===//
 473 // Constant formation:
 474 //===----------------------------------------------------------------------===//
 475
 476 def ILHv8i16:
 477   RI16Form<0b110000010, (outs VECREG:$rT), (ins s16imm:$val),
 478     "ilh\t$rT, $val", ImmLoad,
 479     [(set (v8i16 VECREG:$rT), (v8i16 v8i16SExt16Imm:$val))]>;
 480
 481 def ILHr16:
 482   RI16Form<0b110000010, (outs R16C:$rT), (ins s16imm:$val),
 483     "ilh\t$rT, $val", ImmLoad,
 484     [(set R16C:$rT, immSExt16:$val)]>;
 485
 486 // Cell SPU doesn't have a native 8-bit immediate load, but ILH works ("with
 487 // the right constant")
 488 def ILHr8:
 489   RI16Form<0b110000010, (outs R8C:$rT), (ins s16imm_i8:$val),
 490     "ilh\t$rT, $val", ImmLoad,
 491     [(set R8C:$rT, immSExt8:$val)]>;
 492
 493 // IL does sign extension!
 494 def ILr64:
 495   RI16Form<0b100000010, (outs R64C:$rT), (ins s16imm_i64:$val),
 496     "il\t$rT, $val", ImmLoad,
 497     [(set R64C:$rT, immSExt16:$val)]>;
 498
 499 def ILv2i64:
 500   RI16Form<0b100000010, (outs VECREG:$rT), (ins s16imm_i64:$val),
 501     "il\t$rT, $val", ImmLoad,
 502     [(set VECREG:$rT, (v2i64 v2i64SExt16Imm:$val))]>;
 503
 504 def ILv4i32:
 505   RI16Form<0b100000010, (outs VECREG:$rT), (ins s16imm:$val),
 506     "il\t$rT, $val", ImmLoad,
 507     [(set VECREG:$rT, (v4i32 v4i32SExt16Imm:$val))]>;
 508
 509 def ILr32:
 510   RI16Form<0b100000010, (outs R32C:$rT), (ins s16imm_i32:$val),
 511     "il\t$rT, $val", ImmLoad,
 512     [(set R32C:$rT, immSExt16:$val)]>;
 513
 514 def ILf32:
 515   RI16Form<0b100000010, (outs R32FP:$rT), (ins s16imm_f32:$val),
 516     "il\t$rT, $val", ImmLoad,
 517     [(set R32FP:$rT, (SPUFPconstant fpimmSExt16:$val))]>;
 518
 519 def ILf64:
 520   RI16Form<0b100000010, (outs R64FP:$rT), (ins s16imm_f64:$val),
 521     "il\t$rT, $val", ImmLoad,
 522     [(set R64FP:$rT, (SPUFPconstant fpimmSExt16:$val))]>;
 523
 524 def ILHUv4i32:
 525   RI16Form<0b010000010, (outs VECREG:$rT), (ins u16imm:$val),
 526     "ilhu\t$rT, $val", ImmLoad,
 527     [(set VECREG:$rT, (v4i32 immILHUvec:$val))]>;
 528
 529 def ILHUr32:
 530    RI16Form<0b010000010, (outs R32C:$rT), (ins u16imm:$val),
 531     "ilhu\t$rT, $val", ImmLoad,
 532     [(set R32C:$rT, hi16:$val)]>;
 533
 534 // ILHUf32: Used to custom lower float constant loads
 535 def ILHUf32:
 536    RI16Form<0b010000010, (outs R32FP:$rT), (ins f16imm:$val),
 537     "ilhu\t$rT, $val", ImmLoad,
 538     [(set R32FP:$rT, (SPUFPconstant hi16_f32:$val))]>;
 539
 540 // ILHUhi: Used for loading high portion of an address. Note the symbolHi
 541 // printer used for the operand.
 542 def ILHUhi : RI16Form<0b010000010, (outs R32C:$rT), (ins symbolHi:$val),
 543     "ilhu\t$rT, $val", ImmLoad,
 544     [(set R32C:$rT, hi16:$val)]>;
 545
 546 // Immediate load address (can also be used to load 18-bit unsigned constants,
 547 // see the zext 16->32 pattern)
 548 def ILAr64:
 549   RI18Form<0b1000010, (outs R64C:$rT), (ins u18imm_i64:$val),
 550     "ila\t$rT, $val", LoadNOP,
 551     [(set R64C:$rT, imm18:$val)]>;
 552
 553 // TODO: ILAv2i64
 554
 555 def ILAv2i64:
 556   RI18Form<0b1000010, (outs VECREG:$rT), (ins u18imm:$val),
 557     "ila\t$rT, $val", LoadNOP,
 558     [(set (v2i64 VECREG:$rT), v2i64Uns18Imm:$val)]>;
 559
 560 def ILAv4i32:
 561   RI18Form<0b1000010, (outs VECREG:$rT), (ins u18imm:$val),
 562     "ila\t$rT, $val", LoadNOP,
 563     [(set (v4i32 VECREG:$rT), v4i32Uns18Imm:$val)]>;
 564
 565 def ILAr32:
 566   RI18Form<0b1000010, (outs R32C:$rT), (ins u18imm:$val),
 567     "ila\t$rT, $val", LoadNOP,
 568     [(set R32C:$rT, imm18:$val)]>;
 569
 570 def ILAf32:
 571   RI18Form<0b1000010, (outs R32FP:$rT), (ins f18imm:$val),
 572     "ila\t$rT, $val", LoadNOP,
 573     [(set R32FP:$rT, (SPUFPconstant fpimm18:$val))]>;
 574
 575 def ILAf64:
 576   RI18Form<0b1000010, (outs R64FP:$rT), (ins f18imm_f64:$val),
 577     "ila\t$rT, $val", LoadNOP,
 578     [(set R64FP:$rT, (SPUFPconstant fpimm18:$val))]>;
 579
 580 def ILAlo:
 581     RI18Form<0b1000010, (outs R32C:$rT), (ins symbolLo:$val),
 582     "ila\t$rT, $val", ImmLoad,
 583     [(set R32C:$rT, imm18:$val)]>;
 584
 585 def ILAlsa:
 586     RI18Form<0b1000010, (outs R32C:$rT), (ins symbolLSA:$val),
 587     "ila\t$rT, $val", ImmLoad,
 588     [/* no pattern */]>;
 589
 590 // Immediate OR, Halfword Lower: The "other" part of loading large constants
 591 // into 32-bit registers. See the anonymous pattern Pat<(i32 imm:$imm), ...>
 592 // Note that these are really two operand instructions, but they're encoded
 593 // as three operands with the first two arguments tied-to each other.
 594
 595 def IOHLvec:
 596     RI16Form<0b100000110, (outs VECREG:$rT), (ins VECREG:$rS, u16imm:$val),
 597       "iohl\t$rT, $val", ImmLoad,
 598       [/* insert intrinsic here */]>,
 599       RegConstraint<"$rS = $rT">,
 600       NoEncode<"$rS">;
 601
 602 def IOHLr32:
 603     RI16Form<0b100000110, (outs R32C:$rT), (ins R32C:$rS, i32imm:$val),
 604       "iohl\t$rT, $val", ImmLoad,
 605       [/* insert intrinsic here */]>,
 606       RegConstraint<"$rS = $rT">,
 607       NoEncode<"$rS">;
 608
 609 def IOHLf32:
 610     RI16Form<0b100000110, (outs R32FP:$rT), (ins R32FP:$rS, f32imm:$val),
 611       "iohl\t$rT, $val", ImmLoad,
 612       [/* insert intrinsic here */]>,
 613       RegConstraint<"$rS = $rT">,
 614       NoEncode<"$rS">;
 615
 616 // Form select mask for bytes using immediate, used in conjunction with the
 617 // SELB instruction:
 618
 619 def FSMBIv16i8 : RI16Form<0b101001100, (outs VECREG:$rT), (ins u16imm:$val),
 620     "fsmbi\t$rT, $val", SelectOp,
 621     [(set (v16i8 VECREG:$rT), (SPUfsmbi_v16i8 immU16:$val))]>;
 622
 623 def FSMBIv8i16 : RI16Form<0b101001100, (outs VECREG:$rT), (ins u16imm:$val),
 624     "fsmbi\t$rT, $val", SelectOp,
 625     [(set (v8i16 VECREG:$rT), (SPUfsmbi_v8i16 immU16:$val))]>;
 626
 627 def FSMBIvecv4i32 : RI16Form<0b101001100, (outs VECREG:$rT), (ins u16imm:$val),
 628     "fsmbi\t$rT, $val", SelectOp,
 629     [(set (v4i32 VECREG:$rT), (SPUfsmbi_v4i32 immU16:$val))]>;
 630
 631 //===----------------------------------------------------------------------===//
 632 // Integer and Logical Operations:
 633 //===----------------------------------------------------------------------===//
 634
 635 def AHv8i16:
 636   RRForm<0b00010011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
 637     "ah\t$rT, $rA, $rB", IntegerOp,
 638     [(set (v8i16 VECREG:$rT), (int_spu_si_ah VECREG:$rA, VECREG:$rB))]>;
 639
 640 def : Pat<(add (v8i16 VECREG:$rA), (v8i16 VECREG:$rB)),
 641           (AHv8i16 VECREG:$rA, VECREG:$rB)>;
 642
 643 //  [(set (v8i16 VECREG:$rT), (add (v8i16 VECREG:$rA), (v8i16 VECREG:$rB)))]>;
 644
 645 def AHr16:
 646   RRForm<0b00010011000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
 647     "ah\t$rT, $rA, $rB", IntegerOp,
 648     [(set R16C:$rT, (add R16C:$rA, R16C:$rB))]>;
 649
 650 def AHIvec:
 651     RI10Form<0b10111000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
 652       "ahi\t$rT, $rA, $val", IntegerOp,
 653       [(set (v8i16 VECREG:$rT), (add (v8i16 VECREG:$rA),
 654                                      v8i16SExt10Imm:$val))]>;
 655
 656 def AHIr16 : RI10Form<0b10111000, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
 657   "ahi\t$rT, $rA, $val", IntegerOp,
 658   [(set R16C:$rT, (add R16C:$rA, v8i16SExt10Imm:$val))]>;
 659
 660 def Avec : RRForm<0b00000011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
 661   "a\t$rT, $rA, $rB", IntegerOp,
 662   [(set (v4i32 VECREG:$rT), (add (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))]>;
 663
 664 def : Pat<(add (v16i8 VECREG:$rA), (v16i8 VECREG:$rB)),
 665           (Avec VECREG:$rA, VECREG:$rB)>;
 666
 667 def Ar32 : RRForm<0b00000011000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
 668   "a\t$rT, $rA, $rB", IntegerOp,
 669   [(set R32C:$rT, (add R32C:$rA, R32C:$rB))]>;
 670
 671 def Ar8:
 672     RRForm<0b00000011000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
 673       "a\t$rT, $rA, $rB", IntegerOp,
 674       [(set R8C:$rT, (add R8C:$rA, R8C:$rB))]>;
 675
 676 def AIvec:
 677     RI10Form<0b00111000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
 678       "ai\t$rT, $rA, $val", IntegerOp,
 679       [(set (v4i32 VECREG:$rT), (add (v4i32 VECREG:$rA),
 680                                       v4i32SExt10Imm:$val))]>;
 681
 682 def AIr32:
 683     RI10Form<0b00111000, (outs R32C:$rT), (ins R32C:$rA, s10imm_i32:$val),
 684       "ai\t$rT, $rA, $val", IntegerOp,
 685       [(set R32C:$rT, (add R32C:$rA, i32ImmSExt10:$val))]>;
 686
 687 def SFHvec:
 688     RRForm<0b00010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
 689       "sfh\t$rT, $rA, $rB", IntegerOp,
 690       [(set (v8i16 VECREG:$rT), (sub (v8i16 VECREG:$rA),
 691                                      (v8i16 VECREG:$rB)))]>;
 692
 693 def SFHr16:
 694     RRForm<0b00010010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
 695       "sfh\t$rT, $rA, $rB", IntegerOp,
 696       [(set R16C:$rT, (sub R16C:$rA, R16C:$rB))]>;
 697
 698 def SFHIvec:
 699     RI10Form<0b10110000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
 700       "sfhi\t$rT, $rA, $val", IntegerOp,
 701       [(set (v8i16 VECREG:$rT), (sub v8i16SExt10Imm:$val,
 702                                      (v8i16 VECREG:$rA)))]>;
 703
 704 def SFHIr16 : RI10Form<0b10110000, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
 705   "sfhi\t$rT, $rA, $val", IntegerOp,
 706   [(set R16C:$rT, (sub i16ImmSExt10:$val, R16C:$rA))]>;
 707
 708 def SFvec : RRForm<0b00000010000, (outs VECREG:$rT),
 709                                   (ins VECREG:$rA, VECREG:$rB),
 710   "sf\t$rT, $rA, $rB", IntegerOp,
 711   [(set (v4i32 VECREG:$rT), (sub (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))]>;
 712
 713 def SFr32 : RRForm<0b00000010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
 714   "sf\t$rT, $rA, $rB", IntegerOp,
 715   [(set R32C:$rT, (sub R32C:$rA, R32C:$rB))]>;
 716
 717 def SFIvec:
 718     RI10Form<0b00110000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
 719       "sfi\t$rT, $rA, $val", IntegerOp,
 720       [(set (v4i32 VECREG:$rT), (sub v4i32SExt10Imm:$val,
 721                                      (v4i32 VECREG:$rA)))]>;
 722
 723 def SFIr32 : RI10Form<0b00110000, (outs R32C:$rT),
 724                                   (ins R32C:$rA, s10imm_i32:$val),
 725   "sfi\t$rT, $rA, $val", IntegerOp,
 726   [(set R32C:$rT, (sub i32ImmSExt10:$val, R32C:$rA))]>;
 727
 728 // ADDX: only available in vector form, doesn't match a pattern.
 729 def ADDXvec:
 730     RRForm<0b00000010110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB,
 731                                VECREG:$rCarry),
 732       "addx\t$rT, $rA, $rB", IntegerOp,
 733       []>,
 734     RegConstraint<"$rCarry = $rT">,
 735     NoEncode<"$rCarry">;
 736
 737 // CG: only available in vector form, doesn't match a pattern.
 738 def CGvec:
 739     RRForm<0b01000011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB,
 740                                VECREG:$rCarry),
 741       "cg\t$rT, $rA, $rB", IntegerOp,
 742       []>,
 743     RegConstraint<"$rCarry = $rT">,
 744     NoEncode<"$rCarry">;
 745
 746 // SFX: only available in vector form, doesn't match a pattern
 747 def SFXvec:
 748     RRForm<0b10000010110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB,
 749                                VECREG:$rCarry),
 750       "sfx\t$rT, $rA, $rB", IntegerOp,
 751       []>,
 752     RegConstraint<"$rCarry = $rT">,
 753     NoEncode<"$rCarry">;
 754
 755 // BG: only available in vector form, doesn't match a pattern.
 756 def BGvec:
 757     RRForm<0b01000010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB,
 758                                VECREG:$rCarry),
 759       "bg\t$rT, $rA, $rB", IntegerOp,
 760       []>,
 761     RegConstraint<"$rCarry = $rT">,
 762     NoEncode<"$rCarry">;
 763
 764 // BGX: only available in vector form, doesn't match a pattern.
 765 def BGXvec:
 766     RRForm<0b11000010110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB,
 767                                VECREG:$rCarry),
 768       "bgx\t$rT, $rA, $rB", IntegerOp,
 769       []>,
 770     RegConstraint<"$rCarry = $rT">,
 771     NoEncode<"$rCarry">;
 772
 773 // Halfword multiply variants:
 774 // N.B: These can be used to build up larger quantities (16x16 -> 32)
 775
 776 def MPYv8i16:
 777   RRForm<0b00100011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
 778     "mpy\t$rT, $rA, $rB", IntegerMulDiv,
 779     [(set (v8i16 VECREG:$rT), (SPUmpy_v8i16 (v8i16 VECREG:$rA),
 780                                             (v8i16 VECREG:$rB)))]>;
 781
 782 def MPYr16:
 783   RRForm<0b00100011110, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
 784     "mpy\t$rT, $rA, $rB", IntegerMulDiv,
 785     [(set R16C:$rT, (mul R16C:$rA, R16C:$rB))]>;
 786
 787 def MPYUv4i32:
 788   RRForm<0b00110011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
 789     "mpyu\t$rT, $rA, $rB", IntegerMulDiv,
 790     [(set (v4i32 VECREG:$rT),
 791           (SPUmpyu_v4i32 (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))]>;
 792
 793 def MPYUr16:
 794   RRForm<0b00110011110, (outs R32C:$rT), (ins R16C:$rA, R16C:$rB),
 795     "mpyu\t$rT, $rA, $rB", IntegerMulDiv,
 796     [(set R32C:$rT, (mul (zext R16C:$rA),
 797                          (zext R16C:$rB)))]>;
 798
 799 def MPYUr32:
 800   RRForm<0b00110011110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
 801     "mpyu\t$rT, $rA, $rB", IntegerMulDiv,
 802     [(set R32C:$rT, (SPUmpyu_i32 R32C:$rA, R32C:$rB))]>;
 803
 804 // mpyi: multiply 16 x s10imm -> 32 result (custom lowering for 32 bit result,
 805 // this only produces the lower 16 bits)
 806 def MPYIvec:
 807   RI10Form<0b00101110, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
 808     "mpyi\t$rT, $rA, $val", IntegerMulDiv,
 809     [(set (v8i16 VECREG:$rT), (mul (v8i16 VECREG:$rA), v8i16SExt10Imm:$val))]>;
 810
 811 def MPYIr16:
 812   RI10Form<0b00101110, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
 813     "mpyi\t$rT, $rA, $val", IntegerMulDiv,
 814     [(set R16C:$rT, (mul R16C:$rA, i16ImmSExt10:$val))]>;
 815
 816 // mpyui: same issues as other multiplies, plus, this doesn't match a
 817 // pattern... but may be used during target DAG selection or lowering
 818 def MPYUIvec:
 819   RI10Form<0b10101110, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
 820     "mpyui\t$rT, $rA, $val", IntegerMulDiv,
 821     []>;
 822
 823 def MPYUIr16:
 824   RI10Form<0b10101110, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
 825     "mpyui\t$rT, $rA, $val", IntegerMulDiv,
 826     []>;
 827
 828 // mpya: 16 x 16 + 16 -> 32 bit result
 829 def MPYAvec:
 830   RRRForm<0b0011, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
 831     "mpya\t$rT, $rA, $rB, $rC", IntegerMulDiv,
 832     [(set (v4i32 VECREG:$rT), (add (v4i32 (bitconvert (mul (v8i16 VECREG:$rA),
 833                                                            (v8i16 VECREG:$rB)))),
 834                                    (v4i32 VECREG:$rC)))]>;
 835
 836 def MPYAr32:
 837   RRRForm<0b0011, (outs R32C:$rT), (ins R16C:$rA, R16C:$rB, R32C:$rC),
 838     "mpya\t$rT, $rA, $rB, $rC", IntegerMulDiv,
 839     [(set R32C:$rT, (add (sext (mul R16C:$rA, R16C:$rB)),
 840                          R32C:$rC))]>;
 841
 842 def : Pat<(add (mul (sext R16C:$rA), (sext R16C:$rB)), R32C:$rC),
 843           (MPYAr32 R16C:$rA, R16C:$rB, R32C:$rC)>;
 844
 845 def MPYAr32_sextinreg:
 846   RRRForm<0b0011, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB, R32C:$rC),
 847     "mpya\t$rT, $rA, $rB, $rC", IntegerMulDiv,
 848     [(set R32C:$rT, (add (mul (sext_inreg R32C:$rA, i16),
 849                               (sext_inreg R32C:$rB, i16)),
 850                          R32C:$rC))]>;
 851
 852 //def MPYAr32:
 853 //  RRRForm<0b0011, (outs R32C:$rT), (ins R16C:$rA, R16C:$rB, R32C:$rC),
 854 //    "mpya\t$rT, $rA, $rB, $rC", IntegerMulDiv,
 855 //    [(set R32C:$rT, (add (sext (mul R16C:$rA, R16C:$rB)),
 856 //                         R32C:$rC))]>;
 857
 858 // mpyh: multiply high, used to synthesize 32-bit multiplies
 859 def MPYHv4i32:
 860     RRForm<0b10100011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
 861       "mpyh\t$rT, $rA, $rB", IntegerMulDiv,
 862       [(set (v4i32 VECREG:$rT),
 863             (SPUmpyh_v4i32 (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))]>;
 864
 865 def MPYHr32:
 866     RRForm<0b10100011110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
 867       "mpyh\t$rT, $rA, $rB", IntegerMulDiv,
 868       [(set R32C:$rT, (SPUmpyh_i32 R32C:$rA, R32C:$rB))]>;
 869
 870 // mpys: multiply high and shift right (returns the top half of
 871 // a 16-bit multiply, sign extended to 32 bits.)
 872 def MPYSvec:
 873     RRForm<0b11100011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
 874       "mpys\t$rT, $rA, $rB", IntegerMulDiv,
 875       []>;
 876
 877 def MPYSr16:
 878     RRForm<0b11100011110, (outs R32C:$rT), (ins R16C:$rA, R16C:$rB),
 879       "mpys\t$rT, $rA, $rB", IntegerMulDiv,
 880       []>;
 881
 882 // mpyhh: multiply high-high (returns the 32-bit result from multiplying
 883 // the top 16 bits of the $rA, $rB)
 884 def MPYHHv8i16:
 885     RRForm<0b01100011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
 886       "mpyhh\t$rT, $rA, $rB", IntegerMulDiv,
 887       [(set (v8i16 VECREG:$rT),
 888             (SPUmpyhh_v8i16 (v8i16 VECREG:$rA), (v8i16 VECREG:$rB)))]>;
 889
 890 def MPYHHr32:
 891     RRForm<0b01100011110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
 892       "mpyhh\t$rT, $rA, $rB", IntegerMulDiv,
 893       []>;
 894
 895 // mpyhha: Multiply high-high, add to $rT:
 896 def MPYHHAvec:
 897     RRForm<0b01100010110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
 898       "mpyhha\t$rT, $rA, $rB", IntegerMulDiv,
 899       []>;
 900
 901 def MPYHHAr32:
 902     RRForm<0b01100010110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
 903       "mpyhha\t$rT, $rA, $rB", IntegerMulDiv,
 904       []>;
 905
 906 // mpyhhu: Multiply high-high, unsigned
 907 def MPYHHUvec:
 908     RRForm<0b01110011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
 909       "mpyhhu\t$rT, $rA, $rB", IntegerMulDiv,
 910       []>;
 911
 912 def MPYHHUr32:
 913     RRForm<0b01110011110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
 914       "mpyhhu\t$rT, $rA, $rB", IntegerMulDiv,
 915       []>;
 916
 917 // mpyhhau: Multiply high-high, unsigned
 918 def MPYHHAUvec:
 919     RRForm<0b01110010110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
 920       "mpyhhau\t$rT, $rA, $rB", IntegerMulDiv,
 921       []>;
 922
 923 def MPYHHAUr32:
 924     RRForm<0b01110010110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
 925       "mpyhhau\t$rT, $rA, $rB", IntegerMulDiv,
 926       []>;
 927
 928 // clz: Count leading zeroes
 929 def CLZv4i32:
 930     RRForm_1<0b10100101010, (outs VECREG:$rT), (ins VECREG:$rA),
 931       "clz\t$rT, $rA", IntegerOp,
 932       [/* intrinsic */]>;
 933
 934 def CLZr32:
 935     RRForm_1<0b10100101010, (outs R32C:$rT), (ins R32C:$rA),
 936       "clz\t$rT, $rA", IntegerOp,
 937       [(set R32C:$rT, (ctlz R32C:$rA))]>;
 938
 939 // cntb: Count ones in bytes (aka "population count")
 940 // NOTE: This instruction is really a vector instruction, but the custom
 941 // lowering code uses it in unorthodox ways to support CTPOP for other
 942 // data types!
 943 def CNTBv16i8:
 944     RRForm_1<0b00101101010, (outs VECREG:$rT), (ins VECREG:$rA),
 945       "cntb\t$rT, $rA", IntegerOp,
 946       [(set (v16i8 VECREG:$rT), (SPUcntb_v16i8 (v16i8 VECREG:$rA)))]>;
 947
 948 def CNTBv8i16 :
 949     RRForm_1<0b00101101010, (outs VECREG:$rT), (ins VECREG:$rA),
 950       "cntb\t$rT, $rA", IntegerOp,
 951       [(set (v8i16 VECREG:$rT), (SPUcntb_v8i16 (v8i16 VECREG:$rA)))]>;
 952
 953 def CNTBv4i32 :
 954     RRForm_1<0b00101101010, (outs VECREG:$rT), (ins VECREG:$rA),
 955       "cntb\t$rT, $rA", IntegerOp,
 956       [(set (v4i32 VECREG:$rT), (SPUcntb_v4i32 (v4i32 VECREG:$rA)))]>;
 957
 958 // fsmb: Form select mask for bytes. N.B. Input operand, $rA, is 16-bits
 959 def FSMB:
 960     RRForm_1<0b01101101100, (outs VECREG:$rT), (ins R16C:$rA),
 961       "fsmb\t$rT, $rA", SelectOp,
 962       []>;
 963
 964 // fsmh: Form select mask for halfwords. N.B., Input operand, $rA, is
 965 // only 8-bits wide (even though it's input as 16-bits here)
 966 def FSMH:
 967     RRForm_1<0b10101101100, (outs VECREG:$rT), (ins R16C:$rA),
 968       "fsmh\t$rT, $rA", SelectOp,
 969       []>;
 970
 971 // fsm: Form select mask for words. Like the other fsm* instructions,
 972 // only the lower 4 bits of $rA are significant.
 973 def FSM:
 974     RRForm_1<0b00101101100, (outs VECREG:$rT), (ins R16C:$rA),
 975       "fsm\t$rT, $rA", SelectOp,
 976       []>;
 977
 978 // gbb: Gather all low order bits from each byte in $rA into a single 16-bit
 979 // quantity stored into $rT
 980 def GBB:
 981     RRForm_1<0b01001101100, (outs R16C:$rT), (ins VECREG:$rA),
 982       "gbb\t$rT, $rA", GatherOp,
 983       []>;
 984
 985 // gbh: Gather all low order bits from each halfword in $rA into a single
 986 // 8-bit quantity stored in $rT
 987 def GBH:
 988     RRForm_1<0b10001101100, (outs R16C:$rT), (ins VECREG:$rA),
 989       "gbh\t$rT, $rA", GatherOp,
 990       []>;
 991
 992 // gb: Gather all low order bits from each word in $rA into a single
 993 // 4-bit quantity stored in $rT
 994 def GB:
 995     RRForm_1<0b00001101100, (outs R16C:$rT), (ins VECREG:$rA),
 996       "gb\t$rT, $rA", GatherOp,
 997       []>;
 998
 999 // avgb: average bytes
1000 def AVGB:
1001     RRForm<0b11001011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1002       "avgb\t$rT, $rA, $rB", ByteOp,
1003       []>;
1004
1005 // absdb: absolute difference of bytes
1006 def ABSDB:
1007     RRForm<0b11001010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1008       "absdb\t$rT, $rA, $rB", ByteOp,
1009       []>;
1010
1011 // sumb: sum bytes into halfwords
1012 def SUMB:
1013     RRForm<0b11001010010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1014       "sumb\t$rT, $rA, $rB", ByteOp,
1015       []>;
1016
1017 // Sign extension operations:
1018 def XSBHvec:
1019     RRForm_1<0b01101101010, (outs VECREG:$rDst), (ins VECREG:$rSrc),
1020       "xsbh\t$rDst, $rSrc", IntegerOp,
1021       [(set (v8i16 VECREG:$rDst), (sext (v16i8 VECREG:$rSrc)))]>;
1022
1023 // Ordinary form for XSBH
1024 def XSBHr16:
1025     RRForm_1<0b01101101010, (outs R16C:$rDst), (ins R16C:$rSrc),
1026       "xsbh\t$rDst, $rSrc", IntegerOp,
1027       [(set R16C:$rDst, (sext_inreg R16C:$rSrc, i8))]>;
1028
1029 def XSBHr8:
1030     RRForm_1<0b01101101010, (outs R16C:$rDst), (ins R8C:$rSrc),
1031       "xsbh\t$rDst, $rSrc", IntegerOp,
1032       [(set R16C:$rDst, (sext R8C:$rSrc))]>;
1033
1034 // 32-bit form for XSBH: used to sign extend 8-bit quantities to 16-bit
1035 // quantities to 32-bit quantities via a 32-bit register (see the sext 8->32
1036 // pattern below). Intentionally doesn't match a pattern because we want the
1037 // sext 8->32 pattern to do the work for us, namely because we need the extra
1038 // XSHWr32.
1039 def XSBHr32:
1040     RRForm_1<0b01101101010, (outs R32C:$rDst), (ins R32C:$rSrc),
1041       "xsbh\t$rDst, $rSrc", IntegerOp,
1042       [(set R32C:$rDst, (sext_inreg R32C:$rSrc, i8))]>;
1043
1044 // Sign extend halfwords to words:
1045 def XSHWvec:
1046     RRForm_1<0b01101101010, (outs VECREG:$rDest), (ins VECREG:$rSrc),
1047       "xshw\t$rDest, $rSrc", IntegerOp,
1048       [(set (v4i32 VECREG:$rDest), (sext (v8i16 VECREG:$rSrc)))]>;
1049
1050 def XSHWr32:
1051     RRForm_1<0b01101101010, (outs R32C:$rDst), (ins R32C:$rSrc),
1052       "xshw\t$rDst, $rSrc", IntegerOp,
1053       [(set R32C:$rDst, (sext_inreg R32C:$rSrc, i16))]>;
1054
1055 def XSHWr16:
1056     RRForm_1<0b01101101010, (outs R32C:$rDst), (ins R16C:$rSrc),
1057       "xshw\t$rDst, $rSrc", IntegerOp,
1058       [(set R32C:$rDst, (sext R16C:$rSrc))]>;
1059
1060 def XSWDvec:
1061     RRForm_1<0b01100101010, (outs VECREG:$rDst), (ins VECREG:$rSrc),
1062       "xswd\t$rDst, $rSrc", IntegerOp,
1063       [(set (v2i64 VECREG:$rDst), (sext (v4i32 VECREG:$rSrc)))]>;
1064
1065 def XSWDr64:
1066     RRForm_1<0b01100101010, (outs R64C:$rDst), (ins R64C:$rSrc),
1067       "xswd\t$rDst, $rSrc", IntegerOp,
1068       [(set R64C:$rDst, (sext_inreg R64C:$rSrc, i32))]>;
1069
1070 def XSWDr32:
1071     RRForm_1<0b01100101010, (outs R64C:$rDst), (ins R32C:$rSrc),
1072       "xswd\t$rDst, $rSrc", IntegerOp,
1073       [(set R64C:$rDst, (SPUsext32_to_64 R32C:$rSrc))]>;
1074
1075 def : Pat<(sext R32C:$inp),
1076           (XSWDr32 R32C:$inp)>;
1077
1078 // AND operations
1079 def ANDv16i8:
1080     RRForm<0b10000011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1081       "and\t$rT, $rA, $rB", IntegerOp,
1082       [(set (v16i8 VECREG:$rT), (and (v16i8 VECREG:$rA),
1083                                      (v16i8 VECREG:$rB)))]>;
1084
1085 def ANDv8i16:
1086     RRForm<0b10000011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1087       "and\t$rT, $rA, $rB", IntegerOp,
1088       [(set (v8i16 VECREG:$rT), (and (v8i16 VECREG:$rA),
1089                                      (v8i16 VECREG:$rB)))]>;
1090
1091 def ANDv4i32:
1092     RRForm<0b10000011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1093       "and\t$rT, $rA, $rB", IntegerOp,
1094       [(set (v4i32 VECREG:$rT), (and (v4i32 VECREG:$rA),
1095                                      (v4i32 VECREG:$rB)))]>;
1096
1097 def ANDr32:
1098     RRForm<0b10000011000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
1099       "and\t$rT, $rA, $rB", IntegerOp,
1100       [(set R32C:$rT, (and R32C:$rA, R32C:$rB))]>;
1101
1102 //===---------------------------------------------
1103 // Special instructions to perform the fabs instruction
1104 def ANDfabs32:
1105     RRForm<0b10000011000, (outs R32FP:$rT), (ins R32FP:$rA, R32C:$rB),
1106       "and\t$rT, $rA, $rB", IntegerOp,
1107       [/* Intentionally does not match a pattern */]>;
1108
1109 def ANDfabs64:
1110     RRForm<0b10000011000, (outs R64FP:$rT), (ins R64FP:$rA, VECREG:$rB),
1111       "and\t$rT, $rA, $rB", IntegerOp,
1112       [/* Intentionally does not match a pattern */]>;
1113
1114 // Could use ANDv4i32, but won't for clarity
1115 def ANDfabsvec:
1116     RRForm<0b10000011000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1117       "and\t$rT, $rA, $rB", IntegerOp,
1118       [/* Intentionally does not match a pattern */]>;
1119
1120 //===---------------------------------------------
1121
1122 def ANDr16:
1123     RRForm<0b10000011000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
1124       "and\t$rT, $rA, $rB", IntegerOp,
1125       [(set R16C:$rT, (and R16C:$rA, R16C:$rB))]>;
1126
1127 def ANDr8:
1128     RRForm<0b10000011000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
1129       "and\t$rT, $rA, $rB", IntegerOp,
1130       [(set R8C:$rT, (and R8C:$rA, R8C:$rB))]>;
1131
1132 // Hacked form of AND to zero-extend 16-bit quantities to 32-bit
1133 // quantities -- see 16->32 zext pattern.
1134 //
1135 // This pattern is somewhat artificial, since it might match some
1136 // compiler generated pattern but it is unlikely to do so.
1137 def AND2To4:
1138     RRForm<0b10000011000, (outs R32C:$rT), (ins R16C:$rA, R32C:$rB),
1139       "and\t$rT, $rA, $rB", IntegerOp,
1140       [(set R32C:$rT, (and (zext R16C:$rA), R32C:$rB))]>;
1141
1142 // N.B.: vnot_conv is one of those special target selection pattern fragments,
1143 // in which we expect there to be a bit_convert on the constant. Bear in mind
1144 // that llvm translates "not <reg>" to "xor <reg>, -1" (or in this case, a
1145 // constant -1 vector.)
1146 def ANDCv16i8:
1147     RRForm<0b10000011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1148       "andc\t$rT, $rA, $rB", IntegerOp,
1149       [(set (v16i8 VECREG:$rT), (and (v16i8 VECREG:$rA),
1150                                      (vnot (v16i8 VECREG:$rB))))]>;
1151
1152 def ANDCv8i16:
1153     RRForm<0b10000011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1154       "andc\t$rT, $rA, $rB", IntegerOp,
1155       [(set (v8i16 VECREG:$rT), (and (v8i16 VECREG:$rA),
1156                                      (vnot (v8i16 VECREG:$rB))))]>;
1157
1158 def ANDCv4i32:
1159     RRForm<0b10000011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1160       "andc\t$rT, $rA, $rB", IntegerOp,
1161       [(set (v4i32 VECREG:$rT), (and (v4i32 VECREG:$rA),
1162                                      (vnot (v4i32 VECREG:$rB))))]>;
1163
1164 def ANDCr32:
1165     RRForm<0b10000011010, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
1166       "andc\t$rT, $rA, $rB", IntegerOp,
1167       [(set R32C:$rT, (and R32C:$rA, (not R32C:$rB)))]>;
1168
1169 def ANDCr16:
1170     RRForm<0b10000011010, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
1171       "andc\t$rT, $rA, $rB", IntegerOp,
1172       [(set R16C:$rT, (and R16C:$rA, (not R16C:$rB)))]>;
1173
1174 def ANDCr8:
1175     RRForm<0b10000011010, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
1176       "andc\t$rT, $rA, $rB", IntegerOp,
1177       [(set R8C:$rT, (and R8C:$rA, (not R8C:$rB)))]>;
1178
1179 def ANDBIv16i8:
1180     RI10Form<0b01101000, (outs VECREG:$rT), (ins VECREG:$rA, u10imm:$val),
1181       "andbi\t$rT, $rA, $val", IntegerOp,
1182       [(set (v16i8 VECREG:$rT),
1183             (and (v16i8 VECREG:$rA), (v16i8 v16i8U8Imm:$val)))]>;
1184
1185 def ANDBIr8:
1186     RI10Form<0b01101000, (outs R8C:$rT), (ins R8C:$rA, u10imm_i8:$val),
1187       "andbi\t$rT, $rA, $val", IntegerOp,
1188       [(set R8C:$rT, (and R8C:$rA, immU8:$val))]>;
1189
1190 def ANDHIv8i16:
1191     RI10Form<0b10101000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
1192       "andhi\t$rT, $rA, $val", IntegerOp,
1193       [(set (v8i16 VECREG:$rT),
1194             (and (v8i16 VECREG:$rA), v8i16SExt10Imm:$val))]>;
1195
1196 def ANDHIr16:
1197     RI10Form<0b10101000, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
1198       "andhi\t$rT, $rA, $val", IntegerOp,
1199       [(set R16C:$rT, (and R16C:$rA, i16ImmUns10:$val))]>;
1200
1201 def ANDHI1To2:
1202     RI10Form<0b10101000, (outs R16C:$rT), (ins R8C:$rA, s10imm:$val),
1203       "andhi\t$rT, $rA, $val", IntegerOp,
1204       [(set R16C:$rT, (and (zext R8C:$rA), i16ImmSExt10:$val))]>;
1205
1206 def ANDIv4i32:
1207     RI10Form<0b00101000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
1208       "andi\t$rT, $rA, $val", IntegerOp,
1209       [(set (v4i32 VECREG:$rT),
1210             (and (v4i32 VECREG:$rA), v4i32SExt10Imm:$val))]>;
1211
1212 def ANDIr32:
1213     RI10Form<0b10101000, (outs R32C:$rT), (ins R32C:$rA, s10imm_i32:$val),
1214       "andi\t$rT, $rA, $val", IntegerOp,
1215       [(set R32C:$rT, (and R32C:$rA, i32ImmSExt10:$val))]>;
1216
1217 // Hacked form of ANDI to zero-extend i8 quantities to i32. See the zext 8->32
1218 // pattern below.
1219 def ANDI1To4:
1220     RI10Form<0b10101000, (outs R32C:$rT), (ins R8C:$rA, s10imm_i32:$val),
1221       "andi\t$rT, $rA, $val", IntegerOp,
1222       [(set R32C:$rT, (and (zext R8C:$rA), i32ImmSExt10:$val))]>;
1223
1224 // Hacked form of ANDI to zero-extend i16 quantities to i32. See the
1225 // zext 16->32 pattern below.
1226 //
1227 // Note that this pattern is somewhat artificial, since it might match
1228 // something the compiler generates but is unlikely to occur in practice.
1229 def ANDI2To4:
1230     RI10Form<0b10101000, (outs R32C:$rT), (ins R16C:$rA, s10imm_i32:$val),
1231       "andi\t$rT, $rA, $val", IntegerOp,
1232       [(set R32C:$rT, (and (zext R16C:$rA), i32ImmSExt10:$val))]>;
1233
1234 // Bitwise OR group:
1235 // Bitwise "or" (N.B.: These are also register-register copy instructions...)
1236 def ORv16i8:
1237     RRForm<0b10000010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1238       "or\t$rT, $rA, $rB", IntegerOp,
1239       [(set (v16i8 VECREG:$rT), (or (v16i8 VECREG:$rA), (v16i8 VECREG:$rB)))]>;
1240
1241 def ORv8i16:
1242     RRForm<0b10000010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1243       "or\t$rT, $rA, $rB", IntegerOp,
1244       [(set (v8i16 VECREG:$rT), (or (v8i16 VECREG:$rA), (v8i16 VECREG:$rB)))]>;
1245
1246 def ORv4i32:
1247     RRForm<0b10000010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1248       "or\t$rT, $rA, $rB", IntegerOp,
1249       [(set (v4i32 VECREG:$rT), (or (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))]>;
1250
1251 def ORv4f32:
1252     RRForm<0b10000010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1253       "or\t$rT, $rA, $rB", IntegerOp,
1254       [(set (v4f32 VECREG:$rT),
1255             (v4f32 (bitconvert (or (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))))]>;
1256
1257 def ORv2f64:
1258     RRForm<0b10000010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1259       "or\t$rT, $rA, $rB", IntegerOp,
1260       [(set (v2f64 VECREG:$rT),
1261             (v2f64 (bitconvert (or (v2i64 VECREG:$rA), (v2i64 VECREG:$rB)))))]>;
1262
1263 def ORgprc:
1264     RRForm<0b10000010000, (outs GPRC:$rT), (ins GPRC:$rA, GPRC:$rB),
1265       "or\t$rT, $rA, $rB", IntegerOp,
1266       [(set GPRC:$rT, (or GPRC:$rA, GPRC:$rB))]>;
1267
1268 def ORr64:
1269     RRForm<0b10000010000, (outs R64C:$rT), (ins R64C:$rA, R64C:$rB),
1270       "or\t$rT, $rA, $rB", IntegerOp,
1271       [(set R64C:$rT, (or R64C:$rA, R64C:$rB))]>;
1272
1273 def ORr32:
1274     RRForm<0b10000010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
1275       "or\t$rT, $rA, $rB", IntegerOp,
1276       [(set R32C:$rT, (or R32C:$rA, R32C:$rB))]>;
1277
1278 def ORr16:
1279     RRForm<0b10000010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
1280       "or\t$rT, $rA, $rB", IntegerOp,
1281       [(set R16C:$rT, (or R16C:$rA, R16C:$rB))]>;
1282
1283 def ORr8:
1284     RRForm<0b10000010000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
1285       "or\t$rT, $rA, $rB", IntegerOp,
1286       [(set R8C:$rT, (or R8C:$rA, R8C:$rB))]>;
1287
1288 // ORv*_*: Used in scalar->vector promotions:
1289 def ORv16i8_i8:
1290     RRForm<0b10000010000, (outs VECREG:$rT), (ins R8C:$rA, R8C:$rB),
1291       "or\t$rT, $rA, $rB", IntegerOp,
1292       [/* no pattern */]>;
1293
1294 def : Pat<(v16i8 (SPUpromote_scalar R8C:$rA)),
1295           (ORv16i8_i8 R8C:$rA, R8C:$rA)>;
1296
1297 def ORv8i16_i16:
1298     RRForm<0b10000010000, (outs VECREG:$rT), (ins R16C:$rA, R16C:$rB),
1299       "or\t$rT, $rA, $rB", IntegerOp,
1300       [/* no pattern */]>;
1301
1302 def : Pat<(v8i16 (SPUpromote_scalar R16C:$rA)),
1303           (ORv8i16_i16 R16C:$rA, R16C:$rA)>;
1304
1305 def ORv4i32_i32:
1306     RRForm<0b10000010000, (outs VECREG:$rT), (ins R32C:$rA, R32C:$rB),
1307       "or\t$rT, $rA, $rB", IntegerOp,
1308       [/* no pattern */]>;
1309
1310 def : Pat<(v4i32 (SPUpromote_scalar R32C:$rA)),
1311           (ORv4i32_i32 R32C:$rA, R32C:$rA)>;
1312
1313 def ORv2i64_i64:
1314     RRForm<0b10000010000, (outs VECREG:$rT), (ins R64C:$rA, R64C:$rB),
1315       "or\t$rT, $rA, $rB", IntegerOp,
1316       [/* no pattern */]>;
1317
1318 def : Pat<(v2i64 (SPUpromote_scalar R64C:$rA)),
1319           (ORv2i64_i64 R64C:$rA, R64C:$rA)>;
1320
1321 def ORv4f32_f32:
1322     RRForm<0b10000010000, (outs VECREG:$rT), (ins R32FP:$rA, R32FP:$rB),
1323       "or\t$rT, $rA, $rB", IntegerOp,
1324       [/* no pattern */]>;
1325
1326 def : Pat<(v4f32 (SPUpromote_scalar R32FP:$rA)),
1327           (ORv4f32_f32 R32FP:$rA, R32FP:$rA)>;
1328
1329 def ORv2f64_f64:
1330     RRForm<0b10000010000, (outs VECREG:$rT), (ins R64FP:$rA, R64FP:$rB),
1331       "or\t$rT, $rA, $rB", IntegerOp,
1332       [/* no pattern */]>;
1333
1334 def : Pat<(v2f64 (SPUpromote_scalar R64FP:$rA)),
1335           (ORv2f64_f64 R64FP:$rA, R64FP:$rA)>;
1336
1337 // ORi*_v*: Used to extract vector element 0 (the preferred slot)
1338 def ORi8_v16i8:
1339     RRForm<0b10000010000, (outs R8C:$rT), (ins VECREG:$rA, VECREG:$rB),
1340       "or\t$rT, $rA, $rB", IntegerOp,
1341       [/* no pattern */]>;
1342
1343 def : Pat<(SPUextract_elt0 (v16i8 VECREG:$rA)),
1344           (ORi8_v16i8 VECREG:$rA, VECREG:$rA)>;
1345
1346 def ORi16_v8i16:
1347     RRForm<0b10000010000, (outs R16C:$rT), (ins VECREG:$rA, VECREG:$rB),
1348       "or\t$rT, $rA, $rB", IntegerOp,
1349       [/* no pattern */]>;
1350
1351 def : Pat<(SPUextract_elt0 (v8i16 VECREG:$rA)),
1352           (ORi16_v8i16 VECREG:$rA, VECREG:$rA)>;
1353
1354 def : Pat<(SPUextract_elt0_chained (v8i16 VECREG:$rA)),
1355           (ORi16_v8i16 VECREG:$rA, VECREG:$rA)>;
1356
1357 def ORi32_v4i32:
1358     RRForm<0b10000010000, (outs R32C:$rT), (ins VECREG:$rA, VECREG:$rB),
1359       "or\t$rT, $rA, $rB", IntegerOp,
1360       [/* no pattern */]>;
1361
1362 def : Pat<(SPUextract_elt0 (v4i32 VECREG:$rA)),
1363           (ORi32_v4i32 VECREG:$rA, VECREG:$rA)>;
1364
1365 def : Pat<(SPUextract_elt0_chained (v4i32 VECREG:$rA)),
1366           (ORi32_v4i32 VECREG:$rA, VECREG:$rA)>;
1367
1368 def ORi64_v2i64:
1369     RRForm<0b10000010000, (outs R64C:$rT), (ins VECREG:$rA, VECREG:$rB),
1370       "or\t$rT, $rA, $rB", IntegerOp,
1371       [/* no pattern */]>;
1372
1373 def : Pat<(SPUextract_elt0 (v2i64 VECREG:$rA)),
1374           (ORi64_v2i64 VECREG:$rA, VECREG:$rA)>;
1375
1376 def : Pat<(SPUextract_elt0_chained (v2i64 VECREG:$rA)),
1377           (ORi64_v2i64 VECREG:$rA, VECREG:$rA)>;
1378
1379 def ORf32_v4f32:
1380     RRForm<0b10000010000, (outs R32FP:$rT), (ins VECREG:$rA, VECREG:$rB),
1381       "or\t$rT, $rA, $rB", IntegerOp,
1382       [/* no pattern */]>;
1383
1384 def : Pat<(SPUextract_elt0 (v4f32 VECREG:$rA)),
1385           (ORf32_v4f32 VECREG:$rA, VECREG:$rA)>;
1386
1387 def : Pat<(SPUextract_elt0_chained (v4f32 VECREG:$rA)),
1388           (ORf32_v4f32 VECREG:$rA, VECREG:$rA)>;
1389
1390 def ORf64_v2f64:
1391     RRForm<0b10000010000, (outs R64FP:$rT), (ins VECREG:$rA, VECREG:$rB),
1392       "or\t$rT, $rA, $rB", IntegerOp,
1393       [/* no pattern */]>;
1394
1395 def : Pat<(SPUextract_elt0 (v2f64 VECREG:$rA)),
1396           (ORf64_v2f64 VECREG:$rA, VECREG:$rA)>;
1397
1398 def : Pat<(SPUextract_elt0_chained (v2f64 VECREG:$rA)),
1399           (ORf64_v2f64 VECREG:$rA, VECREG:$rA)>;
1400
1401 // ORC: Bitwise "or" with complement (match before ORvec, ORr32)
1402 def ORCv16i8:
1403     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1404       "orc\t$rT, $rA, $rB", IntegerOp,
1405       [(set (v16i8 VECREG:$rT), (or (v16i8 VECREG:$rA),
1406                                     (vnot (v16i8 VECREG:$rB))))]>;
1407
1408 def ORCv8i16:
1409     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1410       "orc\t$rT, $rA, $rB", IntegerOp,
1411       [(set (v8i16 VECREG:$rT), (or (v8i16 VECREG:$rA),
1412                                     (vnot (v8i16 VECREG:$rB))))]>;
1413
1414 def ORCv4i32:
1415     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1416       "orc\t$rT, $rA, $rB", IntegerOp,
1417       [(set (v4i32 VECREG:$rT), (or (v4i32 VECREG:$rA),
1418                                     (vnot (v4i32 VECREG:$rB))))]>;
1419
1420 def ORCr32:
1421   RRForm<0b10010010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
1422     "orc\t$rT, $rA, $rB", IntegerOp,
1423     [(set R32C:$rT, (or R32C:$rA, (not R32C:$rB)))]>;
1424
1425 def ORCr16:
1426   RRForm<0b10010010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
1427     "orc\t$rT, $rA, $rB", IntegerOp,
1428     [(set R16C:$rT, (or R16C:$rA, (not R16C:$rB)))]>;
1429
1430 def ORCr8:
1431   RRForm<0b10010010000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
1432     "orc\t$rT, $rA, $rB", IntegerOp,
1433     [(set R8C:$rT, (or R8C:$rA, (not R8C:$rB)))]>;
1434
1435 // OR byte immediate
1436 def ORBIv16i8:
1437     RI10Form<0b01100000, (outs VECREG:$rT), (ins VECREG:$rA, u10imm:$val),
1438        "orbi\t$rT, $rA, $val", IntegerOp,
1439        [(set (v16i8 VECREG:$rT),
1440              (or (v16i8 VECREG:$rA), (v16i8 v16i8U8Imm:$val)))]>;
1441
1442 def ORBIr8:
1443     RI10Form<0b01100000, (outs R8C:$rT), (ins R8C:$rA, u10imm_i8:$val),
1444        "orbi\t$rT, $rA, $val", IntegerOp,
1445        [(set R8C:$rT, (or R8C:$rA, immU8:$val))]>;
1446
1447 // OR halfword immediate
1448 def ORHIv8i16:
1449     RI10Form<0b10100000, (outs VECREG:$rT), (ins VECREG:$rA, u10imm:$val),
1450       "orhi\t$rT, $rA, $val", IntegerOp,
1451       [(set (v8i16 VECREG:$rT), (or (v8i16 VECREG:$rA),
1452                                     v8i16Uns10Imm:$val))]>;
1453
1454 def ORHIr16:
1455     RI10Form<0b10100000, (outs R16C:$rT), (ins R16C:$rA, u10imm:$val),
1456       "orhi\t$rT, $rA, $val", IntegerOp,
1457       [(set R16C:$rT, (or R16C:$rA, i16ImmUns10:$val))]>;
1458
1459 // Hacked form of ORHI used to promote 8-bit registers to 16-bit
1460 def ORHI1To2:
1461     RI10Form<0b10100000, (outs R16C:$rT), (ins R8C:$rA, s10imm:$val),
1462       "orhi\t$rT, $rA, $val", IntegerOp,
1463       [(set R16C:$rT, (or (anyext R8C:$rA), i16ImmSExt10:$val))]>;
1464
1465 // Bitwise "or" with immediate
1466 def ORIv4i32:
1467     RI10Form<0b00100000, (outs VECREG:$rT), (ins VECREG:$rA, u10imm:$val),
1468       "ori\t$rT, $rA, $val", IntegerOp,
1469       [(set (v4i32 VECREG:$rT), (or (v4i32 VECREG:$rA),
1470                                      v4i32Uns10Imm:$val))]>;
1471
1472 def ORIr32:
1473     RI10Form<0b00100000, (outs R32C:$rT), (ins R32C:$rA, u10imm_i32:$val),
1474       "ori\t$rT, $rA, $val", IntegerOp,
1475       [(set R32C:$rT, (or R32C:$rA, i32ImmUns10:$val))]>;
1476
1477 // Hacked forms of or immediate to copy one 32- and 64-bit FP register
1478 // to another. Do not match patterns.
1479 def ORIf32:
1480     RI10Form_1<0b00100000, (outs R32FP:$rT), (ins R32FP:$rA, s10imm_i32:$val),
1481       "ori\t$rT, $rA, $val", IntegerOp,
1482       [/* no pattern */]>;
1483
1484 def ORIf64:
1485     RI10Form_1<0b00100000, (outs R64FP:$rT), (ins R64FP:$rA, s10imm_i32:$val),
1486       "ori\t$rT, $rA, $val", IntegerOp,
1487       [/* no pattern */]>;
1488
1489 def ORIr64:
1490     RI10Form_1<0b00100000, (outs R64C:$rT), (ins R64C:$rA, s10imm_i32:$val),
1491       "ori\t$rT, $rA, $val", IntegerOp,
1492       [/* no pattern */]>;
1493
1494 // ORI2To4: hacked version of the ori instruction to extend 16-bit quantities
1495 // to 32-bit quantities. used exclusively to match "anyext" conversions (vide
1496 // infra "anyext 16->32" pattern.)
1497 def ORI2To4:
1498     RI10Form<0b00100000, (outs R32C:$rT), (ins R16C:$rA, s10imm_i32:$val),
1499       "ori\t$rT, $rA, $val", IntegerOp,
1500       [(set R32C:$rT, (or (anyext R16C:$rA), i32ImmSExt10:$val))]>;
1501
1502 // ORI1To4: Hacked version of the ORI instruction to extend 16-bit quantities
1503 // to 32-bit quantities. Used exclusively to match "anyext" conversions (vide
1504 // infra "anyext 16->32" pattern.)
1505 def ORI1To4:
1506     RI10Form<0b00100000, (outs R32C:$rT), (ins R8C:$rA, s10imm_i32:$val),
1507       "ori\t$rT, $rA, $val", IntegerOp,
1508       [(set R32C:$rT, (or (anyext R8C:$rA), i32ImmSExt10:$val))]>;
1509
1510 // ORX: "or" across the vector: or's $rA's word slots leaving the result in
1511 // $rT[0], slots 1-3 are zeroed.
1512 //
1513 // FIXME: Needs to match an intrinsic pattern.
1514 def ORXv4i32:
1515     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1516       "orx\t$rT, $rA, $rB", IntegerOp,
1517       []>;
1518
1519 // XOR:
1520 def XORv16i8:
1521     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1522       "xor\t$rT, $rA, $rB", IntegerOp,
1523       [(set (v16i8 VECREG:$rT), (xor (v16i8 VECREG:$rA), (v16i8 VECREG:$rB)))]>;
1524
1525 def XORv8i16:
1526     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1527       "xor\t$rT, $rA, $rB", IntegerOp,
1528       [(set (v8i16 VECREG:$rT), (xor (v8i16 VECREG:$rA), (v8i16 VECREG:$rB)))]>;
1529
1530 def XORv4i32:
1531     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1532       "xor\t$rT, $rA, $rB", IntegerOp,
1533       [(set (v4i32 VECREG:$rT), (xor (v4i32 VECREG:$rA), (v4i32 VECREG:$rB)))]>;
1534
1535 def XORr32:
1536     RRForm<0b10010010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
1537       "xor\t$rT, $rA, $rB", IntegerOp,
1538       [(set R32C:$rT, (xor R32C:$rA, R32C:$rB))]>;
1539
1540 //==----------------------------------------------------------
1541 // Special forms for floating point instructions.
1542 // Bitwise ORs and ANDs don't make sense for normal floating
1543 // point numbers. These operations (fneg and fabs), however,
1544 // require bitwise logical ops to manipulate the sign bit.
1545 def XORfneg32:
1546     RRForm<0b10010010000, (outs R32FP:$rT), (ins R32FP:$rA, R32C:$rB),
1547       "xor\t$rT, $rA, $rB", IntegerOp,
1548       [/* Intentionally does not match a pattern, see fneg32 */]>;
1549
1550 // KLUDGY! Better way to do this without a VECREG? bitconvert?
1551 // VECREG is assumed to contain two identical 64-bit masks, so
1552 // it doesn't matter which word we select for the xor
1553 def XORfneg64:
1554     RRForm<0b10010010000, (outs R64FP:$rT), (ins R64FP:$rA, VECREG:$rB),
1555       "xor\t$rT, $rA, $rB", IntegerOp,
1556       [/* Intentionally does not match a pattern, see fneg64 */]>;
1557
1558 // Could use XORv4i32, but will use this for clarity
1559 def XORfnegvec:
1560     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1561       "xor\t$rT, $rA, $rB", IntegerOp,
1562       [/* Intentionally does not match a pattern, see fneg{32,64} */]>;
1563
1564 //==----------------------------------------------------------
1565
1566 def XORr16:
1567     RRForm<0b10010010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
1568       "xor\t$rT, $rA, $rB", IntegerOp,
1569       [(set R16C:$rT, (xor R16C:$rA, R16C:$rB))]>;
1570
1571 def XORr8:
1572     RRForm<0b10010010000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
1573       "xor\t$rT, $rA, $rB", IntegerOp,
1574       [(set R8C:$rT, (xor R8C:$rA, R8C:$rB))]>;
1575
1576 def XORBIv16i8:
1577     RI10Form<0b01100000, (outs VECREG:$rT), (ins VECREG:$rA, u10imm:$val),
1578        "xorbi\t$rT, $rA, $val", IntegerOp,
1579        [(set (v16i8 VECREG:$rT), (xor (v16i8 VECREG:$rA), v16i8U8Imm:$val))]>;
1580
1581 def XORBIr8:
1582     RI10Form<0b01100000, (outs R8C:$rT), (ins R8C:$rA, u10imm_i8:$val),
1583        "xorbi\t$rT, $rA, $val", IntegerOp,
1584        [(set R8C:$rT, (xor R8C:$rA, immU8:$val))]>;
1585
1586 def XORHIv8i16:
1587     RI10Form<0b10100000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
1588       "xorhi\t$rT, $rA, $val", IntegerOp,
1589       [(set (v8i16 VECREG:$rT), (xor (v8i16 VECREG:$rA),
1590                                       v8i16SExt10Imm:$val))]>;
1591
1592 def XORHIr16:
1593     RI10Form<0b10100000, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
1594       "xorhi\t$rT, $rA, $val", IntegerOp,
1595       [(set R16C:$rT, (xor R16C:$rA, i16ImmSExt10:$val))]>;
1596
1597 def XORIv4i32:
1598     RI10Form<0b00100000, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
1599       "xori\t$rT, $rA, $val", IntegerOp,
1600       [(set (v4i32 VECREG:$rT), (xor (v4i32 VECREG:$rA),
1601                                      v4i32SExt10Imm:$val))]>;
1602
1603 def XORIr32:
1604     RI10Form<0b00100000, (outs R32C:$rT), (ins R32C:$rA, s10imm_i32:$val),
1605       "xori\t$rT, $rA, $val", IntegerOp,
1606       [(set R32C:$rT, (xor R32C:$rA, i32ImmSExt10:$val))]>;
1607
1608 // NAND:
1609 def NANDv16i8:
1610     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1611       "nand\t$rT, $rA, $rB", IntegerOp,
1612       [(set (v16i8 VECREG:$rT), (vnot (and (v16i8 VECREG:$rA),
1613                                            (v16i8 VECREG:$rB))))]>;
1614
1615 def NANDv8i16:
1616     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1617       "nand\t$rT, $rA, $rB", IntegerOp,
1618       [(set (v8i16 VECREG:$rT), (vnot (and (v8i16 VECREG:$rA),
1619                                            (v8i16 VECREG:$rB))))]>;
1620
1621 def NANDv4i32:
1622     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1623       "nand\t$rT, $rA, $rB", IntegerOp,
1624       [(set (v4i32 VECREG:$rT), (vnot (and (v4i32 VECREG:$rA),
1625                                            (v4i32 VECREG:$rB))))]>;
1626
1627 def NANDr32:
1628     RRForm<0b10010010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
1629       "nand\t$rT, $rA, $rB", IntegerOp,
1630       [(set R32C:$rT, (not (and R32C:$rA, R32C:$rB)))]>;
1631
1632 def NANDr16:
1633     RRForm<0b10010010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
1634       "nand\t$rT, $rA, $rB", IntegerOp,
1635       [(set R16C:$rT, (not (and R16C:$rA, R16C:$rB)))]>;
1636
1637 def NANDr8:
1638     RRForm<0b10010010000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
1639       "nand\t$rT, $rA, $rB", IntegerOp,
1640       [(set R8C:$rT, (not (and R8C:$rA, R8C:$rB)))]>;
1641
1642 // NOR:
1643 def NORv16i8:
1644     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1645       "nor\t$rT, $rA, $rB", IntegerOp,
1646       [(set (v16i8 VECREG:$rT), (vnot (or (v16i8 VECREG:$rA),
1647                                           (v16i8 VECREG:$rB))))]>;
1648
1649 def NORv8i16:
1650     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1651       "nor\t$rT, $rA, $rB", IntegerOp,
1652       [(set (v8i16 VECREG:$rT), (vnot (or (v8i16 VECREG:$rA),
1653                                           (v8i16 VECREG:$rB))))]>;
1654
1655 def NORv4i32:
1656     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1657       "nor\t$rT, $rA, $rB", IntegerOp,
1658       [(set (v4i32 VECREG:$rT), (vnot (or (v4i32 VECREG:$rA),
1659                                           (v4i32 VECREG:$rB))))]>;
1660
1661 def NORr32:
1662     RRForm<0b10010010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
1663       "nor\t$rT, $rA, $rB", IntegerOp,
1664       [(set R32C:$rT, (not (or R32C:$rA, R32C:$rB)))]>;
1665
1666 def NORr16:
1667     RRForm<0b10010010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
1668       "nor\t$rT, $rA, $rB", IntegerOp,
1669       [(set R16C:$rT, (not (or R16C:$rA, R16C:$rB)))]>;
1670
1671 def NORr8:
1672     RRForm<0b10010010000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
1673       "nor\t$rT, $rA, $rB", IntegerOp,
1674       [(set R8C:$rT, (not (or R8C:$rA, R8C:$rB)))]>;
1675
1676 // EQV: Equivalence (1 for each same bit, otherwise 0)
1677 def EQVv16i8:
1678     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1679       "eqv\t$rT, $rA, $rB", IntegerOp,
1680       [(set (v16i8 VECREG:$rT), (or (and (v16i8 VECREG:$rA),
1681                                          (v16i8 VECREG:$rB)),
1682                                     (and (vnot (v16i8 VECREG:$rA)),
1683                                          (vnot (v16i8 VECREG:$rB)))))]>;
1684
1685 def : Pat<(xor (v16i8 VECREG:$rA), (vnot (v16i8 VECREG:$rB))),
1686           (EQVv16i8 VECREG:$rA, VECREG:$rB)>;
1687
1688 def : Pat<(xor (vnot (v16i8 VECREG:$rA)), (v16i8 VECREG:$rB)),
1689           (EQVv16i8 VECREG:$rA, VECREG:$rB)>;
1690
1691 def EQVv8i16:
1692     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1693       "eqv\t$rT, $rA, $rB", IntegerOp,
1694       [(set (v8i16 VECREG:$rT), (or (and (v8i16 VECREG:$rA),
1695                                          (v8i16 VECREG:$rB)),
1696                                     (and (vnot (v8i16 VECREG:$rA)),
1697                                          (vnot (v8i16 VECREG:$rB)))))]>;
1698
1699 def : Pat<(xor (v8i16 VECREG:$rA), (vnot (v8i16 VECREG:$rB))),
1700           (EQVv8i16 VECREG:$rA, VECREG:$rB)>;
1701
1702 def : Pat<(xor (vnot (v8i16 VECREG:$rA)), (v8i16 VECREG:$rB)),
1703           (EQVv8i16 VECREG:$rA, VECREG:$rB)>;
1704
1705 def EQVv4i32:
1706     RRForm<0b10010010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
1707       "eqv\t$rT, $rA, $rB", IntegerOp,
1708       [(set (v4i32 VECREG:$rT), (or (and (v4i32 VECREG:$rA),
1709                                          (v4i32 VECREG:$rB)),
1710                                     (and (vnot (v4i32 VECREG:$rA)),
1711                                          (vnot (v4i32 VECREG:$rB)))))]>;
1712
1713 def : Pat<(xor (v4i32 VECREG:$rA), (vnot (v4i32 VECREG:$rB))),
1714           (EQVv4i32 VECREG:$rA, VECREG:$rB)>;
1715
1716 def : Pat<(xor (vnot (v4i32 VECREG:$rA)), (v4i32 VECREG:$rB)),
1717           (EQVv4i32 VECREG:$rA, VECREG:$rB)>;
1718
1719 def EQVr32:
1720     RRForm<0b10010010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
1721       "eqv\t$rT, $rA, $rB", IntegerOp,
1722       [(set R32C:$rT, (or (and R32C:$rA, R32C:$rB),
1723                           (and (not R32C:$rA), (not R32C:$rB))))]>;
1724
1725 def : Pat<(xor R32C:$rA, (not R32C:$rB)),
1726           (EQVr32 R32C:$rA, R32C:$rB)>;
1727
1728 def : Pat<(xor (not R32C:$rA), R32C:$rB),
1729           (EQVr32 R32C:$rA, R32C:$rB)>;
1730
1731 def EQVr16:
1732     RRForm<0b10010010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
1733       "eqv\t$rT, $rA, $rB", IntegerOp,
1734       [(set R16C:$rT, (or (and R16C:$rA, R16C:$rB),
1735                           (and (not R16C:$rA), (not R16C:$rB))))]>;
1736
1737 def : Pat<(xor R16C:$rA, (not R16C:$rB)),
1738           (EQVr16 R16C:$rA, R16C:$rB)>;
1739
1740 def : Pat<(xor (not R16C:$rA), R16C:$rB),
1741           (EQVr16 R16C:$rA, R16C:$rB)>;
1742
1743 def EQVr8:
1744     RRForm<0b10010010000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
1745       "eqv\t$rT, $rA, $rB", IntegerOp,
1746       [(set R8C:$rT, (or (and R8C:$rA, R8C:$rB),
1747                           (and (not R8C:$rA), (not R8C:$rB))))]>;
1748
1749 def : Pat<(xor R8C:$rA, (not R8C:$rB)),
1750           (EQVr8 R8C:$rA, R8C:$rB)>;
1751
1752 def : Pat<(xor (not R8C:$rA), R8C:$rB),
1753           (EQVr8 R8C:$rA, R8C:$rB)>;
1754
1755 // gcc optimizes (p & q) | (~p & ~q) -> ~(p | q) | (p & q), so match that
1756 // pattern also:
1757 def : Pat<(or (vnot (or (v16i8 VECREG:$rA), (v16i8 VECREG:$rB))),
1758               (and (v16i8 VECREG:$rA), (v16i8 VECREG:$rB))),
1759           (EQVv16i8 VECREG:$rA, VECREG:$rB)>;
1760
1761 def : Pat<(or (vnot (or (v8i16 VECREG:$rA), (v8i16 VECREG:$rB))),
1762               (and (v8i16 VECREG:$rA), (v8i16 VECREG:$rB))),
1763           (EQVv8i16 VECREG:$rA, VECREG:$rB)>;
1764
1765 def : Pat<(or (vnot (or (v4i32 VECREG:$rA), (v4i32 VECREG:$rB))),
1766               (and (v4i32 VECREG:$rA), (v4i32 VECREG:$rB))),
1767           (EQVv4i32 VECREG:$rA, VECREG:$rB)>;
1768
1769 def : Pat<(or (not (or R32C:$rA, R32C:$rB)), (and R32C:$rA, R32C:$rB)),
1770           (EQVr32 R32C:$rA, R32C:$rB)>;
1771
1772 def : Pat<(or (not (or R16C:$rA, R16C:$rB)), (and R16C:$rA, R16C:$rB)),
1773           (EQVr16 R16C:$rA, R16C:$rB)>;
1774
1775 def : Pat<(or (not (or R8C:$rA, R8C:$rB)), (and R8C:$rA, R8C:$rB)),
1776           (EQVr8 R8C:$rA, R8C:$rB)>;
1777
1778 // Select bits:
1779 def SELBv16i8:
1780     RRRForm<0b1000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
1781       "selb\t$rT, $rA, $rB, $rC", IntegerOp,
1782       [(set (v16i8 VECREG:$rT),
1783             (SPUselb_v16i8 (v16i8 VECREG:$rA), (v16i8 VECREG:$rB),
1784                            (v16i8 VECREG:$rC)))]>;
1785
1786 def : Pat<(or (and (v16i8 VECREG:$rA), (v16i8 VECREG:$rC)),
1787               (and (v16i8 VECREG:$rB), (vnot (v16i8 VECREG:$rC)))),
1788           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1789
1790 def : Pat<(or (and (v16i8 VECREG:$rC), (v16i8 VECREG:$rA)),
1791               (and (v16i8 VECREG:$rB), (vnot (v16i8 VECREG:$rC)))),
1792           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1793
1794 def : Pat<(or (and (v16i8 VECREG:$rA), (v16i8 VECREG:$rC)),
1795               (and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rB))),
1796           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1797
1798 def : Pat<(or (and (v16i8 VECREG:$rC), (v16i8 VECREG:$rA)),
1799               (and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rB))),
1800           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1801
1802 def : Pat<(or (and (v16i8 VECREG:$rA), (vnot (v16i8 VECREG:$rC))),
1803               (and (v16i8 VECREG:$rB), (v16i8 VECREG:$rC))),
1804           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1805
1806 def : Pat<(or (and (v16i8 VECREG:$rA), (vnot (v16i8 VECREG:$rC))),
1807               (and (v16i8 VECREG:$rC), (v16i8 VECREG:$rB))),
1808           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1809
1810 def : Pat<(or (and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rA)),
1811               (and (v16i8 VECREG:$rB), (v16i8 VECREG:$rC))),
1812           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1813
1814 def : Pat<(or (and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rA)),
1815               (and (v16i8 VECREG:$rC), (v16i8 VECREG:$rB))),
1816           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1817
1818 def : Pat<(or (and (v16i8 VECREG:$rA), (v16i8 VECREG:$rC)),
1819               (and (v16i8 VECREG:$rB), (vnot (v16i8 VECREG:$rC)))),
1820           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1821
1822 def : Pat<(or (and (v16i8 VECREG:$rC), (v16i8 VECREG:$rA)),
1823               (and (v16i8 VECREG:$rB), (vnot (v16i8 VECREG:$rC)))),
1824           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1825
1826 def : Pat<(or (and (v16i8 VECREG:$rA), (v16i8 VECREG:$rC)),
1827               (and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rB))),
1828           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1829
1830 def : Pat<(or (and (v16i8 VECREG:$rC), (v16i8 VECREG:$rA)),
1831               (and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rB))),
1832           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1833
1834 def : Pat<(or (and (v16i8 VECREG:$rA), (vnot (v16i8 VECREG:$rC))),
1835               (and (v16i8 VECREG:$rB), (v16i8 VECREG:$rC))),
1836           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1837
1838 def : Pat<(or (and (v16i8 VECREG:$rA), (vnot (v16i8 VECREG:$rC))),
1839               (and (v16i8 VECREG:$rC), (v16i8 VECREG:$rB))),
1840           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1841
1842 def : Pat<(or (and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rA)),
1843               (and (v16i8 VECREG:$rB), (v16i8 VECREG:$rC))),
1844           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1845
1846 def : Pat<(or (and (vnot (v16i8 VECREG:$rC)), (v16i8 VECREG:$rA)),
1847               (and (v16i8 VECREG:$rC), (v16i8 VECREG:$rB))),
1848           (SELBv16i8 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1849
1850 def SELBv8i16:
1851     RRRForm<0b1000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
1852       "selb\t$rT, $rA, $rB, $rC", IntegerOp,
1853       [(set (v8i16 VECREG:$rT),
1854             (SPUselb_v8i16 (v8i16 VECREG:$rA), (v8i16 VECREG:$rB),
1855                                                (v8i16 VECREG:$rC)))]>;
1856
1857 def : Pat<(or (and (v8i16 VECREG:$rA), (v8i16 VECREG:$rC)),
1858               (and (v8i16 VECREG:$rB), (vnot (v8i16 VECREG:$rC)))),
1859           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1860
1861 def : Pat<(or (and (v8i16 VECREG:$rC), (v8i16 VECREG:$rA)),
1862               (and (v8i16 VECREG:$rB), (vnot (v8i16 VECREG:$rC)))),
1863           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1864
1865 def : Pat<(or (and (v8i16 VECREG:$rA), (v8i16 VECREG:$rC)),
1866               (and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rB))),
1867           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1868
1869 def : Pat<(or (and (v8i16 VECREG:$rC), (v8i16 VECREG:$rA)),
1870               (and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rB))),
1871           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1872
1873 def : Pat<(or (and (v8i16 VECREG:$rA), (vnot (v8i16 VECREG:$rC))),
1874               (and (v8i16 VECREG:$rB), (v8i16 VECREG:$rC))),
1875           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1876
1877 def : Pat<(or (and (v8i16 VECREG:$rA), (vnot (v8i16 VECREG:$rC))),
1878               (and (v8i16 VECREG:$rC), (v8i16 VECREG:$rB))),
1879           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1880
1881 def : Pat<(or (and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rA)),
1882               (and (v8i16 VECREG:$rB), (v8i16 VECREG:$rC))),
1883           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1884
1885 def : Pat<(or (and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rA)),
1886               (and (v8i16 VECREG:$rC), (v8i16 VECREG:$rB))),
1887           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1888
1889 def : Pat<(or (and (v8i16 VECREG:$rA), (v8i16 VECREG:$rC)),
1890               (and (v8i16 VECREG:$rB), (vnot (v8i16 VECREG:$rC)))),
1891           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1892
1893 def : Pat<(or (and (v8i16 VECREG:$rC), (v8i16 VECREG:$rA)),
1894               (and (v8i16 VECREG:$rB), (vnot (v8i16 VECREG:$rC)))),
1895           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1896
1897 def : Pat<(or (and (v8i16 VECREG:$rA), (v8i16 VECREG:$rC)),
1898               (and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rB))),
1899           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1900
1901 def : Pat<(or (and (v8i16 VECREG:$rC), (v8i16 VECREG:$rA)),
1902               (and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rB))),
1903           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1904
1905 def : Pat<(or (and (v8i16 VECREG:$rA), (vnot (v8i16 VECREG:$rC))),
1906               (and (v8i16 VECREG:$rB), (v8i16 VECREG:$rC))),
1907           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1908
1909 def : Pat<(or (and (v8i16 VECREG:$rA), (vnot (v8i16 VECREG:$rC))),
1910               (and (v8i16 VECREG:$rC), (v8i16 VECREG:$rB))),
1911           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1912
1913 def : Pat<(or (and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rA)),
1914               (and (v8i16 VECREG:$rB), (v8i16 VECREG:$rC))),
1915           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1916
1917 def : Pat<(or (and (vnot (v8i16 VECREG:$rC)), (v8i16 VECREG:$rA)),
1918               (and (v8i16 VECREG:$rC), (v8i16 VECREG:$rB))),
1919           (SELBv8i16 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1920
1921 def SELBv4i32:
1922     RRRForm<0b1000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
1923       "selb\t$rT, $rA, $rB, $rC", IntegerOp,
1924       [(set (v4i32 VECREG:$rT),
1925             (SPUselb_v4i32 (v4i32 VECREG:$rA), (v4i32 VECREG:$rB),
1926                                                (v4i32 VECREG:$rC)))]>;
1927
1928 def : Pat<(or (and (v4i32 VECREG:$rA), (v4i32 VECREG:$rC)),
1929               (and (v4i32 VECREG:$rB), (vnot (v4i32 VECREG:$rC)))),
1930           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1931
1932 def : Pat<(or (and (v4i32 VECREG:$rC), (v4i32 VECREG:$rA)),
1933               (and (v4i32 VECREG:$rB), (vnot (v4i32 VECREG:$rC)))),
1934           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1935
1936 def : Pat<(or (and (v4i32 VECREG:$rA), (v4i32 VECREG:$rC)),
1937               (and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rB))),
1938           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1939
1940 def : Pat<(or (and (v4i32 VECREG:$rC), (v4i32 VECREG:$rA)),
1941               (and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rB))),
1942           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1943
1944 def : Pat<(or (and (v4i32 VECREG:$rA), (vnot (v4i32 VECREG:$rC))),
1945               (and (v4i32 VECREG:$rB), (v4i32 VECREG:$rC))),
1946           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1947
1948 def : Pat<(or (and (v4i32 VECREG:$rA), (vnot (v4i32 VECREG:$rC))),
1949               (and (v4i32 VECREG:$rC), (v4i32 VECREG:$rB))),
1950           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1951
1952 def : Pat<(or (and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rA)),
1953               (and (v4i32 VECREG:$rB), (v4i32 VECREG:$rC))),
1954           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1955
1956 def : Pat<(or (and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rA)),
1957               (and (v4i32 VECREG:$rC), (v4i32 VECREG:$rB))),
1958           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1959
1960 def : Pat<(or (and (v4i32 VECREG:$rA), (v4i32 VECREG:$rC)),
1961               (and (v4i32 VECREG:$rB), (vnot (v4i32 VECREG:$rC)))),
1962           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1963
1964 def : Pat<(or (and (v4i32 VECREG:$rC), (v4i32 VECREG:$rA)),
1965               (and (v4i32 VECREG:$rB), (vnot (v4i32 VECREG:$rC)))),
1966           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1967
1968 def : Pat<(or (and (v4i32 VECREG:$rA), (v4i32 VECREG:$rC)),
1969               (and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rB))),
1970           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1971
1972 def : Pat<(or (and (v4i32 VECREG:$rC), (v4i32 VECREG:$rA)),
1973               (and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rB))),
1974           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1975
1976 def : Pat<(or (and (v4i32 VECREG:$rA), (vnot (v4i32 VECREG:$rC))),
1977               (and (v4i32 VECREG:$rB), (v4i32 VECREG:$rC))),
1978           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1979
1980 def : Pat<(or (and (v4i32 VECREG:$rA), (vnot (v4i32 VECREG:$rC))),
1981               (and (v4i32 VECREG:$rC), (v4i32 VECREG:$rB))),
1982           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1983
1984 def : Pat<(or (and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rA)),
1985               (and (v4i32 VECREG:$rB), (v4i32 VECREG:$rC))),
1986           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1987
1988 def : Pat<(or (and (vnot (v4i32 VECREG:$rC)), (v4i32 VECREG:$rA)),
1989               (and (v4i32 VECREG:$rC), (v4i32 VECREG:$rB))),
1990           (SELBv4i32 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
1991
1992 def SELBr32:
1993     RRRForm<0b1000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB, R32C:$rC),
1994       "selb\t$rT, $rA, $rB, $rC", IntegerOp,
1995       []>;
1996
1997 // And the various patterns that can be matched... (all 8 of them :-)
1998 def : Pat<(or (and R32C:$rA, R32C:$rC),
1999               (and R32C:$rB, (not R32C:$rC))),
2000           (SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
2001
2002 def : Pat<(or (and R32C:$rC, R32C:$rA),
2003               (and R32C:$rB, (not R32C:$rC))),
2004           (SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
2005
2006 def : Pat<(or (and R32C:$rA, R32C:$rC),
2007               (and (not R32C:$rC), R32C:$rB)),
2008           (SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
2009
2010 def : Pat<(or (and R32C:$rC, R32C:$rA),
2011               (and (not R32C:$rC), R32C:$rB)),
2012           (SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
2013
2014 def : Pat<(or (and R32C:$rA, (not R32C:$rC)),
2015               (and R32C:$rB, R32C:$rC)),
2016           (SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
2017
2018 def : Pat<(or (and R32C:$rA, (not R32C:$rC)),
2019               (and R32C:$rC, R32C:$rB)),
2020           (SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
2021
2022 def : Pat<(or (and (not R32C:$rC), R32C:$rA),
2023               (and R32C:$rB, R32C:$rC)),
2024           (SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
2025
2026 def : Pat<(or (and (not R32C:$rC), R32C:$rA),
2027               (and R32C:$rC, R32C:$rB)),
2028           (SELBr32 R32C:$rA, R32C:$rB, R32C:$rC)>;
2029
2030 def SELBr16:
2031     RRRForm<0b1000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB, R16C:$rC),
2032       "selb\t$rT, $rA, $rB, $rC", IntegerOp,
2033       []>;
2034
2035 def : Pat<(or (and R16C:$rA, R16C:$rC),
2036               (and R16C:$rB, (not R16C:$rC))),
2037           (SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
2038
2039 def : Pat<(or (and R16C:$rC, R16C:$rA),
2040               (and R16C:$rB, (not R16C:$rC))),
2041           (SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
2042
2043 def : Pat<(or (and R16C:$rA, R16C:$rC),
2044               (and (not R16C:$rC), R16C:$rB)),
2045           (SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
2046
2047 def : Pat<(or (and R16C:$rC, R16C:$rA),
2048               (and (not R16C:$rC), R16C:$rB)),
2049           (SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
2050
2051 def : Pat<(or (and R16C:$rA, (not R16C:$rC)),
2052               (and R16C:$rB, R16C:$rC)),
2053           (SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
2054
2055 def : Pat<(or (and R16C:$rA, (not R16C:$rC)),
2056               (and R16C:$rC, R16C:$rB)),
2057           (SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
2058
2059 def : Pat<(or (and (not R16C:$rC), R16C:$rA),
2060               (and R16C:$rB, R16C:$rC)),
2061           (SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
2062
2063 def : Pat<(or (and (not R16C:$rC), R16C:$rA),
2064               (and R16C:$rC, R16C:$rB)),
2065           (SELBr16 R16C:$rA, R16C:$rB, R16C:$rC)>;
2066
2067 def SELBr8:
2068     RRRForm<0b1000, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB, R8C:$rC),
2069       "selb\t$rT, $rA, $rB, $rC", IntegerOp,
2070       []>;
2071
2072 def : Pat<(or (and R8C:$rA, R8C:$rC),
2073               (and R8C:$rB, (not R8C:$rC))),
2074           (SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
2075
2076 def : Pat<(or (and R8C:$rC, R8C:$rA),
2077               (and R8C:$rB, (not R8C:$rC))),
2078           (SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
2079
2080 def : Pat<(or (and R8C:$rA, R8C:$rC),
2081               (and (not R8C:$rC), R8C:$rB)),
2082           (SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
2083
2084 def : Pat<(or (and R8C:$rC, R8C:$rA),
2085               (and (not R8C:$rC), R8C:$rB)),
2086           (SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
2087
2088 def : Pat<(or (and R8C:$rA, (not R8C:$rC)),
2089               (and R8C:$rB, R8C:$rC)),
2090           (SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
2091
2092 def : Pat<(or (and R8C:$rA, (not R8C:$rC)),
2093               (and R8C:$rC, R8C:$rB)),
2094           (SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
2095
2096 def : Pat<(or (and (not R8C:$rC), R8C:$rA),
2097               (and R8C:$rB, R8C:$rC)),
2098           (SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
2099
2100 def : Pat<(or (and (not R8C:$rC), R8C:$rA),
2101               (and R8C:$rC, R8C:$rB)),
2102           (SELBr8 R8C:$rA, R8C:$rB, R8C:$rC)>;
2103
2104 //===----------------------------------------------------------------------===//
2105 // Vector shuffle...
2106 //===----------------------------------------------------------------------===//
2107
2108 def SHUFB:
2109     RRRForm<0b1000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
2110       "shufb\t$rT, $rA, $rB, $rC", IntegerOp,
2111       [/* insert intrinsic here */]>;
2112
2113 // SPUshuffle is generated in LowerVECTOR_SHUFFLE and gets replaced with SHUFB.
2114 // See the SPUshuffle SDNode operand above, which sets up the DAG pattern
2115 // matcher to emit something when the LowerVECTOR_SHUFFLE generates a node with
2116 // the SPUISD::SHUFB opcode.
2117 def : Pat<(SPUshuffle (v16i8 VECREG:$rA), (v16i8 VECREG:$rB), VECREG:$rC),
2118           (SHUFB VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
2119
2120 def : Pat<(SPUshuffle (v8i16 VECREG:$rA), (v8i16 VECREG:$rB), VECREG:$rC),
2121           (SHUFB VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
2122
2123 def : Pat<(SPUshuffle (v4i32 VECREG:$rA), (v4i32 VECREG:$rB), VECREG:$rC),
2124           (SHUFB VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
2125
2126 def : Pat<(SPUshuffle (v2i64 VECREG:$rA), (v2i64 VECREG:$rB), VECREG:$rC),
2127           (SHUFB VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
2128
2129 //===----------------------------------------------------------------------===//
2130 // Shift and rotate group:
2131 //===----------------------------------------------------------------------===//
2132
2133 def SHLHv8i16:
2134     RRForm<0b11111010000, (outs VECREG:$rT), (ins VECREG:$rA, R16C:$rB),
2135       "shlh\t$rT, $rA, $rB", RotateShift,
2136       [(set (v8i16 VECREG:$rT),
2137             (SPUvec_shl_v8i16 (v8i16 VECREG:$rA), R16C:$rB))]>;
2138
2139 // $rB gets promoted to 32-bit register type when confronted with
2140 // this llvm assembly code:
2141 //
2142 // define i16 @shlh_i16_1(i16 %arg1, i16 %arg2) {
2143 //      %A = shl i16 %arg1, %arg2
2144 //      ret i16 %A
2145 // }
2146 //
2147 // However, we will generate this code when lowering 8-bit shifts and rotates.
2148
2149 def SHLHr16:
2150     RRForm<0b11111010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
2151       "shlh\t$rT, $rA, $rB", RotateShift,
2152       [(set R16C:$rT, (shl R16C:$rA, R16C:$rB))]>;
2153
2154 def SHLHr16_r32:
2155     RRForm<0b11111010000, (outs R16C:$rT), (ins R16C:$rA, R32C:$rB),
2156       "shlh\t$rT, $rA, $rB", RotateShift,
2157       [(set R16C:$rT, (shl R16C:$rA, R32C:$rB))]>;
2158
2159 def SHLHIv8i16:
2160     RI7Form<0b11111010000, (outs VECREG:$rT), (ins VECREG:$rA, u7imm_i8:$val),
2161       "shlhi\t$rT, $rA, $val", RotateShift,
2162       [(set (v8i16 VECREG:$rT),
2163             (SPUvec_shl_v8i16 (v8i16 VECREG:$rA), (i8 uimm7:$val)))]>;
2164
2165 def : Pat<(SPUvec_shl_v8i16 (v8i16 VECREG:$rA), (i16 uimm7:$val)),
2166           (SHLHIv8i16 VECREG:$rA, imm:$val)>;
2167
2168 def : Pat<(SPUvec_shl_v8i16 (v8i16 VECREG:$rA), (i32 uimm7:$val)),
2169           (SHLHIv8i16 VECREG:$rA, imm:$val)>;
2170
2171 def SHLHIr16:
2172     RI7Form<0b11111010000, (outs R16C:$rT), (ins R16C:$rA, u7imm_i32:$val),
2173       "shlhi\t$rT, $rA, $val", RotateShift,
2174       [(set R16C:$rT, (shl R16C:$rA, (i32 uimm7:$val)))]>;
2175
2176 def : Pat<(shl R16C:$rA, (i8 uimm7:$val)),
2177           (SHLHIr16 R16C:$rA, uimm7:$val)>;
2178
2179 def : Pat<(shl R16C:$rA, (i16 uimm7:$val)),
2180           (SHLHIr16 R16C:$rA, uimm7:$val)>;
2181
2182 def SHLv4i32:
2183     RRForm<0b11111010000, (outs VECREG:$rT), (ins VECREG:$rA, R16C:$rB),
2184       "shl\t$rT, $rA, $rB", RotateShift,
2185       [(set (v4i32 VECREG:$rT),
2186             (SPUvec_shl_v4i32 (v4i32 VECREG:$rA), R16C:$rB))]>;
2187
2188 def SHLr32:
2189     RRForm<0b11111010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
2190       "shl\t$rT, $rA, $rB", RotateShift,
2191       [(set R32C:$rT, (shl R32C:$rA, R32C:$rB))]>;
2192
2193 def SHLIv4i32:
2194     RI7Form<0b11111010000, (outs VECREG:$rT), (ins VECREG:$rA, u7imm_i8:$val),
2195       "shli\t$rT, $rA, $val", RotateShift,
2196       [(set (v4i32 VECREG:$rT),
2197             (SPUvec_shl_v4i32 (v4i32 VECREG:$rA), (i8 uimm7:$val)))]>;
2198
2199 def: Pat<(SPUvec_shl_v4i32 (v4i32 VECREG:$rA), (i16 uimm7:$val)),
2200          (SHLIv4i32 VECREG:$rA, uimm7:$val)>;
2201
2202 def: Pat<(SPUvec_shl_v4i32 (v4i32 VECREG:$rA), (i32 uimm7:$val)),
2203          (SHLIv4i32 VECREG:$rA, uimm7:$val)>;
2204
2205 def SHLIr32:
2206     RI7Form<0b11111010000, (outs R32C:$rT), (ins R32C:$rA, u7imm_i32:$val),
2207       "shli\t$rT, $rA, $val", RotateShift,
2208       [(set R32C:$rT, (shl R32C:$rA, (i32 uimm7:$val)))]>;
2209
2210 def : Pat<(shl R32C:$rA, (i16 uimm7:$val)),
2211           (SHLIr32 R32C:$rA, uimm7:$val)>;
2212
2213 def : Pat<(shl R32C:$rA, (i8 uimm7:$val)),
2214           (SHLIr32 R32C:$rA, uimm7:$val)>;
2215
2216 // SHLQBI vec form: Note that this will shift the entire vector (the 128-bit
2217 // register) to the left. Vector form is here to ensure type correctness.
2218 def SHLQBIvec:
2219     RRForm<0b11011011100, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
2220       "shlqbi\t$rT, $rA, $rB", RotateShift,
2221       [/* intrinsic */]>;
2222
2223 // See note above on SHLQBI.
2224 def SHLQBIIvec:
2225     RI7Form<0b11011111100, (outs VECREG:$rT), (ins VECREG:$rA, u7imm:$val),
2226       "shlqbii\t$rT, $rA, $val", RotateShift,
2227       [/* intrinsic */]>;
2228
2229 // SHLQBY, SHLQBYI vector forms: Shift the entire vector to the left by bytes,
2230 // not by bits.
2231 def SHLQBYvec:
2232     RI7Form<0b11111011100, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
2233       "shlqbyi\t$rT, $rA, $rB", RotateShift,
2234       [/* intrinsic */]>;
2235
2236 def SHLQBYIvec:
2237     RI7Form<0b11111111100, (outs VECREG:$rT), (ins VECREG:$rA, u7imm:$val),
2238       "shlqbyi\t$rT, $rA, $val", RotateShift,
2239       [/* intrinsic */]>;
2240
2241 // ROTH v8i16 form:
2242 def ROTHv8i16:
2243     RRForm<0b00111010000, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
2244       "roth\t$rT, $rA, $rB", RotateShift,
2245       [(set (v8i16 VECREG:$rT),
2246             (SPUvec_rotl_v8i16 VECREG:$rA, VECREG:$rB))]>;
2247
2248 def ROTHr16:
2249     RRForm<0b00111010000, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
2250       "roth\t$rT, $rA, $rB", RotateShift,
2251       [(set R16C:$rT, (rotl R16C:$rA, R16C:$rB))]>;
2252
2253 def ROTHr16_r32:
2254     RRForm<0b00111010000, (outs R16C:$rT), (ins R16C:$rA, R32C:$rB),
2255       "roth\t$rT, $rA, $rB", RotateShift,
2256       [(set R16C:$rT, (rotl R16C:$rA, R32C:$rB))]>;
2257
2258 // The rotate amount is in the same bits whether we've got an 8-bit, 16-bit or
2259 // 32-bit register
2260 def ROTHr16_r8:
2261     RRForm<0b00111010000, (outs R16C:$rT), (ins R16C:$rA, R8C:$rB),
2262       "roth\t$rT, $rA, $rB", RotateShift,
2263       [(set R16C:$rT, (rotl R16C:$rA, (i32 (zext R8C:$rB))))]>;
2264
2265 def : Pat<(rotl R16C:$rA, (i32 (sext R8C:$rB))),
2266           (ROTHr16_r8 R16C:$rA, R8C:$rB)>;
2267
2268 def : Pat<(rotl R16C:$rA, (i32 (zext R8C:$rB))),
2269           (ROTHr16_r8 R16C:$rA, R8C:$rB)>;
2270
2271 def : Pat<(rotl R16C:$rA, (i32 (anyext R8C:$rB))),
2272           (ROTHr16_r8 R16C:$rA, R8C:$rB)>;
2273
2274 def ROTHIv8i16:
2275     RI7Form<0b00111110000, (outs VECREG:$rT), (ins VECREG:$rA, u7imm_i8:$val),
2276       "rothi\t$rT, $rA, $val", RotateShift,
2277       [(set (v8i16 VECREG:$rT),
2278             (SPUvec_rotl_v8i16 VECREG:$rA, (i8 uimm7:$val)))]>;
2279
2280 def : Pat<(SPUvec_rotl_v8i16 VECREG:$rA, (i16 uimm7:$val)),
2281           (ROTHIv8i16 VECREG:$rA, imm:$val)>;
2282
2283 def : Pat<(SPUvec_rotl_v8i16 VECREG:$rA, (i32 uimm7:$val)),
2284           (ROTHIv8i16 VECREG:$rA, imm:$val)>;
2285
2286 def ROTHIr16:
2287     RI7Form<0b00111110000, (outs R16C:$rT), (ins R16C:$rA, u7imm:$val),
2288       "rothi\t$rT, $rA, $val", RotateShift,
2289       [(set R16C:$rT, (rotl R16C:$rA, (i16 uimm7:$val)))]>;
2290
2291 def ROTHIr16_i32:
2292     RI7Form<0b00111110000, (outs R16C:$rT), (ins R16C:$rA, u7imm_i32:$val),
2293       "rothi\t$rT, $rA, $val", RotateShift,
2294       [(set R16C:$rT, (rotl R16C:$rA, (i32 uimm7:$val)))]>;
2295
2296 def ROTHIr16_i8:
2297     RI7Form<0b00111110000, (outs R16C:$rT), (ins R16C:$rA, u7imm_i8:$val),
2298       "rothi\t$rT, $rA, $val", RotateShift,
2299       [(set R16C:$rT, (rotl R16C:$rA, (i8 uimm7:$val)))]>;
2300
2301 def ROTv4i32:
2302     RRForm<0b00011010000, (outs VECREG:$rT), (ins VECREG:$rA, R32C:$rB),
2303       "rot\t$rT, $rA, $rB", RotateShift,
2304       [(set (v4i32 VECREG:$rT),
2305             (SPUvec_rotl_v4i32 (v4i32 VECREG:$rA), R32C:$rB))]>;
2306
2307 def ROTr32:
2308     RRForm<0b00011010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
2309       "rot\t$rT, $rA, $rB", RotateShift,
2310       [(set R32C:$rT, (rotl R32C:$rA, R32C:$rB))]>;
2311
2312 // The rotate amount is in the same bits whether we've got an 8-bit, 16-bit or
2313 // 32-bit register
2314 def ROTr32_r16_anyext:
2315     RRForm<0b00011010000, (outs R32C:$rT), (ins R32C:$rA, R16C:$rB),
2316       "rot\t$rT, $rA, $rB", RotateShift,
2317       [(set R32C:$rT, (rotl R32C:$rA, (i32 (anyext R16C:$rB))))]>;
2318
2319 def : Pat<(rotl R32C:$rA, (i32 (zext R16C:$rB))),
2320           (ROTr32_r16_anyext R32C:$rA, R16C:$rB)>;
2321
2322 def : Pat<(rotl R32C:$rA, (i32 (sext R16C:$rB))),
2323           (ROTr32_r16_anyext R32C:$rA, R16C:$rB)>;
2324
2325 def ROTr32_r8_anyext:
2326     RRForm<0b00011010000, (outs R32C:$rT), (ins R32C:$rA, R8C:$rB),
2327       "rot\t$rT, $rA, $rB", RotateShift,
2328       [(set R32C:$rT, (rotl R32C:$rA, (i32 (anyext R8C:$rB))))]>;
2329
2330 def : Pat<(rotl R32C:$rA, (i32 (zext R8C:$rB))),
2331           (ROTr32_r8_anyext R32C:$rA, R8C:$rB)>;
2332
2333 def : Pat<(rotl R32C:$rA, (i32 (sext R8C:$rB))),
2334           (ROTr32_r8_anyext R32C:$rA, R8C:$rB)>;
2335
2336 def ROTIv4i32:
2337     RI7Form<0b00011110000, (outs VECREG:$rT), (ins VECREG:$rA, u7imm_i32:$val),
2338       "roti\t$rT, $rA, $val", RotateShift,
2339       [(set (v4i32 VECREG:$rT),
2340             (SPUvec_rotl_v4i32 (v4i32 VECREG:$rA), (i32 uimm7:$val)))]>;
2341
2342 def : Pat<(SPUvec_rotl_v4i32 (v4i32 VECREG:$rA), (i16 uimm7:$val)),
2343           (ROTIv4i32 VECREG:$rA, imm:$val)>;
2344
2345 def : Pat<(SPUvec_rotl_v4i32 (v4i32 VECREG:$rA), (i8 uimm7:$val)),
2346            (ROTIv4i32 VECREG:$rA, imm:$val)>;
2347
2348 def ROTIr32:
2349     RI7Form<0b00011110000, (outs R32C:$rT), (ins R32C:$rA, u7imm_i32:$val),
2350       "roti\t$rT, $rA, $val", RotateShift,
2351       [(set R32C:$rT, (rotl R32C:$rA, (i32 uimm7:$val)))]>;
2352
2353 def ROTIr32_i16:
2354     RI7Form<0b00111110000, (outs R32C:$rT), (ins R32C:$rA, u7imm:$val),
2355       "roti\t$rT, $rA, $val", RotateShift,
2356       [(set R32C:$rT, (rotl R32C:$rA, (i16 uimm7:$val)))]>;
2357
2358 def ROTIr32_i8:
2359     RI7Form<0b00111110000, (outs R32C:$rT), (ins R32C:$rA, u7imm_i8:$val),
2360       "roti\t$rT, $rA, $val", RotateShift,
2361       [(set R32C:$rT, (rotl R32C:$rA, (i8 uimm7:$val)))]>;
2362
2363 // ROTQBY* vector forms: This rotates the entire vector, but vector registers
2364 // are used here for type checking (instances where ROTQBI is used actually
2365 // use vector registers)
2366 def ROTQBYvec:
2367     RRForm<0b00111011100, (outs VECREG:$rT), (ins VECREG:$rA, R16C:$rB),
2368       "rotqby\t$rT, $rA, $rB", RotateShift,
2369       [(set (v16i8 VECREG:$rT), (SPUrotbytes_left (v16i8 VECREG:$rA), R16C:$rB))]>;
2370
2371 def : Pat<(SPUrotbytes_left_chained (v16i8 VECREG:$rA), R16C:$rB),
2372           (ROTQBYvec VECREG:$rA, R16C:$rB)>;
2373
2374 // See ROTQBY note above.
2375 def ROTQBYIvec:
2376     RI7Form<0b00111111100, (outs VECREG:$rT), (ins VECREG:$rA, u7imm:$val),
2377       "rotqbyi\t$rT, $rA, $val", RotateShift,
2378       [(set (v16i8 VECREG:$rT),
2379             (SPUrotbytes_left (v16i8 VECREG:$rA), (i16 uimm7:$val)))]>;
2380
2381 def : Pat<(SPUrotbytes_left_chained (v16i8 VECREG:$rA), (i16 uimm7:$val)),
2382           (ROTQBYIvec VECREG:$rA, uimm7:$val)>;
2383
2384 // See ROTQBY note above.
2385 def ROTQBYBIvec:
2386     RI7Form<0b00110011100, (outs VECREG:$rT), (ins VECREG:$rA, u7imm:$val),
2387       "rotqbybi\t$rT, $rA, $val", RotateShift,
2388       [/* intrinsic */]>;
2389
2390 // See ROTQBY note above.
2391 //
2392 // Assume that the user of this instruction knows to shift the rotate count
2393 // into bit 29
2394 def ROTQBIvec:
2395     RRForm<0b00011011100, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
2396       "rotqbi\t$rT, $rA, $rB", RotateShift,
2397       [/* insert intrinsic here */]>;
2398
2399 // See ROTQBY note above.
2400 def ROTQBIIvec:
2401     RI7Form<0b00011111100, (outs VECREG:$rT), (ins VECREG:$rA, u7imm_i32:$val),
2402       "rotqbii\t$rT, $rA, $val", RotateShift,
2403       [/* insert intrinsic here */]>;
2404
2405 // ROTHM v8i16 form:
2406 // NOTE(1): No vector rotate is generated by the C/C++ frontend (today),
2407 //          so this only matches a synthetically generated/lowered code
2408 //          fragment.
2409 // NOTE(2): $rB must be negated before the right rotate!
2410 def ROTHMv8i16:
2411     RRForm<0b10111010000, (outs VECREG:$rT), (ins VECREG:$rA, R32C:$rB),
2412       "rothm\t$rT, $rA, $rB", RotateShift,
2413       [/* see patterns below - $rB must be negated */]>;
2414
2415 def : Pat<(SPUvec_srl_v8i16 (v8i16 VECREG:$rA), R32C:$rB),
2416           (ROTHMv8i16 VECREG:$rA, (SFIr32 R32C:$rB, 0))>;
2417
2418 def : Pat<(SPUvec_srl_v8i16 (v8i16 VECREG:$rA), R16C:$rB),
2419           (ROTHMv8i16 VECREG:$rA,
2420                       (SFIr32 (XSHWr16 R16C:$rB), 0))>;
2421
2422 def : Pat<(SPUvec_srl_v8i16 (v8i16 VECREG:$rA), R8C:$rB),
2423           (ROTHMv8i16 VECREG:$rA,
2424                       (SFIr32 (XSHWr16 (XSBHr8 R8C:$rB) ), 0))>;
2425
2426 // ROTHM r16 form: Rotate 16-bit quantity to right, zero fill at the left
2427 // Note: This instruction doesn't match a pattern because rB must be negated
2428 // for the instruction to work. Thus, the pattern below the instruction!
2429 def ROTHMr16:
2430     RRForm<0b10111010000, (outs R16C:$rT), (ins R16C:$rA, R32C:$rB),
2431       "rothm\t$rT, $rA, $rB", RotateShift,
2432       [/* see patterns below - $rB must be negated! */]>;
2433
2434 def : Pat<(srl R16C:$rA, R32C:$rB),
2435           (ROTHMr16 R16C:$rA, (SFIr32 R32C:$rB, 0))>;
2436
2437 def : Pat<(srl R16C:$rA, R16C:$rB),
2438           (ROTHMr16 R16C:$rA,
2439                     (SFIr32 (XSHWr16 R16C:$rB), 0))>;
2440
2441 def : Pat<(srl R16C:$rA, R8C:$rB),
2442           (ROTHMr16 R16C:$rA,
2443                     (SFIr32 (XSHWr16 (XSBHr8 R8C:$rB) ), 0))>;
2444
2445 // ROTHMI v8i16 form: See the comment for ROTHM v8i16. The difference here is
2446 // that the immediate can be complemented, so that the user doesn't have to
2447 // worry about it.
2448 def ROTHMIv8i16:
2449     RI7Form<0b10111110000, (outs VECREG:$rT), (ins VECREG:$rA, rothNeg7imm:$val),
2450       "rothmi\t$rT, $rA, $val", RotateShift,
2451       [(set (v8i16 VECREG:$rT),
2452             (SPUvec_srl_v8i16 (v8i16 VECREG:$rA), (i32 imm:$val)))]>;
2453
2454 def: Pat<(SPUvec_srl_v8i16 (v8i16 VECREG:$rA), (i16 imm:$val)),
2455          (ROTHMIv8i16 VECREG:$rA, imm:$val)>;
2456
2457 def: Pat<(SPUvec_srl_v8i16 (v8i16 VECREG:$rA), (i8 imm:$val)),
2458          (ROTHMIv8i16 VECREG:$rA, imm:$val)>;
2459
2460 def ROTHMIr16:
2461     RI7Form<0b10111110000, (outs R16C:$rT), (ins R16C:$rA, rothNeg7imm:$val),
2462       "rothmi\t$rT, $rA, $val", RotateShift,
2463       [(set R16C:$rT, (srl R16C:$rA, (i32 uimm7:$val)))]>;
2464
2465 def: Pat<(srl R16C:$rA, (i16 uimm7:$val)),
2466          (ROTHMIr16 R16C:$rA, uimm7:$val)>;
2467
2468 def: Pat<(srl R16C:$rA, (i8 uimm7:$val)),
2469          (ROTHMIr16 R16C:$rA, uimm7:$val)>;
2470
2471 // ROTM v4i32 form: See the ROTHM v8i16 comments.
2472 def ROTMv4i32:
2473     RRForm<0b10011010000, (outs VECREG:$rT), (ins VECREG:$rA, R32C:$rB),
2474       "rotm\t$rT, $rA, $rB", RotateShift,
2475       [/* see patterns below - $rB must be negated */]>;
2476
2477 def : Pat<(SPUvec_srl_v4i32 VECREG:$rA, R32C:$rB),
2478           (ROTMv4i32 VECREG:$rA, (SFIr32 R32C:$rB, 0))>;
2479
2480 def : Pat<(SPUvec_srl_v4i32 VECREG:$rA, R16C:$rB),
2481           (ROTMv4i32 VECREG:$rA,
2482                      (SFIr32 (XSHWr16 R16C:$rB), 0))>;
2483
2484 def : Pat<(SPUvec_srl_v4i32 VECREG:$rA, /* R8C */ R16C:$rB),
2485           (ROTMv4i32 VECREG:$rA,
2486                      (SFIr32 (XSHWr16 /* (XSBHr8 R8C */ R16C:$rB) /*)*/, 0))>;
2487
2488 def ROTMr32:
2489     RRForm<0b10011010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
2490       "rotm\t$rT, $rA, $rB", RotateShift,
2491       [/* see patterns below - $rB must be negated */]>;
2492
2493 def : Pat<(srl R32C:$rA, R32C:$rB),
2494           (ROTMr32 R32C:$rA, (SFIr32 R32C:$rB, 0))>;
2495
2496 def : Pat<(srl R32C:$rA, R16C:$rB),
2497           (ROTMr32 R32C:$rA,
2498                    (SFIr32 (XSHWr16 R16C:$rB), 0))>;
2499
2500 def : Pat<(srl R32C:$rA, R8C:$rB),
2501           (ROTMr32 R32C:$rA,
2502                    (SFIr32 (XSHWr16 (XSBHr8 R8C:$rB)), 0))>;
2503
2504 // ROTMI v4i32 form: See the comment for ROTHM v8i16.
2505 def ROTMIv4i32:
2506     RI7Form<0b10011110000, (outs VECREG:$rT), (ins VECREG:$rA, rotNeg7imm:$val),
2507       "rotmi\t$rT, $rA, $val", RotateShift,
2508       [(set (v4i32 VECREG:$rT),
2509             (SPUvec_srl_v4i32 VECREG:$rA, (i32 uimm7:$val)))]>;
2510
2511 def : Pat<(SPUvec_srl_v4i32 VECREG:$rA, (i16 uimm7:$val)),
2512           (ROTMIv4i32 VECREG:$rA, uimm7:$val)>;
2513
2514 def : Pat<(SPUvec_srl_v4i32 VECREG:$rA, (i8 uimm7:$val)),
2515           (ROTMIv4i32 VECREG:$rA, uimm7:$val)>;
2516
2517 // ROTMI r32 form: know how to complement the immediate value.
2518 def ROTMIr32:
2519     RI7Form<0b10011110000, (outs R32C:$rT), (ins R32C:$rA, rotNeg7imm:$val),
2520       "rotmi\t$rT, $rA, $val", RotateShift,
2521       [(set R32C:$rT, (srl R32C:$rA, (i32 uimm7:$val)))]>;
2522
2523 def : Pat<(srl R32C:$rA, (i16 imm:$val)),
2524           (ROTMIr32 R32C:$rA, uimm7:$val)>;
2525
2526 def : Pat<(srl R32C:$rA, (i8 imm:$val)),
2527           (ROTMIr32 R32C:$rA, uimm7:$val)>;
2528
2529 // ROTQMBYvec: This is a vector form merely so that when used in an
2530 // instruction pattern, type checking will succeed. This instruction assumes
2531 // that the user knew to complement $rB.
2532 def ROTQMBYvec:
2533     RRForm<0b10111011100, (outs VECREG:$rT), (ins VECREG:$rA, R32C:$rB),
2534       "rotqmby\t$rT, $rA, $rB", RotateShift,
2535       [(set (v16i8 VECREG:$rT),
2536             (SPUrotbytes_right_zfill (v16i8 VECREG:$rA), R32C:$rB))]>;
2537
2538 def ROTQMBYIvec:
2539     RI7Form<0b10111111100, (outs VECREG:$rT), (ins VECREG:$rA, rotNeg7imm:$val),
2540       "rotqmbyi\t$rT, $rA, $val", RotateShift,
2541       [(set (v16i8 VECREG:$rT),
2542             (SPUrotbytes_right_zfill (v16i8 VECREG:$rA), (i32 uimm7:$val)))]>;
2543
2544 def : Pat<(SPUrotbytes_right_zfill VECREG:$rA, (i16 uimm7:$val)),
2545           (ROTQMBYIvec VECREG:$rA, uimm7:$val)>;
2546
2547 def ROTQMBYBIvec:
2548     RRForm<0b10110011100, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
2549       "rotqmbybi\t$rT, $rA, $rB", RotateShift,
2550       [/* intrinsic */]>;
2551
2552 def ROTQMBIvec:
2553     RRForm<0b10011011100, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
2554       "rotqmbi\t$rT, $rA, $rB", RotateShift,
2555       [/* intrinsic */]>;
2556
2557 def ROTQMBIIvec:
2558     RI7Form<0b10011111100, (outs VECREG:$rT), (ins VECREG:$rA, rotNeg7imm:$val),
2559       "rotqmbii\t$rT, $rA, $val", RotateShift,
2560       [/* intrinsic */]>;
2561
2562 def ROTMAHv8i16:
2563     RRForm<0b01111010000, (outs VECREG:$rT), (ins VECREG:$rA, R32C:$rB),
2564       "rotmah\t$rT, $rA, $rB", RotateShift,
2565       [/* see patterns below - $rB must be negated */]>;
2566
2567 def : Pat<(SPUvec_sra_v8i16 VECREG:$rA, R32C:$rB),
2568           (ROTMAHv8i16 VECREG:$rA, (SFIr32 R32C:$rB, 0))>;
2569
2570 def : Pat<(SPUvec_sra_v8i16 VECREG:$rA, R16C:$rB),
2571           (ROTMAHv8i16 VECREG:$rA,
2572                        (SFIr32 (XSHWr16 R16C:$rB), 0))>;
2573
2574 def : Pat<(SPUvec_sra_v8i16 VECREG:$rA, R8C:$rB),
2575           (ROTMAHv8i16 VECREG:$rA,
2576                        (SFIr32 (XSHWr16 (XSBHr8 R8C:$rB)), 0))>;
2577
2578 def ROTMAHr16:
2579     RRForm<0b01111010000, (outs R16C:$rT), (ins R16C:$rA, R32C:$rB),
2580       "rotmah\t$rT, $rA, $rB", RotateShift,
2581       [/* see patterns below - $rB must be negated */]>;
2582
2583 def : Pat<(sra R16C:$rA, R32C:$rB),
2584           (ROTMAHr16 R16C:$rA, (SFIr32 R32C:$rB, 0))>;
2585
2586 def : Pat<(sra R16C:$rA, R16C:$rB),
2587           (ROTMAHr16 R16C:$rA,
2588                      (SFIr32 (XSHWr16 R16C:$rB), 0))>;
2589
2590 def : Pat<(sra R16C:$rA, R8C:$rB),
2591           (ROTMAHr16 R16C:$rA,
2592                      (SFIr32 (XSHWr16 (XSBHr8 R8C:$rB)), 0))>;
2593
2594 def ROTMAHIv8i16:
2595     RRForm<0b01111110000, (outs VECREG:$rT), (ins VECREG:$rA, rothNeg7imm:$val),
2596       "rotmahi\t$rT, $rA, $val", RotateShift,
2597       [(set (v8i16 VECREG:$rT),
2598             (SPUvec_sra_v8i16 (v8i16 VECREG:$rA), (i32 uimm7:$val)))]>;
2599
2600 def : Pat<(SPUvec_sra_v8i16 (v8i16 VECREG:$rA), (i16 uimm7:$val)),
2601           (ROTMAHIv8i16 (v8i16 VECREG:$rA), (i32 uimm7:$val))>;
2602
2603 def : Pat<(SPUvec_sra_v8i16 (v8i16 VECREG:$rA), (i8 uimm7:$val)),
2604           (ROTMAHIv8i16 (v8i16 VECREG:$rA), (i32 uimm7:$val))>;
2605
2606 def ROTMAHIr16:
2607     RRForm<0b01111110000, (outs R16C:$rT), (ins R16C:$rA, rothNeg7imm_i16:$val),
2608       "rotmahi\t$rT, $rA, $val", RotateShift,
2609       [(set R16C:$rT, (sra R16C:$rA, (i16 uimm7:$val)))]>;
2610
2611 def : Pat<(sra R16C:$rA, (i32 imm:$val)),
2612           (ROTMAHIr16 R16C:$rA, uimm7:$val)>;
2613
2614 def : Pat<(sra R16C:$rA, (i8 imm:$val)),
2615           (ROTMAHIr16 R16C:$rA, uimm7:$val)>;
2616
2617 def ROTMAv4i32:
2618     RRForm<0b01011010000, (outs VECREG:$rT), (ins VECREG:$rA, R32C:$rB),
2619       "rotma\t$rT, $rA, $rB", RotateShift,
2620       [/* see patterns below - $rB must be negated */]>;
2621
2622 def : Pat<(SPUvec_sra_v4i32 VECREG:$rA, R32C:$rB),
2623           (ROTMAv4i32 (v4i32 VECREG:$rA), (SFIr32 R32C:$rB, 0))>;
2624
2625 def : Pat<(SPUvec_sra_v4i32 VECREG:$rA, R16C:$rB),
2626           (ROTMAv4i32 (v4i32 VECREG:$rA),
2627                       (SFIr32 (XSHWr16 R16C:$rB), 0))>;
2628
2629 def : Pat<(SPUvec_sra_v4i32 VECREG:$rA, R8C:$rB),
2630           (ROTMAv4i32 (v4i32 VECREG:$rA),
2631                       (SFIr32 (XSHWr16 (XSBHr8 R8C:$rB)), 0))>;
2632
2633 def ROTMAr32:
2634     RRForm<0b01011010000, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
2635       "rotma\t$rT, $rA, $rB", RotateShift,
2636       [/* see patterns below - $rB must be negated */]>;
2637
2638 def : Pat<(sra R32C:$rA, R32C:$rB),
2639           (ROTMAr32 R32C:$rA, (SFIr32 R32C:$rB, 0))>;
2640
2641 def : Pat<(sra R32C:$rA, R16C:$rB),
2642           (ROTMAr32 R32C:$rA,
2643                     (SFIr32 (XSHWr16 R16C:$rB), 0))>;
2644
2645 def : Pat<(sra R32C:$rA, R8C:$rB),
2646           (ROTMAr32 R32C:$rA,
2647                     (SFIr32 (XSHWr16 (XSBHr8 R8C:$rB)), 0))>;
2648
2649 def ROTMAIv4i32:
2650     RRForm<0b01011110000, (outs VECREG:$rT), (ins VECREG:$rA, rotNeg7imm:$val),
2651       "rotmai\t$rT, $rA, $val", RotateShift,
2652       [(set (v4i32 VECREG:$rT),
2653             (SPUvec_sra_v4i32 VECREG:$rA, (i32 uimm7:$val)))]>;
2654
2655 def : Pat<(SPUvec_sra_v4i32 VECREG:$rA, (i16 uimm7:$val)),
2656           (ROTMAIv4i32 VECREG:$rA, uimm7:$val)>;
2657
2658 def ROTMAIr32:
2659     RRForm<0b01011110000, (outs R32C:$rT), (ins R32C:$rA, rotNeg7imm:$val),
2660       "rotmai\t$rT, $rA, $val", RotateShift,
2661       [(set R32C:$rT, (sra R32C:$rA, (i32 uimm7:$val)))]>;
2662
2663 def : Pat<(sra R32C:$rA, (i16 uimm7:$val)),
2664           (ROTMAIr32 R32C:$rA, uimm7:$val)>;
2665
2666 def : Pat<(sra R32C:$rA, (i8 uimm7:$val)),
2667           (ROTMAIr32 R32C:$rA, uimm7:$val)>;
2668
2669 //===----------------------------------------------------------------------===//
2670 // Branch and conditionals:
2671 //===----------------------------------------------------------------------===//
2672
2673 let isTerminator = 1, isBarrier = 1 in {
2674   // Halt If Equal (r32 preferred slot only, no vector form)
2675   def HEQr32:
2676     RRForm_3<0b00011011110, (outs), (ins R32C:$rA, R32C:$rB),
2677       "heq\t$rA, $rB", BranchResolv,
2678       [/* no pattern to match */]>;
2679
2680   def HEQIr32 :
2681     RI10Form_2<0b11111110, (outs), (ins R32C:$rA, s10imm:$val),
2682       "heqi\t$rA, $val", BranchResolv,
2683       [/* no pattern to match */]>;
2684
2685   // HGT/HGTI: These instructions use signed arithmetic for the comparison,
2686   // contrasting with HLGT/HLGTI, which use unsigned comparison:
2687   def HGTr32:
2688     RRForm_3<0b00011010010, (outs), (ins R32C:$rA, R32C:$rB),
2689       "hgt\t$rA, $rB", BranchResolv,
2690       [/* no pattern to match */]>;
2691
2692   def HGTIr32:
2693     RI10Form_2<0b11110010, (outs), (ins R32C:$rA, s10imm:$val),
2694       "hgti\t$rA, $val", BranchResolv,
2695       [/* no pattern to match */]>;
2696
2697   def HLGTr32:
2698     RRForm_3<0b00011011010, (outs), (ins R32C:$rA, R32C:$rB),
2699       "hlgt\t$rA, $rB", BranchResolv,
2700       [/* no pattern to match */]>;
2701
2702   def HLGTIr32:
2703     RI10Form_2<0b11111010, (outs), (ins R32C:$rA, s10imm:$val),
2704       "hlgti\t$rA, $val", BranchResolv,
2705       [/* no pattern to match */]>;
2706 }
2707
2708 // Comparison operators:
2709 def CEQBr8:
2710   RRForm<0b00001011110, (outs R8C:$rT), (ins R8C:$rA, R8C:$rB),
2711     "ceqb\t$rT, $rA, $rB", ByteOp,
2712     [/* no pattern to match */]>;
2713
2714 def CEQBv16i8:
2715   RRForm<0b00001011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
2716     "ceqb\t$rT, $rA, $rB", ByteOp,
2717     [/* no pattern to match: intrinsic */]>;
2718
2719 def CEQBIr8:
2720   RI10Form<0b01111110, (outs R8C:$rT), (ins R8C:$rA, s7imm:$val),
2721     "ceqbi\t$rT, $rA, $val", ByteOp,
2722     [/* no pattern to match: intrinsic */]>;
2723
2724 def CEQBIv16i8:
2725   RI10Form<0b01111110, (outs VECREG:$rT), (ins VECREG:$rA, s7imm:$val),
2726     "ceqbi\t$rT, $rA, $val", ByteOp,
2727     [/* no pattern to match: intrinsic */]>;
2728
2729 def CEQHr16:
2730   RRForm<0b00010011110, (outs R16C:$rT), (ins R16C:$rA, R16C:$rB),
2731     "ceqh\t$rT, $rA, $rB", ByteOp,
2732     [/* no pattern to match */]>;
2733
2734 def CEQHv8i16:
2735   RRForm<0b00010011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
2736     "ceqh\t$rT, $rA, $rB", ByteOp,
2737     [/* no pattern to match: intrinsic */]>;
2738
2739 def CEQHIr16:
2740   RI10Form<0b10111110, (outs R16C:$rT), (ins R16C:$rA, s10imm:$val),
2741     "ceqhi\t$rT, $rA, $val", ByteOp,
2742     [/* no pattern to match: intrinsic */]>;
2743
2744 def CEQHIv8i16:
2745   RI10Form<0b10111110, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
2746     "ceqhi\t$rT, $rA, $val", ByteOp,
2747     [/* no pattern to match: intrinsic */]>;
2748
2749 def CEQr32:
2750   RRForm<0b00000011110, (outs R32C:$rT), (ins R32C:$rA, R32C:$rB),
2751     "ceq\t$rT, $rA, $rB", ByteOp,
2752     [/* no pattern to match: intrinsic */]>;
2753
2754 def CEQv4i32:
2755   RRForm<0b00000011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
2756     "ceq\t$rT, $rA, $rB", ByteOp,
2757     [/* no pattern to match: intrinsic */]>;
2758
2759 def CEQIr32:
2760   RI10Form<0b00111110, (outs R32C:$rT), (ins R32C:$rA, s10imm:$val),
2761     "ceqi\t$rT, $rA, $val", ByteOp,
2762     [/* no pattern to match: intrinsic */]>;
2763
2764 def CEQIv4i32:
2765   RI10Form<0b00111110, (outs VECREG:$rT), (ins VECREG:$rA, s10imm:$val),
2766     "ceqi\t$rT, $rA, $val", ByteOp,
2767     [/* no pattern to match: intrinsic */]>;
2768
2769 let isCall = 1,
2770   // All calls clobber the non-callee-saved registers:
2771   Defs = [R0, R1, R2, R3, R4, R5, R6, R7, R8, R9,
2772           R10,R11,R12,R13,R14,R15,R16,R17,R18,R19,
2773           R20,R21,R22,R23,R24,R25,R26,R27,R28,R29,
2774           R30,R31,R32,R33,R34,R35,R36,R37,R38,R39,
2775           R40,R41,R42,R43,R44,R45,R46,R47,R48,R49,
2776           R50,R51,R52,R53,R54,R55,R56,R57,R58,R59,
2777           R60,R61,R62,R63,R64,R65,R66,R67,R68,R69,
2778           R70,R71,R72,R73,R74,R75,R76,R77,R78,R79],
2779   // All of these instructions use $lr (aka $0)
2780   Uses = [R0]  in {
2781   // Branch relative and set link: Used if we actually know that the target
2782   // is within [-32768, 32767] bytes of the target
2783   def BRSL:
2784     BranchSetLink<0b011001100, (outs), (ins relcalltarget:$func, variable_ops),
2785       "brsl\t$$lr, $func",
2786       [(SPUcall (SPUpcrel tglobaladdr:$func, 0))]>;
2787
2788   // Branch absolute and set link: Used if we actually know that the target
2789   // is an absolute address
2790   def BRASL:
2791     BranchSetLink<0b011001100, (outs), (ins calltarget:$func, variable_ops),
2792       "brasl\t$$lr, $func",
2793       [(SPUcall tglobaladdr:$func)]>;
2794
2795   // Branch indirect and set link if external data. These instructions are not
2796   // actually generated, matched by an intrinsic:
2797   def BISLED_00: BISLEDForm<0b11, "bisled\t$$lr, $func", [/* empty pattern */]>;
2798   def BISLED_E0: BISLEDForm<0b10, "bisled\t$$lr, $func", [/* empty pattern */]>;
2799   def BISLED_0D: BISLEDForm<0b01, "bisled\t$$lr, $func", [/* empty pattern */]>;
2800   def BISLED_ED: BISLEDForm<0b00, "bisled\t$$lr, $func", [/* empty pattern */]>;
2801
2802   // Branch indirect and set link. This is the "X-form" address version of a
2803   // function call
2804   def BISL:
2805     BIForm<0b10010101100, "bisl\t$$lr, $func", [(SPUcall R32C:$func)]>;
2806 }
2807
2808 // Unconditional branches:
2809 let isBranch = 1, isTerminator = 1, hasCtrlDep = 1, isBarrier = 1 in {
2810   def BR :
2811     UncondBranch<0b001001100, (outs), (ins brtarget:$dest),
2812       "br\t$dest",
2813       [(br bb:$dest)]>;
2814
2815   // Unconditional, absolute address branch
2816   def BRA:
2817     UncondBranch<0b001100000, (outs), (ins brtarget:$dest),
2818       "bra\t$dest",
2819       [/* no pattern */]>;
2820
2821   // Indirect branch
2822   def BI:
2823     BIForm<0b00010101100, "bi\t$func", [(brind R32C:$func)]>;
2824
2825   // Various branches:
2826   def BRNZ:
2827     RI16Form<0b010000100, (outs), (ins R32C:$rCond, brtarget:$dest),
2828       "brnz\t$rCond,$dest",
2829       BranchResolv,
2830       [(brcond R32C:$rCond, bb:$dest)]>;
2831
2832   def BRZ:
2833     RI16Form<0b000000100, (outs), (ins R32C:$rT, brtarget:$dest),
2834       "brz\t$rT,$dest",
2835       BranchResolv,
2836       [/* no pattern */]>;
2837
2838   def BRHNZ:
2839     RI16Form<0b011000100, (outs), (ins R16C:$rCond, brtarget:$dest),
2840       "brhnz\t$rCond,$dest",
2841       BranchResolv,
2842       [(brcond R16C:$rCond, bb:$dest)]>;
2843
2844   def BRHZ:
2845     RI16Form<0b001000100, (outs), (ins R16C:$rT, brtarget:$dest),
2846       "brhz\t$rT,$dest",
2847       BranchResolv,
2848       [/* no pattern */]>;
2849
2850 /*
2851   def BINZ:
2852     BICondForm<0b10010100100, "binz\t$rA, $func",
2853                [(SPUbinz R32C:$rA, R32C:$func)]>;
2854
2855   def BIZ:
2856     BICondForm<0b00010100100, "biz\t$rA, $func",
2857                [(SPUbiz R32C:$rA, R32C:$func)]>;
2858 */
2859 }
2860
2861 def : Pat<(brcond (i16 (seteq R16C:$rA, 0)), bb:$dest),
2862           (BRHZ R16C:$rA, bb:$dest)>;
2863 def : Pat<(brcond (i16 (setne R16C:$rA, 0)), bb:$dest),
2864           (BRHNZ R16C:$rA, bb:$dest)>;
2865
2866 def : Pat<(brcond (i32 (seteq R32C:$rA, 0)), bb:$dest),
2867           (BRZ R32C:$rA, bb:$dest)>;
2868 def : Pat<(brcond (i32 (setne R32C:$rA, 0)), bb:$dest),
2869           (BRZ R32C:$rA, bb:$dest)>;
2870
2871 let isTerminator = 1, isBarrier = 1 in {
2872   let isReturn = 1 in {
2873     def RET:
2874         RETForm<"bi\t$$lr", [(retflag)]>;
2875   }
2876 }
2877
2878 //===----------------------------------------------------------------------===//
2879 // Various brcond predicates:
2880 //===----------------------------------------------------------------------===//
2881 /*
2882 def : Pat<(brcond (i32 (seteq R32C:$rA, 0)), bb:$dest),
2883           (BRZ R32C:$rA, bb:$dest)>;
2884
2885 def : Pat<(brcond (i32 (seteq R32C:$rA, R32C:$rB)), bb:$dest),
2886           (BRNZ (CEQr32 R32C:$rA, R32C:$rB), bb:$dest)>;
2887
2888 def : Pat<(brcond (i16 (seteq R16C:$rA, i16ImmSExt10:$val)), bb:$dest),
2889           (BRHNZ (CEQHIr16 R16C:$rA, i16ImmSExt10:$val), bb:$dest)>;
2890
2891 def : Pat<(brcond (i16 (seteq R16C:$rA, R16C:$rB)), bb:$dest),
2892           (BRHNZ (CEQHr16 R16C:$rA, R16C:$rB), bb:$dest)>;
2893 */
2894
2895 //===----------------------------------------------------------------------===//
2896 // Single precision floating point instructions
2897 //===----------------------------------------------------------------------===//
2898
2899 def FAv4f32:
2900     RRForm<0b00100011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
2901       "fa\t$rT, $rA, $rB", SPrecFP,
2902       [(set (v4f32 VECREG:$rT), (fadd (v4f32 VECREG:$rA), (v4f32 VECREG:$rB)))]>;
2903
2904 def FAf32 :
2905     RRForm<0b00100011010, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB),
2906       "fa\t$rT, $rA, $rB", SPrecFP,
2907       [(set R32FP:$rT, (fadd R32FP:$rA, R32FP:$rB))]>;
2908
2909 def FSv4f32:
2910     RRForm<0b00100011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
2911       "fs\t$rT, $rA, $rB", SPrecFP,
2912       [(set (v4f32 VECREG:$rT), (fsub (v4f32 VECREG:$rA), (v4f32 VECREG:$rB)))]>;
2913
2914 def FSf32 :
2915     RRForm<0b10100011010, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB),
2916       "fs\t$rT, $rA, $rB", SPrecFP,
2917       [(set R32FP:$rT, (fsub R32FP:$rA, R32FP:$rB))]>;
2918
2919 // Floating point reciprocal estimate
2920 def FREv4f32 :
2921     RRForm_1<0b00011101100, (outs VECREG:$rT), (ins VECREG:$rA),
2922       "frest\t$rT, $rA", SPrecFP,
2923       [(set (v4f32 VECREG:$rT), (SPUreciprocalEst (v4f32 VECREG:$rA)))]>;
2924
2925 def FREf32 :
2926     RRForm_1<0b00011101100, (outs R32FP:$rT), (ins R32FP:$rA),
2927       "frest\t$rT, $rA", SPrecFP,
2928       [(set R32FP:$rT, (SPUreciprocalEst R32FP:$rA))]>;
2929
2930 // Floating point interpolate (used in conjunction with reciprocal estimate)
2931 def FIv4f32 :
2932     RRForm<0b00101011110, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
2933       "fi\t$rT, $rA, $rB", SPrecFP,
2934       [(set (v4f32 VECREG:$rT), (SPUinterpolate (v4f32 VECREG:$rA),
2935                                                 (v4f32 VECREG:$rB)))]>;
2936
2937 def FIf32 :
2938     RRForm<0b00101011110, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB),
2939       "fi\t$rT, $rA, $rB", SPrecFP,
2940       [(set R32FP:$rT, (SPUinterpolate R32FP:$rA, R32FP:$rB))]>;
2941
2942 // Floating Compare Equal
2943 def FCEQf32 :
2944     RRForm<0b01000011110, (outs R32C:$rT), (ins R32FP:$rA, R32FP:$rB),
2945       "fceq\t$rT, $rA, $rB", SPrecFP,
2946       [(set R32C:$rT, (setoeq R32FP:$rA, R32FP:$rB))]>;
2947
2948 def FCMEQf32 :
2949     RRForm<0b01010011110, (outs R32C:$rT), (ins R32FP:$rA, R32FP:$rB),
2950       "fcmeq\t$rT, $rA, $rB", SPrecFP,
2951       [(set R32C:$rT, (setoeq (fabs R32FP:$rA), (fabs R32FP:$rB)))]>;
2952
2953 def FCGTf32 :
2954     RRForm<0b01000011010, (outs R32C:$rT), (ins R32FP:$rA, R32FP:$rB),
2955       "fcgt\t$rT, $rA, $rB", SPrecFP,
2956       [(set R32C:$rT, (setogt R32FP:$rA, R32FP:$rB))]>;
2957
2958 def FCMGTf32 :
2959     RRForm<0b01010011010, (outs R32C:$rT), (ins R32FP:$rA, R32FP:$rB),
2960       "fcmgt\t$rT, $rA, $rB", SPrecFP,
2961       [(set R32C:$rT, (setogt (fabs R32FP:$rA), (fabs R32FP:$rB)))]>;
2962
2963 // FP Status and Control Register Write
2964 // Why isn't rT a don't care in the ISA?
2965 // Should we create a special RRForm_3 for this guy and zero out the rT?
2966 def FSCRWf32 :
2967     RRForm_1<0b01011101110, (outs R32FP:$rT), (ins R32FP:$rA),
2968       "fscrwr\t$rA", SPrecFP,
2969       [/* This instruction requires an intrinsic. Note: rT is unused. */]>;
2970
2971 // FP Status and Control Register Read
2972 def FSCRRf32 :
2973     RRForm_2<0b01011101110, (outs R32FP:$rT), (ins),
2974       "fscrrd\t$rT", SPrecFP,
2975       [/* This instruction requires an intrinsic */]>;
2976
2977 // llvm instruction space
2978 // How do these map onto cell instructions?
2979 // fdiv rA rB
2980 //   frest rC rB        # c = 1/b (both lines)
2981 //   fi rC rB rC
2982 //   fm rD rA rC        # d = a * 1/b
2983 //   fnms rB rD rB rA # b = - (d * b - a) --should == 0 in a perfect world
2984 //   fma rB rB rC rD            # b = b * c + d
2985 //                              = -(d *b -a) * c + d
2986 //                              = a * c - c ( a *b *c - a)
2987
2988 // fcopysign (???)
2989
2990 // Library calls:
2991 // These llvm instructions will actually map to library calls.
2992 // All that's needed, then, is to check that the appropriate library is
2993 // imported and do a brsl to the proper function name.
2994 // frem # fmod(x, y): x - (x/y) * y
2995 // (Note: fmod(double, double), fmodf(float,float)
2996 // fsqrt?
2997 // fsin?
2998 // fcos?
2999 // Unimplemented SPU instruction space
3000 // floating reciprocal absolute square root estimate (frsqest)
3001
3002 // The following are probably just intrinsics
3003 // status and control register write
3004 // status and control register read
3005
3006 //--------------------------------------
3007 // Floating point multiply instructions
3008 //--------------------------------------
3009
3010 def FMv4f32:
3011     RRForm<0b00100011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
3012       "fm\t$rT, $rA, $rB", SPrecFP,
3013       [(set (v4f32 VECREG:$rT), (fmul (v4f32 VECREG:$rA),
3014                                       (v4f32 VECREG:$rB)))]>;
3015
3016 def FMf32 :
3017     RRForm<0b01100011010, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB),
3018       "fm\t$rT, $rA, $rB", SPrecFP,
3019       [(set R32FP:$rT, (fmul R32FP:$rA, R32FP:$rB))]>;
3020
3021 // Floating point multiply and add
3022 // e.g. d = c + (a * b)
3023 def FMAv4f32:
3024     RRRForm<0b0111, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
3025       "fma\t$rT, $rA, $rB, $rC", SPrecFP,
3026       [(set (v4f32 VECREG:$rT),
3027             (fadd (v4f32 VECREG:$rC),
3028                   (fmul (v4f32 VECREG:$rA), (v4f32 VECREG:$rB))))]>;
3029
3030 def FMAf32:
3031     RRRForm<0b0111, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB, R32FP:$rC),
3032       "fma\t$rT, $rA, $rB, $rC", SPrecFP,
3033       [(set R32FP:$rT, (fadd R32FP:$rC, (fmul R32FP:$rA, R32FP:$rB)))]>;
3034
3035 // FP multiply and subtract
3036 // Subtracts value in rC from product
3037 // res = a * b - c
3038 def FMSv4f32 :
3039     RRRForm<0b0111, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
3040       "fms\t$rT, $rA, $rB, $rC", SPrecFP,
3041       [(set (v4f32 VECREG:$rT),
3042             (fsub (fmul (v4f32 VECREG:$rA), (v4f32 VECREG:$rB)),
3043                   (v4f32 VECREG:$rC)))]>;
3044
3045 def FMSf32 :
3046     RRRForm<0b0111, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB, R32FP:$rC),
3047       "fms\t$rT, $rA, $rB, $rC", SPrecFP,
3048       [(set R32FP:$rT,
3049             (fsub (fmul R32FP:$rA, R32FP:$rB), R32FP:$rC))]>;
3050
3051 // Floating Negative Mulitply and Subtract
3052 // Subtracts product from value in rC
3053 // res = fneg(fms a b c)
3054 //     = - (a * b - c)
3055 //     = c - a * b
3056 // NOTE: subtraction order
3057 // fsub a b = a - b
3058 // fs a b = b - a?
3059 def FNMSf32 :
3060     RRRForm<0b1101, (outs R32FP:$rT), (ins R32FP:$rA, R32FP:$rB, R32FP:$rC),
3061       "fnms\t$rT, $rA, $rB, $rC", SPrecFP,
3062       [(set R32FP:$rT, (fsub R32FP:$rC, (fmul R32FP:$rA, R32FP:$rB)))]>;
3063
3064 def FNMSv4f32 :
3065     RRRForm<0b1101, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
3066       "fnms\t$rT, $rA, $rB, $rC", SPrecFP,
3067       [(set (v4f32 VECREG:$rT),
3068             (fsub (v4f32 VECREG:$rC),
3069                   (fmul (v4f32 VECREG:$rA),
3070                         (v4f32 VECREG:$rB))))]>;
3071
3072 //--------------------------------------
3073 // Floating Point Conversions
3074 // Signed conversions:
3075 def CSiFv4f32:
3076     CVTIntFPForm<0b0101101110, (outs VECREG:$rT), (ins VECREG:$rA),
3077       "csflt\t$rT, $rA, 0", SPrecFP,
3078       [(set (v4f32 VECREG:$rT), (sint_to_fp (v4i32 VECREG:$rA)))]>;
3079
3080 // Convert signed integer to floating point
3081 def CSiFf32 :
3082     CVTIntFPForm<0b0101101110, (outs R32FP:$rT), (ins R32C:$rA),
3083       "csflt\t$rT, $rA, 0", SPrecFP,
3084       [(set R32FP:$rT, (sint_to_fp R32C:$rA))]>;
3085
3086 // Convert unsigned into to float
3087 def CUiFv4f32 :
3088     CVTIntFPForm<0b1101101110, (outs VECREG:$rT), (ins VECREG:$rA),
3089       "cuflt\t$rT, $rA, 0", SPrecFP,
3090       [(set (v4f32 VECREG:$rT), (uint_to_fp (v4i32 VECREG:$rA)))]>;
3091
3092 def CUiFf32 :
3093     CVTIntFPForm<0b1101101110, (outs R32FP:$rT), (ins R32C:$rA),
3094       "cuflt\t$rT, $rA, 0", SPrecFP,
3095       [(set R32FP:$rT, (uint_to_fp R32C:$rA))]>;
3096
3097 // Convert float to unsigned int
3098 // Assume that scale = 0
3099
3100 def CFUiv4f32 :
3101     CVTIntFPForm<0b1101101110, (outs VECREG:$rT), (ins VECREG:$rA),
3102       "cfltu\t$rT, $rA, 0", SPrecFP,
3103       [(set (v4i32 VECREG:$rT), (fp_to_uint (v4f32 VECREG:$rA)))]>;
3104
3105 def CFUif32 :
3106     CVTIntFPForm<0b1101101110, (outs R32C:$rT), (ins R32FP:$rA),
3107       "cfltu\t$rT, $rA, 0", SPrecFP,
3108       [(set R32C:$rT, (fp_to_uint R32FP:$rA))]>;
3109
3110 // Convert float to signed int
3111 // Assume that scale = 0
3112
3113 def CFSiv4f32 :
3114     CVTIntFPForm<0b1101101110, (outs VECREG:$rT), (ins VECREG:$rA),
3115       "cflts\t$rT, $rA, 0", SPrecFP,
3116       [(set (v4i32 VECREG:$rT), (fp_to_sint (v4f32 VECREG:$rA)))]>;
3117
3118 def CFSif32 :
3119     CVTIntFPForm<0b1101101110, (outs R32C:$rT), (ins R32FP:$rA),
3120       "cflts\t$rT, $rA, 0", SPrecFP,
3121       [(set R32C:$rT, (fp_to_sint R32FP:$rA))]>;
3122
3123 //===----------------------------------------------------------------------==//
3124 // Single<->Double precision conversions
3125 //===----------------------------------------------------------------------==//
3126
3127 // NOTE: We use "vec" name suffix here to avoid confusion (e.g. input is a
3128 // v4f32, output is v2f64--which goes in the name?)
3129
3130 // Floating point extend single to double
3131 // NOTE: Not sure if passing in v4f32 to FESDvec is correct since it
3132 // operates on two double-word slots (i.e. 1st and 3rd fp numbers
3133 // are ignored).
3134 def FESDvec :
3135     RRForm_1<0b00011101110, (outs VECREG:$rT), (ins VECREG:$rA),
3136       "fesd\t$rT, $rA", SPrecFP,
3137       [(set (v2f64 VECREG:$rT), (fextend (v4f32 VECREG:$rA)))]>;
3138
3139 def FESDf32 :
3140     RRForm_1<0b00011101110, (outs R64FP:$rT), (ins R32FP:$rA),
3141       "fesd\t$rT, $rA", SPrecFP,
3142       [(set R64FP:$rT, (fextend R32FP:$rA))]>;
3143
3144 // Floating point round double to single
3145 //def FRDSvec :
3146 //    RRForm_1<0b10011101110, (outs VECREG:$rT), (ins VECREG:$rA),
3147 //      "frds\t$rT, $rA,", SPrecFP,
3148 //      [(set (v4f32 R32FP:$rT), (fround (v2f64 R64FP:$rA)))]>;
3149
3150 def FRDSf64 :
3151     RRForm_1<0b10011101110, (outs R32FP:$rT), (ins R64FP:$rA),
3152       "frds\t$rT, $rA", SPrecFP,
3153       [(set R32FP:$rT, (fround R64FP:$rA))]>;
3154
3155 //ToDo include anyextend?
3156
3157 //===----------------------------------------------------------------------==//
3158 // Double precision floating point instructions
3159 //===----------------------------------------------------------------------==//
3160 def FAf64 :
3161     RRForm<0b00110011010, (outs R64FP:$rT), (ins R64FP:$rA, R64FP:$rB),
3162       "dfa\t$rT, $rA, $rB", DPrecFP,
3163       [(set R64FP:$rT, (fadd R64FP:$rA, R64FP:$rB))]>;
3164
3165 def FAv2f64 :
3166     RRForm<0b00110011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
3167       "dfa\t$rT, $rA, $rB", DPrecFP,
3168       [(set (v2f64 VECREG:$rT), (fadd (v2f64 VECREG:$rA), (v2f64 VECREG:$rB)))]>;
3169
3170 def FSf64 :
3171     RRForm<0b10100011010, (outs R64FP:$rT), (ins R64FP:$rA, R64FP:$rB),
3172       "dfs\t$rT, $rA, $rB", DPrecFP,
3173       [(set R64FP:$rT, (fsub R64FP:$rA, R64FP:$rB))]>;
3174
3175 def FSv2f64 :
3176     RRForm<0b10100011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
3177       "dfs\t$rT, $rA, $rB", DPrecFP,
3178       [(set (v2f64 VECREG:$rT),
3179             (fsub (v2f64 VECREG:$rA), (v2f64 VECREG:$rB)))]>;
3180
3181 def FMf64 :
3182     RRForm<0b01100011010, (outs R64FP:$rT), (ins R64FP:$rA, R64FP:$rB),
3183       "dfm\t$rT, $rA, $rB", DPrecFP,
3184       [(set R64FP:$rT, (fmul R64FP:$rA, R64FP:$rB))]>;
3185
3186 def FMv2f64:
3187     RRForm<0b00100011010, (outs VECREG:$rT), (ins VECREG:$rA, VECREG:$rB),
3188       "dfm\t$rT, $rA, $rB", DPrecFP,
3189       [(set (v2f64 VECREG:$rT),
3190             (fmul (v2f64 VECREG:$rA), (v2f64 VECREG:$rB)))]>;
3191
3192 def FMAf64:
3193     RRForm<0b00111010110, (outs R64FP:$rT),
3194                           (ins R64FP:$rA, R64FP:$rB, R64FP:$rC),
3195       "dfma\t$rT, $rA, $rB", DPrecFP,
3196       [(set R64FP:$rT, (fadd R64FP:$rC, (fmul R64FP:$rA, R64FP:$rB)))]>,
3197     RegConstraint<"$rC = $rT">,
3198     NoEncode<"$rC">;
3199
3200 def FMAv2f64:
3201     RRForm<0b00111010110, (outs VECREG:$rT),
3202                           (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
3203       "dfma\t$rT, $rA, $rB", DPrecFP,
3204       [(set (v2f64 VECREG:$rT),
3205             (fadd (v2f64 VECREG:$rC),
3206                   (fmul (v2f64 VECREG:$rA), (v2f64 VECREG:$rB))))]>,
3207     RegConstraint<"$rC = $rT">,
3208     NoEncode<"$rC">;
3209
3210 def FMSf64 :
3211     RRForm<0b10111010110, (outs R64FP:$rT),
3212                           (ins R64FP:$rA, R64FP:$rB, R64FP:$rC),
3213       "dfms\t$rT, $rA, $rB", DPrecFP,
3214       [(set R64FP:$rT, (fsub (fmul R64FP:$rA, R64FP:$rB), R64FP:$rC))]>,
3215     RegConstraint<"$rC = $rT">,
3216     NoEncode<"$rC">;
3217
3218 def FMSv2f64 :
3219     RRForm<0b10111010110, (outs VECREG:$rT),
3220                           (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
3221       "dfms\t$rT, $rA, $rB", DPrecFP,
3222       [(set (v2f64 VECREG:$rT),
3223             (fsub (fmul (v2f64 VECREG:$rA), (v2f64 VECREG:$rB)),
3224                   (v2f64 VECREG:$rC)))]>;
3225
3226 // FNMS: - (a * b - c)
3227 // - (a * b) + c => c - (a * b)
3228 def FNMSf64 :
3229     RRForm<0b01111010110, (outs R64FP:$rT),
3230                           (ins R64FP:$rA, R64FP:$rB, R64FP:$rC),
3231       "dfnms\t$rT, $rA, $rB", DPrecFP,
3232       [(set R64FP:$rT, (fsub R64FP:$rC, (fmul R64FP:$rA, R64FP:$rB)))]>,
3233     RegConstraint<"$rC = $rT">,
3234     NoEncode<"$rC">;
3235
3236 def : Pat<(fneg (fsub (fmul R64FP:$rA, R64FP:$rB), R64FP:$rC)),
3237           (FNMSf64 R64FP:$rA, R64FP:$rB, R64FP:$rC)>;
3238
3239 def FNMSv2f64 :
3240     RRForm<0b01111010110, (outs VECREG:$rT),
3241                           (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
3242       "dfnms\t$rT, $rA, $rB", DPrecFP,
3243       [(set (v2f64 VECREG:$rT),
3244             (fsub (v2f64 VECREG:$rC),
3245                   (fmul (v2f64 VECREG:$rA),
3246                         (v2f64 VECREG:$rB))))]>,
3247     RegConstraint<"$rC = $rT">,
3248     NoEncode<"$rC">;
3249
3250 def : Pat<(fneg (fsub (fmul (v2f64 VECREG:$rA), (v2f64 VECREG:$rB)),
3251                 (v2f64 VECREG:$rC))),
3252           (FNMSv2f64 VECREG:$rA, VECREG:$rB, VECREG:$rC)>;
3253
3254 // - (a * b + c)
3255 // - (a * b) - c
3256 def FNMAf64 :
3257     RRForm<0b11111010110, (outs R64FP:$rT),
3258                           (ins R64FP:$rA, R64FP:$rB, R64FP:$rC),
3259       "dfnma\t$rT, $rA, $rB", DPrecFP,
3260       [(set R64FP:$rT, (fneg (fadd R64FP:$rC, (fmul R64FP:$rA, R64FP:$rB))))]>,
3261     RegConstraint<"$rC = $rT">,
3262     NoEncode<"$rC">;
3263
3264 def FNMAv2f64 :
3265     RRForm<0b11111010110, (outs VECREG:$rT),
3266                           (ins VECREG:$rA, VECREG:$rB, VECREG:$rC),
3267       "dfnma\t$rT, $rA, $rB", DPrecFP,
3268       [(set (v2f64 VECREG:$rT),
3269             (fneg (fadd (v2f64 VECREG:$rC),
3270                         (fmul (v2f64 VECREG:$rA),
3271                               (v2f64 VECREG:$rB)))))]>,
3272     RegConstraint<"$rC = $rT">,
3273     NoEncode<"$rC">;
3274
3275 //===----------------------------------------------------------------------==//
3276 // Floating point negation and absolute value
3277 //===----------------------------------------------------------------------==//
3278
3279 def : Pat<(fneg (v4f32 VECREG:$rA)),
3280           (XORfnegvec (v4f32 VECREG:$rA),
3281                       (v4f32 (ILHUv4i32 0x8000)))>;
3282
3283 def : Pat<(fneg R32FP:$rA),
3284           (XORfneg32 R32FP:$rA, (ILHUr32 0x8000))>;
3285
3286 def : Pat<(fneg (v2f64 VECREG:$rA)),
3287           (XORfnegvec (v2f64 VECREG:$rA),
3288                       (v2f64 (ANDBIv16i8 (FSMBIv16i8 0x8080), 0x80)))>;
3289
3290 def : Pat<(fneg R64FP:$rA),
3291           (XORfneg64 R64FP:$rA,
3292                      (ANDBIv16i8 (FSMBIv16i8 0x8080), 0x80))>;
3293
3294 // Floating point absolute value
3295
3296 def : Pat<(fabs R32FP:$rA),
3297           (ANDfabs32 R32FP:$rA, (IOHLr32 (ILHUr32 0x7fff), 0xffff))>;
3298
3299 def : Pat<(fabs (v4f32 VECREG:$rA)),
3300           (ANDfabsvec (v4f32 VECREG:$rA),
3301                       (v4f32 (ANDBIv16i8 (FSMBIv16i8 0xffff), 0x7f)))>;
3302
3303 def : Pat<(fabs R64FP:$rA),
3304           (ANDfabs64 R64FP:$rA, (ANDBIv16i8 (FSMBIv16i8 0xffff), 0x7f))>;
3305
3306 def : Pat<(fabs (v2f64 VECREG:$rA)),
3307           (ANDfabsvec (v2f64 VECREG:$rA),
3308                       (v2f64 (ANDBIv16i8 (FSMBIv16i8 0xffff), 0x7f)))>;
3309
3310 //===----------------------------------------------------------------------===//
3311 // Execution, Load NOP (execute NOPs belong in even pipeline, load NOPs belong
3312 // in the odd pipeline)
3313 //===----------------------------------------------------------------------===//
3314
3315 def ENOP : I<(outs), (ins), "enop", ExecNOP> {
3316   let Pattern = [];
3317
3318   let Inst{0-10} = 0b10000000010;
3319   let Inst{11-17} = 0;
3320   let Inst{18-24} = 0;
3321   let Inst{25-31} = 0;
3322 }
3323
3324 def LNOP : I<(outs), (ins), "lnop", LoadNOP> {
3325   let Pattern = [];
3326
3327   let Inst{0-10} = 0b10000000000;
3328   let Inst{11-17} = 0;
3329   let Inst{18-24} = 0;
3330   let Inst{25-31} = 0;
3331 }
3332
3333 //===----------------------------------------------------------------------===//
3334 // Bit conversions (type conversions between vector/packed types)
3335 // NOTE: Promotions are handled using the XS* instructions. Truncation
3336 // is not handled.
3337 //===----------------------------------------------------------------------===//
3338 def : Pat<(v16i8 (bitconvert (v8i16 VECREG:$src))), (v16i8 VECREG:$src)>;
3339 def : Pat<(v16i8 (bitconvert (v4i32 VECREG:$src))), (v16i8 VECREG:$src)>;
3340 def : Pat<(v16i8 (bitconvert (v2i64 VECREG:$src))), (v16i8 VECREG:$src)>;
3341 def : Pat<(v16i8 (bitconvert (v4f32 VECREG:$src))), (v16i8 VECREG:$src)>;
3342 def : Pat<(v16i8 (bitconvert (v2f64 VECREG:$src))), (v16i8 VECREG:$src)>;
3343
3344 def : Pat<(v8i16 (bitconvert (v16i8 VECREG:$src))), (v8i16 VECREG:$src)>;
3345 def : Pat<(v8i16 (bitconvert (v4i32 VECREG:$src))), (v8i16 VECREG:$src)>;
3346 def : Pat<(v8i16 (bitconvert (v2i64 VECREG:$src))), (v8i16 VECREG:$src)>;
3347 def : Pat<(v8i16 (bitconvert (v4f32 VECREG:$src))), (v8i16 VECREG:$src)>;
3348 def : Pat<(v8i16 (bitconvert (v2f64 VECREG:$src))), (v8i16 VECREG:$src)>;
3349
3350 def : Pat<(v4i32 (bitconvert (v16i8 VECREG:$src))), (v4i32 VECREG:$src)>;
3351 def : Pat<(v4i32 (bitconvert (v8i16 VECREG:$src))), (v4i32 VECREG:$src)>;
3352 def : Pat<(v4i32 (bitconvert (v2i64 VECREG:$src))), (v4i32 VECREG:$src)>;
3353 def : Pat<(v4i32 (bitconvert (v4f32 VECREG:$src))), (v4i32 VECREG:$src)>;
3354 def : Pat<(v4i32 (bitconvert (v2f64 VECREG:$src))), (v4i32 VECREG:$src)>;
3355
3356 def : Pat<(v2i64 (bitconvert (v16i8 VECREG:$src))), (v2i64 VECREG:$src)>;
3357 def : Pat<(v2i64 (bitconvert (v8i16 VECREG:$src))), (v2i64 VECREG:$src)>;
3358 def : Pat<(v2i64 (bitconvert (v4i32 VECREG:$src))), (v2i64 VECREG:$src)>;
3359 def : Pat<(v2i64 (bitconvert (v4f32 VECREG:$src))), (v2i64 VECREG:$src)>;
3360 def : Pat<(v2i64 (bitconvert (v2f64 VECREG:$src))), (v2i64 VECREG:$src)>;
3361
3362 def : Pat<(v4f32 (bitconvert (v16i8 VECREG:$src))), (v4f32 VECREG:$src)>;
3363 def : Pat<(v4f32 (bitconvert (v8i16 VECREG:$src))), (v4f32 VECREG:$src)>;
3364 def : Pat<(v4f32 (bitconvert (v2i64 VECREG:$src))), (v4f32 VECREG:$src)>;
3365 def : Pat<(v4f32 (bitconvert (v4i32 VECREG:$src))), (v4f32 VECREG:$src)>;
3366 def : Pat<(v4f32 (bitconvert (v2f64 VECREG:$src))), (v4f32 VECREG:$src)>;
3367
3368 def : Pat<(v2f64 (bitconvert (v16i8 VECREG:$src))), (v2f64 VECREG:$src)>;
3369 def : Pat<(v2f64 (bitconvert (v8i16 VECREG:$src))), (v2f64 VECREG:$src)>;
3370 def : Pat<(v2f64 (bitconvert (v4i32 VECREG:$src))), (v2f64 VECREG:$src)>;
3371 def : Pat<(v2f64 (bitconvert (v2i64 VECREG:$src))), (v2f64 VECREG:$src)>;
3372 def : Pat<(v2f64 (bitconvert (v2f64 VECREG:$src))), (v2f64 VECREG:$src)>;
3373
3374 def : Pat<(f32 (bitconvert (i32 R32C:$src))), (f32 R32FP:$src)>;
3375
3376 //===----------------------------------------------------------------------===//
3377 // Instruction patterns:
3378 //===----------------------------------------------------------------------===//
3379
3380 // General 32-bit constants:
3381 def : Pat<(i32 imm:$imm),
3382           (IOHLr32 (ILHUr32 (HI16 imm:$imm)), (LO16 imm:$imm))>;
3383
3384 // Single precision float constants:
3385 def : Pat<(SPUFPconstant (f32 fpimm:$imm)),
3386           (IOHLf32 (ILHUf32 (HI16_f32 fpimm:$imm)), (LO16_f32 fpimm:$imm))>;
3387
3388 // General constant 32-bit vectors
3389 def : Pat<(v4i32 v4i32Imm:$imm),
3390           (IOHLvec (v4i32 (ILHUv4i32 (HI16_vec v4i32Imm:$imm))),
3391                    (LO16_vec v4i32Imm:$imm))>;
3392
3393 // 8-bit constants
3394 def : Pat<(i8 imm:$imm),
3395           (ILHr8 imm:$imm)>;
3396
3397 //===----------------------------------------------------------------------===//
3398 // Call instruction patterns:
3399 //===----------------------------------------------------------------------===//
3400 // Return void
3401 def : Pat<(ret),
3402           (RET)>;
3403
3404 //===----------------------------------------------------------------------===//
3405 // Zero/Any/Sign extensions
3406 //===----------------------------------------------------------------------===//
3407
3408 // zext 1->32: Zero extend i1 to i32
3409 def : Pat<(SPUextract_i1_zext R32C:$rSrc),
3410           (ANDIr32 R32C:$rSrc, 0x1)>;
3411
3412 // sext 8->32: Sign extend bytes to words
3413 def : Pat<(sext_inreg R32C:$rSrc, i8),
3414           (XSHWr32 (XSBHr32 R32C:$rSrc))>;
3415
3416 def : Pat<(i32 (sext R8C:$rSrc)),
3417           (XSHWr16 (XSBHr8 R8C:$rSrc))>;
3418
3419 def : Pat<(SPUextract_i8_sext VECREG:$rSrc),
3420           (XSHWr32 (XSBHr32 (ORi32_v4i32 (v4i32 VECREG:$rSrc),
3421                             (v4i32 VECREG:$rSrc))))>;
3422
3423 // zext 8->16: Zero extend bytes to halfwords
3424 def : Pat<(i16 (zext R8C:$rSrc)),
3425           (ANDHI1To2 R8C:$rSrc, 0xff)>;
3426
3427 // zext 8->32 from preferred slot in load/store
3428 def : Pat<(SPUextract_i8_zext VECREG:$rSrc),
3429           (ANDIr32 (ORi32_v4i32 (v4i32 VECREG:$rSrc), (v4i32 VECREG:$rSrc)),
3430                    0xff)>;
3431
3432 // zext 8->32: Zero extend bytes to words
3433 def : Pat<(i32 (zext R8C:$rSrc)),
3434           (ANDI1To4 R8C:$rSrc, 0xff)>;
3435
3436 // anyext 8->16: Extend 8->16 bits, irrespective of sign
3437 def : Pat<(i16 (anyext R8C:$rSrc)),
3438           (ORHI1To2 R8C:$rSrc, 0)>;
3439
3440 // anyext 8->32: Extend 8->32 bits, irrespective of sign
3441 def : Pat<(i32 (anyext R8C:$rSrc)),
3442           (ORI1To4 R8C:$rSrc, 0)>;
3443
3444 // zext 16->32: Zero extend halfwords to words (note that we have to juggle the
3445 // 0xffff constant since it will not fit into an immediate.)
3446 def : Pat<(i32 (zext R16C:$rSrc)),
3447           (AND2To4 R16C:$rSrc, (ILAr32 0xffff))>;
3448
3449 def : Pat<(i32 (zext (and R16C:$rSrc, 0xf))),
3450           (ANDI2To4 R16C:$rSrc, 0xf)>;
3451
3452 def : Pat<(i32 (zext (and R16C:$rSrc, 0xff))),
3453           (ANDI2To4 R16C:$rSrc, 0xff)>;
3454
3455 def : Pat<(i32 (zext (and R16C:$rSrc, 0xfff))),
3456           (ANDI2To4 R16C:$rSrc, 0xfff)>;
3457
3458 // anyext 16->32: Extend 16->32 bits, irrespective of sign
3459 def : Pat<(i32 (anyext R16C:$rSrc)),
3460           (ORI2To4 R16C:$rSrc, 0)>;
3461
3462 //===----------------------------------------------------------------------===//
3463 // Address translation: SPU, like PPC, has to split addresses into high and
3464 // low parts in order to load them into a register.
3465 //===----------------------------------------------------------------------===//
3466
3467 def : Pat<(SPUhi    tglobaladdr:$in, 0), (ILHUhi tglobaladdr:$in)>;
3468 def : Pat<(SPUlo    tglobaladdr:$in, 0), (ILAlo  tglobaladdr:$in)>;
3469 def : Pat<(SPUdform tglobaladdr:$in, imm:$imm), (ILAlsa tglobaladdr:$in)>;
3470 def : Pat<(SPUhi    tconstpool:$in , 0), (ILHUhi tconstpool:$in)>;
3471 def : Pat<(SPUlo    tconstpool:$in , 0), (ILAlo  tconstpool:$in)>;
3472 def : Pat<(SPUdform tconstpool:$in, imm:$imm), (ILAlsa tconstpool:$in)>;
3473 def : Pat<(SPUhi    tjumptable:$in, 0),  (ILHUhi tjumptable:$in)>;
3474 def : Pat<(SPUlo    tjumptable:$in, 0),  (ILAlo tjumptable:$in)>;
3475 def : Pat<(SPUdform tjumptable:$in, imm:$imm),  (ILAlsa tjumptable:$in)>;
3476
3477 // Force load of global address to a register. These forms show up in
3478 // SPUISD::DFormAddr pseudo instructions:
3479 def : Pat<(add tglobaladdr:$in, 0), (ILAlsa tglobaladdr:$in)>;
3480 def : Pat<(add tconstpool:$in, 0),  (ILAlsa tglobaladdr:$in)>;
3481 def : Pat<(add tjumptable:$in, 0),  (ILAlsa tglobaladdr:$in)>;
3482 // Instrinsics:
3483 include "CellSDKIntrinsics.td"