← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/X86GenFastISel.inc

  • 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++/X86GenFastISel.inc
 
1
//===- TableGen'erated file -------------------------------------*- C++ -*-===//
 
2
//
 
3
// "Fast" Instruction Selector for the X86 target
 
4
//
 
5
// Automatically generated file, do not edit!
 
6
//
 
7
//===----------------------------------------------------------------------===//
 
8
 
 
9
// FastEmit functions for ISD::Constant.
 
10
 
 
11
unsigned FastEmit_ISD_Constant_MVT_i8_i(MVT RetVT, uint64_t imm0) {
 
12
  if (RetVT.SimpleTy != MVT::i8)
 
13
    return 0;
 
14
  return FastEmitInst_i(X86::MOV8ri, X86::GR8RegisterClass, imm0);
 
15
}
 
16
 
 
17
unsigned FastEmit_ISD_Constant_MVT_i16_i(MVT RetVT, uint64_t imm0) {
 
18
  if (RetVT.SimpleTy != MVT::i16)
 
19
    return 0;
 
20
  return FastEmitInst_i(X86::MOV16ri, X86::GR16RegisterClass, imm0);
 
21
}
 
22
 
 
23
unsigned FastEmit_ISD_Constant_MVT_i32_i(MVT RetVT, uint64_t imm0) {
 
24
  if (RetVT.SimpleTy != MVT::i32)
 
25
    return 0;
 
26
  return FastEmitInst_i(X86::MOV32ri, X86::GR32RegisterClass, imm0);
 
27
}
 
28
 
 
29
unsigned FastEmit_ISD_Constant_MVT_i64_i(MVT RetVT, uint64_t imm0) {
 
30
  if (RetVT.SimpleTy != MVT::i64)
 
31
    return 0;
 
32
  return FastEmitInst_i(X86::MOV64ri, X86::GR64RegisterClass, imm0);
 
33
}
 
34
 
 
35
unsigned FastEmit_ISD_Constant_i(MVT VT, MVT RetVT, uint64_t imm0) {
 
36
  switch (VT.SimpleTy) {
 
37
  case MVT::i8: return FastEmit_ISD_Constant_MVT_i8_i(RetVT, imm0);
 
38
  case MVT::i16: return FastEmit_ISD_Constant_MVT_i16_i(RetVT, imm0);
 
39
  case MVT::i32: return FastEmit_ISD_Constant_MVT_i32_i(RetVT, imm0);
 
40
  case MVT::i64: return FastEmit_ISD_Constant_MVT_i64_i(RetVT, imm0);
 
41
  default: return 0;
 
42
  }
 
43
}
 
44
 
 
45
// Top-level FastEmit function.
 
46
 
 
47
unsigned FastEmit_i(MVT VT, MVT RetVT, unsigned Opcode, uint64_t imm0) {
 
48
  switch (Opcode) {
 
49
  case ISD::Constant: return FastEmit_ISD_Constant_i(VT, RetVT, imm0);
 
50
  default: return 0;
 
51
  }
 
52
}
 
53
 
 
54
// FastEmit functions for ISD::ANY_EXTEND.
 
55
 
 
56
unsigned FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i16_r(unsigned Op0) {
 
57
  return FastEmitInst_r(X86::MOVZX16rr8, X86::GR16RegisterClass, Op0);
 
58
}
 
59
 
 
60
unsigned FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i32_r(unsigned Op0) {
 
61
  return FastEmitInst_r(X86::MOVZX32rr8, X86::GR32RegisterClass, Op0);
 
62
}
 
63
 
 
64
unsigned FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i64_r(unsigned Op0) {
 
65
  return FastEmitInst_r(X86::MOVZX64rr8, X86::GR64RegisterClass, Op0);
 
66
}
 
67
 
 
68
unsigned FastEmit_ISD_ANY_EXTEND_MVT_i8_r(MVT RetVT, unsigned Op0) {
 
69
switch (RetVT.SimpleTy) {
 
70
  case MVT::i16: return FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i16_r(Op0);
 
71
  case MVT::i32: return FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i32_r(Op0);
 
72
  case MVT::i64: return FastEmit_ISD_ANY_EXTEND_MVT_i8_MVT_i64_r(Op0);
 
73
  default: return 0;
 
74
}
 
75
}
 
76
 
 
77
unsigned FastEmit_ISD_ANY_EXTEND_MVT_i16_MVT_i32_r(unsigned Op0) {
 
78
  return FastEmitInst_r(X86::MOVZX32rr16, X86::GR32RegisterClass, Op0);
 
79
}
 
80
 
 
81
unsigned FastEmit_ISD_ANY_EXTEND_MVT_i16_MVT_i64_r(unsigned Op0) {
 
82
  return FastEmitInst_r(X86::MOVZX64rr16, X86::GR64RegisterClass, Op0);
 
83
}
 
84
 
 
85
unsigned FastEmit_ISD_ANY_EXTEND_MVT_i16_r(MVT RetVT, unsigned Op0) {
 
86
switch (RetVT.SimpleTy) {
 
87
  case MVT::i32: return FastEmit_ISD_ANY_EXTEND_MVT_i16_MVT_i32_r(Op0);
 
88
  case MVT::i64: return FastEmit_ISD_ANY_EXTEND_MVT_i16_MVT_i64_r(Op0);
 
89
  default: return 0;
 
90
}
 
91
}
 
92
 
 
93
unsigned FastEmit_ISD_ANY_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0) {
 
94
  switch (VT.SimpleTy) {
 
95
  case MVT::i8: return FastEmit_ISD_ANY_EXTEND_MVT_i8_r(RetVT, Op0);
 
96
  case MVT::i16: return FastEmit_ISD_ANY_EXTEND_MVT_i16_r(RetVT, Op0);
 
97
  default: return 0;
 
98
  }
 
99
}
 
100
 
 
101
// FastEmit functions for ISD::BIT_CONVERT.
 
102
 
 
103
unsigned FastEmit_ISD_BIT_CONVERT_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
104
  if (RetVT.SimpleTy != MVT::f32)
 
105
    return 0;
 
106
  if ((Subtarget->hasSSE2())) {
 
107
    return FastEmitInst_r(X86::MOVDI2SSrr, X86::FR32RegisterClass, Op0);
 
108
  }
 
109
  return 0;
 
110
}
 
111
 
 
112
unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_f64_r(unsigned Op0) {
 
113
  if ((Subtarget->hasSSE2())) {
 
114
    return FastEmitInst_r(X86::MOV64toSDrr, X86::FR64RegisterClass, Op0);
 
115
  }
 
116
  return 0;
 
117
}
 
118
 
 
119
unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v8i8_r(unsigned Op0) {
 
120
  return FastEmitInst_r(X86::MMX_MOVD64to64rr, X86::VR64RegisterClass, Op0);
 
121
}
 
122
 
 
123
unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v4i16_r(unsigned Op0) {
 
124
  return FastEmitInst_r(X86::MMX_MOVD64to64rr, X86::VR64RegisterClass, Op0);
 
125
}
 
126
 
 
127
unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v2i32_r(unsigned Op0) {
 
128
  return FastEmitInst_r(X86::MMX_MOVD64to64rr, X86::VR64RegisterClass, Op0);
 
129
}
 
130
 
 
131
unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v1i64_r(unsigned Op0) {
 
132
  return FastEmitInst_r(X86::MMX_MOVD64to64rr, X86::VR64RegisterClass, Op0);
 
133
}
 
134
 
 
135
unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v2f32_r(unsigned Op0) {
 
136
  return FastEmitInst_r(X86::MMX_MOVD64to64rr, X86::VR64RegisterClass, Op0);
 
137
}
 
138
 
 
139
unsigned FastEmit_ISD_BIT_CONVERT_MVT_i64_r(MVT RetVT, unsigned Op0) {
 
140
switch (RetVT.SimpleTy) {
 
141
  case MVT::f64: return FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_f64_r(Op0);
 
142
  case MVT::v8i8: return FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v8i8_r(Op0);
 
143
  case MVT::v4i16: return FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v4i16_r(Op0);
 
144
  case MVT::v2i32: return FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v2i32_r(Op0);
 
145
  case MVT::v1i64: return FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v1i64_r(Op0);
 
146
  case MVT::v2f32: return FastEmit_ISD_BIT_CONVERT_MVT_i64_MVT_v2f32_r(Op0);
 
147
  default: return 0;
 
148
}
 
149
}
 
150
 
 
151
unsigned FastEmit_ISD_BIT_CONVERT_MVT_f32_r(MVT RetVT, unsigned Op0) {
 
152
  if (RetVT.SimpleTy != MVT::i32)
 
153
    return 0;
 
154
  if ((Subtarget->hasSSE2())) {
 
155
    return FastEmitInst_r(X86::MOVSS2DIrr, X86::GR32RegisterClass, Op0);
 
156
  }
 
157
  return 0;
 
158
}
 
159
 
 
160
unsigned FastEmit_ISD_BIT_CONVERT_MVT_f64_r(MVT RetVT, unsigned Op0) {
 
161
  if (RetVT.SimpleTy != MVT::i64)
 
162
    return 0;
 
163
  if ((Subtarget->hasSSE2())) {
 
164
    return FastEmitInst_r(X86::MOVSDto64rr, X86::GR64RegisterClass, Op0);
 
165
  }
 
166
  return 0;
 
167
}
 
168
 
 
169
unsigned FastEmit_ISD_BIT_CONVERT_MVT_v8i8_MVT_i64_r(unsigned Op0) {
 
170
  return FastEmitInst_r(X86::MMX_MOVD64from64rr, X86::GR64RegisterClass, Op0);
 
171
}
 
172
 
 
173
unsigned FastEmit_ISD_BIT_CONVERT_MVT_v8i8_MVT_f64_r(unsigned Op0) {
 
174
  return FastEmitInst_r(X86::MMX_MOVQ2FR64rr, X86::FR64RegisterClass, Op0);
 
175
}
 
176
 
 
177
unsigned FastEmit_ISD_BIT_CONVERT_MVT_v8i8_r(MVT RetVT, unsigned Op0) {
 
178
switch (RetVT.SimpleTy) {
 
179
  case MVT::i64: return FastEmit_ISD_BIT_CONVERT_MVT_v8i8_MVT_i64_r(Op0);
 
180
  case MVT::f64: return FastEmit_ISD_BIT_CONVERT_MVT_v8i8_MVT_f64_r(Op0);
 
181
  default: return 0;
 
182
}
 
183
}
 
184
 
 
185
unsigned FastEmit_ISD_BIT_CONVERT_MVT_v4i16_MVT_i64_r(unsigned Op0) {
 
186
  return FastEmitInst_r(X86::MMX_MOVD64from64rr, X86::GR64RegisterClass, Op0);
 
187
}
 
188
 
 
189
unsigned FastEmit_ISD_BIT_CONVERT_MVT_v4i16_MVT_f64_r(unsigned Op0) {
 
190
  return FastEmitInst_r(X86::MMX_MOVQ2FR64rr, X86::FR64RegisterClass, Op0);
 
191
}
 
192
 
 
193
unsigned FastEmit_ISD_BIT_CONVERT_MVT_v4i16_r(MVT RetVT, unsigned Op0) {
 
194
switch (RetVT.SimpleTy) {
 
195
  case MVT::i64: return FastEmit_ISD_BIT_CONVERT_MVT_v4i16_MVT_i64_r(Op0);
 
196
  case MVT::f64: return FastEmit_ISD_BIT_CONVERT_MVT_v4i16_MVT_f64_r(Op0);
 
197
  default: return 0;
 
198
}
 
199
}
 
200
 
 
201
unsigned FastEmit_ISD_BIT_CONVERT_MVT_v2i32_MVT_i64_r(unsigned Op0) {
 
202
  return FastEmitInst_r(X86::MMX_MOVD64from64rr, X86::GR64RegisterClass, Op0);
 
203
}
 
204
 
 
205
unsigned FastEmit_ISD_BIT_CONVERT_MVT_v2i32_MVT_f64_r(unsigned Op0) {
 
206
  return FastEmitInst_r(X86::MMX_MOVQ2FR64rr, X86::FR64RegisterClass, Op0);
 
207
}
 
208
 
 
209
unsigned FastEmit_ISD_BIT_CONVERT_MVT_v2i32_r(MVT RetVT, unsigned Op0) {
 
210
switch (RetVT.SimpleTy) {
 
211
  case MVT::i64: return FastEmit_ISD_BIT_CONVERT_MVT_v2i32_MVT_i64_r(Op0);
 
212
  case MVT::f64: return FastEmit_ISD_BIT_CONVERT_MVT_v2i32_MVT_f64_r(Op0);
 
213
  default: return 0;
 
214
}
 
215
}
 
216
 
 
217
unsigned FastEmit_ISD_BIT_CONVERT_MVT_v1i64_MVT_i64_r(unsigned Op0) {
 
218
  return FastEmitInst_r(X86::MMX_MOVD64from64rr, X86::GR64RegisterClass, Op0);
 
219
}
 
220
 
 
221
unsigned FastEmit_ISD_BIT_CONVERT_MVT_v1i64_MVT_f64_r(unsigned Op0) {
 
222
  return FastEmitInst_r(X86::MMX_MOVQ2FR64rr, X86::FR64RegisterClass, Op0);
 
223
}
 
224
 
 
225
unsigned FastEmit_ISD_BIT_CONVERT_MVT_v1i64_r(MVT RetVT, unsigned Op0) {
 
226
switch (RetVT.SimpleTy) {
 
227
  case MVT::i64: return FastEmit_ISD_BIT_CONVERT_MVT_v1i64_MVT_i64_r(Op0);
 
228
  case MVT::f64: return FastEmit_ISD_BIT_CONVERT_MVT_v1i64_MVT_f64_r(Op0);
 
229
  default: return 0;
 
230
}
 
231
}
 
232
 
 
233
unsigned FastEmit_ISD_BIT_CONVERT_MVT_v2f32_r(MVT RetVT, unsigned Op0) {
 
234
  if (RetVT.SimpleTy != MVT::i64)
 
235
    return 0;
 
236
  return FastEmitInst_r(X86::MMX_MOVD64from64rr, X86::GR64RegisterClass, Op0);
 
237
}
 
238
 
 
239
unsigned FastEmit_ISD_BIT_CONVERT_r(MVT VT, MVT RetVT, unsigned Op0) {
 
240
  switch (VT.SimpleTy) {
 
241
  case MVT::i32: return FastEmit_ISD_BIT_CONVERT_MVT_i32_r(RetVT, Op0);
 
242
  case MVT::i64: return FastEmit_ISD_BIT_CONVERT_MVT_i64_r(RetVT, Op0);
 
243
  case MVT::f32: return FastEmit_ISD_BIT_CONVERT_MVT_f32_r(RetVT, Op0);
 
244
  case MVT::f64: return FastEmit_ISD_BIT_CONVERT_MVT_f64_r(RetVT, Op0);
 
245
  case MVT::v8i8: return FastEmit_ISD_BIT_CONVERT_MVT_v8i8_r(RetVT, Op0);
 
246
  case MVT::v4i16: return FastEmit_ISD_BIT_CONVERT_MVT_v4i16_r(RetVT, Op0);
 
247
  case MVT::v2i32: return FastEmit_ISD_BIT_CONVERT_MVT_v2i32_r(RetVT, Op0);
 
248
  case MVT::v1i64: return FastEmit_ISD_BIT_CONVERT_MVT_v1i64_r(RetVT, Op0);
 
249
  case MVT::v2f32: return FastEmit_ISD_BIT_CONVERT_MVT_v2f32_r(RetVT, Op0);
 
250
  default: return 0;
 
251
  }
 
252
}
 
253
 
 
254
// FastEmit functions for ISD::BRIND.
 
255
 
 
256
unsigned FastEmit_ISD_BRIND_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
257
  if (RetVT.SimpleTy != MVT::isVoid)
 
258
    return 0;
 
259
  return FastEmitInst_r(X86::JMP32r, X86::GR32RegisterClass, Op0);
 
260
}
 
261
 
 
262
unsigned FastEmit_ISD_BRIND_MVT_i64_r(MVT RetVT, unsigned Op0) {
 
263
  if (RetVT.SimpleTy != MVT::isVoid)
 
264
    return 0;
 
265
  return FastEmitInst_r(X86::JMP64r, X86::GR64RegisterClass, Op0);
 
266
}
 
267
 
 
268
unsigned FastEmit_ISD_BRIND_r(MVT VT, MVT RetVT, unsigned Op0) {
 
269
  switch (VT.SimpleTy) {
 
270
  case MVT::i32: return FastEmit_ISD_BRIND_MVT_i32_r(RetVT, Op0);
 
271
  case MVT::i64: return FastEmit_ISD_BRIND_MVT_i64_r(RetVT, Op0);
 
272
  default: return 0;
 
273
  }
 
274
}
 
275
 
 
276
// FastEmit functions for ISD::BSWAP.
 
277
 
 
278
unsigned FastEmit_ISD_BSWAP_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
279
  if (RetVT.SimpleTy != MVT::i32)
 
280
    return 0;
 
281
  return FastEmitInst_r(X86::BSWAP32r, X86::GR32RegisterClass, Op0);
 
282
}
 
283
 
 
284
unsigned FastEmit_ISD_BSWAP_MVT_i64_r(MVT RetVT, unsigned Op0) {
 
285
  if (RetVT.SimpleTy != MVT::i64)
 
286
    return 0;
 
287
  return FastEmitInst_r(X86::BSWAP64r, X86::GR64RegisterClass, Op0);
 
288
}
 
289
 
 
290
unsigned FastEmit_ISD_BSWAP_r(MVT VT, MVT RetVT, unsigned Op0) {
 
291
  switch (VT.SimpleTy) {
 
292
  case MVT::i32: return FastEmit_ISD_BSWAP_MVT_i32_r(RetVT, Op0);
 
293
  case MVT::i64: return FastEmit_ISD_BSWAP_MVT_i64_r(RetVT, Op0);
 
294
  default: return 0;
 
295
  }
 
296
}
 
297
 
 
298
// FastEmit functions for ISD::FABS.
 
299
 
 
300
unsigned FastEmit_ISD_FABS_MVT_f32_r(MVT RetVT, unsigned Op0) {
 
301
  if (RetVT.SimpleTy != MVT::f32)
 
302
    return 0;
 
303
  if ((!Subtarget->hasSSE1())) {
 
304
    return FastEmitInst_r(X86::ABS_Fp32, X86::RFP32RegisterClass, Op0);
 
305
  }
 
306
  return 0;
 
307
}
 
308
 
 
309
unsigned FastEmit_ISD_FABS_MVT_f64_r(MVT RetVT, unsigned Op0) {
 
310
  if (RetVT.SimpleTy != MVT::f64)
 
311
    return 0;
 
312
  if ((!Subtarget->hasSSE2())) {
 
313
    return FastEmitInst_r(X86::ABS_Fp64, X86::RFP64RegisterClass, Op0);
 
314
  }
 
315
  return 0;
 
316
}
 
317
 
 
318
unsigned FastEmit_ISD_FABS_MVT_f80_r(MVT RetVT, unsigned Op0) {
 
319
  if (RetVT.SimpleTy != MVT::f80)
 
320
    return 0;
 
321
  return FastEmitInst_r(X86::ABS_Fp80, X86::RFP80RegisterClass, Op0);
 
322
}
 
323
 
 
324
unsigned FastEmit_ISD_FABS_r(MVT VT, MVT RetVT, unsigned Op0) {
 
325
  switch (VT.SimpleTy) {
 
326
  case MVT::f32: return FastEmit_ISD_FABS_MVT_f32_r(RetVT, Op0);
 
327
  case MVT::f64: return FastEmit_ISD_FABS_MVT_f64_r(RetVT, Op0);
 
328
  case MVT::f80: return FastEmit_ISD_FABS_MVT_f80_r(RetVT, Op0);
 
329
  default: return 0;
 
330
  }
 
331
}
 
332
 
 
333
// FastEmit functions for ISD::FCOS.
 
334
 
 
335
unsigned FastEmit_ISD_FCOS_MVT_f32_r(MVT RetVT, unsigned Op0) {
 
336
  if (RetVT.SimpleTy != MVT::f32)
 
337
    return 0;
 
338
  if ((!Subtarget->hasSSE1())) {
 
339
    return FastEmitInst_r(X86::COS_Fp32, X86::RFP32RegisterClass, Op0);
 
340
  }
 
341
  return 0;
 
342
}
 
343
 
 
344
unsigned FastEmit_ISD_FCOS_MVT_f64_r(MVT RetVT, unsigned Op0) {
 
345
  if (RetVT.SimpleTy != MVT::f64)
 
346
    return 0;
 
347
  if ((!Subtarget->hasSSE2())) {
 
348
    return FastEmitInst_r(X86::COS_Fp64, X86::RFP64RegisterClass, Op0);
 
349
  }
 
350
  return 0;
 
351
}
 
352
 
 
353
unsigned FastEmit_ISD_FCOS_MVT_f80_r(MVT RetVT, unsigned Op0) {
 
354
  if (RetVT.SimpleTy != MVT::f80)
 
355
    return 0;
 
356
  return FastEmitInst_r(X86::COS_Fp80, X86::RFP80RegisterClass, Op0);
 
357
}
 
358
 
 
359
unsigned FastEmit_ISD_FCOS_r(MVT VT, MVT RetVT, unsigned Op0) {
 
360
  switch (VT.SimpleTy) {
 
361
  case MVT::f32: return FastEmit_ISD_FCOS_MVT_f32_r(RetVT, Op0);
 
362
  case MVT::f64: return FastEmit_ISD_FCOS_MVT_f64_r(RetVT, Op0);
 
363
  case MVT::f80: return FastEmit_ISD_FCOS_MVT_f80_r(RetVT, Op0);
 
364
  default: return 0;
 
365
  }
 
366
}
 
367
 
 
368
// FastEmit functions for ISD::FNEG.
 
369
 
 
370
unsigned FastEmit_ISD_FNEG_MVT_f32_r(MVT RetVT, unsigned Op0) {
 
371
  if (RetVT.SimpleTy != MVT::f32)
 
372
    return 0;
 
373
  if ((!Subtarget->hasSSE1())) {
 
374
    return FastEmitInst_r(X86::CHS_Fp32, X86::RFP32RegisterClass, Op0);
 
375
  }
 
376
  return 0;
 
377
}
 
378
 
 
379
unsigned FastEmit_ISD_FNEG_MVT_f64_r(MVT RetVT, unsigned Op0) {
 
380
  if (RetVT.SimpleTy != MVT::f64)
 
381
    return 0;
 
382
  if ((!Subtarget->hasSSE2())) {
 
383
    return FastEmitInst_r(X86::CHS_Fp64, X86::RFP64RegisterClass, Op0);
 
384
  }
 
385
  return 0;
 
386
}
 
387
 
 
388
unsigned FastEmit_ISD_FNEG_MVT_f80_r(MVT RetVT, unsigned Op0) {
 
389
  if (RetVT.SimpleTy != MVT::f80)
 
390
    return 0;
 
391
  return FastEmitInst_r(X86::CHS_Fp80, X86::RFP80RegisterClass, Op0);
 
392
}
 
393
 
 
394
unsigned FastEmit_ISD_FNEG_r(MVT VT, MVT RetVT, unsigned Op0) {
 
395
  switch (VT.SimpleTy) {
 
396
  case MVT::f32: return FastEmit_ISD_FNEG_MVT_f32_r(RetVT, Op0);
 
397
  case MVT::f64: return FastEmit_ISD_FNEG_MVT_f64_r(RetVT, Op0);
 
398
  case MVT::f80: return FastEmit_ISD_FNEG_MVT_f80_r(RetVT, Op0);
 
399
  default: return 0;
 
400
  }
 
401
}
 
402
 
 
403
// FastEmit functions for ISD::FP_EXTEND.
 
404
 
 
405
unsigned FastEmit_ISD_FP_EXTEND_MVT_f32_MVT_f64_r(unsigned Op0) {
 
406
  if ((!Subtarget->hasSSE1())) {
 
407
    return FastEmitInst_r(X86::MOV_Fp3264, X86::RFP64RegisterClass, Op0);
 
408
  }
 
409
  if ((Subtarget->hasSSE2())) {
 
410
    return FastEmitInst_r(X86::CVTSS2SDrr, X86::FR64RegisterClass, Op0);
 
411
  }
 
412
  return 0;
 
413
}
 
414
 
 
415
unsigned FastEmit_ISD_FP_EXTEND_MVT_f32_MVT_f80_r(unsigned Op0) {
 
416
  if ((!Subtarget->hasSSE1())) {
 
417
    return FastEmitInst_r(X86::MOV_Fp3280, X86::RFP80RegisterClass, Op0);
 
418
  }
 
419
  return 0;
 
420
}
 
421
 
 
422
unsigned FastEmit_ISD_FP_EXTEND_MVT_f32_r(MVT RetVT, unsigned Op0) {
 
423
switch (RetVT.SimpleTy) {
 
424
  case MVT::f64: return FastEmit_ISD_FP_EXTEND_MVT_f32_MVT_f64_r(Op0);
 
425
  case MVT::f80: return FastEmit_ISD_FP_EXTEND_MVT_f32_MVT_f80_r(Op0);
 
426
  default: return 0;
 
427
}
 
428
}
 
