include/llvm/Target/TargetSelectionDAG.td

   1 //===- TargetSelectionDAG.td - Common code for DAG isels ---*- tablegen -*-===//
   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 //
   9 // This file defines the target-independent interfaces used by SelectionDAG
  10 // instruction selection generators.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 //===----------------------------------------------------------------------===//
  15 // Selection DAG Type Constraint definitions.
  16 //
  17 // Note that the semantics of these constraints are hard coded into tblgen.  To
  18 // modify or add constraints, you have to hack tblgen.
  19 //
  20
  21 class SDTypeConstraint<int opnum> {
  22   int OperandNum = opnum;
  23 }
  24
  25 // SDTCisVT - The specified operand has exactly this VT.
  26 class SDTCisVT<int OpNum, ValueType vt> : SDTypeConstraint<OpNum> {
  27   ValueType VT = vt;
  28 }
  29
  30 class SDTCisPtrTy<int OpNum> : SDTypeConstraint<OpNum>;
  31
  32 // SDTCisInt - The specified operand has integer type.
  33 class SDTCisInt<int OpNum> : SDTypeConstraint<OpNum>;
  34
  35 // SDTCisFP - The specified operand has floating-point type.
  36 class SDTCisFP<int OpNum> : SDTypeConstraint<OpNum>;
  37
  38 // SDTCisVec - The specified operand has a vector type.
  39 class SDTCisVec<int OpNum> : SDTypeConstraint<OpNum>;
  40
  41 // SDTCisSameAs - The two specified operands have identical types.
  42 class SDTCisSameAs<int OpNum, int OtherOp> : SDTypeConstraint<OpNum> {
  43   int OtherOperandNum = OtherOp;
  44 }
  45
  46 // SDTCisVTSmallerThanOp - The specified operand is a VT SDNode, and its type is
  47 // smaller than the 'Other' operand.
  48 class SDTCisVTSmallerThanOp<int OpNum, int OtherOp> : SDTypeConstraint<OpNum> {
  49   int OtherOperandNum = OtherOp;
  50 }
  51
  52 class SDTCisOpSmallerThanOp<int SmallOp, int BigOp> : SDTypeConstraint<SmallOp>{
  53   int BigOperandNum = BigOp;
  54 }
  55
  56 /// SDTCisEltOfVec - This indicates that ThisOp is a scalar type of the same
  57 /// type as the element type of OtherOp, which is a vector type.
  58 class SDTCisEltOfVec<int ThisOp, int OtherOp>
  59   : SDTypeConstraint<ThisOp> {
  60   int OtherOpNum = OtherOp;
  61 }
  62
  63 /// SDTCisSubVecOfVec - This indicates that ThisOp is a vector type
  64 /// with length less that of OtherOp, which is a vector type.
  65 class SDTCisSubVecOfVec<int ThisOp, int OtherOp>
  66   : SDTypeConstraint<ThisOp> {
  67   int OtherOpNum = OtherOp;
  68 }
  69
  70 // SDTCVecEltisVT - The specified operand is vector type with element type
  71 // of VT.
  72 class SDTCVecEltisVT<int OpNum, ValueType vt> : SDTypeConstraint<OpNum> {
  73   ValueType VT = vt;
  74 }
  75
  76 // SDTCisSameNumEltsAs - The two specified operands have identical number
  77 // of elements.
  78 class SDTCisSameNumEltsAs<int OpNum, int OtherOp> : SDTypeConstraint<OpNum> {
  79   int OtherOperandNum = OtherOp;
  80 }
  81
  82 // SDTCisSameSizeAs - The two specified operands have identical size.
  83 class SDTCisSameSizeAs<int OpNum, int OtherOp> : SDTypeConstraint<OpNum> {
  84   int OtherOperandNum = OtherOp;
  85 }
  86
  87 //===----------------------------------------------------------------------===//
  88 // Selection DAG Type Profile definitions.
  89 //
  90 // These use the constraints defined above to describe the type requirements of
  91 // the various nodes.  These are not hard coded into tblgen, allowing targets to
  92 // add their own if needed.
  93 //
  94
  95 // SDTypeProfile - This profile describes the type requirements of a Selection
  96 // DAG node.
  97 class SDTypeProfile<int numresults, int numoperands,
  98                     list<SDTypeConstraint> constraints> {
  99   int NumResults = numresults;
 100   int NumOperands = numoperands;
 101   list<SDTypeConstraint> Constraints = constraints;
 102 }
 103
 104 // Builtin profiles.
 105 def SDTIntLeaf: SDTypeProfile<1, 0, [SDTCisInt<0>]>;         // for 'imm'.
 106 def SDTFPLeaf : SDTypeProfile<1, 0, [SDTCisFP<0>]>;          // for 'fpimm'.
 107 def SDTPtrLeaf: SDTypeProfile<1, 0, [SDTCisPtrTy<0>]>;       // for '&g'.
 108 def SDTOther  : SDTypeProfile<1, 0, [SDTCisVT<0, OtherVT>]>; // for 'vt'.
 109 def SDTUNDEF  : SDTypeProfile<1, 0, []>;                     // for 'undef'.
 110 def SDTUnaryOp  : SDTypeProfile<1, 1, []>;                   // for bitconvert.
 111
 112 def SDTIntBinOp : SDTypeProfile<1, 2, [     // add, and, or, xor, udiv, etc.
 113   SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisInt<0>
 114 ]>;
 115 def SDTIntShiftOp : SDTypeProfile<1, 2, [   // shl, sra, srl
 116   SDTCisSameAs<0, 1>, SDTCisInt<0>, SDTCisInt<2>
 117 ]>;
 118 def SDTIntShiftDOp: SDTypeProfile<1, 3, [   // fshl, fshr
 119   SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisInt<0>, SDTCisInt<3>
 120 ]>;
 121 def SDTIntSatNoShOp : SDTypeProfile<1, 2, [   // ssat with no shift
 122   SDTCisSameAs<0, 1>, SDTCisInt<2>
 123 ]>;
 124 def SDTIntBinHiLoOp : SDTypeProfile<2, 2, [ // mulhi, mullo, sdivrem, udivrem
 125   SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisSameAs<0, 3>,SDTCisInt<0>
 126 ]>;
 127 def SDTIntScaledBinOp : SDTypeProfile<1, 3, [  // smulfix, umulfix
 128   SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisInt<0>, SDTCisInt<3>
 129 ]>;
 130
 131 def SDTFPBinOp : SDTypeProfile<1, 2, [      // fadd, fmul, etc.
 132   SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisFP<0>
 133 ]>;
 134 def SDTFPSignOp : SDTypeProfile<1, 2, [     // fcopysign.
 135   SDTCisSameAs<0, 1>, SDTCisFP<0>, SDTCisFP<2>
 136 ]>;
 137 def SDTFPTernaryOp : SDTypeProfile<1, 3, [  // fmadd, fnmsub, etc.
 138   SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisSameAs<0, 3>, SDTCisFP<0>
 139 ]>;
 140 def SDTIntUnaryOp : SDTypeProfile<1, 1, [ // bitreverse
 141   SDTCisSameAs<0, 1>, SDTCisInt<0>
 142 ]>;
 143 def SDTIntBitCountUnaryOp : SDTypeProfile<1, 1, [   // ctlz, cttz
 144   SDTCisInt<0>, SDTCisInt<1>
 145 ]>;
 146 def SDTIntExtendOp : SDTypeProfile<1, 1, [  // sext, zext, anyext
 147   SDTCisInt<0>, SDTCisInt<1>, SDTCisOpSmallerThanOp<1, 0>, SDTCisSameNumEltsAs<0, 1>
 148 ]>;
 149 def SDTIntTruncOp  : SDTypeProfile<1, 1, [  // trunc
 150   SDTCisInt<0>, SDTCisInt<1>, SDTCisOpSmallerThanOp<0, 1>, SDTCisSameNumEltsAs<0, 1>
 151 ]>;
 152 def SDTFPUnaryOp  : SDTypeProfile<1, 1, [   // fneg, fsqrt, etc
 153   SDTCisSameAs<0, 1>, SDTCisFP<0>
 154 ]>;
 155 def SDTFPRoundOp  : SDTypeProfile<1, 1, [   // fround
 156   SDTCisFP<0>, SDTCisFP<1>, SDTCisOpSmallerThanOp<0, 1>, SDTCisSameNumEltsAs<0, 1>
 157 ]>;
 158 def SDTFPExtendOp  : SDTypeProfile<1, 1, [  // fextend
 159   SDTCisFP<0>, SDTCisFP<1>, SDTCisOpSmallerThanOp<1, 0>, SDTCisSameNumEltsAs<0, 1>
 160 ]>;
 161 def SDTIntToFPOp : SDTypeProfile<1, 1, [    // [su]int_to_fp
 162   SDTCisFP<0>, SDTCisInt<1>, SDTCisSameNumEltsAs<0, 1>
 163 ]>;
 164 def SDTFPToIntOp : SDTypeProfile<1, 1, [    // fp_to_[su]int
 165   SDTCisInt<0>, SDTCisFP<1>, SDTCisSameNumEltsAs<0, 1>
 166 ]>;
 167 def SDTExtInreg : SDTypeProfile<1, 2, [     // sext_inreg
 168   SDTCisSameAs<0, 1>, SDTCisInt<0>, SDTCisVT<2, OtherVT>,
 169   SDTCisVTSmallerThanOp<2, 1>
 170 ]>;
 171 def SDTExtInvec : SDTypeProfile<1, 1, [     // sext_invec
 172   SDTCisInt<0>, SDTCisVec<0>, SDTCisInt<1>, SDTCisVec<1>,
 173   SDTCisOpSmallerThanOp<1, 0>
 174 ]>;
 175
 176 def SDTSetCC : SDTypeProfile<1, 3, [        // setcc
 177   SDTCisInt<0>, SDTCisSameAs<1, 2>, SDTCisVT<3, OtherVT>
 178 ]>;
 179
 180 def SDTSelect : SDTypeProfile<1, 3, [       // select
 181   SDTCisInt<1>, SDTCisSameAs<0, 2>, SDTCisSameAs<2, 3>
 182 ]>;
 183
 184 def SDTVSelect : SDTypeProfile<1, 3, [       // vselect
 185   SDTCisVec<0>, SDTCisInt<1>, SDTCisSameAs<0, 2>, SDTCisSameAs<2, 3>, SDTCisSameNumEltsAs<0, 1>
 186 ]>;
 187
 188 def SDTSelectCC : SDTypeProfile<1, 5, [     // select_cc
 189   SDTCisSameAs<1, 2>, SDTCisSameAs<3, 4>, SDTCisSameAs<0, 3>,
 190   SDTCisVT<5, OtherVT>
 191 ]>;
 192
 193 def SDTBr : SDTypeProfile<0, 1, [           // br
 194   SDTCisVT<0, OtherVT>
 195 ]>;
 196
 197 def SDTBrCC : SDTypeProfile<0, 4, [       // brcc
 198   SDTCisVT<0, OtherVT>, SDTCisSameAs<1, 2>, SDTCisVT<3, OtherVT>
 199 ]>;
 200
 201 def SDTBrcond : SDTypeProfile<0, 2, [       // brcond
 202   SDTCisInt<0>, SDTCisVT<1, OtherVT>
 203 ]>;
 204
 205 def SDTBrind : SDTypeProfile<0, 1, [        // brind
 206   SDTCisPtrTy<0>
 207 ]>;
 208
 209 def SDTCatchret : SDTypeProfile<0, 2, [     // catchret
 210   SDTCisVT<0, OtherVT>, SDTCisVT<1, OtherVT>
 211 ]>;
 212
 213 def SDTNone : SDTypeProfile<0, 0, []>;      // ret, trap
 214
 215 def SDTLoad : SDTypeProfile<1, 1, [         // load
 216   SDTCisPtrTy<1>
 217 ]>;
 218
 219 def SDTStore : SDTypeProfile<0, 2, [        // store
 220   SDTCisPtrTy<1>
 221 ]>;
 222
 223 def SDTIStore : SDTypeProfile<1, 3, [       // indexed store
 224   SDTCisSameAs<0, 2>, SDTCisPtrTy<0>, SDTCisPtrTy<3>
 225 ]>;
 226
 227 def SDTMaskedStore: SDTypeProfile<0, 3, [       // masked store
 228   SDTCisVec<0>, SDTCisPtrTy<1>, SDTCisVec<2>, SDTCisSameNumEltsAs<0, 2>
 229 ]>;
 230
 231 def SDTMaskedLoad: SDTypeProfile<1, 3, [       // masked load
 232   SDTCisVec<0>, SDTCisPtrTy<1>, SDTCisVec<2>, SDTCisSameAs<0, 3>,
 233   SDTCisSameNumEltsAs<0, 2>
 234 ]>;
 235
 236 def SDTVecShuffle : SDTypeProfile<1, 2, [
 237   SDTCisSameAs<0, 1>, SDTCisSameAs<1, 2>
 238 ]>;
 239 def SDTVecExtract : SDTypeProfile<1, 2, [   // vector extract
 240   SDTCisEltOfVec<0, 1>, SDTCisPtrTy<2>
 241 ]>;
 242 def SDTVecInsert : SDTypeProfile<1, 3, [    // vector insert
 243   SDTCisEltOfVec<2, 1>, SDTCisSameAs<0, 1>, SDTCisPtrTy<3>
 244 ]>;
 245 def SDTVecReduce : SDTypeProfile<1, 1, [    // vector reduction
 246   SDTCisInt<0>, SDTCisVec<1>
 247 ]>;
 248
 249 def SDTSubVecExtract : SDTypeProfile<1, 2, [// subvector extract
 250   SDTCisSubVecOfVec<0,1>, SDTCisInt<2>
 251 ]>;
 252 def SDTSubVecInsert : SDTypeProfile<1, 3, [ // subvector insert
 253   SDTCisSubVecOfVec<2, 1>, SDTCisSameAs<0,1>, SDTCisInt<3>
 254 ]>;
 255
 256 def SDTPrefetch : SDTypeProfile<0, 4, [     // prefetch
 257   SDTCisPtrTy<0>, SDTCisSameAs<1, 2>, SDTCisSameAs<1, 3>, SDTCisInt<1>
 258 ]>;
 259
 260 def SDTMemBarrier : SDTypeProfile<0, 5, [   // memory barrier
 261   SDTCisSameAs<0,1>,  SDTCisSameAs<0,2>,  SDTCisSameAs<0,3>, SDTCisSameAs<0,4>,
 262   SDTCisInt<0>
 263 ]>;
 264 def SDTAtomicFence : SDTypeProfile<0, 2, [
 265   SDTCisSameAs<0,1>, SDTCisPtrTy<0>
 266 ]>;
 267 def SDTAtomic3 : SDTypeProfile<1, 3, [
 268   SDTCisSameAs<0,2>,  SDTCisSameAs<0,3>, SDTCisInt<0>, SDTCisPtrTy<1>
 269 ]>;
 270 def SDTAtomic2 : SDTypeProfile<1, 2, [
 271   SDTCisSameAs<0,2>, SDTCisInt<0>, SDTCisPtrTy<1>
 272 ]>;
 273
 274 def SDTFPAtomic2 : SDTypeProfile<1, 2, [
 275   SDTCisSameAs<0,2>, SDTCisFP<0>, SDTCisPtrTy<1>
 276 ]>;
 277
 278 def SDTAtomicStore : SDTypeProfile<0, 2, [
 279   SDTCisPtrTy<0>, SDTCisInt<1>
 280 ]>;
 281 def SDTAtomicLoad : SDTypeProfile<1, 1, [
 282   SDTCisInt<0>, SDTCisPtrTy<1>
 283 ]>;
 284
 285 def SDTConvertOp : SDTypeProfile<1, 5, [ //cvtss, su, us, uu, ff, fs, fu, sf, su
 286   SDTCisVT<2, OtherVT>, SDTCisVT<3, OtherVT>, SDTCisPtrTy<4>, SDTCisPtrTy<5>
 287 ]>;
 288
 289 class SDCallSeqStart<list<SDTypeConstraint> constraints> :
 290         SDTypeProfile<0, 2, constraints>;
 291 class SDCallSeqEnd<list<SDTypeConstraint> constraints> :
 292         SDTypeProfile<0, 2, constraints>;
 293
 294 //===----------------------------------------------------------------------===//
 295 // Selection DAG Node definitions.
 296 //
 297 class SDNode<string opcode, SDTypeProfile typeprof,
 298              list<SDNodeProperty> props = [], string sdclass = "SDNode">
 299              : SDPatternOperator {
 300   string Opcode  = opcode;
 301   string SDClass = sdclass;
 302   let Properties = props;
 303   SDTypeProfile TypeProfile = typeprof;
 304 }
 305
 306 // Special TableGen-recognized dag nodes
 307 def set;
 308 def implicit;
 309 def node;
 310 def srcvalue;
 311
 312 def imm        : SDNode<"ISD::Constant"  , SDTIntLeaf , [], "ConstantSDNode">;
 313 def timm       : SDNode<"ISD::TargetConstant",SDTIntLeaf, [], "ConstantSDNode">;
 314 def fpimm      : SDNode<"ISD::ConstantFP", SDTFPLeaf  , [], "ConstantFPSDNode">;
 315 def vt         : SDNode<"ISD::VALUETYPE" , SDTOther   , [], "VTSDNode">;
 316 def bb         : SDNode<"ISD::BasicBlock", SDTOther   , [], "BasicBlockSDNode">;
 317 def cond       : SDNode<"ISD::CONDCODE"  , SDTOther   , [], "CondCodeSDNode">;
 318 def undef      : SDNode<"ISD::UNDEF"     , SDTUNDEF   , []>;
 319 def globaladdr : SDNode<"ISD::GlobalAddress",         SDTPtrLeaf, [],
 320                         "GlobalAddressSDNode">;
 321 def tglobaladdr : SDNode<"ISD::TargetGlobalAddress",  SDTPtrLeaf, [],
 322                          "GlobalAddressSDNode">;
 323 def globaltlsaddr : SDNode<"ISD::GlobalTLSAddress",         SDTPtrLeaf, [],
 324                           "GlobalAddressSDNode">;
 325 def tglobaltlsaddr : SDNode<"ISD::TargetGlobalTLSAddress",  SDTPtrLeaf, [],
 326                            "GlobalAddressSDNode">;
 327 def constpool   : SDNode<"ISD::ConstantPool",         SDTPtrLeaf, [],
 328                          "ConstantPoolSDNode">;
 329 def tconstpool  : SDNode<"ISD::TargetConstantPool",   SDTPtrLeaf, [],
 330                          "ConstantPoolSDNode">;
 331 def jumptable   : SDNode<"ISD::JumpTable",            SDTPtrLeaf, [],
 332                          "JumpTableSDNode">;
 333 def tjumptable  : SDNode<"ISD::TargetJumpTable",      SDTPtrLeaf, [],
 334                          "JumpTableSDNode">;
 335 def frameindex  : SDNode<"ISD::FrameIndex",           SDTPtrLeaf, [],
 336                          "FrameIndexSDNode">;
 337 def tframeindex : SDNode<"ISD::TargetFrameIndex",     SDTPtrLeaf, [],
 338                          "FrameIndexSDNode">;
 339 def externalsym : SDNode<"ISD::ExternalSymbol",       SDTPtrLeaf, [],
 340                          "ExternalSymbolSDNode">;
 341 def texternalsym: SDNode<"ISD::TargetExternalSymbol", SDTPtrLeaf, [],
 342                          "ExternalSymbolSDNode">;
 343 def mcsym: SDNode<"ISD::MCSymbol", SDTPtrLeaf, [], "MCSymbolSDNode">;
 344 def blockaddress : SDNode<"ISD::BlockAddress",        SDTPtrLeaf, [],
 345                          "BlockAddressSDNode">;
 346 def tblockaddress: SDNode<"ISD::TargetBlockAddress",  SDTPtrLeaf, [],
 347                          "BlockAddressSDNode">;
 348
 349 def add        : SDNode<"ISD::ADD"       , SDTIntBinOp   ,
 350                         [SDNPCommutative, SDNPAssociative]>;
 351 def sub        : SDNode<"ISD::SUB"       , SDTIntBinOp>;
 352 def mul        : SDNode<"ISD::MUL"       , SDTIntBinOp,
 353                         [SDNPCommutative, SDNPAssociative]>;
 354 def mulhs      : SDNode<"ISD::MULHS"     , SDTIntBinOp, [SDNPCommutative]>;
 355 def mulhu      : SDNode<"ISD::MULHU"     , SDTIntBinOp, [SDNPCommutative]>;
 356 def smullohi   : SDNode<"ISD::SMUL_LOHI" , SDTIntBinHiLoOp, [SDNPCommutative]>;
 357 def umullohi   : SDNode<"ISD::UMUL_LOHI" , SDTIntBinHiLoOp, [SDNPCommutative]>;
 358 def sdiv       : SDNode<"ISD::SDIV"      , SDTIntBinOp>;
 359 def udiv       : SDNode<"ISD::UDIV"      , SDTIntBinOp>;
 360 def srem       : SDNode<"ISD::SREM"      , SDTIntBinOp>;
 361 def urem       : SDNode<"ISD::UREM"      , SDTIntBinOp>;
 362 def sdivrem    : SDNode<"ISD::SDIVREM"   , SDTIntBinHiLoOp>;
 363 def udivrem    : SDNode<"ISD::UDIVREM"   , SDTIntBinHiLoOp>;
 364 def srl        : SDNode<"ISD::SRL"       , SDTIntShiftOp>;
 365 def sra        : SDNode<"ISD::SRA"       , SDTIntShiftOp>;
 366 def shl        : SDNode<"ISD::SHL"       , SDTIntShiftOp>;
 367 def rotl       : SDNode<"ISD::ROTL"      , SDTIntShiftOp>;
 368 def rotr       : SDNode<"ISD::ROTR"      , SDTIntShiftOp>;
 369 def fshl       : SDNode<"ISD::FSHL"      , SDTIntShiftDOp>;
 370 def fshr       : SDNode<"ISD::FSHR"      , SDTIntShiftDOp>;
 371 def and        : SDNode<"ISD::AND"       , SDTIntBinOp,
 372                         [SDNPCommutative, SDNPAssociative]>;
 373 def or         : SDNode<"ISD::OR"        , SDTIntBinOp,
 374                         [SDNPCommutative, SDNPAssociative]>;
 375 def xor        : SDNode<"ISD::XOR"       , SDTIntBinOp,
 376                         [SDNPCommutative, SDNPAssociative]>;
 377 def addc       : SDNode<"ISD::ADDC"      , SDTIntBinOp,
 378                         [SDNPCommutative, SDNPOutGlue]>;
 379 def adde       : SDNode<"ISD::ADDE"      , SDTIntBinOp,
 380                         [SDNPCommutative, SDNPOutGlue, SDNPInGlue]>;
 381 def subc       : SDNode<"ISD::SUBC"      , SDTIntBinOp,
 382                         [SDNPOutGlue]>;
 383 def sube       : SDNode<"ISD::SUBE"      , SDTIntBinOp,
 384                         [SDNPOutGlue, SDNPInGlue]>;
 385 def smin       : SDNode<"ISD::SMIN"      , SDTIntBinOp,
 386                                   [SDNPCommutative, SDNPAssociative]>;
 387 def smax       : SDNode<"ISD::SMAX"      , SDTIntBinOp,
 388                                   [SDNPCommutative, SDNPAssociative]>;
 389 def umin       : SDNode<"ISD::UMIN"      , SDTIntBinOp,
 390                                   [SDNPCommutative, SDNPAssociative]>;
 391 def umax       : SDNode<"ISD::UMAX"      , SDTIntBinOp,
 392                                   [SDNPCommutative, SDNPAssociative]>;
 393
 394 def saddsat    : SDNode<"ISD::SADDSAT"   , SDTIntBinOp, [SDNPCommutative]>;
 395 def uaddsat    : SDNode<"ISD::UADDSAT"   , SDTIntBinOp, [SDNPCommutative]>;
 396 def ssubsat    : SDNode<"ISD::SSUBSAT"   , SDTIntBinOp>;
 397 def usubsat    : SDNode<"ISD::USUBSAT"   , SDTIntBinOp>;
 398
 399 def smulfix    : SDNode<"ISD::SMULFIX"   , SDTIntScaledBinOp, [SDNPCommutative]>;
 400 def smulfixsat : SDNode<"ISD::SMULFIXSAT", SDTIntScaledBinOp, [SDNPCommutative]>;
 401 def umulfix    : SDNode<"ISD::UMULFIX"   , SDTIntScaledBinOp, [SDNPCommutative]>;
 402 def umulfixsat : SDNode<"ISD::UMULFIXSAT", SDTIntScaledBinOp, [SDNPCommutative]>;
 403
 404 def sext_inreg : SDNode<"ISD::SIGN_EXTEND_INREG", SDTExtInreg>;
 405 def sext_invec : SDNode<"ISD::SIGN_EXTEND_VECTOR_INREG", SDTExtInvec>;
 406 def zext_invec : SDNode<"ISD::ZERO_EXTEND_VECTOR_INREG", SDTExtInvec>;
 407
 408 def abs        : SDNode<"ISD::ABS"        , SDTIntUnaryOp>;
 409 def bitreverse : SDNode<"ISD::BITREVERSE" , SDTIntUnaryOp>;
 410 def bswap      : SDNode<"ISD::BSWAP"      , SDTIntUnaryOp>;
 411 def ctlz       : SDNode<"ISD::CTLZ"       , SDTIntBitCountUnaryOp>;
 412 def cttz       : SDNode<"ISD::CTTZ"       , SDTIntBitCountUnaryOp>;
 413 def ctpop      : SDNode<"ISD::CTPOP"      , SDTIntBitCountUnaryOp>;
 414 def ctlz_zero_undef : SDNode<"ISD::CTLZ_ZERO_UNDEF", SDTIntBitCountUnaryOp>;
 415 def cttz_zero_undef : SDNode<"ISD::CTTZ_ZERO_UNDEF", SDTIntBitCountUnaryOp>;
 416 def sext       : SDNode<"ISD::SIGN_EXTEND", SDTIntExtendOp>;
 417 def zext       : SDNode<"ISD::ZERO_EXTEND", SDTIntExtendOp>;
 418 def anyext     : SDNode<"ISD::ANY_EXTEND" , SDTIntExtendOp>;
 419 def trunc      : SDNode<"ISD::TRUNCATE"   , SDTIntTruncOp>;
 420 def bitconvert : SDNode<"ISD::BITCAST"    , SDTUnaryOp>;
 421 def addrspacecast : SDNode<"ISD::ADDRSPACECAST", SDTUnaryOp>;
 422 def extractelt : SDNode<"ISD::EXTRACT_VECTOR_ELT", SDTVecExtract>;
 423 def insertelt  : SDNode<"ISD::INSERT_VECTOR_ELT", SDTVecInsert>;
 424
 425 def vecreduce_add  : SDNode<"ISD::VECREDUCE_ADD", SDTVecReduce>;
 426 def vecreduce_smax  : SDNode<"ISD::VECREDUCE_SMAX", SDTVecReduce>;
 427 def vecreduce_umax  : SDNode<"ISD::VECREDUCE_UMAX", SDTVecReduce>;
 428 def vecreduce_smin  : SDNode<"ISD::VECREDUCE_SMIN", SDTVecReduce>;
 429 def vecreduce_umin  : SDNode<"ISD::VECREDUCE_UMIN", SDTVecReduce>;
 430
 431 def fadd       : SDNode<"ISD::FADD"       , SDTFPBinOp, [SDNPCommutative]>;
 432 def fsub       : SDNode<"ISD::FSUB"       , SDTFPBinOp>;
 433 def fmul       : SDNode<"ISD::FMUL"       , SDTFPBinOp, [SDNPCommutative]>;
 434 def fdiv       : SDNode<"ISD::FDIV"       , SDTFPBinOp>;
 435 def frem       : SDNode<"ISD::FREM"       , SDTFPBinOp>;
 436 def fma        : SDNode<"ISD::FMA"        , SDTFPTernaryOp>;
 437 def fmad       : SDNode<"ISD::FMAD"       , SDTFPTernaryOp>;
 438 def fabs       : SDNode<"ISD::FABS"       , SDTFPUnaryOp>;
 439 def fminnum    : SDNode<"ISD::FMINNUM"    , SDTFPBinOp,
 440                                   [SDNPCommutative, SDNPAssociative]>;
 441 def fmaxnum    : SDNode<"ISD::FMAXNUM"    , SDTFPBinOp,
 442                                   [SDNPCommutative, SDNPAssociative]>;
 443 def fminnum_ieee : SDNode<"ISD::FMINNUM_IEEE", SDTFPBinOp,
 444                           [SDNPCommutative]>;
 445 def fmaxnum_ieee  : SDNode<"ISD::FMAXNUM_IEEE", SDTFPBinOp,
 446                            [SDNPCommutative]>;
 447 def fminimum   : SDNode<"ISD::FMINIMUM"   , SDTFPBinOp,
 448                         [SDNPCommutative, SDNPAssociative]>;
 449 def fmaximum   : SDNode<"ISD::FMAXIMUM"   , SDTFPBinOp,
 450                         [SDNPCommutative, SDNPAssociative]>;
 451 def fgetsign   : SDNode<"ISD::FGETSIGN"   , SDTFPToIntOp>;
 452 def fcanonicalize : SDNode<"ISD::FCANONICALIZE", SDTFPUnaryOp>;
 453 def fneg       : SDNode<"ISD::FNEG"       , SDTFPUnaryOp>;
 454 def fsqrt      : SDNode<"ISD::FSQRT"      , SDTFPUnaryOp>;
 455 def fsin       : SDNode<"ISD::FSIN"       , SDTFPUnaryOp>;
 456 def fcos       : SDNode<"ISD::FCOS"       , SDTFPUnaryOp>;
 457 def fexp2      : SDNode<"ISD::FEXP2"      , SDTFPUnaryOp>;
 458 def fpow       : SDNode<"ISD::FPOW"       , SDTFPBinOp>;
 459 def flog2      : SDNode<"ISD::FLOG2"      , SDTFPUnaryOp>;
 460 def frint      : SDNode<"ISD::FRINT"      , SDTFPUnaryOp>;
 461 def ftrunc     : SDNode<"ISD::FTRUNC"     , SDTFPUnaryOp>;
 462 def fceil      : SDNode<"ISD::FCEIL"      , SDTFPUnaryOp>;
 463 def ffloor     : SDNode<"ISD::FFLOOR"     , SDTFPUnaryOp>;
 464 def fnearbyint : SDNode<"ISD::FNEARBYINT" , SDTFPUnaryOp>;
 465 def fround     : SDNode<"ISD::FROUND"     , SDTFPUnaryOp>;
 466
 467 def lround     : SDNode<"ISD::LROUND"     , SDTFPToIntOp>;
 468 def llround    : SDNode<"ISD::LLROUND"    , SDTFPToIntOp>;
 469 def lrint      : SDNode<"ISD::LRINT"      , SDTFPToIntOp>;
 470 def llrint     : SDNode<"ISD::LLRINT"     , SDTFPToIntOp>;
 471
 472 def fpround    : SDNode<"ISD::FP_ROUND"   , SDTFPRoundOp>;
 473 def fpextend   : SDNode<"ISD::FP_EXTEND"  , SDTFPExtendOp>;
 474 def fcopysign  : SDNode<"ISD::FCOPYSIGN"  , SDTFPSignOp>;
 475
 476 def sint_to_fp : SDNode<"ISD::SINT_TO_FP" , SDTIntToFPOp>;
 477 def uint_to_fp : SDNode<"ISD::UINT_TO_FP" , SDTIntToFPOp>;
 478 def fp_to_sint : SDNode<"ISD::FP_TO_SINT" , SDTFPToIntOp>;
 479 def fp_to_uint : SDNode<"ISD::FP_TO_UINT" , SDTFPToIntOp>;
 480 def f16_to_fp  : SDNode<"ISD::FP16_TO_FP" , SDTIntToFPOp>;
 481 def fp_to_f16  : SDNode<"ISD::FP_TO_FP16" , SDTFPToIntOp>;
 482
 483 def strict_fadd       : SDNode<"ISD::STRICT_FADD",
 484                                SDTFPBinOp, [SDNPHasChain, SDNPCommutative]>;
 485 def strict_fsub       : SDNode<"ISD::STRICT_FSUB",
 486                                SDTFPBinOp, [SDNPHasChain]>;
 487 def strict_fmul       : SDNode<"ISD::STRICT_FMUL",
 488                                SDTFPBinOp, [SDNPHasChain, SDNPCommutative]>;
 489 def strict_fdiv       : SDNode<"ISD::STRICT_FDIV",
 490                                SDTFPBinOp, [SDNPHasChain]>;
 491 def strict_frem       : SDNode<"ISD::STRICT_FREM",
 492                                SDTFPBinOp, [SDNPHasChain]>;
 493 def strict_fma        : SDNode<"ISD::STRICT_FMA",
 494                                SDTFPTernaryOp, [SDNPHasChain]>;
 495 def strict_fsqrt      : SDNode<"ISD::STRICT_FSQRT",
 496                                SDTFPUnaryOp, [SDNPHasChain]>;
 497 def strict_fsin       : SDNode<"ISD::STRICT_FSIN",
 498                                SDTFPUnaryOp, [SDNPHasChain]>;
 499 def strict_fcos       : SDNode<"ISD::STRICT_FCOS",
 500                                SDTFPUnaryOp, [SDNPHasChain]>;
 501 def strict_fexp2      : SDNode<"ISD::STRICT_FEXP2",
 502                                SDTFPUnaryOp, [SDNPHasChain]>;
 503 def strict_fpow       : SDNode<"ISD::STRICT_FPOW",
 504                                SDTFPBinOp, [SDNPHasChain]>;
 505 def strict_flog2      : SDNode<"ISD::STRICT_FLOG2",
 506                                SDTFPUnaryOp, [SDNPHasChain]>;
 507 def strict_frint      : SDNode<"ISD::STRICT_FRINT",
 508                                SDTFPUnaryOp, [SDNPHasChain]>;
 509 def strict_fnearbyint : SDNode<"ISD::STRICT_FNEARBYINT",
 510                                SDTFPUnaryOp, [SDNPHasChain]>;
 511 def strict_fceil      : SDNode<"ISD::STRICT_FCEIL",
 512                                SDTFPUnaryOp, [SDNPHasChain]>;
 513 def strict_ffloor     : SDNode<"ISD::STRICT_FFLOOR",
 514                                SDTFPUnaryOp, [SDNPHasChain]>;
 515 def strict_fround     : SDNode<"ISD::STRICT_FROUND",
 516                                SDTFPUnaryOp, [SDNPHasChain]>;
 517 def strict_ftrunc     : SDNode<"ISD::STRICT_FTRUNC",
 518                                SDTFPUnaryOp, [SDNPHasChain]>;
 519 def strict_fminnum    : SDNode<"ISD::STRICT_FMINNUM",
 520                                SDTFPBinOp, [SDNPHasChain,
 521                                             SDNPCommutative, SDNPAssociative]>;
 522 def strict_fmaxnum    : SDNode<"ISD::STRICT_FMAXNUM",
 523                                SDTFPBinOp, [SDNPHasChain,
 524                                             SDNPCommutative, SDNPAssociative]>;
 525 def strict_fpround    : SDNode<"ISD::STRICT_FP_ROUND",
 526                                SDTFPRoundOp, [SDNPHasChain]>;
 527 def strict_fpextend   : SDNode<"ISD::STRICT_FP_EXTEND",
 528                                SDTFPExtendOp, [SDNPHasChain]>;
 529 def strict_fp_to_sint : SDNode<"ISD::STRICT_FP_TO_SINT",
 530                                SDTFPToIntOp, [SDNPHasChain]>;
 531 def strict_fp_to_uint : SDNode<"ISD::STRICT_FP_TO_UINT",
 532                                SDTFPToIntOp, [SDNPHasChain]>;
 533
 534 def setcc      : SDNode<"ISD::SETCC"      , SDTSetCC>;
 535 def select     : SDNode<"ISD::SELECT"     , SDTSelect>;
 536 def vselect    : SDNode<"ISD::VSELECT"    , SDTVSelect>;
 537 def selectcc   : SDNode<"ISD::SELECT_CC"  , SDTSelectCC>;
 538
 539 def brcc       : SDNode<"ISD::BR_CC"      , SDTBrCC,   [SDNPHasChain]>;
 540 def brcond     : SDNode<"ISD::BRCOND"     , SDTBrcond, [SDNPHasChain]>;
 541 def brind      : SDNode<"ISD::BRIND"      , SDTBrind,  [SDNPHasChain]>;
 542 def br         : SDNode<"ISD::BR"         , SDTBr,     [SDNPHasChain]>;
 543 def catchret   : SDNode<"ISD::CATCHRET"   , SDTCatchret,
 544                         [SDNPHasChain, SDNPSideEffect]>;
 545 def cleanupret : SDNode<"ISD::CLEANUPRET" , SDTNone,   [SDNPHasChain]>;
 546 def catchpad   : SDNode<"ISD::CATCHPAD"   , SDTNone,
 547                         [SDNPHasChain, SDNPSideEffect]>;
 548
 549 def trap       : SDNode<"ISD::TRAP"       , SDTNone,
 550                         [SDNPHasChain, SDNPSideEffect]>;
 551 def debugtrap  : SDNode<"ISD::DEBUGTRAP"  , SDTNone,
 552                         [SDNPHasChain, SDNPSideEffect]>;
 553
 554 def prefetch   : SDNode<"ISD::PREFETCH"   , SDTPrefetch,
 555                         [SDNPHasChain, SDNPMayLoad, SDNPMayStore,
 556                          SDNPMemOperand]>;
 557
 558 def readcyclecounter : SDNode<"ISD::READCYCLECOUNTER", SDTIntLeaf,
 559                      [SDNPHasChain, SDNPSideEffect]>;
 560
 561 def atomic_fence : SDNode<"ISD::ATOMIC_FENCE" , SDTAtomicFence,
 562                           [SDNPHasChain, SDNPSideEffect]>;
 563
 564 def atomic_cmp_swap : SDNode<"ISD::ATOMIC_CMP_SWAP" , SDTAtomic3,
 565                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 566 def atomic_load_add : SDNode<"ISD::ATOMIC_LOAD_ADD" , SDTAtomic2,
 567                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 568 def atomic_swap     : SDNode<"ISD::ATOMIC_SWAP", SDTAtomic2,
 569                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 570 def atomic_load_sub : SDNode<"ISD::ATOMIC_LOAD_SUB" , SDTAtomic2,
 571                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 572 def atomic_load_and : SDNode<"ISD::ATOMIC_LOAD_AND" , SDTAtomic2,
 573                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 574 def atomic_load_clr : SDNode<"ISD::ATOMIC_LOAD_CLR" , SDTAtomic2,
 575                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 576 def atomic_load_or  : SDNode<"ISD::ATOMIC_LOAD_OR" , SDTAtomic2,
 577                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 578 def atomic_load_xor : SDNode<"ISD::ATOMIC_LOAD_XOR" , SDTAtomic2,
 579                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 580 def atomic_load_nand: SDNode<"ISD::ATOMIC_LOAD_NAND", SDTAtomic2,
 581                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 582 def atomic_load_min : SDNode<"ISD::ATOMIC_LOAD_MIN", SDTAtomic2,
 583                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 584 def atomic_load_max : SDNode<"ISD::ATOMIC_LOAD_MAX", SDTAtomic2,
 585                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 586 def atomic_load_umin : SDNode<"ISD::ATOMIC_LOAD_UMIN", SDTAtomic2,
 587                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 588 def atomic_load_umax : SDNode<"ISD::ATOMIC_LOAD_UMAX", SDTAtomic2,
 589                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 590 def atomic_load_fadd : SDNode<"ISD::ATOMIC_LOAD_FADD" , SDTFPAtomic2,
 591                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 592 def atomic_load_fsub : SDNode<"ISD::ATOMIC_LOAD_FSUB" , SDTFPAtomic2,
 593                     [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 594
 595 def atomic_load      : SDNode<"ISD::ATOMIC_LOAD", SDTAtomicLoad,
 596                     [SDNPHasChain, SDNPMayLoad, SDNPMemOperand]>;
 597 def atomic_store     : SDNode<"ISD::ATOMIC_STORE", SDTAtomicStore,
 598                     [SDNPHasChain, SDNPMayStore, SDNPMemOperand]>;
 599
 600 def masked_st    : SDNode<"ISD::MSTORE",  SDTMaskedStore,
 601                        [SDNPHasChain, SDNPMayStore, SDNPMemOperand]>;
 602 def masked_ld    : SDNode<"ISD::MLOAD",  SDTMaskedLoad,
 603                        [SDNPHasChain, SDNPMayLoad, SDNPMemOperand]>;
 604
 605 // Do not use ld, st directly. Use load, extload, sextload, zextload, store,
 606 // and truncst (see below).
 607 def ld         : SDNode<"ISD::LOAD"       , SDTLoad,
 608                         [SDNPHasChain, SDNPMayLoad, SDNPMemOperand]>;
 609 def st         : SDNode<"ISD::STORE"      , SDTStore,
 610                         [SDNPHasChain, SDNPMayStore, SDNPMemOperand]>;
 611 def ist        : SDNode<"ISD::STORE"      , SDTIStore,
 612                         [SDNPHasChain, SDNPMayStore, SDNPMemOperand]>;
 613
 614 def vector_shuffle : SDNode<"ISD::VECTOR_SHUFFLE", SDTVecShuffle, []>;
 615 def build_vector : SDNode<"ISD::BUILD_VECTOR", SDTypeProfile<1, -1, []>, []>;
 616 def scalar_to_vector : SDNode<"ISD::SCALAR_TO_VECTOR", SDTypeProfile<1, 1, []>,
 617                               []>;
 618
 619 // vector_extract/vector_insert are deprecated. extractelt/insertelt
 620 // are preferred.
 621 def vector_extract : SDNode<"ISD::EXTRACT_VECTOR_ELT",
 622     SDTypeProfile<1, 2, [SDTCisPtrTy<2>]>, []>;
 623 def vector_insert : SDNode<"ISD::INSERT_VECTOR_ELT",
 624     SDTypeProfile<1, 3, [SDTCisSameAs<0, 1>, SDTCisPtrTy<3>]>, []>;
 625 def concat_vectors : SDNode<"ISD::CONCAT_VECTORS",
 626     SDTypeProfile<1, 2, [SDTCisSubVecOfVec<1, 0>, SDTCisSameAs<1, 2>]>,[]>;
 627
 628 // This operator does not do subvector type checking.  The ARM
 629 // backend, at least, needs it.
 630 def vector_extract_subvec : SDNode<"ISD::EXTRACT_SUBVECTOR",
 631     SDTypeProfile<1, 2, [SDTCisInt<2>, SDTCisVec<1>, SDTCisVec<0>]>,
 632     []>;
 633
 634 // This operator does subvector type checking.
 635 def extract_subvector : SDNode<"ISD::EXTRACT_SUBVECTOR", SDTSubVecExtract, []>;
 636 def insert_subvector : SDNode<"ISD::INSERT_SUBVECTOR", SDTSubVecInsert, []>;
 637
 638 // Nodes for intrinsics, you should use the intrinsic itself and let tblgen use
 639 // these internally.  Don't reference these directly.
 640 def intrinsic_void : SDNode<"ISD::INTRINSIC_VOID",
 641                             SDTypeProfile<0, -1, [SDTCisPtrTy<0>]>,
 642                             [SDNPHasChain]>;
 643 def intrinsic_w_chain : SDNode<"ISD::INTRINSIC_W_CHAIN",
 644                                SDTypeProfile<1, -1, [SDTCisPtrTy<1>]>,
 645                                [SDNPHasChain]>;
 646 def intrinsic_wo_chain : SDNode<"ISD::INTRINSIC_WO_CHAIN",
 647                                 SDTypeProfile<1, -1, [SDTCisPtrTy<1>]>, []>;
 648
 649 def SDT_assertext : SDTypeProfile<1, 1,
 650   [SDTCisInt<0>, SDTCisInt<1>, SDTCisSameAs<1, 0>]>;
 651 def assertsext : SDNode<"ISD::AssertSext", SDT_assertext>;
 652 def assertzext : SDNode<"ISD::AssertZext", SDT_assertext>;
 653
 654
 655 //===----------------------------------------------------------------------===//
 656 // Selection DAG Condition Codes
 657
 658 class CondCode<string fcmpName = "", string icmpName = ""> {
 659   string ICmpPredicate = icmpName;
 660   string FCmpPredicate = fcmpName;
 661 }
 662
 663 // ISD::CondCode enums, and mapping to CmpInst::Predicate names
 664 def SETOEQ : CondCode<"FCMP_OEQ">;
 665 def SETOGT : CondCode<"FCMP_OGT">;
 666 def SETOGE : CondCode<"FCMP_OGE">;
 667 def SETOLT : CondCode<"FCMP_OLT">;
 668 def SETOLE : CondCode<"FCMP_OLE">;
 669 def SETONE : CondCode<"FCMP_ONE">;
 670 def SETO   : CondCode<"FCMP_ORD">;
 671 def SETUO  : CondCode<"FCMP_UNO">;
 672 def SETUEQ : CondCode<"FCMP_UEQ">;
 673 def SETUGT : CondCode<"FCMP_UGT", "ICMP_UGT">;
 674 def SETUGE : CondCode<"FCMP_UGE", "ICMP_UGE">;
 675 def SETULT : CondCode<"FCMP_ULT", "ICMP_ULT">;
 676 def SETULE : CondCode<"FCMP_ULE", "ICMP_ULE">;
 677 def SETUNE : CondCode<"FCMP_UNE">;
 678 def SETEQ : CondCode<"", "ICMP_EQ">;
 679 def SETGT : CondCode<"", "ICMP_SGT">;
 680 def SETGE : CondCode<"", "ICMP_SGE">;
 681 def SETLT : CondCode<"", "ICMP_SLT">;
 682 def SETLE : CondCode<"", "ICMP_SLE">;
 683 def SETNE : CondCode<"", "ICMP_NE">;
 684
 685 //===----------------------------------------------------------------------===//
 686 // Selection DAG Node Transformation Functions.
 687 //
 688 // This mechanism allows targets to manipulate nodes in the output DAG once a
 689 // match has been formed.  This is typically used to manipulate immediate
 690 // values.
 691 //
 692 class SDNodeXForm<SDNode opc, code xformFunction> {
 693   SDNode Opcode = opc;
 694   code XFormFunction = xformFunction;
 695 }
 696
 697 def NOOP_SDNodeXForm : SDNodeXForm<imm, [{}]>;
 698
 699 //===----------------------------------------------------------------------===//
 700 // PatPred Subclasses.
 701 //
 702 // These allow specifying different sorts of predicates that control whether a
 703 // node is matched.
 704 //
 705 class PatPred;
 706
 707 class CodePatPred<code predicate> : PatPred {
 708   code PredicateCode = predicate;
 709 }
 710
 711
 712 //===----------------------------------------------------------------------===//
 713 // Selection DAG Pattern Fragments.
 714 //
 715 // Pattern fragments are reusable chunks of dags that match specific things.
 716 // They can take arguments and have C++ predicates that control whether they
 717 // match.  They are intended to make the patterns for common instructions more
 718 // compact and readable.
 719 //
 720
 721 /// PatFrags - Represents a set of pattern fragments.  Each single fragment
 722 /// can match something on the DAG, from a single node to multiple nested other
 723 /// fragments.   The whole set of fragments matches if any of the single
 724 /// fragemnts match.  This allows e.g. matching and "add with overflow" and
 725 /// a regular "add" with the same fragment set.
 726 ///
 727 class PatFrags<dag ops, list<dag> frags, code pred = [{}],
 728                SDNodeXForm xform = NOOP_SDNodeXForm> : SDPatternOperator {
 729   dag Operands = ops;
 730   list<dag> Fragments = frags;
 731   code PredicateCode = pred;
 732   code GISelPredicateCode = [{}];
 733   code ImmediateCode = [{}];
 734   SDNodeXForm OperandTransform = xform;
 735
 736   // When this is set, the PredicateCode may refer to a constant Operands
 737   // vector which contains the captured nodes of the DAG, in the order listed
 738   // by the Operands field above.
 739   //
 740   // This is useful when Fragments involves associative / commutative
 741   // operators: a single piece of code can easily refer to all operands even
 742   // when re-associated / commuted variants of the fragment are matched.
 743   bit PredicateCodeUsesOperands = 0;
 744
 745   // Define a few pre-packaged predicates. This helps GlobalISel import
 746   // existing rules from SelectionDAG for many common cases.
 747   // They will be tested prior to the code in pred and must not be used in
 748   // ImmLeaf and its subclasses.
 749
 750   // Is the desired pre-packaged predicate for a load?
 751   bit IsLoad = ?;
 752   // Is the desired pre-packaged predicate for a store?
 753   bit IsStore = ?;
 754   // Is the desired pre-packaged predicate for an atomic?
 755   bit IsAtomic = ?;
 756
 757   // cast<LoadSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
 758   // cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
 759   bit IsUnindexed = ?;
 760
 761   // cast<LoadSDNode>(N)->getExtensionType() != ISD::NON_EXTLOAD
 762   bit IsNonExtLoad = ?;
 763   // cast<LoadSDNode>(N)->getExtensionType() == ISD::EXTLOAD;
 764   bit IsAnyExtLoad = ?;
 765   // cast<LoadSDNode>(N)->getExtensionType() == ISD::SEXTLOAD;
 766   bit IsSignExtLoad = ?;
 767   // cast<LoadSDNode>(N)->getExtensionType() == ISD::ZEXTLOAD;
 768   bit IsZeroExtLoad = ?;
 769   // !cast<StoreSDNode>(N)->isTruncatingStore();
 770   // cast<StoreSDNode>(N)->isTruncatingStore();
 771   bit IsTruncStore = ?;
 772
 773   // cast<MemSDNode>(N)->getAddressSpace() ==
 774   // If this empty, accept any address space.
 775   list<int> AddressSpaces = ?;
 776
 777   // cast<MemSDNode>(N)->getAlignment() >=
 778   // If this is empty, accept any alignment.
 779   int MinAlignment = ?;
 780
 781   // cast<AtomicSDNode>(N)->getOrdering() == AtomicOrdering::Monotonic
 782   bit IsAtomicOrderingMonotonic = ?;
 783   // cast<AtomicSDNode>(N)->getOrdering() == AtomicOrdering::Acquire
 784   bit IsAtomicOrderingAcquire = ?;
 785   // cast<AtomicSDNode>(N)->getOrdering() == AtomicOrdering::Release
 786   bit IsAtomicOrderingRelease = ?;
 787   // cast<AtomicSDNode>(N)->getOrdering() == AtomicOrdering::AcquireRelease
 788   bit IsAtomicOrderingAcquireRelease = ?;
 789   // cast<AtomicSDNode>(N)->getOrdering() == AtomicOrdering::SequentiallyConsistent
 790   bit IsAtomicOrderingSequentiallyConsistent = ?;
 791
 792   // isAcquireOrStronger(cast<AtomicSDNode>(N)->getOrdering())
 793   // !isAcquireOrStronger(cast<AtomicSDNode>(N)->getOrdering())
 794   bit IsAtomicOrderingAcquireOrStronger = ?;
 795
 796   // isReleaseOrStronger(cast<AtomicSDNode>(N)->getOrdering())
 797   // !isReleaseOrStronger(cast<AtomicSDNode>(N)->getOrdering())
 798   bit IsAtomicOrderingReleaseOrStronger = ?;
 799
 800   // cast<LoadSDNode>(N)->getMemoryVT() == MVT::<VT>;
 801   // cast<StoreSDNode>(N)->getMemoryVT() == MVT::<VT>;
 802   ValueType MemoryVT = ?;
 803   // cast<LoadSDNode>(N)->getMemoryVT().getScalarType() == MVT::<VT>;
 804   // cast<StoreSDNode>(N)->getMemoryVT().getScalarType() == MVT::<VT>;
 805   ValueType ScalarMemoryVT = ?;
 806 }
 807
 808 // PatFrag - A version of PatFrags matching only a single fragment.
 809 class PatFrag<dag ops, dag frag, code pred = [{}],
 810               SDNodeXForm xform = NOOP_SDNodeXForm>
 811   : PatFrags<ops, [frag], pred, xform>;
 812
 813 // OutPatFrag is a pattern fragment that is used as part of an output pattern
 814 // (not an input pattern). These do not have predicates or transforms, but are
 815 // used to avoid repeated subexpressions in output patterns.
 816 class OutPatFrag<dag ops, dag frag>
 817  : PatFrag<ops, frag, [{}], NOOP_SDNodeXForm>;
 818
 819 // PatLeaf's are pattern fragments that have no operands.  This is just a helper
 820 // to define immediates and other common things concisely.
 821 class PatLeaf<dag frag, code pred = [{}], SDNodeXForm xform = NOOP_SDNodeXForm>
 822  : PatFrag<(ops), frag, pred, xform>;
 823
 824
 825 // ImmLeaf is a pattern fragment with a constraint on the immediate.  The
 826 // constraint is a function that is run on the immediate (always with the value
 827 // sign extended out to an int64_t) as Imm.  For example:
 828 //
 829 //  def immSExt8 : ImmLeaf<i16, [{ return (char)Imm == Imm; }]>;
 830 //
 831 // this is a more convenient form to match 'imm' nodes in than PatLeaf and also
 832 // is preferred over using PatLeaf because it allows the code generator to
 833 // reason more about the constraint.
 834 //
 835 // If FastIsel should ignore all instructions that have an operand of this type,
 836 // the FastIselShouldIgnore flag can be set.  This is an optimization to reduce
 837 // the code size of the generated fast instruction selector.
 838 class ImmLeaf<ValueType vt, code pred, SDNodeXForm xform = NOOP_SDNodeXForm,
 839               SDNode ImmNode = imm>
 840   : PatFrag<(ops), (vt ImmNode), [{}], xform> {
 841   let ImmediateCode = pred;
 842   bit FastIselShouldIgnore = 0;
 843
 844   // Is the data type of the immediate an APInt?
 845   bit IsAPInt = 0;
 846
 847   // Is the data type of the immediate an APFloat?
 848   bit IsAPFloat = 0;
 849 }
 850
 851 // An ImmLeaf except that Imm is an APInt. This is useful when you need to
 852 // zero-extend the immediate instead of sign-extend it.
 853 //
 854 // Note that FastISel does not currently understand IntImmLeaf and will not
 855 // generate code for rules that make use of it. As such, it does not make sense
 856 // to replace ImmLeaf with IntImmLeaf. However, replacing PatLeaf with an
 857 // IntImmLeaf will allow GlobalISel to import the rule.
 858 class IntImmLeaf<ValueType vt, code pred, SDNodeXForm xform = NOOP_SDNodeXForm>
 859     : ImmLeaf<vt, pred, xform> {
 860   let IsAPInt = 1;
 861   let FastIselShouldIgnore = 1;
 862 }
 863
 864 // An ImmLeaf except that Imm is an APFloat.
 865 //
 866 // Note that FastISel does not currently understand FPImmLeaf and will not
 867 // generate code for rules that make use of it.
 868 class FPImmLeaf<ValueType vt, code pred, SDNodeXForm xform = NOOP_SDNodeXForm>
 869   : ImmLeaf<vt, pred, xform, fpimm> {
 870   let IsAPFloat = 1;
 871   let FastIselShouldIgnore = 1;
 872 }
 873
 874 // Leaf fragments.
 875
 876 def vtInt      : PatLeaf<(vt),  [{ return N->getVT().isInteger(); }]>;
 877 def vtFP       : PatLeaf<(vt),  [{ return N->getVT().isFloatingPoint(); }]>;
 878
 879 // Use ISD::isBuildVectorAllOnes or ISD::isBuildVectorAllZeros to look for
 880 // the corresponding build_vector. Will look through bitcasts except when used
 881 // as a pattern root.
 882 def immAllOnesV; // ISD::isBuildVectorAllOnes
 883 def immAllZerosV; // ISD::isBuildVectorAllZeros
 884
 885 // Other helper fragments.
 886 def not  : PatFrag<(ops node:$in), (xor node:$in, -1)>;
 887 def vnot : PatFrag<(ops node:$in), (xor node:$in, immAllOnesV)>;
 888 def ineg : PatFrag<(ops node:$in), (sub 0, node:$in)>;
 889
 890 // null_frag - The null pattern operator is used in multiclass instantiations
 891 // which accept an SDPatternOperator for use in matching patterns for internal
 892 // definitions. When expanding a pattern, if the null fragment is referenced
 893 // in the expansion, the pattern is discarded and it is as-if '[]' had been
 894 // specified. This allows multiclasses to have the isel patterns be optional.
 895 def null_frag : SDPatternOperator;
 896
 897 // load fragments.
 898 def unindexedload : PatFrag<(ops node:$ptr), (ld node:$ptr)> {
 899   let IsLoad = 1;
 900   let IsUnindexed = 1;
 901 }
 902 def load : PatFrag<(ops node:$ptr), (unindexedload node:$ptr)> {
 903   let IsLoad = 1;
 904   let IsNonExtLoad = 1;
 905 }
 906
 907 // extending load fragments.
 908 def extload   : PatFrag<(ops node:$ptr), (unindexedload node:$ptr)> {
 909   let IsLoad = 1;
 910   let IsAnyExtLoad = 1;
 911 }
 912 def sextload  : PatFrag<(ops node:$ptr), (unindexedload node:$ptr)> {
 913   let IsLoad = 1;
 914   let IsSignExtLoad = 1;
 915 }
 916 def zextload  : PatFrag<(ops node:$ptr), (unindexedload node:$ptr)> {
 917   let IsLoad = 1;
 918   let IsZeroExtLoad = 1;
 919 }
 920
 921 def extloadi1  : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
 922   let IsLoad = 1;
 923   let MemoryVT = i1;
 924 }
 925 def extloadi8  : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
 926   let IsLoad = 1;
 927   let MemoryVT = i8;
 928 }
 929 def extloadi16 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
 930   let IsLoad = 1;
 931   let MemoryVT = i16;
 932 }
 933 def extloadi32 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
 934   let IsLoad = 1;
 935   let MemoryVT = i32;
 936 }
 937 def extloadf32 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
 938   let IsLoad = 1;
 939   let MemoryVT = f32;
 940 }
 941 def extloadf64 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
 942   let IsLoad = 1;
 943   let MemoryVT = f64;
 944 }
 945
 946 def sextloadi1  : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
 947   let IsLoad = 1;
 948   let MemoryVT = i1;
 949 }
 950 def sextloadi8  : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
 951   let IsLoad = 1;
 952   let MemoryVT = i8;
 953 }
 954 def sextloadi16 : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
 955   let IsLoad = 1;
 956   let MemoryVT = i16;
 957 }
 958 def sextloadi32 : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
 959   let IsLoad = 1;
 960   let MemoryVT = i32;
 961 }
 962
 963 def zextloadi1  : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
 964   let IsLoad = 1;
 965   let MemoryVT = i1;
 966 }
 967 def zextloadi8  : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
 968   let IsLoad = 1;
 969   let MemoryVT = i8;
 970 }
 971 def zextloadi16 : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
 972   let IsLoad = 1;
 973   let MemoryVT = i16;
 974 }
 975 def zextloadi32 : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
 976   let IsLoad = 1;
 977   let MemoryVT = i32;
 978 }
 979
 980 def extloadvi1  : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
 981   let IsLoad = 1;
 982   let ScalarMemoryVT = i1;
 983 }
 984 def extloadvi8  : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
 985   let IsLoad = 1;
 986   let ScalarMemoryVT = i8;
 987 }
 988 def extloadvi16 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
 989   let IsLoad = 1;
 990   let ScalarMemoryVT = i16;
 991 }
 992 def extloadvi32 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
 993   let IsLoad = 1;
 994   let ScalarMemoryVT = i32;
 995 }
 996 def extloadvf32 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
 997   let IsLoad = 1;
 998   let ScalarMemoryVT = f32;
 999 }
