Jia Liu | e1d6196 | 2012-02-19 02:03:36 +0000 | [diff] [blame] | 1 | //===-- X86InstrFragmentsSIMD.td - x86 SIMD ISA ------------*- tablegen -*-===// |
David Greene | 509be1f | 2010-02-09 23:52:19 +0000 | [diff] [blame] | 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Jia Liu | b22310f | 2012-02-18 12:03:15 +0000 | [diff] [blame] | 7 | // |
David Greene | 509be1f | 2010-02-09 23:52:19 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file provides pattern fragments useful for SIMD instructions. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | //===----------------------------------------------------------------------===// |
Bruno Cardoso Lopes | e446aef | 2015-02-05 13:22:50 +0000 | [diff] [blame] | 15 | // MMX specific DAG Nodes. |
| 16 | //===----------------------------------------------------------------------===// |
| 17 | |
| 18 | // Low word of MMX to GPR. |
| 19 | def MMX_X86movd2w : SDNode<"X86ISD::MMX_MOVD2W", SDTypeProfile<1, 1, |
| 20 | [SDTCisVT<0, i32>, SDTCisVT<1, x86mmx>]>>; |
Bruno Cardoso Lopes | ab9ae87 | 2015-02-05 13:23:07 +0000 | [diff] [blame] | 21 | // GPR to low word of MMX. |
| 22 | def MMX_X86movw2d : SDNode<"X86ISD::MMX_MOVW2D", SDTypeProfile<1, 1, |
| 23 | [SDTCisVT<0, x86mmx>, SDTCisVT<1, i32>]>>; |
Bruno Cardoso Lopes | e446aef | 2015-02-05 13:22:50 +0000 | [diff] [blame] | 24 | |
| 25 | //===----------------------------------------------------------------------===// |
David Greene | 509be1f | 2010-02-09 23:52:19 +0000 | [diff] [blame] | 26 | // MMX Pattern Fragments |
| 27 | //===----------------------------------------------------------------------===// |
| 28 | |
Dale Johannesen | dd224d2 | 2010-09-30 23:57:10 +0000 | [diff] [blame] | 29 | def load_mmx : PatFrag<(ops node:$ptr), (x86mmx (load node:$ptr))>; |
Bruno Cardoso Lopes | 9e1c4c1 | 2015-02-23 15:23:14 +0000 | [diff] [blame] | 30 | def load_mvmmx : PatFrag<(ops node:$ptr), |
| 31 | (x86mmx (MMX_X86movw2d (load node:$ptr)))>; |
Dale Johannesen | dd224d2 | 2010-09-30 23:57:10 +0000 | [diff] [blame] | 32 | def bc_mmx : PatFrag<(ops node:$in), (x86mmx (bitconvert node:$in))>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 33 | |
| 34 | //===----------------------------------------------------------------------===// |
| 35 | // SSE specific DAG Nodes. |
| 36 | //===----------------------------------------------------------------------===// |
| 37 | |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 38 | def SDTX86VFCMP : SDTypeProfile<1, 3, [SDTCisInt<0>, SDTCisSameAs<1, 2>, |
Craig Topper | aefaab6 | 2014-01-26 04:59:39 +0000 | [diff] [blame] | 39 | SDTCisFP<1>, SDTCisVT<3, i8>, |
| 40 | SDTCisVec<1>]>; |
Asaf Badouh | 2489f35 | 2015-12-02 08:17:51 +0000 | [diff] [blame] | 41 | def SDTX86CmpTestSae : SDTypeProfile<1, 3, [SDTCisVT<0, i32>, |
| 42 | SDTCisSameAs<1, 2>, SDTCisInt<3>]>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 43 | |
| 44 | def X86fmin : SDNode<"X86ISD::FMIN", SDTFPBinOp>; |
| 45 | def X86fmax : SDNode<"X86ISD::FMAX", SDTFPBinOp>; |
Nadav Rotem | 178250a | 2012-08-19 13:06:16 +0000 | [diff] [blame] | 46 | |
| 47 | // Commutative and Associative FMIN and FMAX. |
| 48 | def X86fminc : SDNode<"X86ISD::FMINC", SDTFPBinOp, |
| 49 | [SDNPCommutative, SDNPAssociative]>; |
| 50 | def X86fmaxc : SDNode<"X86ISD::FMAXC", SDTFPBinOp, |
| 51 | [SDNPCommutative, SDNPAssociative]>; |
| 52 | |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 53 | def X86fand : SDNode<"X86ISD::FAND", SDTFPBinOp, |
| 54 | [SDNPCommutative, SDNPAssociative]>; |
| 55 | def X86for : SDNode<"X86ISD::FOR", SDTFPBinOp, |
| 56 | [SDNPCommutative, SDNPAssociative]>; |
| 57 | def X86fxor : SDNode<"X86ISD::FXOR", SDTFPBinOp, |
| 58 | [SDNPCommutative, SDNPAssociative]>; |
Benjamin Kramer | 5bc180c | 2013-08-04 12:05:16 +0000 | [diff] [blame] | 59 | def X86fandn : SDNode<"X86ISD::FANDN", SDTFPBinOp, |
| 60 | [SDNPCommutative, SDNPAssociative]>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 61 | def X86frsqrt : SDNode<"X86ISD::FRSQRT", SDTFPUnaryOp>; |
| 62 | def X86frcp : SDNode<"X86ISD::FRCP", SDTFPUnaryOp>; |
Asaf Badouh | eaf2da1 | 2015-09-21 10:23:53 +0000 | [diff] [blame] | 63 | def X86frsqrt14s: SDNode<"X86ISD::FRSQRT", SDTFPBinOp>; |
| 64 | def X86frcp14s : SDNode<"X86ISD::FRCP", SDTFPBinOp>; |
Stuart Hastings | 9f20804 | 2011-06-01 04:39:42 +0000 | [diff] [blame] | 65 | def X86fgetsign: SDNode<"X86ISD::FGETSIGNx86",SDTFPToIntOp>; |
Duncan Sands | 0e4fcb8 | 2011-09-22 20:15:48 +0000 | [diff] [blame] | 66 | def X86fhadd : SDNode<"X86ISD::FHADD", SDTFPBinOp>; |
| 67 | def X86fhsub : SDNode<"X86ISD::FHSUB", SDTFPBinOp>; |
Craig Topper | f984efb | 2011-11-19 09:02:40 +0000 | [diff] [blame] | 68 | def X86hadd : SDNode<"X86ISD::HADD", SDTIntBinOp>; |
| 69 | def X86hsub : SDNode<"X86ISD::HSUB", SDTIntBinOp>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 70 | def X86comi : SDNode<"X86ISD::COMI", SDTX86CmpTest>; |
Asaf Badouh | 2489f35 | 2015-12-02 08:17:51 +0000 | [diff] [blame] | 71 | def X86comiSae : SDNode<"X86ISD::COMI", SDTX86CmpTestSae>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 72 | def X86ucomi : SDNode<"X86ISD::UCOMI", SDTX86CmpTest>; |
Asaf Badouh | 2489f35 | 2015-12-02 08:17:51 +0000 | [diff] [blame] | 73 | def X86ucomiSae: SDNode<"X86ISD::UCOMI", SDTX86CmpTestSae>; |
Elena Demikhovsky | 47fc44e | 2013-12-16 13:52:35 +0000 | [diff] [blame] | 74 | def X86cmps : SDNode<"X86ISD::FSETCC", SDTX86Cmps>; |
| 75 | //def X86cmpsd : SDNode<"X86ISD::FSETCCsd", SDTX86Cmpsd>; |
Simon Pilgrim | cae7b94 | 2015-06-16 21:40:28 +0000 | [diff] [blame] | 76 | def X86cvtdq2pd: SDNode<"X86ISD::CVTDQ2PD", |
| 77 | SDTypeProfile<1, 1, [SDTCisVT<0, v2f64>, |
| 78 | SDTCisVT<1, v4i32>]>>; |
Elena Demikhovsky | 0f37093 | 2015-07-13 13:26:20 +0000 | [diff] [blame] | 79 | def X86cvtudq2pd: SDNode<"X86ISD::CVTUDQ2PD", |
| 80 | SDTypeProfile<1, 1, [SDTCisVT<0, v2f64>, |
| 81 | SDTCisVT<1, v4i32>]>>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 82 | def X86pshufb : SDNode<"X86ISD::PSHUFB", |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 83 | SDTypeProfile<1, 2, [SDTCVecEltisVT<0, i8>, SDTCisSameAs<0,1>, |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 84 | SDTCisSameAs<0,2>]>>; |
Chandler Carruth | 6ba9730 | 2015-05-30 03:20:59 +0000 | [diff] [blame] | 85 | def X86psadbw : SDNode<"X86ISD::PSADBW", |
Craig Topper | 4c175cd | 2015-11-26 07:02:21 +0000 | [diff] [blame] | 86 | SDTypeProfile<1, 2, [SDTCVecEltisVT<0, i64>, |
| 87 | SDTCVecEltisVT<1, i8>, |
| 88 | SDTCisSameSizeAs<0,1>, |
Cong Hou | db6220f | 2015-11-24 19:51:26 +0000 | [diff] [blame] | 89 | SDTCisSameAs<1,2>]>>; |
Igor Breger | f3ded81 | 2015-08-31 13:09:30 +0000 | [diff] [blame] | 90 | def X86dbpsadbw : SDNode<"X86ISD::DBPSADBW", |
Craig Topper | 4c175cd | 2015-11-26 07:02:21 +0000 | [diff] [blame] | 91 | SDTypeProfile<1, 3, [SDTCVecEltisVT<0, i16>, |
| 92 | SDTCVecEltisVT<1, i8>, |
| 93 | SDTCisSameSizeAs<0,1>, |
Igor Breger | f3ded81 | 2015-08-31 13:09:30 +0000 | [diff] [blame] | 94 | SDTCisSameAs<1,2>, SDTCisInt<3>]>>; |
Bruno Cardoso Lopes | 7ba479d | 2011-07-13 21:36:47 +0000 | [diff] [blame] | 95 | def X86andnp : SDNode<"X86ISD::ANDNP", |
Bruno Cardoso Lopes | 9613b64 | 2011-07-13 21:36:51 +0000 | [diff] [blame] | 96 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
Nate Begeman | 97b72c9 | 2010-12-17 22:55:37 +0000 | [diff] [blame] | 97 | SDTCisSameAs<0,2>]>>; |
Craig Topper | 81390be | 2011-11-19 07:33:10 +0000 | [diff] [blame] | 98 | def X86psign : SDNode<"X86ISD::PSIGN", |
Craig Topper | de6b73b | 2011-11-19 07:07:26 +0000 | [diff] [blame] | 99 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
Nate Begeman | 97b72c9 | 2010-12-17 22:55:37 +0000 | [diff] [blame] | 100 | SDTCisSameAs<0,2>]>>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 101 | def X86pextrb : SDNode<"X86ISD::PEXTRB", |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 102 | SDTypeProfile<1, 2, [SDTCisVT<0, i32>, SDTCisVT<1, v16i8>, |
| 103 | SDTCisPtrTy<2>]>>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 104 | def X86pextrw : SDNode<"X86ISD::PEXTRW", |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 105 | SDTypeProfile<1, 2, [SDTCisVT<0, i32>, SDTCisVT<1, v8i16>, |
| 106 | SDTCisPtrTy<2>]>>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 107 | def X86pinsrb : SDNode<"X86ISD::PINSRB", |
| 108 | SDTypeProfile<1, 3, [SDTCisVT<0, v16i8>, SDTCisSameAs<0,1>, |
| 109 | SDTCisVT<2, i32>, SDTCisPtrTy<3>]>>; |
| 110 | def X86pinsrw : SDNode<"X86ISD::PINSRW", |
| 111 | SDTypeProfile<1, 3, [SDTCisVT<0, v8i16>, SDTCisSameAs<0,1>, |
| 112 | SDTCisVT<2, i32>, SDTCisPtrTy<3>]>>; |
Filipe Cabecinhas | 2035221 | 2014-04-21 20:07:29 +0000 | [diff] [blame] | 113 | def X86insertps : SDNode<"X86ISD::INSERTPS", |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 114 | SDTypeProfile<1, 3, [SDTCisVT<0, v4f32>, SDTCisSameAs<0,1>, |
Chandler Carruth | 373b2b1 | 2014-09-06 10:00:01 +0000 | [diff] [blame] | 115 | SDTCisVT<2, v4f32>, SDTCisVT<3, i8>]>>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 116 | def X86vzmovl : SDNode<"X86ISD::VZEXT_MOVL", |
| 117 | SDTypeProfile<1, 1, [SDTCisSameAs<0,1>]>>; |
Elena Demikhovsky | 8d7e56c | 2012-04-22 09:39:03 +0000 | [diff] [blame] | 118 | |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 119 | def X86vzload : SDNode<"X86ISD::VZEXT_LOAD", SDTLoad, |
Chris Lattner | 54e5329 | 2010-09-22 00:34:38 +0000 | [diff] [blame] | 120 | [SDNPHasChain, SDNPMayLoad, SDNPMemOperand]>; |
Michael Liao | 34107b9 | 2012-08-14 21:24:47 +0000 | [diff] [blame] | 121 | |
Michael Liao | 1be96bb | 2012-10-23 17:34:00 +0000 | [diff] [blame] | 122 | def X86vzext : SDNode<"X86ISD::VZEXT", |
| 123 | SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisVec<1>, |
Craig Topper | aefaab6 | 2014-01-26 04:59:39 +0000 | [diff] [blame] | 124 | SDTCisInt<0>, SDTCisInt<1>, |
| 125 | SDTCisOpSmallerThanOp<1, 0>]>>; |
Michael Liao | 1be96bb | 2012-10-23 17:34:00 +0000 | [diff] [blame] | 126 | |
| 127 | def X86vsext : SDNode<"X86ISD::VSEXT", |
| 128 | SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisVec<1>, |
Craig Topper | aefaab6 | 2014-01-26 04:59:39 +0000 | [diff] [blame] | 129 | SDTCisInt<0>, SDTCisInt<1>, |
| 130 | SDTCisOpSmallerThanOp<1, 0>]>>; |
Michael Liao | 1be96bb | 2012-10-23 17:34:00 +0000 | [diff] [blame] | 131 | |
Igor Breger | 074a64e | 2015-07-24 17:24:15 +0000 | [diff] [blame] | 132 | def SDTVtrunc : SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisVec<1>, |
| 133 | SDTCisInt<0>, SDTCisInt<1>, |
| 134 | SDTCisOpSmallerThanOp<0, 1>]>; |
| 135 | |
| 136 | def X86vtrunc : SDNode<"X86ISD::VTRUNC", SDTVtrunc>; |
| 137 | def X86vtruncs : SDNode<"X86ISD::VTRUNCS", SDTVtrunc>; |
| 138 | def X86vtruncus : SDNode<"X86ISD::VTRUNCUS", SDTVtrunc>; |
| 139 | |
Elena Demikhovsky | c5f6726 | 2013-12-17 08:33:15 +0000 | [diff] [blame] | 140 | def X86trunc : SDNode<"X86ISD::TRUNC", |
Craig Topper | aefaab6 | 2014-01-26 04:59:39 +0000 | [diff] [blame] | 141 | SDTypeProfile<1, 1, [SDTCisInt<0>, SDTCisInt<1>, |
| 142 | SDTCisOpSmallerThanOp<0, 1>]>>; |
Michael Liao | 34107b9 | 2012-08-14 21:24:47 +0000 | [diff] [blame] | 143 | def X86vfpext : SDNode<"X86ISD::VFPEXT", |
| 144 | SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisVec<1>, |
Craig Topper | aefaab6 | 2014-01-26 04:59:39 +0000 | [diff] [blame] | 145 | SDTCisFP<0>, SDTCisFP<1>, |
| 146 | SDTCisOpSmallerThanOp<1, 0>]>>; |
Michael Liao | e999b86 | 2012-10-10 16:53:28 +0000 | [diff] [blame] | 147 | def X86vfpround: SDNode<"X86ISD::VFPROUND", |
| 148 | SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisVec<1>, |
Craig Topper | aefaab6 | 2014-01-26 04:59:39 +0000 | [diff] [blame] | 149 | SDTCisFP<0>, SDTCisFP<1>, |
| 150 | SDTCisOpSmallerThanOp<0, 1>]>>; |
Michael Liao | 34107b9 | 2012-08-14 21:24:47 +0000 | [diff] [blame] | 151 | |
Asaf Badouh | 2744d21 | 2015-09-20 14:31:19 +0000 | [diff] [blame] | 152 | def X86fround: SDNode<"X86ISD::VFPROUND", |
| 153 | SDTypeProfile<1, 2, [SDTCisFP<0>, SDTCisFP<1>,SDTCisFP<2>, |
| 154 | SDTCVecEltisVT<0, f32>, |
| 155 | SDTCVecEltisVT<1, f64>, |
| 156 | SDTCVecEltisVT<2, f64>, |
| 157 | SDTCisOpSmallerThanOp<0, 1>]>>; |
| 158 | def X86froundRnd: SDNode<"X86ISD::VFPROUND", |
| 159 | SDTypeProfile<1, 3, [SDTCisFP<0>, SDTCisFP<1>,SDTCisFP<2>, |
| 160 | SDTCVecEltisVT<0, f32>, |
| 161 | SDTCVecEltisVT<1, f64>, |
| 162 | SDTCVecEltisVT<2, f64>, |
| 163 | SDTCisOpSmallerThanOp<0, 1>, |
| 164 | SDTCisInt<3>]>>; |
| 165 | |
| 166 | def X86fpext : SDNode<"X86ISD::VFPEXT", |
| 167 | SDTypeProfile<1, 2, [SDTCisFP<0>, SDTCisFP<1>,SDTCisFP<2>, |
| 168 | SDTCVecEltisVT<0, f64>, |
| 169 | SDTCVecEltisVT<1, f32>, |
| 170 | SDTCVecEltisVT<2, f32>, |
| 171 | SDTCisOpSmallerThanOp<1, 0>]>>; |
| 172 | |
| 173 | def X86fpextRnd : SDNode<"X86ISD::VFPEXT", |
| 174 | SDTypeProfile<1, 3, [SDTCisFP<0>, SDTCisFP<1>,SDTCisFP<2>, |
| 175 | SDTCVecEltisVT<0, f64>, |
| 176 | SDTCVecEltisVT<1, f32>, |
| 177 | SDTCVecEltisVT<2, f32>, |
| 178 | SDTCisOpSmallerThanOp<1, 0>, |
| 179 | SDTCisInt<3>]>>; |
| 180 | |
Craig Topper | 0946264 | 2012-01-22 19:15:14 +0000 | [diff] [blame] | 181 | def X86vshldq : SDNode<"X86ISD::VSHLDQ", SDTIntShiftOp>; |
| 182 | def X86vshrdq : SDNode<"X86ISD::VSRLDQ", SDTIntShiftOp>; |
Craig Topper | 0b7ad76 | 2012-01-22 23:36:02 +0000 | [diff] [blame] | 183 | def X86cmpp : SDNode<"X86ISD::CMPP", SDTX86VFCMP>; |
Craig Topper | bd488437 | 2012-01-22 22:42:16 +0000 | [diff] [blame] | 184 | def X86pcmpeq : SDNode<"X86ISD::PCMPEQ", SDTIntBinOp, [SDNPCommutative]>; |
| 185 | def X86pcmpgt : SDNode<"X86ISD::PCMPGT", SDTIntBinOp>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 186 | |
Elena Demikhovsky | 60b1f28 | 2013-08-13 13:24:07 +0000 | [diff] [blame] | 187 | def X86IntCmpMask : SDTypeProfile<1, 2, |
| 188 | [SDTCisVec<0>, SDTCisSameAs<1, 2>, SDTCisInt<1>]>; |
| 189 | def X86pcmpeqm : SDNode<"X86ISD::PCMPEQM", X86IntCmpMask, [SDNPCommutative]>; |
| 190 | def X86pcmpgtm : SDNode<"X86ISD::PCMPGTM", X86IntCmpMask>; |
| 191 | |
Elena Demikhovsky | 47fc44e | 2013-12-16 13:52:35 +0000 | [diff] [blame] | 192 | def X86CmpMaskCC : |
Elena Demikhovsky | 29792e9 | 2015-05-07 11:24:42 +0000 | [diff] [blame] | 193 | SDTypeProfile<1, 3, [SDTCisVec<0>, SDTCVecEltisVT<0, i1>, |
| 194 | SDTCisVec<1>, SDTCisSameAs<2, 1>, |
| 195 | SDTCisSameNumEltsAs<0, 1>, SDTCisVT<3, i8>]>; |
| 196 | def X86CmpMaskCCRound : |
| 197 | SDTypeProfile<1, 4, [SDTCisVec<0>,SDTCVecEltisVT<0, i1>, |
| 198 | SDTCisVec<1>, SDTCisSameAs<2, 1>, |
| 199 | SDTCisSameNumEltsAs<0, 1>, SDTCisVT<3, i8>, |
| 200 | SDTCisInt<4>]>; |
Elena Demikhovsky | 47fc44e | 2013-12-16 13:52:35 +0000 | [diff] [blame] | 201 | def X86CmpMaskCCScalar : |
| 202 | SDTypeProfile<1, 3, [SDTCisInt<0>, SDTCisSameAs<1, 2>, SDTCisVT<3, i8>]>; |
| 203 | |
Igor Breger | b7e1f9d | 2015-09-20 15:15:10 +0000 | [diff] [blame] | 204 | def X86CmpMaskCCScalarRound : |
| 205 | SDTypeProfile<1, 4, [SDTCisInt<0>, SDTCisSameAs<1, 2>, SDTCisVT<3, i8>, |
| 206 | SDTCisInt<4>]>; |
| 207 | |
| 208 | def X86cmpm : SDNode<"X86ISD::CMPM", X86CmpMaskCC>; |
| 209 | def X86cmpmRnd : SDNode<"X86ISD::CMPM_RND", X86CmpMaskCCRound>; |
| 210 | def X86cmpmu : SDNode<"X86ISD::CMPMU", X86CmpMaskCC>; |
| 211 | def X86cmpms : SDNode<"X86ISD::FSETCC", X86CmpMaskCCScalar>; |
| 212 | def X86cmpmsRnd : SDNode<"X86ISD::FSETCC", X86CmpMaskCCScalarRound>; |
Elena Demikhovsky | 60b1f28 | 2013-08-13 13:24:07 +0000 | [diff] [blame] | 213 | |
Craig Topper | 0946264 | 2012-01-22 19:15:14 +0000 | [diff] [blame] | 214 | def X86vshl : SDNode<"X86ISD::VSHL", |
| 215 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
| 216 | SDTCisVec<2>]>>; |
| 217 | def X86vsrl : SDNode<"X86ISD::VSRL", |
| 218 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
| 219 | SDTCisVec<2>]>>; |
| 220 | def X86vsra : SDNode<"X86ISD::VSRA", |
| 221 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
| 222 | SDTCisVec<2>]>>; |
| 223 | |
| 224 | def X86vshli : SDNode<"X86ISD::VSHLI", SDTIntShiftOp>; |
| 225 | def X86vsrli : SDNode<"X86ISD::VSRLI", SDTIntShiftOp>; |
| 226 | def X86vsrai : SDNode<"X86ISD::VSRAI", SDTIntShiftOp>; |
| 227 | |
Michael Zuckerman | 2ddcbcf | 2016-01-12 21:19:17 +0000 | [diff] [blame] | 228 | def X86vrotli : SDNode<"X86ISD::VROTLI", SDTIntShiftOp>; |
Michael Zuckerman | 298a680 | 2016-01-13 12:39:33 +0000 | [diff] [blame^] | 229 | def X86vrotri : SDNode<"X86ISD::VROTRI", SDTIntShiftOp>; |
Michael Zuckerman | 2ddcbcf | 2016-01-12 21:19:17 +0000 | [diff] [blame] | 230 | |
Simon Pilgrim | 86c5e85 | 2015-10-17 19:04:24 +0000 | [diff] [blame] | 231 | def X86vprot : SDNode<"X86ISD::VPROT", |
| 232 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 233 | SDTCisSameAs<0,2>]>>; |
Simon Pilgrim | 86c5e85 | 2015-10-17 19:04:24 +0000 | [diff] [blame] | 234 | def X86vproti : SDNode<"X86ISD::VPROTI", |
| 235 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 236 | SDTCisVT<2, i8>]>>; |
Simon Pilgrim | 86c5e85 | 2015-10-17 19:04:24 +0000 | [diff] [blame] | 237 | |
Simon Pilgrim | 3d11c99 | 2015-09-30 08:17:50 +0000 | [diff] [blame] | 238 | def X86vpshl : SDNode<"X86ISD::VPSHL", |
| 239 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 240 | SDTCisSameAs<0,2>]>>; |
Simon Pilgrim | 3d11c99 | 2015-09-30 08:17:50 +0000 | [diff] [blame] | 241 | def X86vpsha : SDNode<"X86ISD::VPSHA", |
| 242 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 243 | SDTCisSameAs<0,2>]>>; |
Simon Pilgrim | 3d11c99 | 2015-09-30 08:17:50 +0000 | [diff] [blame] | 244 | |
Simon Pilgrim | 52d47e5 | 2015-10-11 14:15:17 +0000 | [diff] [blame] | 245 | def X86vpcom : SDNode<"X86ISD::VPCOM", |
| 246 | SDTypeProfile<1, 3, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 247 | SDTCisSameAs<0,2>, |
| 248 | SDTCisVT<3, i8>]>>; |
Simon Pilgrim | 52d47e5 | 2015-10-11 14:15:17 +0000 | [diff] [blame] | 249 | def X86vpcomu : SDNode<"X86ISD::VPCOMU", |
| 250 | SDTypeProfile<1, 3, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 251 | SDTCisSameAs<0,2>, |
| 252 | SDTCisVT<3, i8>]>>; |
Simon Pilgrim | 52d47e5 | 2015-10-11 14:15:17 +0000 | [diff] [blame] | 253 | |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 254 | def SDTX86CmpPTest : SDTypeProfile<1, 2, [SDTCisVT<0, i32>, |
Bruno Cardoso Lopes | 91d61df | 2010-08-10 23:25:42 +0000 | [diff] [blame] | 255 | SDTCisVec<1>, |
| 256 | SDTCisSameAs<2, 1>]>; |
Elena Demikhovsky | 5226638 | 2015-05-04 12:35:55 +0000 | [diff] [blame] | 257 | def X86addus : SDNode<"X86ISD::ADDUS", SDTIntBinOp>; |
Benjamin Kramer | b16ccde | 2012-12-15 16:47:44 +0000 | [diff] [blame] | 258 | def X86subus : SDNode<"X86ISD::SUBUS", SDTIntBinOp>; |
Elena Demikhovsky | 5226638 | 2015-05-04 12:35:55 +0000 | [diff] [blame] | 259 | def X86adds : SDNode<"X86ISD::ADDS", SDTIntBinOp>; |
| 260 | def X86subs : SDNode<"X86ISD::SUBS", SDTIntBinOp>; |
Asaf Badouh | c6f3c82 | 2015-07-06 14:03:40 +0000 | [diff] [blame] | 261 | def X86mulhrs : SDNode<"X86ISD::MULHRS" , SDTIntBinOp>; |
Asaf Badouh | 81f03c3 | 2015-06-18 12:30:53 +0000 | [diff] [blame] | 262 | def X86avg : SDNode<"X86ISD::AVG" , SDTIntBinOp>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 263 | def X86ptest : SDNode<"X86ISD::PTEST", SDTX86CmpPTest>; |
Bruno Cardoso Lopes | 91d61df | 2010-08-10 23:25:42 +0000 | [diff] [blame] | 264 | def X86testp : SDNode<"X86ISD::TESTP", SDTX86CmpPTest>; |
Elena Demikhovsky | 40864b6 | 2013-08-05 08:52:21 +0000 | [diff] [blame] | 265 | def X86kortest : SDNode<"X86ISD::KORTEST", SDTX86CmpPTest>; |
Igor Breger | 5ea0a681 | 2015-08-31 13:30:19 +0000 | [diff] [blame] | 266 | def X86ktest : SDNode<"X86ISD::KTEST", SDTX86CmpPTest>; |
Elena Demikhovsky | 47fc44e | 2013-12-16 13:52:35 +0000 | [diff] [blame] | 267 | def X86testm : SDNode<"X86ISD::TESTM", SDTypeProfile<1, 2, [SDTCisVec<0>, |
Elena Demikhovsky | 431b81e | 2015-04-21 13:13:46 +0000 | [diff] [blame] | 268 | SDTCisVec<1>, SDTCisSameAs<2, 1>, |
| 269 | SDTCVecEltisVT<0, i1>, |
| 270 | SDTCisSameNumEltsAs<0, 1>]>>; |
Elena Demikhovsky | a30e437 | 2014-02-05 07:05:03 +0000 | [diff] [blame] | 271 | def X86testnm : SDNode<"X86ISD::TESTNM", SDTypeProfile<1, 2, [SDTCisVec<0>, |
Elena Demikhovsky | 431b81e | 2015-04-21 13:13:46 +0000 | [diff] [blame] | 272 | SDTCisVec<1>, SDTCisSameAs<2, 1>, |
| 273 | SDTCVecEltisVT<0, i1>, |
| 274 | SDTCisSameNumEltsAs<0, 1>]>>; |
Elena Demikhovsky | 47fc44e | 2013-12-16 13:52:35 +0000 | [diff] [blame] | 275 | def X86select : SDNode<"X86ISD::SELECT" , SDTSelect>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 276 | |
Craig Topper | 1d471e3 | 2012-02-05 03:14:49 +0000 | [diff] [blame] | 277 | def X86pmuludq : SDNode<"X86ISD::PMULUDQ", |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 278 | SDTypeProfile<1, 2, [SDTCVecEltisVT<0, i64>, |
| 279 | SDTCVecEltisVT<1, i32>, |
| 280 | SDTCisSameSizeAs<0,1>, |
| 281 | SDTCisSameAs<1,2>]>>; |
Benjamin Kramer | 6d2dff6 | 2014-04-26 14:12:19 +0000 | [diff] [blame] | 282 | def X86pmuldq : SDNode<"X86ISD::PMULDQ", |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 283 | SDTypeProfile<1, 2, [SDTCVecEltisVT<0, i64>, |
| 284 | SDTCVecEltisVT<1, i32>, |
| 285 | SDTCisSameSizeAs<0,1>, |
| 286 | SDTCisSameAs<1,2>]>>; |
Craig Topper | 1d471e3 | 2012-02-05 03:14:49 +0000 | [diff] [blame] | 287 | |
Simon Pilgrim | d85cae3 | 2015-07-06 20:46:41 +0000 | [diff] [blame] | 288 | def X86extrqi : SDNode<"X86ISD::EXTRQI", |
| 289 | SDTypeProfile<1, 3, [SDTCisVT<0, v2i64>, SDTCisSameAs<0,1>, |
| 290 | SDTCisVT<2, i8>, SDTCisVT<3, i8>]>>; |
| 291 | def X86insertqi : SDNode<"X86ISD::INSERTQI", |
| 292 | SDTypeProfile<1, 4, [SDTCisVT<0, v2i64>, SDTCisSameAs<0,1>, |
| 293 | SDTCisSameAs<1,2>, SDTCisVT<3, i8>, |
| 294 | SDTCisVT<4, i8>]>>; |
| 295 | |
Bruno Cardoso Lopes | 6f3b38a | 2010-08-20 22:55:05 +0000 | [diff] [blame] | 296 | // Specific shuffle nodes - At some point ISD::VECTOR_SHUFFLE will always get |
| 297 | // translated into one of the target nodes below during lowering. |
| 298 | // Note: this is a work in progress... |
| 299 | def SDTShuff1Op : SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisSameAs<0,1>]>; |
| 300 | def SDTShuff2Op : SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
| 301 | SDTCisSameAs<0,2>]>; |
| 302 | |
Chandler Carruth | 6d5916a | 2014-09-23 10:08:29 +0000 | [diff] [blame] | 303 | def SDTShuff2OpM : SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 304 | SDTCisSameSizeAs<0,2>, |
| 305 | SDTCisSameNumEltsAs<0,2>]>; |
Bruno Cardoso Lopes | 6f3b38a | 2010-08-20 22:55:05 +0000 | [diff] [blame] | 306 | def SDTShuff2OpI : SDTypeProfile<1, 2, [SDTCisVec<0>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 307 | SDTCisSameAs<0,1>, SDTCisVT<2, i8>]>; |
Bruno Cardoso Lopes | 6f3b38a | 2010-08-20 22:55:05 +0000 | [diff] [blame] | 308 | def SDTShuff3OpI : SDTypeProfile<1, 3, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 309 | SDTCisSameAs<0,2>, SDTCisVT<3, i8>]>; |
Elena Demikhovsky | 42c96d9 | 2015-06-01 06:50:49 +0000 | [diff] [blame] | 310 | def SDTFPBinOpImmRound: SDTypeProfile<1, 4, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
| 311 | SDTCisSameAs<0,2>, SDTCisInt<3>, SDTCisInt<4>]>; |
Asaf Badouh | a5b2e5e | 2015-07-22 12:00:43 +0000 | [diff] [blame] | 312 | def SDTFPUnaryOpImmRound: SDTypeProfile<1, 3, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
| 313 | SDTCisInt<2>, SDTCisInt<3>]>; |
Bruno Cardoso Lopes | 6f3b38a | 2010-08-20 22:55:05 +0000 | [diff] [blame] | 314 | |
Elena Demikhovsky | 45c54ad | 2013-08-07 12:34:55 +0000 | [diff] [blame] | 315 | def SDTVBroadcast : SDTypeProfile<1, 1, [SDTCisVec<0>]>; |
Asaf Badouh | 0d957b8 | 2015-11-18 09:42:45 +0000 | [diff] [blame] | 316 | def SDTVBroadcastm : SDTypeProfile<1, 1, [SDTCisVec<0>, |
| 317 | SDTCisInt<0>, SDTCisInt<1>]>; |
Elena Demikhovsky | 45c54ad | 2013-08-07 12:34:55 +0000 | [diff] [blame] | 318 | |
Nadav Rotem | 9bc178a | 2012-04-11 06:40:27 +0000 | [diff] [blame] | 319 | def SDTBlend : SDTypeProfile<1, 3, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
Chandler Carruth | 373b2b1 | 2014-09-06 10:00:01 +0000 | [diff] [blame] | 320 | SDTCisSameAs<1,2>, SDTCisVT<3, i8>]>; |
Elena Demikhovsky | 3cb3b00 | 2012-08-01 12:06:00 +0000 | [diff] [blame] | 321 | |
Igor Breger | b4bb190 | 2015-10-15 12:33:24 +0000 | [diff] [blame] | 322 | def SDTTernlog : SDTypeProfile<1, 4, [SDTCisVec<0>, SDTCisSameAs<0,1>, |
| 323 | SDTCisSameAs<0,2>, SDTCisSameAs<0,3>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 324 | SDTCisVT<4, i8>]>; |
Igor Breger | b4bb190 | 2015-10-15 12:33:24 +0000 | [diff] [blame] | 325 | |
Elena Demikhovsky | 714f23b | 2015-02-18 07:59:20 +0000 | [diff] [blame] | 326 | def SDTFPBinOpRound : SDTypeProfile<1, 3, [ // fadd_round, fmul_round, etc. |
| 327 | SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisFP<0>, SDTCisInt<3>]>; |
| 328 | |
Asaf Badouh | 402ebb3 | 2015-06-03 13:41:48 +0000 | [diff] [blame] | 329 | def SDTFPUnaryOpRound : SDTypeProfile<1, 2, [ // fsqrt_round, fgetexp_round, etc. |
| 330 | SDTCisSameAs<0, 1>, SDTCisFP<0>, SDTCisInt<2>]>; |
| 331 | |
Elena Demikhovsky | 3cb3b00 | 2012-08-01 12:06:00 +0000 | [diff] [blame] | 332 | def SDTFma : SDTypeProfile<1, 3, [SDTCisSameAs<0,1>, |
| 333 | SDTCisSameAs<1,2>, SDTCisSameAs<1,3>]>; |
Elena Demikhovsky | 7b0dd39 | 2015-01-28 10:21:27 +0000 | [diff] [blame] | 334 | def SDTFmaRound : SDTypeProfile<1, 4, [SDTCisSameAs<0,1>, |
| 335 | SDTCisSameAs<1,2>, SDTCisSameAs<1,3>, SDTCisInt<4>]>; |
Elena Demikhovsky | be8808d | 2014-11-12 07:31:03 +0000 | [diff] [blame] | 336 | def STDFp1SrcRm : SDTypeProfile<1, 2, [SDTCisSameAs<0,1>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 337 | SDTCisVec<0>, SDTCisVT<2, i32>]>; |
Elena Demikhovsky | 905a5a6 | 2014-11-26 10:46:49 +0000 | [diff] [blame] | 338 | def STDFp2SrcRm : SDTypeProfile<1, 3, [SDTCisSameAs<0,1>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 339 | SDTCisVec<0>, SDTCisVT<3, i32>]>; |
Elena Demikhovsky | 52e81bc | 2015-02-23 15:12:31 +0000 | [diff] [blame] | 340 | def STDFp3SrcRm : SDTypeProfile<1, 4, [SDTCisSameAs<0,1>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 341 | SDTCisVec<0>, SDTCisVT<3, i32>, SDTCisVT<4, i32>]>; |
Bruno Cardoso Lopes | be5e987 | 2011-08-17 02:29:19 +0000 | [diff] [blame] | 342 | |
Craig Topper | 8fb09f0 | 2013-01-28 06:48:25 +0000 | [diff] [blame] | 343 | def X86PAlignr : SDNode<"X86ISD::PALIGNR", SDTShuff3OpI>; |
Adam Nemet | 2f10cc6 | 2014-08-05 17:22:55 +0000 | [diff] [blame] | 344 | def X86VAlign : SDNode<"X86ISD::VALIGN", SDTShuff3OpI>; |
Igor Breger | 0dcd8bc | 2015-09-03 09:05:31 +0000 | [diff] [blame] | 345 | |
| 346 | def X86Abs : SDNode<"X86ISD::ABS", SDTIntUnaryOp>; |
| 347 | def X86Conflict : SDNode<"X86ISD::CONFLICT", SDTIntUnaryOp>; |
Bruno Cardoso Lopes | 6f3b38a | 2010-08-20 22:55:05 +0000 | [diff] [blame] | 348 | |
| 349 | def X86PShufd : SDNode<"X86ISD::PSHUFD", SDTShuff2OpI>; |
| 350 | def X86PShufhw : SDNode<"X86ISD::PSHUFHW", SDTShuff2OpI>; |
| 351 | def X86PShuflw : SDNode<"X86ISD::PSHUFLW", SDTShuff2OpI>; |
| 352 | |
Elena Demikhovsky | 9e38086 | 2015-06-03 10:56:40 +0000 | [diff] [blame] | 353 | def X86Shufp : SDNode<"X86ISD::SHUFP", SDTShuff3OpI>; |
| 354 | def X86Shuf128 : SDNode<"X86ISD::SHUF128", SDTShuff3OpI>; |
Bruno Cardoso Lopes | 6f3b38a | 2010-08-20 22:55:05 +0000 | [diff] [blame] | 355 | |
| 356 | def X86Movddup : SDNode<"X86ISD::MOVDDUP", SDTShuff1Op>; |
| 357 | def X86Movshdup : SDNode<"X86ISD::MOVSHDUP", SDTShuff1Op>; |
| 358 | def X86Movsldup : SDNode<"X86ISD::MOVSLDUP", SDTShuff1Op>; |
| 359 | |
Bruno Cardoso Lopes | 6f3b38a | 2010-08-20 22:55:05 +0000 | [diff] [blame] | 360 | def X86Movsd : SDNode<"X86ISD::MOVSD", SDTShuff2Op>; |
| 361 | def X86Movss : SDNode<"X86ISD::MOVSS", SDTShuff2Op>; |
| 362 | |
| 363 | def X86Movlhps : SDNode<"X86ISD::MOVLHPS", SDTShuff2Op>; |
Bruno Cardoso Lopes | 6f3b38a | 2010-08-20 22:55:05 +0000 | [diff] [blame] | 364 | def X86Movlhpd : SDNode<"X86ISD::MOVLHPD", SDTShuff2Op>; |
Bruno Cardoso Lopes | 03e4c35 | 2010-08-31 21:15:21 +0000 | [diff] [blame] | 365 | def X86Movhlps : SDNode<"X86ISD::MOVHLPS", SDTShuff2Op>; |
Bruno Cardoso Lopes | 6f3b38a | 2010-08-20 22:55:05 +0000 | [diff] [blame] | 366 | |
Bruno Cardoso Lopes | b382521 | 2010-09-01 05:08:25 +0000 | [diff] [blame] | 367 | def X86Movlps : SDNode<"X86ISD::MOVLPS", SDTShuff2Op>; |
| 368 | def X86Movlpd : SDNode<"X86ISD::MOVLPD", SDTShuff2Op>; |
Bruno Cardoso Lopes | 6f3b38a | 2010-08-20 22:55:05 +0000 | [diff] [blame] | 369 | |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 370 | def SDTPack : SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>, |
| 371 | SDTCisSameSizeAs<0,1>, |
| 372 | SDTCisSameAs<1,2>]>; |
Chandler Carruth | 8366ceb | 2014-06-20 01:05:28 +0000 | [diff] [blame] | 373 | def X86Packss : SDNode<"X86ISD::PACKSS", SDTPack>; |
| 374 | def X86Packus : SDNode<"X86ISD::PACKUS", SDTPack>; |
| 375 | |
Craig Topper | 8d4ba19 | 2011-12-06 08:21:25 +0000 | [diff] [blame] | 376 | def X86Unpckl : SDNode<"X86ISD::UNPCKL", SDTShuff2Op>; |
| 377 | def X86Unpckh : SDNode<"X86ISD::UNPCKH", SDTShuff2Op>; |
Bruno Cardoso Lopes | 6f3b38a | 2010-08-20 22:55:05 +0000 | [diff] [blame] | 378 | |
Igor Breger | f7fd547 | 2015-07-21 07:11:28 +0000 | [diff] [blame] | 379 | def X86vpmaddubsw : SDNode<"X86ISD::VPMADDUBSW" , SDTPack>; |
| 380 | def X86vpmaddwd : SDNode<"X86ISD::VPMADDWD" , SDTPack>; |
| 381 | |
Chandler Carruth | 6d5916a | 2014-09-23 10:08:29 +0000 | [diff] [blame] | 382 | def X86VPermilpv : SDNode<"X86ISD::VPERMILPV", SDTShuff2OpM>; |
Chandler Carruth | ed5dfff | 2014-09-22 22:29:42 +0000 | [diff] [blame] | 383 | def X86VPermilpi : SDNode<"X86ISD::VPERMILPI", SDTShuff2OpI>; |
Craig Topper | ecae476 | 2015-11-29 22:53:22 +0000 | [diff] [blame] | 384 | def X86VPermv : SDNode<"X86ISD::VPERMV", |
| 385 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisInt<1>, |
| 386 | SDTCisSameNumEltsAs<0,1>, |
| 387 | SDTCisSameSizeAs<0,1>, |
| 388 | SDTCisSameAs<0,2>]>>; |
Chandler Carruth | ed5dfff | 2014-09-22 22:29:42 +0000 | [diff] [blame] | 389 | def X86VPermi : SDNode<"X86ISD::VPERMI", SDTShuff2OpI>; |
Craig Topper | 05858f5 | 2015-11-26 20:02:01 +0000 | [diff] [blame] | 390 | def X86VPermt2 : SDNode<"X86ISD::VPERMV3", |
| 391 | SDTypeProfile<1, 3, [SDTCisVec<0>, |
Elena Demikhovsky | f07df9f | 2015-11-25 08:17:56 +0000 | [diff] [blame] | 392 | SDTCisSameAs<0,1>, SDTCisInt<2>, |
| 393 | SDTCisVec<2>, SDTCisSameNumEltsAs<0, 2>, |
Craig Topper | a3ac738 | 2015-11-26 07:58:20 +0000 | [diff] [blame] | 394 | SDTCisSameSizeAs<0,2>, |
Elena Demikhovsky | f07df9f | 2015-11-25 08:17:56 +0000 | [diff] [blame] | 395 | SDTCisSameAs<0,3>]>, []>; |
Elena Demikhovsky | f07df9f | 2015-11-25 08:17:56 +0000 | [diff] [blame] | 396 | |
Craig Topper | aad5f11 | 2015-11-30 00:13:24 +0000 | [diff] [blame] | 397 | def X86VPermi2X : SDNode<"X86ISD::VPERMIV3", |
| 398 | SDTypeProfile<1, 3, [SDTCisVec<0>, SDTCisInt<1>, |
| 399 | SDTCisVec<1>, SDTCisSameNumEltsAs<0, 1>, |
| 400 | SDTCisSameSizeAs<0,1>, |
| 401 | SDTCisSameAs<0,2>, |
| 402 | SDTCisSameAs<0,3>]>, []>; |
| 403 | |
Igor Breger | b4bb190 | 2015-10-15 12:33:24 +0000 | [diff] [blame] | 404 | def X86vpternlog : SDNode<"X86ISD::VPTERNLOG", SDTTernlog>; |
Bruno Cardoso Lopes | b878caa | 2011-07-21 01:55:47 +0000 | [diff] [blame] | 405 | |
Craig Topper | 0a672ea | 2011-11-30 07:47:51 +0000 | [diff] [blame] | 406 | def X86VPerm2x128 : SDNode<"X86ISD::VPERM2X128", SDTShuff3OpI>; |
Bruno Cardoso Lopes | f15dfe5 | 2011-08-12 21:48:26 +0000 | [diff] [blame] | 407 | |
Igor Breger | 1e58e8a | 2015-09-02 11:18:55 +0000 | [diff] [blame] | 408 | def X86VFixupimm : SDNode<"X86ISD::VFIXUPIMM", SDTFPBinOpImmRound>; |
| 409 | def X86VRange : SDNode<"X86ISD::VRANGE", SDTFPBinOpImmRound>; |
| 410 | def X86VReduce : SDNode<"X86ISD::VREDUCE", SDTFPUnaryOpImmRound>; |
| 411 | def X86VRndScale : SDNode<"X86ISD::VRNDSCALE", SDTFPUnaryOpImmRound>; |
| 412 | def X86VGetMant : SDNode<"X86ISD::VGETMANT", SDTFPUnaryOpImmRound>; |
Craig Topper | 9d1deb4 | 2015-11-26 18:31:19 +0000 | [diff] [blame] | 413 | def X86Vfpclass : SDNode<"X86ISD::VFPCLASS", |
Asaf Badouh | 572bbce | 2015-09-20 08:46:07 +0000 | [diff] [blame] | 414 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCVecEltisVT<0, i1>, |
Craig Topper | 0009656 | 2015-11-26 19:41:34 +0000 | [diff] [blame] | 415 | SDTCisVec<1>, SDTCisFP<1>, |
| 416 | SDTCisSameNumEltsAs<0,1>, |
| 417 | SDTCisVT<2, i32>]>, []>; |
| 418 | def X86Vfpclasss : SDNode<"X86ISD::VFPCLASSS", |
| 419 | SDTypeProfile<1, 2, [SDTCisVT<0, i1>, |
| 420 | SDTCisFP<1>, SDTCisVT<2, i32>]>,[]>; |
Elena Demikhovsky | 42c96d9 | 2015-06-01 06:50:49 +0000 | [diff] [blame] | 421 | |
Elena Demikhovsky | ad9c396 | 2015-05-18 06:42:57 +0000 | [diff] [blame] | 422 | def X86SubVBroadcast : SDNode<"X86ISD::SUBV_BROADCAST", |
| 423 | SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisVec<1>, |
| 424 | SDTCisSubVecOfVec<1, 0>]>, []>; |
Igor Breger | fa798a9 | 2015-11-02 07:39:36 +0000 | [diff] [blame] | 425 | // SDTCisSubVecOfVec restriction cannot be applied for 128 bit version of VBROADCASTI32x2. |
| 426 | def X86SubV32x2Broadcast : SDNode<"X86ISD::SUBV_BROADCAST", |
Craig Topper | 9d1deb4 | 2015-11-26 18:31:19 +0000 | [diff] [blame] | 427 | SDTypeProfile<1, 1, [SDTCisVec<0>, |
| 428 | SDTCisSameAs<0,1>]>, []>; |
Igor Breger | fa798a9 | 2015-11-02 07:39:36 +0000 | [diff] [blame] | 429 | |
Bruno Cardoso Lopes | be5e987 | 2011-08-17 02:29:19 +0000 | [diff] [blame] | 430 | def X86VBroadcast : SDNode<"X86ISD::VBROADCAST", SDTVBroadcast>; |
Asaf Badouh | 0d957b8 | 2015-11-18 09:42:45 +0000 | [diff] [blame] | 431 | def X86VBroadcastm : SDNode<"X86ISD::VBROADCASTM", SDTVBroadcastm>; |
Elena Demikhovsky | 8952974 | 2013-09-12 08:55:00 +0000 | [diff] [blame] | 432 | def X86Vinsert : SDNode<"X86ISD::VINSERT", SDTypeProfile<1, 3, |
Craig Topper | 9d1deb4 | 2015-11-26 18:31:19 +0000 | [diff] [blame] | 433 | [SDTCisSameAs<0, 1>, SDTCisEltOfVec<2, 1>, |
| 434 | SDTCisPtrTy<3>]>, []>; |
Elena Demikhovsky | 9f423d6 | 2014-02-10 07:02:39 +0000 | [diff] [blame] | 435 | def X86Vextract : SDNode<"X86ISD::VEXTRACT", SDTypeProfile<1, 2, |
Craig Topper | 9d1deb4 | 2015-11-26 18:31:19 +0000 | [diff] [blame] | 436 | [SDTCisEltOfVec<0, 1>, SDTCisVec<1>, |
| 437 | SDTCisPtrTy<2>]>, []>; |
Bruno Cardoso Lopes | be5e987 | 2011-08-17 02:29:19 +0000 | [diff] [blame] | 438 | |
Elena Demikhovsky | cd3c1c4 | 2012-12-05 09:24:57 +0000 | [diff] [blame] | 439 | def X86Blendi : SDNode<"X86ISD::BLENDI", SDTBlend>; |
Chandler Carruth | 204ad4c | 2014-09-15 20:09:47 +0000 | [diff] [blame] | 440 | |
| 441 | def X86Addsub : SDNode<"X86ISD::ADDSUB", SDTFPBinOp>; |
| 442 | |
Elena Demikhovsky | 714f23b | 2015-02-18 07:59:20 +0000 | [diff] [blame] | 443 | def X86faddRnd : SDNode<"X86ISD::FADD_RND", SDTFPBinOpRound>; |
| 444 | def X86fsubRnd : SDNode<"X86ISD::FSUB_RND", SDTFPBinOpRound>; |
| 445 | def X86fmulRnd : SDNode<"X86ISD::FMUL_RND", SDTFPBinOpRound>; |
| 446 | def X86fdivRnd : SDNode<"X86ISD::FDIV_RND", SDTFPBinOpRound>; |
Igor Breger | 4c4cd78 | 2015-09-20 09:13:41 +0000 | [diff] [blame] | 447 | def X86fmaxRnd : SDNode<"X86ISD::FMAX_RND", SDTFPBinOpRound>; |
| 448 | def X86scalef : SDNode<"X86ISD::SCALEF", SDTFPBinOpRound>; |
| 449 | def X86fminRnd : SDNode<"X86ISD::FMIN_RND", SDTFPBinOpRound>; |
| 450 | def X86fsqrtRnd : SDNode<"X86ISD::FSQRT_RND", SDTFPUnaryOpRound>; |
| 451 | def X86fsqrtRnds : SDNode<"X86ISD::FSQRT_RND", STDFp2SrcRm>; |
Igor Breger | 8352a0d | 2015-07-28 06:53:28 +0000 | [diff] [blame] | 452 | def X86fgetexpRnd : SDNode<"X86ISD::FGETEXP_RND", SDTFPUnaryOpRound>; |
| 453 | def X86fgetexpRnds : SDNode<"X86ISD::FGETEXP_RND", STDFp2SrcRm>; |
Elena Demikhovsky | 714f23b | 2015-02-18 07:59:20 +0000 | [diff] [blame] | 454 | |
Elena Demikhovsky | 3cb3b00 | 2012-08-01 12:06:00 +0000 | [diff] [blame] | 455 | def X86Fmadd : SDNode<"X86ISD::FMADD", SDTFma>; |
| 456 | def X86Fnmadd : SDNode<"X86ISD::FNMADD", SDTFma>; |
| 457 | def X86Fmsub : SDNode<"X86ISD::FMSUB", SDTFma>; |
| 458 | def X86Fnmsub : SDNode<"X86ISD::FNMSUB", SDTFma>; |
Craig Topper | a999c66 | 2012-08-29 07:18:25 +0000 | [diff] [blame] | 459 | def X86Fmaddsub : SDNode<"X86ISD::FMADDSUB", SDTFma>; |
| 460 | def X86Fmsubadd : SDNode<"X86ISD::FMSUBADD", SDTFma>; |
Nadav Rotem | 9bc178a | 2012-04-11 06:40:27 +0000 | [diff] [blame] | 461 | |
Elena Demikhovsky | 7b0dd39 | 2015-01-28 10:21:27 +0000 | [diff] [blame] | 462 | def X86FmaddRnd : SDNode<"X86ISD::FMADD_RND", SDTFmaRound>; |
| 463 | def X86FnmaddRnd : SDNode<"X86ISD::FNMADD_RND", SDTFmaRound>; |
| 464 | def X86FmsubRnd : SDNode<"X86ISD::FMSUB_RND", SDTFmaRound>; |
| 465 | def X86FnmsubRnd : SDNode<"X86ISD::FNMSUB_RND", SDTFmaRound>; |
| 466 | def X86FmaddsubRnd : SDNode<"X86ISD::FMADDSUB_RND", SDTFmaRound>; |
| 467 | def X86FmsubaddRnd : SDNode<"X86ISD::FMSUBADD_RND", SDTFmaRound>; |
| 468 | |
Elena Demikhovsky | be8808d | 2014-11-12 07:31:03 +0000 | [diff] [blame] | 469 | def X86rsqrt28 : SDNode<"X86ISD::RSQRT28", STDFp1SrcRm>; |
| 470 | def X86rcp28 : SDNode<"X86ISD::RCP28", STDFp1SrcRm>; |
Elena Demikhovsky | 905a5a6 | 2014-11-26 10:46:49 +0000 | [diff] [blame] | 471 | def X86exp2 : SDNode<"X86ISD::EXP2", STDFp1SrcRm>; |
| 472 | |
Igor Breger | 1e58e8a | 2015-09-02 11:18:55 +0000 | [diff] [blame] | 473 | def X86rsqrt28s : SDNode<"X86ISD::RSQRT28", STDFp2SrcRm>; |
| 474 | def X86rcp28s : SDNode<"X86ISD::RCP28", STDFp2SrcRm>; |
Asaf Badouh | a5b2e5e | 2015-07-22 12:00:43 +0000 | [diff] [blame] | 475 | def X86RndScales : SDNode<"X86ISD::VRNDSCALE", STDFp3SrcRm>; |
Igor Breger | 1e58e8a | 2015-09-02 11:18:55 +0000 | [diff] [blame] | 476 | def X86Reduces : SDNode<"X86ISD::VREDUCE", STDFp3SrcRm>; |
| 477 | def X86GetMants : SDNode<"X86ISD::VGETMANT", STDFp3SrcRm>; |
Elena Demikhovsky | be8808d | 2014-11-12 07:31:03 +0000 | [diff] [blame] | 478 | |
Craig Topper | ab47fe4 | 2012-08-06 06:22:36 +0000 | [diff] [blame] | 479 | def SDT_PCMPISTRI : SDTypeProfile<2, 3, [SDTCisVT<0, i32>, SDTCisVT<1, i32>, |
| 480 | SDTCisVT<2, v16i8>, SDTCisVT<3, v16i8>, |
| 481 | SDTCisVT<4, i8>]>; |
| 482 | def SDT_PCMPESTRI : SDTypeProfile<2, 5, [SDTCisVT<0, i32>, SDTCisVT<1, i32>, |
| 483 | SDTCisVT<2, v16i8>, SDTCisVT<3, i32>, |
| 484 | SDTCisVT<4, v16i8>, SDTCisVT<5, i32>, |
| 485 | SDTCisVT<6, i8>]>; |
| 486 | |
| 487 | def X86pcmpistri : SDNode<"X86ISD::PCMPISTRI", SDT_PCMPISTRI>; |
| 488 | def X86pcmpestri : SDNode<"X86ISD::PCMPESTRI", SDT_PCMPESTRI>; |
| 489 | |
Elena Demikhovsky | ba5ab32 | 2015-06-22 11:16:30 +0000 | [diff] [blame] | 490 | def X86compress: SDNode<"X86ISD::COMPRESS", SDTypeProfile<1, 1, |
| 491 | [SDTCisSameAs<0, 1>, SDTCisVec<1>]>, []>; |
| 492 | def X86expand : SDNode<"X86ISD::EXPAND", SDTypeProfile<1, 1, |
| 493 | [SDTCisSameAs<0, 1>, SDTCisVec<1>]>, []>; |
Elena Demikhovsky | 908dbf4 | 2014-12-11 15:02:24 +0000 | [diff] [blame] | 494 | |
Igor Breger | abe4a79 | 2015-06-14 12:44:55 +0000 | [diff] [blame] | 495 | def SDTintToFPRound: SDTypeProfile<1, 3, [SDTCisVec<0>, SDTCisFP<0>, |
Craig Topper | 9d1deb4 | 2015-11-26 18:31:19 +0000 | [diff] [blame] | 496 | SDTCisSameAs<0,1>, SDTCisInt<2>, |
| 497 | SDTCisVT<3, i32>]>; |
Igor Breger | abe4a79 | 2015-06-14 12:44:55 +0000 | [diff] [blame] | 498 | |
Elena Demikhovsky | 0f37093 | 2015-07-13 13:26:20 +0000 | [diff] [blame] | 499 | def SDTDoubleToInt: SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisVec<1>, |
| 500 | SDTCisInt<0>, SDTCVecEltisVT<1, f64>]>; |
| 501 | def SDTFloatToInt: SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisVec<1>, |
| 502 | SDTCisInt<0>, SDTCVecEltisVT<1, f32>]>; |
| 503 | |
| 504 | def SDTDoubleToIntRnd: SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>, |
| 505 | SDTCisInt<0>, SDTCVecEltisVT<1, f64>]>; |
Asaf Badouh | 2744d21 | 2015-09-20 14:31:19 +0000 | [diff] [blame] | 506 | def SDTSDoubleToIntRnd: SDTypeProfile<1, 2, [SDTCisInt<0>,SDTCisFP<1>, |
| 507 | SDTCVecEltisVT<1, f64>, SDTCisInt<2>]>; |
Elena Demikhovsky | 0f37093 | 2015-07-13 13:26:20 +0000 | [diff] [blame] | 508 | def SDTFloatToIntRnd: SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>, |
| 509 | SDTCisInt<0>, SDTCVecEltisVT<1, f32>]>; |
Asaf Badouh | 2744d21 | 2015-09-20 14:31:19 +0000 | [diff] [blame] | 510 | def SDTSFloatToIntRnd: SDTypeProfile<1, 2, [SDTCisInt<0>, SDTCisFP<1>, |
| 511 | SDTCVecEltisVT<1, f32>, SDTCisInt<2>]>; |
Elena Demikhovsky | 0f37093 | 2015-07-13 13:26:20 +0000 | [diff] [blame] | 512 | def SDTVintToFPRound: SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>, |
| 513 | SDTCisFP<0>, SDTCVecEltisVT<1, i32>, |
| 514 | SDTCisInt<2>]>; |
| 515 | def SDTVlongToFPRound: SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>, |
| 516 | SDTCisFP<0>, SDTCVecEltisVT<1, i64>, |
| 517 | SDTCisInt<2>]>; |
| 518 | |
| 519 | def SDTVFPToIntRound: SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>, |
| 520 | SDTCisFP<1>, SDTCVecEltisVT<0, i32>, |
| 521 | SDTCisInt<2>]>; |
| 522 | def SDTVFPToLongRound: SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>, |
| 523 | SDTCisFP<1>, SDTCVecEltisVT<0, i64>, |
| 524 | SDTCisInt<2>]>; |
| 525 | |
| 526 | // Scalar |
| 527 | def X86SintToFpRnd : SDNode<"X86ISD::SINT_TO_FP_RND", SDTintToFPRound>; |
| 528 | def X86UintToFpRnd : SDNode<"X86ISD::UINT_TO_FP_RND", SDTintToFPRound>; |
| 529 | |
Asaf Badouh | 2744d21 | 2015-09-20 14:31:19 +0000 | [diff] [blame] | 530 | def X86cvttss2IntRnd : SDNode<"X86ISD::FP_TO_SINT_RND", SDTSFloatToIntRnd>; |
| 531 | def X86cvttss2UIntRnd : SDNode<"X86ISD::FP_TO_UINT_RND", SDTSFloatToIntRnd>; |
| 532 | def X86cvttsd2IntRnd : SDNode<"X86ISD::FP_TO_SINT_RND", SDTSDoubleToIntRnd>; |
| 533 | def X86cvttsd2UIntRnd : SDNode<"X86ISD::FP_TO_UINT_RND", SDTSDoubleToIntRnd>; |
Elena Demikhovsky | 0f37093 | 2015-07-13 13:26:20 +0000 | [diff] [blame] | 534 | // Vector with rounding mode |
| 535 | |
| 536 | // cvtt fp-to-int staff |
| 537 | def X86VFpToSintRnd : SDNode<"ISD::FP_TO_SINT", SDTVFPToIntRound>; |
| 538 | def X86VFpToUintRnd : SDNode<"ISD::FP_TO_UINT", SDTVFPToIntRound>; |
| 539 | def X86VFpToSlongRnd : SDNode<"ISD::FP_TO_SINT", SDTVFPToLongRound>; |
| 540 | def X86VFpToUlongRnd : SDNode<"ISD::FP_TO_UINT", SDTVFPToLongRound>; |
| 541 | |
| 542 | def X86VSintToFpRnd : SDNode<"ISD::SINT_TO_FP", SDTVintToFPRound>; |
| 543 | def X86VUintToFpRnd : SDNode<"ISD::UINT_TO_FP", SDTVintToFPRound>; |
| 544 | def X86VSlongToFpRnd : SDNode<"ISD::SINT_TO_FP", SDTVlongToFPRound>; |
| 545 | def X86VUlongToFpRnd : SDNode<"ISD::UINT_TO_FP", SDTVlongToFPRound>; |
| 546 | |
| 547 | // cvt fp-to-int staff |
| 548 | def X86cvtps2IntRnd : SDNode<"X86ISD::FP_TO_SINT_RND", SDTFloatToIntRnd>; |
| 549 | def X86cvtps2UIntRnd : SDNode<"X86ISD::FP_TO_UINT_RND", SDTFloatToIntRnd>; |
| 550 | def X86cvtpd2IntRnd : SDNode<"X86ISD::FP_TO_SINT_RND", SDTDoubleToIntRnd>; |
| 551 | def X86cvtpd2UIntRnd : SDNode<"X86ISD::FP_TO_UINT_RND", SDTDoubleToIntRnd>; |
| 552 | |
| 553 | // Vector without rounding mode |
| 554 | def X86cvtps2Int : SDNode<"X86ISD::FP_TO_SINT_RND", SDTFloatToInt>; |
| 555 | def X86cvtps2UInt : SDNode<"X86ISD::FP_TO_UINT_RND", SDTFloatToInt>; |
| 556 | def X86cvtpd2Int : SDNode<"X86ISD::FP_TO_SINT_RND", SDTDoubleToInt>; |
| 557 | def X86cvtpd2UInt : SDNode<"X86ISD::FP_TO_UINT_RND", SDTDoubleToInt>; |
| 558 | |
Asaf Badouh | 7c52245 | 2015-10-22 14:01:16 +0000 | [diff] [blame] | 559 | def X86cvtph2ps : SDNode<"ISD::FP16_TO_FP", |
| 560 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>, |
| 561 | SDTCVecEltisVT<0, f32>, |
| 562 | SDTCVecEltisVT<1, i16>, |
Craig Topper | 9d1deb4 | 2015-11-26 18:31:19 +0000 | [diff] [blame] | 563 | SDTCisFP<0>, |
| 564 | SDTCisVT<2, i32>]> >; |
Asaf Badouh | 7c52245 | 2015-10-22 14:01:16 +0000 | [diff] [blame] | 565 | |
Asaf Badouh | c7cb880 | 2015-10-27 15:37:17 +0000 | [diff] [blame] | 566 | def X86cvtps2ph : SDNode<"ISD::FP_TO_FP16", |
| 567 | SDTypeProfile<1, 3, [SDTCisVec<0>, SDTCisVec<1>, |
| 568 | SDTCVecEltisVT<0, i16>, |
| 569 | SDTCVecEltisVT<1, f32>, |
Craig Topper | 9d1deb4 | 2015-11-26 18:31:19 +0000 | [diff] [blame] | 570 | SDTCisFP<1>, SDTCisVT<2, i32>, |
| 571 | SDTCisVT<3, i32>]> >; |
Elena Demikhovsky | 0f37093 | 2015-07-13 13:26:20 +0000 | [diff] [blame] | 572 | def X86vfpextRnd : SDNode<"X86ISD::VFPEXT", |
| 573 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>, |
| 574 | SDTCisFP<0>, SDTCisFP<1>, |
Craig Topper | 9d1deb4 | 2015-11-26 18:31:19 +0000 | [diff] [blame] | 575 | SDTCVecEltisVT<0, f64>, |
| 576 | SDTCVecEltisVT<1, f32>, |
Elena Demikhovsky | 0f37093 | 2015-07-13 13:26:20 +0000 | [diff] [blame] | 577 | SDTCisOpSmallerThanOp<1, 0>, |
Craig Topper | 9d1deb4 | 2015-11-26 18:31:19 +0000 | [diff] [blame] | 578 | SDTCisVT<2, i32>]>>; |
Elena Demikhovsky | 0f37093 | 2015-07-13 13:26:20 +0000 | [diff] [blame] | 579 | def X86vfproundRnd: SDNode<"X86ISD::VFPROUND", |
| 580 | SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>, |
| 581 | SDTCisFP<0>, SDTCisFP<1>, |
| 582 | SDTCVecEltisVT<0, f32>, |
| 583 | SDTCVecEltisVT<1, f64>, |
Craig Topper | 9d1deb4 | 2015-11-26 18:31:19 +0000 | [diff] [blame] | 584 | SDTCisOpSmallerThanOp<0, 1>, |
| 585 | SDTCisVT<2, i32>]>>; |
Igor Breger | abe4a79 | 2015-06-14 12:44:55 +0000 | [diff] [blame] | 586 | |
Igor Breger | 756c289 | 2015-12-27 13:56:16 +0000 | [diff] [blame] | 587 | def X86cvt2mask : SDNode<"X86ISD::CVT2MASK", SDTIntTruncOp>; |
| 588 | |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 589 | //===----------------------------------------------------------------------===// |
| 590 | // SSE Complex Patterns |
| 591 | //===----------------------------------------------------------------------===// |
| 592 | |
| 593 | // These are 'extloads' from a scalar to the low element of a vector, zeroing |
| 594 | // the top elements. These are used for the SSE 'ss' and 'sd' instruction |
| 595 | // forms. |
Sanjay Patel | 85030aa | 2015-10-13 16:23:00 +0000 | [diff] [blame] | 596 | def sse_load_f32 : ComplexPattern<v4f32, 5, "selectScalarSSELoad", [], |
Chris Lattner | 0e023ea | 2010-09-21 20:31:19 +0000 | [diff] [blame] | 597 | [SDNPHasChain, SDNPMayLoad, SDNPMemOperand, |
| 598 | SDNPWantRoot]>; |
Sanjay Patel | 85030aa | 2015-10-13 16:23:00 +0000 | [diff] [blame] | 599 | def sse_load_f64 : ComplexPattern<v2f64, 5, "selectScalarSSELoad", [], |
Chris Lattner | 0e023ea | 2010-09-21 20:31:19 +0000 | [diff] [blame] | 600 | [SDNPHasChain, SDNPMayLoad, SDNPMemOperand, |
| 601 | SDNPWantRoot]>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 602 | |
| 603 | def ssmem : Operand<v4f32> { |
| 604 | let PrintMethod = "printf32mem"; |
| 605 | let MIOperandInfo = (ops ptr_rc, i8imm, ptr_rc_nosp, i32imm, i8imm); |
Craig Topper | 6269f49 | 2013-08-26 00:39:04 +0000 | [diff] [blame] | 606 | let ParserMatchClass = X86Mem32AsmOperand; |
Benjamin Kramer | 9654eef | 2011-07-14 21:47:22 +0000 | [diff] [blame] | 607 | let OperandType = "OPERAND_MEMORY"; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 608 | } |
| 609 | def sdmem : Operand<v2f64> { |
| 610 | let PrintMethod = "printf64mem"; |
| 611 | let MIOperandInfo = (ops ptr_rc, i8imm, ptr_rc_nosp, i32imm, i8imm); |
Craig Topper | 6269f49 | 2013-08-26 00:39:04 +0000 | [diff] [blame] | 612 | let ParserMatchClass = X86Mem64AsmOperand; |
Benjamin Kramer | 9654eef | 2011-07-14 21:47:22 +0000 | [diff] [blame] | 613 | let OperandType = "OPERAND_MEMORY"; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 614 | } |
| 615 | |
| 616 | //===----------------------------------------------------------------------===// |
| 617 | // SSE pattern fragments |
| 618 | //===----------------------------------------------------------------------===// |
| 619 | |
Bruno Cardoso Lopes | 160be29 | 2010-08-13 20:39:01 +0000 | [diff] [blame] | 620 | // 128-bit load pattern fragments |
Craig Topper | 0d8e67a | 2012-01-24 03:03:17 +0000 | [diff] [blame] | 621 | // NOTE: all 128-bit integer vector loads are promoted to v2i64 |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 622 | def loadv4f32 : PatFrag<(ops node:$ptr), (v4f32 (load node:$ptr))>; |
| 623 | def loadv2f64 : PatFrag<(ops node:$ptr), (v2f64 (load node:$ptr))>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 624 | def loadv2i64 : PatFrag<(ops node:$ptr), (v2i64 (load node:$ptr))>; |
| 625 | |
Bruno Cardoso Lopes | 160be29 | 2010-08-13 20:39:01 +0000 | [diff] [blame] | 626 | // 256-bit load pattern fragments |
Craig Topper | 0d8e67a | 2012-01-24 03:03:17 +0000 | [diff] [blame] | 627 | // NOTE: all 256-bit integer vector loads are promoted to v4i64 |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 628 | def loadv8f32 : PatFrag<(ops node:$ptr), (v8f32 (load node:$ptr))>; |
| 629 | def loadv4f64 : PatFrag<(ops node:$ptr), (v4f64 (load node:$ptr))>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 630 | def loadv4i64 : PatFrag<(ops node:$ptr), (v4i64 (load node:$ptr))>; |
| 631 | |
Elena Demikhovsky | cf5b145 | 2013-08-11 07:55:09 +0000 | [diff] [blame] | 632 | // 512-bit load pattern fragments |
| 633 | def loadv16f32 : PatFrag<(ops node:$ptr), (v16f32 (load node:$ptr))>; |
| 634 | def loadv8f64 : PatFrag<(ops node:$ptr), (v8f64 (load node:$ptr))>; |
Robert Khasanov | 7ca7df0 | 2014-08-04 14:35:15 +0000 | [diff] [blame] | 635 | def loadv64i8 : PatFrag<(ops node:$ptr), (v64i8 (load node:$ptr))>; |
| 636 | def loadv32i16 : PatFrag<(ops node:$ptr), (v32i16 (load node:$ptr))>; |
Elena Demikhovsky | 1f3ed41 | 2013-10-22 09:19:28 +0000 | [diff] [blame] | 637 | def loadv16i32 : PatFrag<(ops node:$ptr), (v16i32 (load node:$ptr))>; |
Elena Demikhovsky | cf5b145 | 2013-08-11 07:55:09 +0000 | [diff] [blame] | 638 | def loadv8i64 : PatFrag<(ops node:$ptr), (v8i64 (load node:$ptr))>; |
| 639 | |
| 640 | // 128-/256-/512-bit extload pattern fragments |
Michael Liao | 400f7ef | 2012-09-10 18:33:51 +0000 | [diff] [blame] | 641 | def extloadv2f32 : PatFrag<(ops node:$ptr), (v2f64 (extloadvf32 node:$ptr))>; |
| 642 | def extloadv4f32 : PatFrag<(ops node:$ptr), (v4f64 (extloadvf32 node:$ptr))>; |
Elena Demikhovsky | cf5b145 | 2013-08-11 07:55:09 +0000 | [diff] [blame] | 643 | def extloadv8f32 : PatFrag<(ops node:$ptr), (v8f64 (extloadvf32 node:$ptr))>; |
Michael Liao | 400f7ef | 2012-09-10 18:33:51 +0000 | [diff] [blame] | 644 | |
Sanjay Patel | b811c1d | 2015-02-17 20:08:21 +0000 | [diff] [blame] | 645 | // These are needed to match a scalar load that is used in a vector-only |
| 646 | // math instruction such as the FP logical ops: andps, andnps, orps, xorps. |
| 647 | // The memory operand is required to be a 128-bit load, so it must be converted |
| 648 | // from a vector to a scalar. |
| 649 | def loadf32_128 : PatFrag<(ops node:$ptr), |
Matt Arsenault | fbd9bbf | 2015-12-11 19:20:16 +0000 | [diff] [blame] | 650 | (f32 (extractelt (loadv4f32 node:$ptr), (iPTR 0)))>; |
Sanjay Patel | b811c1d | 2015-02-17 20:08:21 +0000 | [diff] [blame] | 651 | def loadf64_128 : PatFrag<(ops node:$ptr), |
Matt Arsenault | fbd9bbf | 2015-12-11 19:20:16 +0000 | [diff] [blame] | 652 | (f64 (extractelt (loadv2f64 node:$ptr), (iPTR 0)))>; |
Sanjay Patel | b811c1d | 2015-02-17 20:08:21 +0000 | [diff] [blame] | 653 | |
Bruno Cardoso Lopes | 03d6002 | 2011-09-13 19:33:03 +0000 | [diff] [blame] | 654 | // Like 'store', but always requires 128-bit vector alignment. |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 655 | def alignedstore : PatFrag<(ops node:$val, node:$ptr), |
| 656 | (store node:$val, node:$ptr), [{ |
| 657 | return cast<StoreSDNode>(N)->getAlignment() >= 16; |
| 658 | }]>; |
| 659 | |
Bruno Cardoso Lopes | 03d6002 | 2011-09-13 19:33:03 +0000 | [diff] [blame] | 660 | // Like 'store', but always requires 256-bit vector alignment. |
| 661 | def alignedstore256 : PatFrag<(ops node:$val, node:$ptr), |
| 662 | (store node:$val, node:$ptr), [{ |
| 663 | return cast<StoreSDNode>(N)->getAlignment() >= 32; |
| 664 | }]>; |
| 665 | |
Elena Demikhovsky | cf5b145 | 2013-08-11 07:55:09 +0000 | [diff] [blame] | 666 | // Like 'store', but always requires 512-bit vector alignment. |
| 667 | def alignedstore512 : PatFrag<(ops node:$val, node:$ptr), |
| 668 | (store node:$val, node:$ptr), [{ |
| 669 | return cast<StoreSDNode>(N)->getAlignment() >= 64; |
| 670 | }]>; |
| 671 | |
Bruno Cardoso Lopes | 03d6002 | 2011-09-13 19:33:03 +0000 | [diff] [blame] | 672 | // Like 'load', but always requires 128-bit vector alignment. |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 673 | def alignedload : PatFrag<(ops node:$ptr), (load node:$ptr), [{ |
| 674 | return cast<LoadSDNode>(N)->getAlignment() >= 16; |
| 675 | }]>; |
| 676 | |
Chad Rosier | a281afc | 2012-03-09 02:00:48 +0000 | [diff] [blame] | 677 | // Like 'X86vzload', but always requires 128-bit vector alignment. |
| 678 | def alignedX86vzload : PatFrag<(ops node:$ptr), (X86vzload node:$ptr), [{ |
| 679 | return cast<MemSDNode>(N)->getAlignment() >= 16; |
| 680 | }]>; |
| 681 | |
Bruno Cardoso Lopes | 03d6002 | 2011-09-13 19:33:03 +0000 | [diff] [blame] | 682 | // Like 'load', but always requires 256-bit vector alignment. |
| 683 | def alignedload256 : PatFrag<(ops node:$ptr), (load node:$ptr), [{ |
| 684 | return cast<LoadSDNode>(N)->getAlignment() >= 32; |
| 685 | }]>; |
| 686 | |
Elena Demikhovsky | cf5b145 | 2013-08-11 07:55:09 +0000 | [diff] [blame] | 687 | // Like 'load', but always requires 512-bit vector alignment. |
| 688 | def alignedload512 : PatFrag<(ops node:$ptr), (load node:$ptr), [{ |
| 689 | return cast<LoadSDNode>(N)->getAlignment() >= 64; |
| 690 | }]>; |
| 691 | |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 692 | def alignedloadfsf32 : PatFrag<(ops node:$ptr), |
| 693 | (f32 (alignedload node:$ptr))>; |
| 694 | def alignedloadfsf64 : PatFrag<(ops node:$ptr), |
| 695 | (f64 (alignedload node:$ptr))>; |
Bruno Cardoso Lopes | 160be29 | 2010-08-13 20:39:01 +0000 | [diff] [blame] | 696 | |
| 697 | // 128-bit aligned load pattern fragments |
Craig Topper | 0d8e67a | 2012-01-24 03:03:17 +0000 | [diff] [blame] | 698 | // NOTE: all 128-bit integer vector loads are promoted to v2i64 |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 699 | def alignedloadv4f32 : PatFrag<(ops node:$ptr), |
| 700 | (v4f32 (alignedload node:$ptr))>; |
| 701 | def alignedloadv2f64 : PatFrag<(ops node:$ptr), |
| 702 | (v2f64 (alignedload node:$ptr))>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 703 | def alignedloadv2i64 : PatFrag<(ops node:$ptr), |
| 704 | (v2i64 (alignedload node:$ptr))>; |
| 705 | |
Bruno Cardoso Lopes | 160be29 | 2010-08-13 20:39:01 +0000 | [diff] [blame] | 706 | // 256-bit aligned load pattern fragments |
Craig Topper | 0d8e67a | 2012-01-24 03:03:17 +0000 | [diff] [blame] | 707 | // NOTE: all 256-bit integer vector loads are promoted to v4i64 |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 708 | def alignedloadv8f32 : PatFrag<(ops node:$ptr), |
Bruno Cardoso Lopes | 03d6002 | 2011-09-13 19:33:03 +0000 | [diff] [blame] | 709 | (v8f32 (alignedload256 node:$ptr))>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 710 | def alignedloadv4f64 : PatFrag<(ops node:$ptr), |
Bruno Cardoso Lopes | 03d6002 | 2011-09-13 19:33:03 +0000 | [diff] [blame] | 711 | (v4f64 (alignedload256 node:$ptr))>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 712 | def alignedloadv4i64 : PatFrag<(ops node:$ptr), |
Bruno Cardoso Lopes | 03d6002 | 2011-09-13 19:33:03 +0000 | [diff] [blame] | 713 | (v4i64 (alignedload256 node:$ptr))>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 714 | |
Elena Demikhovsky | cf5b145 | 2013-08-11 07:55:09 +0000 | [diff] [blame] | 715 | // 512-bit aligned load pattern fragments |
| 716 | def alignedloadv16f32 : PatFrag<(ops node:$ptr), |
| 717 | (v16f32 (alignedload512 node:$ptr))>; |
Elena Demikhovsky | 3ce8dbb | 2013-08-18 13:08:57 +0000 | [diff] [blame] | 718 | def alignedloadv16i32 : PatFrag<(ops node:$ptr), |
| 719 | (v16i32 (alignedload512 node:$ptr))>; |
Elena Demikhovsky | cf5b145 | 2013-08-11 07:55:09 +0000 | [diff] [blame] | 720 | def alignedloadv8f64 : PatFrag<(ops node:$ptr), |
| 721 | (v8f64 (alignedload512 node:$ptr))>; |
Elena Demikhovsky | cf5b145 | 2013-08-11 07:55:09 +0000 | [diff] [blame] | 722 | def alignedloadv8i64 : PatFrag<(ops node:$ptr), |
| 723 | (v8i64 (alignedload512 node:$ptr))>; |
| 724 | |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 725 | // Like 'load', but uses special alignment checks suitable for use in |
| 726 | // memory operands in most SSE instructions, which are required to |
| 727 | // be naturally aligned on some targets but not on others. If the subtarget |
| 728 | // allows unaligned accesses, match any load, though this may require |
| 729 | // setting a feature bit in the processor (on startup, for example). |
| 730 | // Opteron 10h and later implement such a feature. |
| 731 | def memop : PatFrag<(ops node:$ptr), (load node:$ptr), [{ |
Sanjay Patel | ffd039b | 2015-02-03 17:13:04 +0000 | [diff] [blame] | 732 | return Subtarget->hasSSEUnalignedMem() |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 733 | || cast<LoadSDNode>(N)->getAlignment() >= 16; |
| 734 | }]>; |
| 735 | |
| 736 | def memopfsf32 : PatFrag<(ops node:$ptr), (f32 (memop node:$ptr))>; |
| 737 | def memopfsf64 : PatFrag<(ops node:$ptr), (f64 (memop node:$ptr))>; |
Bruno Cardoso Lopes | 160be29 | 2010-08-13 20:39:01 +0000 | [diff] [blame] | 738 | |
| 739 | // 128-bit memop pattern fragments |
Craig Topper | 0d8e67a | 2012-01-24 03:03:17 +0000 | [diff] [blame] | 740 | // NOTE: all 128-bit integer vector loads are promoted to v2i64 |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 741 | def memopv4f32 : PatFrag<(ops node:$ptr), (v4f32 (memop node:$ptr))>; |
| 742 | def memopv2f64 : PatFrag<(ops node:$ptr), (v2f64 (memop node:$ptr))>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 743 | def memopv2i64 : PatFrag<(ops node:$ptr), (v2i64 (memop node:$ptr))>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 744 | |
Sanjay Patel | b811c1d | 2015-02-17 20:08:21 +0000 | [diff] [blame] | 745 | // These are needed to match a scalar memop that is used in a vector-only |
| 746 | // math instruction such as the FP logical ops: andps, andnps, orps, xorps. |
| 747 | // The memory operand is required to be a 128-bit load, so it must be converted |
| 748 | // from a vector to a scalar. |
| 749 | def memopfsf32_128 : PatFrag<(ops node:$ptr), |
Matt Arsenault | fbd9bbf | 2015-12-11 19:20:16 +0000 | [diff] [blame] | 750 | (f32 (extractelt (memopv4f32 node:$ptr), (iPTR 0)))>; |
Sanjay Patel | b811c1d | 2015-02-17 20:08:21 +0000 | [diff] [blame] | 751 | def memopfsf64_128 : PatFrag<(ops node:$ptr), |
Matt Arsenault | fbd9bbf | 2015-12-11 19:20:16 +0000 | [diff] [blame] | 752 | (f64 (extractelt (memopv2f64 node:$ptr), (iPTR 0)))>; |
Sanjay Patel | b811c1d | 2015-02-17 20:08:21 +0000 | [diff] [blame] | 753 | |
| 754 | |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 755 | // SSSE3 uses MMX registers for some instructions. They aren't aligned on a |
| 756 | // 16-byte boundary. |
| 757 | // FIXME: 8 byte alignment for mmx reads is not required |
| 758 | def memop64 : PatFrag<(ops node:$ptr), (load node:$ptr), [{ |
| 759 | return cast<LoadSDNode>(N)->getAlignment() >= 8; |
| 760 | }]>; |
| 761 | |
Dale Johannesen | dd224d2 | 2010-09-30 23:57:10 +0000 | [diff] [blame] | 762 | def memopmmx : PatFrag<(ops node:$ptr), (x86mmx (memop64 node:$ptr))>; |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 763 | |
Elena Demikhovsky | 6a1a357 | 2015-06-28 10:53:29 +0000 | [diff] [blame] | 764 | def mgatherv4i32 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 765 | (masked_gather node:$src1, node:$src2, node:$src3) , [{ |
| 766 | if (MaskedGatherSDNode *Mgt = dyn_cast<MaskedGatherSDNode>(N)) |
| 767 | return (Mgt->getIndex().getValueType() == MVT::v4i32 || |
| 768 | Mgt->getBasePtr().getValueType() == MVT::v4i32); |
| 769 | return false; |
| 770 | }]>; |
| 771 | |
Elena Demikhovsky | e1eda8a | 2015-04-30 08:38:48 +0000 | [diff] [blame] | 772 | def mgatherv8i32 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 773 | (masked_gather node:$src1, node:$src2, node:$src3) , [{ |
| 774 | if (MaskedGatherSDNode *Mgt = dyn_cast<MaskedGatherSDNode>(N)) |
| 775 | return (Mgt->getIndex().getValueType() == MVT::v8i32 || |
| 776 | Mgt->getBasePtr().getValueType() == MVT::v8i32); |
| 777 | return false; |
| 778 | }]>; |
| 779 | |
Elena Demikhovsky | 6a1a357 | 2015-06-28 10:53:29 +0000 | [diff] [blame] | 780 | def mgatherv2i64 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 781 | (masked_gather node:$src1, node:$src2, node:$src3) , [{ |
| 782 | if (MaskedGatherSDNode *Mgt = dyn_cast<MaskedGatherSDNode>(N)) |
| 783 | return (Mgt->getIndex().getValueType() == MVT::v2i64 || |
| 784 | Mgt->getBasePtr().getValueType() == MVT::v2i64); |
| 785 | return false; |
| 786 | }]>; |
| 787 | def mgatherv4i64 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 788 | (masked_gather node:$src1, node:$src2, node:$src3) , [{ |
| 789 | if (MaskedGatherSDNode *Mgt = dyn_cast<MaskedGatherSDNode>(N)) |
| 790 | return (Mgt->getIndex().getValueType() == MVT::v4i64 || |
| 791 | Mgt->getBasePtr().getValueType() == MVT::v4i64); |
| 792 | return false; |
| 793 | }]>; |
Elena Demikhovsky | e1eda8a | 2015-04-30 08:38:48 +0000 | [diff] [blame] | 794 | def mgatherv8i64 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 795 | (masked_gather node:$src1, node:$src2, node:$src3) , [{ |
| 796 | if (MaskedGatherSDNode *Mgt = dyn_cast<MaskedGatherSDNode>(N)) |
| 797 | return (Mgt->getIndex().getValueType() == MVT::v8i64 || |
| 798 | Mgt->getBasePtr().getValueType() == MVT::v8i64); |
| 799 | return false; |
| 800 | }]>; |
| 801 | def mgatherv16i32 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 802 | (masked_gather node:$src1, node:$src2, node:$src3) , [{ |
| 803 | if (MaskedGatherSDNode *Mgt = dyn_cast<MaskedGatherSDNode>(N)) |
| 804 | return (Mgt->getIndex().getValueType() == MVT::v16i32 || |
| 805 | Mgt->getBasePtr().getValueType() == MVT::v16i32); |
| 806 | return false; |
| 807 | }]>; |
| 808 | |
Elena Demikhovsky | 30bc4ca | 2015-06-29 12:14:24 +0000 | [diff] [blame] | 809 | def mscatterv2i64 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 810 | (masked_scatter node:$src1, node:$src2, node:$src3) , [{ |
| 811 | if (MaskedScatterSDNode *Sc = dyn_cast<MaskedScatterSDNode>(N)) |
| 812 | return (Sc->getIndex().getValueType() == MVT::v2i64 || |
| 813 | Sc->getBasePtr().getValueType() == MVT::v2i64); |
| 814 | return false; |
| 815 | }]>; |
| 816 | |
| 817 | def mscatterv4i32 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 818 | (masked_scatter node:$src1, node:$src2, node:$src3) , [{ |
| 819 | if (MaskedScatterSDNode *Sc = dyn_cast<MaskedScatterSDNode>(N)) |
| 820 | return (Sc->getIndex().getValueType() == MVT::v4i32 || |
| 821 | Sc->getBasePtr().getValueType() == MVT::v4i32); |
| 822 | return false; |
| 823 | }]>; |
| 824 | |
| 825 | def mscatterv4i64 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 826 | (masked_scatter node:$src1, node:$src2, node:$src3) , [{ |
| 827 | if (MaskedScatterSDNode *Sc = dyn_cast<MaskedScatterSDNode>(N)) |
| 828 | return (Sc->getIndex().getValueType() == MVT::v4i64 || |
| 829 | Sc->getBasePtr().getValueType() == MVT::v4i64); |
| 830 | return false; |
| 831 | }]>; |
| 832 | |
Elena Demikhovsky | e1eda8a | 2015-04-30 08:38:48 +0000 | [diff] [blame] | 833 | def mscatterv8i32 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 834 | (masked_scatter node:$src1, node:$src2, node:$src3) , [{ |
| 835 | if (MaskedScatterSDNode *Sc = dyn_cast<MaskedScatterSDNode>(N)) |
| 836 | return (Sc->getIndex().getValueType() == MVT::v8i32 || |
| 837 | Sc->getBasePtr().getValueType() == MVT::v8i32); |
| 838 | return false; |
| 839 | }]>; |
| 840 | |
| 841 | def mscatterv8i64 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 842 | (masked_scatter node:$src1, node:$src2, node:$src3) , [{ |
| 843 | if (MaskedScatterSDNode *Sc = dyn_cast<MaskedScatterSDNode>(N)) |
| 844 | return (Sc->getIndex().getValueType() == MVT::v8i64 || |
| 845 | Sc->getBasePtr().getValueType() == MVT::v8i64); |
| 846 | return false; |
| 847 | }]>; |
| 848 | def mscatterv16i32 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 849 | (masked_scatter node:$src1, node:$src2, node:$src3) , [{ |
| 850 | if (MaskedScatterSDNode *Sc = dyn_cast<MaskedScatterSDNode>(N)) |
| 851 | return (Sc->getIndex().getValueType() == MVT::v16i32 || |
| 852 | Sc->getBasePtr().getValueType() == MVT::v16i32); |
| 853 | return false; |
| 854 | }]>; |
| 855 | |
Bruno Cardoso Lopes | 160be29 | 2010-08-13 20:39:01 +0000 | [diff] [blame] | 856 | // 128-bit bitconvert pattern fragments |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 857 | def bc_v4f32 : PatFrag<(ops node:$in), (v4f32 (bitconvert node:$in))>; |
| 858 | def bc_v2f64 : PatFrag<(ops node:$in), (v2f64 (bitconvert node:$in))>; |
| 859 | def bc_v16i8 : PatFrag<(ops node:$in), (v16i8 (bitconvert node:$in))>; |
| 860 | def bc_v8i16 : PatFrag<(ops node:$in), (v8i16 (bitconvert node:$in))>; |
| 861 | def bc_v4i32 : PatFrag<(ops node:$in), (v4i32 (bitconvert node:$in))>; |
| 862 | def bc_v2i64 : PatFrag<(ops node:$in), (v2i64 (bitconvert node:$in))>; |
| 863 | |
Bruno Cardoso Lopes | 160be29 | 2010-08-13 20:39:01 +0000 | [diff] [blame] | 864 | // 256-bit bitconvert pattern fragments |
Craig Topper | 682b850 | 2011-11-02 04:42:13 +0000 | [diff] [blame] | 865 | def bc_v32i8 : PatFrag<(ops node:$in), (v32i8 (bitconvert node:$in))>; |
| 866 | def bc_v16i16 : PatFrag<(ops node:$in), (v16i16 (bitconvert node:$in))>; |
Bruno Cardoso Lopes | e3acfd4 | 2010-07-21 23:53:50 +0000 | [diff] [blame] | 867 | def bc_v8i32 : PatFrag<(ops node:$in), (v8i32 (bitconvert node:$in))>; |
Bruno Cardoso Lopes | 1021b4a | 2011-07-13 01:15:33 +0000 | [diff] [blame] | 868 | def bc_v4i64 : PatFrag<(ops node:$in), (v4i64 (bitconvert node:$in))>; |
Elena Demikhovsky | 3629b4a | 2014-01-06 08:45:54 +0000 | [diff] [blame] | 869 | def bc_v8f32 : PatFrag<(ops node:$in), (v8f32 (bitconvert node:$in))>; |
Bruno Cardoso Lopes | e3acfd4 | 2010-07-21 23:53:50 +0000 | [diff] [blame] | 870 | |
Craig Topper | 8c92962 | 2013-08-16 06:07:34 +0000 | [diff] [blame] | 871 | // 512-bit bitconvert pattern fragments |
| 872 | def bc_v16i32 : PatFrag<(ops node:$in), (v16i32 (bitconvert node:$in))>; |
| 873 | def bc_v8i64 : PatFrag<(ops node:$in), (v8i64 (bitconvert node:$in))>; |
Elena Demikhovsky | de3f751 | 2014-01-01 15:12:34 +0000 | [diff] [blame] | 874 | def bc_v8f64 : PatFrag<(ops node:$in), (v8f64 (bitconvert node:$in))>; |
| 875 | def bc_v16f32 : PatFrag<(ops node:$in), (v16f32 (bitconvert node:$in))>; |
Craig Topper | 8c92962 | 2013-08-16 06:07:34 +0000 | [diff] [blame] | 876 | |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 877 | def vzmovl_v2i64 : PatFrag<(ops node:$src), |
| 878 | (bitconvert (v2i64 (X86vzmovl |
| 879 | (v2i64 (scalar_to_vector (loadi64 node:$src))))))>; |
| 880 | def vzmovl_v4i32 : PatFrag<(ops node:$src), |
| 881 | (bitconvert (v4i32 (X86vzmovl |
| 882 | (v4i32 (scalar_to_vector (loadi32 node:$src))))))>; |
| 883 | |
| 884 | def vzload_v2i64 : PatFrag<(ops node:$src), |
| 885 | (bitconvert (v2i64 (X86vzload node:$src)))>; |
| 886 | |
| 887 | |
| 888 | def fp32imm0 : PatLeaf<(f32 fpimm), [{ |
| 889 | return N->isExactlyValue(+0.0); |
| 890 | }]>; |
| 891 | |
Elena Demikhovsky | de3f751 | 2014-01-01 15:12:34 +0000 | [diff] [blame] | 892 | def I8Imm : SDNodeXForm<imm, [{ |
| 893 | // Transformation function: get the low 8 bits. |
Sergey Dmitrouk | 842a51b | 2015-04-28 14:05:47 +0000 | [diff] [blame] | 894 | return getI8Imm((uint8_t)N->getZExtValue(), SDLoc(N)); |
Elena Demikhovsky | de3f751 | 2014-01-01 15:12:34 +0000 | [diff] [blame] | 895 | }]>; |
| 896 | |
| 897 | def FROUND_NO_EXC : ImmLeaf<i32, [{ return Imm == 8; }]>; |
Adam Nemet | 50b83f0 | 2014-08-14 17:13:26 +0000 | [diff] [blame] | 898 | def FROUND_CURRENT : ImmLeaf<i32, [{ |
| 899 | return Imm == X86::STATIC_ROUNDING::CUR_DIRECTION; |
| 900 | }]>; |
Elena Demikhovsky | de3f751 | 2014-01-01 15:12:34 +0000 | [diff] [blame] | 901 | |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 902 | // BYTE_imm - Transform bit immediates into byte immediates. |
| 903 | def BYTE_imm : SDNodeXForm<imm, [{ |
| 904 | // Transformation function: imm >> 3 |
Sergey Dmitrouk | 842a51b | 2015-04-28 14:05:47 +0000 | [diff] [blame] | 905 | return getI32Imm(N->getZExtValue() >> 3, SDLoc(N)); |
David Greene | 03264ef | 2010-07-12 23:41:28 +0000 | [diff] [blame] | 906 | }]>; |
| 907 | |
Elena Demikhovsky | 67b05fc | 2013-07-31 11:35:14 +0000 | [diff] [blame] | 908 | // EXTRACT_get_vextract128_imm xform function: convert extract_subvector index |
| 909 | // to VEXTRACTF128/VEXTRACTI128 imm. |
| 910 | def EXTRACT_get_vextract128_imm : SDNodeXForm<extract_subvector, [{ |
Sergey Dmitrouk | 842a51b | 2015-04-28 14:05:47 +0000 | [diff] [blame] | 911 | return getI8Imm(X86::getExtractVEXTRACT128Immediate(N), SDLoc(N)); |
David Greene | c4da110 | 2011-02-03 15:50:00 +0000 | [diff] [blame] | 912 | }]>; |
| 913 | |
Elena Demikhovsky | 67b05fc | 2013-07-31 11:35:14 +0000 | [diff] [blame] | 914 | // INSERT_get_vinsert128_imm xform function: convert insert_subvector index to |
| 915 | // VINSERTF128/VINSERTI128 imm. |
| 916 | def INSERT_get_vinsert128_imm : SDNodeXForm<insert_subvector, [{ |
Sergey Dmitrouk | 842a51b | 2015-04-28 14:05:47 +0000 | [diff] [blame] | 917 | return getI8Imm(X86::getInsertVINSERT128Immediate(N), SDLoc(N)); |
David Greene | 653f1ee | 2011-02-04 16:08:29 +0000 | [diff] [blame] | 918 | }]>; |
| 919 | |
Elena Demikhovsky | 67b05fc | 2013-07-31 11:35:14 +0000 | [diff] [blame] | 920 | // EXTRACT_get_vextract256_imm xform function: convert extract_subvector index |
| 921 | // to VEXTRACTF64x4 imm. |
| 922 | def EXTRACT_get_vextract256_imm : SDNodeXForm<extract_subvector, [{ |
Sergey Dmitrouk | 842a51b | 2015-04-28 14:05:47 +0000 | [diff] [blame] | 923 | return getI8Imm(X86::getExtractVEXTRACT256Immediate(N), SDLoc(N)); |
Elena Demikhovsky | 67b05fc | 2013-07-31 11:35:14 +0000 | [diff] [blame] | 924 | }]>; |
| 925 | |
| 926 | // INSERT_get_vinsert256_imm xform function: convert insert_subvector index to |
| 927 | // VINSERTF64x4 imm. |
| 928 | def INSERT_get_vinsert256_imm : SDNodeXForm<insert_subvector, [{ |
Sergey Dmitrouk | 842a51b | 2015-04-28 14:05:47 +0000 | [diff] [blame] | 929 | return getI8Imm(X86::getInsertVINSERT256Immediate(N), SDLoc(N)); |
Elena Demikhovsky | 67b05fc | 2013-07-31 11:35:14 +0000 | [diff] [blame] | 930 | }]>; |
| 931 | |
| 932 | def vextract128_extract : PatFrag<(ops node:$bigvec, node:$index), |
David Greene | c4da110 | 2011-02-03 15:50:00 +0000 | [diff] [blame] | 933 | (extract_subvector node:$bigvec, |
| 934 | node:$index), [{ |
Elena Demikhovsky | 67b05fc | 2013-07-31 11:35:14 +0000 | [diff] [blame] | 935 | return X86::isVEXTRACT128Index(N); |
| 936 | }], EXTRACT_get_vextract128_imm>; |
David Greene | 653f1ee | 2011-02-04 16:08:29 +0000 | [diff] [blame] | 937 | |
Elena Demikhovsky | 67b05fc | 2013-07-31 11:35:14 +0000 | [diff] [blame] | 938 | def vinsert128_insert : PatFrag<(ops node:$bigvec, node:$smallvec, |
David Greene | 653f1ee | 2011-02-04 16:08:29 +0000 | [diff] [blame] | 939 | node:$index), |
| 940 | (insert_subvector node:$bigvec, node:$smallvec, |
| 941 | node:$index), [{ |
Elena Demikhovsky | 67b05fc | 2013-07-31 11:35:14 +0000 | [diff] [blame] | 942 | return X86::isVINSERT128Index(N); |
| 943 | }], INSERT_get_vinsert128_imm>; |
| 944 | |
| 945 | |
| 946 | def vextract256_extract : PatFrag<(ops node:$bigvec, node:$index), |
| 947 | (extract_subvector node:$bigvec, |
| 948 | node:$index), [{ |
| 949 | return X86::isVEXTRACT256Index(N); |
| 950 | }], EXTRACT_get_vextract256_imm>; |
| 951 | |
| 952 | def vinsert256_insert : PatFrag<(ops node:$bigvec, node:$smallvec, |
| 953 | node:$index), |
| 954 | (insert_subvector node:$bigvec, node:$smallvec, |
| 955 | node:$index), [{ |
| 956 | return X86::isVINSERT256Index(N); |
| 957 | }], INSERT_get_vinsert256_imm>; |
Bruno Cardoso Lopes | 123dff0 | 2011-07-25 23:05:25 +0000 | [diff] [blame] | 958 | |
Elena Demikhovsky | d207f17 | 2015-03-03 15:03:35 +0000 | [diff] [blame] | 959 | def masked_load_aligned128 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 960 | (masked_load node:$src1, node:$src2, node:$src3), [{ |
Benjamin Kramer | 619c4e5 | 2015-04-10 11:24:51 +0000 | [diff] [blame] | 961 | if (auto *Load = dyn_cast<MaskedLoadSDNode>(N)) |
| 962 | return Load->getAlignment() >= 16; |
Elena Demikhovsky | d207f17 | 2015-03-03 15:03:35 +0000 | [diff] [blame] | 963 | return false; |
| 964 | }]>; |
| 965 | |
| 966 | def masked_load_aligned256 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 967 | (masked_load node:$src1, node:$src2, node:$src3), [{ |
Benjamin Kramer | 619c4e5 | 2015-04-10 11:24:51 +0000 | [diff] [blame] | 968 | if (auto *Load = dyn_cast<MaskedLoadSDNode>(N)) |
| 969 | return Load->getAlignment() >= 32; |
Elena Demikhovsky | d207f17 | 2015-03-03 15:03:35 +0000 | [diff] [blame] | 970 | return false; |
| 971 | }]>; |
| 972 | |
| 973 | def masked_load_aligned512 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 974 | (masked_load node:$src1, node:$src2, node:$src3), [{ |
Benjamin Kramer | 619c4e5 | 2015-04-10 11:24:51 +0000 | [diff] [blame] | 975 | if (auto *Load = dyn_cast<MaskedLoadSDNode>(N)) |
| 976 | return Load->getAlignment() >= 64; |
Elena Demikhovsky | d207f17 | 2015-03-03 15:03:35 +0000 | [diff] [blame] | 977 | return false; |
| 978 | }]>; |
| 979 | |
| 980 | def masked_load_unaligned : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 981 | (masked_load node:$src1, node:$src2, node:$src3), [{ |
Benjamin Kramer | 619c4e5 | 2015-04-10 11:24:51 +0000 | [diff] [blame] | 982 | return isa<MaskedLoadSDNode>(N); |
Elena Demikhovsky | d207f17 | 2015-03-03 15:03:35 +0000 | [diff] [blame] | 983 | }]>; |
| 984 | |
Igor Breger | 074a64e | 2015-07-24 17:24:15 +0000 | [diff] [blame] | 985 | // masked store fragments. |
| 986 | // X86mstore can't be implemented in core DAG files because some targets |
| 987 | // doesn't support vector type ( llvm-tblgen will fail) |
| 988 | def X86mstore : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 989 | (masked_store node:$src1, node:$src2, node:$src3), [{ |
| 990 | return !cast<MaskedStoreSDNode>(N)->isTruncatingStore(); |
| 991 | }]>; |
| 992 | |
Elena Demikhovsky | d207f17 | 2015-03-03 15:03:35 +0000 | [diff] [blame] | 993 | def masked_store_aligned128 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
Igor Breger | 074a64e | 2015-07-24 17:24:15 +0000 | [diff] [blame] | 994 | (X86mstore node:$src1, node:$src2, node:$src3), [{ |
Benjamin Kramer | 619c4e5 | 2015-04-10 11:24:51 +0000 | [diff] [blame] | 995 | if (auto *Store = dyn_cast<MaskedStoreSDNode>(N)) |
| 996 | return Store->getAlignment() >= 16; |
Elena Demikhovsky | d207f17 | 2015-03-03 15:03:35 +0000 | [diff] [blame] | 997 | return false; |
| 998 | }]>; |
| 999 | |
| 1000 | def masked_store_aligned256 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
Igor Breger | 074a64e | 2015-07-24 17:24:15 +0000 | [diff] [blame] | 1001 | (X86mstore node:$src1, node:$src2, node:$src3), [{ |
Benjamin Kramer | 619c4e5 | 2015-04-10 11:24:51 +0000 | [diff] [blame] | 1002 | if (auto *Store = dyn_cast<MaskedStoreSDNode>(N)) |
| 1003 | return Store->getAlignment() >= 32; |
Elena Demikhovsky | d207f17 | 2015-03-03 15:03:35 +0000 | [diff] [blame] | 1004 | return false; |
| 1005 | }]>; |
| 1006 | |
| 1007 | def masked_store_aligned512 : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
Igor Breger | 074a64e | 2015-07-24 17:24:15 +0000 | [diff] [blame] | 1008 | (X86mstore node:$src1, node:$src2, node:$src3), [{ |
Benjamin Kramer | 619c4e5 | 2015-04-10 11:24:51 +0000 | [diff] [blame] | 1009 | if (auto *Store = dyn_cast<MaskedStoreSDNode>(N)) |
| 1010 | return Store->getAlignment() >= 64; |
Elena Demikhovsky | d207f17 | 2015-03-03 15:03:35 +0000 | [diff] [blame] | 1011 | return false; |
| 1012 | }]>; |
| 1013 | |
| 1014 | def masked_store_unaligned : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
Igor Breger | 074a64e | 2015-07-24 17:24:15 +0000 | [diff] [blame] | 1015 | (X86mstore node:$src1, node:$src2, node:$src3), [{ |
Benjamin Kramer | 619c4e5 | 2015-04-10 11:24:51 +0000 | [diff] [blame] | 1016 | return isa<MaskedStoreSDNode>(N); |
Elena Demikhovsky | d207f17 | 2015-03-03 15:03:35 +0000 | [diff] [blame] | 1017 | }]>; |
| 1018 | |
Igor Breger | 074a64e | 2015-07-24 17:24:15 +0000 | [diff] [blame] | 1019 | // masked truncstore fragments |
| 1020 | // X86mtruncstore can't be implemented in core DAG files because some targets |
| 1021 | // doesn't support vector type ( llvm-tblgen will fail) |
| 1022 | def X86mtruncstore : PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 1023 | (masked_store node:$src1, node:$src2, node:$src3), [{ |
| 1024 | return cast<MaskedStoreSDNode>(N)->isTruncatingStore(); |
| 1025 | }]>; |
| 1026 | def masked_truncstorevi8 : |
| 1027 | PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 1028 | (X86mtruncstore node:$src1, node:$src2, node:$src3), [{ |
| 1029 | return cast<MaskedStoreSDNode>(N)->getMemoryVT().getScalarType() == MVT::i8; |
| 1030 | }]>; |
| 1031 | def masked_truncstorevi16 : |
| 1032 | PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 1033 | (X86mtruncstore node:$src1, node:$src2, node:$src3), [{ |
| 1034 | return cast<MaskedStoreSDNode>(N)->getMemoryVT().getScalarType() == MVT::i16; |
| 1035 | }]>; |
| 1036 | def masked_truncstorevi32 : |
| 1037 | PatFrag<(ops node:$src1, node:$src2, node:$src3), |
| 1038 | (X86mtruncstore node:$src1, node:$src2, node:$src3), [{ |
| 1039 | return cast<MaskedStoreSDNode>(N)->getMemoryVT().getScalarType() == MVT::i32; |
| 1040 | }]>; |