429
 
 
430
unsigned FastEmit_ISD_FP_EXTEND_MVT_f64_r(MVT RetVT, unsigned Op0) {
 
431
  if (RetVT.SimpleTy != MVT::f80)
 
432
    return 0;
 
433
  if ((!Subtarget->hasSSE2())) {
 
434
    return FastEmitInst_r(X86::MOV_Fp6480, X86::RFP80RegisterClass, Op0);
 
435
  }
 
436
  return 0;
 
437
}
 
438
 
 
439
unsigned FastEmit_ISD_FP_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0) {
 
440
  switch (VT.SimpleTy) {
 
441
  case MVT::f32: return FastEmit_ISD_FP_EXTEND_MVT_f32_r(RetVT, Op0);
 
442
  case MVT::f64: return FastEmit_ISD_FP_EXTEND_MVT_f64_r(RetVT, Op0);
 
443
  default: return 0;
 
444
  }
 
445
}
 
446
 
 
447
// FastEmit functions for ISD::FP_ROUND.
 
448
 
 
449
unsigned FastEmit_ISD_FP_ROUND_MVT_f64_r(MVT RetVT, unsigned Op0) {
 
450
  if (RetVT.SimpleTy != MVT::f32)
 
451
    return 0;
 
452
  if ((!Subtarget->hasSSE1())) {
 
453
    return FastEmitInst_r(X86::MOV_Fp6432, X86::RFP32RegisterClass, Op0);
 
454
  }
 
455
  if ((Subtarget->hasSSE2())) {
 
456
    return FastEmitInst_r(X86::CVTSD2SSrr, X86::FR32RegisterClass, Op0);
 
457
  }
 
458
  return 0;
 
459
}
 
460
 
 
461
unsigned FastEmit_ISD_FP_ROUND_MVT_f80_MVT_f32_r(unsigned Op0) {
 
462
  if ((!Subtarget->hasSSE1())) {
 
463
    return FastEmitInst_r(X86::MOV_Fp8032, X86::RFP32RegisterClass, Op0);
 
464
  }
 
465
  return 0;
 
466
}
 
467
 
 
468
unsigned FastEmit_ISD_FP_ROUND_MVT_f80_MVT_f64_r(unsigned Op0) {
 
469
  if ((!Subtarget->hasSSE2())) {
 
470
    return FastEmitInst_r(X86::MOV_Fp8064, X86::RFP64RegisterClass, Op0);
 
471
  }
 
472
  return 0;
 
473
}
 
474
 
 
475
unsigned FastEmit_ISD_FP_ROUND_MVT_f80_r(MVT RetVT, unsigned Op0) {
 
476
switch (RetVT.SimpleTy) {
 
477
  case MVT::f32: return FastEmit_ISD_FP_ROUND_MVT_f80_MVT_f32_r(Op0);
 
478
  case MVT::f64: return FastEmit_ISD_FP_ROUND_MVT_f80_MVT_f64_r(Op0);
 
479
  default: return 0;
 
480
}
 
481
}
 
482
 
 
483
unsigned FastEmit_ISD_FP_ROUND_r(MVT VT, MVT RetVT, unsigned Op0) {
 
484
  switch (VT.SimpleTy) {
 
485
  case MVT::f64: return FastEmit_ISD_FP_ROUND_MVT_f64_r(RetVT, Op0);
 
486
  case MVT::f80: return FastEmit_ISD_FP_ROUND_MVT_f80_r(RetVT, Op0);
 
487
  default: return 0;
 
488
  }
 
489
}
 
490
 
 
491
// FastEmit functions for ISD::FP_TO_SINT.
 
492
 
 
493
unsigned FastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i32_r(unsigned Op0) {
 
494
  if ((Subtarget->hasSSE1())) {
 
495
    return FastEmitInst_r(X86::CVTTSS2SIrr, X86::GR32RegisterClass, Op0);
 
496
  }
 
497
  return 0;
 
498
}
 
499
 
 
500
unsigned FastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i64_r(unsigned Op0) {
 
501
  if ((Subtarget->hasSSE1())) {
 
502
    return FastEmitInst_r(X86::CVTTSS2SI64rr, X86::GR64RegisterClass, Op0);
 
503
  }
 
504
  return 0;
 
505
}
 
506
 
 
507
unsigned FastEmit_ISD_FP_TO_SINT_MVT_f32_r(MVT RetVT, unsigned Op0) {
 
508
switch (RetVT.SimpleTy) {
 
509
  case MVT::i32: return FastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i32_r(Op0);
 
510
  case MVT::i64: return FastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i64_r(Op0);
 
511
  default: return 0;
 
512
}
 
513
}
 
514
 
 
515
unsigned FastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i32_r(unsigned Op0) {
 
516
  if ((Subtarget->hasSSE2())) {
 
517
    return FastEmitInst_r(X86::CVTTSD2SIrr, X86::GR32RegisterClass, Op0);
 
518
  }
 
519
  return 0;
 
520
}
 
521
 
 
522
unsigned FastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i64_r(unsigned Op0) {
 
523
  if ((Subtarget->hasSSE2())) {
 
524
    return FastEmitInst_r(X86::CVTTSD2SI64rr, X86::GR64RegisterClass, Op0);
 
525
  }
 
526
  return 0;
 
527
}
 
528
 
 
529
unsigned FastEmit_ISD_FP_TO_SINT_MVT_f64_r(MVT RetVT, unsigned Op0) {
 
530
switch (RetVT.SimpleTy) {
 
531
  case MVT::i32: return FastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i32_r(Op0);
 
532
  case MVT::i64: return FastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i64_r(Op0);
 
533
  default: return 0;
 
534
}
 
535
}
 
536
 
 
537
unsigned FastEmit_ISD_FP_TO_SINT_MVT_v4f32_r(MVT RetVT, unsigned Op0) {
 
538
  if (RetVT.SimpleTy != MVT::v4i32)
 
539
    return 0;
 
540
  if ((Subtarget->hasSSE2())) {
 
541
    return FastEmitInst_r(X86::Int_CVTTPS2DQrr, X86::VR128RegisterClass, Op0);
 
542
  }
 
543
  return 0;
 
544
}
 
545
 
 
546
unsigned FastEmit_ISD_FP_TO_SINT_MVT_v2f64_r(MVT RetVT, unsigned Op0) {
 
547
  if (RetVT.SimpleTy != MVT::v2i32)
 
548
    return 0;
 
549
  if ((Subtarget->hasSSE2())) {
 
550
    return FastEmitInst_r(X86::Int_CVTTPD2PIrr, X86::VR64RegisterClass, Op0);
 
551
  }
 
552
  return 0;
 
553
}
 
554
 
 
555
unsigned FastEmit_ISD_FP_TO_SINT_r(MVT VT, MVT RetVT, unsigned Op0) {
 
556
  switch (VT.SimpleTy) {
 
557
  case MVT::f32: return FastEmit_ISD_FP_TO_SINT_MVT_f32_r(RetVT, Op0);
 
558
  case MVT::f64: return FastEmit_ISD_FP_TO_SINT_MVT_f64_r(RetVT, Op0);
 
559
  case MVT::v4f32: return FastEmit_ISD_FP_TO_SINT_MVT_v4f32_r(RetVT, Op0);
 
560
  case MVT::v2f64: return FastEmit_ISD_FP_TO_SINT_MVT_v2f64_r(RetVT, Op0);
 
561
  default: return 0;
 
562
  }
 
563
}
 
564
 
 
565
// FastEmit functions for ISD::FSIN.
 
566
 
 
567
unsigned FastEmit_ISD_FSIN_MVT_f32_r(MVT RetVT, unsigned Op0) {
 
568
  if (RetVT.SimpleTy != MVT::f32)
 
569
    return 0;
 
570
  if ((!Subtarget->hasSSE1())) {
 
571
    return FastEmitInst_r(X86::SIN_Fp32, X86::RFP32RegisterClass, Op0);
 
572
  }
 
573
  return 0;
 
574
}
 
575
 
 
576
unsigned FastEmit_ISD_FSIN_MVT_f64_r(MVT RetVT, unsigned Op0) {
 
577
  if (RetVT.SimpleTy != MVT::f64)
 
578
    return 0;
 
579
  if ((!Subtarget->hasSSE2())) {
 
580
    return FastEmitInst_r(X86::SIN_Fp64, X86::RFP64RegisterClass, Op0);
 
581
  }
 
582
  return 0;
 
583
}
 
584
 
 
585
unsigned FastEmit_ISD_FSIN_MVT_f80_r(MVT RetVT, unsigned Op0) {
 
586
  if (RetVT.SimpleTy != MVT::f80)
 
587
    return 0;
 
588
  return FastEmitInst_r(X86::SIN_Fp80, X86::RFP80RegisterClass, Op0);
 
589
}
 
590
 
 
591
unsigned FastEmit_ISD_FSIN_r(MVT VT, MVT RetVT, unsigned Op0) {
 
592
  switch (VT.SimpleTy) {
 
593
  case MVT::f32: return FastEmit_ISD_FSIN_MVT_f32_r(RetVT, Op0);
 
594
  case MVT::f64: return FastEmit_ISD_FSIN_MVT_f64_r(RetVT, Op0);
 
595
  case MVT::f80: return FastEmit_ISD_FSIN_MVT_f80_r(RetVT, Op0);
 
596
  default: return 0;
 
597
  }
 
598
}
 
599
 
 
600
// FastEmit functions for ISD::FSQRT.
 
601
 
 
602
unsigned FastEmit_ISD_FSQRT_MVT_f32_r(MVT RetVT, unsigned Op0) {
 
603
  if (RetVT.SimpleTy != MVT::f32)
 
604
    return 0;
 
605
  if ((!Subtarget->hasSSE1())) {
 
606
    return FastEmitInst_r(X86::SQRT_Fp32, X86::RFP32RegisterClass, Op0);
 
607
  }
 
608
  if ((Subtarget->hasSSE1())) {
 
609
    return FastEmitInst_r(X86::SQRTSSr, X86::FR32RegisterClass, Op0);
 
610
  }
 
611
  return 0;
 
612
}
 
613
 
 
614
unsigned FastEmit_ISD_FSQRT_MVT_f64_r(MVT RetVT, unsigned Op0) {
 
615
  if (RetVT.SimpleTy != MVT::f64)
 
616
    return 0;
 
617
  if ((!Subtarget->hasSSE2())) {
 
618
    return FastEmitInst_r(X86::SQRT_Fp64, X86::RFP64RegisterClass, Op0);
 
619
  }
 
620
  if ((Subtarget->hasSSE2())) {
 
621
    return FastEmitInst_r(X86::SQRTSDr, X86::FR64RegisterClass, Op0);
 
622
  }
 
623
  return 0;
 
624
}
 
625
 
 
626
unsigned FastEmit_ISD_FSQRT_MVT_f80_r(MVT RetVT, unsigned Op0) {
 
627
  if (RetVT.SimpleTy != MVT::f80)
 
628
    return 0;
 
629
  return FastEmitInst_r(X86::SQRT_Fp80, X86::RFP80RegisterClass, Op0);
 
630
}
 
631
 
 
632
unsigned FastEmit_ISD_FSQRT_MVT_v4f32_r(MVT RetVT, unsigned Op0) {
 
633
  if (RetVT.SimpleTy != MVT::v4f32)
 
634
    return 0;
 
635
  if ((Subtarget->hasSSE1())) {
 
636
    return FastEmitInst_r(X86::SQRTPSr, X86::VR128RegisterClass, Op0);
 
637
  }
 
638
  return 0;
 
639
}
 
640
 
 
641
unsigned FastEmit_ISD_FSQRT_MVT_v2f64_r(MVT RetVT, unsigned Op0) {
 
642
  if (RetVT.SimpleTy != MVT::v2f64)
 
643
    return 0;
 
644
  if ((Subtarget->hasSSE2())) {
 
645
    return FastEmitInst_r(X86::SQRTPDr, X86::VR128RegisterClass, Op0);
 
646
  }
 
647
  return 0;
 
648
}
 
649
 
 
650
unsigned FastEmit_ISD_FSQRT_r(MVT VT, MVT RetVT, unsigned Op0) {
 
651
  switch (VT.SimpleTy) {
 
652
  case MVT::f32: return FastEmit_ISD_FSQRT_MVT_f32_r(RetVT, Op0);
 
653
  case MVT::f64: return FastEmit_ISD_FSQRT_MVT_f64_r(RetVT, Op0);
 
654
  case MVT::f80: return FastEmit_ISD_FSQRT_MVT_f80_r(RetVT, Op0);
 
655
  case MVT::v4f32: return FastEmit_ISD_FSQRT_MVT_v4f32_r(RetVT, Op0);
 
656
  case MVT::v2f64: return FastEmit_ISD_FSQRT_MVT_v2f64_r(RetVT, Op0);
 
657
  default: return 0;
 
658
  }
 
659
}
 
660
 
 
661
// FastEmit functions for ISD::SCALAR_TO_VECTOR.
 
662
 
 
663
unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v2i32_r(unsigned Op0) {
 
664
  if ((Subtarget->hasMMX())) {
 
665
    return FastEmitInst_r(X86::MMX_MOVD64rr, X86::VR64RegisterClass, Op0);
 
666
  }
 
667
  return 0;
 
668
}
 
669
 
 
670
unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v4i32_r(unsigned Op0) {
 
671
  if ((Subtarget->hasSSE2())) {
 
672
    return FastEmitInst_r(X86::MOVDI2PDIrr, X86::VR128RegisterClass, Op0);
 
673
  }
 
674
  return 0;
 
675
}
 
676
 
 
677
unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
678
switch (RetVT.SimpleTy) {
 
679
  case MVT::v2i32: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v2i32_r(Op0);
 
680
  case MVT::v4i32: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v4i32_r(Op0);
 
681
  default: return 0;
 
682
}
 
683
}
 
684
 
 
685
unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_MVT_v1i64_r(unsigned Op0) {
 
686
  if ((Subtarget->hasMMX())) {
 
687
    return FastEmitInst_r(X86::MMX_MOVD64rrv164, X86::VR64RegisterClass, Op0);
 
688
  }
 
689
  return 0;
 
690
}
 
691
 
 
692
unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_MVT_v2i64_r(unsigned Op0) {
 
693
  if ((Subtarget->hasSSE2())) {
 
694
    return FastEmitInst_r(X86::MOV64toPQIrr, X86::VR128RegisterClass, Op0);
 
695
  }
 
696
  return 0;
 
697
}
 
698
 
 
699
unsigned FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_r(MVT RetVT, unsigned Op0) {
 
700
switch (RetVT.SimpleTy) {
 
701
  case MVT::v1i64: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_MVT_v1i64_r(Op0);
 
702
  case MVT::v2i64: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_MVT_v2i64_r(Op0);
 
703
  default: return 0;
 
704
}
 
705
}
 
706
 
 
707
unsigned FastEmit_ISD_SCALAR_TO_VECTOR_r(MVT VT, MVT RetVT, unsigned Op0) {
 
708
  switch (VT.SimpleTy) {
 
709
  case MVT::i32: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_r(RetVT, Op0);
 
710
  case MVT::i64: return FastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_r(RetVT, Op0);
 
711
  default: return 0;
 
712
  }
 
713
}
 
714
 
 
715
// FastEmit functions for ISD::SIGN_EXTEND.
 
716
 
 
717
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i16_r(unsigned Op0) {
 
718
  return FastEmitInst_r(X86::MOVSX16rr8, X86::GR16RegisterClass, Op0);
 
719
}
 
720
 
 
721
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i32_r(unsigned Op0) {
 
722
  return FastEmitInst_r(X86::MOVSX32rr8, X86::GR32RegisterClass, Op0);
 
723
}
 
724
 
 
725
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i64_r(unsigned Op0) {
 
726
  return FastEmitInst_r(X86::MOVSX64rr8, X86::GR64RegisterClass, Op0);
 
727
}
 
728
 
 
729
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i8_r(MVT RetVT, unsigned Op0) {
 
730
switch (RetVT.SimpleTy) {
 
731
  case MVT::i16: return FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i16_r(Op0);
 
732
  case MVT::i32: return FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i32_r(Op0);
 
733
  case MVT::i64: return FastEmit_ISD_SIGN_EXTEND_MVT_i8_MVT_i64_r(Op0);
 
734
  default: return 0;
 
735
}
 
736
}
 
737
 
 
738
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i32_r(unsigned Op0) {
 
739
  return FastEmitInst_r(X86::MOVSX32rr16, X86::GR32RegisterClass, Op0);
 
740
}
 
741
 
 
742
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i64_r(unsigned Op0) {
 
743
  return FastEmitInst_r(X86::MOVSX64rr16, X86::GR64RegisterClass, Op0);
 
744
}
 
745
 
 
746
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i16_r(MVT RetVT, unsigned Op0) {
 
747
switch (RetVT.SimpleTy) {
 
748
  case MVT::i32: return FastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i32_r(Op0);
 
749
  case MVT::i64: return FastEmit_ISD_SIGN_EXTEND_MVT_i16_MVT_i64_r(Op0);
 
750
  default: return 0;
 
751
}
 
752
}
 
753
 
 
754
unsigned FastEmit_ISD_SIGN_EXTEND_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
755
  if (RetVT.SimpleTy != MVT::i64)
 
756
    return 0;
 
757
  return FastEmitInst_r(X86::MOVSX64rr32, X86::GR64RegisterClass, Op0);
 
758
}
 
759
 
 
760
unsigned FastEmit_ISD_SIGN_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0) {
 
761
  switch (VT.SimpleTy) {
 
762
  case MVT::i8: return FastEmit_ISD_SIGN_EXTEND_MVT_i8_r(RetVT, Op0);
 
763
  case MVT::i16: return FastEmit_ISD_SIGN_EXTEND_MVT_i16_r(RetVT, Op0);
 
764
  case MVT::i32: return FastEmit_ISD_SIGN_EXTEND_MVT_i32_r(RetVT, Op0);
 
765
  default: return 0;
 
766
  }
 
767
}
 
768
 
 
769
// FastEmit functions for ISD::SINT_TO_FP.
 
770
 
 
771
unsigned FastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f32_r(unsigned Op0) {
 
772
  if ((Subtarget->hasSSE1())) {
 
773
    return FastEmitInst_r(X86::CVTSI2SSrr, X86::FR32RegisterClass, Op0);
 
774
  }
 
775
  return 0;
 
776
}
 
777
 
 
778
unsigned FastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f64_r(unsigned Op0) {
 
779
  if ((Subtarget->hasSSE2())) {
 
780
    return FastEmitInst_r(X86::CVTSI2SDrr, X86::FR64RegisterClass, Op0);
 
781
  }
 
782
  return 0;
 
783
}
 
784
 
 
785
unsigned FastEmit_ISD_SINT_TO_FP_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
786
switch (RetVT.SimpleTy) {
 
787
  case MVT::f32: return FastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f32_r(Op0);
 
788
  case MVT::f64: return FastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f64_r(Op0);
 
789
  default: return 0;
 
790
}
 
791
}
 
792
 
 
793
unsigned FastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f32_r(unsigned Op0) {
 
794
  if ((Subtarget->hasSSE1())) {
 
795
    return FastEmitInst_r(X86::CVTSI2SS64rr, X86::FR32RegisterClass, Op0);
 
796
  }
 
797
  return 0;
 
798
}
 
799
 
 
800
unsigned FastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f64_r(unsigned Op0) {
 
801
  if ((Subtarget->hasSSE2())) {
 
802
    return FastEmitInst_r(X86::CVTSI2SD64rr, X86::FR64RegisterClass, Op0);
 
803
  }
 
804
  return 0;
 
805
}
 
806
 
 
807
unsigned FastEmit_ISD_SINT_TO_FP_MVT_i64_r(MVT RetVT, unsigned Op0) {
 
808
switch (RetVT.SimpleTy) {
 
809
  case MVT::f32: return FastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f32_r(Op0);
 
810
  case MVT::f64: return FastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f64_r(Op0);
 
811
  default: return 0;
 
812
}
 
813
}
 
814
 
 
815
unsigned FastEmit_ISD_SINT_TO_FP_MVT_v2i32_r(MVT RetVT, unsigned Op0) {
 
816
  if (RetVT.SimpleTy != MVT::v2f64)
 
817
    return 0;
 
818
  if ((Subtarget->hasSSE2())) {
 
819
    return FastEmitInst_r(X86::Int_CVTPI2PDrr, X86::VR128RegisterClass, Op0);
 
820
  }
 
821
  return 0;
 
822
}
 
823
 
 
824
unsigned FastEmit_ISD_SINT_TO_FP_MVT_v4i32_r(MVT RetVT, unsigned Op0) {
 
825
  if (RetVT.SimpleTy != MVT::v4f32)
 
826
    return 0;
 
827
  if ((Subtarget->hasSSE2())) {
 
828
    return FastEmitInst_r(X86::Int_CVTDQ2PSrr, X86::VR128RegisterClass, Op0);
 
829
  }
 
830
  return 0;
 
831
}
 
832
 
 
833
unsigned FastEmit_ISD_SINT_TO_FP_r(MVT VT, MVT RetVT, unsigned Op0) {
 
834
  switch (VT.SimpleTy) {
 
835
  case MVT::i32: return FastEmit_ISD_SINT_TO_FP_MVT_i32_r(RetVT, Op0);
 
836
  case MVT::i64: return FastEmit_ISD_SINT_TO_FP_MVT_i64_r(RetVT, Op0);
 
837
  case MVT::v2i32: return FastEmit_ISD_SINT_TO_FP_MVT_v2i32_r(RetVT, Op0);
 
838
  case MVT::v4i32: return FastEmit_ISD_SINT_TO_FP_MVT_v4i32_r(RetVT, Op0);
 
839
  default: return 0;
 
840
  }
 
841
}
 
842
 
 
843
// FastEmit functions for ISD::TRUNCATE.
 
844
 
 
845
unsigned FastEmit_ISD_TRUNCATE_MVT_i16_r(MVT RetVT, unsigned Op0) {
 
846
  if (RetVT.SimpleTy != MVT::i8)
 
847
    return 0;
 
848
  if ((Subtarget->is64Bit())) {
 
849
    return FastEmitInst_extractsubreg(RetVT, Op0, 1);
 
850
  }
 
851
  return 0;
 
852
}
 
853
 
 
854
unsigned FastEmit_ISD_TRUNCATE_MVT_i32_MVT_i8_r(unsigned Op0) {
 
855
  if ((Subtarget->is64Bit())) {
 
856
    return FastEmitInst_extractsubreg(MVT::i8, Op0, 1);
 
857
  }
 
858
  return 0;
 
859
}
 
860
 
 
861
unsigned FastEmit_ISD_TRUNCATE_MVT_i32_MVT_i16_r(unsigned Op0) {
 
862
  return FastEmitInst_extractsubreg(MVT::i16, Op0, 3);
 
863
}
 
864
 
 
865
unsigned FastEmit_ISD_TRUNCATE_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
866
switch (RetVT.SimpleTy) {
 
867
  case MVT::i8: return FastEmit_ISD_TRUNCATE_MVT_i32_MVT_i8_r(Op0);
 
868
  case MVT::i16: return FastEmit_ISD_TRUNCATE_MVT_i32_MVT_i16_r(Op0);
 
869
  default: return 0;
 
870
}
 
871
}
 
872
 
 
873
unsigned FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i8_r(unsigned Op0) {
 
874
  return FastEmitInst_extractsubreg(MVT::i8, Op0, 1);
 
875
}
 
876
 
 
877
unsigned FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i16_r(unsigned Op0) {
 
878
  return FastEmitInst_extractsubreg(MVT::i16, Op0, 3);
 
879
}
 
880
 
 
881
unsigned FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i32_r(unsigned Op0) {
 
882
  return FastEmitInst_extractsubreg(MVT::i32, Op0, 4);
 
883
}
 
884
 
 
885
unsigned FastEmit_ISD_TRUNCATE_MVT_i64_r(MVT RetVT, unsigned Op0) {
 
886
switch (RetVT.SimpleTy) {
 
887
  case MVT::i8: return FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i8_r(Op0);
 
888
  case MVT::i16: return FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i16_r(Op0);
 
889
  case MVT::i32: return FastEmit_ISD_TRUNCATE_MVT_i64_MVT_i32_r(Op0);
 
890
  default: return 0;
 
891
}
 
892
}
 
893
 
 
894
unsigned FastEmit_ISD_TRUNCATE_r(MVT VT, MVT RetVT, unsigned Op0) {
 
895
  switch (VT.SimpleTy) {
 
896
  case MVT::i16: return FastEmit_ISD_TRUNCATE_MVT_i16_r(RetVT, Op0);
 
897
  case MVT::i32: return FastEmit_ISD_TRUNCATE_MVT_i32_r(RetVT, Op0);
 
898
  case MVT::i64: return FastEmit_ISD_TRUNCATE_MVT_i64_r(RetVT, Op0);
 
899
  default: return 0;
 
900
  }
 
901
}
 
