lib/Target/AMDGPU/SIInstructions.td

   1 //===-- SIInstructions.td - SI Instruction Defintions ---------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 // This file was originally auto-generated from a GPU register header file and
   9 // all the instruction definitions were originally commented out.  Instructions
  10 // that are not yet supported remain commented out.
  11 //===----------------------------------------------------------------------===//
  12
  13 class GCNPat<dag pattern, dag result> : Pat<pattern, result>, GCNPredicateControl {
  14
  15 }
  16
  17 include "SOPInstructions.td"
  18 include "VOPInstructions.td"
  19 include "SMInstructions.td"
  20 include "FLATInstructions.td"
  21 include "BUFInstructions.td"
  22
  23 //===----------------------------------------------------------------------===//
  24 // EXP Instructions
  25 //===----------------------------------------------------------------------===//
  26
  27 defm EXP : EXP_m<0, AMDGPUexport>;
  28 defm EXP_DONE : EXP_m<1, AMDGPUexport_done>;
  29
  30 //===----------------------------------------------------------------------===//
  31 // VINTRP Instructions
  32 //===----------------------------------------------------------------------===//
  33
  34 // Used to inject printing of "_e32" suffix for VI (there are "_e64" variants for VI)
  35 def VINTRPDst : VINTRPDstOperand <VGPR_32>;
  36
  37 let Uses = [M0, EXEC] in {
  38
  39 // FIXME: Specify SchedRW for VINTRP insturctions.
  40
  41 multiclass V_INTERP_P1_F32_m : VINTRP_m <
  42   0x00000000,
  43   (outs VINTRPDst:$vdst),
  44   (ins VGPR_32:$vsrc, Attr:$attr, AttrChan:$attrchan),
  45   "v_interp_p1_f32$vdst, $vsrc, $attr$attrchan",
  46   [(set f32:$vdst, (AMDGPUinterp_p1 f32:$vsrc, (i32 imm:$attrchan),
  47                                                (i32 imm:$attr)))]
  48 >;
  49
  50 let OtherPredicates = [has32BankLDS] in {
  51
  52 defm V_INTERP_P1_F32 : V_INTERP_P1_F32_m;
  53
  54 } // End OtherPredicates = [has32BankLDS]
  55
  56 let OtherPredicates = [has16BankLDS], Constraints = "@earlyclobber $vdst", isAsmParserOnly=1 in {
  57
  58 defm V_INTERP_P1_F32_16bank : V_INTERP_P1_F32_m;
  59
  60 } // End OtherPredicates = [has32BankLDS], Constraints = "@earlyclobber $vdst", isAsmParserOnly=1
  61
  62 let DisableEncoding = "$src0", Constraints = "$src0 = $vdst" in {
  63
  64 defm V_INTERP_P2_F32 : VINTRP_m <
  65   0x00000001,
  66   (outs VINTRPDst:$vdst),
  67   (ins VGPR_32:$src0, VGPR_32:$vsrc, Attr:$attr, AttrChan:$attrchan),
  68   "v_interp_p2_f32$vdst, $vsrc, $attr$attrchan",
  69   [(set f32:$vdst, (AMDGPUinterp_p2 f32:$src0, f32:$vsrc, (i32 imm:$attrchan),
  70                                                           (i32 imm:$attr)))]>;
  71
  72 } // End DisableEncoding = "$src0", Constraints = "$src0 = $vdst"
  73
  74 defm V_INTERP_MOV_F32 : VINTRP_m <
  75   0x00000002,
  76   (outs VINTRPDst:$vdst),
  77   (ins InterpSlot:$vsrc, Attr:$attr, AttrChan:$attrchan),
  78   "v_interp_mov_f32$vdst, $vsrc, $attr$attrchan",
  79   [(set f32:$vdst, (AMDGPUinterp_mov (i32 imm:$vsrc), (i32 imm:$attrchan),
  80                                      (i32 imm:$attr)))]>;
  81
  82 } // End Uses = [M0, EXEC]
  83
  84 //===----------------------------------------------------------------------===//
  85 // Pseudo Instructions
  86 //===----------------------------------------------------------------------===//
  87 def ATOMIC_FENCE : SPseudoInstSI<
  88   (outs), (ins i32imm:$ordering, i32imm:$scope),
  89   [(atomic_fence (i32 imm:$ordering), (i32 imm:$scope))],
  90   "ATOMIC_FENCE $ordering, $scope"> {
  91   let hasSideEffects = 1;
  92   let maybeAtomic = 1;
  93 }
  94
  95 let hasSideEffects = 0, mayLoad = 0, mayStore = 0, Uses = [EXEC] in {
  96
  97 // For use in patterns
  98 def V_CNDMASK_B64_PSEUDO : VOP3Common <(outs VReg_64:$vdst),
  99   (ins VSrc_b64:$src0, VSrc_b64:$src1, SSrc_b64:$src2), "", []> {
 100   let isPseudo = 1;
 101   let isCodeGenOnly = 1;
 102   let usesCustomInserter = 1;
 103 }
 104
 105 // 64-bit vector move instruction. This is mainly used by the
 106 // SIFoldOperands pass to enable folding of inline immediates.
 107 def V_MOV_B64_PSEUDO : VPseudoInstSI <(outs VReg_64:$vdst),
 108                                       (ins VSrc_b64:$src0)>;
 109
 110 // Pseudoinstruction for @llvm.amdgcn.wqm. It is turned into a copy after the
 111 // WQM pass processes it.
 112 def WQM : PseudoInstSI <(outs unknown:$vdst), (ins unknown:$src0)>;
 113
 114 // Pseudoinstruction for @llvm.amdgcn.softwqm. Like @llvm.amdgcn.wqm it is
 115 // turned into a copy by WQM pass, but does not seed WQM requirements.
 116 def SOFT_WQM : PseudoInstSI <(outs unknown:$vdst), (ins unknown:$src0)>;
 117
 118 // Pseudoinstruction for @llvm.amdgcn.wwm. It is turned into a copy post-RA, so
 119 // that the @earlyclobber is respected. The @earlyclobber is to make sure that
 120 // the instruction that defines $src0 (which is run in WWM) doesn't
 121 // accidentally clobber inactive channels of $vdst.
 122 let Constraints = "@earlyclobber $vdst" in {
 123 def WWM : PseudoInstSI <(outs unknown:$vdst), (ins unknown:$src0)>;
 124 }
 125
 126 } // End let hasSideEffects = 0, mayLoad = 0, mayStore = 0, Uses = [EXEC]
 127
 128 def ENTER_WWM : SPseudoInstSI <(outs SReg_1:$sdst), (ins i64imm:$src0)> {
 129   let Defs = [EXEC];
 130   let hasSideEffects = 0;
 131   let mayLoad = 0;
 132   let mayStore = 0;
 133 }
 134
 135 def EXIT_WWM : SPseudoInstSI <(outs SReg_1:$sdst), (ins SReg_1:$src0)> {
 136   let hasSideEffects = 0;
 137   let mayLoad = 0;
 138   let mayStore = 0;
 139 }
 140
 141 // Invert the exec mask and overwrite the inactive lanes of dst with inactive,
 142 // restoring it after we're done.
 143 def V_SET_INACTIVE_B32 : VPseudoInstSI <(outs VGPR_32:$vdst),
 144   (ins VGPR_32: $src, VSrc_b32:$inactive),
 145   [(set i32:$vdst, (int_amdgcn_set_inactive i32:$src, i32:$inactive))]> {
 146   let Constraints = "$src = $vdst";
 147 }
 148
 149 def V_SET_INACTIVE_B64 : VPseudoInstSI <(outs VReg_64:$vdst),
 150   (ins VReg_64: $src, VSrc_b64:$inactive),
 151   [(set i64:$vdst, (int_amdgcn_set_inactive i64:$src, i64:$inactive))]> {
 152   let Constraints = "$src = $vdst";
 153 }
 154
 155
 156 let usesCustomInserter = 1, Defs = [SCC] in {
 157 def S_ADD_U64_PSEUDO : SPseudoInstSI <
 158   (outs SReg_64:$vdst), (ins SSrc_b64:$src0, SSrc_b64:$src1),
 159   [(set SReg_64:$vdst, (add i64:$src0, i64:$src1))]
 160 >;
 161
 162 def S_SUB_U64_PSEUDO : SPseudoInstSI <
 163   (outs SReg_64:$vdst), (ins SSrc_b64:$src0, SSrc_b64:$src1),
 164   [(set SReg_64:$vdst, (sub i64:$src0, i64:$src1))]
 165 >;
 166
 167 def S_ADD_U64_CO_PSEUDO : SPseudoInstSI <
 168   (outs SReg_64:$vdst, VOPDstS64orS32:$sdst), (ins SSrc_b64:$src0, SSrc_b64:$src1)
 169 >;
 170
 171 def S_SUB_U64_CO_PSEUDO : SPseudoInstSI <
 172   (outs SReg_64:$vdst, VOPDstS64orS32:$sdst), (ins SSrc_b64:$src0, SSrc_b64:$src1)
 173 >;
 174 } // End usesCustomInserter = 1, Defs = [SCC]
 175
 176 let usesCustomInserter = 1 in {
 177 def GET_GROUPSTATICSIZE : SPseudoInstSI <(outs SReg_32:$sdst), (ins),
 178   [(set SReg_32:$sdst, (int_amdgcn_groupstaticsize))]>;
 179 } // End let usesCustomInserter = 1, SALU = 1
 180
 181 // Wrap an instruction by duplicating it, except for setting isTerminator.
 182 class WrapTerminatorInst<SOP_Pseudo base_inst> : SPseudoInstSI<
 183       base_inst.OutOperandList,
 184       base_inst.InOperandList> {
 185   let Uses = base_inst.Uses;
 186   let Defs = base_inst.Defs;
 187   let isTerminator = 1;
 188   let isAsCheapAsAMove = base_inst.isAsCheapAsAMove;
 189   let hasSideEffects = base_inst.hasSideEffects;
 190   let UseNamedOperandTable = base_inst.UseNamedOperandTable;
 191   let CodeSize = base_inst.CodeSize;
 192 }
 193
 194 let WaveSizePredicate = isWave64 in {
 195 def S_MOV_B64_term : WrapTerminatorInst<S_MOV_B64>;
 196 def S_OR_B64_term : WrapTerminatorInst<S_OR_B64>;
 197 def S_XOR_B64_term : WrapTerminatorInst<S_XOR_B64>;
 198 def S_ANDN2_B64_term : WrapTerminatorInst<S_ANDN2_B64>;
 199 }
 200
 201 let WaveSizePredicate = isWave32 in {
 202 def S_MOV_B32_term : WrapTerminatorInst<S_MOV_B32>;
 203 def S_XOR_B32_term : WrapTerminatorInst<S_XOR_B32>;
 204 def S_OR_B32_term : WrapTerminatorInst<S_OR_B32>;
 205 def S_ANDN2_B32_term : WrapTerminatorInst<S_ANDN2_B32>;
 206 }
 207
 208 def WAVE_BARRIER : SPseudoInstSI<(outs), (ins),
 209   [(int_amdgcn_wave_barrier)]> {
 210   let SchedRW = [];
 211   let hasNoSchedulingInfo = 1;
 212   let hasSideEffects = 1;
 213   let mayLoad = 1;
 214   let mayStore = 1;
 215   let isConvergent = 1;
 216   let FixedSize = 1;
 217   let Size = 0;
 218 }
 219
 220 // SI pseudo instructions. These are used by the CFG structurizer pass
 221 // and should be lowered to ISA instructions prior to codegen.
 222
 223 // Dummy terminator instruction to use after control flow instructions
 224 // replaced with exec mask operations.
 225 def SI_MASK_BRANCH : VPseudoInstSI <
 226   (outs), (ins brtarget:$target)> {
 227   let isBranch = 0;
 228   let isTerminator = 1;
 229   let isBarrier = 0;
 230   let SchedRW = [];
 231   let hasNoSchedulingInfo = 1;
 232   let FixedSize = 1;
 233   let Size = 0;
 234 }
 235
 236 let isTerminator = 1 in {
 237
 238 let OtherPredicates = [EnableLateCFGStructurize] in {
 239  def SI_NON_UNIFORM_BRCOND_PSEUDO : CFPseudoInstSI <
 240   (outs),
 241   (ins SReg_1:$vcc, brtarget:$target),
 242   [(brcond i1:$vcc, bb:$target)]> {
 243     let Size = 12;
 244 }
 245 }
 246
 247 def SI_IF: CFPseudoInstSI <
 248   (outs SReg_1:$dst), (ins SReg_1:$vcc, brtarget:$target),
 249   [(set i1:$dst, (AMDGPUif i1:$vcc, bb:$target))], 1, 1> {
 250   let Constraints = "";
 251   let Size = 12;
 252   let hasSideEffects = 1;
 253 }
 254
 255 def SI_ELSE : CFPseudoInstSI <
 256   (outs SReg_1:$dst),
 257   (ins SReg_1:$src, brtarget:$target, i1imm:$execfix), [], 1, 1> {
 258   let Size = 12;
 259   let hasSideEffects = 1;
 260 }
 261
 262 def SI_LOOP : CFPseudoInstSI <
 263   (outs), (ins SReg_1:$saved, brtarget:$target),
 264   [(AMDGPUloop i1:$saved, bb:$target)], 1, 1> {
 265   let Size = 8;
 266   let isBranch = 1;
 267   let hasSideEffects = 1;
 268 }
 269
 270 } // End isTerminator = 1
 271
 272 def SI_END_CF : CFPseudoInstSI <
 273   (outs), (ins SReg_1:$saved), [], 1, 1> {
 274   let Size = 4;
 275   let isAsCheapAsAMove = 1;
 276   let isReMaterializable = 1;
 277   let hasSideEffects = 1;
 278   let mayLoad = 1; // FIXME: Should not need memory flags
 279   let mayStore = 1;
 280 }
 281
 282 def SI_IF_BREAK : CFPseudoInstSI <
 283   (outs SReg_1:$dst), (ins SReg_1:$vcc, SReg_1:$src), []> {
 284   let Size = 4;
 285   let isAsCheapAsAMove = 1;
 286   let isReMaterializable = 1;
 287 }
 288
 289 let Uses = [EXEC] in {
 290
 291 multiclass PseudoInstKill <dag ins> {
 292   // Even though this pseudo can usually be expanded without an SCC def, we
 293   // conservatively assume that it has an SCC def, both because it is sometimes
 294   // required in degenerate cases (when V_CMPX cannot be used due to constant
 295   // bus limitations) and because it allows us to avoid having to track SCC
 296   // liveness across basic blocks.
 297   let Defs = [EXEC,VCC,SCC] in
 298   def _PSEUDO : PseudoInstSI <(outs), ins> {
 299     let isConvergent = 1;
 300     let usesCustomInserter = 1;
 301   }
 302
 303   let Defs = [EXEC,VCC,SCC] in
 304   def _TERMINATOR : SPseudoInstSI <(outs), ins> {
 305     let isTerminator = 1;
 306   }
 307 }
 308
 309 defm SI_KILL_I1 : PseudoInstKill <(ins SCSrc_i1:$src, i1imm:$killvalue)>;
 310 defm SI_KILL_F32_COND_IMM : PseudoInstKill <(ins VSrc_b32:$src0, i32imm:$src1, i32imm:$cond)>;
 311
 312 let Defs = [EXEC,VCC] in
 313 def SI_ILLEGAL_COPY : SPseudoInstSI <
 314   (outs unknown:$dst), (ins unknown:$src),
 315   [], " ; illegal copy $src to $dst">;
 316
 317 } // End Uses = [EXEC], Defs = [EXEC,VCC]
 318
 319 // Branch on undef scc. Used to avoid intermediate copy from
 320 // IMPLICIT_DEF to SCC.
 321 def SI_BR_UNDEF : SPseudoInstSI <(outs), (ins sopp_brtarget:$simm16)> {
 322   let isTerminator = 1;
 323   let usesCustomInserter = 1;
 324   let isBranch = 1;
 325 }
 326
 327 def SI_PS_LIVE : PseudoInstSI <
 328   (outs SReg_1:$dst), (ins),
 329   [(set i1:$dst, (int_amdgcn_ps_live))]> {
 330   let SALU = 1;
 331 }
 332
 333 def SI_MASKED_UNREACHABLE : SPseudoInstSI <(outs), (ins),
 334   [(int_amdgcn_unreachable)],
 335   "; divergent unreachable"> {
 336   let Size = 0;
 337   let hasNoSchedulingInfo = 1;
 338   let FixedSize = 1;
 339 }
 340
 341 // Used as an isel pseudo to directly emit initialization with an
 342 // s_mov_b32 rather than a copy of another initialized
 343 // register. MachineCSE skips copies, and we don't want to have to
 344 // fold operands before it runs.
 345 def SI_INIT_M0 : SPseudoInstSI <(outs), (ins SSrc_b32:$src)> {
 346   let Defs = [M0];
 347   let usesCustomInserter = 1;
 348   let isAsCheapAsAMove = 1;
 349   let isReMaterializable = 1;
 350 }
 351
 352 def SI_INIT_EXEC : SPseudoInstSI <
 353   (outs), (ins i64imm:$src), []> {
 354   let Defs = [EXEC];
 355   let usesCustomInserter = 1;
 356   let isAsCheapAsAMove = 1;
 357   let WaveSizePredicate = isWave64;
 358 }
 359
 360 def SI_INIT_EXEC_LO : SPseudoInstSI <
 361   (outs), (ins i32imm:$src), []> {
 362   let Defs = [EXEC_LO];
 363   let usesCustomInserter = 1;
 364   let isAsCheapAsAMove = 1;
 365   let WaveSizePredicate = isWave32;
 366 }
 367
 368 def SI_INIT_EXEC_FROM_INPUT : SPseudoInstSI <
 369   (outs), (ins SSrc_b32:$input, i32imm:$shift), []> {
 370   let Defs = [EXEC];
 371   let usesCustomInserter = 1;
 372 }
 373
 374 // Return for returning shaders to a shader variant epilog.
 375 def SI_RETURN_TO_EPILOG : SPseudoInstSI <
 376   (outs), (ins variable_ops), [(AMDGPUreturn_to_epilog)]> {
 377   let isTerminator = 1;
 378   let isBarrier = 1;
 379   let isReturn = 1;
 380   let hasNoSchedulingInfo = 1;
 381   let DisableWQM = 1;
 382   let FixedSize = 1;
 383 }
 384
 385 // Return for returning function calls.
 386 def SI_RETURN : SPseudoInstSI <
 387   (outs), (ins), [],
 388   "; return"> {
 389   let isTerminator = 1;
 390   let isBarrier = 1;
 391   let isReturn = 1;
 392   let SchedRW = [WriteBranch];
 393 }
 394
 395 // Return for returning function calls without output register.
 396 //
 397 // This version is only needed so we can fill in the output regiter in
 398 // the custom inserter.
 399 def SI_CALL_ISEL : SPseudoInstSI <
 400   (outs), (ins SSrc_b64:$src0, unknown:$callee),
 401   [(AMDGPUcall i64:$src0, tglobaladdr:$callee)]> {
 402   let Size = 4;
 403   let isCall = 1;
 404   let SchedRW = [WriteBranch];
 405   let usesCustomInserter = 1;
 406   // TODO: Should really base this on the call target
 407   let isConvergent = 1;
 408 }
 409
 410 // Wrapper around s_swappc_b64 with extra $callee parameter to track
 411 // the called function after regalloc.
 412 def SI_CALL : SPseudoInstSI <
 413   (outs SReg_64:$dst), (ins SSrc_b64:$src0, unknown:$callee)> {
 414   let Size = 4;
 415   let isCall = 1;
 416   let UseNamedOperandTable = 1;
 417   let SchedRW = [WriteBranch];
 418   // TODO: Should really base this on the call target
 419   let isConvergent = 1;
 420 }
 421
 422 // Tail call handling pseudo
 423 def SI_TCRETURN : SPseudoInstSI <(outs),
 424   (ins SSrc_b64:$src0, unknown:$callee, i32imm:$fpdiff),
 425   [(AMDGPUtc_return i64:$src0, tglobaladdr:$callee, i32:$fpdiff)]> {
 426   let Size = 4;
 427   let isCall = 1;
 428   let isTerminator = 1;
 429   let isReturn = 1;
 430   let isBarrier = 1;
 431   let UseNamedOperandTable = 1;
 432   let SchedRW = [WriteBranch];
 433   // TODO: Should really base this on the call target
 434   let isConvergent = 1;
 435 }
 436
 437
 438 def ADJCALLSTACKUP : SPseudoInstSI<
 439   (outs), (ins i32imm:$amt0, i32imm:$amt1),
 440   [(callseq_start timm:$amt0, timm:$amt1)],
 441   "; adjcallstackup $amt0 $amt1"> {
 442   let Size = 8; // Worst case. (s_add_u32 + constant)
 443   let FixedSize = 1;
 444   let hasSideEffects = 1;
 445   let usesCustomInserter = 1;
 446   let SchedRW = [WriteSALU];
 447   let Defs = [SCC];
 448 }
 449
 450 def ADJCALLSTACKDOWN : SPseudoInstSI<
 451   (outs), (ins i32imm:$amt1, i32imm:$amt2),
 452   [(callseq_end timm:$amt1, timm:$amt2)],
 453   "; adjcallstackdown $amt1"> {
 454   let Size = 8; // Worst case. (s_add_u32 + constant)
 455   let hasSideEffects = 1;
 456   let usesCustomInserter = 1;
 457   let SchedRW = [WriteSALU];
 458   let Defs = [SCC];
 459 }
 460
 461 let Defs = [M0, EXEC, SCC],
 462   UseNamedOperandTable = 1 in {
 463
 464 class SI_INDIRECT_SRC<RegisterClass rc> : VPseudoInstSI <
 465   (outs VGPR_32:$vdst),
 466   (ins rc:$src, VS_32:$idx, i32imm:$offset)> {
 467   let usesCustomInserter = 1;
 468 }
 469
 470 class SI_INDIRECT_DST<RegisterClass rc> : VPseudoInstSI <
 471   (outs rc:$vdst),
 472   (ins rc:$src, VS_32:$idx, i32imm:$offset, VGPR_32:$val)> {
 473   let Constraints = "$src = $vdst";
 474   let usesCustomInserter = 1;
 475 }
 476
 477 // TODO: We can support indirect SGPR access.
 478 def SI_INDIRECT_SRC_V1 : SI_INDIRECT_SRC<VGPR_32>;
 479 def SI_INDIRECT_SRC_V2 : SI_INDIRECT_SRC<VReg_64>;
 480 def SI_INDIRECT_SRC_V4 : SI_INDIRECT_SRC<VReg_128>;
 481 def SI_INDIRECT_SRC_V8 : SI_INDIRECT_SRC<VReg_256>;
 482 def SI_INDIRECT_SRC_V16 : SI_INDIRECT_SRC<VReg_512>;
 483
 484 def SI_INDIRECT_DST_V1 : SI_INDIRECT_DST<VGPR_32>;
 485 def SI_INDIRECT_DST_V2 : SI_INDIRECT_DST<VReg_64>;
 486 def SI_INDIRECT_DST_V4 : SI_INDIRECT_DST<VReg_128>;
 487 def SI_INDIRECT_DST_V8 : SI_INDIRECT_DST<VReg_256>;
 488 def SI_INDIRECT_DST_V16 : SI_INDIRECT_DST<VReg_512>;
 489
 490 } // End Uses = [EXEC], Defs = [M0, EXEC]
 491
 492 multiclass SI_SPILL_SGPR <RegisterClass sgpr_class> {
 493   let UseNamedOperandTable = 1, SGPRSpill = 1, Uses = [EXEC] in {
 494     def _SAVE : PseudoInstSI <
 495       (outs),
 496       (ins sgpr_class:$data, i32imm:$addr)> {
 497       let mayStore = 1;
 498       let mayLoad = 0;
 499     }
 500
 501     def _RESTORE : PseudoInstSI <
 502       (outs sgpr_class:$data),
 503       (ins i32imm:$addr)> {
 504       let mayStore = 0;
 505       let mayLoad = 1;
 506     }
 507   } // End UseNamedOperandTable = 1
 508 }
 509
 510 // You cannot use M0 as the output of v_readlane_b32 instructions or
 511 // use it in the sdata operand of SMEM instructions. We still need to
 512 // be able to spill the physical register m0, so allow it for
 513 // SI_SPILL_32_* instructions.
 514 defm SI_SPILL_S32  : SI_SPILL_SGPR <SReg_32>;
 515 defm SI_SPILL_S64  : SI_SPILL_SGPR <SReg_64>;
 516 defm SI_SPILL_S96  : SI_SPILL_SGPR <SReg_96>;
 517 defm SI_SPILL_S128 : SI_SPILL_SGPR <SReg_128>;
 518 defm SI_SPILL_S160 : SI_SPILL_SGPR <SReg_160>;
 519 defm SI_SPILL_S256 : SI_SPILL_SGPR <SReg_256>;
 520 defm SI_SPILL_S512 : SI_SPILL_SGPR <SReg_512>;
 521 defm SI_SPILL_S1024 : SI_SPILL_SGPR <SReg_1024>;
 522
 523 multiclass SI_SPILL_VGPR <RegisterClass vgpr_class> {
 524   let UseNamedOperandTable = 1, VGPRSpill = 1,
 525        SchedRW = [WriteVMEM] in {
 526     def _SAVE : VPseudoInstSI <
 527       (outs),
 528       (ins vgpr_class:$vdata, i32imm:$vaddr, SReg_128:$srsrc,
 529            SReg_32:$soffset, i32imm:$offset)> {
 530       let mayStore = 1;
 531       let mayLoad = 0;
 532       // (2 * 4) + (8 * num_subregs) bytes maximum
 533       int MaxSize = !add(!shl(!srl(vgpr_class.Size, 5), 3), 8);
 534       // Size field is unsigned char and cannot fit more.
 535       let Size = !if(!le(MaxSize, 256), MaxSize, 252);
 536     }
 537
 538     def _RESTORE : VPseudoInstSI <
 539       (outs vgpr_class:$vdata),
 540       (ins i32imm:$vaddr, SReg_128:$srsrc, SReg_32:$soffset,
 541            i32imm:$offset)> {
 542       let mayStore = 0;
 543       let mayLoad = 1;
 544
 545       // (2 * 4) + (8 * num_subregs) bytes maximum
 546       int MaxSize = !add(!shl(!srl(vgpr_class.Size, 5), 3), 8);
 547       // Size field is unsigned char and cannot fit more.
 548       let Size = !if(!le(MaxSize, 256), MaxSize, 252);
 549     }
 550   } // End UseNamedOperandTable = 1, VGPRSpill = 1, SchedRW = [WriteVMEM]
 551 }
 552
 553 defm SI_SPILL_V32  : SI_SPILL_VGPR <VGPR_32>;
 554 defm SI_SPILL_V64  : SI_SPILL_VGPR <VReg_64>;
 555 defm SI_SPILL_V96  : SI_SPILL_VGPR <VReg_96>;
 556 defm SI_SPILL_V128 : SI_SPILL_VGPR <VReg_128>;
 557 defm SI_SPILL_V160 : SI_SPILL_VGPR <VReg_160>;
 558 defm SI_SPILL_V256 : SI_SPILL_VGPR <VReg_256>;
 559 defm SI_SPILL_V512 : SI_SPILL_VGPR <VReg_512>;
 560 defm SI_SPILL_V1024 : SI_SPILL_VGPR <VReg_1024>;
 561
 562 multiclass SI_SPILL_AGPR <RegisterClass vgpr_class> {
 563   let UseNamedOperandTable = 1, VGPRSpill = 1,
 564       Constraints = "@earlyclobber $tmp",
 565       SchedRW = [WriteVMEM] in {
 566     def _SAVE : VPseudoInstSI <
 567       (outs VGPR_32:$tmp),
 568       (ins vgpr_class:$vdata, i32imm:$vaddr, SReg_128:$srsrc,
 569            SReg_32:$soffset, i32imm:$offset)> {
 570       let mayStore = 1;
 571       let mayLoad = 0;
 572       // (2 * 4) + (16 * num_subregs) bytes maximum
 573       int MaxSize = !add(!shl(!srl(vgpr_class.Size, 5), 4), 8);
 574       // Size field is unsigned char and cannot fit more.
 575       let Size = !if(!le(MaxSize, 256), MaxSize, 252);
 576     }
 577
 578     def _RESTORE : VPseudoInstSI <
 579       (outs vgpr_class:$vdata, VGPR_32:$tmp),
 580       (ins i32imm:$vaddr, SReg_128:$srsrc, SReg_32:$soffset,
 581            i32imm:$offset)> {
 582       let mayStore = 0;
 583       let mayLoad = 1;
 584
 585       // (2 * 4) + (16 * num_subregs) bytes maximum
 586       int MaxSize = !add(!shl(!srl(vgpr_class.Size, 5), 4), 8);
 587       // Size field is unsigned char and cannot fit more.
 588       let Size = !if(!le(MaxSize, 256), MaxSize, 252);
 589     }
 590   } // End UseNamedOperandTable = 1, VGPRSpill = 1, SchedRW = [WriteVMEM]
 591 }
 592
 593 defm SI_SPILL_A32  : SI_SPILL_AGPR <AGPR_32>;
 594 defm SI_SPILL_A64  : SI_SPILL_AGPR <AReg_64>;
 595 defm SI_SPILL_A128 : SI_SPILL_AGPR <AReg_128>;
 596 defm SI_SPILL_A512 : SI_SPILL_AGPR <AReg_512>;
 597 defm SI_SPILL_A1024 : SI_SPILL_AGPR <AReg_1024>;
 598
 599 def SI_PC_ADD_REL_OFFSET : SPseudoInstSI <
 600   (outs SReg_64:$dst),
 601   (ins si_ga:$ptr_lo, si_ga:$ptr_hi),
 602   [(set SReg_64:$dst,
 603       (i64 (SIpc_add_rel_offset tglobaladdr:$ptr_lo, tglobaladdr:$ptr_hi)))]> {
 604   let Defs = [SCC];
 605 }
 606
 607 def : GCNPat <
 608   (SIpc_add_rel_offset tglobaladdr:$ptr_lo, 0),
 609   (SI_PC_ADD_REL_OFFSET $ptr_lo, (i32 0))
 610 >;
 611
 612 def : GCNPat <
 613   (AMDGPUinit_exec i64:$src),
 614   (SI_INIT_EXEC (as_i64imm $src))
 615 > {
 616   let WaveSizePredicate = isWave64;
 617 }
 618
 619 def : GCNPat <
 620   (AMDGPUinit_exec i64:$src),
 621   (SI_INIT_EXEC_LO (as_i32imm $src))
 622 > {
 623   let WaveSizePredicate = isWave32;
 624 }
 625
 626 def : GCNPat <
 627   (AMDGPUinit_exec_from_input i32:$input, i32:$shift),
 628   (SI_INIT_EXEC_FROM_INPUT (i32 $input), (as_i32imm $shift))
 629 >;
 630
 631 def : GCNPat<
 632   (AMDGPUtrap timm:$trapid),
 633   (S_TRAP $trapid)
 634 >;
 635
 636 def : GCNPat<
 637   (AMDGPUelse i1:$src, bb:$target),
 638   (SI_ELSE $src, $target, 0)
 639 >;
 640
 641 def : Pat <
 642   // -1.0 as i32 (LowerINTRINSIC_VOID converts all other constants to -1.0)
 643   (AMDGPUkill (i32 -1082130432)),
 644   (SI_KILL_I1_PSEUDO (i1 0), 0)
 645 >;
 646
 647 def : Pat <
 648   (int_amdgcn_kill i1:$src),
 649   (SI_KILL_I1_PSEUDO $src, 0)
 650 >;
 651
 652 def : Pat <
 653   (int_amdgcn_kill (i1 (not i1:$src))),
 654   (SI_KILL_I1_PSEUDO $src, -1)
 655 >;
 656
 657 def : Pat <
 658   (AMDGPUkill i32:$src),
 659   (SI_KILL_F32_COND_IMM_PSEUDO $src, 0, 3) // 3 means SETOGE
 660 >;
 661
 662 def : Pat <
 663   (int_amdgcn_kill (i1 (setcc f32:$src, InlineFPImm<f32>:$imm, cond:$cond))),
 664   (SI_KILL_F32_COND_IMM_PSEUDO $src, (bitcast_fpimm_to_i32 $imm), (cond_as_i32imm $cond))
 665 >;
 666
 667   // TODO: we could add more variants for other types of conditionals
 668
 669 def : Pat <
 670   (i64 (int_amdgcn_icmp i1:$src, (i1 0), (i32 33))),
 671   (COPY $src) // Return the SGPRs representing i1 src
 672 >;
 673
 674 def : Pat <
 675   (i32 (int_amdgcn_icmp i1:$src, (i1 0), (i32 33))),
 676   (COPY $src) // Return the SGPRs representing i1 src
 677 >;
 678
 679 //===----------------------------------------------------------------------===//
 680 // VOP1 Patterns
 681 //===----------------------------------------------------------------------===//
 682
 683 let OtherPredicates = [UnsafeFPMath] in {
 684
 685 //def : RcpPat<V_RCP_F64_e32, f64>;
 686 //defm : RsqPat<V_RSQ_F64_e32, f64>;
 687 //defm : RsqPat<V_RSQ_F32_e32, f32>;
 688
 689 def : RsqPat<V_RSQ_F32_e32, f32>;
 690 def : RsqPat<V_RSQ_F64_e32, f64>;
 691
 692 // Convert (x - floor(x)) to fract(x)
 693 def : GCNPat <
 694   (f32 (fsub (f32 (VOP3Mods f32:$x, i32:$mods)),
 695              (f32 (ffloor (f32 (VOP3Mods f32:$x, i32:$mods)))))),
 696   (V_FRACT_F32_e64 $mods, $x, DSTCLAMP.NONE, DSTOMOD.NONE)
 697 >;
 698
 699 // Convert (x + (-floor(x))) to fract(x)
 700 def : GCNPat <
 701   (f64 (fadd (f64 (VOP3Mods f64:$x, i32:$mods)),
 702              (f64 (fneg (f64 (ffloor (f64 (VOP3Mods f64:$x, i32:$mods)))))))),
 703   (V_FRACT_F64_e64 $mods, $x, DSTCLAMP.NONE, DSTOMOD.NONE)
 704 >;
 705
 706 } // End OtherPredicates = [UnsafeFPMath]
 707
 708
 709 // f16_to_fp patterns
 710 def : GCNPat <
 711   (f32 (f16_to_fp i32:$src0)),
 712   (V_CVT_F32_F16_e64 SRCMODS.NONE, $src0, DSTCLAMP.NONE, DSTOMOD.NONE)
 713 >;
 714
 715 def : GCNPat <
 716   (f32 (f16_to_fp (and_oneuse i32:$src0, 0x7fff))),
 717   (V_CVT_F32_F16_e64 SRCMODS.ABS, $src0, DSTCLAMP.NONE, DSTOMOD.NONE)
 718 >;
 719
 720 def : GCNPat <
 721   (f32 (f16_to_fp (i32 (srl_oneuse (and_oneuse i32:$src0, 0x7fff0000), (i32 16))))),
 722   (V_CVT_F32_F16_e64 SRCMODS.ABS, (i32 (V_LSHRREV_B32_e64 (i32 16), i32:$src0)), DSTCLAMP.NONE, DSTOMOD.NONE)
 723 >;
 724
 725 def : GCNPat <
 726   (f32 (f16_to_fp (or_oneuse i32:$src0, 0x8000))),
 727   (V_CVT_F32_F16_e64 SRCMODS.NEG_ABS, $src0, DSTCLAMP.NONE, DSTOMOD.NONE)
 728 >;
 729
 730 def : GCNPat <
 731   (f32 (f16_to_fp (xor_oneuse i32:$src0, 0x8000))),
 732   (V_CVT_F32_F16_e64 SRCMODS.NEG, $src0, DSTCLAMP.NONE, DSTOMOD.NONE)
 733 >;
 734
 735 def : GCNPat <
 736   (f64 (fpextend f16:$src)),
 737   (V_CVT_F64_F32_e32 (V_CVT_F32_F16_e32 $src))
 738 >;
 739
 740 // fp_to_fp16 patterns
 741 def : GCNPat <
 742   (i32 (AMDGPUfp_to_f16 (f32 (VOP3Mods f32:$src0, i32:$src0_modifiers)))),
 743   (V_CVT_F16_F32_e64 $src0_modifiers, f32:$src0, DSTCLAMP.NONE, DSTOMOD.NONE)
 744 >;
 745
 746 def : GCNPat <
 747   (i32 (fp_to_sint f16:$src)),
 748   (V_CVT_I32_F32_e32 (V_CVT_F32_F16_e32 $src))
 749 >;
 750
 751 def : GCNPat <
 752   (i32 (fp_to_uint f16:$src)),
 753   (V_CVT_U32_F32_e32 (V_CVT_F32_F16_e32 $src))
 754 >;
 755
 756 def : GCNPat <
 757   (f16 (sint_to_fp i32:$src)),
 758   (V_CVT_F16_F32_e32 (V_CVT_F32_I32_e32 $src))
 759 >;
 760
 761 def : GCNPat <
 762   (f16 (uint_to_fp i32:$src)),
 763   (V_CVT_F16_F32_e32 (V_CVT_F32_U32_e32 $src))
 764 >;
 765
 766 //===----------------------------------------------------------------------===//
 767 // VOP2 Patterns
 768 //===----------------------------------------------------------------------===//
 769
 770 multiclass FMADPat <ValueType vt, Instruction inst> {
 771   def : GCNPat <
 772     (vt (fmad (VOP3NoMods vt:$src0),
 773               (VOP3NoMods vt:$src1),
 774               (VOP3NoMods vt:$src2))),
 775     (inst SRCMODS.NONE, $src0, SRCMODS.NONE, $src1,
 776           SRCMODS.NONE, $src2, DSTCLAMP.NONE, DSTOMOD.NONE)
 777   >;
 778 }
 779
 780 defm : FMADPat <f16, V_MAC_F16_e64>;
 781 defm : FMADPat <f32, V_MAC_F32_e64>;
 782
 783 class FMADModsPat<Instruction inst, SDPatternOperator mad_opr, ValueType Ty>
 784   : GCNPat<
 785   (Ty (mad_opr (VOP3Mods Ty:$src0, i32:$src0_mod),
 786   (VOP3Mods Ty:$src1, i32:$src1_mod),
 787   (VOP3Mods Ty:$src2, i32:$src2_mod))),
 788   (inst $src0_mod, $src0, $src1_mod, $src1,
 789   $src2_mod, $src2, DSTCLAMP.NONE, DSTOMOD.NONE)
 790 >;
 791
 792 def : FMADModsPat<V_MAD_F32, AMDGPUfmad_ftz, f32>;
 793 def : FMADModsPat<V_MAD_F16, AMDGPUfmad_ftz, f16> {
 794   let SubtargetPredicate = Has16BitInsts;
 795 }
 796
 797 multiclass SelectPat <ValueType vt> {
 798   def : GCNPat <
 799     (vt (select i1:$src0, (VOP3Mods_f32 vt:$src1, i32:$src1_mods),
 800                           (VOP3Mods_f32 vt:$src2, i32:$src2_mods))),
 801     (V_CNDMASK_B32_e64 $src2_mods, $src2, $src1_mods, $src1, $src0)
 802   >;
 803 }
 804
 805 defm : SelectPat <i16>;
 806 defm : SelectPat <i32>;
 807 defm : SelectPat <f16>;
 808 defm : SelectPat <f32>;
 809
 810 let AddedComplexity = 1 in {
 811 def : GCNPat <
 812   (i32 (add (i32 (getDivergentFrag<ctpop>.ret i32:$popcnt)), i32:$val)),
 813   (V_BCNT_U32_B32_e64 $popcnt, $val)
 814 >;
 815 }
 816 def : GCNPat <
 817   (i16 (add (i16 (trunc (getDivergentFrag<ctpop>.ret i32:$popcnt))), i16:$val)),
 818   (V_BCNT_U32_B32_e64 $popcnt, $val)
 819 >;
 820
 821 /********** ============================================ **********/
 822 /********** Extraction, Insertion, Building and Casting  **********/
 823 /********** ============================================ **********/
 824
 825 foreach Index = 0-2 in {
 826   def Extract_Element_v2i32_#Index : Extract_Element <
 827     i32, v2i32, Index, !cast<SubRegIndex>(sub#Index)
 828   >;
 829   def Insert_Element_v2i32_#Index : Insert_Element <
 830     i32, v2i32, Index, !cast<SubRegIndex>(sub#Index)
 831   >;
 832
 833   def Extract_Element_v2f32_#Index : Extract_Element <
 834     f32, v2f32, Index, !cast<SubRegIndex>(sub#Index)
 835   >;
 836   def Insert_Element_v2f32_#Index : Insert_Element <
 837     f32, v2f32, Index, !cast<SubRegIndex>(sub#Index)
 838   >;
 839 }
 840
 841 foreach Index = 0-2 in {
 842   def Extract_Element_v3i32_#Index : Extract_Element <
 843     i32, v3i32, Index, !cast<SubRegIndex>(sub#Index)
 844   >;
 845   def Insert_Element_v3i32_#Index : Insert_Element <
 846     i32, v3i32, Index, !cast<SubRegIndex>(sub#Index)
 847   >;
 848
 849   def Extract_Element_v3f32_#Index : Extract_Element <
 850     f32, v3f32, Index, !cast<SubRegIndex>(sub#Index)
 851   >;
 852   def Insert_Element_v3f32_#Index : Insert_Element <
 853     f32, v3f32, Index, !cast<SubRegIndex>(sub#Index)
 854   >;
 855 }
 856
 857 foreach Index = 0-3 in {
 858   def Extract_Element_v4i32_#Index : Extract_Element <
 859     i32, v4i32, Index, !cast<SubRegIndex>(sub#Index)
 860   >;
 861   def Insert_Element_v4i32_#Index : Insert_Element <
 862     i32, v4i32, Index, !cast<SubRegIndex>(sub#Index)
 863   >;
 864
 865   def Extract_Element_v4f32_#Index : Extract_Element <
 866     f32, v4f32, Index, !cast<SubRegIndex>(sub#Index)
 867   >;
 868   def Insert_Element_v4f32_#Index : Insert_Element <
 869     f32, v4f32, Index, !cast<SubRegIndex>(sub#Index)
 870   >;
 871 }
 872
 873 foreach Index = 0-4 in {
 874   def Extract_Element_v5i32_#Index : Extract_Element <
 875     i32, v5i32, Index, !cast<SubRegIndex>(sub#Index)
 876   >;
 877   def Insert_Element_v5i32_#Index : Insert_Element <
 878     i32, v5i32, Index, !cast<SubRegIndex>(sub#Index)
 879   >;
 880
 881   def Extract_Element_v5f32_#Index : Extract_Element <
 882     f32, v5f32, Index, !cast<SubRegIndex>(sub#Index)
 883   >;
 884   def Insert_Element_v5f32_#Index : Insert_Element <
 885     f32, v5f32, Index, !cast<SubRegIndex>(sub#Index)
 886   >;
 887 }
 888
 889 foreach Index = 0-7 in {
 890   def Extract_Element_v8i32_#Index : Extract_Element <
 891     i32, v8i32, Index, !cast<SubRegIndex>(sub#Index)
 892   >;
 893   def Insert_Element_v8i32_#Index : Insert_Element <
 894     i32, v8i32, Index, !cast<SubRegIndex>(sub#Index)
 895   >;
 896
 897   def Extract_Element_v8f32_#Index : Extract_Element <
 898     f32, v8f32, Index, !cast<SubRegIndex>(sub#Index)
 899   >;
 900   def Insert_Element_v8f32_#Index : Insert_Element <
 901     f32, v8f32, Index, !cast<SubRegIndex>(sub#Index)
 902   >;
 903 }
 904
 905 foreach Index = 0-15 in {
 906   def Extract_Element_v16i32_#Index : Extract_Element <
 907     i32, v16i32, Index, !cast<SubRegIndex>(sub#Index)
 908   >;
 909   def Insert_Element_v16i32_#Index : Insert_Element <
 910     i32, v16i32, Index, !cast<SubRegIndex>(sub#Index)
 911   >;
 912
 913   def Extract_Element_v16f32_#Index : Extract_Element <
 914     f32, v16f32, Index, !cast<SubRegIndex>(sub#Index)
 915   >;
 916   def Insert_Element_v16f32_#Index : Insert_Element <
 917     f32, v16f32, Index, !cast<SubRegIndex>(sub#Index)
 918   >;
 919 }
 920
 921
 922 def : Pat <
 923   (extract_subvector v4i16:$vec, (i32 0)),
 924   (v2i16 (EXTRACT_SUBREG v4i16:$vec, sub0))
 925 >;
 926
 927 def : Pat <
 928   (extract_subvector v4i16:$vec, (i32 2)),
 929   (v2i16 (EXTRACT_SUBREG v4i16:$vec, sub1))
 930 >;
 931
 932 def : Pat <
 933   (extract_subvector v4f16:$vec, (i32 0)),
 934   (v2f16 (EXTRACT_SUBREG v4f16:$vec, sub0))
 935 >;
 936
 937 def : Pat <
 938   (extract_subvector v4f16:$vec, (i32 2)),
 939   (v2f16 (EXTRACT_SUBREG v4f16:$vec, sub1))
 940 >;
 941
 942 foreach Index = 0-31 in {
 943   def Extract_Element_v32i32_#Index : Extract_Element <
 944     i32, v32i32, Index, !cast<SubRegIndex>(sub#Index)
 945   >;
 946
 947   def Insert_Element_v32i32_#Index : Insert_Element <
 948     i32, v32i32, Index, !cast<SubRegIndex>(sub#Index)
 949   >;
 950
 951   def Extract_Element_v32f32_#Index : Extract_Element <
 952     f32, v32f32, Index, !cast<SubRegIndex>(sub#Index)
 953   >;
 954
 955   def Insert_Element_v32f32_#Index : Insert_Element <
 956     f32, v32f32, Index, !cast<SubRegIndex>(sub#Index)
 957   >;
 958 }
 959
 960 // FIXME: Why do only some of these type combinations for SReg and
 961 // VReg?
 962 // 16-bit bitcast
 963 def : BitConvert <i16, f16, VGPR_32>;
 964 def : BitConvert <f16, i16, VGPR_32>;
 965 def : BitConvert <i16, f16, SReg_32>;
 966 def : BitConvert <f16, i16, SReg_32>;
 967
 968 // 32-bit bitcast
 969 def : BitConvert <i32, f32, VGPR_32>;
 970 def : BitConvert <f32, i32, VGPR_32>;
 971 def : BitConvert <i32, f32, SReg_32>;
 972 def : BitConvert <f32, i32, SReg_32>;
 973 def : BitConvert <v2i16, i32, SReg_32>;
 974 def : BitConvert <i32, v2i16, SReg_32>;
 975 def : BitConvert <v2f16, i32, SReg_32>;
 976 def : BitConvert <i32, v2f16, SReg_32>;
 977 def : BitConvert <v2i16, v2f16, SReg_32>;
 978 def : BitConvert <v2f16, v2i16, SReg_32>;
 979 def : BitConvert <v2f16, f32, SReg_32>;
 980 def : BitConvert <f32, v2f16, SReg_32>;
 981 def : BitConvert <v2i16, f32, SReg_32>;
 982 def : BitConvert <f32, v2i16, SReg_32>;
 983
 984 // 64-bit bitcast
 985 def : BitConvert <i64, f64, VReg_64>;
 986 def : BitConvert <f64, i64, VReg_64>;
 987 def : BitConvert <v2i32, v2f32, VReg_64>;
 988 def : BitConvert <v2f32, v2i32, VReg_64>;
 989 def : BitConvert <i64, v2i32, VReg_64>;
 990 def : BitConvert <v2i32, i64, VReg_64>;
 991 def : BitConvert <i64, v2f32, VReg_64>;
 992 def : BitConvert <v2f32, i64, VReg_64>;
 993 def : BitConvert <f64, v2f32, VReg_64>;
 994 def : BitConvert <v2f32, f64, VReg_64>;
 995 def : BitConvert <f64, v2i32, VReg_64>;
 996 def : BitConvert <v2i32, f64, VReg_64>;
 997 def : BitConvert <v4i16, v4f16, VReg_64>;
 998 def : BitConvert <v4f16, v4i16, VReg_64>;
 999
1000 // FIXME: Make SGPR
1001 def : BitConvert <v2i32, v4f16, VReg_64>;
1002 def : BitConvert <v4f16, v2i32, VReg_64>;
1003 def : BitConvert <v2i32, v4f16, VReg_64>;
1004 def : BitConvert <v2i32, v4i16, VReg_64>;
1005 def : BitConvert <v4i16, v2i32, VReg_64>;
1006 def : BitConvert <v2f32, v4f16, VReg_64>;
1007 def : BitConvert <v4f16, v2f32, VReg_64>;
1008 def : BitConvert <v2f32, v4i16, VReg_64>;
1009 def : BitConvert <v4i16, v2f32, VReg_64>;
1010 def : BitConvert <v4i16, f64, VReg_64>;
1011 def : BitConvert <v4f16, f64, VReg_64>;
1012 def : BitConvert <f64, v4i16, VReg_64>;
1013 def : BitConvert <f64, v4f16, VReg_64>;
1014 def : BitConvert <v4i16, i64, VReg_64>;
1015 def : BitConvert <v4f16, i64, VReg_64>;
1016 def : BitConvert <i64, v4i16, VReg_64>;
1017 def : BitConvert <i64, v4f16, VReg_64>;
1018
1019 def : BitConvert <v4i32, v4f32, VReg_128>;
1020 def : BitConvert <v4f32, v4i32, VReg_128>;
1021
1022 // 96-bit bitcast
1023 def : BitConvert <v3i32, v3f32, SGPR_96>;
1024 def : BitConvert <v3f32, v3i32, SGPR_96>;
1025
1026 // 128-bit bitcast
1027 def : BitConvert <v2i64, v4i32, SReg_128>;
1028 def : BitConvert <v4i32, v2i64, SReg_128>;
1029 def : BitConvert <v2f64, v4f32, VReg_128>;
1030 def : BitConvert <v2f64, v4i32, VReg_128>;
1031 def : BitConvert <v4f32, v2f64, VReg_128>;
1032 def : BitConvert <v4i32, v2f64, VReg_128>;
1033 def : BitConvert <v2i64, v2f64, VReg_128>;
1034 def : BitConvert <v2f64, v2i64, VReg_128>;
1035
1036 // 160-bit bitcast
1037 def : BitConvert <v5i32, v5f32, SGPR_160>;
1038 def : BitConvert <v5f32, v5i32, SGPR_160>;
1039
1040 // 256-bit bitcast
1041 def : BitConvert <v8i32, v8f32, SReg_256>;
1042 def : BitConvert <v8f32, v8i32, SReg_256>;
1043 def : BitConvert <v8i32, v8f32, VReg_256>;
1044 def : BitConvert <v8f32, v8i32, VReg_256>;
1045
1046 // 512-bit bitcast
1047 def : BitConvert <v16i32, v16f32, VReg_512>;
1048 def : BitConvert <v16f32, v16i32, VReg_512>;
1049
1050 // 1024-bit bitcast
1051 def : BitConvert <v32i32, v32f32, VReg_1024>;
1052 def : BitConvert <v32f32, v32i32, VReg_1024>;
1053
1054 /********** =================== **********/
1055 /********** Src & Dst modifiers **********/
1056 /********** =================== **********/
1057
1058
1059 // If denormals are not enabled, it only impacts the compare of the
1060 // inputs. The output result is not flushed.
1061 class ClampPat<Instruction inst, ValueType vt> : GCNPat <
1062   (vt (AMDGPUclamp (VOP3Mods vt:$src0, i32:$src0_modifiers))),
1063   (inst i32:$src0_modifiers, vt:$src0,
1064         i32:$src0_modifiers, vt:$src0, DSTCLAMP.ENABLE, DSTOMOD.NONE)
1065 >;
1066
1067 def : ClampPat<V_MAX_F32_e64, f32>;
1068 def : ClampPat<V_MAX_F64, f64>;
1069 def : ClampPat<V_MAX_F16_e64, f16>;
1070
1071 let SubtargetPredicate = HasVOP3PInsts in {
1072 def : GCNPat <
1073   (v2f16 (AMDGPUclamp (VOP3PMods v2f16:$src0, i32:$src0_modifiers))),
1074   (V_PK_MAX_F16 $src0_modifiers, $src0,
1075                 $src0_modifiers, $src0, DSTCLAMP.ENABLE)
1076 >;
1077 }
1078
1079 /********** ================================ **********/
1080 /********** Floating point absolute/negative **********/
1081 /********** ================================ **********/
1082
1083 // Prevent expanding both fneg and fabs.
1084
1085 def : GCNPat <
1086   (fneg (fabs f32:$src)),
1087   (S_OR_B32 $src, (S_MOV_B32(i32 0x80000000))) // Set sign bit
1088 >;
1089
1090 // FIXME: Should use S_OR_B32
1091 def : GCNPat <
1092   (fneg (fabs f64:$src)),
1093   (REG_SEQUENCE VReg_64,
1094     (i32 (EXTRACT_SUBREG f64:$src, sub0)),
1095     sub0,
1096     (V_OR_B32_e32 (i32 (EXTRACT_SUBREG f64:$src, sub1)),
1097                   (V_MOV_B32_e32 (i32 0x80000000))), // Set sign bit.
1098     sub1)
1099 >;
1100
1101 def : GCNPat <
1102   (fabs f32:$src),
1103   (S_AND_B32 $src, (S_MOV_B32 (i32 0x7fffffff)))
1104 >;
1105
1106 def : GCNPat <
1107   (fneg f32:$src),
1108   (V_XOR_B32_e32 $src, (V_MOV_B32_e32 (i32 0x80000000)))
1109 >;
1110
1111 def : GCNPat <
1112   (fabs f64:$src),
1113   (REG_SEQUENCE VReg_64,
1114     (i32 (EXTRACT_SUBREG f64:$src, sub0)),
1115     sub0,
1116     (V_AND_B32_e64 (i32 (EXTRACT_SUBREG f64:$src, sub1)),
1117                    (V_MOV_B32_e32 (i32 0x7fffffff))), // Set sign bit.
1118      sub1)
1119 >;
1120
1121 def : GCNPat <
1122   (fneg f64:$src),
1123   (REG_SEQUENCE VReg_64,
1124     (i32 (EXTRACT_SUBREG f64:$src, sub0)),
1125     sub0,
1126     (V_XOR_B32_e32 (i32 (EXTRACT_SUBREG f64:$src, sub1)),
1127                    (i32 (V_MOV_B32_e32 (i32 0x80000000)))),
1128     sub1)
1129 >;
1130
1131 def : GCNPat <
1132   (fcopysign f16:$src0, f16:$src1),
1133   (V_BFI_B32 (S_MOV_B32 (i32 0x00007fff)), $src0, $src1)
1134 >;
1135
1136 def : GCNPat <
1137   (fcopysign f32:$src0, f16:$src1),
1138   (V_BFI_B32 (S_MOV_B32 (i32 0x7fffffff)), $src0,
1139              (V_LSHLREV_B32_e64 (i32 16), $src1))
1140 >;
1141
1142 def : GCNPat <
1143   (fcopysign f64:$src0, f16:$src1),
1144   (REG_SEQUENCE SReg_64,
1145     (i32 (EXTRACT_SUBREG $src0, sub0)), sub0,
1146     (V_BFI_B32 (S_MOV_B32 (i32 0x7fffffff)), (i32 (EXTRACT_SUBREG $src0, sub1)),
1147                (V_LSHLREV_B32_e64 (i32 16), $src1)), sub1)
1148 >;
1149
1150 def : GCNPat <
1151   (fcopysign f16:$src0, f32:$src1),
1152   (V_BFI_B32 (S_MOV_B32 (i32 0x00007fff)), $src0,
1153              (V_LSHRREV_B32_e64 (i32 16), $src1))
1154 >;
1155
1156 def : GCNPat <
1157   (fcopysign f16:$src0, f64:$src1),
1158   (V_BFI_B32 (S_MOV_B32 (i32 0x00007fff)), $src0,
1159              (V_LSHRREV_B32_e64 (i32 16), (EXTRACT_SUBREG $src1, sub1)))
1160 >;
1161
1162 def : GCNPat <
1163   (fneg f16:$src),
1164   (S_XOR_B32 $src, (S_MOV_B32 (i32 0x00008000)))
1165 >;
1166
1167 def : GCNPat <
1168   (fabs f16:$src),
1169   (S_AND_B32 $src, (S_MOV_B32 (i32 0x00007fff)))
1170 >;
1171
1172 def : GCNPat <
1173   (fneg (fabs f16:$src)),
1174   (S_OR_B32 $src, (S_MOV_B32 (i32 0x00008000))) // Set sign bit
1175 >;
1176
1177 def : GCNPat <
1178   (fneg v2f16:$src),
1179   (S_XOR_B32 $src, (S_MOV_B32 (i32 0x80008000)))
1180 >;
1181
1182 def : GCNPat <
1183   (fabs v2f16:$src),
1184   (S_AND_B32 $src, (S_MOV_B32 (i32 0x7fff7fff)))
1185 >;
1186
1187 // This is really (fneg (fabs v2f16:$src))
1188 //
1189 // fabs is not reported as free because there is modifier for it in
1190 // VOP3P instructions, so it is turned into the bit op.
1191 def : GCNPat <
1192   (fneg (v2f16 (bitconvert (and_oneuse i32:$src, 0x7fff7fff)))),
1193   (S_OR_B32 $src, (S_MOV_B32 (i32 0x80008000))) // Set sign bit
1194 >;
1195
1196 def : GCNPat <
1197   (fneg (v2f16 (fabs v2f16:$src))),
1198   (S_OR_B32 $src, (S_MOV_B32 (i32 0x80008000))) // Set sign bit
1199 >;
1200
1201 /********** ================== **********/
1202 /********** Immediate Patterns **********/
1203 /********** ================== **********/
1204
1205 def : GCNPat <
1206   (VGPRImm<(i32 imm)>:$imm),
1207   (V_MOV_B32_e32 imm:$imm)
1208 >;
1209
1210 def : GCNPat <
1211   (VGPRImm<(f32 fpimm)>:$imm),
1212   (V_MOV_B32_e32 (f32 (bitcast_fpimm_to_i32 $imm)))
1213 >;
1214
1215 def : GCNPat <
1216   (i32 imm:$imm),
1217   (S_MOV_B32 imm:$imm)
1218 >;
1219
1220 def : GCNPat <
1221   (VGPRImm<(SIlds tglobaladdr:$ga)>),
1222   (V_MOV_B32_e32 $ga)
1223 >;
1224
1225 def : GCNPat <
1226   (SIlds tglobaladdr:$ga),
1227   (S_MOV_B32 $ga)
1228 >;
1229
1230 // FIXME: Workaround for ordering issue with peephole optimizer where
1231 // a register class copy interferes with immediate folding.  Should
1232 // use s_mov_b32, which can be shrunk to s_movk_i32
1233 def : GCNPat <
1234   (VGPRImm<(f16 fpimm)>:$imm),
1235   (V_MOV_B32_e32 (f16 (bitcast_fpimm_to_i32 $imm)))
1236 >;
1237
1238 def : GCNPat <
1239   (f32 fpimm:$imm),
1240   (S_MOV_B32 (f32 (bitcast_fpimm_to_i32 $imm)))
1241 >;
1242
1243 def : GCNPat <
1244   (f16 fpimm:$imm),
1245   (S_MOV_B32 (i32 (bitcast_fpimm_to_i32 $imm)))
1246 >;
1247
1248 def : GCNPat <
1249  (i32 frameindex:$fi),
1250  (V_MOV_B32_e32 (i32 (frameindex_to_targetframeindex $fi)))
1251 >;
1252
1253 def : GCNPat <
1254   (i64 InlineImm<i64>:$imm),
1255   (S_MOV_B64 InlineImm<i64>:$imm)
1256 >;
1257
1258 // XXX - Should this use a s_cmp to set SCC?
1259
1260 // Set to sign-extended 64-bit value (true = -1, false = 0)
1261 def : GCNPat <
1262   (i1 imm:$imm),
1263   (S_MOV_B64 (i64 (as_i64imm $imm)))
1264 > {
1265   let WaveSizePredicate = isWave64;
1266 }
1267
1268 def : GCNPat <
1269   (i1 imm:$imm),
1270   (S_MOV_B32 (i32 (as_i32imm $imm)))
1271 > {
1272   let WaveSizePredicate = isWave32;
1273 }
1274
1275 def : GCNPat <
1276   (f64 InlineFPImm<f64>:$imm),
1277   (S_MOV_B64 (f64 (bitcast_fpimm_to_i64 InlineFPImm<f64>:$imm)))
1278 >;
1279
1280 /********** ================== **********/
1281 /********** Intrinsic Patterns **********/
1282 /********** ================== **********/
1283
1284 def : POW_Common <V_LOG_F32_e32, V_EXP_F32_e32, V_MUL_LEGACY_F32_e32>;
1285
1286 def : GCNPat <
1287   (i32 (sext i1:$src0)),
1288   (V_CNDMASK_B32_e64 /*src0mod*/(i32 0), /*src0*/(i32 0),
1289                      /*src1mod*/(i32 0), /*src1*/(i32 -1), $src0)
1290 >;
1291
1292 class Ext32Pat <SDNode ext> : GCNPat <
1293   (i32 (ext i1:$src0)),
1294   (V_CNDMASK_B32_e64 /*src0mod*/(i32 0), /*src0*/(i32 0),
1295                      /*src1mod*/(i32 0), /*src1*/(i32 1), $src0)
1296 >;
1297
1298 def : Ext32Pat <zext>;
1299 def : Ext32Pat <anyext>;
1300
1301 // The multiplication scales from [0,1] to the unsigned integer range
1302 def : GCNPat <
1303   (AMDGPUurecip i32:$src0),
1304   (V_CVT_U32_F32_e32
1305     (V_MUL_F32_e32 (i32 CONST.FP_UINT_MAX_PLUS_1),
1306                    (V_RCP_IFLAG_F32_e32 (V_CVT_F32_U32_e32 $src0))))
1307 >;
1308
1309 //===----------------------------------------------------------------------===//
1310 // VOP3 Patterns
1311 //===----------------------------------------------------------------------===//
1312
1313 def : IMad24Pat<V_MAD_I32_I24, 1>;
1314 def : UMad24Pat<V_MAD_U32_U24, 1>;
1315
1316 // FIXME: This should only be done for VALU inputs
1317 defm : BFIPatterns <V_BFI_B32, S_MOV_B32, SReg_64>;
1318 def : ROTRPattern <V_ALIGNBIT_B32>;
1319
1320 def : GCNPat<(i32 (trunc (srl i64:$src0, (and i32:$src1, (i32 31))))),
1321           (V_ALIGNBIT_B32 (i32 (EXTRACT_SUBREG (i64 $src0), sub1)),
1322                           (i32 (EXTRACT_SUBREG (i64 $src0), sub0)), $src1)>;
1323
1324 def : GCNPat<(i32 (trunc (srl i64:$src0, (i32 ShiftAmt32Imm:$src1)))),
1325           (V_ALIGNBIT_B32 (i32 (EXTRACT_SUBREG (i64 $src0), sub1)),
1326                           (i32 (EXTRACT_SUBREG (i64 $src0), sub0)), $src1)>;
1327
1328 /********** ====================== **********/
1329 /**********   Indirect addressing  **********/
1330 /********** ====================== **********/
1331
1332 multiclass SI_INDIRECT_Pattern <ValueType vt, ValueType eltvt, string VecSize> {
1333   // Extract with offset
1334   def : GCNPat<
1335     (eltvt (extractelt vt:$src, (MOVRELOffset i32:$idx, (i32 imm:$offset)))),
1336     (!cast<Instruction>("SI_INDIRECT_SRC_"#VecSize) $src, $idx, imm:$offset)
1337   >;
1338
1339   // Insert with offset
1340   def : GCNPat<
1341     (insertelt vt:$src, eltvt:$val, (MOVRELOffset i32:$idx, (i32 imm:$offset))),
1342     (!cast<Instruction>("SI_INDIRECT_DST_"#VecSize) $src, $idx, imm:$offset, $val)
1343   >;
1344 }
1345
1346 defm : SI_INDIRECT_Pattern <v2f32, f32, "V2">;
1347 defm : SI_INDIRECT_Pattern <v4f32, f32, "V4">;
1348 defm : SI_INDIRECT_Pattern <v8f32, f32, "V8">;
1349 defm : SI_INDIRECT_Pattern <v16f32, f32, "V16">;
1350
1351 defm : SI_INDIRECT_Pattern <v2i32, i32, "V2">;
1352 defm : SI_INDIRECT_Pattern <v4i32, i32, "V4">;
1353 defm : SI_INDIRECT_Pattern <v8i32, i32, "V8">;
1354 defm : SI_INDIRECT_Pattern <v16i32, i32, "V16">;
1355
1356 //===----------------------------------------------------------------------===//
1357 // SAD Patterns
1358 //===----------------------------------------------------------------------===//
1359
1360 def : GCNPat <
1361   (add (sub_oneuse (umax i32:$src0, i32:$src1),
1362                    (umin i32:$src0, i32:$src1)),
1363        i32:$src2),
1364   (V_SAD_U32 $src0, $src1, $src2, (i1 0))
1365 >;
1366
1367 def : GCNPat <
1368   (add (select_oneuse (i1 (setugt i32:$src0, i32:$src1)),
1369                       (sub i32:$src0, i32:$src1),
1370                       (sub i32:$src1, i32:$src0)),
1371        i32:$src2),
1372   (V_SAD_U32 $src0, $src1, $src2, (i1 0))
1373 >;
1374
1375 //===----------------------------------------------------------------------===//
1376 // Conversion Patterns
1377 //===----------------------------------------------------------------------===//
1378
1379 def : GCNPat<(i32 (sext_inreg i32:$src, i1)),
1380   (S_BFE_I32 i32:$src, (i32 65536))>; // 0 | 1 << 16
1381
1382 // Handle sext_inreg in i64
1383 def : GCNPat <
1384   (i64 (sext_inreg i64:$src, i1)),
1385   (S_BFE_I64 i64:$src, (i32 0x10000)) // 0 | 1 << 16
1386 >;
1387
1388 def : GCNPat <
1389   (i16 (sext_inreg i16:$src, i1)),
1390   (S_BFE_I32 $src, (i32 0x00010000)) // 0 | 1 << 16
1391 >;
1392
1393 def : GCNPat <
1394   (i16 (sext_inreg i16:$src, i8)),
1395   (S_BFE_I32 $src, (i32 0x80000)) // 0 | 8 << 16
1396 >;
1397
1398 def : GCNPat <
1399   (i64 (sext_inreg i64:$src, i8)),
1400   (S_BFE_I64 i64:$src, (i32 0x80000)) // 0 | 8 << 16
1401 >;
1402
1403 def : GCNPat <
1404   (i64 (sext_inreg i64:$src, i16)),
1405   (S_BFE_I64 i64:$src, (i32 0x100000)) // 0 | 16 << 16
1406 >;
1407
1408 def : GCNPat <
1409   (i64 (sext_inreg i64:$src, i32)),
1410   (S_BFE_I64 i64:$src, (i32 0x200000)) // 0 | 32 << 16
1411 >;
1412
1413 def : GCNPat <
1414   (i64 (zext i32:$src)),
1415   (REG_SEQUENCE SReg_64, $src, sub0, (S_MOV_B32 (i32 0)), sub1)
1416 >;
1417
1418 def : GCNPat <
1419   (i64 (anyext i32:$src)),
1420   (REG_SEQUENCE SReg_64, $src, sub0, (i32 (IMPLICIT_DEF)), sub1)
1421 >;
1422
1423 class ZExt_i64_i1_Pat <SDNode ext> : GCNPat <
1424   (i64 (ext i1:$src)),
1425     (REG_SEQUENCE VReg_64,
1426       (V_CNDMASK_B32_e64 /*src0mod*/(i32 0), /*src0*/(i32 0),
1427                          /*src1mod*/(i32 0), /*src1*/(i32 1), $src),
1428       sub0, (S_MOV_B32 (i32 0)), sub1)
1429 >;
1430
1431
1432 def : ZExt_i64_i1_Pat<zext>;
1433 def : ZExt_i64_i1_Pat<anyext>;
1434
1435 // FIXME: We need to use COPY_TO_REGCLASS to work-around the fact that
1436 // REG_SEQUENCE patterns don't support instructions with multiple outputs.
1437 def : GCNPat <
1438   (i64 (sext i32:$src)),
1439     (REG_SEQUENCE SReg_64, $src, sub0,
1440     (i32 (COPY_TO_REGCLASS (S_ASHR_I32 $src, (i32 31)), SReg_32_XM0)), sub1)
1441 >;
1442
1443 def : GCNPat <
1444   (i64 (sext i1:$src)),
1445   (REG_SEQUENCE VReg_64,
1446     (V_CNDMASK_B32_e64 /*src0mod*/(i32 0), /*src0*/(i32 0),
1447                        /*src1mod*/(i32 0), /*src1*/(i32 -1), $src), sub0,
1448     (V_CNDMASK_B32_e64 /*src0mod*/(i32 0), /*src0*/(i32 0),
1449                        /*src1mod*/(i32 0), /*src1*/(i32 -1), $src), sub1)
1450 >;
1451
1452 class FPToI1Pat<Instruction Inst, int KOne, ValueType kone_type, ValueType vt, SDPatternOperator fp_to_int> : GCNPat <
1453   (i1 (fp_to_int (vt (VOP3Mods vt:$src0, i32:$src0_modifiers)))),
1454   (i1 (Inst 0, (kone_type KOne), $src0_modifiers, $src0, DSTCLAMP.NONE))
1455 >;
1456
1457 def : FPToI1Pat<V_CMP_EQ_F32_e64, CONST.FP32_ONE, i32, f32, fp_to_uint>;
1458 def : FPToI1Pat<V_CMP_EQ_F32_e64, CONST.FP32_NEG_ONE, i32, f32, fp_to_sint>;
1459 def : FPToI1Pat<V_CMP_EQ_F64_e64, CONST.FP64_ONE, i64, f64, fp_to_uint>;
1460 def : FPToI1Pat<V_CMP_EQ_F64_e64, CONST.FP64_NEG_ONE, i64, f64, fp_to_sint>;
1461
1462 // If we need to perform a logical operation on i1 values, we need to
1463 // use vector comparisons since there is only one SCC register. Vector
1464 // comparisons may write to a pair of SGPRs or a single SGPR, so treat
1465 // these as 32 or 64-bit comparisons. When legalizing SGPR copies,
1466 // instructions resulting in the copies from SCC to these instructions
1467 // will be moved to the VALU.
1468
1469 let WaveSizePredicate = isWave64 in {
1470 def : GCNPat <
1471   (i1 (and i1:$src0, i1:$src1)),
1472   (S_AND_B64 $src0, $src1)
1473 >;
1474
1475 def : GCNPat <
1476   (i1 (or i1:$src0, i1:$src1)),
1477   (S_OR_B64 $src0, $src1)
1478 >;
1479
1480 def : GCNPat <
1481   (i1 (xor i1:$src0, i1:$src1)),
1482   (S_XOR_B64 $src0, $src1)
1483 >;
1484
1485 def : GCNPat <
1486   (i1 (add i1:$src0, i1:$src1)),
1487   (S_XOR_B64 $src0, $src1)
1488 >;
1489
1490 def : GCNPat <
1491   (i1 (sub i1:$src0, i1:$src1)),
1492   (S_XOR_B64 $src0, $src1)
1493 >;
1494
1495 let AddedComplexity = 1 in {
1496 def : GCNPat <
1497   (i1 (add i1:$src0, (i1 -1))),
1498   (S_NOT_B64 $src0)
1499 >;
1500
1501 def : GCNPat <
1502   (i1 (sub i1:$src0, (i1 -1))),
1503   (S_NOT_B64 $src0)
1504 >;
1505 }
1506 } // end isWave64
1507
1508 let WaveSizePredicate = isWave32 in {
1509 def : GCNPat <
1510   (i1 (and i1:$src0, i1:$src1)),
1511   (S_AND_B32 $src0, $src1)
1512 >;
1513
1514 def : GCNPat <
1515   (i1 (or i1:$src0, i1:$src1)),
1516   (S_OR_B32 $src0, $src1)
1517 >;
1518
1519 def : GCNPat <
1520   (i1 (xor i1:$src0, i1:$src1)),
1521   (S_XOR_B32 $src0, $src1)
1522 >;
1523
1524 def : GCNPat <
1525   (i1 (add i1:$src0, i1:$src1)),
1526   (S_XOR_B32 $src0, $src1)
1527 >;
1528
1529 def : GCNPat <
1530   (i1 (sub i1:$src0, i1:$src1)),
1531   (S_XOR_B32 $src0, $src1)
1532 >;
1533
1534 let AddedComplexity = 1 in {
1535 def : GCNPat <
1536   (i1 (add i1:$src0, (i1 -1))),
1537   (S_NOT_B32 $src0)
1538 >;
1539
1540 def : GCNPat <
1541   (i1 (sub i1:$src0, (i1 -1))),
1542   (S_NOT_B32 $src0)
1543 >;
1544 }
1545 } // end isWave32
1546
1547 def : GCNPat <
1548   (f16 (sint_to_fp i1:$src)),
1549   (V_CVT_F16_F32_e32 (
1550       V_CNDMASK_B32_e64 /*src0mod*/(i32 0), /*src0*/(i32 0),
1551                         /*src1mod*/(i32 0), /*src1*/(i32 CONST.FP32_NEG_ONE),
1552                         $src))
1553 >;
1554
1555 def : GCNPat <
1556   (f16 (uint_to_fp i1:$src)),
1557   (V_CVT_F16_F32_e32 (
1558       V_CNDMASK_B32_e64 /*src0mod*/(i32 0), /*src0*/(i32 0),
1559                         /*src1mod*/(i32 0), /*src1*/(i32 CONST.FP32_ONE),
1560                         $src))
1561 >;
1562
1563 def : GCNPat <
1564   (f32 (sint_to_fp i1:$src)),
1565   (V_CNDMASK_B32_e64 /*src0mod*/(i32 0), /*src0*/(i32 0),
1566                         /*src1mod*/(i32 0), /*src1*/(i32 CONST.FP32_NEG_ONE),
1567                         $src)
1568 >;
1569
1570 def : GCNPat <
1571   (f32 (uint_to_fp i1:$src)),
1572   (V_CNDMASK_B32_e64 /*src0mod*/(i32 0), /*src0*/(i32 0),
1573                         /*src1mod*/(i32 0), /*src1*/(i32 CONST.FP32_ONE),
1574                         $src)
1575 >;
1576
1577 def : GCNPat <
1578   (f64 (sint_to_fp i1:$src)),
1579   (V_CVT_F64_I32_e32 (V_CNDMASK_B32_e64 /*src0mod*/(i32 0), /*src0*/(i32 0),
1580                                         /*src1mod*/(i32 0), /*src1*/(i32 -1),
1581                                         $src))
1582 >;
1583
1584 def : GCNPat <
1585   (f64 (uint_to_fp i1:$src)),
1586   (V_CVT_F64_U32_e32 (V_CNDMASK_B32_e64 /*src0mod*/(i32 0), /*src0*/(i32 0),
1587                                         /*src1mod*/(i32 0), /*src1*/(i32 1),
1588                                         $src))
1589 >;
1590
1591 //===----------------------------------------------------------------------===//
1592 // Miscellaneous Patterns
1593 //===----------------------------------------------------------------------===//
1594 def : GCNPat <
1595   (i32 (AMDGPUfp16_zext f16:$src)),
1596   (COPY $src)
1597 >;
1598
1599
1600 def : GCNPat <
1601   (i32 (trunc i64:$a)),
1602   (EXTRACT_SUBREG $a, sub0)
1603 >;
1604
1605 def : GCNPat <
1606   (i1 (trunc i32:$a)),
1607   (V_CMP_EQ_U32_e64 (S_AND_B32 (i32 1), $a), (i32 1))
1608 >;
1609
1610 def : GCNPat <
1611   (i1 (trunc i16:$a)),
1612   (V_CMP_EQ_U32_e64 (S_AND_B32 (i32 1), $a), (i32 1))
1613 >;
1614
1615 def : GCNPat <
1616   (i1 (trunc i64:$a)),
1617   (V_CMP_EQ_U32_e64 (S_AND_B32 (i32 1),
1618                     (i32 (EXTRACT_SUBREG $a, sub0))), (i32 1))
1619 >;
1620
1621 def : GCNPat <
1622   (i32 (bswap i32:$a)),
1623   (V_BFI_B32 (S_MOV_B32 (i32 0x00ff00ff)),
1624              (V_ALIGNBIT_B32 $a, $a, (i32 24)),
1625              (V_ALIGNBIT_B32 $a, $a, (i32 8)))
1626 >;
1627
1628 let OtherPredicates = [NoFP16Denormals] in {
1629 def : GCNPat<
1630   (fcanonicalize (f16 (VOP3Mods f16:$src, i32:$src_mods))),
1631   (V_MUL_F16_e64 0, (i32 CONST.FP16_ONE), $src_mods, $src, 0, 0)
1632 >;
1633
1634 def : GCNPat<
1635   (fcanonicalize (f16 (fneg (VOP3Mods f16:$src, i32:$src_mods)))),
1636   (V_MUL_F16_e64 0, (i32 CONST.FP16_NEG_ONE), $src_mods, $src, 0, 0)
1637 >;
1638
1639 def : GCNPat<
1640   (fcanonicalize (v2f16 (VOP3PMods v2f16:$src, i32:$src_mods))),
1641   (V_PK_MUL_F16 0, (i32 CONST.FP16_ONE), $src_mods, $src, DSTCLAMP.NONE)
1642 >;
1643 }
1644
1645 let OtherPredicates = [FP16Denormals] in {
1646 def : GCNPat<
1647   (fcanonicalize (f16 (VOP3Mods f16:$src, i32:$src_mods))),
1648   (V_MAX_F16_e64 $src_mods, $src, $src_mods, $src, 0, 0)
1649 >;
1650
1651 let SubtargetPredicate = HasVOP3PInsts in {
1652 def : GCNPat<
1653   (fcanonicalize (v2f16 (VOP3PMods v2f16:$src, i32:$src_mods))),
1654   (V_PK_MAX_F16 $src_mods, $src, $src_mods, $src, DSTCLAMP.NONE)
1655 >;
1656 }
1657 }
1658
1659 let OtherPredicates = [NoFP32Denormals] in {
1660 def : GCNPat<
1661   (fcanonicalize (f32 (VOP3Mods f32:$src, i32:$src_mods))),
1662   (V_MUL_F32_e64 0, (i32 CONST.FP32_ONE), $src_mods, $src, 0, 0)
1663 >;
1664
1665 def : GCNPat<
1666   (fcanonicalize (f32 (fneg (VOP3Mods f32:$src, i32:$src_mods)))),
1667   (V_MUL_F32_e64 0, (i32 CONST.FP32_NEG_ONE), $src_mods, $src, 0, 0)
1668 >;
1669 }
1670
1671 let OtherPredicates = [FP32Denormals] in {
1672 def : GCNPat<
1673   (fcanonicalize (f32 (VOP3Mods f32:$src, i32:$src_mods))),
1674   (V_MAX_F32_e64 $src_mods, $src, $src_mods, $src, 0, 0)
1675 >;
1676 }
1677
1678 let OtherPredicates = [NoFP64Denormals] in {
1679 def : GCNPat<
1680   (fcanonicalize (f64 (VOP3Mods f64:$src, i32:$src_mods))),
1681   (V_MUL_F64 0, CONST.FP64_ONE, $src_mods, $src, 0, 0)
1682 >;
1683 }
1684
1685 let OtherPredicates = [FP64Denormals] in {
1686 def : GCNPat<
1687   (fcanonicalize (f64 (VOP3Mods f64:$src, i32:$src_mods))),
1688   (V_MAX_F64 $src_mods, $src, $src_mods, $src, 0, 0)
1689 >;
1690 }
1691
1692 let OtherPredicates = [HasDLInsts] in {
1693 def : GCNPat <
1694   (fma (f32 (VOP3Mods0 f32:$src0, i32:$src0_modifiers, i1:$clamp, i32:$omod)),
1695        (f32 (VOP3Mods f32:$src1, i32:$src1_modifiers)),
1696        (f32 (VOP3NoMods f32:$src2))),
1697   (V_FMAC_F32_e64 $src0_modifiers, $src0, $src1_modifiers, $src1,
1698                   SRCMODS.NONE, $src2, $clamp, $omod)
1699 >;
1700 } // End OtherPredicates = [HasDLInsts]
1701
1702 let SubtargetPredicate = isGFX10Plus in
1703 def : GCNPat <
1704   (fma (f16 (VOP3Mods0 f32:$src0, i32:$src0_modifiers, i1:$clamp, i32:$omod)),
1705        (f16 (VOP3Mods f32:$src1, i32:$src1_modifiers)),
1706        (f16 (VOP3NoMods f32:$src2))),
1707   (V_FMAC_F16_e64 $src0_modifiers, $src0, $src1_modifiers, $src1,
1708                   SRCMODS.NONE, $src2, $clamp, $omod)
1709 >;
1710
1711 // Allow integer inputs
1712 class ExpPattern<SDPatternOperator node, ValueType vt, Instruction Inst> : GCNPat<
1713   (node (i8 timm:$tgt), (i8 timm:$en), vt:$src0, vt:$src1, vt:$src2, vt:$src3, (i1 timm:$compr), (i1 timm:$vm)),
1714   (Inst i8:$tgt, vt:$src0, vt:$src1, vt:$src2, vt:$src3, i1:$vm, i1:$compr, i8:$en)
1715 >;
1716
1717 def : ExpPattern<AMDGPUexport, i32, EXP>;
1718 def : ExpPattern<AMDGPUexport_done, i32, EXP_DONE>;
1719
1720 // COPY is workaround tablegen bug from multiple outputs
1721 // from S_LSHL_B32's multiple outputs from implicit scc def.
1722 def : GCNPat <
1723   (v2i16 (build_vector (i16 0), i16:$src1)),
1724   (v2i16 (COPY (S_LSHL_B32 i16:$src1, (i16 16))))
1725 >;
1726
1727 def : GCNPat <
1728   (v2i16 (build_vector i16:$src0, (i16 undef))),
1729   (v2i16 (COPY $src0))
1730 >;
1731
1732 def : GCNPat <
1733   (v2f16 (build_vector f16:$src0, (f16 undef))),
1734   (v2f16 (COPY $src0))
1735 >;
1736
1737 def : GCNPat <
1738   (v2i16 (build_vector (i16 undef), i16:$src1)),
1739   (v2i16 (COPY (S_LSHL_B32 $src1, (i32 16))))
1740 >;
1741
1742 def : GCNPat <
1743   (v2f16 (build_vector (f16 undef), f16:$src1)),
1744   (v2f16 (COPY (S_LSHL_B32 $src1, (i32 16))))
1745 >;
1746
1747 let SubtargetPredicate = HasVOP3PInsts in {
1748 def : GCNPat <
1749   (v2i16 (build_vector i16:$src0, i16:$src1)),
1750   (v2i16 (S_PACK_LL_B32_B16 $src0, $src1))
1751 >;
1752
1753 // With multiple uses of the shift, this will duplicate the shift and
1754 // increase register pressure.
1755 def : GCNPat <
1756   (v2i16 (build_vector i16:$src0, (i16 (trunc (srl_oneuse i32:$src1, (i32 16)))))),
1757   (v2i16 (S_PACK_LH_B32_B16 i16:$src0, i32:$src1))
1758 >;
1759
1760
1761 def : GCNPat <
1762   (v2i16 (build_vector (i16 (trunc (srl_oneuse i32:$src0, (i32 16)))),
1763                        (i16 (trunc (srl_oneuse i32:$src1, (i32 16)))))),
1764   (v2i16 (S_PACK_HH_B32_B16 $src0, $src1))
1765 >;
1766
1767 // TODO: Should source modifiers be matched to v_pack_b32_f16?
1768 def : GCNPat <
1769   (v2f16 (build_vector f16:$src0, f16:$src1)),
1770   (v2f16 (S_PACK_LL_B32_B16 $src0, $src1))
1771 >;
1772
1773 } // End SubtargetPredicate = HasVOP3PInsts
1774
1775
1776 def : GCNPat <
1777   (v2f16 (scalar_to_vector f16:$src0)),
1778   (COPY $src0)
1779 >;
1780
1781 def : GCNPat <
1782   (v2i16 (scalar_to_vector i16:$src0)),
1783   (COPY $src0)
1784 >;
1785
1786 def : GCNPat <
1787   (v4i16 (scalar_to_vector i16:$src0)),
1788   (INSERT_SUBREG (IMPLICIT_DEF), $src0, sub0)
1789 >;
1790
1791 def : GCNPat <
1792   (v4f16 (scalar_to_vector f16:$src0)),
1793   (INSERT_SUBREG (IMPLICIT_DEF), $src0, sub0)
1794 >;
1795
1796 //===----------------------------------------------------------------------===//
1797 // Fract Patterns
1798 //===----------------------------------------------------------------------===//
1799
1800 let SubtargetPredicate = isGFX6 in {
1801
1802 // V_FRACT is buggy on SI, so the F32 version is never used and (x-floor(x)) is
1803 // used instead. However, SI doesn't have V_FLOOR_F64, so the most efficient
1804 // way to implement it is using V_FRACT_F64.
1805 // The workaround for the V_FRACT bug is:
1806 //    fract(x) = isnan(x) ? x : min(V_FRACT(x), 0.99999999999999999)
1807
1808 // Convert floor(x) to (x - fract(x))
1809 def : GCNPat <
1810   (f64 (ffloor (f64 (VOP3Mods f64:$x, i32:$mods)))),
1811   (V_ADD_F64
1812       $mods,
1813       $x,
1814       SRCMODS.NEG,
1815       (V_CNDMASK_B64_PSEUDO
1816          (V_MIN_F64
1817              SRCMODS.NONE,
1818              (V_FRACT_F64_e64 $mods, $x, DSTCLAMP.NONE, DSTOMOD.NONE),
1819              SRCMODS.NONE,
1820              (V_MOV_B64_PSEUDO 0x3fefffffffffffff),
1821              DSTCLAMP.NONE, DSTOMOD.NONE),
1822          $x,
1823          (V_CMP_CLASS_F64_e64 SRCMODS.NONE, $x, (i32 3 /*NaN*/))),
1824       DSTCLAMP.NONE, DSTOMOD.NONE)
1825 >;
1826
1827 } // End SubtargetPredicates = isGFX6
1828
1829 //============================================================================//
1830 // Miscellaneous Optimization Patterns
1831 //============================================================================//
1832
1833 // Undo sub x, c -> add x, -c canonicalization since c is more likely
1834 // an inline immediate than -c.
1835 // TODO: Also do for 64-bit.
1836 def : GCNPat<
1837   (add i32:$src0, (i32 NegSubInlineConst32:$src1)),
1838   (S_SUB_I32 $src0, NegSubInlineConst32:$src1)
1839 >;
1840
1841 // Avoid pointlessly materializing a constant in VGPR.
1842 // FIXME: Should also do this for readlane, but tablegen crashes on
1843 // the ignored src1.
1844 def : GCNPat<
1845   (int_amdgcn_readfirstlane (i32 imm:$src)),
1846   (S_MOV_B32 $src)
1847 >;
1848
1849 multiclass BFMPatterns <ValueType vt, InstSI BFM, InstSI MOV> {
1850   def : GCNPat <
1851     (vt (shl (vt (add (vt (shl 1, vt:$a)), -1)), vt:$b)),
1852     (BFM $a, $b)
1853   >;
1854
1855   def : GCNPat <
1856     (vt (add (vt (shl 1, vt:$a)), -1)),
1857     (BFM $a, (MOV (i32 0)))
1858   >;
1859 }
1860
1861 defm : BFMPatterns <i32, S_BFM_B32, S_MOV_B32>;
1862 // FIXME: defm : BFMPatterns <i64, S_BFM_B64, S_MOV_B64>;
1863
1864 defm : BFEPattern <V_BFE_U32, V_BFE_I32, S_MOV_B32>;
1865 defm : SHA256MaPattern <V_BFI_B32, V_XOR_B32_e64, SReg_64>;
1866
1867 defm : IntMed3Pat<V_MED3_I32, smin, smax, smin_oneuse, smax_oneuse>;
1868 defm : IntMed3Pat<V_MED3_U32, umin, umax, umin_oneuse, umax_oneuse>;
1869
1870 // This matches 16 permutations of
1871 // max(min(x, y), min(max(x, y), z))
1872 class FPMed3Pat<ValueType vt,
1873                 //SDPatternOperator max, SDPatternOperator min,
1874                 Instruction med3Inst> : GCNPat<
1875   (fmaxnum_like (fminnum_like_oneuse (VOP3Mods_nnan vt:$src0, i32:$src0_mods),
1876                            (VOP3Mods_nnan vt:$src1, i32:$src1_mods)),
1877            (fminnum_like_oneuse (fmaxnum_like_oneuse (VOP3Mods_nnan vt:$src0, i32:$src0_mods),
1878                                            (VOP3Mods_nnan vt:$src1, i32:$src1_mods)),
1879                            (vt (VOP3Mods_nnan vt:$src2, i32:$src2_mods)))),
1880   (med3Inst $src0_mods, $src0, $src1_mods, $src1, $src2_mods, $src2, DSTCLAMP.NONE, DSTOMOD.NONE)
1881 >;
1882
1883 class FP16Med3Pat<ValueType vt,
1884                 Instruction med3Inst> : GCNPat<
1885   (fmaxnum_like (fminnum_like_oneuse (VOP3Mods_nnan vt:$src0, i32:$src0_mods),
1886                                      (VOP3Mods_nnan vt:$src1, i32:$src1_mods)),
1887            (fminnum_like_oneuse (fmaxnum_like_oneuse (VOP3Mods_nnan vt:$src0, i32:$src0_mods),
1888                                                      (VOP3Mods_nnan vt:$src1, i32:$src1_mods)),
1889                            (vt (VOP3Mods_nnan vt:$src2, i32:$src2_mods)))),
1890   (med3Inst $src0_mods, $src0, $src1_mods, $src1, $src2_mods, $src2, DSTCLAMP.NONE)
1891 >;
1892
1893 multiclass Int16Med3Pat<Instruction med3Inst,
1894                    SDPatternOperator min,
1895                    SDPatternOperator max,
1896                    SDPatternOperator max_oneuse,
1897                    SDPatternOperator min_oneuse,
1898                    ValueType vt = i16> {
1899   // This matches 16 permutations of
1900   // max(min(x, y), min(max(x, y), z))
1901   def : GCNPat <
1902   (max (min_oneuse vt:$src0, vt:$src1),
1903        (min_oneuse (max_oneuse vt:$src0, vt:$src1), vt:$src2)),
1904   (med3Inst SRCMODS.NONE, $src0, SRCMODS.NONE, $src1, SRCMODS.NONE, $src2, DSTCLAMP.NONE)
1905 >;
1906
1907   // This matches 16 permutations of
1908   // min(max(a, b), max(min(a, b), c))
1909   def : GCNPat <
1910   (min (max_oneuse vt:$src0, vt:$src1),
1911       (max_oneuse (min_oneuse vt:$src0, vt:$src1), vt:$src2)),
1912   (med3Inst SRCMODS.NONE, $src0, SRCMODS.NONE, $src1, SRCMODS.NONE, $src2, DSTCLAMP.NONE)
1913 >;
1914 }
1915
1916 def : FPMed3Pat<f32, V_MED3_F32>;
1917
1918 let OtherPredicates = [isGFX9Plus] in {
1919 def : FP16Med3Pat<f16, V_MED3_F16>;
1920 defm : Int16Med3Pat<V_MED3_I16, smin, smax, smax_oneuse, smin_oneuse>;
1921 defm : Int16Med3Pat<V_MED3_U16, umin, umax, umax_oneuse, umin_oneuse>;
1922 } // End Predicates = [isGFX9Plus]