← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/Target/TargetSelectionDAG.td

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm/Target/TargetSelectionDAG.td
 
1
//===- TargetSelectionDAG.td - Common code for DAG isels ---*- tablegen -*-===//
 
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.
 
7
// 
 
8
//===----------------------------------------------------------------------===//
 
9
//
 
10
// This file defines the target-independent interfaces used by SelectionDAG
 
11
// instruction selection generators.
 
12
//
 
13
//===----------------------------------------------------------------------===//
 
14
 
 
15
//===----------------------------------------------------------------------===//
 
16
// Selection DAG Type Constraint definitions.
 
17
//
 
18
// Note that the semantics of these constraints are hard coded into tblgen.  To
 
19
// modify or add constraints, you have to hack tblgen.
 
20
//
 
21
 
 
22
class SDTypeConstraint<int opnum> {
 
23
  int OperandNum = opnum;
 
24
}
 
25
 
 
26
// SDTCisVT - The specified operand has exactly this VT.
 
27
class SDTCisVT<int OpNum, ValueType vt> : SDTypeConstraint<OpNum> {
 
28
  ValueType VT = vt;
 
29
}
 
30
 
 
31
class SDTCisPtrTy<int OpNum> : SDTypeConstraint<OpNum>;
 
32
 
 
33
// SDTCisInt - The specified operand has integer type.
 
34
class SDTCisInt<int OpNum> : SDTypeConstraint<OpNum>;
 
35
 
 
36
// SDTCisFP - The specified operand has floating-point type.
 
37
class SDTCisFP<int OpNum> : SDTypeConstraint<OpNum>;
 
38
 
 
39
// SDTCisVec - The specified operand has a vector type.
 
40
class SDTCisVec<int OpNum> : SDTypeConstraint<OpNum>;
 
41
 
 
42
// SDTCisSameAs - The two specified operands have identical types.
 
43
class SDTCisSameAs<int OpNum, int OtherOp> : SDTypeConstraint<OpNum> {
 
44
  int OtherOperandNum = OtherOp;
 
45
}
 
46
 
 
47
// SDTCisVTSmallerThanOp - The specified operand is a VT SDNode, and its type is
 
48
// smaller than the 'Other' operand.
 
49
class SDTCisVTSmallerThanOp<int OpNum, int OtherOp> : SDTypeConstraint<OpNum> {
 
50
  int OtherOperandNum = OtherOp;
 
51
}
 
52
 
 
53
class SDTCisOpSmallerThanOp<int SmallOp, int BigOp> : SDTypeConstraint<SmallOp>{
 
54
  int BigOperandNum = BigOp;
 
55
}
 
56
 
 
57
/// SDTCisEltOfVec - This indicates that ThisOp is a scalar type of the same
 
58
/// type as the element type of OtherOp, which is a vector type.
 
59
class SDTCisEltOfVec<int ThisOp, int OtherOp>
 
60
  : SDTypeConstraint<ThisOp> {
 
61
  int OtherOpNum = OtherOp;
 
62
}
 
63
 
 
64
//===----------------------------------------------------------------------===//
 
65
// Selection DAG Type Profile definitions.
 
66
//
 
67
// These use the constraints defined above to describe the type requirements of
 
68
// the various nodes.  These are not hard coded into tblgen, allowing targets to
 
69
// add their own if needed.
 
70
//
 
71
 
 
72
// SDTypeProfile - This profile describes the type requirements of a Selection
 
73
// DAG node.
 
74
class SDTypeProfile<int numresults, int numoperands,
 
75
                    list<SDTypeConstraint> constraints> {
 
76
  int NumResults = numresults;
 
77
  int NumOperands = numoperands;
 
78
  list<SDTypeConstraint> Constraints = constraints;
 
79
}
 
80
 
 
81
// Builtin profiles.
 
82
def SDTIntLeaf: SDTypeProfile<1, 0, [SDTCisInt<0>]>;         // for 'imm'.
 
83
def SDTFPLeaf : SDTypeProfile<1, 0, [SDTCisFP<0>]>;          // for 'fpimm'.
 
84
def SDTPtrLeaf: SDTypeProfile<1, 0, [SDTCisPtrTy<0>]>;       // for '&g'.
 
85
def SDTOther  : SDTypeProfile<1, 0, [SDTCisVT<0, OtherVT>]>; // for 'vt'.
 
86
def SDTUNDEF  : SDTypeProfile<1, 0, []>;                     // for 'undef'.
 
87
def SDTUnaryOp  : SDTypeProfile<1, 1, []>;                   // for bitconvert.
 
88
 
 
89
def SDTIntBinOp : SDTypeProfile<1, 2, [     // add, and, or, xor, udiv, etc.
 
90
  SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisInt<0>
 
91
]>;
 
92
def SDTIntShiftOp : SDTypeProfile<1, 2, [   // shl, sra, srl
 
93
  SDTCisSameAs<0, 1>, SDTCisInt<0>, SDTCisInt<2>
 
94
]>;
 
95
def SDTFPBinOp : SDTypeProfile<1, 2, [      // fadd, fmul, etc.
 
96
  SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisFP<0>
 
97
]>;
 
98
def SDTFPSignOp : SDTypeProfile<1, 2, [     // fcopysign.
 
99
  SDTCisSameAs<0, 1>, SDTCisFP<0>, SDTCisFP<2>
 
100
]>;
 
101
def SDTFPTernaryOp : SDTypeProfile<1, 3, [  // fmadd, fnmsub, etc.
 
102
  SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisSameAs<0, 3>, SDTCisFP<0>
 
103
]>;
 
104
def SDTIntUnaryOp : SDTypeProfile<1, 1, [   // ctlz
 
105
  SDTCisSameAs<0, 1>, SDTCisInt<0>
 
106
]>;
 
107
def SDTIntExtendOp : SDTypeProfile<1, 1, [  // sext, zext, anyext
 
108
  SDTCisInt<0>, SDTCisInt<1>, SDTCisOpSmallerThanOp<1, 0>
 
109
]>;
 
110
def SDTIntTruncOp  : SDTypeProfile<1, 1, [  // trunc
 
111
  SDTCisInt<0>, SDTCisInt<1>, SDTCisOpSmallerThanOp<0, 1>
 
112
]>;
 
113
def SDTFPUnaryOp  : SDTypeProfile<1, 1, [   // fneg, fsqrt, etc
 
114
  SDTCisSameAs<0, 1>, SDTCisFP<0>
 
115
]>;
 
116
def SDTFPRoundOp  : SDTypeProfile<1, 1, [   // fround
 
117
  SDTCisFP<0>, SDTCisFP<1>, SDTCisOpSmallerThanOp<0, 1>
 
118
]>;
 