902
 
 
903
// FastEmit functions for ISD::ZERO_EXTEND.
 
904
 
 
905
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i16_r(unsigned Op0) {
 
906
  return FastEmitInst_r(X86::MOVZX16rr8, X86::GR16RegisterClass, Op0);
 
907
}
 
908
 
 
909
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i32_r(unsigned Op0) {
 
910
  return FastEmitInst_r(X86::MOVZX32rr8, X86::GR32RegisterClass, Op0);
 
911
}
 
912
 
 
913
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i64_r(unsigned Op0) {
 
914
  return FastEmitInst_r(X86::MOVZX64rr8, X86::GR64RegisterClass, Op0);
 
915
}
 
916
 
 
917
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i8_r(MVT RetVT, unsigned Op0) {
 
918
switch (RetVT.SimpleTy) {
 
919
  case MVT::i16: return FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i16_r(Op0);
 
920
  case MVT::i32: return FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i32_r(Op0);
 
921
  case MVT::i64: return FastEmit_ISD_ZERO_EXTEND_MVT_i8_MVT_i64_r(Op0);
 
922
  default: return 0;
 
923
}
 
924
}
 
925
 
 
926
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i16_MVT_i32_r(unsigned Op0) {
 
927
  return FastEmitInst_r(X86::MOVZX32rr16, X86::GR32RegisterClass, Op0);
 
928
}
 
929
 
 
930
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i16_MVT_i64_r(unsigned Op0) {
 
931
  return FastEmitInst_r(X86::MOVZX64rr16, X86::GR64RegisterClass, Op0);
 
932
}
 
933
 
 
934
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i16_r(MVT RetVT, unsigned Op0) {
 
935
switch (RetVT.SimpleTy) {
 
936
  case MVT::i32: return FastEmit_ISD_ZERO_EXTEND_MVT_i16_MVT_i32_r(Op0);
 
937
  case MVT::i64: return FastEmit_ISD_ZERO_EXTEND_MVT_i16_MVT_i64_r(Op0);
 
938
  default: return 0;
 
939
}
 
940
}
 
941
 
 
942
unsigned FastEmit_ISD_ZERO_EXTEND_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
943
  if (RetVT.SimpleTy != MVT::i64)
 
944
    return 0;
 
945
  return FastEmitInst_r(X86::MOVZX64rr32, X86::GR64RegisterClass, Op0);
 
946
}
 
947
 
 
948
unsigned FastEmit_ISD_ZERO_EXTEND_r(MVT VT, MVT RetVT, unsigned Op0) {
 
949
  switch (VT.SimpleTy) {
 
950
  case MVT::i8: return FastEmit_ISD_ZERO_EXTEND_MVT_i8_r(RetVT, Op0);
 
951
  case MVT::i16: return FastEmit_ISD_ZERO_EXTEND_MVT_i16_r(RetVT, Op0);
 
952
  case MVT::i32: return FastEmit_ISD_ZERO_EXTEND_MVT_i32_r(RetVT, Op0);
 
953
  default: return 0;
 
954
  }
 
955
}
 
956
 
 
957
// FastEmit functions for X86ISD::BSF.
 
958
 
 
959
unsigned FastEmit_X86ISD_BSF_MVT_i16_r(MVT RetVT, unsigned Op0) {
 
960
  if (RetVT.SimpleTy != MVT::i16)
 
961
    return 0;
 
962
  return FastEmitInst_r(X86::BSF16rr, X86::GR16RegisterClass, Op0);
 
963
}
 
964
 
 
965
unsigned FastEmit_X86ISD_BSF_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
966
  if (RetVT.SimpleTy != MVT::i32)
 
967
    return 0;
 
968
  return FastEmitInst_r(X86::BSF32rr, X86::GR32RegisterClass, Op0);
 
969
}
 
970
 
 
971
unsigned FastEmit_X86ISD_BSF_MVT_i64_r(MVT RetVT, unsigned Op0) {
 
972
  if (RetVT.SimpleTy != MVT::i64)
 
973
    return 0;
 
974
  return FastEmitInst_r(X86::BSF64rr, X86::GR64RegisterClass, Op0);
 
975
}
 
976
 
 
977
unsigned FastEmit_X86ISD_BSF_r(MVT VT, MVT RetVT, unsigned Op0) {
 
978
  switch (VT.SimpleTy) {
 
979
  case MVT::i16: return FastEmit_X86ISD_BSF_MVT_i16_r(RetVT, Op0);
 
980
  case MVT::i32: return FastEmit_X86ISD_BSF_MVT_i32_r(RetVT, Op0);
 
981
  case MVT::i64: return FastEmit_X86ISD_BSF_MVT_i64_r(RetVT, Op0);
 
982
  default: return 0;
 
983
  }
 
984
}
 
985
 
 
986
// FastEmit functions for X86ISD::BSR.
 
987
 
 
988
unsigned FastEmit_X86ISD_BSR_MVT_i16_r(MVT RetVT, unsigned Op0) {
 
989
  if (RetVT.SimpleTy != MVT::i16)
 
990
    return 0;
 
991
  return FastEmitInst_r(X86::BSR16rr, X86::GR16RegisterClass, Op0);
 
992
}
 
993
 
 
994
unsigned FastEmit_X86ISD_BSR_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
995
  if (RetVT.SimpleTy != MVT::i32)
 
996
    return 0;
 
997
  return FastEmitInst_r(X86::BSR32rr, X86::GR32RegisterClass, Op0);
 
998
}
 
999
 
 
1000
unsigned FastEmit_X86ISD_BSR_MVT_i64_r(MVT RetVT, unsigned Op0) {
 
1001
  if (RetVT.SimpleTy != MVT::i64)
 
1002
    return 0;
 
1003
  return FastEmitInst_r(X86::BSR64rr, X86::GR64RegisterClass, Op0);
 
1004
}
 
1005
 
 
1006
unsigned FastEmit_X86ISD_BSR_r(MVT VT, MVT RetVT, unsigned Op0) {
 
1007
  switch (VT.SimpleTy) {
 
1008
  case MVT::i16: return FastEmit_X86ISD_BSR_MVT_i16_r(RetVT, Op0);
 
1009
  case MVT::i32: return FastEmit_X86ISD_BSR_MVT_i32_r(RetVT, Op0);
 
1010
  case MVT::i64: return FastEmit_X86ISD_BSR_MVT_i64_r(RetVT, Op0);
 
1011
  default: return 0;
 
1012
  }
 
1013
}
 
1014
 
 
1015
// FastEmit functions for X86ISD::CALL.
 
1016
 
 
1017
unsigned FastEmit_X86ISD_CALL_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
1018
  if (RetVT.SimpleTy != MVT::isVoid)
 
1019
    return 0;
 
1020
  return FastEmitInst_r(X86::CALL32r, X86::GR32RegisterClass, Op0);
 
1021
}
 
1022
 
 
1023
unsigned FastEmit_X86ISD_CALL_MVT_i64_r(MVT RetVT, unsigned Op0) {
 
1024
  if (RetVT.SimpleTy != MVT::isVoid)
 
1025
    return 0;
 
1026
  if ((!Subtarget->isTargetWin64())) {
 
1027
    return FastEmitInst_r(X86::CALL64r, X86::GR64RegisterClass, Op0);
 
1028
  }
 
1029
  if ((Subtarget->isTargetWin64())) {
 
1030
    return FastEmitInst_r(X86::WINCALL64r, X86::GR64RegisterClass, Op0);
 
1031
  }
 
1032
  return 0;
 
1033
}
 
1034
 
 
1035
unsigned FastEmit_X86ISD_CALL_r(MVT VT, MVT RetVT, unsigned Op0) {
 
1036
  switch (VT.SimpleTy) {
 
1037
  case MVT::i32: return FastEmit_X86ISD_CALL_MVT_i32_r(RetVT, Op0);
 
1038
  case MVT::i64: return FastEmit_X86ISD_CALL_MVT_i64_r(RetVT, Op0);
 
1039
  default: return 0;
 
1040
  }
 
1041
}
 
1042
 
 
1043
// FastEmit functions for X86ISD::DEC.
 
1044
 
 
1045
unsigned FastEmit_X86ISD_DEC_MVT_i8_r(MVT RetVT, unsigned Op0) {
 
1046
  if (RetVT.SimpleTy != MVT::i8)
 
1047
    return 0;
 
1048
  return FastEmitInst_r(X86::DEC8r, X86::GR8RegisterClass, Op0);
 
1049
}
 
1050
 
 
1051
unsigned FastEmit_X86ISD_DEC_MVT_i16_r(MVT RetVT, unsigned Op0) {
 
1052
  if (RetVT.SimpleTy != MVT::i16)
 
1053
    return 0;
 
1054
  if ((!Subtarget->is64Bit())) {
 
1055
    return FastEmitInst_r(X86::DEC16r, X86::GR16RegisterClass, Op0);
 
1056
  }
 
1057
  if ((Subtarget->is64Bit())) {
 
1058
    return FastEmitInst_r(X86::DEC64_16r, X86::GR16RegisterClass, Op0);
 
1059
  }
 
1060
  return 0;
 
1061
}
 
1062
 
 
1063
unsigned FastEmit_X86ISD_DEC_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
1064
  if (RetVT.SimpleTy != MVT::i32)
 
1065
    return 0;
 
1066
  if ((!Subtarget->is64Bit())) {
 
1067
    return FastEmitInst_r(X86::DEC32r, X86::GR32RegisterClass, Op0);
 
1068
  }
 
1069
  if ((Subtarget->is64Bit())) {
 
1070
    return FastEmitInst_r(X86::DEC64_32r, X86::GR32RegisterClass, Op0);
 
1071
  }
 
1072
  return 0;
 
1073
}
 
1074
 
 
1075
unsigned FastEmit_X86ISD_DEC_MVT_i64_r(MVT RetVT, unsigned Op0) {
 
1076
  if (RetVT.SimpleTy != MVT::i64)
 
1077
    return 0;
 
1078
  return FastEmitInst_r(X86::DEC64r, X86::GR64RegisterClass, Op0);
 
1079
}
 
1080
 
 
1081
unsigned FastEmit_X86ISD_DEC_r(MVT VT, MVT RetVT, unsigned Op0) {
 
1082
  switch (VT.SimpleTy) {
 
1083
  case MVT::i8: return FastEmit_X86ISD_DEC_MVT_i8_r(RetVT, Op0);
 
1084
  case MVT::i16: return FastEmit_X86ISD_DEC_MVT_i16_r(RetVT, Op0);
 
1085
  case MVT::i32: return FastEmit_X86ISD_DEC_MVT_i32_r(RetVT, Op0);
 
1086
  case MVT::i64: return FastEmit_X86ISD_DEC_MVT_i64_r(RetVT, Op0);
 
1087
  default: return 0;
 
1088
  }
 
1089
}
 
1090
 
 
1091
// FastEmit functions for X86ISD::EH_RETURN.
 
1092
 
 
1093
unsigned FastEmit_X86ISD_EH_RETURN_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
1094
  if (RetVT.SimpleTy != MVT::isVoid)
 
1095
    return 0;
 
1096
  return FastEmitInst_r(X86::EH_RETURN, X86::GR32RegisterClass, Op0);
 
1097
}
 
1098
 
 
1099
unsigned FastEmit_X86ISD_EH_RETURN_MVT_i64_r(MVT RetVT, unsigned Op0) {
 
1100
  if (RetVT.SimpleTy != MVT::isVoid)
 
1101
    return 0;
 
1102
  return FastEmitInst_r(X86::EH_RETURN64, X86::GR64RegisterClass, Op0);
 
1103
}
 
1104
 
 
1105
unsigned FastEmit_X86ISD_EH_RETURN_r(MVT VT, MVT RetVT, unsigned Op0) {
 
1106
  switch (VT.SimpleTy) {
 
1107
  case MVT::i32: return FastEmit_X86ISD_EH_RETURN_MVT_i32_r(RetVT, Op0);
 
1108
  case MVT::i64: return FastEmit_X86ISD_EH_RETURN_MVT_i64_r(RetVT, Op0);
 
1109
  default: return 0;
 
1110
  }
 
1111
}
 
1112
 
 
1113
// FastEmit functions for X86ISD::FRCP.
 
1114
 
 
1115
unsigned FastEmit_X86ISD_FRCP_MVT_f32_r(MVT RetVT, unsigned Op0) {
 
1116
  if (RetVT.SimpleTy != MVT::f32)
 
1117
    return 0;
 
1118
  if ((Subtarget->hasSSE1())) {
 
1119
    return FastEmitInst_r(X86::RCPSSr, X86::FR32RegisterClass, Op0);
 
1120
  }
 
1121
  return 0;
 
1122
}
 
1123
 
 
1124
unsigned FastEmit_X86ISD_FRCP_MVT_v4f32_r(MVT RetVT, unsigned Op0) {
 
1125
  if (RetVT.SimpleTy != MVT::v4f32)
 
1126
    return 0;
 
1127
  if ((Subtarget->hasSSE1())) {
 
1128
    return FastEmitInst_r(X86::RCPPSr, X86::VR128RegisterClass, Op0);
 
1129
  }
 
1130
  return 0;
 
1131
}
 
1132
 
 
1133
unsigned FastEmit_X86ISD_FRCP_r(MVT VT, MVT RetVT, unsigned Op0) {
 
1134
  switch (VT.SimpleTy) {
 
1135
  case MVT::f32: return FastEmit_X86ISD_FRCP_MVT_f32_r(RetVT, Op0);
 
1136
  case MVT::v4f32: return FastEmit_X86ISD_FRCP_MVT_v4f32_r(RetVT, Op0);
 
1137
  default: return 0;
 
1138
  }
 
1139
}
 
1140
 
 
1141
// FastEmit functions for X86ISD::FRSQRT.
 
1142
 
 
1143
unsigned FastEmit_X86ISD_FRSQRT_MVT_f32_r(MVT RetVT, unsigned Op0) {
 
1144
  if (RetVT.SimpleTy != MVT::f32)
 
1145
    return 0;
 
1146
  if ((Subtarget->hasSSE1())) {
 
1147
    return FastEmitInst_r(X86::RSQRTSSr, X86::FR32RegisterClass, Op0);
 
1148
  }
 
1149
  return 0;
 
1150
}
 
1151
 
 
1152
unsigned FastEmit_X86ISD_FRSQRT_MVT_v4f32_r(MVT RetVT, unsigned Op0) {
 
1153
  if (RetVT.SimpleTy != MVT::v4f32)
 
1154
    return 0;
 
1155
  if ((Subtarget->hasSSE1())) {
 
1156
    return FastEmitInst_r(X86::RSQRTPSr, X86::VR128RegisterClass, Op0);
 
1157
  }
 
1158
  return 0;
 
1159
}
 
1160
 
 
1161
unsigned FastEmit_X86ISD_FRSQRT_r(MVT VT, MVT RetVT, unsigned Op0) {
 
1162
  switch (VT.SimpleTy) {
 
1163
  case MVT::f32: return FastEmit_X86ISD_FRSQRT_MVT_f32_r(RetVT, Op0);
 
1164
  case MVT::v4f32: return FastEmit_X86ISD_FRSQRT_MVT_v4f32_r(RetVT, Op0);
 
1165
  default: return 0;
 
1166
  }
 
1167
}
 
1168
 
 
1169
// FastEmit functions for X86ISD::INC.
 
1170
 
 
1171
unsigned FastEmit_X86ISD_INC_MVT_i8_r(MVT RetVT, unsigned Op0) {
 
1172
  if (RetVT.SimpleTy != MVT::i8)
 
1173
    return 0;
 
1174
  return FastEmitInst_r(X86::INC8r, X86::GR8RegisterClass, Op0);
 
1175
}
 
1176
 
 
1177
unsigned FastEmit_X86ISD_INC_MVT_i16_r(MVT RetVT, unsigned Op0) {
 
1178
  if (RetVT.SimpleTy != MVT::i16)
 
1179
    return 0;
 
1180
  if ((!Subtarget->is64Bit())) {
 
1181
    return FastEmitInst_r(X86::INC16r, X86::GR16RegisterClass, Op0);
 
1182
  }
 
1183
  if ((Subtarget->is64Bit())) {
 
1184
    return FastEmitInst_r(X86::INC64_16r, X86::GR16RegisterClass, Op0);
 
1185
  }
 
1186
  return 0;
 
1187
}
 
1188
 
 
1189
unsigned FastEmit_X86ISD_INC_MVT_i32_r(MVT RetVT, unsigned Op0) {
 
1190
  if (RetVT.SimpleTy != MVT::i32)
 
1191
    return 0;
 
1192
  if ((!Subtarget->is64Bit())) {
 
1193
    return FastEmitInst_r(X86::INC32r, X86::GR32RegisterClass, Op0);
 
1194
  }
 
1195
  if ((Subtarget->is64Bit())) {
 
1196
    return FastEmitInst_r(X86::INC64_32r, X86::GR32RegisterClass, Op0);
 
1197
  }
 
1198
  return 0;
 
1199
}
 
1200
 
 
1201
unsigned FastEmit_X86ISD_INC_MVT_i64_r(MVT RetVT, unsigned Op0) {
 
1202
  if (RetVT.SimpleTy != MVT::i64)
 
1203
    return 0;
 
1204
  return FastEmitInst_r(X86::INC64r, X86::GR64RegisterClass, Op0);
 
1205
}
 
1206
 
 
1207
unsigned FastEmit_X86ISD_INC_r(MVT VT, MVT RetVT, unsigned Op0) {
 
1208
  switch (VT.SimpleTy) {
 
1209
  case MVT::i8: return FastEmit_X86ISD_INC_MVT_i8_r(RetVT, Op0);
 
1210
  case MVT::i16: return FastEmit_X86ISD_INC_MVT_i16_r(RetVT, Op0);
 
1211
  case MVT::i32: return FastEmit_X86ISD_INC_MVT_i32_r(RetVT, Op0);
 
1212
  case MVT::i64: return FastEmit_X86ISD_INC_MVT_i64_r(RetVT, Op0);
 
1213
  default: return 0;
 
1214
  }
 
1215
}
 
1216
 
 
1217
// FastEmit functions for X86ISD::MOVQ2DQ.
 
1218
 
 
1219
unsigned FastEmit_X86ISD_MOVQ2DQ_MVT_v1i64_r(MVT RetVT, unsigned Op0) {
 
1220
  if (RetVT.SimpleTy != MVT::v2i64)
 
1221
    return 0;
 
1222
  return FastEmitInst_r(X86::MMX_MOVQ2DQrr, X86::VR128RegisterClass, Op0);
 
1223
}
 
1224
 
 
1225
unsigned FastEmit_X86ISD_MOVQ2DQ_r(MVT VT, MVT RetVT, unsigned Op0) {
 
1226
  switch (VT.SimpleTy) {
 
1227
  case MVT::v1i64: return FastEmit_X86ISD_MOVQ2DQ_MVT_v1i64_r(RetVT, Op0);
 
1228
  default: return 0;
 
1229
  }
 
1230
}
 
1231
 
 
1232
// FastEmit functions for X86ISD::VZEXT_MOVL.
 
1233
 
 
1234
unsigned FastEmit_X86ISD_VZEXT_MOVL_MVT_v2i64_r(MVT RetVT, unsigned Op0) {
 
1235
  if (RetVT.SimpleTy != MVT::v2i64)
 
1236
    return 0;
 
1237
  if ((Subtarget->hasSSE2())) {
 
1238
    return FastEmitInst_r(X86::MOVZPQILo2PQIrr, X86::VR128RegisterClass, Op0);
 
1239
  }
 
1240
  return 0;
 
1241
}
 
1242
 
 
1243
unsigned FastEmit_X86ISD_VZEXT_MOVL_MVT_v2f64_r(MVT RetVT, unsigned Op0) {
 
1244
  if (RetVT.SimpleTy != MVT::v2f64)
 
1245
    return 0;
 
1246
  if ((Subtarget->hasSSE2())) {
 
1247
    return FastEmitInst_r(X86::MOVZPQILo2PQIrr, X86::VR128RegisterClass, Op0);
 
1248
  }
 
1249
  return 0;
 
1250
}
 
1251
 
 
1252
unsigned FastEmit_X86ISD_VZEXT_MOVL_r(MVT VT, MVT RetVT, unsigned Op0) {
 
1253
  switch (VT.SimpleTy) {
 
1254
  case MVT::v2i64: return FastEmit_X86ISD_VZEXT_MOVL_MVT_v2i64_r(RetVT, Op0);
 
1255
  case MVT::v2f64: return FastEmit_X86ISD_VZEXT_MOVL_MVT_v2f64_r(RetVT, Op0);
 
1256
  default: return 0;
 
1257
  }
 
1258
}
 
1259
 
 
1260
// Top-level FastEmit function.
 
1261
 
 
1262
unsigned FastEmit_r(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0) {
 
1263
  switch (Opcode) {
 
1264
  case ISD::ANY_EXTEND: return FastEmit_ISD_ANY_EXTEND_r(VT, RetVT, Op0);
 
1265
  case ISD::BIT_CONVERT: return FastEmit_ISD_BIT_CONVERT_r(VT, RetVT, Op0);
 
1266
  case ISD::BRIND: return FastEmit_ISD_BRIND_r(VT, RetVT, Op0);
 
1267
  case ISD::BSWAP: return FastEmit_ISD_BSWAP_r(VT, RetVT, Op0);
 
1268
  case ISD::FABS: return FastEmit_ISD_FABS_r(VT, RetVT, Op0);
 
1269
  case ISD::FCOS: return FastEmit_ISD_FCOS_r(VT, RetVT, Op0);
 
1270
  case ISD::FNEG: return FastEmit_ISD_FNEG_r(VT, RetVT, Op0);
 
1271
  case ISD::FP_EXTEND: return FastEmit_ISD_FP_EXTEND_r(VT, RetVT, Op0);
 
1272
  case ISD::FP_ROUND: return FastEmit_ISD_FP_ROUND_r(VT, RetVT, Op0);
 
1273
  case ISD::FP_TO_SINT: return FastEmit_ISD_FP_TO_SINT_r(VT, RetVT, Op0);
 
1274
  case ISD::FSIN: return FastEmit_ISD_FSIN_r(VT, RetVT, Op0);
 
1275
  case ISD::FSQRT: return FastEmit_ISD_FSQRT_r(VT, RetVT, Op0);
 
1276
  case ISD::SCALAR_TO_VECTOR: return FastEmit_ISD_SCALAR_TO_VECTOR_r(VT, RetVT, Op0);
 
1277
  case ISD::SIGN_EXTEND: return FastEmit_ISD_SIGN_EXTEND_r(VT, RetVT, Op0);
 
1278
  case ISD::SINT_TO_FP: return FastEmit_ISD_SINT_TO_FP_r(VT, RetVT, Op0);
 
1279
  case ISD::TRUNCATE: return FastEmit_ISD_TRUNCATE_r(VT, RetVT, Op0);
 
1280
  case ISD::ZERO_EXTEND: return FastEmit_ISD_ZERO_EXTEND_r(VT, RetVT, Op0);
 
1281
  case X86ISD::BSF: return FastEmit_X86ISD_BSF_r(VT, RetVT, Op0);
 
1282
  case X86ISD::BSR: return FastEmit_X86ISD_BSR_r(VT, RetVT, Op0);
 
1283
  case X86ISD::CALL: return FastEmit_X86ISD_CALL_r(VT, RetVT, Op0);
 
1284
  case X86ISD::DEC: return FastEmit_X86ISD_DEC_r(VT, RetVT, Op0);
 
1285
  case X86ISD::EH_RETURN: return FastEmit_X86ISD_EH_RETURN_r(VT, RetVT, Op0);
 
1286
  case X86ISD::FRCP: return FastEmit_X86ISD_FRCP_r(VT, RetVT, Op0);
 
1287
  case X86ISD::FRSQRT: return FastEmit_X86ISD_FRSQRT_r(VT, RetVT, Op0);
 
1288
  case X86ISD::INC: return FastEmit_X86ISD_INC_r(VT, RetVT, Op0);
 
1289
  case X86ISD::MOVQ2DQ: return FastEmit_X86ISD_MOVQ2DQ_r(VT, RetVT, Op0);
 
1290
  case X86ISD::VZEXT_MOVL: return FastEmit_X86ISD_VZEXT_MOVL_r(VT, RetVT, Op0);
 
1291
  default: return 0;
 
1292
  }
 
1293
}
 
1294
 
 
1295
// FastEmit functions for ISD::ADD.
 
1296
 
 
1297
unsigned FastEmit_ISD_ADD_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1298
  if (RetVT.SimpleTy != MVT::i8)
 
1299
    return 0;
 
1300
  return FastEmitInst_ri(X86::ADD8ri, X86::GR8RegisterClass, Op0, imm1);
 
1301
}
 
1302
 
 
1303
unsigned FastEmit_ISD_ADD_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1304
  if (RetVT.SimpleTy != MVT::i16)
 