1000 def extloadvf64 : PatFrag<(ops node:$ptr), (extload node:$ptr)> {
1001   let IsLoad = 1;
1002   let ScalarMemoryVT = f64;
1003 }
1004
1005 def sextloadvi1  : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
1006   let IsLoad = 1;
1007   let ScalarMemoryVT = i1;
1008 }
1009 def sextloadvi8  : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
1010   let IsLoad = 1;
1011   let ScalarMemoryVT = i8;
1012 }
1013 def sextloadvi16 : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
1014   let IsLoad = 1;
1015   let ScalarMemoryVT = i16;
1016 }
1017 def sextloadvi32 : PatFrag<(ops node:$ptr), (sextload node:$ptr)> {
1018   let IsLoad = 1;
1019   let ScalarMemoryVT = i32;
1020 }
1021
1022 def zextloadvi1  : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
1023   let IsLoad = 1;
1024   let ScalarMemoryVT = i1;
1025 }
1026 def zextloadvi8  : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
1027   let IsLoad = 1;
1028   let ScalarMemoryVT = i8;
1029 }
1030 def zextloadvi16 : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
1031   let IsLoad = 1;
1032   let ScalarMemoryVT = i16;
1033 }
1034 def zextloadvi32 : PatFrag<(ops node:$ptr), (zextload node:$ptr)> {
1035   let IsLoad = 1;
1036   let ScalarMemoryVT = i32;
1037 }
1038
1039 // store fragments.
1040 def unindexedstore : PatFrag<(ops node:$val, node:$ptr),
1041                              (st node:$val, node:$ptr)> {
1042   let IsStore = 1;
1043   let IsUnindexed = 1;
1044 }
1045 def store : PatFrag<(ops node:$val, node:$ptr),
1046                     (unindexedstore node:$val, node:$ptr)> {
1047   let IsStore = 1;
1048   let IsTruncStore = 0;
1049 }
1050
1051 // truncstore fragments.
1052 def truncstore : PatFrag<(ops node:$val, node:$ptr),
1053                          (unindexedstore node:$val, node:$ptr)> {
1054   let IsStore = 1;
1055   let IsTruncStore = 1;
1056 }
1057 def truncstorei8 : PatFrag<(ops node:$val, node:$ptr),
1058                            (truncstore node:$val, node:$ptr)> {
1059   let IsStore = 1;
1060   let MemoryVT = i8;
1061 }
1062 def truncstorei16 : PatFrag<(ops node:$val, node:$ptr),
1063                             (truncstore node:$val, node:$ptr)> {
1064   let IsStore = 1;
1065   let MemoryVT = i16;
1066 }
1067 def truncstorei32 : PatFrag<(ops node:$val, node:$ptr),
1068                             (truncstore node:$val, node:$ptr)> {
1069   let IsStore = 1;
1070   let MemoryVT = i32;
1071 }
1072 def truncstoref32 : PatFrag<(ops node:$val, node:$ptr),
1073                             (truncstore node:$val, node:$ptr)> {
1074   let IsStore = 1;
1075   let MemoryVT = f32;
1076 }
1077 def truncstoref64 : PatFrag<(ops node:$val, node:$ptr),
1078                             (truncstore node:$val, node:$ptr)> {
1079   let IsStore = 1;
1080   let MemoryVT = f64;
1081 }
1082
1083 def truncstorevi8 : PatFrag<(ops node:$val, node:$ptr),
1084                             (truncstore node:$val, node:$ptr)> {
1085   let IsStore = 1;
1086   let ScalarMemoryVT = i8;
1087 }
1088
1089 def truncstorevi16 : PatFrag<(ops node:$val, node:$ptr),
1090                              (truncstore node:$val, node:$ptr)> {
1091   let IsStore = 1;
1092   let ScalarMemoryVT = i16;
1093 }
1094
1095 def truncstorevi32 : PatFrag<(ops node:$val, node:$ptr),
1096                              (truncstore node:$val, node:$ptr)> {
1097   let IsStore = 1;
1098   let ScalarMemoryVT = i32;
1099 }
1100
1101 // indexed store fragments.
1102 def istore : PatFrag<(ops node:$val, node:$base, node:$offset),
1103                      (ist node:$val, node:$base, node:$offset)> {
1104   let IsStore = 1;
1105   let IsTruncStore = 0;
1106 }
1107
1108 def pre_store : PatFrag<(ops node:$val, node:$base, node:$offset),
1109                         (istore node:$val, node:$base, node:$offset), [{
1110   ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
1111   return AM == ISD::PRE_INC || AM == ISD::PRE_DEC;
1112 }]>;
1113
1114 def itruncstore : PatFrag<(ops node:$val, node:$base, node:$offset),
1115                           (ist node:$val, node:$base, node:$offset)> {
1116   let IsStore = 1;
1117   let IsTruncStore = 1;
1118 }
1119 def pre_truncst : PatFrag<(ops node:$val, node:$base, node:$offset),
1120                           (itruncstore node:$val, node:$base, node:$offset), [{
1121   ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
1122   return AM == ISD::PRE_INC || AM == ISD::PRE_DEC;
1123 }]>;
1124 def pre_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset),
1125                             (pre_truncst node:$val, node:$base, node:$offset)> {
1126   let IsStore = 1;
1127   let MemoryVT = i1;
1128 }
1129 def pre_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset),
1130                             (pre_truncst node:$val, node:$base, node:$offset)> {
1131   let IsStore = 1;
1132   let MemoryVT = i8;
1133 }
1134 def pre_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset),
1135                              (pre_truncst node:$val, node:$base, node:$offset)> {
1136   let IsStore = 1;
1137   let MemoryVT = i16;
1138 }
1139 def pre_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset),
1140                              (pre_truncst node:$val, node:$base, node:$offset)> {
1141   let IsStore = 1;
1142   let MemoryVT = i32;
1143 }
1144 def pre_truncstf32 : PatFrag<(ops node:$val, node:$base, node:$offset),
1145                              (pre_truncst node:$val, node:$base, node:$offset)> {
1146   let IsStore = 1;
1147   let MemoryVT = f32;
1148 }
1149 def pre_truncstvi8 : PatFrag<(ops node:$val, node:$base, node:$offset),
1150                              (pre_truncst node:$val, node:$base, node:$offset)> {
1151   let IsStore = 1;
1152   let ScalarMemoryVT = i8;
1153 }
1154 def pre_truncstvi16 : PatFrag<(ops node:$val, node:$base, node:$offset),
1155                               (pre_truncst node:$val, node:$base, node:$offset)> {
1156   let IsStore = 1;
1157   let ScalarMemoryVT = i16;
1158 }
1159
1160 def post_store : PatFrag<(ops node:$val, node:$ptr, node:$offset),
1161                          (istore node:$val, node:$ptr, node:$offset), [{
1162   ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
1163   return AM == ISD::POST_INC || AM == ISD::POST_DEC;
1164 }]>;
1165
1166 def post_truncst : PatFrag<(ops node:$val, node:$base, node:$offset),
1167                            (itruncstore node:$val, node:$base, node:$offset), [{
1168   ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
1169   return AM == ISD::POST_INC || AM == ISD::POST_DEC;
1170 }]>;
1171 def post_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset),
1172                              (post_truncst node:$val, node:$base, node:$offset)> {
1173   let IsStore = 1;
1174   let MemoryVT = i1;
1175 }
1176 def post_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset),
1177                              (post_truncst node:$val, node:$base, node:$offset)> {
1178   let IsStore = 1;
1179   let MemoryVT = i8;
1180 }
1181 def post_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset),
1182                               (post_truncst node:$val, node:$base, node:$offset)> {
1183   let IsStore = 1;
1184   let MemoryVT = i16;
1185 }
1186 def post_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset),
1187                               (post_truncst node:$val, node:$base, node:$offset)> {
1188   let IsStore = 1;
1189   let MemoryVT = i32;
1190 }
1191 def post_truncstf32 : PatFrag<(ops node:$val, node:$base, node:$offset),
1192                               (post_truncst node:$val, node:$base, node:$offset)> {
1193   let IsStore = 1;
1194   let MemoryVT = f32;
1195 }
1196 def post_truncstvi8 : PatFrag<(ops node:$val, node:$base, node:$offset),
1197                               (post_truncst node:$val, node:$base, node:$offset)> {
1198   let IsStore = 1;
1199   let ScalarMemoryVT = i8;
1200 }
1201 def post_truncstvi16 : PatFrag<(ops node:$val, node:$base, node:$offset),
1202                                (post_truncst node:$val, node:$base, node:$offset)> {
1203   let IsStore = 1;
1204   let ScalarMemoryVT = i16;
1205 }
1206
1207 // TODO: Split these into volatile and unordered flavors to enable
1208 // selectively legal optimizations for each.  (See D66309)
1209 def simple_load : PatFrag<(ops node:$ptr),
1210                           (load node:$ptr), [{
1211   return cast<LoadSDNode>(N)->isSimple();
1212 }]>;
1213 def simple_store : PatFrag<(ops node:$val, node:$ptr),
1214                            (store node:$val, node:$ptr), [{
1215   return cast<StoreSDNode>(N)->isSimple();
1216 }]>;
1217
1218 // nontemporal store fragments.
1219 def nontemporalstore : PatFrag<(ops node:$val, node:$ptr),
1220                                (store node:$val, node:$ptr), [{
1221   return cast<StoreSDNode>(N)->isNonTemporal();
1222 }]>;
1223
1224 def alignednontemporalstore : PatFrag<(ops node:$val, node:$ptr),
1225                                       (nontemporalstore node:$val, node:$ptr), [{
1226   StoreSDNode *St = cast<StoreSDNode>(N);
1227   return St->getAlignment() >= St->getMemoryVT().getStoreSize();
1228 }]>;
1229
1230 def unalignednontemporalstore : PatFrag<(ops node:$val, node:$ptr),
1231                                         (nontemporalstore node:$val, node:$ptr), [{
1232   StoreSDNode *St = cast<StoreSDNode>(N);
1233   return St->getAlignment() < St->getMemoryVT().getStoreSize();
1234 }]>;
1235
1236 // nontemporal load fragments.
1237 def nontemporalload : PatFrag<(ops node:$ptr),
1238                                (load node:$ptr), [{
1239   return cast<LoadSDNode>(N)->isNonTemporal();
1240 }]>;
1241
1242 def alignednontemporalload : PatFrag<(ops node:$ptr),
1243                                       (nontemporalload node:$ptr), [{
1244   LoadSDNode *Ld = cast<LoadSDNode>(N);
1245   return Ld->getAlignment() >= Ld->getMemoryVT().getStoreSize();
1246 }]>;
1247
1248 // setcc convenience fragments.
1249 def setoeq : PatFrag<(ops node:$lhs, node:$rhs),
1250                      (setcc node:$lhs, node:$rhs, SETOEQ)>;
1251 def setogt : PatFrag<(ops node:$lhs, node:$rhs),
1252                      (setcc node:$lhs, node:$rhs, SETOGT)>;
1253 def setoge : PatFrag<(ops node:$lhs, node:$rhs),
1254                      (setcc node:$lhs, node:$rhs, SETOGE)>;
1255 def setolt : PatFrag<(ops node:$lhs, node:$rhs),
1256                      (setcc node:$lhs, node:$rhs, SETOLT)>;
1257 def setole : PatFrag<(ops node:$lhs, node:$rhs),
1258                      (setcc node:$lhs, node:$rhs, SETOLE)>;
1259 def setone : PatFrag<(ops node:$lhs, node:$rhs),
1260                      (setcc node:$lhs, node:$rhs, SETONE)>;
1261 def seto   : PatFrag<(ops node:$lhs, node:$rhs),
1262                      (setcc node:$lhs, node:$rhs, SETO)>;
1263 def setuo  : PatFrag<(ops node:$lhs, node:$rhs),
1264                      (setcc node:$lhs, node:$rhs, SETUO)>;
1265 def setueq : PatFrag<(ops node:$lhs, node:$rhs),
1266                      (setcc node:$lhs, node:$rhs, SETUEQ)>;
1267 def setugt : PatFrag<(ops node:$lhs, node:$rhs),
1268                      (setcc node:$lhs, node:$rhs, SETUGT)>;
1269 def setuge : PatFrag<(ops node:$lhs, node:$rhs),
1270                      (setcc node:$lhs, node:$rhs, SETUGE)>;
1271 def setult : PatFrag<(ops node:$lhs, node:$rhs),
1272                      (setcc node:$lhs, node:$rhs, SETULT)>;
1273 def setule : PatFrag<(ops node:$lhs, node:$rhs),
1274                      (setcc node:$lhs, node:$rhs, SETULE)>;
1275 def setune : PatFrag<(ops node:$lhs, node:$rhs),
1276                      (setcc node:$lhs, node:$rhs, SETUNE)>;
1277 def seteq  : PatFrag<(ops node:$lhs, node:$rhs),
1278                      (setcc node:$lhs, node:$rhs, SETEQ)>;
1279 def setgt  : PatFrag<(ops node:$lhs, node:$rhs),
1280                      (setcc node:$lhs, node:$rhs, SETGT)>;
1281 def setge  : PatFrag<(ops node:$lhs, node:$rhs),
1282                      (setcc node:$lhs, node:$rhs, SETGE)>;
1283 def setlt  : PatFrag<(ops node:$lhs, node:$rhs),
1284                      (setcc node:$lhs, node:$rhs, SETLT)>;
1285 def setle  : PatFrag<(ops node:$lhs, node:$rhs),
1286                      (setcc node:$lhs, node:$rhs, SETLE)>;
1287 def setne  : PatFrag<(ops node:$lhs, node:$rhs),
1288                      (setcc node:$lhs, node:$rhs, SETNE)>;
1289
1290 // We don't have strict FP extended loads as single DAG nodes, but we can
1291 // still provide convenience fragments to match those operations.
1292 def strict_extloadf32 : PatFrag<(ops node:$ptr),
1293                                 (strict_fpextend (f32 (load node:$ptr)))>;
1294 def strict_extloadf64 : PatFrag<(ops node:$ptr),
1295                                 (strict_fpextend (f64 (load node:$ptr)))>;
1296
1297 // Convenience fragments to match both strict and non-strict fp operations
1298 def any_fadd       : PatFrags<(ops node:$lhs, node:$rhs),
1299                               [(strict_fadd node:$lhs, node:$rhs),
1300                                (fadd node:$lhs, node:$rhs)]>;
1301 def any_fsub       : PatFrags<(ops node:$lhs, node:$rhs),
1302                               [(strict_fsub node:$lhs, node:$rhs),
1303                                (fsub node:$lhs, node:$rhs)]>;
1304 def any_fmul       : PatFrags<(ops node:$lhs, node:$rhs),
1305                               [(strict_fmul node:$lhs, node:$rhs),
1306                                (fmul node:$lhs, node:$rhs)]>;
1307 def any_fdiv       : PatFrags<(ops node:$lhs, node:$rhs),
1308                               [(strict_fdiv node:$lhs, node:$rhs),
1309                                (fdiv node:$lhs, node:$rhs)]>;
1310 def any_frem       : PatFrags<(ops node:$lhs, node:$rhs),
1311                               [(strict_frem node:$lhs, node:$rhs),
1312                                (frem node:$lhs, node:$rhs)]>;
1313 def any_fma        : PatFrags<(ops node:$src1, node:$src2, node:$src3),
1314                               [(strict_fma node:$src1, node:$src2, node:$src3),
1315                                (fma node:$src1, node:$src2, node:$src3)]>;
1316 def any_fsqrt      : PatFrags<(ops node:$src),
1317                               [(strict_fsqrt node:$src),
1318                                (fsqrt node:$src)]>;
1319 def any_fsin       : PatFrags<(ops node:$src),
1320                               [(strict_fsin node:$src),
1321                                (fsin node:$src)]>;
1322 def any_fcos       : PatFrags<(ops node:$src),
1323                               [(strict_fcos node:$src),
1324                                (fcos node:$src)]>;
1325 def any_fexp2      : PatFrags<(ops node:$src),
1326                               [(strict_fexp2 node:$src),
1327                                (fexp2 node:$src)]>;
1328 def any_fpow       : PatFrags<(ops node:$lhs, node:$rhs),
1329                               [(strict_fpow node:$lhs, node:$rhs),
1330                                (fpow node:$lhs, node:$rhs)]>;
1331 def any_flog2      : PatFrags<(ops node:$src),
1332                               [(strict_flog2 node:$src),
1333                                (flog2 node:$src)]>;
1334 def any_frint      : PatFrags<(ops node:$src),
1335                               [(strict_frint node:$src),
1336                                (frint node:$src)]>;
1337 def any_fnearbyint : PatFrags<(ops node:$src),
1338                               [(strict_fnearbyint node:$src),
1339                                (fnearbyint node:$src)]>;
1340 def any_fceil      : PatFrags<(ops node:$src),
1341                               [(strict_fceil node:$src),
1342                                (fceil node:$src)]>;
1343 def any_ffloor     : PatFrags<(ops node:$src),
1344                               [(strict_ffloor node:$src),
1345                                (ffloor node:$src)]>;
1346 def any_fround     : PatFrags<(ops node:$src),
1347                               [(strict_fround node:$src),
1348                                (fround node:$src)]>;
1349 def any_ftrunc     : PatFrags<(ops node:$src),
1350                               [(strict_ftrunc node:$src),
1351                                (ftrunc node:$src)]>;
1352 def any_fmaxnum    : PatFrags<(ops node:$lhs, node:$rhs),
1353                               [(strict_fmaxnum node:$lhs, node:$rhs),
1354                                (fmaxnum node:$lhs, node:$rhs)]>;
1355 def any_fminnum    : PatFrags<(ops node:$lhs, node:$rhs),
1356                               [(strict_fminnum node:$lhs, node:$rhs),
1357                                (fminnum node:$lhs, node:$rhs)]>;
1358 def any_fpround    : PatFrags<(ops node:$src),
1359                               [(strict_fpround node:$src),
1360                                (fpround node:$src)]>;
1361 def any_fpextend   : PatFrags<(ops node:$src),
1362                               [(strict_fpextend node:$src),
1363                                (fpextend node:$src)]>;
1364 def any_extloadf32 : PatFrags<(ops node:$ptr),
1365                               [(strict_extloadf32 node:$ptr),
1366                                (extloadf32 node:$ptr)]>;
1367 def any_extloadf64 : PatFrags<(ops node:$ptr),
1368                               [(strict_extloadf64 node:$ptr),
1369                                (extloadf64 node:$ptr)]>;
1370 def any_fp_to_sint : PatFrags<(ops node:$src),
1371                               [(strict_fp_to_sint node:$src),
1372                                (fp_to_sint node:$src)]>;
1373 def any_fp_to_uint : PatFrags<(ops node:$src),
1374                               [(strict_fp_to_uint node:$src),
1375                                (fp_to_uint node:$src)]>;
1376
1377 multiclass binary_atomic_op_ord<SDNode atomic_op> {
1378   def #NAME#_monotonic : PatFrag<(ops node:$ptr, node:$val),
1379       (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$val)> {
1380     let IsAtomic = 1;
1381     let IsAtomicOrderingMonotonic = 1;
1382   }
1383   def #NAME#_acquire : PatFrag<(ops node:$ptr, node:$val),
1384       (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$val)> {
1385     let IsAtomic = 1;
1386     let IsAtomicOrderingAcquire = 1;
1387   }
1388   def #NAME#_release : PatFrag<(ops node:$ptr, node:$val),
1389       (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$val)> {
1390     let IsAtomic = 1;
1391     let IsAtomicOrderingRelease = 1;
1392   }
1393   def #NAME#_acq_rel : PatFrag<(ops node:$ptr, node:$val),
1394       (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$val)> {
1395     let IsAtomic = 1;
1396     let IsAtomicOrderingAcquireRelease = 1;
1397   }
1398   def #NAME#_seq_cst : PatFrag<(ops node:$ptr, node:$val),
1399       (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$val)> {
1400     let IsAtomic = 1;
1401     let IsAtomicOrderingSequentiallyConsistent = 1;
1402   }
1403 }
1404
1405 multiclass ternary_atomic_op_ord<SDNode atomic_op> {
1406   def #NAME#_monotonic : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
1407       (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$cmp, node:$val)> {
1408     let IsAtomic = 1;
1409     let IsAtomicOrderingMonotonic = 1;
1410   }
1411   def #NAME#_acquire : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
1412       (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$cmp, node:$val)> {
1413     let IsAtomic = 1;
1414     let IsAtomicOrderingAcquire = 1;
1415   }
1416   def #NAME#_release : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
1417       (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$cmp, node:$val)> {
1418     let IsAtomic = 1;
1419     let IsAtomicOrderingRelease = 1;
1420   }
1421   def #NAME#_acq_rel : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
1422       (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$cmp, node:$val)> {
1423     let IsAtomic = 1;
1424     let IsAtomicOrderingAcquireRelease = 1;
1425   }
1426   def #NAME#_seq_cst : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
1427       (!cast<SDPatternOperator>(#NAME) node:$ptr, node:$cmp, node:$val)> {
1428     let IsAtomic = 1;
1429     let IsAtomicOrderingSequentiallyConsistent = 1;
1430   }
1431 }
1432
1433 multiclass binary_atomic_op<SDNode atomic_op, bit IsInt = 1> {
1434   def _8 : PatFrag<(ops node:$ptr, node:$val),
1435                    (atomic_op  node:$ptr, node:$val)> {
1436     let IsAtomic = 1;
1437     let MemoryVT = !if(IsInt, i8, ?);
1438   }
1439   def _16 : PatFrag<(ops node:$ptr, node:$val),
1440                     (atomic_op node:$ptr, node:$val)> {
1441     let IsAtomic = 1;
1442     let MemoryVT = !if(IsInt, i16, f16);
1443   }
1444   def _32 : PatFrag<(ops node:$ptr, node:$val),
1445                     (atomic_op node:$ptr, node:$val)> {
1446     let IsAtomic = 1;
1447     let MemoryVT = !if(IsInt, i32, f32);
1448   }
1449   def _64 : PatFrag<(ops node:$ptr, node:$val),
1450                     (atomic_op node:$ptr, node:$val)> {
1451     let IsAtomic = 1;
1452     let MemoryVT = !if(IsInt, i64, f64);
1453   }
1454
1455   defm NAME#_8  : binary_atomic_op_ord<atomic_op>;
1456   defm NAME#_16 : binary_atomic_op_ord<atomic_op>;
1457   defm NAME#_32 : binary_atomic_op_ord<atomic_op>;
1458   defm NAME#_64 : binary_atomic_op_ord<atomic_op>;
1459 }
1460
1461 multiclass ternary_atomic_op<SDNode atomic_op> {
1462   def _8 : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
1463                    (atomic_op  node:$ptr, node:$cmp, node:$val)> {
1464     let IsAtomic = 1;
1465     let MemoryVT = i8;
1466   }
1467   def _16 : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
1468                     (atomic_op node:$ptr, node:$cmp, node:$val)> {
1469     let IsAtomic = 1;
1470     let MemoryVT = i16;
1471   }
1472   def _32 : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
1473                     (atomic_op node:$ptr, node:$cmp, node:$val)> {
1474     let IsAtomic = 1;
1475     let MemoryVT = i32;
1476   }
1477   def _64 : PatFrag<(ops node:$ptr, node:$cmp, node:$val),
1478                     (atomic_op node:$ptr, node:$cmp, node:$val)> {
1479     let IsAtomic = 1;
1480     let MemoryVT = i64;
1481   }
1482
1483   defm NAME#_8  : ternary_atomic_op_ord<atomic_op>;
1484   defm NAME#_16 : ternary_atomic_op_ord<atomic_op>;
1485   defm NAME#_32 : ternary_atomic_op_ord<atomic_op>;
1486   defm NAME#_64 : ternary_atomic_op_ord<atomic_op>;
1487 }
1488
1489 defm atomic_load_add  : binary_atomic_op<atomic_load_add>;
1490 defm atomic_swap      : binary_atomic_op<atomic_swap>;
1491 defm atomic_load_sub  : binary_atomic_op<atomic_load_sub>;
1492 defm atomic_load_and  : binary_atomic_op<atomic_load_and>;
1493 defm atomic_load_clr  : binary_atomic_op<atomic_load_clr>;
1494 defm atomic_load_or   : binary_atomic_op<atomic_load_or>;
1495 defm atomic_load_xor  : binary_atomic_op<atomic_load_xor>;
1496 defm atomic_load_nand : binary_atomic_op<atomic_load_nand>;
1497 defm atomic_load_min  : binary_atomic_op<atomic_load_min>;
1498 defm atomic_load_max  : binary_atomic_op<atomic_load_max>;
1499 defm atomic_load_umin : binary_atomic_op<atomic_load_umin>;
1500 defm atomic_load_umax : binary_atomic_op<atomic_load_umax>;
1501 defm atomic_store     : binary_atomic_op<atomic_store>;
1502 defm atomic_cmp_swap  : ternary_atomic_op<atomic_cmp_swap>;
1503
1504 def atomic_load_8 :
1505   PatFrag<(ops node:$ptr),
1506           (atomic_load node:$ptr)> {
1507   let IsAtomic = 1;
1508   let MemoryVT = i8;
1509 }
1510 def atomic_load_16 :
1511   PatFrag<(ops node:$ptr),
1512           (atomic_load node:$ptr)> {
1513   let IsAtomic = 1;
1514   let MemoryVT = i16;
1515 }
1516 def atomic_load_32 :
1517   PatFrag<(ops node:$ptr),
1518           (atomic_load node:$ptr)> {
1519   let IsAtomic = 1;
1520   let MemoryVT = i32;
1521 }
1522 def atomic_load_64 :
1523   PatFrag<(ops node:$ptr),
1524           (atomic_load node:$ptr)> {
1525   let IsAtomic = 1;
1526   let MemoryVT = i64;
1527 }
1528
1529 //===----------------------------------------------------------------------===//
1530 // Selection DAG Pattern Support.
1531 //
1532 // Patterns are what are actually matched against by the target-flavored
1533 // instruction selection DAG.  Instructions defined by the target implicitly
1534 // define patterns in most cases, but patterns can also be explicitly added when
1535 // an operation is defined by a sequence of instructions (e.g. loading a large
1536 // immediate value on RISC targets that do not support immediates as large as
1537 // their GPRs).
1538 //
1539
1540 class Pattern<dag patternToMatch, list<dag> resultInstrs> {
1541   dag             PatternToMatch  = patternToMatch;
1542   list<dag>       ResultInstrs    = resultInstrs;
1543   list<Predicate> Predicates      = [];  // See class Instruction in Target.td.
1544   int             AddedComplexity = 0;   // See class Instruction in Target.td.
1545 }
1546
1547 // Pat - A simple (but common) form of a pattern, which produces a simple result
1548 // not needing a full list.
1549 class Pat<dag pattern, dag result> : Pattern<pattern, [result]>;
1550
1551 //===----------------------------------------------------------------------===//
1552 // Complex pattern definitions.
1553 //
1554
1555 // Complex patterns, e.g. X86 addressing mode, requires pattern matching code
1556 // in C++. NumOperands is the number of operands returned by the select function;
1557 // SelectFunc is the name of the function used to pattern match the max. pattern;
1558 // RootNodes are the list of possible root nodes of the sub-dags to match.
1559 // e.g. X86 addressing mode - def addr : ComplexPattern<4, "SelectAddr", [add]>;
1560 //
1561 class ComplexPattern<ValueType ty, int numops, string fn,
1562                      list<SDNode> roots = [], list<SDNodeProperty> props = [],
1563                      int complexity = -1> {
1564   ValueType Ty = ty;
1565   int NumOperands = numops;
1566   string SelectFunc = fn;
1567   list<SDNode> RootNodes = roots;
1568   list<SDNodeProperty> Properties = props;
1569   int Complexity = complexity;
1570 }