119
def SDTFPExtendOp  : SDTypeProfile<1, 1, [  // fextend
 
120
  SDTCisFP<0>, SDTCisFP<1>, SDTCisOpSmallerThanOp<1, 0>
 
121
]>;
 
122
def SDTIntToFPOp : SDTypeProfile<1, 1, [    // [su]int_to_fp 
 
123
  SDTCisFP<0>, SDTCisInt<1>
 
124
]>;
 
125
def SDTFPToIntOp : SDTypeProfile<1, 1, [    // fp_to_[su]int 
 
126
  SDTCisInt<0>, SDTCisFP<1>
 
127
]>;
 
128
def SDTExtInreg : SDTypeProfile<1, 2, [     // sext_inreg
 
129
  SDTCisSameAs<0, 1>, SDTCisInt<0>, SDTCisVT<2, OtherVT>,
 
130
  SDTCisVTSmallerThanOp<2, 1>
 
131
]>;
 
132
 
 
133
def SDTSetCC : SDTypeProfile<1, 3, [        // setcc
 
134
  SDTCisInt<0>, SDTCisSameAs<1, 2>, SDTCisVT<3, OtherVT>
 
135
]>;
 
136
 
 
137
def SDTSelect : SDTypeProfile<1, 3, [       // select 
 
138
  SDTCisInt<1>, SDTCisSameAs<0, 2>, SDTCisSameAs<2, 3>
 
139
]>;
 
140
 
 
141
def SDTSelectCC : SDTypeProfile<1, 5, [     // select_cc
 
142
  SDTCisSameAs<1, 2>, SDTCisSameAs<3, 4>, SDTCisSameAs<0, 3>,
 
143
  SDTCisVT<5, OtherVT>
 
144
]>;
 
145
 
 
146
def SDTBr : SDTypeProfile<0, 1, [           // br
 
147
  SDTCisVT<0, OtherVT>
 
148
]>;
 
149
 
 
150
def SDTBrcond : SDTypeProfile<0, 2, [       // brcond
 
151
  SDTCisInt<0>, SDTCisVT<1, OtherVT>
 
152
]>;
 
153
 
 
154
def SDTBrind : SDTypeProfile<0, 1, [        // brind
 
155
  SDTCisPtrTy<0>
 
156
]>;
 
157
 
 
158
def SDTNone : SDTypeProfile<0, 0, []>;      // ret, trap
 
159
 
 
160
def SDTLoad : SDTypeProfile<1, 1, [         // load
 
161
  SDTCisPtrTy<1>  
 
162
]>;
 
163
 
 
164
def SDTStore : SDTypeProfile<0, 2, [        // store
 
165
  SDTCisPtrTy<1>  
 
166
]>;
 
167
 
 
168
def SDTIStore : SDTypeProfile<1, 3, [       // indexed store
 
169
  SDTCisSameAs<0, 2>, SDTCisPtrTy<0>, SDTCisPtrTy<3>
 
170
]>;
 
171
 
 
172
def SDTVecShuffle : SDTypeProfile<1, 2, [
 
173
  SDTCisSameAs<0, 1>, SDTCisSameAs<1, 2>
 
174
]>;
 
175
def SDTVecExtract : SDTypeProfile<1, 2, [   // vector extract
 
176
  SDTCisEltOfVec<0, 1>, SDTCisPtrTy<2>
 
177
]>;
 
178
def SDTVecInsert : SDTypeProfile<1, 3, [    // vector insert
 
179
  SDTCisEltOfVec<2, 1>, SDTCisSameAs<0, 1>, SDTCisPtrTy<3>
 
180
]>;
 
181
 
 
182
def STDPrefetch : SDTypeProfile<0, 3, [     // prefetch
 
183
  SDTCisPtrTy<0>, SDTCisSameAs<1, 2>, SDTCisInt<1>
 
184
]>;
 
185
 
 
186
def STDMemBarrier : SDTypeProfile<0, 5, [   // memory barier
 
187
  SDTCisSameAs<0,1>,  SDTCisSameAs<0,2>,  SDTCisSameAs<0,3>, SDTCisSameAs<0,4>,
 
188
  SDTCisInt<0>
 
189
]>;
 
190
def STDAtomic3 : SDTypeProfile<1, 3, [
 
191
  SDTCisSameAs<0,2>,  SDTCisSameAs<0,3>, SDTCisInt<0>, SDTCisPtrTy<1>
 
192
]>;
 
193
def STDAtomic2 : SDTypeProfile<1, 2, [
 
194
  SDTCisSameAs<0,2>, SDTCisInt<0>, SDTCisPtrTy<1>
 
195
]>;
 
196
 
 
197
def SDTConvertOp : SDTypeProfile<1, 5, [ //cvtss, su, us, uu, ff, fs, fu, sf, su
 
198
  SDTCisVT<2, OtherVT>, SDTCisVT<3, OtherVT>, SDTCisPtrTy<4>, SDTCisPtrTy<5>
 
199
]>;
 
200
 
 
201
class SDCallSeqStart<list<SDTypeConstraint> constraints> :
 
202
        SDTypeProfile<0, 1, constraints>;
 
203
class SDCallSeqEnd<list<SDTypeConstraint> constraints> :
 
204
        SDTypeProfile<0, 2, constraints>;
 
205
 
 
206
//===----------------------------------------------------------------------===//
 
207
// Selection DAG Node Properties.
 
208
//
 
209
// Note: These are hard coded into tblgen.
 
210
//
 
211
class SDNodeProperty;
 
212
def SDNPCommutative : SDNodeProperty;   // X op Y == Y op X
 
213
def SDNPAssociative : SDNodeProperty;   // (X op Y) op Z == X op (Y op Z)
 
214
def SDNPHasChain    : SDNodeProperty;   // R/W chain operand and result
 
215
def SDNPOutFlag     : SDNodeProperty;   // Write a flag result
 
216
def SDNPInFlag      : SDNodeProperty;   // Read a flag operand
 
217
def SDNPOptInFlag   : SDNodeProperty;   // Optionally read a flag operand
 
218
def SDNPMayStore    : SDNodeProperty;   // May write to memory, sets 'mayStore'.
 
219
def SDNPMayLoad     : SDNodeProperty;   // May read memory, sets 'mayLoad'.
 
220
def SDNPSideEffect  : SDNodeProperty;   // Sets 'HasUnmodelledSideEffects'.
 
221
def SDNPMemOperand  : SDNodeProperty;   // Touches memory, has assoc MemOperand
 
222
 
 
223
//===----------------------------------------------------------------------===//
 
224
// Selection DAG Node definitions.
 
225
//
 