1305
    return 0;
 
1306
  return FastEmitInst_ri(X86::ADD16ri, X86::GR16RegisterClass, Op0, imm1);
 
1307
}
 
1308
 
 
1309
unsigned FastEmit_ISD_ADD_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1310
  if (RetVT.SimpleTy != MVT::i32)
 
1311
    return 0;
 
1312
  return FastEmitInst_ri(X86::ADD32ri, X86::GR32RegisterClass, Op0, imm1);
 
1313
}
 
1314
 
 
1315
unsigned FastEmit_ISD_ADD_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1316
  switch (VT.SimpleTy) {
 
1317
  case MVT::i8: return FastEmit_ISD_ADD_MVT_i8_ri(RetVT, Op0, imm1);
 
1318
  case MVT::i16: return FastEmit_ISD_ADD_MVT_i16_ri(RetVT, Op0, imm1);
 
1319
  case MVT::i32: return FastEmit_ISD_ADD_MVT_i32_ri(RetVT, Op0, imm1);
 
1320
  default: return 0;
 
1321
  }
 
1322
}
 
1323
 
 
1324
// FastEmit functions for ISD::ADDC.
 
1325
 
 
1326
unsigned FastEmit_ISD_ADDC_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1327
  if (RetVT.SimpleTy != MVT::i32)
 
1328
    return 0;
 
1329
  return FastEmitInst_ri(X86::ADD32ri, X86::GR32RegisterClass, Op0, imm1);
 
1330
}
 
1331
 
 
1332
unsigned FastEmit_ISD_ADDC_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1333
  switch (VT.SimpleTy) {
 
1334
  case MVT::i32: return FastEmit_ISD_ADDC_MVT_i32_ri(RetVT, Op0, imm1);
 
1335
  default: return 0;
 
1336
  }
 
1337
}
 
1338
 
 
1339
// FastEmit functions for ISD::ADDE.
 
1340
 
 
1341
unsigned FastEmit_ISD_ADDE_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1342
  if (RetVT.SimpleTy != MVT::i8)
 
1343
    return 0;
 
1344
  return FastEmitInst_ri(X86::ADC8ri, X86::GR8RegisterClass, Op0, imm1);
 
1345
}
 
1346
 
 
1347
unsigned FastEmit_ISD_ADDE_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1348
  if (RetVT.SimpleTy != MVT::i16)
 
1349
    return 0;
 
1350
  return FastEmitInst_ri(X86::ADC16ri, X86::GR16RegisterClass, Op0, imm1);
 
1351
}
 
1352
 
 
1353
unsigned FastEmit_ISD_ADDE_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1354
  if (RetVT.SimpleTy != MVT::i32)
 
1355
    return 0;
 
1356
  return FastEmitInst_ri(X86::ADC32ri, X86::GR32RegisterClass, Op0, imm1);
 
1357
}
 
1358
 
 
1359
unsigned FastEmit_ISD_ADDE_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1360
  switch (VT.SimpleTy) {
 
1361
  case MVT::i8: return FastEmit_ISD_ADDE_MVT_i8_ri(RetVT, Op0, imm1);
 
1362
  case MVT::i16: return FastEmit_ISD_ADDE_MVT_i16_ri(RetVT, Op0, imm1);
 
1363
  case MVT::i32: return FastEmit_ISD_ADDE_MVT_i32_ri(RetVT, Op0, imm1);
 
1364
  default: return 0;
 
1365
  }
 
1366
}
 
1367
 
 
1368
// FastEmit functions for ISD::AND.
 
1369
 
 
1370
unsigned FastEmit_ISD_AND_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1371
  if (RetVT.SimpleTy != MVT::i8)
 
1372
    return 0;
 
1373
  return FastEmitInst_ri(X86::AND8ri, X86::GR8RegisterClass, Op0, imm1);
 
1374
}
 
1375
 
 
1376
unsigned FastEmit_ISD_AND_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1377
  if (RetVT.SimpleTy != MVT::i16)
 
1378
    return 0;
 
1379
  return FastEmitInst_ri(X86::AND16ri, X86::GR16RegisterClass, Op0, imm1);
 
1380
}
 
1381
 
 
1382
unsigned FastEmit_ISD_AND_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1383
  if (RetVT.SimpleTy != MVT::i32)
 
1384
    return 0;
 
1385
  return FastEmitInst_ri(X86::AND32ri, X86::GR32RegisterClass, Op0, imm1);
 
1386
}
 
1387
 
 
1388
unsigned FastEmit_ISD_AND_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1389
  switch (VT.SimpleTy) {
 
1390
  case MVT::i8: return FastEmit_ISD_AND_MVT_i8_ri(RetVT, Op0, imm1);
 
1391
  case MVT::i16: return FastEmit_ISD_AND_MVT_i16_ri(RetVT, Op0, imm1);
 
1392
  case MVT::i32: return FastEmit_ISD_AND_MVT_i32_ri(RetVT, Op0, imm1);
 
1393
  default: return 0;
 
1394
  }
 
1395
}
 
1396
 
 
1397
// FastEmit functions for ISD::MUL.
 
1398
 
 
1399
unsigned FastEmit_ISD_MUL_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1400
  if (RetVT.SimpleTy != MVT::i16)
 
1401
    return 0;
 
1402
  return FastEmitInst_ri(X86::IMUL16rri, X86::GR16RegisterClass, Op0, imm1);
 
1403
}
 
1404
 
 
1405
unsigned FastEmit_ISD_MUL_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1406
  if (RetVT.SimpleTy != MVT::i32)
 
1407
    return 0;
 
1408
  return FastEmitInst_ri(X86::IMUL32rri, X86::GR32RegisterClass, Op0, imm1);
 
1409
}
 
1410
 
 
1411
unsigned FastEmit_ISD_MUL_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1412
  switch (VT.SimpleTy) {
 
1413
  case MVT::i16: return FastEmit_ISD_MUL_MVT_i16_ri(RetVT, Op0, imm1);
 
1414
  case MVT::i32: return FastEmit_ISD_MUL_MVT_i32_ri(RetVT, Op0, imm1);
 
1415
  default: return 0;
 
1416
  }
 
1417
}
 
1418
 
 
1419
// FastEmit functions for ISD::OR.
 
1420
 
 
1421
unsigned FastEmit_ISD_OR_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1422
  if (RetVT.SimpleTy != MVT::i8)
 
1423
    return 0;
 
1424
  return FastEmitInst_ri(X86::OR8ri, X86::GR8RegisterClass, Op0, imm1);
 
1425
}
 
1426
 
 
1427
unsigned FastEmit_ISD_OR_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1428
  if (RetVT.SimpleTy != MVT::i16)
 
1429
    return 0;
 
1430
  return FastEmitInst_ri(X86::OR16ri, X86::GR16RegisterClass, Op0, imm1);
 
1431
}
 
1432
 
 
1433
unsigned FastEmit_ISD_OR_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1434
  if (RetVT.SimpleTy != MVT::i32)
 
1435
    return 0;
 
1436
  return FastEmitInst_ri(X86::OR32ri, X86::GR32RegisterClass, Op0, imm1);
 
1437
}
 
1438
 
 
1439
unsigned FastEmit_ISD_OR_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1440
  switch (VT.SimpleTy) {
 
1441
  case MVT::i8: return FastEmit_ISD_OR_MVT_i8_ri(RetVT, Op0, imm1);
 
1442
  case MVT::i16: return FastEmit_ISD_OR_MVT_i16_ri(RetVT, Op0, imm1);
 
1443
  case MVT::i32: return FastEmit_ISD_OR_MVT_i32_ri(RetVT, Op0, imm1);
 
1444
  default: return 0;
 
1445
  }
 
1446
}
 
1447
 
 
1448
// FastEmit functions for ISD::ROTL.
 
1449
 
 
1450
unsigned FastEmit_ISD_ROTL_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1451
  if (RetVT.SimpleTy != MVT::i8)
 
1452
    return 0;
 
1453
  return FastEmitInst_ri(X86::ROL8ri, X86::GR8RegisterClass, Op0, imm1);
 
1454
}
 
1455
 
 
1456
unsigned FastEmit_ISD_ROTL_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1457
  switch (VT.SimpleTy) {
 
1458
  case MVT::i8: return FastEmit_ISD_ROTL_MVT_i8_ri(RetVT, Op0, imm1);
 
1459
  default: return 0;
 
1460
  }
 
1461
}
 
1462
 
 
1463
// FastEmit functions for ISD::ROTR.
 
1464
 
 
1465
unsigned FastEmit_ISD_ROTR_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1466
  if (RetVT.SimpleTy != MVT::i8)
 
1467
    return 0;
 
1468
  return FastEmitInst_ri(X86::ROR8ri, X86::GR8RegisterClass, Op0, imm1);
 
1469
}
 
1470
 
 
1471
unsigned FastEmit_ISD_ROTR_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1472
  switch (VT.SimpleTy) {
 
1473
  case MVT::i8: return FastEmit_ISD_ROTR_MVT_i8_ri(RetVT, Op0, imm1);
 
1474
  default: return 0;
 
1475
  }
 
1476
}
 
1477
 
 
1478
// FastEmit functions for ISD::SHL.
 
1479
 
 
1480
unsigned FastEmit_ISD_SHL_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1481
  if (RetVT.SimpleTy != MVT::i8)
 
1482
    return 0;
 
1483
  return FastEmitInst_ri(X86::SHL8ri, X86::GR8RegisterClass, Op0, imm1);
 
1484
}
 
1485
 
 
1486
unsigned FastEmit_ISD_SHL_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1487
  switch (VT.SimpleTy) {
 
1488
  case MVT::i8: return FastEmit_ISD_SHL_MVT_i8_ri(RetVT, Op0, imm1);
 
1489
  default: return 0;
 
1490
  }
 
1491
}
 
1492
 
 
1493
// FastEmit functions for ISD::SRA.
 
1494
 
 
1495
unsigned FastEmit_ISD_SRA_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1496
  if (RetVT.SimpleTy != MVT::i8)
 
1497
    return 0;
 
1498
  return FastEmitInst_ri(X86::SAR8ri, X86::GR8RegisterClass, Op0, imm1);
 
1499
}
 
1500
 
 
1501
unsigned FastEmit_ISD_SRA_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1502
  switch (VT.SimpleTy) {
 
1503
  case MVT::i8: return FastEmit_ISD_SRA_MVT_i8_ri(RetVT, Op0, imm1);
 
1504
  default: return 0;
 
1505
  }
 
1506
}
 
1507
 
 
1508
// FastEmit functions for ISD::SRL.
 
1509
 
 
1510
unsigned FastEmit_ISD_SRL_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1511
  if (RetVT.SimpleTy != MVT::i8)
 
1512
    return 0;
 
1513
  return FastEmitInst_ri(X86::SHR8ri, X86::GR8RegisterClass, Op0, imm1);
 
1514
}
 
1515
 
 
1516
unsigned FastEmit_ISD_SRL_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1517
  switch (VT.SimpleTy) {
 
1518
  case MVT::i8: return FastEmit_ISD_SRL_MVT_i8_ri(RetVT, Op0, imm1);
 
1519
  default: return 0;
 
1520
  }
 
1521
}
 
1522
 
 
1523
// FastEmit functions for ISD::SUB.
 
1524
 
 
1525
unsigned FastEmit_ISD_SUB_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1526
  if (RetVT.SimpleTy != MVT::i8)
 
1527
    return 0;
 
1528
  return FastEmitInst_ri(X86::SUB8ri, X86::GR8RegisterClass, Op0, imm1);
 
1529
}
 
1530
 
 
1531
unsigned FastEmit_ISD_SUB_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1532
  if (RetVT.SimpleTy != MVT::i16)
 
1533
    return 0;
 
1534
  return FastEmitInst_ri(X86::SUB16ri, X86::GR16RegisterClass, Op0, imm1);
 
1535
}
 
1536
 
 
1537
unsigned FastEmit_ISD_SUB_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1538
  if (RetVT.SimpleTy != MVT::i32)
 
1539
    return 0;
 
1540
  return FastEmitInst_ri(X86::SUB32ri, X86::GR32RegisterClass, Op0, imm1);
 
1541
}
 
1542
 
 
1543
unsigned FastEmit_ISD_SUB_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1544
  switch (VT.SimpleTy) {
 
1545
  case MVT::i8: return FastEmit_ISD_SUB_MVT_i8_ri(RetVT, Op0, imm1);
 
1546
  case MVT::i16: return FastEmit_ISD_SUB_MVT_i16_ri(RetVT, Op0, imm1);
 
1547
  case MVT::i32: return FastEmit_ISD_SUB_MVT_i32_ri(RetVT, Op0, imm1);
 
1548
  default: return 0;
 
1549
  }
 
1550
}
 
1551
 
 
1552
// FastEmit functions for ISD::SUBC.
 
1553
 
 
1554
unsigned FastEmit_ISD_SUBC_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1555
  if (RetVT.SimpleTy != MVT::i32)
 
1556
    return 0;
 
1557
  return FastEmitInst_ri(X86::SUB32ri, X86::GR32RegisterClass, Op0, imm1);
 
1558
}
 
1559
 
 
1560
unsigned FastEmit_ISD_SUBC_MVT_i64_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1561
  if (RetVT.SimpleTy != MVT::i64)
 
1562
    return 0;
 
1563
  return FastEmitInst_ri(X86::SUB64ri32, X86::GR64RegisterClass, Op0, imm1);
 
1564
}
 
1565
 
 
1566
unsigned FastEmit_ISD_SUBC_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1567
  switch (VT.SimpleTy) {
 
1568
  case MVT::i32: return FastEmit_ISD_SUBC_MVT_i32_ri(RetVT, Op0, imm1);
 
1569
  case MVT::i64: return FastEmit_ISD_SUBC_MVT_i64_ri(RetVT, Op0, imm1);
 
1570
  default: return 0;
 
1571
  }
 
1572
}
 
1573
 
 
1574
// FastEmit functions for ISD::SUBE.
 
1575
 
 
1576
unsigned FastEmit_ISD_SUBE_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1577
  if (RetVT.SimpleTy != MVT::i8)
 
1578
    return 0;
 
1579
  return FastEmitInst_ri(X86::SBB8ri, X86::GR8RegisterClass, Op0, imm1);
 
1580
}
 
1581
 
 
1582
unsigned FastEmit_ISD_SUBE_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1583
  if (RetVT.SimpleTy != MVT::i16)
 
1584
    return 0;
 
1585
  return FastEmitInst_ri(X86::SBB16ri, X86::GR16RegisterClass, Op0, imm1);
 
1586
}
 
1587
 
 
1588
unsigned FastEmit_ISD_SUBE_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1589
  if (RetVT.SimpleTy != MVT::i32)
 
1590
    return 0;
 
1591
  return FastEmitInst_ri(X86::SBB32ri, X86::GR32RegisterClass, Op0, imm1);
 
1592
}
 
1593
 
 
1594
unsigned FastEmit_ISD_SUBE_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1595
  switch (VT.SimpleTy) {
 
1596
  case MVT::i8: return FastEmit_ISD_SUBE_MVT_i8_ri(RetVT, Op0, imm1);
 
1597
  case MVT::i16: return FastEmit_ISD_SUBE_MVT_i16_ri(RetVT, Op0, imm1);
 
1598
  case MVT::i32: return FastEmit_ISD_SUBE_MVT_i32_ri(RetVT, Op0, imm1);
 
1599
  default: return 0;
 
1600
  }
 
1601
}
 
1602
 
 
1603
// FastEmit functions for ISD::XOR.
 
1604
 
 
1605
unsigned FastEmit_ISD_XOR_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1606
  if (RetVT.SimpleTy != MVT::i8)
 
1607
    return 0;
 
1608
  return FastEmitInst_ri(X86::XOR8ri, X86::GR8RegisterClass, Op0, imm1);
 
1609
}
 
1610
 
 
1611
unsigned FastEmit_ISD_XOR_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1612
  if (RetVT.SimpleTy != MVT::i16)
 
1613
    return 0;
 
1614
  return FastEmitInst_ri(X86::XOR16ri, X86::GR16RegisterClass, Op0, imm1);
 
1615
}
 
1616
 
 
1617
unsigned FastEmit_ISD_XOR_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1618
  if (RetVT.SimpleTy != MVT::i32)
 
1619
    return 0;
 
1620
  return FastEmitInst_ri(X86::XOR32ri, X86::GR32RegisterClass, Op0, imm1);
 
1621
}
 
1622
 
 
1623
unsigned FastEmit_ISD_XOR_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1624
  switch (VT.SimpleTy) {
 
1625
  case MVT::i8: return FastEmit_ISD_XOR_MVT_i8_ri(RetVT, Op0, imm1);
 
1626
  case MVT::i16: return FastEmit_ISD_XOR_MVT_i16_ri(RetVT, Op0, imm1);
 
1627
  case MVT::i32: return FastEmit_ISD_XOR_MVT_i32_ri(RetVT, Op0, imm1);
 
1628
  default: return 0;
 
1629
  }
 
1630
}
 
1631
 
 
1632
// FastEmit functions for X86ISD::ADD.
 
1633
 
 
1634
unsigned FastEmit_X86ISD_ADD_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1635
  if (RetVT.SimpleTy != MVT::i8)
 
1636
    return 0;
 
1637
  return FastEmitInst_ri(X86::ADD8ri, X86::GR8RegisterClass, Op0, imm1);
 
1638
}
 
1639
 
 
1640
unsigned FastEmit_X86ISD_ADD_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1641
  if (RetVT.SimpleTy != MVT::i16)
 
1642
    return 0;
 
1643
  return FastEmitInst_ri(X86::ADD16ri, X86::GR16RegisterClass, Op0, imm1);
 
1644
}
 
1645
 
 
1646
unsigned FastEmit_X86ISD_ADD_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1647
  if (RetVT.SimpleTy != MVT::i32)
 
1648
    return 0;
 
1649
  return FastEmitInst_ri(X86::ADD32ri, X86::GR32RegisterClass, Op0, imm1);
 
1650
}
 
1651
 
 
1652
unsigned FastEmit_X86ISD_ADD_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1653
  switch (VT.SimpleTy) {
 
1654
  case MVT::i8: return FastEmit_X86ISD_ADD_MVT_i8_ri(RetVT, Op0, imm1);
 
1655
  case MVT::i16: return FastEmit_X86ISD_ADD_MVT_i16_ri(RetVT, Op0, imm1);
 
1656
  case MVT::i32: return FastEmit_X86ISD_ADD_MVT_i32_ri(RetVT, Op0, imm1);
 
1657
  default: return 0;
 
1658
  }
 
1659
}
 
1660
 
 
1661
// FastEmit functions for X86ISD::AND.
 
1662
 
 
1663
unsigned FastEmit_X86ISD_AND_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1664
  if (RetVT.SimpleTy != MVT::i8)
 
1665
    return 0;
 
1666
  return FastEmitInst_ri(X86::AND8ri, X86::GR8RegisterClass, Op0, imm1);
 
1667
}
 
1668
 
 
1669
unsigned FastEmit_X86ISD_AND_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1670
  if (RetVT.SimpleTy != MVT::i16)
 
1671
    return 0;
 
1672
  return FastEmitInst_ri(X86::AND16ri, X86::GR16RegisterClass, Op0, imm1);
 
1673
}
 
1674
 
 
1675
unsigned FastEmit_X86ISD_AND_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1676
  if (RetVT.SimpleTy != MVT::i32)
 
1677
    return 0;
 
1678
  return FastEmitInst_ri(X86::AND32ri, X86::GR32RegisterClass, Op0, imm1);
 
1679
}
 
1680
 
 
1681
unsigned FastEmit_X86ISD_AND_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1682
  switch (VT.SimpleTy) {
 
1683
  case MVT::i8: return FastEmit_X86ISD_AND_MVT_i8_ri(RetVT, Op0, imm1);
 
1684
  case MVT::i16: return FastEmit_X86ISD_AND_MVT_i16_ri(RetVT, Op0, imm1);
 
1685
  case MVT::i32: return FastEmit_X86ISD_AND_MVT_i32_ri(RetVT, Op0, imm1);
 
1686
  default: return 0;
 
1687
  }
 
1688
}
 
1689
 
 
1690
// FastEmit functions for X86ISD::CMP.
 
1691
 
 
1692
unsigned FastEmit_X86ISD_CMP_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1693
  if (RetVT.SimpleTy != MVT::isVoid)
 
1694
    return 0;
 
1695
  return FastEmitInst_ri(X86::CMP8ri, X86::GR8RegisterClass, Op0, imm1);
 
1696
}
 
1697
 
 
1698
unsigned FastEmit_X86ISD_CMP_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1699
  if (RetVT.SimpleTy != MVT::isVoid)
 
1700
    return 0;
 
1701
  return FastEmitInst_ri(X86::CMP16ri, X86::GR16RegisterClass, Op0, imm1);
 
1702
}
 
1703
 
 
1704
unsigned FastEmit_X86ISD_CMP_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1705
  if (RetVT.SimpleTy != MVT::isVoid)
 
1706
    return 0;
 
1707
  return FastEmitInst_ri(X86::CMP32ri, X86::GR32RegisterClass, Op0, imm1);
 
1708
}
 
1709
 
 
1710
unsigned FastEmit_X86ISD_CMP_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1711
  switch (VT.SimpleTy) {
 
1712
  case MVT::i8: return FastEmit_X86ISD_CMP_MVT_i8_ri(RetVT, Op0, imm1);
 
1713
  case MVT::i16: return FastEmit_X86ISD_CMP_MVT_i16_ri(RetVT, Op0, imm1);
 
1714
  case MVT::i32: return FastEmit_X86ISD_CMP_MVT_i32_ri(RetVT, Op0, imm1);
 
1715
  default: return 0;
 
1716
  }
 
1717
}
 
1718
 
 
1719
// FastEmit functions for X86ISD::OR.
 
1720
 
 
1721
unsigned FastEmit_X86ISD_OR_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1722
  if (RetVT.SimpleTy != MVT::i8)
 
1723
    return 0;
 
1724
  return FastEmitInst_ri(X86::OR8ri, X86::GR8RegisterClass, Op0, imm1);
 
1725
}
 
1726
 
 
1727
unsigned FastEmit_X86ISD_OR_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1728
  if (RetVT.SimpleTy != MVT::i16)
 
1729
    return 0;
 
1730
  return FastEmitInst_ri(X86::OR16ri, X86::GR16RegisterClass, Op0, imm1);
 
1731
}
 
1732
 
 
1733
unsigned FastEmit_X86ISD_OR_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1734
  if (RetVT.SimpleTy != MVT::i32)
 
1735
    return 0;
 
1736
  return FastEmitInst_ri(X86::OR32ri, X86::GR32RegisterClass, Op0, imm1);
 
1737
}
 
1738
 
 
1739
unsigned FastEmit_X86ISD_OR_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1740
  switch (VT.SimpleTy) {
 
1741
  case MVT::i8: return FastEmit_X86ISD_OR_MVT_i8_ri(RetVT, Op0, imm1);
 
1742
  case MVT::i16: return FastEmit_X86ISD_OR_MVT_i16_ri(RetVT, Op0, imm1);
 
1743
  case MVT::i32: return FastEmit_X86ISD_OR_MVT_i32_ri(RetVT, Op0, imm1);
 
1744
  default: return 0;
 
1745
  }
 
1746
}
 
1747
 
 
1748
// FastEmit functions for X86ISD::SMUL.
 
1749
 
 
1750
unsigned FastEmit_X86ISD_SMUL_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1751
  if (RetVT.SimpleTy != MVT::i16)
 
1752
    return 0;
 
1753
  return FastEmitInst_ri(X86::IMUL16rri, X86::GR16RegisterClass, Op0, imm1);
 
1754
}
 
1755
 
 
1756
unsigned FastEmit_X86ISD_SMUL_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1757
  if (RetVT.SimpleTy != MVT::i32)
 
1758
    return 0;
 
1759
  return FastEmitInst_ri(X86::IMUL32rri, X86::GR32RegisterClass, Op0, imm1);
 
1760
}
 
1761
 
 
1762
unsigned FastEmit_X86ISD_SMUL_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1763
  switch (VT.SimpleTy) {
 
1764
  case MVT::i16: return FastEmit_X86ISD_SMUL_MVT_i16_ri(RetVT, Op0, imm1);
 
1765
  case MVT::i32: return FastEmit_X86ISD_SMUL_MVT_i32_ri(RetVT, Op0, imm1);
 
1766
  default: return 0;
 
1767
  }
 
1768
}
 
1769
 
 
1770
// FastEmit functions for X86ISD::SUB.
 
1771
 
 
1772
unsigned FastEmit_X86ISD_SUB_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1773
  if (RetVT.SimpleTy != MVT::i8)
 
1774
    return 0;
 
1775
  return FastEmitInst_ri(X86::SUB8ri, X86::GR8RegisterClass, Op0, imm1);
 
1776
}
 
1777
 
 
1778
unsigned FastEmit_X86ISD_SUB_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1779
  if (RetVT.SimpleTy != MVT::i16)
 