226
class SDNode<string opcode, SDTypeProfile typeprof,
 
227
             list<SDNodeProperty> props = [], string sdclass = "SDNode"> {
 
228
  string Opcode  = opcode;
 
229
  string SDClass = sdclass;
 
230
  list<SDNodeProperty> Properties = props;
 
231
  SDTypeProfile TypeProfile = typeprof;
 
232
}
 
233
 
 
234
// Special TableGen-recognized dag nodes
 
235
def set;
 
236
def implicit;
 
237
def parallel;
 
238
def node;
 
239
def srcvalue;
 
240
 
 
241
def imm        : SDNode<"ISD::Constant"  , SDTIntLeaf , [], "ConstantSDNode">;
 
242
def timm       : SDNode<"ISD::TargetConstant",SDTIntLeaf, [], "ConstantSDNode">;
 
243
def fpimm      : SDNode<"ISD::ConstantFP", SDTFPLeaf  , [], "ConstantFPSDNode">;
 
244
def vt         : SDNode<"ISD::VALUETYPE" , SDTOther   , [], "VTSDNode">;
 
245
def bb         : SDNode<"ISD::BasicBlock", SDTOther   , [], "BasicBlockSDNode">;
 
246
def cond       : SDNode<"ISD::CONDCODE"  , SDTOther   , [], "CondCodeSDNode">;
 
247
def undef      : SDNode<"ISD::UNDEF"     , SDTUNDEF   , []>;
 
248
def globaladdr : SDNode<"ISD::GlobalAddress",         SDTPtrLeaf, [],
 
249
                        "GlobalAddressSDNode">;
 
250
def tglobaladdr : SDNode<"ISD::TargetGlobalAddress",  SDTPtrLeaf, [],
 
251
                         "GlobalAddressSDNode">;
 
252
def globaltlsaddr : SDNode<"ISD::GlobalTLSAddress",         SDTPtrLeaf, [],
 
253
                          "GlobalAddressSDNode">;
 
254
def tglobaltlsaddr : SDNode<"ISD::TargetGlobalTLSAddress",  SDTPtrLeaf, [],
 
255
                           "GlobalAddressSDNode">;
 
256
def constpool   : SDNode<"ISD::ConstantPool",         SDTPtrLeaf, [],
 
257
                         "ConstantPoolSDNode">;
 
258
def tconstpool  : SDNode<"ISD::TargetConstantPool",   SDTPtrLeaf, [],
 
259
                         "ConstantPoolSDNode">;
 
260
def jumptable   : SDNode<"ISD::JumpTable",            SDTPtrLeaf, [],
 
261
                         "JumpTableSDNode">;
 
262
def tjumptable  : SDNode<"ISD::TargetJumpTable",      SDTPtrLeaf, [],
 
263
                         "JumpTableSDNode">;
 
264
def frameindex  : SDNode<"ISD::FrameIndex",           SDTPtrLeaf, [],
 
265
                         "FrameIndexSDNode">;
 
266
def tframeindex : SDNode<"ISD::TargetFrameIndex",     SDTPtrLeaf, [],
 
267
                         "FrameIndexSDNode">;
 
268
def externalsym : SDNode<"ISD::ExternalSymbol",       SDTPtrLeaf, [],
 
269
                         "ExternalSymbolSDNode">;
 
270
def texternalsym: SDNode<"ISD::TargetExternalSymbol", SDTPtrLeaf, [],
 
271
                         "ExternalSymbolSDNode">;
 
272
def blockaddress : SDNode<"ISD::BlockAddress",        SDTPtrLeaf, [],
 
273
                         "BlockAddressSDNode">;
 
274
def tblockaddress: SDNode<"ISD::TargetBlockAddress",  SDTPtrLeaf, [],
 
275
                         "BlockAddressSDNode">;
 
276
 
 
277
def add        : SDNode<"ISD::ADD"       , SDTIntBinOp   ,
 
278
                        [SDNPCommutative, SDNPAssociative]>;
 
279
def sub        : SDNode<"ISD::SUB"       , SDTIntBinOp>;
 
280
def mul        : SDNode<"ISD::MUL"       , SDTIntBinOp,
 
281
                        [SDNPCommutative, SDNPAssociative]>;
 
282
def mulhs      : SDNode<"ISD::MULHS"     , SDTIntBinOp, [SDNPCommutative]>;
 
283
def mulhu      : SDNode<"ISD::MULHU"     , SDTIntBinOp, [SDNPCommutative]>;
 
284
def sdiv       : SDNode<"ISD::SDIV"      , SDTIntBinOp>;
 
285
def udiv       : SDNode<"ISD::UDIV"      , SDTIntBinOp>;
 
286
def srem       : SDNode<"ISD::SREM"      , SDTIntBinOp>;
 
287
def urem       : SDNode<"ISD::UREM"      , SDTIntBinOp>;
 
288
def srl        : SDNode<"ISD::SRL"       , SDTIntShiftOp>;
 
289
def sra        : SDNode<"ISD::SRA"       , SDTIntShiftOp>;
 
290
def shl        : SDNode<"ISD::SHL"       , SDTIntShiftOp>;
 
291
def rotl       : SDNode<"ISD::ROTL"      , SDTIntShiftOp>;
 
292
def rotr       : SDNode<"ISD::ROTR"      , SDTIntShiftOp>;
 
293
def and        : SDNode<"ISD::AND"       , SDTIntBinOp,
 
294
                        [SDNPCommutative, SDNPAssociative]>;
 
295
def or         : SDNode<"ISD::OR"        , SDTIntBinOp,
 
296
                        [SDNPCommutative, SDNPAssociative]>;
 
297
def xor        : SDNode<"ISD::XOR"       , SDTIntBinOp,
 
298
                        [SDNPCommutative, SDNPAssociative]>;
 
299
def addc       : SDNode<"ISD::ADDC"      , SDTIntBinOp,
 
300
                        [SDNPCommutative, SDNPOutFlag]>;
 
301
def adde       : SDNode<"ISD::ADDE"      , SDTIntBinOp,
 
302
                        [SDNPCommutative, SDNPOutFlag, SDNPInFlag]>;
 
303
def subc       : SDNode<"ISD::SUBC"      , SDTIntBinOp,
 
304
                        [SDNPOutFlag]>;
 
305
def sube       : SDNode<"ISD::SUBE"      , SDTIntBinOp,
 
306
                        [SDNPOutFlag, SDNPInFlag]>;
 
307
                        
 
308
def sext_inreg : SDNode<"ISD::SIGN_EXTEND_INREG", SDTExtInreg>;
 
309
def bswap      : SDNode<"ISD::BSWAP"      , SDTIntUnaryOp>;
 
310
def ctlz       : SDNode<"ISD::CTLZ"       , SDTIntUnaryOp>;
 
311
def cttz       : SDNode<"ISD::CTTZ"       , SDTIntUnaryOp>;
 
312
def ctpop      : SDNode<"ISD::CTPOP"      , SDTIntUnaryOp>;
 
313
def sext       : SDNode<"ISD::SIGN_EXTEND", SDTIntExtendOp>;
 
314
def zext       : SDNode<"ISD::ZERO_EXTEND", SDTIntExtendOp>;
 
315
def anyext     : SDNode<"ISD::ANY_EXTEND" , SDTIntExtendOp>;
 
316
def trunc      : SDNode<"ISD::TRUNCATE"   , SDTIntTruncOp>;
 
317
def bitconvert : SDNode<"ISD::BIT_CONVERT", SDTUnaryOp>;
 
318
def extractelt : SDNode<"ISD::EXTRACT_VECTOR_ELT", SDTVecExtract>;
 
319
def insertelt  : SDNode<"ISD::INSERT_VECTOR_ELT", SDTVecInsert>;
 
320
 
 
321
                        
 
322
def fadd       : SDNode<"ISD::FADD"       , SDTFPBinOp, [SDNPCommutative]>;
 
323
def fsub       : SDNode<"ISD::FSUB"       , SDTFPBinOp>;
 
324
def fmul       : SDNode<"ISD::FMUL"       , SDTFPBinOp, [SDNPCommutative]>;
 
325
def fdiv       : SDNode<"ISD::FDIV"       , SDTFPBinOp>;
 
326
def frem       : SDNode<"ISD::FREM"       , SDTFPBinOp>;
 
327
def fabs       : SDNode<"ISD::FABS"       , SDTFPUnaryOp>;
 
328
def fneg       : SDNode<"ISD::FNEG"       , SDTFPUnaryOp>;
 
329
def fsqrt      : SDNode<"ISD::FSQRT"      , SDTFPUnaryOp>;
 
330
def fsin       : SDNode<"ISD::FSIN"       , SDTFPUnaryOp>;
 
331
def fcos       : SDNode<"ISD::FCOS"       , SDTFPUnaryOp>;
 
332
def fexp2      : SDNode<"ISD::FEXP2"      , SDTFPUnaryOp>;
 
333
def flog2      : SDNode<"ISD::FLOG2"      , SDTFPUnaryOp>;
 
334
def frint      : SDNode<"ISD::FRINT"      , SDTFPUnaryOp>;
 
335
def ftrunc     : SDNode<"ISD::FTRUNC"     , SDTFPUnaryOp>;
 
336
def fceil      : SDNode<"ISD::FCEIL"      , SDTFPUnaryOp>;
 
337
def ffloor     : SDNode<"ISD::FFLOOR"     , SDTFPUnaryOp>;
 
338
def fnearbyint : SDNode<"ISD::FNEARBYINT" , SDTFPUnaryOp>;
 
339
 
 
340
def fround     : SDNode<"ISD::FP_ROUND"   , SDTFPRoundOp>;
 
341
def fextend    : SDNode<"ISD::FP_EXTEND"  , SDTFPExtendOp>;
 
342
def fcopysign  : SDNode<"ISD::FCOPYSIGN"  , SDTFPSignOp>;
 
343
 
 
344
def sint_to_fp : SDNode<"ISD::SINT_TO_FP" , SDTIntToFPOp>;
 
345
def uint_to_fp : SDNode<"ISD::UINT_TO_FP" , SDTIntToFPOp>;
 
346
def fp_to_sint : SDNode<"ISD::FP_TO_SINT" , SDTFPToIntOp>;
 
347
def fp_to_uint : SDNode<"ISD::FP_TO_UINT" , SDTFPToIntOp>;
 
348
 
 
349
def setcc      : SDNode<"ISD::SETCC"      , SDTSetCC>;
 
350
def select     : SDNode<"ISD::SELECT"     , SDTSelect>;
 
351
def selectcc   : SDNode<"ISD::SELECT_CC"  , SDTSelectCC>;
 
352
def vsetcc     : SDNode<"ISD::VSETCC"     , SDTSetCC>;
 
353
 
 
354
def brcond     : SDNode<"ISD::BRCOND"     , SDTBrcond, [SDNPHasChain]>;
 
355
def brind      : SDNode<"ISD::BRIND"      , SDTBrind,  [SDNPHasChain]>;
 
356
def br         : SDNode<"ISD::BR"         , SDTBr,     [SDNPHasChain]>;
 
357
def trap       : SDNode<"ISD::TRAP"       , SDTNone,
 
358
                        [SDNPHasChain, SDNPSideEffect]>;
 
359
 
 
360
def prefetch   : SDNode<"ISD::PREFETCH"   , STDPrefetch,
 
361
                        [SDNPHasChain, SDNPMayLoad, SDNPMayStore]>;
 
362
 
 
363
def membarrier : SDNode<"ISD::MEMBARRIER" , STDMemBarrier,
 
364
                        [SDNPHasChain, SDNPSideEffect]>;
 
365
 
 
366
def atomic_cmp_swap : SDNode<"ISD::ATOMIC_CMP_SWAP" , STDAtomic3,
 