1780
    return 0;
 
1781
  return FastEmitInst_ri(X86::SUB16ri, X86::GR16RegisterClass, Op0, imm1);
 
1782
}
 
1783
 
 
1784
unsigned FastEmit_X86ISD_SUB_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1785
  if (RetVT.SimpleTy != MVT::i32)
 
1786
    return 0;
 
1787
  return FastEmitInst_ri(X86::SUB32ri, X86::GR32RegisterClass, Op0, imm1);
 
1788
}
 
1789
 
 
1790
unsigned FastEmit_X86ISD_SUB_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1791
  switch (VT.SimpleTy) {
 
1792
  case MVT::i8: return FastEmit_X86ISD_SUB_MVT_i8_ri(RetVT, Op0, imm1);
 
1793
  case MVT::i16: return FastEmit_X86ISD_SUB_MVT_i16_ri(RetVT, Op0, imm1);
 
1794
  case MVT::i32: return FastEmit_X86ISD_SUB_MVT_i32_ri(RetVT, Op0, imm1);
 
1795
  default: return 0;
 
1796
  }
 
1797
}
 
1798
 
 
1799
// FastEmit functions for X86ISD::TC_RETURN.
 
1800
 
 
1801
unsigned FastEmit_X86ISD_TC_RETURN_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1802
  if (RetVT.SimpleTy != MVT::isVoid)
 
1803
    return 0;
 
1804
  return FastEmitInst_ri(X86::TCRETURNri, X86::GR32RegisterClass, Op0, imm1);
 
1805
}
 
1806
 
 
1807
unsigned FastEmit_X86ISD_TC_RETURN_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1808
  switch (VT.SimpleTy) {
 
1809
  case MVT::i32: return FastEmit_X86ISD_TC_RETURN_MVT_i32_ri(RetVT, Op0, imm1);
 
1810
  default: return 0;
 
1811
  }
 
1812
}
 
1813
 
 
1814
// FastEmit functions for X86ISD::XOR.
 
1815
 
 
1816
unsigned FastEmit_X86ISD_XOR_MVT_i8_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1817
  if (RetVT.SimpleTy != MVT::i8)
 
1818
    return 0;
 
1819
  return FastEmitInst_ri(X86::XOR8ri, X86::GR8RegisterClass, Op0, imm1);
 
1820
}
 
1821
 
 
1822
unsigned FastEmit_X86ISD_XOR_MVT_i16_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1823
  if (RetVT.SimpleTy != MVT::i16)
 
1824
    return 0;
 
1825
  return FastEmitInst_ri(X86::XOR16ri, X86::GR16RegisterClass, Op0, imm1);
 
1826
}
 
1827
 
 
1828
unsigned FastEmit_X86ISD_XOR_MVT_i32_ri(MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1829
  if (RetVT.SimpleTy != MVT::i32)
 
1830
    return 0;
 
1831
  return FastEmitInst_ri(X86::XOR32ri, X86::GR32RegisterClass, Op0, imm1);
 
1832
}
 
1833
 
 
1834
unsigned FastEmit_X86ISD_XOR_ri(MVT VT, MVT RetVT, unsigned Op0, uint64_t imm1) {
 
1835
  switch (VT.SimpleTy) {
 
1836
  case MVT::i8: return FastEmit_X86ISD_XOR_MVT_i8_ri(RetVT, Op0, imm1);
 
1837
  case MVT::i16: return FastEmit_X86ISD_XOR_MVT_i16_ri(RetVT, Op0, imm1);
 
1838
  case MVT::i32: return FastEmit_X86ISD_XOR_MVT_i32_ri(RetVT, Op0, imm1);
 
1839
  default: return 0;
 
1840
  }
 
1841
}
 
1842
 
 
1843
// Top-level FastEmit function.
 
1844
 
 
1845
unsigned FastEmit_ri(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, uint64_t imm1) {
 
1846
  switch (Opcode) {
 
1847
  case ISD::ADD: return FastEmit_ISD_ADD_ri(VT, RetVT, Op0, imm1);
 
1848
  case ISD::ADDC: return FastEmit_ISD_ADDC_ri(VT, RetVT, Op0, imm1);
 
1849
  case ISD::ADDE: return FastEmit_ISD_ADDE_ri(VT, RetVT, Op0, imm1);
 
1850
  case ISD::AND: return FastEmit_ISD_AND_ri(VT, RetVT, Op0, imm1);
 
1851
  case ISD::MUL: return FastEmit_ISD_MUL_ri(VT, RetVT, Op0, imm1);
 
1852
  case ISD::OR: return FastEmit_ISD_OR_ri(VT, RetVT, Op0, imm1);
 
1853
  case ISD::ROTL: return FastEmit_ISD_ROTL_ri(VT, RetVT, Op0, imm1);
 
1854
  case ISD::ROTR: return FastEmit_ISD_ROTR_ri(VT, RetVT, Op0, imm1);
 
1855
  case ISD::SHL: return FastEmit_ISD_SHL_ri(VT, RetVT, Op0, imm1);
 
1856
  case ISD::SRA: return FastEmit_ISD_SRA_ri(VT, RetVT, Op0, imm1);
 
1857
  case ISD::SRL: return FastEmit_ISD_SRL_ri(VT, RetVT, Op0, imm1);
 
1858
  case ISD::SUB: return FastEmit_ISD_SUB_ri(VT, RetVT, Op0, imm1);
 
1859
  case ISD::SUBC: return FastEmit_ISD_SUBC_ri(VT, RetVT, Op0, imm1);
 
1860
  case ISD::SUBE: return FastEmit_ISD_SUBE_ri(VT, RetVT, Op0, imm1);
 
1861
  case ISD::XOR: return FastEmit_ISD_XOR_ri(VT, RetVT, Op0, imm1);
 
1862
  case X86ISD::ADD: return FastEmit_X86ISD_ADD_ri(VT, RetVT, Op0, imm1);
 
1863
  case X86ISD::AND: return FastEmit_X86ISD_AND_ri(VT, RetVT, Op0, imm1);
 
1864
  case X86ISD::CMP: return FastEmit_X86ISD_CMP_ri(VT, RetVT, Op0, imm1);
 
1865
  case X86ISD::OR: return FastEmit_X86ISD_OR_ri(VT, RetVT, Op0, imm1);
 
1866
  case X86ISD::SMUL: return FastEmit_X86ISD_SMUL_ri(VT, RetVT, Op0, imm1);
 
1867
  case X86ISD::SUB: return FastEmit_X86ISD_SUB_ri(VT, RetVT, Op0, imm1);
 
1868
  case X86ISD::TC_RETURN: return FastEmit_X86ISD_TC_RETURN_ri(VT, RetVT, Op0, imm1);
 
1869
  case X86ISD::XOR: return FastEmit_X86ISD_XOR_ri(VT, RetVT, Op0, imm1);
 
1870
  default: return 0;
 
1871
  }
 
1872
}
 
1873
 
 
1874
// FastEmit functions for ISD::ADD.
 
1875
 
 
1876
unsigned FastEmit_ISD_ADD_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1877
  if (RetVT.SimpleTy != MVT::i8)
 
1878
    return 0;
 
1879
  return FastEmitInst_rr(X86::ADD8rr, X86::GR8RegisterClass, Op0, Op1);
 
1880
}
 
1881
 
 
1882
unsigned FastEmit_ISD_ADD_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1883
  if (RetVT.SimpleTy != MVT::i16)
 
1884
    return 0;
 
1885
  return FastEmitInst_rr(X86::ADD16rr, X86::GR16RegisterClass, Op0, Op1);
 
1886
}
 
1887
 
 
1888
unsigned FastEmit_ISD_ADD_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1889
  if (RetVT.SimpleTy != MVT::i32)
 
1890
    return 0;
 
1891
  return FastEmitInst_rr(X86::ADD32rr, X86::GR32RegisterClass, Op0, Op1);
 
1892
}
 
1893
 
 
1894
unsigned FastEmit_ISD_ADD_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1895
  if (RetVT.SimpleTy != MVT::i64)
 
1896
    return 0;
 
1897
  return FastEmitInst_rr(X86::ADD64rr, X86::GR64RegisterClass, Op0, Op1);
 
1898
}
 
1899
 
 
1900
unsigned FastEmit_ISD_ADD_MVT_v8i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1901
  if (RetVT.SimpleTy != MVT::v8i8)
 
1902
    return 0;
 
1903
  if ((Subtarget->hasMMX())) {
 
1904
    return FastEmitInst_rr(X86::MMX_PADDBrr, X86::VR64RegisterClass, Op0, Op1);
 
1905
  }
 
1906
  return 0;
 
1907
}
 
1908
 
 
1909
unsigned FastEmit_ISD_ADD_MVT_v16i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1910
  if (RetVT.SimpleTy != MVT::v16i8)
 
1911
    return 0;
 
1912
  if ((Subtarget->hasSSE2())) {
 
1913
    return FastEmitInst_rr(X86::PADDBrr, X86::VR128RegisterClass, Op0, Op1);
 
1914
  }
 
1915
  return 0;
 
1916
}
 
1917
 
 
1918
unsigned FastEmit_ISD_ADD_MVT_v4i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1919
  if (RetVT.SimpleTy != MVT::v4i16)
 
1920
    return 0;
 
1921
  if ((Subtarget->hasMMX())) {
 
1922
    return FastEmitInst_rr(X86::MMX_PADDWrr, X86::VR64RegisterClass, Op0, Op1);
 
1923
  }
 
1924
  return 0;
 
1925
}
 
1926
 
 
1927
unsigned FastEmit_ISD_ADD_MVT_v8i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1928
  if (RetVT.SimpleTy != MVT::v8i16)
 
1929
    return 0;
 
1930
  if ((Subtarget->hasSSE2())) {
 
1931
    return FastEmitInst_rr(X86::PADDWrr, X86::VR128RegisterClass, Op0, Op1);
 
1932
  }
 
1933
  return 0;
 
1934
}
 
1935
 
 
1936
unsigned FastEmit_ISD_ADD_MVT_v2i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1937
  if (RetVT.SimpleTy != MVT::v2i32)
 
1938
    return 0;
 
1939
  if ((Subtarget->hasMMX())) {
 
1940
    return FastEmitInst_rr(X86::MMX_PADDDrr, X86::VR64RegisterClass, Op0, Op1);
 
1941
  }
 
1942
  return 0;
 
1943
}
 
1944
 
 
1945
unsigned FastEmit_ISD_ADD_MVT_v4i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1946
  if (RetVT.SimpleTy != MVT::v4i32)
 
1947
    return 0;
 
1948
  if ((Subtarget->hasSSE2())) {
 
1949
    return FastEmitInst_rr(X86::PADDDrr, X86::VR128RegisterClass, Op0, Op1);
 
1950
  }
 
1951
  return 0;
 
1952
}
 
1953
 
 
1954
unsigned FastEmit_ISD_ADD_MVT_v1i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1955
  if (RetVT.SimpleTy != MVT::v1i64)
 
1956
    return 0;
 
1957
  if ((Subtarget->hasMMX())) {
 
1958
    return FastEmitInst_rr(X86::MMX_PADDQrr, X86::VR64RegisterClass, Op0, Op1);
 
1959
  }
 
1960
  return 0;
 
1961
}
 
1962
 
 
1963
unsigned FastEmit_ISD_ADD_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1964
  if (RetVT.SimpleTy != MVT::v2i64)
 
1965
    return 0;
 
1966
  if ((Subtarget->hasSSE2())) {
 
1967
    return FastEmitInst_rr(X86::PADDQrr, X86::VR128RegisterClass, Op0, Op1);
 
1968
  }
 
1969
  return 0;
 
1970
}
 
1971
 
 
1972
unsigned FastEmit_ISD_ADD_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
1973
  switch (VT.SimpleTy) {
 
1974
  case MVT::i8: return FastEmit_ISD_ADD_MVT_i8_rr(RetVT, Op0, Op1);
 
1975
  case MVT::i16: return FastEmit_ISD_ADD_MVT_i16_rr(RetVT, Op0, Op1);
 
1976
  case MVT::i32: return FastEmit_ISD_ADD_MVT_i32_rr(RetVT, Op0, Op1);
 
1977
  case MVT::i64: return FastEmit_ISD_ADD_MVT_i64_rr(RetVT, Op0, Op1);
 
1978
  case MVT::v8i8: return FastEmit_ISD_ADD_MVT_v8i8_rr(RetVT, Op0, Op1);
 
1979
  case MVT::v16i8: return FastEmit_ISD_ADD_MVT_v16i8_rr(RetVT, Op0, Op1);
 
1980
  case MVT::v4i16: return FastEmit_ISD_ADD_MVT_v4i16_rr(RetVT, Op0, Op1);
 
1981
  case MVT::v8i16: return FastEmit_ISD_ADD_MVT_v8i16_rr(RetVT, Op0, Op1);
 
1982
  case MVT::v2i32: return FastEmit_ISD_ADD_MVT_v2i32_rr(RetVT, Op0, Op1);
 
1983
  case MVT::v4i32: return FastEmit_ISD_ADD_MVT_v4i32_rr(RetVT, Op0, Op1);
 
1984
  case MVT::v1i64: return FastEmit_ISD_ADD_MVT_v1i64_rr(RetVT, Op0, Op1);
 
1985
  case MVT::v2i64: return FastEmit_ISD_ADD_MVT_v2i64_rr(RetVT, Op0, Op1);
 
1986
  default: return 0;
 
1987
  }
 
1988
}
 
1989
 
 
1990
// FastEmit functions for ISD::ADDC.
 
1991
 
 
1992
unsigned FastEmit_ISD_ADDC_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1993
  if (RetVT.SimpleTy != MVT::i32)
 
1994
    return 0;
 
1995
  return FastEmitInst_rr(X86::ADD32rr, X86::GR32RegisterClass, Op0, Op1);
 
1996
}
 
1997
 
 
1998
unsigned FastEmit_ISD_ADDC_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
1999
  if (RetVT.SimpleTy != MVT::i64)
 
2000
    return 0;
 
2001
  return FastEmitInst_rr(X86::ADD64rr, X86::GR64RegisterClass, Op0, Op1);
 
2002
}
 
2003
 
 
2004
unsigned FastEmit_ISD_ADDC_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2005
  switch (VT.SimpleTy) {
 
2006
  case MVT::i32: return FastEmit_ISD_ADDC_MVT_i32_rr(RetVT, Op0, Op1);
 
2007
  case MVT::i64: return FastEmit_ISD_ADDC_MVT_i64_rr(RetVT, Op0, Op1);
 
2008
  default: return 0;
 
2009
  }
 
2010
}
 
2011
 
 
2012
// FastEmit functions for ISD::ADDE.
 
2013
 
 
2014
unsigned FastEmit_ISD_ADDE_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2015
  if (RetVT.SimpleTy != MVT::i8)
 
2016
    return 0;
 
2017
  return FastEmitInst_rr(X86::ADC8rr, X86::GR8RegisterClass, Op0, Op1);
 
2018
}
 
2019
 
 
2020
unsigned FastEmit_ISD_ADDE_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2021
  if (RetVT.SimpleTy != MVT::i16)
 
2022
    return 0;
 
2023
  return FastEmitInst_rr(X86::ADC16rr, X86::GR16RegisterClass, Op0, Op1);
 
2024
}
 
2025
 
 
2026
unsigned FastEmit_ISD_ADDE_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2027
  if (RetVT.SimpleTy != MVT::i32)
 
2028
    return 0;
 
2029
  return FastEmitInst_rr(X86::ADC32rr, X86::GR32RegisterClass, Op0, Op1);
 
2030
}
 
2031
 
 
2032
unsigned FastEmit_ISD_ADDE_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2033
  if (RetVT.SimpleTy != MVT::i64)
 
2034
    return 0;
 
2035
  return FastEmitInst_rr(X86::ADC64rr, X86::GR64RegisterClass, Op0, Op1);
 
2036
}
 
2037
 
 
2038
unsigned FastEmit_ISD_ADDE_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2039
  switch (VT.SimpleTy) {
 
2040
  case MVT::i8: return FastEmit_ISD_ADDE_MVT_i8_rr(RetVT, Op0, Op1);
 
2041
  case MVT::i16: return FastEmit_ISD_ADDE_MVT_i16_rr(RetVT, Op0, Op1);
 
2042
  case MVT::i32: return FastEmit_ISD_ADDE_MVT_i32_rr(RetVT, Op0, Op1);
 
2043
  case MVT::i64: return FastEmit_ISD_ADDE_MVT_i64_rr(RetVT, Op0, Op1);
 
2044
  default: return 0;
 
2045
  }
 
2046
}
 
2047
 
 
2048
// FastEmit functions for ISD::AND.
 
2049
 
 
2050
unsigned FastEmit_ISD_AND_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2051
  if (RetVT.SimpleTy != MVT::i8)
 
2052
    return 0;
 
2053
  return FastEmitInst_rr(X86::AND8rr, X86::GR8RegisterClass, Op0, Op1);
 
2054
}
 
2055
 
 
2056
unsigned FastEmit_ISD_AND_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2057
  if (RetVT.SimpleTy != MVT::i16)
 
2058
    return 0;
 
2059
  return FastEmitInst_rr(X86::AND16rr, X86::GR16RegisterClass, Op0, Op1);
 
2060
}
 
2061
 
 
2062
unsigned FastEmit_ISD_AND_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2063
  if (RetVT.SimpleTy != MVT::i32)
 
2064
    return 0;
 
2065
  return FastEmitInst_rr(X86::AND32rr, X86::GR32RegisterClass, Op0, Op1);
 
2066
}
 
2067
 
 
2068
unsigned FastEmit_ISD_AND_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2069
  if (RetVT.SimpleTy != MVT::i64)
 
2070
    return 0;
 
2071
  return FastEmitInst_rr(X86::AND64rr, X86::GR64RegisterClass, Op0, Op1);
 
2072
}
 
2073
 
 
2074
unsigned FastEmit_ISD_AND_MVT_v1i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2075
  if (RetVT.SimpleTy != MVT::v1i64)
 
2076
    return 0;
 
2077
  if ((Subtarget->hasMMX())) {
 
2078
    return FastEmitInst_rr(X86::MMX_PANDrr, X86::VR64RegisterClass, Op0, Op1);
 
2079
  }
 
2080
  return 0;
 
2081
}
 
2082
 
 
2083
unsigned FastEmit_ISD_AND_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2084
  if (RetVT.SimpleTy != MVT::v2i64)
 
2085
    return 0;
 
2086
  if ((Subtarget->hasSSE1())) {
 
2087
    return FastEmitInst_rr(X86::ANDPSrr, X86::VR128RegisterClass, Op0, Op1);
 
2088
  }
 
2089
  if ((Subtarget->hasSSE2())) {
 
2090
    return FastEmitInst_rr(X86::PANDrr, X86::VR128RegisterClass, Op0, Op1);
 
2091
  }
 
2092
  return 0;
 
2093
}
 
2094
 
 
2095
unsigned FastEmit_ISD_AND_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2096
  switch (VT.SimpleTy) {
 
2097
  case MVT::i8: return FastEmit_ISD_AND_MVT_i8_rr(RetVT, Op0, Op1);
 
2098
  case MVT::i16: return FastEmit_ISD_AND_MVT_i16_rr(RetVT, Op0, Op1);
 
2099
  case MVT::i32: return FastEmit_ISD_AND_MVT_i32_rr(RetVT, Op0, Op1);
 
2100
  case MVT::i64: return FastEmit_ISD_AND_MVT_i64_rr(RetVT, Op0, Op1);
 
2101
  case MVT::v1i64: return FastEmit_ISD_AND_MVT_v1i64_rr(RetVT, Op0, Op1);
 
2102
  case MVT::v2i64: return FastEmit_ISD_AND_MVT_v2i64_rr(RetVT, Op0, Op1);
 
2103
  default: return 0;
 
2104
  }
 
2105
}
 
2106
 
 
2107
// FastEmit functions for ISD::FADD.
 
2108
 
 
2109
unsigned FastEmit_ISD_FADD_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2110
  if (RetVT.SimpleTy != MVT::f32)
 
2111
    return 0;
 
2112
  if ((!Subtarget->hasSSE1())) {
 
2113
    return FastEmitInst_rr(X86::ADD_Fp32, X86::RFP32RegisterClass, Op0, Op1);
 
2114
  }
 
2115
  if ((Subtarget->hasSSE1())) {
 
2116
    return FastEmitInst_rr(X86::ADDSSrr, X86::FR32RegisterClass, Op0, Op1);
 
2117
  }
 
2118
  return 0;
 
2119
}
 
2120
 
 
2121
unsigned FastEmit_ISD_FADD_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2122
  if (RetVT.SimpleTy != MVT::f64)
 
2123
    return 0;
 
2124
  if ((!Subtarget->hasSSE2())) {
 
2125
    return FastEmitInst_rr(X86::ADD_Fp64, X86::RFP64RegisterClass, Op0, Op1);
 
2126
  }
 
2127
  if ((Subtarget->hasSSE2())) {
 
2128
    return FastEmitInst_rr(X86::ADDSDrr, X86::FR64RegisterClass, Op0, Op1);
 
2129
  }
 
2130
  return 0;
 
2131
}
 
2132
 
 
2133
unsigned FastEmit_ISD_FADD_MVT_f80_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2134
  if (RetVT.SimpleTy != MVT::f80)
 
2135
    return 0;
 
2136
  return FastEmitInst_rr(X86::ADD_Fp80, X86::RFP80RegisterClass, Op0, Op1);
 
2137
}
 
2138
 
 
2139
unsigned FastEmit_ISD_FADD_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2140
  if (RetVT.SimpleTy != MVT::v4f32)
 
2141
    return 0;
 
2142
  if ((Subtarget->hasSSE1())) {
 
2143
    return FastEmitInst_rr(X86::ADDPSrr, X86::VR128RegisterClass, Op0, Op1);
 
2144
  }
 
2145
  return 0;
 
2146
}
 
2147
 
 
2148
unsigned FastEmit_ISD_FADD_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2149
  if (RetVT.SimpleTy != MVT::v2f64)
 
2150
    return 0;
 
2151
  if ((Subtarget->hasSSE2())) {
 
2152
    return FastEmitInst_rr(X86::ADDPDrr, X86::VR128RegisterClass, Op0, Op1);
 
2153
  }
 
2154
  return 0;
 
2155
}
 
2156
 
 
2157
unsigned FastEmit_ISD_FADD_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2158
  switch (VT.SimpleTy) {
 
2159
  case MVT::f32: return FastEmit_ISD_FADD_MVT_f32_rr(RetVT, Op0, Op1);
 
2160
  case MVT::f64: return FastEmit_ISD_FADD_MVT_f64_rr(RetVT, Op0, Op1);
 
2161
  case MVT::f80: return FastEmit_ISD_FADD_MVT_f80_rr(RetVT, Op0, Op1);
 
2162
  case MVT::v4f32: return FastEmit_ISD_FADD_MVT_v4f32_rr(RetVT, Op0, Op1);
 
2163
  case MVT::v2f64: return FastEmit_ISD_FADD_MVT_v2f64_rr(RetVT, Op0, Op1);
 
2164
  default: return 0;
 
2165
  }
 
2166
}
 
2167
 
 
2168
// FastEmit functions for ISD::FDIV.
 
2169
 
 
2170
unsigned FastEmit_ISD_FDIV_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2171
  if (RetVT.SimpleTy != MVT::f32)
 
2172
    return 0;
 
2173
  if ((!Subtarget->hasSSE1())) {
 
2174
    return FastEmitInst_rr(X86::DIV_Fp32, X86::RFP32RegisterClass, Op0, Op1);
 
2175
  }
 
2176
  if ((Subtarget->hasSSE1())) {
 
2177
    return FastEmitInst_rr(X86::DIVSSrr, X86::FR32RegisterClass, Op0, Op1);
 
2178
  }
 
2179
  return 0;
 
2180
}
 
2181
 
 
2182
unsigned FastEmit_ISD_FDIV_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2183
  if (RetVT.SimpleTy != MVT::f64)
 
2184
    return 0;
 
2185
  if ((!Subtarget->hasSSE2())) {
 
2186
    return FastEmitInst_rr(X86::DIV_Fp64, X86::RFP64RegisterClass, Op0, Op1);
 
2187
  }
 
2188
  if ((Subtarget->hasSSE2())) {
 
2189
    return FastEmitInst_rr(X86::DIVSDrr, X86::FR64RegisterClass, Op0, Op1);
 
2190
  }
 
2191
  return 0;
 
2192
}
 
2193
 
 
2194
unsigned FastEmit_ISD_FDIV_MVT_f80_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2195
  if (RetVT.SimpleTy != MVT::f80)
 
2196
    return 0;
 
2197
  return FastEmitInst_rr(X86::DIV_Fp80, X86::RFP80RegisterClass, Op0, Op1);
 
2198
}
 
2199
 
 
2200
unsigned FastEmit_ISD_FDIV_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2201
  if (RetVT.SimpleTy != MVT::v4f32)
 
2202
    return 0;
 