367
                    [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 
368
def atomic_load_add : SDNode<"ISD::ATOMIC_LOAD_ADD" , STDAtomic2,
 
369
                    [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 
370
def atomic_swap     : SDNode<"ISD::ATOMIC_SWAP", STDAtomic2,
 
371
                    [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 
372
def atomic_load_sub : SDNode<"ISD::ATOMIC_LOAD_SUB" , STDAtomic2,
 
373
                    [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 
374
def atomic_load_and : SDNode<"ISD::ATOMIC_LOAD_AND" , STDAtomic2,
 
375
                    [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 
376
def atomic_load_or  : SDNode<"ISD::ATOMIC_LOAD_OR" , STDAtomic2,
 
377
                    [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 
378
def atomic_load_xor : SDNode<"ISD::ATOMIC_LOAD_XOR" , STDAtomic2,
 
379
                    [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 
380
def atomic_load_nand: SDNode<"ISD::ATOMIC_LOAD_NAND", STDAtomic2,
 
381
                    [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 
382
def atomic_load_min : SDNode<"ISD::ATOMIC_LOAD_MIN", STDAtomic2,
 
383
                    [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 
384
def atomic_load_max : SDNode<"ISD::ATOMIC_LOAD_MAX", STDAtomic2,
 
385
                    [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 
386
def atomic_load_umin : SDNode<"ISD::ATOMIC_LOAD_UMIN", STDAtomic2,
 
387
                    [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 
388
def atomic_load_umax : SDNode<"ISD::ATOMIC_LOAD_UMAX", STDAtomic2,
 
389
                    [SDNPHasChain, SDNPMayStore, SDNPMayLoad, SDNPMemOperand]>;
 
390
 
 
391
// Do not use ld, st directly. Use load, extload, sextload, zextload, store,
 
392
// and truncst (see below).
 
393
def ld         : SDNode<"ISD::LOAD"       , SDTLoad,
 
394
                        [SDNPHasChain, SDNPMayLoad, SDNPMemOperand]>;
 
395
def st         : SDNode<"ISD::STORE"      , SDTStore,
 
396
                        [SDNPHasChain, SDNPMayStore, SDNPMemOperand]>;
 
397
def ist        : SDNode<"ISD::STORE"      , SDTIStore,
 
398
                        [SDNPHasChain, SDNPMayStore, SDNPMemOperand]>;
 
399
 
 
400
def vector_shuffle : SDNode<"ISD::VECTOR_SHUFFLE", SDTVecShuffle, []>;
 
401
def build_vector : SDNode<"ISD::BUILD_VECTOR", SDTypeProfile<1, -1, []>, []>;
 
402
def scalar_to_vector : SDNode<"ISD::SCALAR_TO_VECTOR", SDTypeProfile<1, 1, []>,
 
403
                              []>;
 
404
def vector_extract : SDNode<"ISD::EXTRACT_VECTOR_ELT",
 
405
    SDTypeProfile<1, 2, [SDTCisPtrTy<2>]>, []>;
 
406
def vector_insert : SDNode<"ISD::INSERT_VECTOR_ELT",
 
407
    SDTypeProfile<1, 3, [SDTCisSameAs<0, 1>, SDTCisPtrTy<3>]>, []>;
 
408
    
 
409
// Nodes for intrinsics, you should use the intrinsic itself and let tblgen use
 
410
// these internally.  Don't reference these directly.
 
411
def intrinsic_void : SDNode<"ISD::INTRINSIC_VOID", 
 
412
                            SDTypeProfile<0, -1, [SDTCisPtrTy<0>]>,
 
413
                            [SDNPHasChain]>;
 
414
def intrinsic_w_chain : SDNode<"ISD::INTRINSIC_W_CHAIN", 
 
415
                               SDTypeProfile<1, -1, [SDTCisPtrTy<1>]>,
 
416
                               [SDNPHasChain]>;
 
417
def intrinsic_wo_chain : SDNode<"ISD::INTRINSIC_WO_CHAIN", 
 
418
                                SDTypeProfile<1, -1, [SDTCisPtrTy<1>]>, []>;
 
419
 
 
420
// Do not use cvt directly. Use cvt forms below
 
421
def cvt : SDNode<"ISD::CONVERT_RNDSAT", SDTConvertOp>;
 
422
 
 
423
//===----------------------------------------------------------------------===//
 
424
// Selection DAG Condition Codes
 
425
 
 
426
class CondCode; // ISD::CondCode enums
 
427
def SETOEQ : CondCode; def SETOGT : CondCode;
 
428
def SETOGE : CondCode; def SETOLT : CondCode; def SETOLE : CondCode;
 
429
def SETONE : CondCode; def SETO   : CondCode; def SETUO  : CondCode;
 
430
def SETUEQ : CondCode; def SETUGT : CondCode; def SETUGE : CondCode;
 
431
def SETULT : CondCode; def SETULE : CondCode; def SETUNE : CondCode;
 
432
 
 
433
def SETEQ : CondCode; def SETGT : CondCode; def SETGE : CondCode;
 
434
def SETLT : CondCode; def SETLE : CondCode; def SETNE : CondCode;
 
435
 
 
436
 
 
437
//===----------------------------------------------------------------------===//
 
438
// Selection DAG Node Transformation Functions.
 
439
//
 
440
// This mechanism allows targets to manipulate nodes in the output DAG once a
 
441
// match has been formed.  This is typically used to manipulate immediate
 
442
// values.
 
443
//
 
444
class SDNodeXForm<SDNode opc, code xformFunction> {
 
445
  SDNode Opcode = opc;
 
446
  code XFormFunction = xformFunction;
 
447
}
 
448
 
 
449
def NOOP_SDNodeXForm : SDNodeXForm<imm, [{}]>;
 
450
 
 
451
 
 
452
//===----------------------------------------------------------------------===//
 
453
// Selection DAG Pattern Fragments.
 
454
//
 
455
// Pattern fragments are reusable chunks of dags that match specific things.
 
456
// They can take arguments and have C++ predicates that control whether they
 
457
// match.  They are intended to make the patterns for common instructions more
 
458
// compact and readable.
 
459
//
 
460
 
 
461
/// PatFrag - Represents a pattern fragment.  This can match something on the
 
462
/// DAG, frame a single node to multiply nested other fragments.
 
463
///
 
464
class PatFrag<dag ops, dag frag, code pred = [{}],
 
465
              SDNodeXForm xform = NOOP_SDNodeXForm> {
 
466
  dag Operands = ops;
 
467
  dag Fragment = frag;
 
468
  code Predicate = pred;
 
469
  SDNodeXForm OperandTransform = xform;
 
470
}
 
471
 
 
472
// PatLeaf's are pattern fragments that have no operands.  This is just a helper
 
473
// to define immediates and other common things concisely.
 
474
class PatLeaf<dag frag, code pred = [{}], SDNodeXForm xform = NOOP_SDNodeXForm>
 
475
 : PatFrag<(ops), frag, pred, xform>;
 
476
 
 
477
// Leaf fragments.
 
478
 
 
479
def vtInt      : PatLeaf<(vt),  [{ return N->getVT().isInteger(); }]>;
 
480
def vtFP       : PatLeaf<(vt),  [{ return N->getVT().isFloatingPoint(); }]>;
 
481
 
 
482
def immAllOnesV: PatLeaf<(build_vector), [{
 
483
  return ISD::isBuildVectorAllOnes(N);
 
484
}]>;
 
485
def immAllOnesV_bc: PatLeaf<(bitconvert), [{
 
486
  return ISD::isBuildVectorAllOnes(N);
 
487
}]>;
 
488
def immAllZerosV: PatLeaf<(build_vector), [{
 
489
  return ISD::isBuildVectorAllZeros(N);
 
490
}]>;
 
491
def immAllZerosV_bc: PatLeaf<(bitconvert), [{
 
492
  return ISD::isBuildVectorAllZeros(N);
 
493
}]>;
 
494
 
 
495
 
 
496
 
 
497
// Other helper fragments.
 
498
def not  : PatFrag<(ops node:$in), (xor node:$in, -1)>;
 
499
def vnot : PatFrag<(ops node:$in), (xor node:$in, immAllOnesV)>;
 
500
def vnot_conv : PatFrag<(ops node:$in), (xor node:$in, immAllOnesV_bc)>;
 
501
def ineg : PatFrag<(ops node:$in), (sub 0, node:$in)>;
 
502
 
 
503
// load fragments.
 
504
def unindexedload : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
 
505
  return cast<LoadSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
 
506
}]>;
 
507
def load : PatFrag<(ops node:$ptr), (unindexedload node:$ptr), [{
 
508
  return cast<LoadSDNode>(N)->getExtensionType() == ISD::NON_EXTLOAD;
 
509
}]>;
 
510
 
 
511
// extending load fragments.
 
512
def extload   : PatFrag<(ops node:$ptr), (unindexedload node:$ptr), [{
 
513
  return cast<LoadSDNode>(N)->getExtensionType() == ISD::EXTLOAD;
 
514
}]>;
 
515
def sextload  : PatFrag<(ops node:$ptr), (unindexedload node:$ptr), [{
 
516
  return cast<LoadSDNode>(N)->getExtensionType() == ISD::SEXTLOAD;
 
517
}]>;
 
518
def zextload  : PatFrag<(ops node:$ptr), (unindexedload node:$ptr), [{
 
519
  return cast<LoadSDNode>(N)->getExtensionType() == ISD::ZEXTLOAD;
 
520
}]>;
 
521
 
 
522
def extloadi1  : PatFrag<(ops node:$ptr), (extload node:$ptr), [{
 
523
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i1;
 
524
}]>;
 
525
def extloadi8  : PatFrag<(ops node:$ptr), (extload node:$ptr), [{
 
526
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i8;
 
527
}]>;
 
528
def extloadi16 : PatFrag<(ops node:$ptr), (extload node:$ptr), [{
 
529
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i16;
 
530
}]>;
 
531
def extloadi32 : PatFrag<(ops node:$ptr), (extload node:$ptr), [{
 
532
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i32;
 
533
}]>;
 
534
def extloadf32 : PatFrag<(ops node:$ptr), (extload node:$ptr), [{
 
535
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::f32;
 
536
}]>;
 
537
def extloadf64 : PatFrag<(ops node:$ptr), (extload node:$ptr), [{
 
538
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::f64;
 
539
}]>;
 
540
 
 
541
def sextloadi1  : PatFrag<(ops node:$ptr), (sextload node:$ptr), [{
 
542
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i1;
 
543
}]>;
 
544
def sextloadi8  : PatFrag<(ops node:$ptr), (sextload node:$ptr), [{
 
545
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i8;
 
546
}]>;
 
547
def sextloadi16 : PatFrag<(ops node:$ptr), (sextload node:$ptr), [{
 
548
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i16;
 
549
}]>;
 
550
def sextloadi32 : PatFrag<(ops node:$ptr), (sextload node:$ptr), [{
 
551
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i32;
 
552
}]>;
 
553
 
 
554
def zextloadi1  : PatFrag<(ops node:$ptr), (zextload node:$ptr), [{
 
555
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i1;
 
556
}]>;
 
557
def zextloadi8  : PatFrag<(ops node:$ptr), (zextload node:$ptr), [{
 
558
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i8;
 
559
}]>;
 
560
def zextloadi16 : PatFrag<(ops node:$ptr), (zextload node:$ptr), [{
 
561
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i16;
 
562
}]>;
 
563
def zextloadi32 : PatFrag<(ops node:$ptr), (zextload node:$ptr), [{
 
564
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i32;
 
565
}]>;
 
566
 
 
567
// store fragments.
 
568
def unindexedstore : PatFrag<(ops node:$val, node:$ptr),
 
569
                             (st node:$val, node:$ptr), [{
 
570
  return cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
 
571
}]>;
 
572
def store : PatFrag<(ops node:$val, node:$ptr),
 
573
                    (unindexedstore node:$val, node:$ptr), [{
 
574
  return !cast<StoreSDNode>(N)->isTruncatingStore();
 
575
}]>;
 
576
 
 
577
// truncstore fragments.
 
578
def truncstore : PatFrag<(ops node:$val, node:$ptr),
 
579
                         (unindexedstore node:$val, node:$ptr), [{
 
580
  return cast<StoreSDNode>(N)->isTruncatingStore();
 
581
}]>;
 
582
def truncstorei8 : PatFrag<(ops node:$val, node:$ptr),
 
583
                           (truncstore node:$val, node:$ptr), [{
 
584
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i8;
 
585
}]>;
 
586
def truncstorei16 : PatFrag<(ops node:$val, node:$ptr),
 
587
                            (truncstore node:$val, node:$ptr), [{
 
588
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i16;
 
589
}]>;
 
590
def truncstorei32 : PatFrag<(ops node:$val, node:$ptr),
 
591
                            (truncstore node:$val, node:$ptr), [{
 
592
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i32;
 
593
}]>;
 
594
def truncstoref32 : PatFrag<(ops node:$val, node:$ptr),
 
595
                            (truncstore node:$val, node:$ptr), [{
 
596
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::f32;
 
597
}]>;
 
598
def truncstoref64 : PatFrag<(ops node:$val, node:$ptr),
 
599
                            (truncstore node:$val, node:$ptr), [{
 
600
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::f64;
 
601
}]>;
 
602
 
 
603
// indexed store fragments.
 
604
def istore : PatFrag<(ops node:$val, node:$base, node:$offset),
 
605
                     (ist node:$val, node:$base, node:$offset), [{
 
606
  return !cast<StoreSDNode>(N)->isTruncatingStore();
 
607
}]>;
 
608
 
 
609
def pre_store : PatFrag<(ops node:$val, node:$base, node:$offset),
 
610
                        (istore node:$val, node:$base, node:$offset), [{
 
611
  ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
 
612
  return AM == ISD::PRE_INC || AM == ISD::PRE_DEC;
 
613
}]>;
 
614
 
 
615
def itruncstore : PatFrag<(ops node:$val, node:$base, node:$offset),
 
616
                          (ist node:$val, node:$base, node:$offset), [{
 
617
  return cast<StoreSDNode>(N)->isTruncatingStore();
 
618
}]>;
 
619
def pre_truncst : PatFrag<(ops node:$val, node:$base, node:$offset),
 
620
                          (itruncstore node:$val, node:$base, node:$offset), [{
 
621
  ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
 
622
  return AM == ISD::PRE_INC || AM == ISD::PRE_DEC;
 
623
}]>;
 
624
def pre_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset),
 
625
                            (pre_truncst node:$val, node:$base, node:$offset), [{
 
626
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i1;
 
627
}]>;
 
628
def pre_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset),
 
629
                            (pre_truncst node:$val, node:$base, node:$offset), [{
 
630
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i8;
 
631
}]>;
 
632
def pre_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset),
 
633
                             (pre_truncst node:$val, node:$base, node:$offset), [{
 
634
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i16;
 
635
}]>;
 
636
def pre_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset),
 
637
                             (pre_truncst node:$val, node:$base, node:$offset), [{
 
638
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i32;
 
639
}]>;
 
640
def pre_truncstf32 : PatFrag<(ops node:$val, node:$base, node:$offset),
 
641
                             (pre_truncst node:$val, node:$base, node:$offset), [{
 
642
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::f32;
 
643
}]>;
 
644
 
 
645
def post_store : PatFrag<(ops node:$val, node:$ptr, node:$offset),
 
646
                         (istore node:$val, node:$ptr, node:$offset), [{
 
647
  ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
 
648
  return AM == ISD::POST_INC || AM == ISD::POST_DEC;
 
649
}]>;
 
650
 
 
651
def post_truncst : PatFrag<(ops node:$val, node:$base, node:$offset),
 
652
                           (itruncstore node:$val, node:$base, node:$offset), [{
 
653
  ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
 
654
  return AM == ISD::POST_INC || AM == ISD::POST_DEC;
 
655
}]>;
 
656
def post_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset),
 
657
                             (post_truncst node:$val, node:$base, node:$offset), [{
 
658
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i1;
 
659
}]>;
 
660
def post_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset),
 
661
                             (post_truncst node:$val, node:$base, node:$offset), [{
 
662
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i8;
 
663
}]>;
 
664
def post_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset),
 
665
                              (post_truncst node:$val, node:$base, node:$offset), [{
 
666
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i16;
 
667
}]>;
 
668
def post_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset),
 
669
                              (post_truncst node:$val, node:$base, node:$offset), [{
 
670
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i32;
 
671
}]>;
 
672
def post_truncstf32 : PatFrag<(ops node:$val, node:$base, node:$offset),
 
673
                              (post_truncst node:$val, node:$base, node:$offset), [{
 
674
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::f32;
 
675
}]>;
 
676
 
 
677
// setcc convenience fragments.
 
678
def setoeq : PatFrag<(ops node:$lhs, node:$rhs),
 
679
                     (setcc node:$lhs, node:$rhs, SETOEQ)>;
 
680
def setogt : PatFrag<(ops node:$lhs, node:$rhs),
 
681
                     (setcc node:$lhs, node:$rhs, SETOGT)>;
 
682
def setoge : PatFrag<(ops node:$lhs, node:$rhs),
 
683
                     (setcc node:$lhs, node:$rhs, SETOGE)>;
 
684
def setolt : PatFrag<(ops node:$lhs, node:$rhs),
 
685
                     (setcc node:$lhs, node:$rhs, SETOLT)>;
 
686
def setole : PatFrag<(ops node:$lhs, node:$rhs),
 
687
                     (setcc node:$lhs, node:$rhs, SETOLE)>;
 
688
def setone : PatFrag<(ops node:$lhs, node:$rhs),
 
689
                     (setcc node:$lhs, node:$rhs, SETONE)>;
 
690
def seto   : PatFrag<(ops node:$lhs, node:$rhs),
 
691
                     (setcc node:$lhs, node:$rhs, SETO)>;
 
692
def setuo  : PatFrag<(ops node:$lhs, node:$rhs),
 
693
                     (setcc node:$lhs, node:$rhs, SETUO)>;
 
694
def setueq : PatFrag<(ops node:$lhs, node:$rhs),
 
695
                     (setcc node:$lhs, node:$rhs, SETUEQ)>;
 
696
def setugt : PatFrag<(ops node:$lhs, node:$rhs),
 
697
                     (setcc node:$lhs, node:$rhs, SETUGT)>;
 
698
def setuge : PatFrag<(ops node:$lhs, node:$rhs),
 
699
                     (setcc node:$lhs, node:$rhs, SETUGE)>;
 
700
def setult : PatFrag<(ops node:$lhs, node:$rhs),
 
701
                     (setcc node:$lhs, node:$rhs, SETULT)>;
 
702
def setule : PatFrag<(ops node:$lhs, node:$rhs),
 
703
                     (setcc node:$lhs, node:$rhs, SETULE)>;
 
704
def setune : PatFrag<(ops node:$lhs, node:$rhs),
 
705
                     (setcc node:$lhs, node:$rhs, SETUNE)>;
 
706
def seteq  : PatFrag<(ops node:$lhs, node:$rhs),
 
707
                     (setcc node:$lhs, node:$rhs, SETEQ)>;
 
708
def setgt  : PatFrag<(ops node:$lhs, node:$rhs),
 
709
                     (setcc node:$lhs, node:$rhs, SETGT)>;
 
710
def setge  : PatFrag<(ops node:$lhs, node:$rhs),
 
711
                     (setcc node:$lhs, node:$rhs, SETGE)>;
 
712
def setlt  : PatFrag<(ops node:$lhs, node:$rhs),
 
713
                     (setcc node:$lhs, node:$rhs, SETLT)>;
 
714
def setle  : PatFrag<(ops node:$lhs, node:$rhs),
 
715
                     (setcc node:$lhs, node:$rhs, SETLE)>;
 
716
def setne  : PatFrag<(ops node:$lhs, node:$rhs),
 
717
                     (setcc node:$lhs, node:$rhs, SETNE)>;
 
718
 
 
719
def atomic_cmp_swap_8 :
 
720
  PatFrag<(ops node:$ptr, node:$cmp, node:$swap),
 
721
          (atomic_cmp_swap node:$ptr, node:$cmp, node:$swap), [{
 
722
  return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
723
}]>;
 
724
def atomic_cmp_swap_16 :
 
725
  PatFrag<(ops node:$ptr, node:$cmp, node:$swap),
 
726
          (atomic_cmp_swap node:$ptr, node:$cmp, node:$swap), [{
 
727
  return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
728
}]>;
 
729
def atomic_cmp_swap_32 :
 
730
  PatFrag<(ops node:$ptr, node:$cmp, node:$swap),
 
731
          (atomic_cmp_swap node:$ptr, node:$cmp, node:$swap), [{
 
732
  return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
733
}]>;
 
734
def atomic_cmp_swap_64 :
 
735
  PatFrag<(ops node:$ptr, node:$cmp, node:$swap),
 
736
          (atomic_cmp_swap node:$ptr, node:$cmp, node:$swap), [{
 
737
  return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
738
}]>;
 
739
 
 
740
multiclass binary_atomic_op<SDNode atomic_op> {
 
741
  def _8 : PatFrag<(ops node:$ptr, node:$val),
 
742
                   (atomic_op node:$ptr, node:$val), [{
 
743
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
744
  }]>;
 
745
  def _16 : PatFrag<(ops node:$ptr, node:$val),
 
746
                   (atomic_op node:$ptr, node:$val), [{
 
747
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
748
  }]>;
 
749
  def _32 : PatFrag<(ops node:$ptr, node:$val),
 
750
                   (atomic_op node:$ptr, node:$val), [{
 
751
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
752
  }]>;
 
753
  def _64 : PatFrag<(ops node:$ptr, node:$val),
 
754
                   (atomic_op node:$ptr, node:$val), [{
 
755
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
756
  }]>;
 
757
}
 
758
 
 
759
defm atomic_load_add  : binary_atomic_op<atomic_load_add>;
 
760
defm atomic_swap      : binary_atomic_op<atomic_swap>;
 
761
defm atomic_load_sub  : binary_atomic_op<atomic_load_sub>;
 
762
defm atomic_load_and  : binary_atomic_op<atomic_load_and>;
 
763
defm atomic_load_or   : binary_atomic_op<atomic_load_or>;
 
764
defm atomic_load_xor  : binary_atomic_op<atomic_load_xor>;
 
765
defm atomic_load_nand : binary_atomic_op<atomic_load_nand>;
 
766
defm atomic_load_min  : binary_atomic_op<atomic_load_min>;
 
767
defm atomic_load_max  : binary_atomic_op<atomic_load_max>;
 
768
defm atomic_load_umin : binary_atomic_op<atomic_load_umin>;
 
769
defm atomic_load_umax : binary_atomic_op<atomic_load_umax>;
 
770
 
 
771
//===----------------------------------------------------------------------===//
 
772
// Selection DAG CONVERT_RNDSAT patterns
 
773
 
 
774
def cvtff : PatFrag<(ops node:$val, node:$dty, node:$sty, node:$rd, node:$sat),
 
775
    (cvt node:$val, node:$dty, node:$sty, node:$rd, node:$sat), [{
 
776
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_FF;
 
777
    }]>;
 
778
 
 
779
def cvtss : PatFrag<(ops node:$val, node:$dty, node:$sty, node:$rd, node:$sat),
 
780
    (cvt node:$val, node:$dty, node:$sty, node:$rd, node:$sat), [{
 
781
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_SS;
 
782
    }]>;
 
783
 
 
784
def cvtsu : PatFrag<(ops node:$val, node:$dty, node:$sty, node:$rd, node:$sat),
 
785
    (cvt node:$val, node:$dty, node:$sty, node:$rd, node:$sat), [{
 
786
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_SU;
 
787
    }]>;
 
788
 
 
789
def cvtus : PatFrag<(ops node:$val, node:$dty, node:$sty, node:$rd, node:$sat),
 
790
    (cvt node:$val, node:$dty, node:$sty, node:$rd, node:$sat), [{
 
791
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_US;
 
792
    }]>;
 
793
 
 
794
def cvtuu : PatFrag<(ops node:$val, node:$dty, node:$sty, node:$rd, node:$sat),
 
795
    (cvt node:$val, node:$dty, node:$sty, node:$rd, node:$sat), [{
 
796
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_UU;
 
797
    }]>;
 
798
 
 
799
def cvtsf : PatFrag<(ops node:$val, node:$dty, node:$sty, node:$rd, node:$sat),
 
800
    (cvt node:$val, node:$dty, node:$sty, node:$rd, node:$sat), [{
 
801
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_SF;
 
802
    }]>;
 
803
 
 
804
def cvtuf : PatFrag<(ops node:$val, node:$dty, node:$sty, node:$rd, node:$sat),
 
805
    (cvt node:$val, node:$dty, node:$sty, node:$rd, node:$sat), [{
 
806
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_UF;
 
807
    }]>;
 
808
 
 
809
def cvtfs : PatFrag<(ops node:$val, node:$dty, node:$sty, node:$rd, node:$sat),
 
810
    (cvt node:$val, node:$dty, node:$sty, node:$rd, node:$sat), [{
 
811
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_FS;
 
812
    }]>;
 
813
 
 
814
def cvtfu : PatFrag<(ops node:$val, node:$dty, node:$sty, node:$rd, node:$sat),
 
815
    (cvt node:$val, node:$dty, node:$sty, node:$rd, node:$sat), [{
 
816
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_FU;
 
817
    }]>;
 
818
 
 
819
//===----------------------------------------------------------------------===//
 
820
// Selection DAG Pattern Support.
 
821
//
 
822
// Patterns are what are actually matched against the target-flavored
 
823
// instruction selection DAG.  Instructions defined by the target implicitly
 
824
// define patterns in most cases, but patterns can also be explicitly added when
 
825
// an operation is defined by a sequence of instructions (e.g. loading a large
 
826
// immediate value on RISC targets that do not support immediates as large as
 
827
// their GPRs).
 
828
//
 
829
 
 
830
class Pattern<dag patternToMatch, list<dag> resultInstrs> {
 
831
  dag             PatternToMatch  = patternToMatch;
 
832
  list<dag>       ResultInstrs    = resultInstrs;
 
833
  list<Predicate> Predicates      = [];  // See class Instruction in Target.td.
 
834
  int             AddedComplexity = 0;  // See class Instruction in Target.td.
 
835
}
 
836
 
 
837
// Pat - A simple (but common) form of a pattern, which produces a simple result
 
838
// not needing a full list.
 
839
class Pat<dag pattern, dag result> : Pattern<pattern, [result]>;
 
840
 
 
841
//===----------------------------------------------------------------------===//
 
842
// Complex pattern definitions.
 
843
//
 
844
 
 
845
// Complex patterns, e.g. X86 addressing mode, requires pattern matching code
 
846
// in C++. NumOperands is the number of operands returned by the select function;
 
847
// SelectFunc is the name of the function used to pattern match the max. pattern;
 
848
// RootNodes are the list of possible root nodes of the sub-dags to match.
 
849
// e.g. X86 addressing mode - def addr : ComplexPattern<4, "SelectAddr", [add]>;
 
850
//
 
851
class ComplexPattern<ValueType ty, int numops, string fn,
 
852
                     list<SDNode> roots = [], list<SDNodeProperty> props = []> {
 
853
  ValueType Ty = ty;
 
854
  int NumOperands = numops;
 
855
  string SelectFunc = fn;
 
856
  list<SDNode> RootNodes = roots;
 
857
  list<SDNodeProperty> Properties = props;
 
858
}