2203
  if ((Subtarget->hasSSE1())) {
 
2204
    return FastEmitInst_rr(X86::DIVPSrr, X86::VR128RegisterClass, Op0, Op1);
 
2205
  }
 
2206
  return 0;
 
2207
}
 
2208
 
 
2209
unsigned FastEmit_ISD_FDIV_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2210
  if (RetVT.SimpleTy != MVT::v2f64)
 
2211
    return 0;
 
2212
  if ((Subtarget->hasSSE2())) {
 
2213
    return FastEmitInst_rr(X86::DIVPDrr, X86::VR128RegisterClass, Op0, Op1);
 
2214
  }
 
2215
  return 0;
 
2216
}
 
2217
 
 
2218
unsigned FastEmit_ISD_FDIV_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2219
  switch (VT.SimpleTy) {
 
2220
  case MVT::f32: return FastEmit_ISD_FDIV_MVT_f32_rr(RetVT, Op0, Op1);
 
2221
  case MVT::f64: return FastEmit_ISD_FDIV_MVT_f64_rr(RetVT, Op0, Op1);
 
2222
  case MVT::f80: return FastEmit_ISD_FDIV_MVT_f80_rr(RetVT, Op0, Op1);
 
2223
  case MVT::v4f32: return FastEmit_ISD_FDIV_MVT_v4f32_rr(RetVT, Op0, Op1);
 
2224
  case MVT::v2f64: return FastEmit_ISD_FDIV_MVT_v2f64_rr(RetVT, Op0, Op1);
 
2225
  default: return 0;
 
2226
  }
 
2227
}
 
2228
 
 
2229
// FastEmit functions for ISD::FMUL.
 
2230
 
 
2231
unsigned FastEmit_ISD_FMUL_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2232
  if (RetVT.SimpleTy != MVT::f32)
 
2233
    return 0;
 
2234
  if ((!Subtarget->hasSSE1())) {
 
2235
    return FastEmitInst_rr(X86::MUL_Fp32, X86::RFP32RegisterClass, Op0, Op1);
 
2236
  }
 
2237
  if ((Subtarget->hasSSE1())) {
 
2238
    return FastEmitInst_rr(X86::MULSSrr, X86::FR32RegisterClass, Op0, Op1);
 
2239
  }
 
2240
  return 0;
 
2241
}
 
2242
 
 
2243
unsigned FastEmit_ISD_FMUL_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2244
  if (RetVT.SimpleTy != MVT::f64)
 
2245
    return 0;
 
2246
  if ((!Subtarget->hasSSE2())) {
 
2247
    return FastEmitInst_rr(X86::MUL_Fp64, X86::RFP64RegisterClass, Op0, Op1);
 
2248
  }
 
2249
  if ((Subtarget->hasSSE2())) {
 
2250
    return FastEmitInst_rr(X86::MULSDrr, X86::FR64RegisterClass, Op0, Op1);
 
2251
  }
 
2252
  return 0;
 
2253
}
 
2254
 
 
2255
unsigned FastEmit_ISD_FMUL_MVT_f80_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2256
  if (RetVT.SimpleTy != MVT::f80)
 
2257
    return 0;
 
2258
  return FastEmitInst_rr(X86::MUL_Fp80, X86::RFP80RegisterClass, Op0, Op1);
 
2259
}
 
2260
 
 
2261
unsigned FastEmit_ISD_FMUL_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2262
  if (RetVT.SimpleTy != MVT::v4f32)
 
2263
    return 0;
 
2264
  if ((Subtarget->hasSSE1())) {
 
2265
    return FastEmitInst_rr(X86::MULPSrr, X86::VR128RegisterClass, Op0, Op1);
 
2266
  }
 
2267
  return 0;
 
2268
}
 
2269
 
 
2270
unsigned FastEmit_ISD_FMUL_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2271
  if (RetVT.SimpleTy != MVT::v2f64)
 
2272
    return 0;
 
2273
  if ((Subtarget->hasSSE2())) {
 
2274
    return FastEmitInst_rr(X86::MULPDrr, X86::VR128RegisterClass, Op0, Op1);
 
2275
  }
 
2276
  return 0;
 
2277
}
 
2278
 
 
2279
unsigned FastEmit_ISD_FMUL_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2280
  switch (VT.SimpleTy) {
 
2281
  case MVT::f32: return FastEmit_ISD_FMUL_MVT_f32_rr(RetVT, Op0, Op1);
 
2282
  case MVT::f64: return FastEmit_ISD_FMUL_MVT_f64_rr(RetVT, Op0, Op1);
 
2283
  case MVT::f80: return FastEmit_ISD_FMUL_MVT_f80_rr(RetVT, Op0, Op1);
 
2284
  case MVT::v4f32: return FastEmit_ISD_FMUL_MVT_v4f32_rr(RetVT, Op0, Op1);
 
2285
  case MVT::v2f64: return FastEmit_ISD_FMUL_MVT_v2f64_rr(RetVT, Op0, Op1);
 
2286
  default: return 0;
 
2287
  }
 
2288
}
 
2289
 
 
2290
// FastEmit functions for ISD::FSUB.
 
2291
 
 
2292
unsigned FastEmit_ISD_FSUB_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2293
  if (RetVT.SimpleTy != MVT::f32)
 
2294
    return 0;
 
2295
  if ((!Subtarget->hasSSE1())) {
 
2296
    return FastEmitInst_rr(X86::SUB_Fp32, X86::RFP32RegisterClass, Op0, Op1);
 
2297
  }
 
2298
  if ((Subtarget->hasSSE1())) {
 
2299
    return FastEmitInst_rr(X86::SUBSSrr, X86::FR32RegisterClass, Op0, Op1);
 
2300
  }
 
2301
  return 0;
 
2302
}
 
2303
 
 
2304
unsigned FastEmit_ISD_FSUB_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2305
  if (RetVT.SimpleTy != MVT::f64)
 
2306
    return 0;
 
2307
  if ((!Subtarget->hasSSE2())) {
 
2308
    return FastEmitInst_rr(X86::SUB_Fp64, X86::RFP64RegisterClass, Op0, Op1);
 
2309
  }
 
2310
  if ((Subtarget->hasSSE2())) {
 
2311
    return FastEmitInst_rr(X86::SUBSDrr, X86::FR64RegisterClass, Op0, Op1);
 
2312
  }
 
2313
  return 0;
 
2314
}
 
2315
 
 
2316
unsigned FastEmit_ISD_FSUB_MVT_f80_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2317
  if (RetVT.SimpleTy != MVT::f80)
 
2318
    return 0;
 
2319
  return FastEmitInst_rr(X86::SUB_Fp80, X86::RFP80RegisterClass, Op0, Op1);
 
2320
}
 
2321
 
 
2322
unsigned FastEmit_ISD_FSUB_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2323
  if (RetVT.SimpleTy != MVT::v4f32)
 
2324
    return 0;
 
2325
  if ((Subtarget->hasSSE1())) {
 
2326
    return FastEmitInst_rr(X86::SUBPSrr, X86::VR128RegisterClass, Op0, Op1);
 
2327
  }
 
2328
  return 0;
 
2329
}
 
2330
 
 
2331
unsigned FastEmit_ISD_FSUB_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2332
  if (RetVT.SimpleTy != MVT::v2f64)
 
2333
    return 0;
 
2334
  if ((Subtarget->hasSSE2())) {
 
2335
    return FastEmitInst_rr(X86::SUBPDrr, X86::VR128RegisterClass, Op0, Op1);
 
2336
  }
 
2337
  return 0;
 
2338
}
 
2339
 
 
2340
unsigned FastEmit_ISD_FSUB_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2341
  switch (VT.SimpleTy) {
 
2342
  case MVT::f32: return FastEmit_ISD_FSUB_MVT_f32_rr(RetVT, Op0, Op1);
 
2343
  case MVT::f64: return FastEmit_ISD_FSUB_MVT_f64_rr(RetVT, Op0, Op1);
 
2344
  case MVT::f80: return FastEmit_ISD_FSUB_MVT_f80_rr(RetVT, Op0, Op1);
 
2345
  case MVT::v4f32: return FastEmit_ISD_FSUB_MVT_v4f32_rr(RetVT, Op0, Op1);
 
2346
  case MVT::v2f64: return FastEmit_ISD_FSUB_MVT_v2f64_rr(RetVT, Op0, Op1);
 
2347
  default: return 0;
 
2348
  }
 
2349
}
 
2350
 
 
2351
// FastEmit functions for ISD::MUL.
 
2352
 
 
2353
unsigned FastEmit_ISD_MUL_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2354
  if (RetVT.SimpleTy != MVT::i8)
 
2355
    return 0;
 
2356
  TII.copyRegToReg(*MBB, MBB->end(), X86::AL, Op0, TM.getRegisterInfo()->getPhysicalRegisterRegClass(X86::AL), MRI.getRegClass(Op0));
 
2357
  return FastEmitInst_r(X86::MUL8r, X86::GR8RegisterClass, Op1);
 
2358
}
 
2359
 
 
2360
unsigned FastEmit_ISD_MUL_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2361
  if (RetVT.SimpleTy != MVT::i16)
 
2362
    return 0;
 
2363
  return FastEmitInst_rr(X86::IMUL16rr, X86::GR16RegisterClass, Op0, Op1);
 
2364
}
 
2365
 
 
2366
unsigned FastEmit_ISD_MUL_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2367
  if (RetVT.SimpleTy != MVT::i32)
 
2368
    return 0;
 
2369
  return FastEmitInst_rr(X86::IMUL32rr, X86::GR32RegisterClass, Op0, Op1);
 
2370
}
 
2371
 
 
2372
unsigned FastEmit_ISD_MUL_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2373
  if (RetVT.SimpleTy != MVT::i64)
 
2374
    return 0;
 
2375
  return FastEmitInst_rr(X86::IMUL64rr, X86::GR64RegisterClass, Op0, Op1);
 
2376
}
 
2377
 
 
2378
unsigned FastEmit_ISD_MUL_MVT_v4i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2379
  if (RetVT.SimpleTy != MVT::v4i16)
 
2380
    return 0;
 
2381
  if ((Subtarget->hasMMX())) {
 
2382
    return FastEmitInst_rr(X86::MMX_PMULLWrr, X86::VR64RegisterClass, Op0, Op1);
 
2383
  }
 
2384
  return 0;
 
2385
}
 
2386
 
 
2387
unsigned FastEmit_ISD_MUL_MVT_v8i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2388
  if (RetVT.SimpleTy != MVT::v8i16)
 
2389
    return 0;
 
2390
  if ((Subtarget->hasSSE2())) {
 
2391
    return FastEmitInst_rr(X86::PMULLWrr, X86::VR128RegisterClass, Op0, Op1);
 
2392
  }
 
2393
  return 0;
 
2394
}
 
2395
 
 
2396
unsigned FastEmit_ISD_MUL_MVT_v4i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2397
  if (RetVT.SimpleTy != MVT::v4i32)
 
2398
    return 0;
 
2399
  if ((Subtarget->hasSSE41())) {
 
2400
    return FastEmitInst_rr(X86::PMULLDrr, X86::VR128RegisterClass, Op0, Op1);
 
2401
  }
 
2402
  return 0;
 
2403
}
 
2404
 
 
2405
unsigned FastEmit_ISD_MUL_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2406
  switch (VT.SimpleTy) {
 
2407
  case MVT::i8: return FastEmit_ISD_MUL_MVT_i8_rr(RetVT, Op0, Op1);
 
2408
  case MVT::i16: return FastEmit_ISD_MUL_MVT_i16_rr(RetVT, Op0, Op1);
 
2409
  case MVT::i32: return FastEmit_ISD_MUL_MVT_i32_rr(RetVT, Op0, Op1);
 
2410
  case MVT::i64: return FastEmit_ISD_MUL_MVT_i64_rr(RetVT, Op0, Op1);
 
2411
  case MVT::v4i16: return FastEmit_ISD_MUL_MVT_v4i16_rr(RetVT, Op0, Op1);
 
2412
  case MVT::v8i16: return FastEmit_ISD_MUL_MVT_v8i16_rr(RetVT, Op0, Op1);
 
2413
  case MVT::v4i32: return FastEmit_ISD_MUL_MVT_v4i32_rr(RetVT, Op0, Op1);
 
2414
  default: return 0;
 
2415
  }
 
2416
}
 
2417
 
 
2418
// FastEmit functions for ISD::OR.
 
2419
 
 
2420
unsigned FastEmit_ISD_OR_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2421
  if (RetVT.SimpleTy != MVT::i8)
 
2422
    return 0;
 
2423
  return FastEmitInst_rr(X86::OR8rr, X86::GR8RegisterClass, Op0, Op1);
 
2424
}
 
2425
 
 
2426
unsigned FastEmit_ISD_OR_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2427
  if (RetVT.SimpleTy != MVT::i16)
 
2428
    return 0;
 
2429
  return FastEmitInst_rr(X86::OR16rr, X86::GR16RegisterClass, Op0, Op1);
 
2430
}
 
2431
 
 
2432
unsigned FastEmit_ISD_OR_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2433
  if (RetVT.SimpleTy != MVT::i32)
 
2434
    return 0;
 
2435
  return FastEmitInst_rr(X86::OR32rr, X86::GR32RegisterClass, Op0, Op1);
 
2436
}
 
2437
 
 
2438
unsigned FastEmit_ISD_OR_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2439
  if (RetVT.SimpleTy != MVT::i64)
 
2440
    return 0;
 
2441
  return FastEmitInst_rr(X86::OR64rr, X86::GR64RegisterClass, Op0, Op1);
 
2442
}
 
2443
 
 
2444
unsigned FastEmit_ISD_OR_MVT_v1i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2445
  if (RetVT.SimpleTy != MVT::v1i64)
 
2446
    return 0;
 
2447
  if ((Subtarget->hasMMX())) {
 
2448
    return FastEmitInst_rr(X86::MMX_PORrr, X86::VR64RegisterClass, Op0, Op1);
 
2449
  }
 
2450
  return 0;
 
2451
}
 
2452
 
 
2453
unsigned FastEmit_ISD_OR_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2454
  if (RetVT.SimpleTy != MVT::v2i64)
 
2455
    return 0;
 
2456
  if ((Subtarget->hasSSE1())) {
 
2457
    return FastEmitInst_rr(X86::ORPSrr, X86::VR128RegisterClass, Op0, Op1);
 
2458
  }
 
2459
  if ((Subtarget->hasSSE2())) {
 
2460
    return FastEmitInst_rr(X86::PORrr, X86::VR128RegisterClass, Op0, Op1);
 
2461
  }
 
2462
  return 0;
 
2463
}
 
2464
 
 
2465
unsigned FastEmit_ISD_OR_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2466
  switch (VT.SimpleTy) {
 
2467
  case MVT::i8: return FastEmit_ISD_OR_MVT_i8_rr(RetVT, Op0, Op1);
 
2468
  case MVT::i16: return FastEmit_ISD_OR_MVT_i16_rr(RetVT, Op0, Op1);
 
2469
  case MVT::i32: return FastEmit_ISD_OR_MVT_i32_rr(RetVT, Op0, Op1);
 
2470
  case MVT::i64: return FastEmit_ISD_OR_MVT_i64_rr(RetVT, Op0, Op1);
 
2471
  case MVT::v1i64: return FastEmit_ISD_OR_MVT_v1i64_rr(RetVT, Op0, Op1);
 
2472
  case MVT::v2i64: return FastEmit_ISD_OR_MVT_v2i64_rr(RetVT, Op0, Op1);
 
2473
  default: return 0;
 
2474
  }
 
2475
}
 
2476
 
 
2477
// FastEmit functions for ISD::SUB.
 
2478
 
 
2479
unsigned FastEmit_ISD_SUB_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2480
  if (RetVT.SimpleTy != MVT::i8)
 
2481
    return 0;
 
2482
  return FastEmitInst_rr(X86::SUB8rr, X86::GR8RegisterClass, Op0, Op1);
 
2483
}
 
2484
 
 
2485
unsigned FastEmit_ISD_SUB_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2486
  if (RetVT.SimpleTy != MVT::i16)
 
2487
    return 0;
 
2488
  return FastEmitInst_rr(X86::SUB16rr, X86::GR16RegisterClass, Op0, Op1);
 
2489
}
 
2490
 
 
2491
unsigned FastEmit_ISD_SUB_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2492
  if (RetVT.SimpleTy != MVT::i32)
 
2493
    return 0;
 
2494
  return FastEmitInst_rr(X86::SUB32rr, X86::GR32RegisterClass, Op0, Op1);
 
2495
}
 
2496
 
 
2497
unsigned FastEmit_ISD_SUB_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2498
  if (RetVT.SimpleTy != MVT::i64)
 
2499
    return 0;
 
2500
  return FastEmitInst_rr(X86::SUB64rr, X86::GR64RegisterClass, Op0, Op1);
 
2501
}
 
2502
 
 
2503
unsigned FastEmit_ISD_SUB_MVT_v8i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2504
  if (RetVT.SimpleTy != MVT::v8i8)
 
2505
    return 0;
 
2506
  if ((Subtarget->hasMMX())) {
 
2507
    return FastEmitInst_rr(X86::MMX_PSUBBrr, X86::VR64RegisterClass, Op0, Op1);
 
2508
  }
 
2509
  return 0;
 
2510
}
 
2511
 
 
2512
unsigned FastEmit_ISD_SUB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2513
  if (RetVT.SimpleTy != MVT::v16i8)
 
2514
    return 0;
 
2515
  if ((Subtarget->hasSSE2())) {
 
2516
    return FastEmitInst_rr(X86::PSUBBrr, X86::VR128RegisterClass, Op0, Op1);
 
2517
  }
 
2518
  return 0;
 
2519
}
 
2520
 
 
2521
unsigned FastEmit_ISD_SUB_MVT_v4i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2522
  if (RetVT.SimpleTy != MVT::v4i16)
 
2523
    return 0;
 
2524
  if ((Subtarget->hasMMX())) {
 
2525
    return FastEmitInst_rr(X86::MMX_PSUBWrr, X86::VR64RegisterClass, Op0, Op1);
 
2526
  }
 
2527
  return 0;
 
2528
}
 
2529
 
 
2530
unsigned FastEmit_ISD_SUB_MVT_v8i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2531
  if (RetVT.SimpleTy != MVT::v8i16)
 
2532
    return 0;
 
2533
  if ((Subtarget->hasSSE2())) {
 
2534
    return FastEmitInst_rr(X86::PSUBWrr, X86::VR128RegisterClass, Op0, Op1);
 
2535
  }
 
2536
  return 0;
 
2537
}
 
2538
 
 
2539
unsigned FastEmit_ISD_SUB_MVT_v2i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2540
  if (RetVT.SimpleTy != MVT::v2i32)
 
2541
    return 0;
 
2542
  if ((Subtarget->hasMMX())) {
 
2543
    return FastEmitInst_rr(X86::MMX_PSUBDrr, X86::VR64RegisterClass, Op0, Op1);
 
2544
  }
 
2545
  return 0;
 
2546
}
 
2547
 
 
2548
unsigned FastEmit_ISD_SUB_MVT_v4i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2549
  if (RetVT.SimpleTy != MVT::v4i32)
 
2550
    return 0;
 
2551
  if ((Subtarget->hasSSE2())) {
 
2552
    return FastEmitInst_rr(X86::PSUBDrr, X86::VR128RegisterClass, Op0, Op1);
 
2553
  }
 
2554
  return 0;
 
2555
}
 
2556
 
 
2557
unsigned FastEmit_ISD_SUB_MVT_v1i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2558
  if (RetVT.SimpleTy != MVT::v1i64)
 
2559
    return 0;
 
2560
  if ((Subtarget->hasMMX())) {
 
2561
    return FastEmitInst_rr(X86::MMX_PSUBQrr, X86::VR64RegisterClass, Op0, Op1);
 
2562
  }
 
2563
  return 0;
 
2564
}
 
2565
 
 
2566
unsigned FastEmit_ISD_SUB_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2567
  if (RetVT.SimpleTy != MVT::v2i64)
 
2568
    return 0;
 
2569
  if ((Subtarget->hasSSE2())) {
 
2570
    return FastEmitInst_rr(X86::PSUBQrr, X86::VR128RegisterClass, Op0, Op1);
 
2571
  }
 
2572
  return 0;
 
2573
}
 
2574
 
 
2575
unsigned FastEmit_ISD_SUB_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2576
  switch (VT.SimpleTy) {
 
2577
  case MVT::i8: return FastEmit_ISD_SUB_MVT_i8_rr(RetVT, Op0, Op1);
 
2578
  case MVT::i16: return FastEmit_ISD_SUB_MVT_i16_rr(RetVT, Op0, Op1);
 
2579
  case MVT::i32: return FastEmit_ISD_SUB_MVT_i32_rr(RetVT, Op0, Op1);
 
2580
  case MVT::i64: return FastEmit_ISD_SUB_MVT_i64_rr(RetVT, Op0, Op1);
 
2581
  case MVT::v8i8: return FastEmit_ISD_SUB_MVT_v8i8_rr(RetVT, Op0, Op1);
 
2582
  case MVT::v16i8: return FastEmit_ISD_SUB_MVT_v16i8_rr(RetVT, Op0, Op1);
 
2583
  case MVT::v4i16: return FastEmit_ISD_SUB_MVT_v4i16_rr(RetVT, Op0, Op1);
 
2584
  case MVT::v8i16: return FastEmit_ISD_SUB_MVT_v8i16_rr(RetVT, Op0, Op1);
 
2585
  case MVT::v2i32: return FastEmit_ISD_SUB_MVT_v2i32_rr(RetVT, Op0, Op1);
 
2586
  case MVT::v4i32: return FastEmit_ISD_SUB_MVT_v4i32_rr(RetVT, Op0, Op1);
 
2587
  case MVT::v1i64: return FastEmit_ISD_SUB_MVT_v1i64_rr(RetVT, Op0, Op1);
 
2588
  case MVT::v2i64: return FastEmit_ISD_SUB_MVT_v2i64_rr(RetVT, Op0, Op1);
 
2589
  default: return 0;
 
2590
  }
 
2591
}
 
2592
 
 
2593
// FastEmit functions for ISD::SUBC.
 
2594
 
 
2595
unsigned FastEmit_ISD_SUBC_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2596
  if (RetVT.SimpleTy != MVT::i32)
 
2597
    return 0;
 
2598
  return FastEmitInst_rr(X86::SUB32rr, X86::GR32RegisterClass, Op0, Op1);
 
2599
}
 
2600
 
 
2601
unsigned FastEmit_ISD_SUBC_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2602
  if (RetVT.SimpleTy != MVT::i64)
 
2603
    return 0;
 
2604
  return FastEmitInst_rr(X86::SUB64rr, X86::GR64RegisterClass, Op0, Op1);
 
2605
}
 
2606
 
 
2607
unsigned FastEmit_ISD_SUBC_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2608
  switch (VT.SimpleTy) {
 
2609
  case MVT::i32: return FastEmit_ISD_SUBC_MVT_i32_rr(RetVT, Op0, Op1);
 
2610
  case MVT::i64: return FastEmit_ISD_SUBC_MVT_i64_rr(RetVT, Op0, Op1);
 
2611
  default: return 0;
 
2612
  }
 
2613
}
 
2614
 
 
2615
// FastEmit functions for ISD::SUBE.
 
2616
 
 
2617
unsigned FastEmit_ISD_SUBE_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2618
  if (RetVT.SimpleTy != MVT::i8)
 
2619
    return 0;
 
2620
  return FastEmitInst_rr(X86::SBB8rr, X86::GR8RegisterClass, Op0, Op1);
 
2621
}
 
2622
 
 
2623
unsigned FastEmit_ISD_SUBE_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2624
  if (RetVT.SimpleTy != MVT::i16)
 
2625
    return 0;
 
2626
  return FastEmitInst_rr(X86::SBB16rr, X86::GR16RegisterClass, Op0, Op1);
 
2627
}
 
2628
 
 
2629
unsigned FastEmit_ISD_SUBE_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2630
  if (RetVT.SimpleTy != MVT::i32)
 
2631
    return 0;
 
2632
  return FastEmitInst_rr(X86::SBB32rr, X86::GR32RegisterClass, Op0, Op1);
 
2633
}
 
2634
 
 
2635
unsigned FastEmit_ISD_SUBE_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2636
  if (RetVT.SimpleTy != MVT::i64)
 
2637
    return 0;
 
2638
  return FastEmitInst_rr(X86::SBB64rr, X86::GR64RegisterClass, Op0, Op1);
 
2639
}
 
2640
 
 
2641
unsigned FastEmit_ISD_SUBE_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2642
  switch (VT.SimpleTy) {
 
2643
  case MVT::i8: return FastEmit_ISD_SUBE_MVT_i8_rr(RetVT, Op0, Op1);
 
2644
  case MVT::i16: return FastEmit_ISD_SUBE_MVT_i16_rr(RetVT, Op0, Op1);
 
2645
  case MVT::i32: return FastEmit_ISD_SUBE_MVT_i32_rr(RetVT, Op0, Op1);
 
2646
  case MVT::i64: return FastEmit_ISD_SUBE_MVT_i64_rr(RetVT, Op0, Op1);
 
2647
  default: return 0;
 
2648
  }
 
2649
}
 
2650
 
 
2651
// FastEmit functions for ISD::XOR.
 
2652
 
 
2653
unsigned FastEmit_ISD_XOR_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2654
  if (RetVT.SimpleTy != MVT::i8)
 
2655
    return 0;
 
2656
  return FastEmitInst_rr(X86::XOR8rr, X86::GR8RegisterClass, Op0, Op1);
 
2657
}
 
2658
 
 
2659
unsigned FastEmit_ISD_XOR_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2660
  if (RetVT.SimpleTy != MVT::i16)
 
2661
    return 0;
 
2662
  return FastEmitInst_rr(X86::XOR16rr, X86::GR16RegisterClass, Op0, Op1);
 
2663
}
 
2664
 
 
2665
unsigned FastEmit_ISD_XOR_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2666
  if (RetVT.SimpleTy != MVT::i32)
 
2667
    return 0;
 
2668
  return FastEmitInst_rr(X86::XOR32rr, X86::GR32RegisterClass, Op0, Op1);
 
2669
}
 
2670
 
 
2671
unsigned FastEmit_ISD_XOR_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2672
  if (RetVT.SimpleTy != MVT::i64)
 
2673
    return 0;
 
2674
  return FastEmitInst_rr(X86::XOR64rr, X86::GR64RegisterClass, Op0, Op1);
 
2675
}
 
2676
 
 
2677
unsigned FastEmit_ISD_XOR_MVT_v1i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2678
  if (RetVT.SimpleTy != MVT::v1i64)
 
2679
    return 0;
 
2680
  if ((Subtarget->hasMMX())) {
 
2681
    return FastEmitInst_rr(X86::MMX_PXORrr, X86::VR64RegisterClass, Op0, Op1);
 
2682
  }
 
2683
  return 0;
 
2684
}
 
2685
 
 
2686
unsigned FastEmit_ISD_XOR_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2687
  if (RetVT.SimpleTy != MVT::v2i64)
 
2688
    return 0;
 
2689
  if ((Subtarget->hasSSE1())) {
 
2690
    return FastEmitInst_rr(X86::XORPSrr, X86::VR128RegisterClass, Op0, Op1);
 
2691
  }
 
2692
  if ((Subtarget->hasSSE2())) {
 
2693
    return FastEmitInst_rr(X86::PXORrr, X86::VR128RegisterClass, Op0, Op1);
 
2694
  }
 
2695
  return 0;
 
2696
}
 
2697
 
 
2698
unsigned FastEmit_ISD_XOR_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2699
  switch (VT.SimpleTy) {
 
2700
  case MVT::i8: return FastEmit_ISD_XOR_MVT_i8_rr(RetVT, Op0, Op1);
 
2701
  case MVT::i16: return FastEmit_ISD_XOR_MVT_i16_rr(RetVT, Op0, Op1);
 
2702
  case MVT::i32: return FastEmit_ISD_XOR_MVT_i32_rr(RetVT, Op0, Op1);
 
2703
  case MVT::i64: return FastEmit_ISD_XOR_MVT_i64_rr(RetVT, Op0, Op1);
 
2704
  case MVT::v1i64: return FastEmit_ISD_XOR_MVT_v1i64_rr(RetVT, Op0, Op1);
 
2705
  case MVT::v2i64: return FastEmit_ISD_XOR_MVT_v2i64_rr(RetVT, Op0, Op1);
 
2706
  default: return 0;
 
2707
  }
 
2708
}
 
2709
 
 
2710
// FastEmit functions for X86ISD::ADD.
 
2711
 
 
2712
unsigned FastEmit_X86ISD_ADD_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2713
  if (RetVT.SimpleTy != MVT::i8)
 
2714
    return 0;
 
2715
  return FastEmitInst_rr(X86::ADD8rr, X86::GR8RegisterClass, Op0, Op1);
 
2716
}
 
2717
 
 
2718
unsigned FastEmit_X86ISD_ADD_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2719
  if (RetVT.SimpleTy != MVT::i16)
 
2720
    return 0;
 
2721
  return FastEmitInst_rr(X86::ADD16rr, X86::GR16RegisterClass, Op0, Op1);
 
2722
}
 
2723
 
 
2724
unsigned FastEmit_X86ISD_ADD_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2725
  if (RetVT.SimpleTy != MVT::i32)
 
2726
    return 0;
 
2727
  return FastEmitInst_rr(X86::ADD32rr, X86::GR32RegisterClass, Op0, Op1);
 
2728
}
 
2729
 
 
2730
unsigned FastEmit_X86ISD_ADD_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2731
  if (RetVT.SimpleTy != MVT::i64)
 
2732
    return 0;
 
2733
  return FastEmitInst_rr(X86::ADD64rr, X86::GR64RegisterClass, Op0, Op1);
 
2734
}
 
2735
 
 
2736
unsigned FastEmit_X86ISD_ADD_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2737
  switch (VT.SimpleTy) {
 
2738
  case MVT::i8: return FastEmit_X86ISD_ADD_MVT_i8_rr(RetVT, Op0, Op1);
 
2739
  case MVT::i16: return FastEmit_X86ISD_ADD_MVT_i16_rr(RetVT, Op0, Op1);
 
2740
  case MVT::i32: return FastEmit_X86ISD_ADD_MVT_i32_rr(RetVT, Op0, Op1);
 
2741
  case MVT::i64: return FastEmit_X86ISD_ADD_MVT_i64_rr(RetVT, Op0, Op1);
 
2742
  default: return 0;
 
2743
  }
 
2744
}
 
2745
 
 
2746
// FastEmit functions for X86ISD::AND.
 
2747
 
 
2748
unsigned FastEmit_X86ISD_AND_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2749
  if (RetVT.SimpleTy != MVT::i8)
 
2750
    return 0;
 
2751
  return FastEmitInst_rr(X86::AND8rr, X86::GR8RegisterClass, Op0, Op1);
 
2752
}
 
2753
 
 
2754
unsigned FastEmit_X86ISD_AND_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2755
  if (RetVT.SimpleTy != MVT::i16)
 
2756
    return 0;
 
2757
  return FastEmitInst_rr(X86::AND16rr, X86::GR16RegisterClass, Op0, Op1);
 
2758
}
 
2759
 
 
2760
unsigned FastEmit_X86ISD_AND_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2761
  if (RetVT.SimpleTy != MVT::i32)
 
2762
    return 0;
 
2763
  return FastEmitInst_rr(X86::AND32rr, X86::GR32RegisterClass, Op0, Op1);
 
2764
}
 
2765
 
 
2766
unsigned FastEmit_X86ISD_AND_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2767
  if (RetVT.SimpleTy != MVT::i64)
 
2768
    return 0;
 
2769
  return FastEmitInst_rr(X86::AND64rr, X86::GR64RegisterClass, Op0, Op1);
 
2770
}
 
2771
 
 
2772
unsigned FastEmit_X86ISD_AND_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2773
  switch (VT.SimpleTy) {
 
2774
  case MVT::i8: return FastEmit_X86ISD_AND_MVT_i8_rr(RetVT, Op0, Op1);
 
2775
  case MVT::i16: return FastEmit_X86ISD_AND_MVT_i16_rr(RetVT, Op0, Op1);
 
2776
  case MVT::i32: return FastEmit_X86ISD_AND_MVT_i32_rr(RetVT, Op0, Op1);
 
2777
  case MVT::i64: return FastEmit_X86ISD_AND_MVT_i64_rr(RetVT, Op0, Op1);
 
2778
  default: return 0;
 
2779
  }
 
2780
}
 
2781
 
 
2782
// FastEmit functions for X86ISD::BT.
 
2783
 
 
2784
unsigned FastEmit_X86ISD_BT_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2785
  if (RetVT.SimpleTy != MVT::isVoid)
 
2786
    return 0;
 
2787
  return FastEmitInst_rr(X86::BT16rr, X86::GR16RegisterClass, Op0, Op1);
 
2788
}
 
2789
 
 
2790
unsigned FastEmit_X86ISD_BT_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2791
  if (RetVT.SimpleTy != MVT::isVoid)
 
2792
    return 0;
 
2793
  return FastEmitInst_rr(X86::BT32rr, X86::GR32RegisterClass, Op0, Op1);
 
2794
}
 
2795
 
 
2796
unsigned FastEmit_X86ISD_BT_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2797
  if (RetVT.SimpleTy != MVT::isVoid)
 
2798
    return 0;
 
2799
  return FastEmitInst_rr(X86::BT64rr, X86::GR64RegisterClass, Op0, Op1);
 
2800
}
 
2801
 
 
2802
unsigned FastEmit_X86ISD_BT_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2803
  switch (VT.SimpleTy) {
 
2804
  case MVT::i16: return FastEmit_X86ISD_BT_MVT_i16_rr(RetVT, Op0, Op1);
 
2805
  case MVT::i32: return FastEmit_X86ISD_BT_MVT_i32_rr(RetVT, Op0, Op1);
 
2806
  case MVT::i64: return FastEmit_X86ISD_BT_MVT_i64_rr(RetVT, Op0, Op1);
 
2807
  default: return 0;
 
2808
  }
 
2809
}
 
2810
 
 
2811
// FastEmit functions for X86ISD::CMP.
 
2812
 
 
2813
unsigned FastEmit_X86ISD_CMP_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2814
  if (RetVT.SimpleTy != MVT::isVoid)
 
2815
    return 0;
 
2816
  return FastEmitInst_rr(X86::CMP8rr, X86::GR8RegisterClass, Op0, Op1);
 
2817
}
 
2818
 
 
2819
unsigned FastEmit_X86ISD_CMP_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2820
  if (RetVT.SimpleTy != MVT::isVoid)
 
2821
    return 0;
 
2822
  return FastEmitInst_rr(X86::CMP16rr, X86::GR16RegisterClass, Op0, Op1);
 
2823
}
 
2824
 
 
2825
unsigned FastEmit_X86ISD_CMP_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2826
  if (RetVT.SimpleTy != MVT::isVoid)
 
2827
    return 0;
 
2828
  return FastEmitInst_rr(X86::CMP32rr, X86::GR32RegisterClass, Op0, Op1);
 
2829
}
 
2830
 
 
2831
unsigned FastEmit_X86ISD_CMP_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2832
  if (RetVT.SimpleTy != MVT::isVoid)
 
2833
    return 0;
 
2834
  return FastEmitInst_rr(X86::CMP64rr, X86::GR64RegisterClass, Op0, Op1);
 
2835
}
 
2836
 
 
2837
unsigned FastEmit_X86ISD_CMP_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2838
  if (RetVT.SimpleTy != MVT::isVoid)
 
2839
    return 0;
 
2840
  if ((!Subtarget->hasSSE1())) {
 
2841
    return FastEmitInst_rr(X86::UCOM_FpIr32, X86::RFP32RegisterClass, Op0, Op1);
 
2842
  }
 
2843
  if ((Subtarget->hasSSE1())) {
 
2844
    return FastEmitInst_rr(X86::UCOMISSrr, X86::FR32RegisterClass, Op0, Op1);
 
2845
  }
 
2846
  return 0;
 
2847
}
 
2848
 
 
2849
unsigned FastEmit_X86ISD_CMP_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2850
  if (RetVT.SimpleTy != MVT::isVoid)
 
2851
    return 0;
 
2852
  if ((!Subtarget->hasSSE2())) {
 
2853
    return FastEmitInst_rr(X86::UCOM_FpIr64, X86::RFP64RegisterClass, Op0, Op1);
 
2854
  }
 
2855
  if ((Subtarget->hasSSE2())) {
 
2856
    return FastEmitInst_rr(X86::UCOMISDrr, X86::FR64RegisterClass, Op0, Op1);
 
2857
  }
 
2858
  return 0;
 
2859
}
 
2860
 
 
2861
unsigned FastEmit_X86ISD_CMP_MVT_f80_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2862
  if (RetVT.SimpleTy != MVT::isVoid)
 
2863
    return 0;
 
2864
  return FastEmitInst_rr(X86::UCOM_FpIr80, X86::RFP80RegisterClass, Op0, Op1);
 
2865
}
 
2866
 
 
2867
unsigned FastEmit_X86ISD_CMP_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2868
  switch (VT.SimpleTy) {
 
2869
  case MVT::i8: return FastEmit_X86ISD_CMP_MVT_i8_rr(RetVT, Op0, Op1);
 
2870
  case MVT::i16: return FastEmit_X86ISD_CMP_MVT_i16_rr(RetVT, Op0, Op1);
 
2871
  case MVT::i32: return FastEmit_X86ISD_CMP_MVT_i32_rr(RetVT, Op0, Op1);
 
2872
  case MVT::i64: return FastEmit_X86ISD_CMP_MVT_i64_rr(RetVT, Op0, Op1);
 
2873
  case MVT::f32: return FastEmit_X86ISD_CMP_MVT_f32_rr(RetVT, Op0, Op1);
 
2874
  case MVT::f64: return FastEmit_X86ISD_CMP_MVT_f64_rr(RetVT, Op0, Op1);
 
2875
  case MVT::f80: return FastEmit_X86ISD_CMP_MVT_f80_rr(RetVT, Op0, Op1);
 
2876
  default: return 0;
 
2877
  }
 
2878
}
 
2879
 
 
2880
// FastEmit functions for X86ISD::COMI.
 
2881
 
 
2882
unsigned FastEmit_X86ISD_COMI_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2883
  if (RetVT.SimpleTy != MVT::isVoid)
 
2884
    return 0;
 
2885
  if ((Subtarget->hasSSE1())) {
 
2886
    return FastEmitInst_rr(X86::Int_COMISSrr, X86::VR128RegisterClass, Op0, Op1);
 
2887
  }
 
2888
  return 0;
 
2889
}
 
2890
 
 
2891
unsigned FastEmit_X86ISD_COMI_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2892
  if (RetVT.SimpleTy != MVT::isVoid)
 
2893
    return 0;
 
2894
  if ((Subtarget->hasSSE2())) {
 
2895
    return FastEmitInst_rr(X86::Int_COMISDrr, X86::VR128RegisterClass, Op0, Op1);
 
2896
  }
 
2897
  return 0;
 
2898
}
 
2899
 
 
2900
unsigned FastEmit_X86ISD_COMI_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2901
  switch (VT.SimpleTy) {
 
2902
  case MVT::v4f32: return FastEmit_X86ISD_COMI_MVT_v4f32_rr(RetVT, Op0, Op1);
 
2903
  case MVT::v2f64: return FastEmit_X86ISD_COMI_MVT_v2f64_rr(RetVT, Op0, Op1);
 
2904
  default: return 0;
 
2905
  }
 
2906
}
 
2907
 
 
2908
// FastEmit functions for X86ISD::FAND.
 
2909
 
 
2910
unsigned FastEmit_X86ISD_FAND_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2911
  if (RetVT.SimpleTy != MVT::f32)
 
2912
    return 0;
 
2913
  if ((Subtarget->hasSSE1())) {
 
2914
    return FastEmitInst_rr(X86::FsANDPSrr, X86::FR32RegisterClass, Op0, Op1);
 
2915
  }
 
2916
  return 0;
 
2917
}
 
2918
 
 
2919
unsigned FastEmit_X86ISD_FAND_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2920
  if (RetVT.SimpleTy != MVT::f64)
 
2921
    return 0;
 
2922
  if ((Subtarget->hasSSE2())) {
 
2923
    return FastEmitInst_rr(X86::FsANDPDrr, X86::FR64RegisterClass, Op0, Op1);
 
2924
  }
 
2925
  return 0;
 
2926
}
 
2927
 
 
2928
unsigned FastEmit_X86ISD_FAND_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2929
  switch (VT.SimpleTy) {
 
2930
  case MVT::f32: return FastEmit_X86ISD_FAND_MVT_f32_rr(RetVT, Op0, Op1);
 
2931
  case MVT::f64: return FastEmit_X86ISD_FAND_MVT_f64_rr(RetVT, Op0, Op1);
 
2932
  default: return 0;
 
2933
  }
 
2934
}
 
2935
 
 
2936
// FastEmit functions for X86ISD::FMAX.
 
2937
 
 
2938
unsigned FastEmit_X86ISD_FMAX_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2939
  if (RetVT.SimpleTy != MVT::f32)
 
2940
    return 0;
 
2941
  if ((Subtarget->hasSSE1())) {
 
2942
    return FastEmitInst_rr(X86::MAXSSrr, X86::FR32RegisterClass, Op0, Op1);
 
2943
  }
 
2944
  return 0;
 
2945
}
 
2946
 
 
2947
unsigned FastEmit_X86ISD_FMAX_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2948
  if (RetVT.SimpleTy != MVT::f64)
 
2949
    return 0;
 
2950
  if ((Subtarget->hasSSE2())) {
 
2951
    return FastEmitInst_rr(X86::MAXSDrr, X86::FR64RegisterClass, Op0, Op1);
 
2952
  }
 
2953
  return 0;
 
2954
}
 
2955
 
 
2956
unsigned FastEmit_X86ISD_FMAX_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2957
  if (RetVT.SimpleTy != MVT::v4f32)
 
2958
    return 0;
 
2959
  if ((Subtarget->hasSSE1())) {
 
2960
    return FastEmitInst_rr(X86::MAXPSrr, X86::VR128RegisterClass, Op0, Op1);
 
2961
  }
 
2962
  return 0;
 
2963
}
 
2964
 
 
2965
unsigned FastEmit_X86ISD_FMAX_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2966
  if (RetVT.SimpleTy != MVT::v2f64)
 
2967
    return 0;
 
2968
  if ((Subtarget->hasSSE2())) {
 
2969
    return FastEmitInst_rr(X86::MAXPDrr, X86::VR128RegisterClass, Op0, Op1);
 
2970
  }
 
2971
  return 0;
 
2972
}
 
2973
 
 
2974
unsigned FastEmit_X86ISD_FMAX_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
2975
  switch (VT.SimpleTy) {
 
2976
  case MVT::f32: return FastEmit_X86ISD_FMAX_MVT_f32_rr(RetVT, Op0, Op1);
 
2977
  case MVT::f64: return FastEmit_X86ISD_FMAX_MVT_f64_rr(RetVT, Op0, Op1);
 
2978
  case MVT::v4f32: return FastEmit_X86ISD_FMAX_MVT_v4f32_rr(RetVT, Op0, Op1);
 
2979
  case MVT::v2f64: return FastEmit_X86ISD_FMAX_MVT_v2f64_rr(RetVT, Op0, Op1);
 
2980
  default: return 0;
 
2981
  }
 
2982
}
 
2983
 
 
2984
// FastEmit functions for X86ISD::FMIN.
 
2985
 
 
2986
unsigned FastEmit_X86ISD_FMIN_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2987
  if (RetVT.SimpleTy != MVT::f32)
 
2988
    return 0;
 
2989
  if ((Subtarget->hasSSE1())) {
 
2990
    return FastEmitInst_rr(X86::MINSSrr, X86::FR32RegisterClass, Op0, Op1);
 
2991
  }
 
2992
  return 0;
 
2993
}
 
2994
 
 
2995
unsigned FastEmit_X86ISD_FMIN_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
2996
  if (RetVT.SimpleTy != MVT::f64)
 
2997
    return 0;
 
2998
  if ((Subtarget->hasSSE2())) {
 
2999
    return FastEmitInst_rr(X86::MINSDrr, X86::FR64RegisterClass, Op0, Op1);
 
3000
  }
 
3001
  return 0;
 
3002
}
 
3003
 
 
3004
unsigned FastEmit_X86ISD_FMIN_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3005
  if (RetVT.SimpleTy != MVT::v4f32)
 
3006
    return 0;
 
3007
  if ((Subtarget->hasSSE1())) {
 
3008
    return FastEmitInst_rr(X86::MINPSrr, X86::VR128RegisterClass, Op0, Op1);
 
3009
  }
 
3010
  return 0;
 
3011
}
 
3012
 
 
3013
unsigned FastEmit_X86ISD_FMIN_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3014
  if (RetVT.SimpleTy != MVT::v2f64)
 
3015
    return 0;
 
3016
  if ((Subtarget->hasSSE2())) {
 
3017
    return FastEmitInst_rr(X86::MINPDrr, X86::VR128RegisterClass, Op0, Op1);
 
3018
  }
 
3019
  return 0;
 
3020
}
 
3021
 
 
3022
unsigned FastEmit_X86ISD_FMIN_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3023
  switch (VT.SimpleTy) {
 
3024
  case MVT::f32: return FastEmit_X86ISD_FMIN_MVT_f32_rr(RetVT, Op0, Op1);
 
3025
  case MVT::f64: return FastEmit_X86ISD_FMIN_MVT_f64_rr(RetVT, Op0, Op1);
 
3026
  case MVT::v4f32: return FastEmit_X86ISD_FMIN_MVT_v4f32_rr(RetVT, Op0, Op1);
 
3027
  case MVT::v2f64: return FastEmit_X86ISD_FMIN_MVT_v2f64_rr(RetVT, Op0, Op1);
 
3028
  default: return 0;
 
3029
  }
 
3030
}
 
3031
 
 
3032
// FastEmit functions for X86ISD::FOR.
 
3033
 
 
3034
unsigned FastEmit_X86ISD_FOR_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3035
  if (RetVT.SimpleTy != MVT::f32)
 
3036
    return 0;
 
3037
  if ((Subtarget->hasSSE1())) {
 
3038
    return FastEmitInst_rr(X86::FsORPSrr, X86::FR32RegisterClass, Op0, Op1);
 
3039
  }
 
3040
  return 0;
 
3041
}
 
3042
 
 
3043
unsigned FastEmit_X86ISD_FOR_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3044
  if (RetVT.SimpleTy != MVT::f64)
 
3045
    return 0;
 
3046
  if ((Subtarget->hasSSE2())) {
 
3047
    return FastEmitInst_rr(X86::FsORPDrr, X86::FR64RegisterClass, Op0, Op1);
 
3048
  }
 
3049
  return 0;
 
3050
}
 
3051
 
 
3052
unsigned FastEmit_X86ISD_FOR_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3053
  switch (VT.SimpleTy) {
 
3054
  case MVT::f32: return FastEmit_X86ISD_FOR_MVT_f32_rr(RetVT, Op0, Op1);
 
3055
  case MVT::f64: return FastEmit_X86ISD_FOR_MVT_f64_rr(RetVT, Op0, Op1);
 
3056
  default: return 0;
 
3057
  }
 
3058
}
 
3059
 
 
3060
// FastEmit functions for X86ISD::FXOR.
 
3061
 
 
3062
unsigned FastEmit_X86ISD_FXOR_MVT_f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3063
  if (RetVT.SimpleTy != MVT::f32)
 
3064
    return 0;
 
3065
  if ((Subtarget->hasSSE1())) {
 
3066
    return FastEmitInst_rr(X86::FsXORPSrr, X86::FR32RegisterClass, Op0, Op1);
 
3067
  }
 
3068
  return 0;
 
3069
}
 
3070
 
 
3071
unsigned FastEmit_X86ISD_FXOR_MVT_f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3072
  if (RetVT.SimpleTy != MVT::f64)
 
3073
    return 0;
 
3074
  if ((Subtarget->hasSSE2())) {
 
3075
    return FastEmitInst_rr(X86::FsXORPDrr, X86::FR64RegisterClass, Op0, Op1);
 
3076
  }
 
3077
  return 0;
 
3078
}
 
3079
 
 
3080
unsigned FastEmit_X86ISD_FXOR_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3081
  switch (VT.SimpleTy) {
 
3082
  case MVT::f32: return FastEmit_X86ISD_FXOR_MVT_f32_rr(RetVT, Op0, Op1);
 
3083
  case MVT::f64: return FastEmit_X86ISD_FXOR_MVT_f64_rr(RetVT, Op0, Op1);
 
3084
  default: return 0;
 
3085
  }
 
3086
}
 
3087
 
 
3088
// FastEmit functions for X86ISD::OR.
 
3089
 
 
3090
unsigned FastEmit_X86ISD_OR_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3091
  if (RetVT.SimpleTy != MVT::i8)
 
3092
    return 0;
 
3093
  return FastEmitInst_rr(X86::OR8rr, X86::GR8RegisterClass, Op0, Op1);
 
3094
}
 
3095
 
 
3096
unsigned FastEmit_X86ISD_OR_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3097
  if (RetVT.SimpleTy != MVT::i16)
 
3098
    return 0;
 
3099
  return FastEmitInst_rr(X86::OR16rr, X86::GR16RegisterClass, Op0, Op1);
 
3100
}
 
3101
 
 
3102
unsigned FastEmit_X86ISD_OR_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3103
  if (RetVT.SimpleTy != MVT::i32)
 
3104
    return 0;
 
3105
  return FastEmitInst_rr(X86::OR32rr, X86::GR32RegisterClass, Op0, Op1);
 
3106
}
 
3107
 
 
3108
unsigned FastEmit_X86ISD_OR_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3109
  if (RetVT.SimpleTy != MVT::i64)
 
3110
    return 0;
 
3111
  return FastEmitInst_rr(X86::OR64rr, X86::GR64RegisterClass, Op0, Op1);
 
3112
}
 
3113
 
 
3114
unsigned FastEmit_X86ISD_OR_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3115
  switch (VT.SimpleTy) {
 
3116
  case MVT::i8: return FastEmit_X86ISD_OR_MVT_i8_rr(RetVT, Op0, Op1);
 
3117
  case MVT::i16: return FastEmit_X86ISD_OR_MVT_i16_rr(RetVT, Op0, Op1);
 
3118
  case MVT::i32: return FastEmit_X86ISD_OR_MVT_i32_rr(RetVT, Op0, Op1);
 
3119
  case MVT::i64: return FastEmit_X86ISD_OR_MVT_i64_rr(RetVT, Op0, Op1);
 
3120
  default: return 0;
 
3121
  }
 
3122
}
 
3123
 
 
3124
// FastEmit functions for X86ISD::PCMPEQB.
 
3125
 
 
3126
unsigned FastEmit_X86ISD_PCMPEQB_MVT_v8i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3127
  if (RetVT.SimpleTy != MVT::v8i8)
 
3128
    return 0;
 
3129
  return FastEmitInst_rr(X86::MMX_PCMPEQBrr, X86::VR64RegisterClass, Op0, Op1);
 
3130
}
 
3131
 
 
3132
unsigned FastEmit_X86ISD_PCMPEQB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3133
  if (RetVT.SimpleTy != MVT::v16i8)
 
3134
    return 0;
 
3135
  return FastEmitInst_rr(X86::PCMPEQBrr, X86::VR128RegisterClass, Op0, Op1);
 
3136
}
 
3137
 
 
3138
unsigned FastEmit_X86ISD_PCMPEQB_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3139
  switch (VT.SimpleTy) {
 
3140
  case MVT::v8i8: return FastEmit_X86ISD_PCMPEQB_MVT_v8i8_rr(RetVT, Op0, Op1);
 
3141
  case MVT::v16i8: return FastEmit_X86ISD_PCMPEQB_MVT_v16i8_rr(RetVT, Op0, Op1);
 
3142
  default: return 0;
 
3143
  }
 
3144
}
 
3145
 
 
3146
// FastEmit functions for X86ISD::PCMPEQD.
 
3147
 
 
3148
unsigned FastEmit_X86ISD_PCMPEQD_MVT_v2i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3149
  if (RetVT.SimpleTy != MVT::v2i32)
 
3150
    return 0;
 
3151
  return FastEmitInst_rr(X86::MMX_PCMPEQDrr, X86::VR64RegisterClass, Op0, Op1);
 
3152
}
 
3153
 
 
3154
unsigned FastEmit_X86ISD_PCMPEQD_MVT_v4i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3155
  if (RetVT.SimpleTy != MVT::v4i32)
 
3156
    return 0;
 
3157
  return FastEmitInst_rr(X86::PCMPEQDrr, X86::VR128RegisterClass, Op0, Op1);
 
3158
}
 
3159
 
 
3160
unsigned FastEmit_X86ISD_PCMPEQD_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3161
  switch (VT.SimpleTy) {
 
3162
  case MVT::v2i32: return FastEmit_X86ISD_PCMPEQD_MVT_v2i32_rr(RetVT, Op0, Op1);
 
3163
  case MVT::v4i32: return FastEmit_X86ISD_PCMPEQD_MVT_v4i32_rr(RetVT, Op0, Op1);
 
3164
  default: return 0;
 
3165
  }
 
3166
}
 
3167
 
 
3168
// FastEmit functions for X86ISD::PCMPEQQ.
 
3169
 
 
3170
unsigned FastEmit_X86ISD_PCMPEQQ_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3171
  if (RetVT.SimpleTy != MVT::v2i64)
 
3172
    return 0;
 
3173
  return FastEmitInst_rr(X86::PCMPEQQrr, X86::VR128RegisterClass, Op0, Op1);
 
3174
}
 
3175
 
 
3176
unsigned FastEmit_X86ISD_PCMPEQQ_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3177
  switch (VT.SimpleTy) {
 
3178
  case MVT::v2i64: return FastEmit_X86ISD_PCMPEQQ_MVT_v2i64_rr(RetVT, Op0, Op1);
 
3179
  default: return 0;
 
3180
  }
 
3181
}
 
3182
 
 
3183
// FastEmit functions for X86ISD::PCMPEQW.
 
3184
 
 
3185
unsigned FastEmit_X86ISD_PCMPEQW_MVT_v4i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3186
  if (RetVT.SimpleTy != MVT::v4i16)
 
3187
    return 0;
 
3188
  return FastEmitInst_rr(X86::MMX_PCMPEQWrr, X86::VR64RegisterClass, Op0, Op1);
 
3189
}
 
3190
 
 
3191
unsigned FastEmit_X86ISD_PCMPEQW_MVT_v8i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3192
  if (RetVT.SimpleTy != MVT::v8i16)
 
3193
    return 0;
 
3194
  return FastEmitInst_rr(X86::PCMPEQWrr, X86::VR128RegisterClass, Op0, Op1);
 
3195
}
 
3196
 
 
3197
unsigned FastEmit_X86ISD_PCMPEQW_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3198
  switch (VT.SimpleTy) {
 
3199
  case MVT::v4i16: return FastEmit_X86ISD_PCMPEQW_MVT_v4i16_rr(RetVT, Op0, Op1);
 
3200
  case MVT::v8i16: return FastEmit_X86ISD_PCMPEQW_MVT_v8i16_rr(RetVT, Op0, Op1);
 
3201
  default: return 0;
 
3202
  }
 
3203
}
 
3204
 
 
3205
// FastEmit functions for X86ISD::PCMPGTB.
 
3206
 
 
3207
unsigned FastEmit_X86ISD_PCMPGTB_MVT_v8i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3208
  if (RetVT.SimpleTy != MVT::v8i8)
 
3209
    return 0;
 
3210
  return FastEmitInst_rr(X86::MMX_PCMPGTBrr, X86::VR64RegisterClass, Op0, Op1);
 
3211
}
 
3212
 
 
3213
unsigned FastEmit_X86ISD_PCMPGTB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3214
  if (RetVT.SimpleTy != MVT::v16i8)
 
3215
    return 0;
 
3216
  return FastEmitInst_rr(X86::PCMPGTBrr, X86::VR128RegisterClass, Op0, Op1);
 
3217
}
 
3218
 
 
3219
unsigned FastEmit_X86ISD_PCMPGTB_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3220
  switch (VT.SimpleTy) {
 
3221
  case MVT::v8i8: return FastEmit_X86ISD_PCMPGTB_MVT_v8i8_rr(RetVT, Op0, Op1);
 
3222
  case MVT::v16i8: return FastEmit_X86ISD_PCMPGTB_MVT_v16i8_rr(RetVT, Op0, Op1);
 
3223
  default: return 0;
 
3224
  }
 
3225
}
 
3226
 
 
3227
// FastEmit functions for X86ISD::PCMPGTD.
 
3228
 
 
3229
unsigned FastEmit_X86ISD_PCMPGTD_MVT_v2i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3230
  if (RetVT.SimpleTy != MVT::v2i32)
 
3231
    return 0;
 
3232
  return FastEmitInst_rr(X86::MMX_PCMPGTDrr, X86::VR64RegisterClass, Op0, Op1);
 
3233
}
 
3234
 
 
3235
unsigned FastEmit_X86ISD_PCMPGTD_MVT_v4i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3236
  if (RetVT.SimpleTy != MVT::v4i32)
 
3237
    return 0;
 
3238
  return FastEmitInst_rr(X86::PCMPGTDrr, X86::VR128RegisterClass, Op0, Op1);
 
3239
}
 
3240
 
 
3241
unsigned FastEmit_X86ISD_PCMPGTD_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3242
  switch (VT.SimpleTy) {
 
3243
  case MVT::v2i32: return FastEmit_X86ISD_PCMPGTD_MVT_v2i32_rr(RetVT, Op0, Op1);
 
3244
  case MVT::v4i32: return FastEmit_X86ISD_PCMPGTD_MVT_v4i32_rr(RetVT, Op0, Op1);
 
3245
  default: return 0;
 
3246
  }
 
3247
}
 
3248
 
 
3249
// FastEmit functions for X86ISD::PCMPGTQ.
 
3250
 
 
3251
unsigned FastEmit_X86ISD_PCMPGTQ_MVT_v2i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3252
  if (RetVT.SimpleTy != MVT::v2i64)
 
3253
    return 0;
 
3254
  return FastEmitInst_rr(X86::PCMPGTQrr, X86::VR128RegisterClass, Op0, Op1);
 
3255
}
 
3256
 
 
3257
unsigned FastEmit_X86ISD_PCMPGTQ_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3258
  switch (VT.SimpleTy) {
 
3259
  case MVT::v2i64: return FastEmit_X86ISD_PCMPGTQ_MVT_v2i64_rr(RetVT, Op0, Op1);
 
3260
  default: return 0;
 
3261
  }
 
3262
}
 
3263
 
 
3264
// FastEmit functions for X86ISD::PCMPGTW.
 
3265
 
 
3266
unsigned FastEmit_X86ISD_PCMPGTW_MVT_v4i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3267
  if (RetVT.SimpleTy != MVT::v4i16)
 
3268
    return 0;
 
3269
  return FastEmitInst_rr(X86::MMX_PCMPGTWrr, X86::VR64RegisterClass, Op0, Op1);
 
3270
}
 
3271
 
 
3272
unsigned FastEmit_X86ISD_PCMPGTW_MVT_v8i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3273
  if (RetVT.SimpleTy != MVT::v8i16)
 
3274
    return 0;
 
3275
  return FastEmitInst_rr(X86::PCMPGTWrr, X86::VR128RegisterClass, Op0, Op1);
 
3276
}
 
3277
 
 
3278
unsigned FastEmit_X86ISD_PCMPGTW_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3279
  switch (VT.SimpleTy) {
 
3280
  case MVT::v4i16: return FastEmit_X86ISD_PCMPGTW_MVT_v4i16_rr(RetVT, Op0, Op1);
 
3281
  case MVT::v8i16: return FastEmit_X86ISD_PCMPGTW_MVT_v8i16_rr(RetVT, Op0, Op1);
 
3282
  default: return 0;
 
3283
  }
 
3284
}
 
3285
 
 
3286
// FastEmit functions for X86ISD::PSHUFB.
 
3287
 
 
3288
unsigned FastEmit_X86ISD_PSHUFB_MVT_v16i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3289
  if (RetVT.SimpleTy != MVT::v16i8)
 
3290
    return 0;
 
3291
  if ((Subtarget->hasSSSE3())) {
 
3292
    return FastEmitInst_rr(X86::PSHUFBrr128, X86::VR128RegisterClass, Op0, Op1);
 
3293
  }
 
3294
  return 0;
 
3295
}
 
3296
 
 
3297
unsigned FastEmit_X86ISD_PSHUFB_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3298
  switch (VT.SimpleTy) {
 
3299
  case MVT::v16i8: return FastEmit_X86ISD_PSHUFB_MVT_v16i8_rr(RetVT, Op0, Op1);
 
3300
  default: return 0;
 
3301
  }
 
3302
}
 
3303
 
 
3304
// FastEmit functions for X86ISD::PTEST.
 
3305
 
 
3306
unsigned FastEmit_X86ISD_PTEST_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3307
  if (RetVT.SimpleTy != MVT::isVoid)
 
3308
    return 0;
 
3309
  if ((Subtarget->hasSSE41())) {
 
3310
    return FastEmitInst_rr(X86::PTESTrr, X86::VR128RegisterClass, Op0, Op1);
 
3311
  }
 
3312
  return 0;
 
3313
}
 
3314
 
 
3315
unsigned FastEmit_X86ISD_PTEST_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3316
  switch (VT.SimpleTy) {
 
3317
  case MVT::v4f32: return FastEmit_X86ISD_PTEST_MVT_v4f32_rr(RetVT, Op0, Op1);
 
3318
  default: return 0;
 
3319
  }
 
3320
}
 
3321
 
 
3322
// FastEmit functions for X86ISD::SMUL.
 
3323
 
 
3324
unsigned FastEmit_X86ISD_SMUL_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3325
  if (RetVT.SimpleTy != MVT::i16)
 
3326
    return 0;
 
3327
  return FastEmitInst_rr(X86::IMUL16rr, X86::GR16RegisterClass, Op0, Op1);
 
3328
}
 
3329
 
 
3330
unsigned FastEmit_X86ISD_SMUL_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3331
  if (RetVT.SimpleTy != MVT::i32)
 
3332
    return 0;
 
3333
  return FastEmitInst_rr(X86::IMUL32rr, X86::GR32RegisterClass, Op0, Op1);
 
3334
}
 
3335
 
 
3336
unsigned FastEmit_X86ISD_SMUL_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3337
  if (RetVT.SimpleTy != MVT::i64)
 
3338
    return 0;
 
3339
  return FastEmitInst_rr(X86::IMUL64rr, X86::GR64RegisterClass, Op0, Op1);
 
3340
}
 
3341
 
 
3342
unsigned FastEmit_X86ISD_SMUL_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3343
  switch (VT.SimpleTy) {
 
3344
  case MVT::i16: return FastEmit_X86ISD_SMUL_MVT_i16_rr(RetVT, Op0, Op1);
 
3345
  case MVT::i32: return FastEmit_X86ISD_SMUL_MVT_i32_rr(RetVT, Op0, Op1);
 
3346
  case MVT::i64: return FastEmit_X86ISD_SMUL_MVT_i64_rr(RetVT, Op0, Op1);
 
3347
  default: return 0;
 
3348
  }
 
3349
}
 
3350
 
 
3351
// FastEmit functions for X86ISD::SUB.
 
3352
 
 
3353
unsigned FastEmit_X86ISD_SUB_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3354
  if (RetVT.SimpleTy != MVT::i8)
 
3355
    return 0;
 
3356
  return FastEmitInst_rr(X86::SUB8rr, X86::GR8RegisterClass, Op0, Op1);
 
3357
}
 
3358
 
 
3359
unsigned FastEmit_X86ISD_SUB_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3360
  if (RetVT.SimpleTy != MVT::i16)
 
3361
    return 0;
 
3362
  return FastEmitInst_rr(X86::SUB16rr, X86::GR16RegisterClass, Op0, Op1);
 
3363
}
 
3364
 
 
3365
unsigned FastEmit_X86ISD_SUB_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3366
  if (RetVT.SimpleTy != MVT::i32)
 
3367
    return 0;
 
3368
  return FastEmitInst_rr(X86::SUB32rr, X86::GR32RegisterClass, Op0, Op1);
 
3369
}
 
3370
 
 
3371
unsigned FastEmit_X86ISD_SUB_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3372
  if (RetVT.SimpleTy != MVT::i64)
 
3373
    return 0;
 
3374
  return FastEmitInst_rr(X86::SUB64rr, X86::GR64RegisterClass, Op0, Op1);
 
3375
}
 
3376
 
 
3377
unsigned FastEmit_X86ISD_SUB_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3378
  switch (VT.SimpleTy) {
 
3379
  case MVT::i8: return FastEmit_X86ISD_SUB_MVT_i8_rr(RetVT, Op0, Op1);
 
3380
  case MVT::i16: return FastEmit_X86ISD_SUB_MVT_i16_rr(RetVT, Op0, Op1);
 
3381
  case MVT::i32: return FastEmit_X86ISD_SUB_MVT_i32_rr(RetVT, Op0, Op1);
 
3382
  case MVT::i64: return FastEmit_X86ISD_SUB_MVT_i64_rr(RetVT, Op0, Op1);
 
3383
  default: return 0;
 
3384
  }
 
3385
}
 
3386
 
 
3387
// FastEmit functions for X86ISD::UCOMI.
 
3388
 
 
3389
unsigned FastEmit_X86ISD_UCOMI_MVT_v4f32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3390
  if (RetVT.SimpleTy != MVT::isVoid)
 
3391
    return 0;
 
3392
  if ((Subtarget->hasSSE1())) {
 
3393
    return FastEmitInst_rr(X86::Int_UCOMISSrr, X86::VR128RegisterClass, Op0, Op1);
 
3394
  }
 
3395
  return 0;
 
3396
}
 
3397
 
 
3398
unsigned FastEmit_X86ISD_UCOMI_MVT_v2f64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3399
  if (RetVT.SimpleTy != MVT::isVoid)
 
3400
    return 0;
 
3401
  if ((Subtarget->hasSSE2())) {
 
3402
    return FastEmitInst_rr(X86::Int_UCOMISDrr, X86::VR128RegisterClass, Op0, Op1);
 
3403
  }
 
3404
  return 0;
 
3405
}
 
3406
 
 
3407
unsigned FastEmit_X86ISD_UCOMI_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3408
  switch (VT.SimpleTy) {
 
3409
  case MVT::v4f32: return FastEmit_X86ISD_UCOMI_MVT_v4f32_rr(RetVT, Op0, Op1);
 
3410
  case MVT::v2f64: return FastEmit_X86ISD_UCOMI_MVT_v2f64_rr(RetVT, Op0, Op1);
 
3411
  default: return 0;
 
3412
  }
 
3413
}
 
3414
 
 
3415
// FastEmit functions for X86ISD::XOR.
 
3416
 
 
3417
unsigned FastEmit_X86ISD_XOR_MVT_i8_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3418
  if (RetVT.SimpleTy != MVT::i8)
 
3419
    return 0;
 
3420
  return FastEmitInst_rr(X86::XOR8rr, X86::GR8RegisterClass, Op0, Op1);
 
3421
}
 
3422
 
 
3423
unsigned FastEmit_X86ISD_XOR_MVT_i16_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3424
  if (RetVT.SimpleTy != MVT::i16)
 
3425
    return 0;
 
3426
  return FastEmitInst_rr(X86::XOR16rr, X86::GR16RegisterClass, Op0, Op1);
 
3427
}
 
3428
 
 
3429
unsigned FastEmit_X86ISD_XOR_MVT_i32_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3430
  if (RetVT.SimpleTy != MVT::i32)
 
3431
    return 0;
 
3432
  return FastEmitInst_rr(X86::XOR32rr, X86::GR32RegisterClass, Op0, Op1);
 
3433
}
 
3434
 
 
3435
unsigned FastEmit_X86ISD_XOR_MVT_i64_rr(MVT RetVT, unsigned Op0, unsigned Op1) {
 
3436
  if (RetVT.SimpleTy != MVT::i64)
 
3437
    return 0;
 
3438
  return FastEmitInst_rr(X86::XOR64rr, X86::GR64RegisterClass, Op0, Op1);
 
3439
}
 
3440
 
 
3441
unsigned FastEmit_X86ISD_XOR_rr(MVT VT, MVT RetVT, unsigned Op0, unsigned Op1) {
 
3442
  switch (VT.SimpleTy) {
 
3443
  case MVT::i8: return FastEmit_X86ISD_XOR_MVT_i8_rr(RetVT, Op0, Op1);
 
3444
  case MVT::i16: return FastEmit_X86ISD_XOR_MVT_i16_rr(RetVT, Op0, Op1);
 
3445
  case MVT::i32: return FastEmit_X86ISD_XOR_MVT_i32_rr(RetVT, Op0, Op1);
 
3446
  case MVT::i64: return FastEmit_X86ISD_XOR_MVT_i64_rr(RetVT, Op0, Op1);
 
3447
  default: return 0;
 
3448
  }
 
3449
}
 
3450
 
 
3451
// Top-level FastEmit function.
 
3452
 
 
3453
unsigned FastEmit_rr(MVT VT, MVT RetVT, unsigned Opcode, unsigned Op0, unsigned Op1) {
 
3454
  switch (Opcode) {
 
3455
  case ISD::ADD: return FastEmit_ISD_ADD_rr(VT, RetVT, Op0, Op1);
 
3456
  case ISD::ADDC: return FastEmit_ISD_ADDC_rr(VT, RetVT, Op0, Op1);
 
3457
  case ISD::ADDE: return FastEmit_ISD_ADDE_rr(VT, RetVT, Op0, Op1);
 
3458
  case ISD::AND: return FastEmit_ISD_AND_rr(VT, RetVT, Op0, Op1);
 
3459
  case ISD::FADD: return FastEmit_ISD_FADD_rr(VT, RetVT, Op0, Op1);
 
3460
  case ISD::FDIV: return FastEmit_ISD_FDIV_rr(VT, RetVT, Op0, Op1);
 
3461
  case ISD::FMUL: return FastEmit_ISD_FMUL_rr(VT, RetVT, Op0, Op1);
 
3462
  case ISD::FSUB: return FastEmit_ISD_FSUB_rr(VT, RetVT, Op0, Op1);
 
3463
  case ISD::MUL: return FastEmit_ISD_MUL_rr(VT, RetVT, Op0, Op1);
 
3464
  case ISD::OR: return FastEmit_ISD_OR_rr(VT, RetVT, Op0, Op1);
 
3465
  case ISD::SUB: return FastEmit_ISD_SUB_rr(VT, RetVT, Op0, Op1);
 
3466
  case ISD::SUBC: return FastEmit_ISD_SUBC_rr(VT, RetVT, Op0, Op1);
 
3467
  case ISD::SUBE: return FastEmit_ISD_SUBE_rr(VT, RetVT, Op0, Op1);
 
3468
  case ISD::XOR: return FastEmit_ISD_XOR_rr(VT, RetVT, Op0, Op1);
 
3469
  case X86ISD::ADD: return FastEmit_X86ISD_ADD_rr(VT, RetVT, Op0, Op1);
 
3470
  case X86ISD::AND: return FastEmit_X86ISD_AND_rr(VT, RetVT, Op0, Op1);
 
3471
  case X86ISD::BT: return FastEmit_X86ISD_BT_rr(VT, RetVT, Op0, Op1);
 
3472
  case X86ISD::CMP: return FastEmit_X86ISD_CMP_rr(VT, RetVT, Op0, Op1);
 
3473
  case X86ISD::COMI: return FastEmit_X86ISD_COMI_rr(VT, RetVT, Op0, Op1);
 
3474
  case X86ISD::FAND: return FastEmit_X86ISD_FAND_rr(VT, RetVT, Op0, Op1);
 
3475
  case X86ISD::FMAX: return FastEmit_X86ISD_FMAX_rr(VT, RetVT, Op0, Op1);
 
3476
  case X86ISD::FMIN: return FastEmit_X86ISD_FMIN_rr(VT, RetVT, Op0, Op1);
 
3477
  case X86ISD::FOR: return FastEmit_X86ISD_FOR_rr(VT, RetVT, Op0, Op1);
 
3478
  case X86ISD::FXOR: return FastEmit_X86ISD_FXOR_rr(VT, RetVT, Op0, Op1);
 
3479
  case X86ISD::OR: return FastEmit_X86ISD_OR_rr(VT, RetVT, Op0, Op1);
 
3480
  case X86ISD::PCMPEQB: return FastEmit_X86ISD_PCMPEQB_rr(VT, RetVT, Op0, Op1);
 
3481
  case X86ISD::PCMPEQD: return FastEmit_X86ISD_PCMPEQD_rr(VT, RetVT, Op0, Op1);
 
3482
  case X86ISD::PCMPEQQ: return FastEmit_X86ISD_PCMPEQQ_rr(VT, RetVT, Op0, Op1);
 
3483
  case X86ISD::PCMPEQW: return FastEmit_X86ISD_PCMPEQW_rr(VT, RetVT, Op0, Op1);
 
3484
  case X86ISD::PCMPGTB: return FastEmit_X86ISD_PCMPGTB_rr(VT, RetVT, Op0, Op1);
 
3485
  case X86ISD::PCMPGTD: return FastEmit_X86ISD_PCMPGTD_rr(VT, RetVT, Op0, Op1);
 
3486
  case X86ISD::PCMPGTQ: return FastEmit_X86ISD_PCMPGTQ_rr(VT, RetVT, Op0, Op1);
 
3487
  case X86ISD::PCMPGTW: return FastEmit_X86ISD_PCMPGTW_rr(VT, RetVT, Op0, Op1);
 
3488
  case X86ISD::PSHUFB: return FastEmit_X86ISD_PSHUFB_rr(VT, RetVT, Op0, Op1);
 
3489
  case X86ISD::PTEST: return FastEmit_X86ISD_PTEST_rr(VT, RetVT, Op0, Op1);
 
3490
  case X86ISD::SMUL: return FastEmit_X86ISD_SMUL_rr(VT, RetVT, Op0, Op1);
 
3491
  case X86ISD::SUB: return FastEmit_X86ISD_SUB_rr(VT, RetVT, Op0, Op1);
 
3492
  case X86ISD::UCOMI: return FastEmit_X86ISD_UCOMI_rr(VT, RetVT, Op0, Op1);
 
3493
  case X86ISD::XOR: return FastEmit_X86ISD_XOR_rr(VT, RetVT, Op0, Op1);
 
3494
  default: return 0;
 
3495
  }
 
3496
}
 
3497