← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/PPCGenDAGISel.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++/PPCGenDAGISel.inc
 
1
//===- TableGen'erated file -------------------------------------*- C++ -*-===//
 
2
//
 
3
// DAG Instruction Selector for the PPC target
 
4
//
 
5
// Automatically generated file, do not edit!
 
6
//
 
7
//===----------------------------------------------------------------------===//
 
8
 
 
9
// *** NOTE: This file is #included into the middle of the target
 
10
// *** instruction selector class.  These functions are really methods.
 
11
 
 
12
 
 
13
// Predicate functions.
 
14
inline bool Predicate_V_immneg0(SDNode *N) const {
 
15
 
 
16
  return PPC::isAllNegativeZeroVector(N);
 
17
 
 
18
}
 
19
inline bool Predicate_atomic_cmp_swap_16(SDNode *N) const {
 
20
 
 
21
  return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
22
 
 
23
}
 
24
inline bool Predicate_atomic_cmp_swap_32(SDNode *N) const {
 
25
 
 
26
  return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
27
 
 
28
}
 
29
inline bool Predicate_atomic_cmp_swap_64(SDNode *N) const {
 
30
 
 
31
  return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
32
 
 
33
}
 
34
inline bool Predicate_atomic_cmp_swap_8(SDNode *N) const {
 
35
 
 
36
  return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
37
 
 
38
}
 
39
inline bool Predicate_atomic_load_add_16(SDNode *N) const {
 
40
 
 
41
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
42
  
 
43
}
 
44
inline bool Predicate_atomic_load_add_32(SDNode *N) const {
 
45
 
 
46
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
47
  
 
48
}
 
49
inline bool Predicate_atomic_load_add_64(SDNode *N) const {
 
50
 
 
51
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
52
  
 
53
}
 
54
inline bool Predicate_atomic_load_add_8(SDNode *N) const {
 
55
 
 
56
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
57
  
 
58
}
 
59
inline bool Predicate_atomic_load_and_16(SDNode *N) const {
 
60
 
 
61
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
62
  
 
63
}
 
64
inline bool Predicate_atomic_load_and_32(SDNode *N) const {
 
65
 
 
66
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
67
  
 
68
}
 
69
inline bool Predicate_atomic_load_and_64(SDNode *N) const {
 
70
 
 
71
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
72
  
 
73
}
 
74
inline bool Predicate_atomic_load_and_8(SDNode *N) const {
 
75
 
 
76
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
77
  
 
78
}
 
79
inline bool Predicate_atomic_load_max_16(SDNode *N) const {
 
80
 
 
81
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
82
  
 
83
}
 
84
inline bool Predicate_atomic_load_max_32(SDNode *N) const {
 
85
 
 
86
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
87
  
 
88
}
 
89
inline bool Predicate_atomic_load_max_64(SDNode *N) const {
 
90
 
 
91
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
92
  
 
93
}
 
94
inline bool Predicate_atomic_load_max_8(SDNode *N) const {
 
95
 
 
96
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
97
  
 
98
}
 
99
inline bool Predicate_atomic_load_min_16(SDNode *N) const {
 
100
 
 
101
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
102
  
 
103
}
 
104
inline bool Predicate_atomic_load_min_32(SDNode *N) const {
 
105
 
 
106
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
107
  
 
108
}
 
109
inline bool Predicate_atomic_load_min_64(SDNode *N) const {
 
110
 
 
111
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
112
  
 
113
}
 
114
inline bool Predicate_atomic_load_min_8(SDNode *N) const {
 
115
 
 
116
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
117
  
 
118
}
 
119
inline bool Predicate_atomic_load_nand_16(SDNode *N) const {
 
120
 
 
121
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
122
  
 
123
}
 
124
inline bool Predicate_atomic_load_nand_32(SDNode *N) const {
 
125
 
 
126
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
127
  
 
128
}
 
129
inline bool Predicate_atomic_load_nand_64(SDNode *N) const {
 
130
 
 
131
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
132
  
 
133
}
 
134
inline bool Predicate_atomic_load_nand_8(SDNode *N) const {
 
135
 
 
136
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
137
  
 
138
}
 
139
inline bool Predicate_atomic_load_or_16(SDNode *N) const {
 
140
 
 
141
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
142
  
 
143
}
 
144
inline bool Predicate_atomic_load_or_32(SDNode *N) const {
 
145
 
 
146
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
147
  
 
148
}
 
149
inline bool Predicate_atomic_load_or_64(SDNode *N) const {
 
150
 
 
151
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
152
  
 
153
}
 
154
inline bool Predicate_atomic_load_or_8(SDNode *N) const {
 
155
 
 
156
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
157
  
 
158
}
 
159
inline bool Predicate_atomic_load_sub_16(SDNode *N) const {
 
160
 
 
161
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
162
  
 
163
}
 
164
inline bool Predicate_atomic_load_sub_32(SDNode *N) const {
 
165
 
 
166
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
167
  
 
168
}
 
169
inline bool Predicate_atomic_load_sub_64(SDNode *N) const {
 
170
 
 
171
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
172
  
 
173
}
 
174
inline bool Predicate_atomic_load_sub_8(SDNode *N) const {
 
175
 
 
176
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
177
  
 
178
}
 
179
inline bool Predicate_atomic_load_umax_16(SDNode *N) const {
 
180
 
 
181
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
182
  
 
183
}
 
184
inline bool Predicate_atomic_load_umax_32(SDNode *N) const {
 
185
 
 
186
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
187
  
 
188
}
 
189
inline bool Predicate_atomic_load_umax_64(SDNode *N) const {
 
190
 
 
191
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
192
  
 
193
}
 
194
inline bool Predicate_atomic_load_umax_8(SDNode *N) const {
 
195
 
 
196
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
197
  
 
198
}
 
199
inline bool Predicate_atomic_load_umin_16(SDNode *N) const {
 
200
 
 
201
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
202
  
 
203
}
 
204
inline bool Predicate_atomic_load_umin_32(SDNode *N) const {
 
205
 
 
206
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
207
  
 
208
}
 
209
inline bool Predicate_atomic_load_umin_64(SDNode *N) const {
 
210
 
 
211
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
212
  
 
213
}
 
214
inline bool Predicate_atomic_load_umin_8(SDNode *N) const {
 
215
 
 
216
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
217
  
 
218
}
 
219
inline bool Predicate_atomic_load_xor_16(SDNode *N) const {
 
220
 
 
221
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
222
  
 
223
}
 
224
inline bool Predicate_atomic_load_xor_32(SDNode *N) const {
 
225
 
 
226
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
227
  
 
228
}
 
229
inline bool Predicate_atomic_load_xor_64(SDNode *N) const {
 
230
 
 
231
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
232
  
 
233
}
 
234
inline bool Predicate_atomic_load_xor_8(SDNode *N) const {
 
235
 
 
236
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
237
  
 
238
}
 
239
inline bool Predicate_atomic_swap_16(SDNode *N) const {
 
240
 
 
241
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
242
  
 
243
}
 
244
inline bool Predicate_atomic_swap_32(SDNode *N) const {
 
245
 
 
246
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
247
  
 
248
}
 
249
inline bool Predicate_atomic_swap_64(SDNode *N) const {
 
250
 
 
251
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
252
  
 
253
}
 
254
inline bool Predicate_atomic_swap_8(SDNode *N) const {
 
255
 
 
256
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
257
  
 
258
}
 
259
inline bool Predicate_cvtff(SDNode *N) const {
 
260
 
 
261
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_FF;
 
262
    
 
263
}
 
264
inline bool Predicate_cvtfs(SDNode *N) const {
 
265
 
 
266
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_FS;
 
267
    
 
268
}
 
269
inline bool Predicate_cvtfu(SDNode *N) const {
 
270
 
 
271
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_FU;
 
272
    
 
273
}
 
274
inline bool Predicate_cvtsf(SDNode *N) const {
 
275
 
 
276
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_SF;
 
277
    
 
278
}
 
279
inline bool Predicate_cvtss(SDNode *N) const {
 
280
 
 
281
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_SS;
 
282
    
 
283
}
 
284
inline bool Predicate_cvtsu(SDNode *N) const {
 
285
 
 
286
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_SU;
 
287
    
 
288
}
 
289
inline bool Predicate_cvtuf(SDNode *N) const {
 
290
 
 
291
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_UF;
 
292
    
 
293
}
 
294
inline bool Predicate_cvtus(SDNode *N) const {
 
295
 
 
296
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_US;
 
297
    
 
298
}
 
299
inline bool Predicate_cvtuu(SDNode *N) const {
 
300
 
 
301
       return cast<CvtRndSatSDNode>(N)->getCvtCode() == ISD::CVT_UU;
 
302
    
 
303
}
 
304
inline bool Predicate_extload(SDNode *N) const {
 
305
 
 
306
  return cast<LoadSDNode>(N)->getExtensionType() == ISD::EXTLOAD;
 
307
 
 
308
}
 
309
inline bool Predicate_extloadf32(SDNode *N) const {
 
310
 
 
311
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::f32;
 
312
 
 
313
}
 
314
inline bool Predicate_extloadf64(SDNode *N) const {
 
315
 
 
316
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::f64;
 
317
 
 
318
}
 
319
inline bool Predicate_extloadi1(SDNode *N) const {
 
320
 
 
321
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i1;
 
322
 
 
323
}
 
324
inline bool Predicate_extloadi16(SDNode *N) const {
 
325
 
 
326
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i16;
 
327
 
 
328
}
 
329
inline bool Predicate_extloadi32(SDNode *N) const {
 
330
 
 
331
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i32;
 
332
 
 
333
}
 
334
inline bool Predicate_extloadi8(SDNode *N) const {
 
335
 
 
336
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i8;
 
337
 
 
338
}
 
339
inline bool Predicate_imm16ShiftedSExt(SDNode *inN) const {
 
340
  ConstantSDNode *N = cast<ConstantSDNode>(inN);
 
341
 
 
342
  // imm16ShiftedSExt predicate - True if only bits in the top 16-bits of the
 
343
  // immediate are set.  Used by instructions like 'addis'.  Identical to 
 
344
  // imm16ShiftedZExt in 32-bit mode.
 
345
  if (N->getZExtValue() & 0xFFFF) return false;
 
346
  if (N->getValueType(0) == MVT::i32)
 
347
    return true;
 
348
  // For 64-bit, make sure it is sext right.
 
349
  return N->getZExtValue() == (uint64_t)(int)N->getZExtValue();
 
350
 
 
351
}
 
352
inline bool Predicate_imm16ShiftedZExt(SDNode *inN) const {
 
353
  ConstantSDNode *N = cast<ConstantSDNode>(inN);
 
354
 
 
355
  // imm16ShiftedZExt predicate - True if only bits in the top 16-bits of the
 
356
  // immediate are set.  Used by instructions like 'xoris'.
 
357
  return (N->getZExtValue() & ~uint64_t(0xFFFF0000)) == 0;
 
358
 
 
359
}
 
360
inline bool Predicate_immAllOnesV(SDNode *N) const {
 
361
 
 
362
  return ISD::isBuildVectorAllOnes(N);
 
363
 
 
364
}
 
365
inline bool Predicate_immAllOnesV_bc(SDNode *N) const {
 
366
 
 
367
  return ISD::isBuildVectorAllOnes(N);
 
368
 
 
369
}
 
370
inline bool Predicate_immAllZerosV(SDNode *N) const {
 
371
 
 
372
  return ISD::isBuildVectorAllZeros(N);
 
373
 
 
374
}
 
375
inline bool Predicate_immAllZerosV_bc(SDNode *N) const {
 
376
 
 
377
  return ISD::isBuildVectorAllZeros(N);
 
378
 
 
379
}
 
380
inline bool Predicate_immSExt16(SDNode *inN) const {
 
381
  ConstantSDNode *N = cast<ConstantSDNode>(inN);
 
382
 
 
383
  // immSExt16 predicate - True if the immediate fits in a 16-bit sign extended
 
384
  // field.  Used by instructions like 'addi'.
 
385
  if (N->getValueType(0) == MVT::i32)
 
386
    return (int32_t)N->getZExtValue() == (short)N->getZExtValue();
 
387
  else
 
388
    return (int64_t)N->getZExtValue() == (short)N->getZExtValue();
 
389
 
 
390
}
 
391
inline bool Predicate_immZExt16(SDNode *inN) const {
 
392
  ConstantSDNode *N = cast<ConstantSDNode>(inN);
 
393
 
 
394
  // immZExt16 predicate - True if the immediate fits in a 16-bit zero extended
 
395
  // field.  Used by instructions like 'ori'.
 
396
  return (uint64_t)N->getZExtValue() == (unsigned short)N->getZExtValue();
 
397
 
 
398
}
 
399
inline bool Predicate_istore(SDNode *N) const {
 
400
 
 
401
  return !cast<StoreSDNode>(N)->isTruncatingStore();
 
402
 
 
403
}
 
404
inline bool Predicate_itruncstore(SDNode *N) const {
 
405
 
 
406
  return cast<StoreSDNode>(N)->isTruncatingStore();
 
407
 
 
408
}
 
409
inline bool Predicate_load(SDNode *N) const {
 
410
 
 
411
  return cast<LoadSDNode>(N)->getExtensionType() == ISD::NON_EXTLOAD;
 
412
 
 
413
}
 
414
inline bool Predicate_maskimm32(SDNode *inN) const {
 
415
  ConstantSDNode *N = cast<ConstantSDNode>(inN);
 
416
 
 
417
  // maskImm predicate - True if immediate is a run of ones.
 
418
  unsigned mb, me;
 
419
  if (N->getValueType(0) == MVT::i32)
 
420
    return isRunOfOnes((unsigned)N->getZExtValue(), mb, me);
 
421
  else
 
422
    return false;
 
423
 
 
424
}
 
425
inline bool Predicate_post_store(SDNode *N) const {
 
426
 
 
427
  ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
 
428
  return AM == ISD::POST_INC || AM == ISD::POST_DEC;
 
429
 
 
430
}
 
431
inline bool Predicate_post_truncst(SDNode *N) const {
 
432
 
 
433
  ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
 
434
  return AM == ISD::POST_INC || AM == ISD::POST_DEC;
 
435
 
 
436
}
 
437
inline bool Predicate_post_truncstf32(SDNode *N) const {
 
438
 
 
439
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::f32;
 
440
 
 
441
}
 
442
inline bool Predicate_post_truncsti1(SDNode *N) const {
 
443
 
 
444
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i1;
 
445
 
 
446
}
 
447
inline bool Predicate_post_truncsti16(SDNode *N) const {
 
448
 
 
449
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i16;
 
450
 
 
451
}
 
452
inline bool Predicate_post_truncsti32(SDNode *N) const {
 
453
 
 
454
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i32;
 
455
 
 
456
}
 
457
inline bool Predicate_post_truncsti8(SDNode *N) const {
 
458
 
 
459
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i8;
 
460
 
 
461
}
 
462
inline bool Predicate_pre_store(SDNode *N) const {
 
463
 
 
464
  ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
 
465
  return AM == ISD::PRE_INC || AM == ISD::PRE_DEC;
 
466
 
 
467
}
 
468
inline bool Predicate_pre_truncst(SDNode *N) const {
 
469
 
 
470
  ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
 
471
  return AM == ISD::PRE_INC || AM == ISD::PRE_DEC;
 
472
 
 
473
}
 
474
inline bool Predicate_pre_truncstf32(SDNode *N) const {
 
475
 
 
476
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::f32;
 
477
 
 
478
}
 
479
inline bool Predicate_pre_truncsti1(SDNode *N) const {
 
480
 
 
481
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i1;
 
482
 
 
483
}
 
484
inline bool Predicate_pre_truncsti16(SDNode *N) const {
 
485
 
 
486
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i16;
 
487
 
 
488
}
 
489
inline bool Predicate_pre_truncsti32(SDNode *N) const {
 
490
 
 
491
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i32;
 
492
 
 
493
}
 
494
inline bool Predicate_pre_truncsti8(SDNode *N) const {
 
495
 
 
496
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i8;
 
497
 
 
498
}
 
499
inline bool Predicate_sextload(SDNode *N) const {
 
500
 
 
501
  return cast<LoadSDNode>(N)->getExtensionType() == ISD::SEXTLOAD;
 
502
 
 
503
}
 
504
inline bool Predicate_sextloadi1(SDNode *N) const {
 
505
 
 
506
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i1;
 
507
 
 
508
}
 
509
inline bool Predicate_sextloadi16(SDNode *N) const {
 
510
 
 
511
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i16;
 
512
 
 
513
}
 
514
inline bool Predicate_sextloadi32(SDNode *N) const {
 
515
 
 
516
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i32;
 
517
 
 
518
}
 
519
inline bool Predicate_sextloadi8(SDNode *N) const {
 
520
 
 
521
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i8;
 
522
 
 
523
}
 
524
inline bool Predicate_store(SDNode *N) const {
 
525
 
 
526
  return !cast<StoreSDNode>(N)->isTruncatingStore();
 
527
 
 
528
}
 
529
inline bool Predicate_truncstore(SDNode *N) const {
 
530
 
 
531
  return cast<StoreSDNode>(N)->isTruncatingStore();
 
532
 
 
533
}
 
534
inline bool Predicate_truncstoref32(SDNode *N) const {
 
535
 
 
536
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::f32;
 
537
 
 
538
}
 
539
inline bool Predicate_truncstoref64(SDNode *N) const {
 
540
 
 
541
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::f64;
 
542
 
 
543
}
 
544
inline bool Predicate_truncstorei16(SDNode *N) const {
 
545
 
 
546
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i16;
 
547
 
 
548
}
 
549
inline bool Predicate_truncstorei32(SDNode *N) const {
 
550
 
 
551
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i32;
 
552
 
 
553
}
 
554
inline bool Predicate_truncstorei8(SDNode *N) const {
 
555
 
 
556
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i8;
 
557
 
 
558
}
 
559
inline bool Predicate_unindexedload(SDNode *N) const {
 
560
 
 
561
  return cast<LoadSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
 
562
 
 
563
}
 
564
inline bool Predicate_unindexedstore(SDNode *N) const {
 
565
 
 
566
  return cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
 
567
 
 
568
}
 
569
inline bool Predicate_vecspltisb(SDNode *N) const {
 
570
 
 
571
  return PPC::get_VSPLTI_elt(N, 1, *CurDAG).getNode() != 0;
 
572
 
 
573
}
 
574
inline bool Predicate_vecspltish(SDNode *N) const {
 
575
 
 
576
  return PPC::get_VSPLTI_elt(N, 2, *CurDAG).getNode() != 0;
 
577
 
 
578
}
 
579
inline bool Predicate_vecspltisw(SDNode *N) const {
 
580
 
 
581
  return PPC::get_VSPLTI_elt(N, 4, *CurDAG).getNode() != 0;
 
582
 
 
583
}
 
584
inline bool Predicate_vmrghb_shuffle(SDNode *N) const {
 
585
 
 
586
  return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 1, false);
 
587
 
 
588
}
 
589
inline bool Predicate_vmrghb_unary_shuffle(SDNode *N) const {
 
590
 
 
591
  return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 1, true);
 
592
 
 
593
}
 
594
inline bool Predicate_vmrghh_shuffle(SDNode *N) const {
 
595
 
 
596
  return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 2, false);
 
597
 
 
598
}
 
599
inline bool Predicate_vmrghh_unary_shuffle(SDNode *N) const {
 
600
 
 
601
  return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 2, true);
 
602
 
 
603
}
 
604
inline bool Predicate_vmrghw_shuffle(SDNode *N) const {
 
605
 
 
606
  return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 4, false);
 
607
 
 
608
}
 
609
inline bool Predicate_vmrghw_unary_shuffle(SDNode *N) const {
 
610
 
 
611
  return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 4, true);
 
612
 
 
613
}
 
614
inline bool Predicate_vmrglb_shuffle(SDNode *N) const {
 
615
 
 
616
  return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 1, false);
 
617
 
 
618
}
 
619
inline bool Predicate_vmrglb_unary_shuffle(SDNode *N) const {
 
620
 
 
621
  return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 1, true);
 
622
 
 
623
}
 
624
inline bool Predicate_vmrglh_shuffle(SDNode *N) const {
 
625
 
 
626
  return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 2, false);
 
627
 
 
628
}
 
629
inline bool Predicate_vmrglh_unary_shuffle(SDNode *N) const {
 
630
 
 
631
  return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 2, true);
 
632
 
 
633
}
 
634
inline bool Predicate_vmrglw_shuffle(SDNode *N) const {
 
635
 
 
636
  return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 4, false);
 
637
 
 
638
}
 
639
inline bool Predicate_vmrglw_unary_shuffle(SDNode *N) const {
 
640
 
 
641
  return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 4, true);
 
642
 
 
643
}
 
644
inline bool Predicate_vpkuhum_shuffle(SDNode *N) const {
 
645
 
 
646
  return PPC::isVPKUHUMShuffleMask(cast<ShuffleVectorSDNode>(N), false);
 
647
 
 
648
}
 
649
inline bool Predicate_vpkuhum_unary_shuffle(SDNode *N) const {
 
650
 
 
651
  return PPC::isVPKUHUMShuffleMask(cast<ShuffleVectorSDNode>(N), true);
 
652
 
 
653
}
 
654
inline bool Predicate_vpkuwum_shuffle(SDNode *N) const {
 
655
 
 
656
  return PPC::isVPKUWUMShuffleMask(cast<ShuffleVectorSDNode>(N), false);
 
657
 
 
658
}
 
659
inline bool Predicate_vpkuwum_unary_shuffle(SDNode *N) const {
 
660
 
 
661
  return PPC::isVPKUWUMShuffleMask(cast<ShuffleVectorSDNode>(N), true);
 
662
 
 
663
}
 
664
inline bool Predicate_vsldoi_shuffle(SDNode *N) const {
 
665
 
 
666
  return PPC::isVSLDOIShuffleMask(N, false) != -1;
 
667
 
 
668
}
 
669
inline bool Predicate_vsldoi_unary_shuffle(SDNode *N) const {
 
670
 
 
671
  return PPC::isVSLDOIShuffleMask(N, true) != -1;
 
672
 
 
673
}
 
674
inline bool Predicate_vspltb_shuffle(SDNode *N) const {
 
675
 
 
676
  return PPC::isSplatShuffleMask(cast<ShuffleVectorSDNode>(N), 1);
 
677
 
 
678
}
 
679
inline bool Predicate_vsplth_shuffle(SDNode *N) const {
 
680
 
 
681
  return PPC::isSplatShuffleMask(cast<ShuffleVectorSDNode>(N), 2);
 
682
 
 
683
}
 
684
inline bool Predicate_vspltw_shuffle(SDNode *N) const {
 
685
 
 
686
  return PPC::isSplatShuffleMask(cast<ShuffleVectorSDNode>(N), 4);
 
687
 
 
688
}
 
689
inline bool Predicate_vtFP(SDNode *inN) const {
 
690
  VTSDNode *N = cast<VTSDNode>(inN);
 
691
 return N->getVT().isFloatingPoint(); 
 
692
}
 
693
inline bool Predicate_vtInt(SDNode *inN) const {
 
694
  VTSDNode *N = cast<VTSDNode>(inN);
 
695
 return N->getVT().isInteger(); 
 
696
}
 
697
inline bool Predicate_zextload(SDNode *N) const {
 
698
 
 
699
  return cast<LoadSDNode>(N)->getExtensionType() == ISD::ZEXTLOAD;
 
700
 
 
701
}
 
702
inline bool Predicate_zextloadi1(SDNode *N) const {
 
703
 
 
704
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i1;
 
705
 
 
706
}
 
707
inline bool Predicate_zextloadi16(SDNode *N) const {
 
708
 
 
709
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i16;
 
710
 
 
711
}
 
712
inline bool Predicate_zextloadi32(SDNode *N) const {
 
713
 
 
714
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i32;
 
715
 
 
716
}
 
717
inline bool Predicate_zextloadi8(SDNode *N) const {
 
718
 
 
719
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i8;
 
720
 
 
721
}
 
722
 
 
723
 
 
724
// The main instruction selector code.
 
725
SDNode *SelectCode(SDNode *N) {
 
726
  // Opcodes are emitted as 2 bytes, TARGET_OPCODE handles this.
 
727
  #define TARGET_OPCODE(X) X & 255, unsigned(X) >> 8
 
728
  static const unsigned char MatcherTable[] = {
 
729
          OPC_SwitchOpcode , 37,  ISD::MEMBARRIER,
 
730
            OPC_RecordNode,
 
731
            OPC_MoveChild, 1,
 
732
            OPC_CheckOpcode, ISD::Constant,
 
733
            OPC_CheckType, MVT::i32,
 
734
            OPC_MoveParent,
 
735
            OPC_MoveChild, 2,
 
736
            OPC_CheckOpcode, ISD::Constant,
 
737
            OPC_MoveParent,
 
738
            OPC_MoveChild, 3,
 
739
            OPC_CheckOpcode, ISD::Constant,
 
740
            OPC_MoveParent,
 
741
            OPC_MoveChild, 4,
 
742
            OPC_CheckOpcode, ISD::Constant,
 
743
            OPC_MoveParent,
 
744
            OPC_MoveChild, 5,
 
745
            OPC_CheckOpcode, ISD::Constant,
 
746
            OPC_MoveParent,
 
747
            OPC_EmitMergeInputChains, 1, 0, 
 
748
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::SYNC), 0|OPFL_Chain,
 
749
                0, 0, 
 
750
          114|128,4,  ISD::INTRINSIC_VOID,
 
751
            OPC_RecordNode,
 
752
            OPC_MoveChild, 1,
 
753
            OPC_Scope, 19, 
 
754
              OPC_CheckInteger, 80|128,2, 
 
755
              OPC_MoveParent,
 
756
              OPC_RecordChild2,
 
757
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
758
              OPC_EmitMergeInputChains, 1, 0, 
 
759
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DCBA), 0|OPFL_Chain,
 
760
                  0, 2, 2, 3, 
 
761
            19, 
 
762
              OPC_CheckInteger, 81|128,2, 
 
763
              OPC_MoveParent,
 
764
              OPC_RecordChild2,
 
765
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
766
              OPC_EmitMergeInputChains, 1, 0, 
 
767
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DCBF), 0|OPFL_Chain,
 
768
                  0, 2, 2, 3, 
 
769
            19, 
 
770
              OPC_CheckInteger, 82|128,2, 
 
771
              OPC_MoveParent,
 
772
              OPC_RecordChild2,
 
773
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
774
              OPC_EmitMergeInputChains, 1, 0, 
 
775
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DCBI), 0|OPFL_Chain,
 
776
                  0, 2, 2, 3, 
 
777
            19, 
 
778
              OPC_CheckInteger, 83|128,2, 
 
779
              OPC_MoveParent,
 
780
              OPC_RecordChild2,
 
781
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
782
              OPC_EmitMergeInputChains, 1, 0, 
 
783
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DCBST), 0|OPFL_Chain,
 
784
                  0, 2, 2, 3, 
 
785
            19, 
 
786
              OPC_CheckInteger, 84|128,2, 
 
787
              OPC_MoveParent,
 
788
              OPC_RecordChild2,
 
789
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
790
              OPC_EmitMergeInputChains, 1, 0, 
 
791
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DCBT), 0|OPFL_Chain,
 
792
                  0, 2, 2, 3, 
 
793
            19, 
 
794
              OPC_CheckInteger, 85|128,2, 
 
795
              OPC_MoveParent,
 
796
              OPC_RecordChild2,
 
797
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
798
              OPC_EmitMergeInputChains, 1, 0, 
 
799
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DCBTST), 0|OPFL_Chain,
 
800
                  0, 2, 2, 3, 
 
801
            19, 
 
802
              OPC_CheckInteger, 86|128,2, 
 
803
              OPC_MoveParent,
 
804
              OPC_RecordChild2,
 
805
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
806
              OPC_EmitMergeInputChains, 1, 0, 
 
807
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DCBZ), 0|OPFL_Chain,
 
808
                  0, 2, 2, 3, 
 
809
            19, 
 
810
              OPC_CheckInteger, 87|128,2, 
 
811
              OPC_MoveParent,
 
812
              OPC_RecordChild2,
 
813
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
814
              OPC_EmitMergeInputChains, 1, 0, 
 
815
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DCBZL), 0|OPFL_Chain,
 
816
                  0, 2, 2, 3, 
 
817
            21, 
 
818
              OPC_CheckInteger, 76|128,1, 
 
819
              OPC_MoveParent,
 
820
              OPC_RecordChild2,
 
821
              OPC_RecordChild3,
 
822
              OPC_CheckComplexPat, /*CP*/0, /*#*/2,
 
823
              OPC_EmitMergeInputChains, 1, 0, 
 
824
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::STVEBX), 0|OPFL_Chain,
 
825
                  0, 3, 1, 3, 4, 
 
826
            21, 
 
827
              OPC_CheckInteger, 77|128,1, 
 
828
              OPC_MoveParent,
 
829
              OPC_RecordChild2,
 
830
              OPC_RecordChild3,
 
831
              OPC_CheckComplexPat, /*CP*/0, /*#*/2,
 
832
              OPC_EmitMergeInputChains, 1, 0, 
 
833
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::STVEHX), 0|OPFL_Chain,
 
834
                  0, 3, 1, 3, 4, 
 
835
            21, 
 
836
              OPC_CheckInteger, 78|128,1, 
 
837
              OPC_MoveParent,
 
838
              OPC_RecordChild2,
 
839
              OPC_RecordChild3,
 
840
              OPC_CheckComplexPat, /*CP*/0, /*#*/2,
 
841
              OPC_EmitMergeInputChains, 1, 0, 
 
842
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::STVEWX), 0|OPFL_Chain,
 
843
                  0, 3, 1, 3, 4, 
 
844
            21, 
 
845
              OPC_CheckInteger, 79|128,1, 
 
846
              OPC_MoveParent,
 
847
              OPC_RecordChild2,
 
848
              OPC_RecordChild3,
 
849
              OPC_CheckComplexPat, /*CP*/0, /*#*/2,
 
850
              OPC_EmitMergeInputChains, 1, 0, 
 
851
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::STVX), 0|OPFL_Chain,
 
852
                  0, 3, 1, 3, 4, 
 
853
            21, 
 
854
              OPC_CheckInteger, 80|128,1, 
 
855
              OPC_MoveParent,
 
856
              OPC_RecordChild2,
 
857
              OPC_RecordChild3,
 
858
              OPC_CheckComplexPat, /*CP*/0, /*#*/2,
 
859
              OPC_EmitMergeInputChains, 1, 0, 
 
860
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::STVXL), 0|OPFL_Chain,
 
861
                  0, 3, 1, 3, 4, 
 
862
            34, 
 
863
              OPC_CheckInteger, 61|128,1, 
 
864
              OPC_MoveParent,
 
865
              OPC_RecordChild2,
 
866
              OPC_MoveChild, 2,
 
867
              OPC_CheckOpcode, ISD::Constant,
 
868
              OPC_MoveParent,
 
869
              OPC_EmitMergeInputChains, 1, 0, 
 
870
              OPC_EmitInteger, MVT::i32, 0, 
 
871
              OPC_EmitConvertToTarget, 1,
 
872
              OPC_EmitInteger, MVT::i32, 0, 
 
873
              OPC_EmitInteger, MVT::i32, 0, 
 
874
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DSS), 0|OPFL_Chain,
 
875
                  0, 4, 2, 3, 4, 5, 
 
876
            63, 
 
877
              OPC_CheckInteger, 63|128,1, 
 
878
              OPC_MoveParent,
 
879
              OPC_RecordChild2,
 
880
              OPC_Scope, 27, 
 
881
                OPC_CheckChild2Type, MVT::i32,
 
882
                OPC_RecordChild3,
 
883
                OPC_RecordChild4,
 
884
                OPC_MoveChild, 4,
 
885
                OPC_CheckOpcode, ISD::Constant,
 
886
                OPC_MoveParent,
 
887
                OPC_EmitMergeInputChains, 1, 0, 
 
888
                OPC_EmitInteger, MVT::i32, 0, 
 
889
                OPC_EmitConvertToTarget, 3,
 
890
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::DST), 0|OPFL_Chain,
 
891
                    0, 4, 4, 5, 1, 2, 
 
892
              27, 
 
893
                OPC_CheckChild2Type, MVT::i64,
 
894
                OPC_RecordChild3,
 
895
                OPC_RecordChild4,
 
896
                OPC_MoveChild, 4,
 
897
                OPC_CheckOpcode, ISD::Constant,
 
898
                OPC_MoveParent,
 
899
                OPC_EmitMergeInputChains, 1, 0, 
 
900
                OPC_EmitInteger, MVT::i32, 0, 
 
901
                OPC_EmitConvertToTarget, 3,
 
902
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::DST64), 0|OPFL_Chain,
 
903
                    0, 4, 4, 5, 1, 2, 
 
904
              0, 
 
905
            63, 
 
906
              OPC_CheckInteger, 66|128,1, 
 
907
              OPC_MoveParent,
 
908
              OPC_RecordChild2,
 
909
              OPC_Scope, 27, 
 
910
                OPC_CheckChild2Type, MVT::i32,
 
911
                OPC_RecordChild3,
 
912
                OPC_RecordChild4,
 
913
                OPC_MoveChild, 4,
 
914
                OPC_CheckOpcode, ISD::Constant,
 
915
                OPC_MoveParent,
 
916
                OPC_EmitMergeInputChains, 1, 0, 
 
917
                OPC_EmitInteger, MVT::i32, 1, 
 
918
                OPC_EmitConvertToTarget, 3,
 
919
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::DSTT), 0|OPFL_Chain,
 
920
                    0, 4, 4, 5, 1, 2, 
 
921
              27, 
 
922
                OPC_CheckChild2Type, MVT::i64,
 
923
                OPC_RecordChild3,
 
924
                OPC_RecordChild4,
 
925
                OPC_MoveChild, 4,
 
926
                OPC_CheckOpcode, ISD::Constant,
 
927
                OPC_MoveParent,
 
928
                OPC_EmitMergeInputChains, 1, 0, 
 
929
                OPC_EmitInteger, MVT::i32, 1, 
 
930
                OPC_EmitConvertToTarget, 3,
 
931
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::DSTT64), 0|OPFL_Chain,
 
932
                    0, 4, 4, 5, 1, 2, 
 
933
              0, 
 
934
            63, 
 
935
              OPC_CheckInteger, 64|128,1, 
 
936
              OPC_MoveParent,
 
937
              OPC_RecordChild2,
 
938
              OPC_Scope, 27, 
 
939
                OPC_CheckChild2Type, MVT::i32,
 
940
                OPC_RecordChild3,
 
941
                OPC_RecordChild4,
 
942
                OPC_MoveChild, 4,
 
943
                OPC_CheckOpcode, ISD::Constant,
 
944
                OPC_MoveParent,
 
945
                OPC_EmitMergeInputChains, 1, 0, 
 
946
                OPC_EmitInteger, MVT::i32, 0, 
 
947
                OPC_EmitConvertToTarget, 3,
 
948
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::DSTST), 0|OPFL_Chain,
 
949
                    0, 4, 4, 5, 1, 2, 
 
950
              27, 
 
951
                OPC_CheckChild2Type, MVT::i64,
 
952
                OPC_RecordChild3,
 
953
                OPC_RecordChild4,
 
954
                OPC_MoveChild, 4,
 
955
                OPC_CheckOpcode, ISD::Constant,
 
956
                OPC_MoveParent,
 
957
                OPC_EmitMergeInputChains, 1, 0, 
 
958
                OPC_EmitInteger, MVT::i32, 0, 
 
959
                OPC_EmitConvertToTarget, 3,
 
960
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::DSTST64), 0|OPFL_Chain,
 
961
                    0, 4, 4, 5, 1, 2, 
 
962
              0, 
 
963
            63, 
 
964
              OPC_CheckInteger, 65|128,1, 
 
965
              OPC_MoveParent,
 
966
              OPC_RecordChild2,
 
967
              OPC_Scope, 27, 
 
968
                OPC_CheckChild2Type, MVT::i32,
 
969
                OPC_RecordChild3,
 
970
                OPC_RecordChild4,
 
971
                OPC_MoveChild, 4,
 
972
                OPC_CheckOpcode, ISD::Constant,
 
973
                OPC_MoveParent,
 
974
                OPC_EmitMergeInputChains, 1, 0, 
 
975
                OPC_EmitInteger, MVT::i32, 1, 
 
976
                OPC_EmitConvertToTarget, 3,
 
977
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::DSTSTT), 0|OPFL_Chain,
 
978
                    0, 4, 4, 5, 1, 2, 
 
979
              27, 
 
980
                OPC_CheckChild2Type, MVT::i64,
 
981
                OPC_RecordChild3,
 
982
                OPC_RecordChild4,
 
983
                OPC_MoveChild, 4,
 
984
                OPC_CheckOpcode, ISD::Constant,
 
985
                OPC_MoveParent,
 
986
                OPC_EmitMergeInputChains, 1, 0, 
 
987
                OPC_EmitInteger, MVT::i32, 1, 
 
988
                OPC_EmitConvertToTarget, 3,
 
989
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::DSTSTT64), 0|OPFL_Chain,
 
990
                    0, 4, 4, 5, 1, 2, 
 
991
              0, 
 
992
            13, 
 
993
              OPC_CheckInteger, 88|128,2, 
 
994
              OPC_MoveParent,
 
995
              OPC_EmitMergeInputChains, 1, 0, 
 
996
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::SYNC), 0|OPFL_Chain,
 
997
                  0, 0, 
 
998
            15, 
 
999
              OPC_CheckInteger, 75|128,1, 
 
1000
              OPC_MoveParent,
 
1001
              OPC_RecordChild2,
 
1002
              OPC_EmitMergeInputChains, 1, 0, 
 
1003
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::MTVSCR), 0|OPFL_Chain,
 
1004
                  0, 1, 1, 
 
1005
            29, 
 
1006
              OPC_CheckInteger, 62|128,1, 
 
1007
              OPC_MoveParent,
 
1008
              OPC_EmitMergeInputChains, 1, 0, 
 
1009
              OPC_EmitInteger, MVT::i32, 1, 
 
1010
              OPC_EmitInteger, MVT::i32, 0, 
 
1011
              OPC_EmitInteger, MVT::i32, 0, 
 
1012
              OPC_EmitInteger, MVT::i32, 0, 
 
1013
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DSSALL), 0|OPFL_Chain,
 
1014
                  0, 4, 1, 2, 3, 4, 
 
1015
            0, 
 
1016
          125,  ISD::INTRINSIC_W_CHAIN,
 
1017
            OPC_RecordNode,
 
1018
            OPC_MoveChild, 1,
 
1019
            OPC_Scope, 20, 
 
1020
              OPC_CheckInteger, 67|128,1, 
 
1021
              OPC_MoveParent,
 
1022
              OPC_RecordChild2,
 
1023
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
1024
              OPC_EmitMergeInputChains, 1, 0, 
 
1025
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LVEBX), 0|OPFL_Chain,
 
1026
                  1, MVT::v16i8, 2, 2, 3, 
 
1027
            20, 
 
1028
              OPC_CheckInteger, 68|128,1, 
 
1029
              OPC_MoveParent,
 
1030
              OPC_RecordChild2,
 
1031
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
1032
              OPC_EmitMergeInputChains, 1, 0, 
 
1033
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LVEHX), 0|OPFL_Chain,
 
1034
                  1, MVT::v8i16, 2, 2, 3, 
 
1035
            20, 
 
1036
              OPC_CheckInteger, 69|128,1, 
 
1037
              OPC_MoveParent,
 
1038
              OPC_RecordChild2,
 
1039
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
1040
              OPC_EmitMergeInputChains, 1, 0, 
 
1041
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LVEWX), 0|OPFL_Chain,
 
1042
                  1, MVT::v4i32, 2, 2, 3, 
 
1043
            20, 
 
1044
              OPC_CheckInteger, 72|128,1, 
 
1045
              OPC_MoveParent,
 
1046
              OPC_RecordChild2,
 
1047
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
1048
              OPC_EmitMergeInputChains, 1, 0, 
 
1049
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LVX), 0|OPFL_Chain,
 
1050
                  1, MVT::v4i32, 2, 2, 3, 
 
1051
            20, 
 
1052
              OPC_CheckInteger, 73|128,1, 
 
1053
              OPC_MoveParent,
 
1054
              OPC_RecordChild2,
 
1055
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
1056
              OPC_EmitMergeInputChains, 1, 0, 
 
1057
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LVXL), 0|OPFL_Chain,
 
1058
                  1, MVT::v4i32, 2, 2, 3, 
 
1059
            14, 
 
1060
              OPC_CheckInteger, 74|128,1, 
 
1061
              OPC_MoveParent,
 
1062
              OPC_EmitMergeInputChains, 1, 0, 
 
1063
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::MFVSCR), 0|OPFL_Chain,
 
1064
                  1, MVT::v8i16, 0, 
 
1065
            0, 
 
1066
          18|128,13,  ISD::INTRINSIC_WO_CHAIN,
 
1067
            OPC_MoveChild, 0,
 
1068
            OPC_Scope, 17, 
 
1069
              OPC_CheckInteger, 70|128,1, 
 
1070
              OPC_MoveParent,
 
1071
              OPC_RecordChild1,
 
1072
              OPC_CheckComplexPat, /*CP*/0, /*#*/0,
 
1073
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LVSL), 0,
 
1074
                  1, MVT::v16i8, 2, 1, 2, 
 
1075
            17, 
 
1076
              OPC_CheckInteger, 71|128,1, 
 
1077
              OPC_MoveParent,
 
1078
              OPC_RecordChild1,
 
1079
              OPC_CheckComplexPat, /*CP*/0, /*#*/0,
 
1080
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LVSR), 0,
 
1081
                  1, MVT::v16i8, 2, 1, 2, 
 
1082
            22, 
 
1083
              OPC_CheckInteger, 94|128,1, 
 
1084
              OPC_MoveParent,
 
1085
              OPC_RecordChild1,
 
1086
              OPC_RecordChild2,
 
1087
              OPC_MoveChild, 2,
 
1088
              OPC_CheckOpcode, ISD::Constant,
 
1089
              OPC_MoveParent,
 
1090
              OPC_EmitConvertToTarget, 1,
 
1091
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCFSX), 0,
 
1092
                  1, MVT::v4f32, 2, 2, 0, 
 
1093
            22, 
 
1094
              OPC_CheckInteger, 95|128,1, 
 
1095
              OPC_MoveParent,
 
1096
              OPC_RecordChild1,
 
1097
              OPC_RecordChild2,
 
1098
              OPC_MoveChild, 2,
 
1099
              OPC_CheckOpcode, ISD::Constant,
 
1100
              OPC_MoveParent,
 
1101
              OPC_EmitConvertToTarget, 1,
 
1102
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCFUX), 0,
 
1103
                  1, MVT::v4f32, 2, 2, 0, 
 
1104
            22, 
 
1105
              OPC_CheckInteger, 122|128,1, 
 
1106
              OPC_MoveParent,
 
1107
              OPC_RecordChild1,
 
1108
              OPC_RecordChild2,
 
1109
              OPC_MoveChild, 2,
 
1110
              OPC_CheckOpcode, ISD::Constant,
 
1111
              OPC_MoveParent,
 
1112
              OPC_EmitConvertToTarget, 1,
 
1113
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCTSXS), 0,
 
1114
                  1, MVT::v4i32, 2, 2, 0, 
 
1115
            22, 
 
1116
              OPC_CheckInteger, 123|128,1, 
 
1117
              OPC_MoveParent,
 
1118
              OPC_RecordChild1,
 
1119
              OPC_RecordChild2,
 
1120
              OPC_MoveChild, 2,
 
1121
              OPC_CheckOpcode, ISD::Constant,
 
1122
              OPC_MoveParent,
 
1123
              OPC_EmitConvertToTarget, 1,
 
1124
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCTUXS), 0,
 
1125
                  1, MVT::v4i32, 2, 2, 0, 
 
1126
            17, 
 
1127
              OPC_CheckInteger, 6|128,2, 
 
1128
              OPC_MoveParent,
 
1129
              OPC_RecordChild1,
 
1130
              OPC_RecordChild2,
 
1131
              OPC_RecordChild3,
 
1132
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMHADDSHS), 0,
 
1133
                  1, MVT::v8i16, 3, 0, 1, 2, 
 
1134
            17, 
 
1135
              OPC_CheckInteger, 7|128,2, 
 
1136
              OPC_MoveParent,
 
1137
              OPC_RecordChild1,
 
1138
              OPC_RecordChild2,
 
1139
              OPC_RecordChild3,
 
1140
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMHRADDSHS), 0,
 
1141
                  1, MVT::v8i16, 3, 0, 1, 2, 
 
1142
            17, 
 
1143
              OPC_CheckInteger, 15|128,2, 
 
1144
              OPC_MoveParent,
 
1145
              OPC_RecordChild1,
 
1146
              OPC_RecordChild2,
 
1147
              OPC_RecordChild3,
 
1148
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMLADDUHM), 0,
 
1149
                  1, MVT::v8i16, 3, 0, 1, 2, 
 
1150
            17, 
 
1151
              OPC_CheckInteger, 31|128,2, 
 
1152
              OPC_MoveParent,
 
1153
              OPC_RecordChild1,
 
1154
              OPC_RecordChild2,
 
1155
              OPC_RecordChild3,
 
1156
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VPERM), 0,
 
1157
                  1, MVT::v4i32, 3, 0, 1, 2, 
 
1158
            17, 
 
1159
              OPC_CheckInteger, 48|128,2, 
 
1160
              OPC_MoveParent,
 
1161
              OPC_RecordChild1,
 
1162
              OPC_RecordChild2,
 
1163
              OPC_RecordChild3,
 
1164
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSEL), 0,
 
1165
                  1, MVT::v4i32, 3, 0, 1, 2, 
 
1166
            15, 
 
1167
              OPC_CheckInteger, 81|128,1, 
 
1168
              OPC_MoveParent,
 
1169
              OPC_RecordChild1,
 
1170
              OPC_RecordChild2,
 
1171
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VADDCUW), 0,
 
1172
                  1, MVT::v4i32, 2, 0, 1, 
 
1173
            15, 
 
1174
              OPC_CheckInteger, 82|128,1, 
 
1175
              OPC_MoveParent,
 
1176
              OPC_RecordChild1,
 
1177
              OPC_RecordChild2,
 
1178
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VADDSBS), 0,
 
1179
                  1, MVT::v16i8, 2, 0, 1, 
 
1180
            15, 
 
1181
              OPC_CheckInteger, 83|128,1, 
 
1182
              OPC_MoveParent,
 
1183
              OPC_RecordChild1,
 
1184
              OPC_RecordChild2,
 
1185
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VADDSHS), 0,
 
1186
                  1, MVT::v8i16, 2, 0, 1, 
 
1187
            15, 
 
1188
              OPC_CheckInteger, 84|128,1, 
 
1189
              OPC_MoveParent,
 
1190
              OPC_RecordChild1,
 
1191
              OPC_RecordChild2,
 
1192
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VADDSWS), 0,
 
1193
                  1, MVT::v4i32, 2, 0, 1, 
 
1194
            15, 
 
1195
              OPC_CheckInteger, 85|128,1, 
 
1196
              OPC_MoveParent,
 
1197
              OPC_RecordChild1,
 
1198
              OPC_RecordChild2,
 
1199
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VADDUBS), 0,
 
1200
                  1, MVT::v16i8, 2, 0, 1, 
 
1201
            15, 
 
1202
              OPC_CheckInteger, 86|128,1, 
 
1203
              OPC_MoveParent,
 
1204
              OPC_RecordChild1,
 
1205
              OPC_RecordChild2,
 
1206
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VADDUHS), 0,
 
1207
                  1, MVT::v8i16, 2, 0, 1, 
 
1208
            15, 
 
1209
              OPC_CheckInteger, 87|128,1, 
 
1210
              OPC_MoveParent,
 
1211
              OPC_RecordChild1,
 
1212
              OPC_RecordChild2,
 
1213
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VADDUWS), 0,
 
1214
                  1, MVT::v4i32, 2, 0, 1, 
 
1215
            13, 
 
1216
              OPC_CheckInteger, 124|128,1, 
 
1217
              OPC_MoveParent,
 
1218
              OPC_RecordChild1,
 
1219
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VEXPTEFP), 0,
 
1220
                  1, MVT::v4f32, 1, 0, 
 
1221
            13, 
 
1222
              OPC_CheckInteger, 125|128,1, 
 
1223
              OPC_MoveParent,
 
1224
              OPC_RecordChild1,
 
1225
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VLOGEFP), 0,
 
1226
                  1, MVT::v4f32, 1, 0, 
 
1227
            15, 
 
1228
              OPC_CheckInteger, 88|128,1, 
 
1229
              OPC_MoveParent,
 
1230
              OPC_RecordChild1,
 
1231
              OPC_RecordChild2,
 
1232
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VAVGSB), 0,
 
1233
                  1, MVT::v16i8, 2, 0, 1, 
 
1234
            15, 
 
1235
              OPC_CheckInteger, 89|128,1, 
 
1236
              OPC_MoveParent,
 
1237
              OPC_RecordChild1,
 
1238
              OPC_RecordChild2,
 
1239
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VAVGSH), 0,
 
1240
                  1, MVT::v8i16, 2, 0, 1, 
 
1241
            15, 
 
1242
              OPC_CheckInteger, 90|128,1, 
 
1243
              OPC_MoveParent,
 
1244
              OPC_RecordChild1,
 
1245
              OPC_RecordChild2,
 
1246
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VAVGSW), 0,
 
1247
                  1, MVT::v4i32, 2, 0, 1, 
 
1248
            15, 
 
1249
              OPC_CheckInteger, 91|128,1, 
 
1250
              OPC_MoveParent,
 
1251
              OPC_RecordChild1,
 
1252
              OPC_RecordChild2,
 
1253
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VAVGUB), 0,
 
1254
                  1, MVT::v16i8, 2, 0, 1, 
 
1255
            15, 
 
1256
              OPC_CheckInteger, 92|128,1, 
 
1257
              OPC_MoveParent,
 
1258
              OPC_RecordChild1,
 
1259
              OPC_RecordChild2,
 
1260
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VAVGUH), 0,
 
1261
                  1, MVT::v8i16, 2, 0, 1, 
 
1262
            15, 
 
1263
              OPC_CheckInteger, 93|128,1, 
 
1264
              OPC_MoveParent,
 
1265
              OPC_RecordChild1,
 
1266
              OPC_RecordChild2,
 
1267
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VAVGUW), 0,
 
1268
                  1, MVT::v4i32, 2, 0, 1, 
 
1269
            15, 
 
1270
              OPC_CheckInteger, 127|128,1, 
 
1271
              OPC_MoveParent,
 
1272
              OPC_RecordChild1,
 
1273
              OPC_RecordChild2,
 
1274
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMAXFP), 0,
 
1275
                  1, MVT::v4f32, 2, 0, 1, 
 
1276
            15, 
 
1277
              OPC_CheckInteger, 0|128,2, 
 
1278
              OPC_MoveParent,
 
1279
              OPC_RecordChild1,
 
1280
              OPC_RecordChild2,
 
1281
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMAXSB), 0,
 
1282
                  1, MVT::v16i8, 2, 0, 1, 
 
1283
            15, 
 
1284
              OPC_CheckInteger, 1|128,2, 
 
1285
              OPC_MoveParent,
 
1286
              OPC_RecordChild1,
 
1287
              OPC_RecordChild2,
 
1288
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMAXSH), 0,
 
1289
                  1, MVT::v8i16, 2, 0, 1, 
 
1290
            15, 
 
1291
              OPC_CheckInteger, 2|128,2, 
 
1292
              OPC_MoveParent,
 
1293
              OPC_RecordChild1,
 
1294
              OPC_RecordChild2,
 
1295
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMAXSW), 0,
 
1296
                  1, MVT::v4i32, 2, 0, 1, 
 
1297
            15, 
 
1298
              OPC_CheckInteger, 3|128,2, 
 
1299
              OPC_MoveParent,
 
1300
              OPC_RecordChild1,
 
1301
              OPC_RecordChild2,
 
1302
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMAXUB), 0,
 
1303
                  1, MVT::v16i8, 2, 0, 1, 
 
1304
            15, 
 
1305
              OPC_CheckInteger, 4|128,2, 
 
1306
              OPC_MoveParent,
 
1307
              OPC_RecordChild1,
 
1308
              OPC_RecordChild2,
 
1309
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMAXUH), 0,
 
1310
                  1, MVT::v8i16, 2, 0, 1, 
 
1311
            15, 
 
1312
              OPC_CheckInteger, 5|128,2, 
 
1313
              OPC_MoveParent,
 
1314
              OPC_RecordChild1,
 
1315
              OPC_RecordChild2,
 
1316
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMAXUW), 0,
 
1317
                  1, MVT::v4i32, 2, 0, 1, 
 
1318
            15, 
 
1319
              OPC_CheckInteger, 8|128,2, 
 
1320
              OPC_MoveParent,
 
1321
              OPC_RecordChild1,
 
1322
              OPC_RecordChild2,
 
1323
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMINFP), 0,
 
1324
                  1, MVT::v4f32, 2, 0, 1, 
 
1325
            15, 
 
1326
              OPC_CheckInteger, 9|128,2, 
 
1327
              OPC_MoveParent,
 
1328
              OPC_RecordChild1,
 
1329
              OPC_RecordChild2,
 
1330
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMINSB), 0,
 
1331
                  1, MVT::v16i8, 2, 0, 1, 
 
1332
            15, 
 
1333
              OPC_CheckInteger, 10|128,2, 
 
1334
              OPC_MoveParent,
 
1335
              OPC_RecordChild1,
 
1336
              OPC_RecordChild2,
 
1337
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMINSH), 0,
 
1338
                  1, MVT::v8i16, 2, 0, 1, 
 
1339
            15, 
 
1340
              OPC_CheckInteger, 11|128,2, 
 
1341
              OPC_MoveParent,
 
1342
              OPC_RecordChild1,
 
1343
              OPC_RecordChild2,
 
1344
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMINSW), 0,
 
1345
                  1, MVT::v4i32, 2, 0, 1, 
 
1346
            15, 
 
1347
              OPC_CheckInteger, 12|128,2, 
 
1348
              OPC_MoveParent,
 
1349
              OPC_RecordChild1,
 
1350
              OPC_RecordChild2,
 
1351
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMINUB), 0,
 
1352
                  1, MVT::v16i8, 2, 0, 1, 
 
1353
            15, 
 
1354
              OPC_CheckInteger, 13|128,2, 
 
1355
              OPC_MoveParent,
 
1356
              OPC_RecordChild1,
 
1357
              OPC_RecordChild2,
 
1358
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMINUH), 0,
 
1359
                  1, MVT::v8i16, 2, 0, 1, 
 
1360
            15, 
 
1361
              OPC_CheckInteger, 14|128,2, 
 
1362
              OPC_MoveParent,
 
1363
              OPC_RecordChild1,
 
1364
              OPC_RecordChild2,
 
1365
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMINUW), 0,
 
1366
                  1, MVT::v4i32, 2, 0, 1, 
 
1367
            17, 
 
1368
              OPC_CheckInteger, 16|128,2, 
 
1369
              OPC_MoveParent,
 
1370
              OPC_RecordChild1,
 
1371
              OPC_RecordChild2,
 
1372
              OPC_RecordChild3,
 
1373
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMSUMMBM), 0,
 
1374
                  1, MVT::v4i32, 3, 0, 1, 2, 
 
1375
            17, 
 
1376
              OPC_CheckInteger, 17|128,2, 
 
1377
              OPC_MoveParent,
 
1378
              OPC_RecordChild1,
 
1379
              OPC_RecordChild2,
 
1380
              OPC_RecordChild3,
 
1381
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMSUMSHM), 0,
 
1382
                  1, MVT::v4i32, 3, 0, 1, 2, 
 
1383
            17, 
 
1384
              OPC_CheckInteger, 18|128,2, 
 
1385
              OPC_MoveParent,
 
1386
              OPC_RecordChild1,
 
1387
              OPC_RecordChild2,
 
1388
              OPC_RecordChild3,
 
1389
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMSUMSHS), 0,
 
1390
                  1, MVT::v4i32, 3, 0, 1, 2, 
 
1391
            17, 
 
1392
              OPC_CheckInteger, 19|128,2, 
 
1393
              OPC_MoveParent,
 
1394
              OPC_RecordChild1,
 
1395
              OPC_RecordChild2,
 
1396
              OPC_RecordChild3,
 
1397
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMSUMUBM), 0,
 
1398
                  1, MVT::v4i32, 3, 0, 1, 2, 
 
1399
            17, 
 
1400
              OPC_CheckInteger, 20|128,2, 
 
1401
              OPC_MoveParent,
 
1402
              OPC_RecordChild1,
 
1403
              OPC_RecordChild2,
 
1404
              OPC_RecordChild3,
 
1405
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMSUMUHM), 0,
 
1406
                  1, MVT::v4i32, 3, 0, 1, 2, 
 
1407
            17, 
 
1408
              OPC_CheckInteger, 21|128,2, 
 
1409
              OPC_MoveParent,
 
1410
              OPC_RecordChild1,
 
1411
              OPC_RecordChild2,
 
1412
              OPC_RecordChild3,
 
1413
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMSUMUHS), 0,
 
1414
                  1, MVT::v4i32, 3, 0, 1, 2, 
 
1415
            15, 
 
1416
              OPC_CheckInteger, 22|128,2, 
 
1417
              OPC_MoveParent,
 
1418
              OPC_RecordChild1,
 
1419
              OPC_RecordChild2,
 
1420
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMULESB), 0,
 
1421
                  1, MVT::v8i16, 2, 0, 1, 
 
1422
            15, 
 
1423
              OPC_CheckInteger, 23|128,2, 
 
1424
              OPC_MoveParent,
 
1425
              OPC_RecordChild1,
 
1426
              OPC_RecordChild2,
 
1427
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMULESH), 0,
 
1428
                  1, MVT::v4i32, 2, 0, 1, 
 
1429
            15, 
 
1430
              OPC_CheckInteger, 24|128,2, 
 
1431
              OPC_MoveParent,
 
1432
              OPC_RecordChild1,
 
1433
              OPC_RecordChild2,
 
1434
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMULEUB), 0,
 
1435
                  1, MVT::v8i16, 2, 0, 1, 
 
1436
            15, 
 
1437
              OPC_CheckInteger, 25|128,2, 
 
1438
              OPC_MoveParent,
 
1439
              OPC_RecordChild1,
 
1440
              OPC_RecordChild2,
 
1441
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMULEUH), 0,
 
1442
                  1, MVT::v4i32, 2, 0, 1, 
 
1443
            15, 
 
1444
              OPC_CheckInteger, 26|128,2, 
 
1445
              OPC_MoveParent,
 
1446
              OPC_RecordChild1,
 
1447
              OPC_RecordChild2,
 
1448
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMULOSB), 0,
 
1449
                  1, MVT::v8i16, 2, 0, 1, 
 
1450
            15, 
 
1451
              OPC_CheckInteger, 27|128,2, 
 
1452
              OPC_MoveParent,
 
1453
              OPC_RecordChild1,
 
1454
              OPC_RecordChild2,
 
1455
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMULOSH), 0,
 
1456
                  1, MVT::v4i32, 2, 0, 1, 
 
1457
            15, 
 
1458
              OPC_CheckInteger, 28|128,2, 
 
1459
              OPC_MoveParent,
 
1460
              OPC_RecordChild1,
 
1461
              OPC_RecordChild2,
 
1462
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMULOUB), 0,
 
1463
                  1, MVT::v8i16, 2, 0, 1, 
 
1464
            15, 
 
1465
              OPC_CheckInteger, 29|128,2, 
 
1466
              OPC_MoveParent,
 
1467
              OPC_RecordChild1,
 
1468
              OPC_RecordChild2,
 
1469
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMULOUH), 0,
 
1470
                  1, MVT::v4i32, 2, 0, 1, 
 
1471
            13, 
 
1472
              OPC_CheckInteger, 39|128,2, 
 
1473
              OPC_MoveParent,
 
1474
              OPC_RecordChild1,
 
1475
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VREFP), 0,
 
1476
                  1, MVT::v4f32, 1, 0, 
 
1477
            13, 
 
1478
              OPC_CheckInteger, 40|128,2, 
 
1479
              OPC_MoveParent,
 
1480
              OPC_RecordChild1,
 
1481
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VRFIM), 0,
 
1482
                  1, MVT::v4f32, 1, 0, 
 
1483
            13, 
 
1484
              OPC_CheckInteger, 41|128,2, 
 
1485
              OPC_MoveParent,
 
1486
              OPC_RecordChild1,
 
1487
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VRFIN), 0,
 
1488
                  1, MVT::v4f32, 1, 0, 
 
1489
            13, 
 
1490
              OPC_CheckInteger, 42|128,2, 
 
1491
              OPC_MoveParent,
 
1492
              OPC_RecordChild1,
 
1493
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VRFIP), 0,
 
1494
                  1, MVT::v4f32, 1, 0, 
 
1495
            13, 
 
1496
              OPC_CheckInteger, 43|128,2, 
 
1497
              OPC_MoveParent,
 
1498
              OPC_RecordChild1,
 
1499
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VRFIZ), 0,
 
1500
                  1, MVT::v4f32, 1, 0, 
 
1501
            13, 
 
1502
              OPC_CheckInteger, 47|128,2, 
 
1503
              OPC_MoveParent,
 
1504
              OPC_RecordChild1,
 
1505
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VRSQRTEFP), 0,
 
1506
                  1, MVT::v4f32, 1, 0, 
 
1507
            15, 
 
1508
              OPC_CheckInteger, 62|128,2, 
 
1509
              OPC_MoveParent,
 
1510
              OPC_RecordChild1,
 
1511
              OPC_RecordChild2,
 
1512
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUBCUW), 0,
 
1513
                  1, MVT::v4i32, 2, 0, 1, 
 
1514
            15, 
 
1515
              OPC_CheckInteger, 63|128,2, 
 
1516
              OPC_MoveParent,
 
1517
              OPC_RecordChild1,
 
1518
              OPC_RecordChild2,
 
1519
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUBSBS), 0,
 
1520
                  1, MVT::v16i8, 2, 0, 1, 
 
1521
            15, 
 
1522
              OPC_CheckInteger, 64|128,2, 
 
1523
              OPC_MoveParent,
 
1524
              OPC_RecordChild1,
 
1525
              OPC_RecordChild2,
 
1526
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUBSHS), 0,
 
1527
                  1, MVT::v8i16, 2, 0, 1, 
 
1528
            15, 
 
1529
              OPC_CheckInteger, 65|128,2, 
 
1530
              OPC_MoveParent,
 
1531
              OPC_RecordChild1,
 
1532
              OPC_RecordChild2,
 
1533
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUBSWS), 0,
 
1534
                  1, MVT::v4i32, 2, 0, 1, 
 
1535
            15, 
 
1536
              OPC_CheckInteger, 66|128,2, 
 
1537
              OPC_MoveParent,
 
1538
              OPC_RecordChild1,
 
1539
              OPC_RecordChild2,
 
1540
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUBUBS), 0,
 
1541
                  1, MVT::v16i8, 2, 0, 1, 
 
1542
            15, 
 
1543
              OPC_CheckInteger, 67|128,2, 
 
1544
              OPC_MoveParent,
 
1545
              OPC_RecordChild1,
 
1546
              OPC_RecordChild2,
 
1547
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUBUHS), 0,
 
1548
                  1, MVT::v8i16, 2, 0, 1, 
 
1549
            15, 
 
1550
              OPC_CheckInteger, 68|128,2, 
 
1551
              OPC_MoveParent,
 
1552
              OPC_RecordChild1,
 
1553
              OPC_RecordChild2,
 
1554
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUBUWS), 0,
 
1555
                  1, MVT::v4i32, 2, 0, 1, 
 
1556
            15, 
 
1557
              OPC_CheckInteger, 73|128,2, 
 
1558
              OPC_MoveParent,
 
1559
              OPC_RecordChild1,
 
1560
              OPC_RecordChild2,
 
1561
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUMSWS), 0,
 
1562
                  1, MVT::v4i32, 2, 0, 1, 
 
1563
            15, 
 
1564
              OPC_CheckInteger, 69|128,2, 
 
1565
              OPC_MoveParent,
 
1566
              OPC_RecordChild1,
 
1567
              OPC_RecordChild2,
 
1568
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUM2SWS), 0,
 
1569
                  1, MVT::v4i32, 2, 0, 1, 
 
1570
            15, 
 
1571
              OPC_CheckInteger, 70|128,2, 
 
1572
              OPC_MoveParent,
 
1573
              OPC_RecordChild1,
 
1574
              OPC_RecordChild2,
 
1575
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUM4SBS), 0,
 
1576
                  1, MVT::v4i32, 2, 0, 1, 
 
1577
            15, 
 
1578
              OPC_CheckInteger, 71|128,2, 
 
1579
              OPC_MoveParent,
 
1580
              OPC_RecordChild1,
 
1581
              OPC_RecordChild2,
 
1582
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUM4SHS), 0,
 
1583
                  1, MVT::v4i32, 2, 0, 1, 
 
1584
            15, 
 
1585
              OPC_CheckInteger, 72|128,2, 
 
1586
              OPC_MoveParent,
 
1587
              OPC_RecordChild1,
 
1588
              OPC_RecordChild2,
 
1589
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUM4UBS), 0,
 
1590
                  1, MVT::v4i32, 2, 0, 1, 
 
1591
            15, 
 
1592
              OPC_CheckInteger, 44|128,2, 
 
1593
              OPC_MoveParent,
 
1594
              OPC_RecordChild1,
 
1595
              OPC_RecordChild2,
 
1596
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VRLB), 0,
 
1597
                  1, MVT::v16i8, 2, 0, 1, 
 
1598
            15, 
 
1599
              OPC_CheckInteger, 45|128,2, 
 
1600
              OPC_MoveParent,
 
1601
              OPC_RecordChild1,
 
1602
              OPC_RecordChild2,
 
1603
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VRLH), 0,
 
1604
                  1, MVT::v8i16, 2, 0, 1, 
 
1605
            15, 
 
1606
              OPC_CheckInteger, 46|128,2, 
 
1607
              OPC_MoveParent,
 
1608
              OPC_RecordChild1,
 
1609
              OPC_RecordChild2,
 
1610
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VRLW), 0,
 
1611
                  1, MVT::v4i32, 2, 0, 1, 
 
1612
            15, 
 
1613
              OPC_CheckInteger, 49|128,2, 
 
1614
              OPC_MoveParent,
 
1615
              OPC_RecordChild1,
 
1616
              OPC_RecordChild2,
 
1617
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSL), 0,
 
1618
                  1, MVT::v4i32, 2, 0, 1, 
 
1619
            15, 
 
1620
              OPC_CheckInteger, 52|128,2, 
 
1621
              OPC_MoveParent,
 
1622
              OPC_RecordChild1,
 
1623
              OPC_RecordChild2,
 
1624
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSLO), 0,
 
1625
                  1, MVT::v4i32, 2, 0, 1, 
 
1626
            15, 
 
1627
              OPC_CheckInteger, 50|128,2, 
 
1628
              OPC_MoveParent,
 
1629
              OPC_RecordChild1,
 
1630
              OPC_RecordChild2,
 
1631
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSLB), 0,
 
1632
                  1, MVT::v16i8, 2, 0, 1, 
 
1633
            15, 
 
1634
              OPC_CheckInteger, 51|128,2, 
 
1635
              OPC_MoveParent,
 
1636
              OPC_RecordChild1,
 
1637
              OPC_RecordChild2,
 
1638
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSLH), 0,
 
1639
                  1, MVT::v8i16, 2, 0, 1, 
 
1640
            15, 
 
1641
              OPC_CheckInteger, 53|128,2, 
 
1642
              OPC_MoveParent,
 
1643
              OPC_RecordChild1,
 
1644
              OPC_RecordChild2,
 
1645
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSLW), 0,
 
1646
                  1, MVT::v4i32, 2, 0, 1, 
 
1647
            15, 
 
1648
              OPC_CheckInteger, 54|128,2, 
 
1649
              OPC_MoveParent,
 
1650
              OPC_RecordChild1,
 
1651
              OPC_RecordChild2,
 
1652
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSR), 0,
 
1653
                  1, MVT::v4i32, 2, 0, 1, 
 
1654
            15, 
 
1655
              OPC_CheckInteger, 60|128,2, 
 
1656
              OPC_MoveParent,
 
1657
              OPC_RecordChild1,
 
1658
              OPC_RecordChild2,
 
1659
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSRO), 0,
 
1660
                  1, MVT::v4i32, 2, 0, 1, 
 
1661
            15, 
 
1662
              OPC_CheckInteger, 55|128,2, 
 
1663
              OPC_MoveParent,
 
1664
              OPC_RecordChild1,
 
1665
              OPC_RecordChild2,
 
1666
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSRAB), 0,
 
1667
                  1, MVT::v16i8, 2, 0, 1, 
 
1668
            15, 
 
1669
              OPC_CheckInteger, 56|128,2, 
 
1670
              OPC_MoveParent,
 
1671
              OPC_RecordChild1,
 
1672
              OPC_RecordChild2,
 
1673
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSRAH), 0,
 
1674
                  1, MVT::v8i16, 2, 0, 1, 
 
1675
            15, 
 
1676
              OPC_CheckInteger, 57|128,2, 
 
1677
              OPC_MoveParent,
 
1678
              OPC_RecordChild1,
 
1679
              OPC_RecordChild2,
 
1680
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSRAW), 0,
 
1681
                  1, MVT::v4i32, 2, 0, 1, 
 
1682
            15, 
 
1683
              OPC_CheckInteger, 58|128,2, 
 
1684
              OPC_MoveParent,
 
1685
              OPC_RecordChild1,
 
1686
              OPC_RecordChild2,
 
1687
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSRB), 0,
 
1688
                  1, MVT::v16i8, 2, 0, 1, 
 
1689
            15, 
 
1690
              OPC_CheckInteger, 59|128,2, 
 
1691
              OPC_MoveParent,
 
1692
              OPC_RecordChild1,
 
1693
              OPC_RecordChild2,
 
1694
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSRH), 0,
 
1695
                  1, MVT::v8i16, 2, 0, 1, 
 
1696
            15, 
 
1697
              OPC_CheckInteger, 61|128,2, 
 
1698
              OPC_MoveParent,
 
1699
              OPC_RecordChild1,
 
1700
              OPC_RecordChild2,
 
1701
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSRW), 0,
 
1702
                  1, MVT::v4i32, 2, 0, 1, 
 
1703
            15, 
 
1704
              OPC_CheckInteger, 32|128,2, 
 
1705
              OPC_MoveParent,
 
1706
              OPC_RecordChild1,
 
1707
              OPC_RecordChild2,
 
1708
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VPKPX), 0,
 
1709
                  1, MVT::v8i16, 2, 0, 1, 
 
1710
            15, 
 
1711
              OPC_CheckInteger, 33|128,2, 
 
1712
              OPC_MoveParent,
 
1713
              OPC_RecordChild1,
 
1714
              OPC_RecordChild2,
 
1715
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VPKSHSS), 0,
 
1716
                  1, MVT::v16i8, 2, 0, 1, 
 
1717
            15, 
 
1718
              OPC_CheckInteger, 34|128,2, 
 
1719
              OPC_MoveParent,
 
1720
              OPC_RecordChild1,
 
1721
              OPC_RecordChild2,
 
1722
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VPKSHUS), 0,
 
1723
                  1, MVT::v16i8, 2, 0, 1, 
 
1724
            15, 
 
1725
              OPC_CheckInteger, 35|128,2, 
 
1726
              OPC_MoveParent,
 
1727
              OPC_RecordChild1,
 
1728
              OPC_RecordChild2,
 
1729
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VPKSWSS), 0,
 
1730
                  1, MVT::v16i8, 2, 0, 1, 
 
1731
            15, 
 
1732
              OPC_CheckInteger, 36|128,2, 
 
1733
              OPC_MoveParent,
 
1734
              OPC_RecordChild1,
 
1735
              OPC_RecordChild2,
 
1736
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VPKSWUS), 0,
 
1737
                  1, MVT::v8i16, 2, 0, 1, 
 
1738
            15, 
 
1739
              OPC_CheckInteger, 37|128,2, 
 
1740
              OPC_MoveParent,
 
1741
              OPC_RecordChild1,
 
1742
              OPC_RecordChild2,
 
1743
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VPKUHUS), 0,
 
1744
                  1, MVT::v16i8, 2, 0, 1, 
 
1745
            15, 
 
1746
              OPC_CheckInteger, 38|128,2, 
 
1747
              OPC_MoveParent,
 
1748
              OPC_RecordChild1,
 
1749
              OPC_RecordChild2,
 
1750
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VPKUWUS), 0,
 
1751
                  1, MVT::v8i16, 2, 0, 1, 
 
1752
            13, 
 
1753
              OPC_CheckInteger, 74|128,2, 
 
1754
              OPC_MoveParent,
 
1755
              OPC_RecordChild1,
 
1756
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VUPKHPX), 0,
 
1757
                  1, MVT::v4i32, 1, 0, 
 
1758
            13, 
 
1759
              OPC_CheckInteger, 75|128,2, 
 
1760
              OPC_MoveParent,
 
1761
              OPC_RecordChild1,
 
1762
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VUPKHSB), 0,
 
1763
                  1, MVT::v8i16, 1, 0, 
 
1764
            13, 
 
1765
              OPC_CheckInteger, 76|128,2, 
 
1766
              OPC_MoveParent,
 
1767
              OPC_RecordChild1,
 
1768
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VUPKHSH), 0,
 
1769
                  1, MVT::v4i32, 1, 0, 
 
1770
            13, 
 
1771
              OPC_CheckInteger, 77|128,2, 
 
1772
              OPC_MoveParent,
 
1773
              OPC_RecordChild1,
 
1774
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VUPKLPX), 0,
 
1775
                  1, MVT::v4i32, 1, 0, 
 
1776
            13, 
 
1777
              OPC_CheckInteger, 78|128,2, 
 
1778
              OPC_MoveParent,
 
1779
              OPC_RecordChild1,
 
1780
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VUPKLSB), 0,
 
1781
                  1, MVT::v8i16, 1, 0, 
 
1782
            13, 
 
1783
              OPC_CheckInteger, 79|128,2, 
 
1784
              OPC_MoveParent,
 
1785
              OPC_RecordChild1,
 
1786
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VUPKLSH), 0,
 
1787
                  1, MVT::v4i32, 1, 0, 
 
1788
            17, 
 
1789
              OPC_CheckInteger, 126|128,1, 
 
1790
              OPC_MoveParent,
 
1791
              OPC_RecordChild1,
 
1792
              OPC_RecordChild2,
 
1793
              OPC_RecordChild3,
 
1794
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMADDFP), 0,
 
1795
                  1, MVT::v4f32, 3, 0, 1, 2, 
 
1796
            17, 
 
1797
              OPC_CheckInteger, 30|128,2, 
 
1798
              OPC_MoveParent,
 
1799
              OPC_RecordChild1,
 
1800
              OPC_RecordChild2,
 
1801
              OPC_RecordChild3,
 
1802
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VNMSUBFP), 0,
 
1803
                  1, MVT::v4f32, 3, 0, 1, 2, 
 
1804
            0, 
 
1805
          17|128,4,  ISD::ADD,
 
1806
            OPC_Scope, 42|128,1, 
 
1807
              OPC_RecordChild0,
 
1808
              OPC_MoveChild, 1,
 
1809
              OPC_SwitchOpcode , 23,  PPCISD::Lo,
 
1810
                OPC_RecordChild0,
 
1811
                OPC_MoveChild, 0,
 
1812
                OPC_CheckOpcode, ISD::TargetGlobalAddress,
 
1813
                OPC_MoveParent,
 
1814
                OPC_MoveChild, 1,
 
1815
                OPC_CheckInteger, 0, 
 
1816
                OPC_MoveParent,
 
1817
                OPC_MoveParent,
 
1818
                OPC_CheckType, MVT::i32,
 
1819
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LA), 0,
 
1820
                    1, MVT::i32, 2, 0, 1, 
 
1821
              9|128,1,  PPCISD::Hi,
 
1822
                OPC_RecordChild0,
 
1823
                OPC_MoveChild, 0,
 
1824
                OPC_SwitchOpcode , 31,  ISD::TargetGlobalAddress,
 
1825
                  OPC_MoveParent,
 
1826
                  OPC_MoveChild, 1,
 
1827
                  OPC_CheckInteger, 0, 
 
1828
                  OPC_MoveParent,
 
1829
                  OPC_MoveParent,
 
1830
                  OPC_SwitchType , 9,  MVT::i32,
 
1831
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS), 0,
 
1832
                        1, MVT::i32, 2, 0, 1, 
 
1833
                  9,  MVT::i64,
 
1834
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS8), 0,
 
1835
                        1, MVT::i64, 2, 0, 1, 
 
1836
                  0, 
 
1837
                31,  ISD::TargetConstantPool,
 
1838
                  OPC_MoveParent,
 
1839
                  OPC_MoveChild, 1,
 
1840
                  OPC_CheckInteger, 0, 
 
1841
                  OPC_MoveParent,
 
1842
                  OPC_MoveParent,
 
1843
                  OPC_SwitchType , 9,  MVT::i32,
 
1844
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS), 0,
 
1845
                        1, MVT::i32, 2, 0, 1, 
 
1846
                  9,  MVT::i64,
 
1847
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS8), 0,
 
1848
                        1, MVT::i64, 2, 0, 1, 
 
1849
                  0, 
 
1850
                31,  ISD::TargetJumpTable,
 
1851
                  OPC_MoveParent,
 
1852
                  OPC_MoveChild, 1,
 
1853
                  OPC_CheckInteger, 0, 
 
1854
                  OPC_MoveParent,
 
1855
                  OPC_MoveParent,
 
1856
                  OPC_SwitchType , 9,  MVT::i32,
 
1857
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS), 0,
 
1858
                        1, MVT::i32, 2, 0, 1, 
 
1859
                  9,  MVT::i64,
 
1860
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS8), 0,
 
1861
                        1, MVT::i64, 2, 0, 1, 
 
1862
                  0, 
 
1863
                31,  ISD::TargetBlockAddress,
 
1864
                  OPC_MoveParent,
 
1865
                  OPC_MoveChild, 1,
 
1866
                  OPC_CheckInteger, 0, 
 
1867
                  OPC_MoveParent,
 
1868
                  OPC_MoveParent,
 
1869
                  OPC_SwitchType , 9,  MVT::i32,
 
1870
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS), 0,
 
1871
                        1, MVT::i32, 2, 0, 1, 
 
1872
                  9,  MVT::i64,
 
1873
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS8), 0,
 
1874
                        1, MVT::i64, 2, 0, 1, 
 
1875
                  0, 
 
1876
                0, 
 
1877
              0, 
 
1878
            46|128,1, 
 
1879
              OPC_MoveChild, 0,
 
1880
              OPC_SwitchOpcode , 24,  PPCISD::Lo,
 
1881
                OPC_RecordChild0,
 
1882
                OPC_MoveChild, 0,
 
1883
                OPC_CheckOpcode, ISD::TargetGlobalAddress,
 
1884
                OPC_MoveParent,
 
1885
                OPC_MoveChild, 1,
 
1886
                OPC_CheckInteger, 0, 
 
1887
                OPC_MoveParent,
 
1888
                OPC_MoveParent,
 
1889
                OPC_RecordChild1,
 
1890
                OPC_CheckType, MVT::i32,
 
1891
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LA), 0,
 
1892
                    1, MVT::i32, 2, 1, 0, 
 
1893
              13|128,1,  PPCISD::Hi,
 
1894
                OPC_RecordChild0,
 
1895
                OPC_MoveChild, 0,
 
1896
                OPC_SwitchOpcode , 32,  ISD::TargetGlobalAddress,
 
1897
                  OPC_MoveParent,
 
1898
                  OPC_MoveChild, 1,
 
1899
                  OPC_CheckInteger, 0, 
 
1900
                  OPC_MoveParent,
 
1901
                  OPC_MoveParent,
 
1902
                  OPC_RecordChild1,
 
1903
                  OPC_SwitchType , 9,  MVT::i64,
 
1904
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS8), 0,
 
1905
                        1, MVT::i64, 2, 1, 0, 
 
1906
                  9,  MVT::i32,
 
1907
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS), 0,
 
1908
                        1, MVT::i32, 2, 1, 0, 
 
1909
                  0, 
 
1910
                32,  ISD::TargetConstantPool,
 
1911
                  OPC_MoveParent,
 
1912
                  OPC_MoveChild, 1,
 
1913
                  OPC_CheckInteger, 0, 
 
1914
                  OPC_MoveParent,
 
1915
                  OPC_MoveParent,
 
1916
                  OPC_RecordChild1,
 
1917
                  OPC_SwitchType , 9,  MVT::i64,
 
1918
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS8), 0,
 
1919
                        1, MVT::i64, 2, 1, 0, 
 
1920
                  9,  MVT::i32,
 
1921
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS), 0,
 
1922
                        1, MVT::i32, 2, 1, 0, 
 
1923
                  0, 
 
1924
                32,  ISD::TargetJumpTable,
 
1925
                  OPC_MoveParent,
 
1926
                  OPC_MoveChild, 1,
 
1927
                  OPC_CheckInteger, 0, 
 
1928
                  OPC_MoveParent,
 
1929
                  OPC_MoveParent,
 
1930
                  OPC_RecordChild1,
 
1931
                  OPC_SwitchType , 9,  MVT::i64,
 
1932
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS8), 0,
 
1933
                        1, MVT::i64, 2, 1, 0, 
 
1934
                  9,  MVT::i32,
 
1935
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS), 0,
 
1936
                        1, MVT::i32, 2, 1, 0, 
 
1937
                  0, 
 
1938
                32,  ISD::TargetBlockAddress,
 
1939
                  OPC_MoveParent,
 
1940
                  OPC_MoveChild, 1,
 
1941
                  OPC_CheckInteger, 0, 
 
1942
                  OPC_MoveParent,
 
1943
                  OPC_MoveParent,
 
1944
                  OPC_RecordChild1,
 
1945
                  OPC_SwitchType , 9,  MVT::i64,
 
1946
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS8), 0,
 
1947
                        1, MVT::i64, 2, 1, 0, 
 
1948
                  9,  MVT::i32,
 
1949
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS), 0,
 
1950
                        1, MVT::i32, 2, 1, 0, 
 
1951
                  0, 
 
1952
                0, 
 
1953
              0, 
 
1954
            49|128,1, 
 
1955
              OPC_RecordChild0,
 
1956
              OPC_RecordChild1,
 
1957
              OPC_Scope, 112, 
 
1958
                OPC_MoveChild, 1,
 
1959
                OPC_CheckOpcode, ISD::Constant,
 
1960
                OPC_Scope, 16, 
 
1961
                  OPC_CheckPredicate, 0,
 
1962
                  OPC_MoveParent,
 
1963
                  OPC_CheckType, MVT::i32,
 
1964
                  OPC_EmitConvertToTarget, 1,
 
1965
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDI), 0,
 
1966
                      1, MVT::i32, 2, 0, 2, 
 
1967
                19, 
 
1968
                  OPC_CheckPredicate, 1,
 
1969
                  OPC_MoveParent,
 
1970
                  OPC_CheckType, MVT::i32,
 
1971
                  OPC_EmitConvertToTarget, 1,
 
1972
                  OPC_EmitNodeXForm, 0, 2,
 
1973
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS), 0,
 
1974
                      1, MVT::i32, 2, 0, 3, 
 
1975
                16, 
 
1976
                  OPC_CheckPredicate, 0,
 
1977
                  OPC_MoveParent,
 
1978
                  OPC_CheckType, MVT::i64,
 
1979
                  OPC_EmitConvertToTarget, 1,
 
1980
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDI8), 0,
 
1981
                      1, MVT::i64, 2, 0, 2, 
 
1982
                19, 
 
1983
                  OPC_CheckPredicate, 1,
 
1984
                  OPC_MoveParent,
 
1985
                  OPC_CheckType, MVT::i64,
 
1986
                  OPC_EmitConvertToTarget, 1,
 
1987
                  OPC_EmitNodeXForm, 0, 2,
 
1988
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS8), 0,
 
1989
                      1, MVT::i64, 2, 0, 3, 
 
1990
                31, 
 
1991
                  OPC_MoveParent,
 
1992
                  OPC_CheckType, MVT::i32,
 
1993
                  OPC_EmitConvertToTarget, 1,
 
1994
                  OPC_EmitNodeXForm, 1, 2,
 
1995
                  OPC_EmitNode, TARGET_OPCODE(PPC::ADDI), 0,
 
1996
                      1, MVT::i32, 2, 0, 3, 
 
1997
                  OPC_EmitConvertToTarget, 1,
 
1998
                  OPC_EmitNodeXForm, 2, 5,
 
1999
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIS), 0,
 
2000
                      1, MVT::i32, 2, 4, 6, 
 
2001
                0, 
 
2002
              11, 
 
2003
                OPC_CheckType, MVT::i32,
 
2004
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADD4), 0,
 
2005
                    1, MVT::i32, 2, 0, 1, 
 
2006
              11, 
 
2007
                OPC_CheckType, MVT::v16i8,
 
2008
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VADDUBM), 0,
 
2009
                    1, MVT::v16i8, 2, 0, 1, 
 
2010
              11, 
 
2011
                OPC_CheckType, MVT::v8i16,
 
2012
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VADDUHM), 0,
 
2013
                    1, MVT::v8i16, 2, 0, 1, 
 
2014
              11, 
 
2015
                OPC_CheckType, MVT::v4i32,
 
2016
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VADDUWM), 0,
 
2017
                    1, MVT::v4i32, 2, 0, 1, 
 
2018
              11, 
 
2019
                OPC_CheckType, MVT::i64,
 
2020
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADD8), 0,
 
2021
                    1, MVT::i64, 2, 0, 1, 
 
2022
              0, 
 
2023
            0, 
 
2024
          12|128,8,  ISD::LOAD,
 
2025
            OPC_CheckPredicate, 2,
 
2026
            OPC_Scope, 24, 
 
2027
              OPC_CheckPredicate, 3,
 
2028
              OPC_CheckPredicate, 4,
 
2029
              OPC_RecordMemRef,
 
2030
              OPC_RecordNode,
 
2031
              OPC_RecordChild1,
 
2032
              OPC_CheckType, MVT::i32,
 
2033
              OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2034
              OPC_EmitMergeInputChains, 1, 0, 
 
2035
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZ), 0|OPFL_Chain|OPFL_MemRefs,
 
2036
                  1, MVT::i32, 2, 2, 3, 
 
2037
            24, 
 
2038
              OPC_CheckPredicate, 5,
 
2039
              OPC_CheckPredicate, 6,
 
2040
              OPC_RecordMemRef,
 
2041
              OPC_RecordNode,
 
2042
              OPC_RecordChild1,
 
2043
              OPC_CheckType, MVT::i32,
 
2044
              OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2045
              OPC_EmitMergeInputChains, 1, 0, 
 
2046
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LHA), 0|OPFL_Chain|OPFL_MemRefs,
 
2047
                  1, MVT::i32, 2, 2, 3, 
 
2048
            24, 
 
2049
              OPC_CheckPredicate, 3,
 
2050
              OPC_CheckPredicate, 7,
 
2051
              OPC_RecordMemRef,
 
2052
              OPC_RecordNode,
 
2053
              OPC_RecordChild1,
 
2054
              OPC_CheckType, MVT::i32,
 
2055
              OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2056
              OPC_EmitMergeInputChains, 1, 0, 
 
2057
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LHZ), 0|OPFL_Chain|OPFL_MemRefs,
 
2058
                  1, MVT::i32, 2, 2, 3, 
 
2059
            58, 
 
2060
              OPC_CheckPredicate, 8,
 
2061
              OPC_RecordMemRef,
 
2062
              OPC_RecordNode,
 
2063
              OPC_RecordChild1,
 
2064
              OPC_SwitchType , 15,  MVT::i32,
 
2065
                OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2066
                OPC_EmitMergeInputChains, 1, 0, 
 
2067
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LWZ), 0|OPFL_Chain|OPFL_MemRefs,
 
2068
                    1, MVT::i32, 2, 2, 3, 
 
2069
              15,  MVT::f32,
 
2070
                OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2071
                OPC_EmitMergeInputChains, 1, 0, 
 
2072
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LFS), 0|OPFL_Chain|OPFL_MemRefs,
 
2073
                    1, MVT::f32, 2, 2, 3, 
 
2074
              15,  MVT::f64,
 
2075
                OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2076
                OPC_EmitMergeInputChains, 1, 0, 
 
2077
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LFD), 0|OPFL_Chain|OPFL_MemRefs,
 
2078
                    1, MVT::f64, 2, 2, 3, 
 
2079
              0, 
 
2080
            24, 
 
2081
              OPC_CheckPredicate, 3,
 
2082
              OPC_CheckPredicate, 4,
 
2083
              OPC_RecordMemRef,
 
2084
              OPC_RecordNode,
 
2085
              OPC_RecordChild1,
 
2086
              OPC_CheckType, MVT::i32,
 
2087
              OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2088
              OPC_EmitMergeInputChains, 1, 0, 
 
2089
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZX), 0|OPFL_Chain|OPFL_MemRefs,
 
2090
                  1, MVT::i32, 2, 2, 3, 
 
2091
            24, 
 
2092
              OPC_CheckPredicate, 5,
 
2093
              OPC_CheckPredicate, 6,
 
2094
              OPC_RecordMemRef,
 
2095
              OPC_RecordNode,
 
2096
              OPC_RecordChild1,
 
2097
              OPC_CheckType, MVT::i32,
 
2098
              OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2099
              OPC_EmitMergeInputChains, 1, 0, 
 
2100
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LHAX), 0|OPFL_Chain|OPFL_MemRefs,
 
2101
                  1, MVT::i32, 2, 2, 3, 
 
2102
            24, 
 
2103
              OPC_CheckPredicate, 3,
 
2104
              OPC_CheckPredicate, 7,
 
2105
              OPC_RecordMemRef,
 
2106
              OPC_RecordNode,
 
2107
              OPC_RecordChild1,
 
2108
              OPC_CheckType, MVT::i32,
 
2109
              OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2110
              OPC_EmitMergeInputChains, 1, 0, 
 
2111
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LHZX), 0|OPFL_Chain|OPFL_MemRefs,
 
2112
                  1, MVT::i32, 2, 2, 3, 
 
2113
            58, 
 
2114
              OPC_CheckPredicate, 8,
 
2115
              OPC_RecordMemRef,
 
2116
              OPC_RecordNode,
 
2117
              OPC_RecordChild1,
 
2118
              OPC_SwitchType , 15,  MVT::i32,
 
2119
                OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2120
                OPC_EmitMergeInputChains, 1, 0, 
 
2121
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LWZX), 0|OPFL_Chain|OPFL_MemRefs,
 
2122
                    1, MVT::i32, 2, 2, 3, 
 
2123
              15,  MVT::f32,
 
2124
                OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2125
                OPC_EmitMergeInputChains, 1, 0, 
 
2126
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LFSX), 0|OPFL_Chain|OPFL_MemRefs,
 
2127
                    1, MVT::f32, 2, 2, 3, 
 
2128
              15,  MVT::f64,
 
2129
                OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2130
                OPC_EmitMergeInputChains, 1, 0, 
 
2131
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LFDX), 0|OPFL_Chain|OPFL_MemRefs,
 
2132
                    1, MVT::f64, 2, 2, 3, 
 
2133
              0, 
 
2134
            43, 
 
2135
              OPC_CheckPredicate, 3,
 
2136
              OPC_CheckPredicate, 9,
 
2137
              OPC_RecordMemRef,
 
2138
              OPC_RecordNode,
 
2139
              OPC_RecordChild1,
 
2140
              OPC_CheckType, MVT::i32,
 
2141
              OPC_Scope, 15, 
 
2142
                OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2143
                OPC_EmitMergeInputChains, 1, 0, 
 
2144
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZ), 0|OPFL_Chain|OPFL_MemRefs,
 
2145
                    1, MVT::i32, 2, 2, 3, 
 
2146
              15, 
 
2147
                OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2148
                OPC_EmitMergeInputChains, 1, 0, 
 
2149
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZX), 0|OPFL_Chain|OPFL_MemRefs,
 
2150
                    1, MVT::i32, 2, 2, 3, 
 
2151
              0, 
 
2152
            2|128,1, 
 
2153
              OPC_CheckPredicate, 10,
 
2154
              OPC_Scope, 41, 
 
2155
                OPC_CheckPredicate, 11,
 
2156
                OPC_RecordMemRef,
 
2157
                OPC_RecordNode,
 
2158
                OPC_RecordChild1,
 
2159
                OPC_CheckType, MVT::i32,
 
2160
                OPC_Scope, 15, 
 
2161
                  OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2162
                  OPC_EmitMergeInputChains, 1, 0, 
 
2163
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZ), 0|OPFL_Chain|OPFL_MemRefs,
 
2164
                      1, MVT::i32, 2, 2, 3, 
 
2165
                15, 
 
2166
                  OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2167
                  OPC_EmitMergeInputChains, 1, 0, 
 
2168
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZX), 0|OPFL_Chain|OPFL_MemRefs,
 
2169
                      1, MVT::i32, 2, 2, 3, 
 
2170
                0, 
 
2171
              41, 
 
2172
                OPC_CheckPredicate, 12,
 
2173
                OPC_RecordMemRef,
 
2174
                OPC_RecordNode,
 
2175
                OPC_RecordChild1,
 
2176
                OPC_CheckType, MVT::i32,
 
2177
                OPC_Scope, 15, 
 
2178
                  OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2179
                  OPC_EmitMergeInputChains, 1, 0, 
 
2180
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZ), 0|OPFL_Chain|OPFL_MemRefs,
 
2181
                      1, MVT::i32, 2, 2, 3, 
 
2182
                15, 
 
2183
                  OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2184
                  OPC_EmitMergeInputChains, 1, 0, 
 
2185
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZX), 0|OPFL_Chain|OPFL_MemRefs,
 
2186
                      1, MVT::i32, 2, 2, 3, 
 
2187
                0, 
 
2188
              41, 
 
2189
                OPC_CheckPredicate, 13,
 
2190
                OPC_RecordMemRef,
 
2191
                OPC_RecordNode,
 
2192
                OPC_RecordChild1,
 
2193
                OPC_CheckType, MVT::i32,
 
2194
                OPC_Scope, 15, 
 
2195
                  OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2196
                  OPC_EmitMergeInputChains, 1, 0, 
 
2197
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LHZ), 0|OPFL_Chain|OPFL_MemRefs,
 
2198
                      1, MVT::i32, 2, 2, 3, 
 
2199
                15, 
 
2200
                  OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2201
                  OPC_EmitMergeInputChains, 1, 0, 
 
2202
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LHZX), 0|OPFL_Chain|OPFL_MemRefs,
 
2203
                      1, MVT::i32, 2, 2, 3, 
 
2204
                0, 
 
2205
              0, 
 
2206
            22, 
 
2207
              OPC_CheckPredicate, 8,
 
2208
              OPC_RecordMemRef,
 
2209
              OPC_RecordNode,
 
2210
              OPC_RecordChild1,
 
2211
              OPC_CheckType, MVT::v4i32,
 
2212
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2213
              OPC_EmitMergeInputChains, 1, 0, 
 
2214
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LVX), 0|OPFL_Chain|OPFL_MemRefs,
 
2215
                  1, MVT::v4i32, 2, 2, 3, 
 
2216
            96, 
 
2217
              OPC_CheckPredicate, 5,
 
2218
              OPC_Scope, 22, 
 
2219
                OPC_CheckPredicate, 6,
 
2220
                OPC_RecordMemRef,
 
2221
                OPC_RecordNode,
 
2222
                OPC_RecordChild1,
 
2223
                OPC_CheckType, MVT::i64,
 
2224
                OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2225
                OPC_EmitMergeInputChains, 1, 0, 
 
2226
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LHA8), 0|OPFL_Chain|OPFL_MemRefs,
 
2227
                    1, MVT::i64, 2, 2, 3, 
 
2228
              22, 
 
2229
                OPC_CheckPredicate, 14,
 
2230
                OPC_RecordMemRef,
 
2231
                OPC_RecordNode,
 
2232
                OPC_RecordChild1,
 
2233
                OPC_CheckType, MVT::i64,
 
2234
                OPC_CheckComplexPat, /*CP*/3, /*#*/1,
 
2235
                OPC_EmitMergeInputChains, 1, 0, 
 
2236
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LWA), 0|OPFL_Chain|OPFL_MemRefs,
 
2237
                    1, MVT::i64, 2, 2, 3, 
 
2238
              22, 
 
2239
                OPC_CheckPredicate, 6,
 
2240
                OPC_RecordMemRef,
 
2241
                OPC_RecordNode,
 
2242
                OPC_RecordChild1,
 
2243
                OPC_CheckType, MVT::i64,
 
2244
                OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2245
                OPC_EmitMergeInputChains, 1, 0, 
 
2246
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LHAX8), 0|OPFL_Chain|OPFL_MemRefs,
 
2247
                    1, MVT::i64, 2, 2, 3, 
 
2248
              22, 
 
2249
                OPC_CheckPredicate, 14,
 
2250
                OPC_RecordMemRef,
 
2251
                OPC_RecordNode,
 
2252
                OPC_RecordChild1,
 
2253
                OPC_CheckType, MVT::i64,
 
2254
                OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2255
                OPC_EmitMergeInputChains, 1, 0, 
 
2256
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LWAX), 0|OPFL_Chain|OPFL_MemRefs,
 
2257
                    1, MVT::i64, 2, 2, 3, 
 
2258
              0, 
 
2259
            14|128,1, 
 
2260
              OPC_CheckPredicate, 3,
 
2261
              OPC_Scope, 22, 
 
2262
                OPC_CheckPredicate, 4,
 
2263
                OPC_RecordMemRef,
 
2264
                OPC_RecordNode,
 
2265
                OPC_RecordChild1,
 
2266
                OPC_CheckType, MVT::i64,
 
2267
                OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2268
                OPC_EmitMergeInputChains, 1, 0, 
 
2269
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZ8), 0|OPFL_Chain|OPFL_MemRefs,
 
2270
                    1, MVT::i64, 2, 2, 3, 
 
2271
              22, 
 
2272
                OPC_CheckPredicate, 7,
 
2273
                OPC_RecordMemRef,
 
2274
                OPC_RecordNode,
 
2275
                OPC_RecordChild1,
 
2276
                OPC_CheckType, MVT::i64,
 
2277
                OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2278
                OPC_EmitMergeInputChains, 1, 0, 
 
2279
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LHZ8), 0|OPFL_Chain|OPFL_MemRefs,
 
2280
                    1, MVT::i64, 2, 2, 3, 
 
2281
              22, 
 
2282
                OPC_CheckPredicate, 15,
 
2283
                OPC_RecordMemRef,
 
2284
                OPC_RecordNode,
 
2285
                OPC_RecordChild1,
 
2286
                OPC_CheckType, MVT::i64,
 
2287
                OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2288
                OPC_EmitMergeInputChains, 1, 0, 
 
2289
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LWZ8), 0|OPFL_Chain|OPFL_MemRefs,
 
2290
                    1, MVT::i64, 2, 2, 3, 
 
2291
              22, 
 
2292
                OPC_CheckPredicate, 4,
 
2293
                OPC_RecordMemRef,
 
2294
                OPC_RecordNode,
 
2295
                OPC_RecordChild1,
 
2296
                OPC_CheckType, MVT::i64,
 
2297
                OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2298
                OPC_EmitMergeInputChains, 1, 0, 
 
2299
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZX8), 0|OPFL_Chain|OPFL_MemRefs,
 
2300
                    1, MVT::i64, 2, 2, 3, 
 
2301
              22, 
 
2302
                OPC_CheckPredicate, 7,
 
2303
                OPC_RecordMemRef,
 
2304
                OPC_RecordNode,
 
2305
                OPC_RecordChild1,
 
2306
                OPC_CheckType, MVT::i64,
 
2307
                OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2308
                OPC_EmitMergeInputChains, 1, 0, 
 
2309
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LHZX8), 0|OPFL_Chain|OPFL_MemRefs,
 
2310
                    1, MVT::i64, 2, 2, 3, 
 
2311
              22, 
 
2312
                OPC_CheckPredicate, 15,
 
2313
                OPC_RecordMemRef,
 
2314
                OPC_RecordNode,
 
2315
                OPC_RecordChild1,
 
2316
                OPC_CheckType, MVT::i64,
 
2317
                OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2318
                OPC_EmitMergeInputChains, 1, 0, 
 
2319
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LWZX8), 0|OPFL_Chain|OPFL_MemRefs,
 
2320
                    1, MVT::i64, 2, 2, 3, 
 
2321
              0, 
 
2322
            41, 
 
2323
              OPC_CheckPredicate, 8,
 
2324
              OPC_RecordMemRef,
 
2325
              OPC_RecordNode,
 
2326
              OPC_RecordChild1,
 
2327
              OPC_CheckType, MVT::i64,
 
2328
              OPC_Scope, 15, 
 
2329
                OPC_CheckComplexPat, /*CP*/3, /*#*/1,
 
2330
                OPC_EmitMergeInputChains, 1, 0, 
 
2331
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LD), 0|OPFL_Chain|OPFL_MemRefs,
 
2332
                    1, MVT::i64, 2, 2, 3, 
 
2333
              15, 
 
2334
                OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2335
                OPC_EmitMergeInputChains, 1, 0, 
 
2336
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LDX), 0|OPFL_Chain|OPFL_MemRefs,
 
2337
                    1, MVT::i64, 2, 2, 3, 
 
2338
              0, 
 
2339
            43, 
 
2340
              OPC_CheckPredicate, 3,
 
2341
              OPC_CheckPredicate, 9,
 
2342
              OPC_RecordMemRef,
 
2343
              OPC_RecordNode,
 
2344
              OPC_RecordChild1,
 
2345
              OPC_CheckType, MVT::i64,
 
2346
              OPC_Scope, 15, 
 
2347
                OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2348
                OPC_EmitMergeInputChains, 1, 0, 
 
2349
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZ8), 0|OPFL_Chain|OPFL_MemRefs,
 
2350
                    1, MVT::i64, 2, 2, 3, 
 
2351
              15, 
 
2352
                OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2353
                OPC_EmitMergeInputChains, 1, 0, 
 
2354
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZX8), 0|OPFL_Chain|OPFL_MemRefs,
 
2355
                    1, MVT::i64, 2, 2, 3, 
 
2356
              0, 
 
2357
            108|128,1, 
 
2358
              OPC_CheckPredicate, 10,
 
2359
              OPC_Scope, 41, 
 
2360
                OPC_CheckPredicate, 11,
 
2361
                OPC_RecordMemRef,
 
2362
                OPC_RecordNode,
 
2363
                OPC_RecordChild1,
 
2364
                OPC_CheckType, MVT::i64,
 
2365
                OPC_Scope, 15, 
 
2366
                  OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2367
                  OPC_EmitMergeInputChains, 1, 0, 
 
2368
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZ8), 0|OPFL_Chain|OPFL_MemRefs,
 
2369
                      1, MVT::i64, 2, 2, 3, 
 
2370
                15, 
 
2371
                  OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2372
                  OPC_EmitMergeInputChains, 1, 0, 
 
2373
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZX8), 0|OPFL_Chain|OPFL_MemRefs,
 
2374
                      1, MVT::i64, 2, 2, 3, 
 
2375
                0, 
 
2376
              41, 
 
2377
                OPC_CheckPredicate, 12,
 
2378
                OPC_RecordMemRef,
 
2379
                OPC_RecordNode,
 
2380
                OPC_RecordChild1,
 
2381
                OPC_CheckType, MVT::i64,
 
2382
                OPC_Scope, 15, 
 
2383
                  OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2384
                  OPC_EmitMergeInputChains, 1, 0, 
 
2385
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZ8), 0|OPFL_Chain|OPFL_MemRefs,
 
2386
                      1, MVT::i64, 2, 2, 3, 
 
2387
                15, 
 
2388
                  OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2389
                  OPC_EmitMergeInputChains, 1, 0, 
 
2390
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LBZX8), 0|OPFL_Chain|OPFL_MemRefs,
 
2391
                      1, MVT::i64, 2, 2, 3, 
 
2392
                0, 
 
2393
              41, 
 
2394
                OPC_CheckPredicate, 13,
 
2395
                OPC_RecordMemRef,
 
2396
                OPC_RecordNode,
 
2397
                OPC_RecordChild1,
 
2398
                OPC_CheckType, MVT::i64,
 
2399
                OPC_Scope, 15, 
 
2400
                  OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2401
                  OPC_EmitMergeInputChains, 1, 0, 
 
2402
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LHZ8), 0|OPFL_Chain|OPFL_MemRefs,
 
2403
                      1, MVT::i64, 2, 2, 3, 
 
2404
                15, 
 
2405
                  OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2406
                  OPC_EmitMergeInputChains, 1, 0, 
 
2407
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LHZX8), 0|OPFL_Chain|OPFL_MemRefs,
 
2408
                      1, MVT::i64, 2, 2, 3, 
 
2409
                0, 
 
2410
              41, 
 
2411
                OPC_CheckPredicate, 16,
 
2412
                OPC_RecordMemRef,
 
2413
                OPC_RecordNode,
 
2414
                OPC_RecordChild1,
 
2415
                OPC_CheckType, MVT::i64,
 
2416
                OPC_Scope, 15, 
 
2417
                  OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2418
                  OPC_EmitMergeInputChains, 1, 0, 
 
2419
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LWZ8), 0|OPFL_Chain|OPFL_MemRefs,
 
2420
                      1, MVT::i64, 2, 2, 3, 
 
2421
                15, 
 
2422
                  OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2423
                  OPC_EmitMergeInputChains, 1, 0, 
 
2424
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::LWZX8), 0|OPFL_Chain|OPFL_MemRefs,
 
2425
                      1, MVT::i64, 2, 2, 3, 
 
2426
                0, 
 
2427
              63, 
 
2428
                OPC_CheckPredicate, 17,
 
2429
                OPC_RecordMemRef,
 
2430
                OPC_RecordNode,
 
2431
                OPC_RecordChild1,
 
2432
                OPC_CheckType, MVT::f64,
 
2433
                OPC_Scope, 26, 
 
2434
                  OPC_CheckComplexPat, /*CP*/1, /*#*/1,
 
2435
                  OPC_EmitMergeInputChains, 1, 0, 
 
2436
                  OPC_EmitNode, TARGET_OPCODE(PPC::LFS), 0|OPFL_Chain,
 
2437
                      1, MVT::f32, 2, 2, 3, 
 
2438
                  OPC_EmitNode, TARGET_OPCODE(PPC::FMRSD), 0|OPFL_MemRefs,
 
2439
                      1, MVT::f64, 1, 4, 
 
2440
                  OPC_CompleteMatch, 1, 5, 
 
2441
 
 
2442
                26, 
 
2443
                  OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
2444
                  OPC_EmitMergeInputChains, 1, 0, 
 
2445
                  OPC_EmitNode, TARGET_OPCODE(PPC::LFSX), 0|OPFL_Chain,
 
2446
                      1, MVT::f32, 2, 2, 3, 
 
2447
                  OPC_EmitNode, TARGET_OPCODE(PPC::FMRSD), 0|OPFL_MemRefs,
 
2448
                      1, MVT::f64, 1, 4, 
 
2449
                  OPC_CompleteMatch, 1, 5, 
 
2450
 
 
2451
                0, 
 
2452
              0, 
 
2453
            0, 
 
2454
          35|128,5,  ISD::STORE,
 
2455
            OPC_Scope, 68|128,3, 
 
2456
              OPC_CheckPredicate, 18,
 
2457
              OPC_Scope, 52, 
 
2458
                OPC_CheckPredicate, 19,
 
2459
                OPC_Scope, 23, 
 
2460
                  OPC_CheckPredicate, 20,
 
2461
                  OPC_RecordMemRef,
 
2462
                  OPC_RecordNode,
 
2463
                  OPC_RecordChild1,
 
2464
                  OPC_CheckChild1Type, MVT::i32,
 
2465
                  OPC_RecordChild2,
 
2466
                  OPC_CheckComplexPat, /*CP*/1, /*#*/2,
 
2467
                  OPC_EmitMergeInputChains, 1, 0, 
 
2468
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STB), 0|OPFL_Chain|OPFL_MemRefs,
 
2469
                      0, 3, 1, 3, 4, 
 
2470
                23, 
 
2471
                  OPC_CheckPredicate, 21,
 
2472
                  OPC_RecordMemRef,
 
2473
                  OPC_RecordNode,
 
2474
                  OPC_RecordChild1,
 
2475
                  OPC_CheckChild1Type, MVT::i32,
 
2476
                  OPC_RecordChild2,
 
2477
                  OPC_CheckComplexPat, /*CP*/1, /*#*/2,
 
2478
                  OPC_EmitMergeInputChains, 1, 0, 
 
2479
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STH), 0|OPFL_Chain|OPFL_MemRefs,
 
2480
                      0, 3, 1, 3, 4, 
 
2481
                0, 
 
2482
              64, 
 
2483
                OPC_CheckPredicate, 22,
 
2484
                OPC_RecordMemRef,
 
2485
                OPC_RecordNode,
 
2486
                OPC_RecordChild1,
 
2487
                OPC_Scope, 18, 
 
2488
                  OPC_CheckChild1Type, MVT::i32,
 
2489
                  OPC_RecordChild2,
 
2490
                  OPC_CheckComplexPat, /*CP*/1, /*#*/2,
 
2491
                  OPC_EmitMergeInputChains, 1, 0, 
 
2492
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STW), 0|OPFL_Chain|OPFL_MemRefs,
 
2493
                      0, 3, 1, 3, 4, 
 
2494
                18, 
 
2495
                  OPC_CheckChild1Type, MVT::f32,
 
2496
                  OPC_RecordChild2,
 
2497
                  OPC_CheckComplexPat, /*CP*/1, /*#*/2,
 
2498
                  OPC_EmitMergeInputChains, 1, 0, 
 
2499
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STFS), 0|OPFL_Chain|OPFL_MemRefs,
 
2500
                      0, 3, 1, 3, 4, 
 
2501
                18, 
 
2502
                  OPC_CheckChild1Type, MVT::f64,
 
2503
                  OPC_RecordChild2,
 
2504
                  OPC_CheckComplexPat, /*CP*/1, /*#*/2,
 
2505
                  OPC_EmitMergeInputChains, 1, 0, 
 
2506
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STFD), 0|OPFL_Chain|OPFL_MemRefs,
 
2507
                      0, 3, 1, 3, 4, 
 
2508
                0, 
 
2509
              52, 
 
2510
                OPC_CheckPredicate, 19,
 
2511
                OPC_Scope, 23, 
 
2512
                  OPC_CheckPredicate, 20,
 
2513
                  OPC_RecordMemRef,
 
2514
                  OPC_RecordNode,
 
2515
                  OPC_RecordChild1,
 
2516
                  OPC_CheckChild1Type, MVT::i32,
 
2517
                  OPC_RecordChild2,
 
2518
                  OPC_CheckComplexPat, /*CP*/2, /*#*/2,
 
2519
                  OPC_EmitMergeInputChains, 1, 0, 
 
2520
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STBX), 0|OPFL_Chain|OPFL_MemRefs,
 
2521
                      0, 3, 1, 3, 4, 
 
2522
                23, 
 
2523
                  OPC_CheckPredicate, 21,
 
2524
                  OPC_RecordMemRef,
 
2525
                  OPC_RecordNode,
 
2526
                  OPC_RecordChild1,
 
2527
                  OPC_CheckChild1Type, MVT::i32,
 
2528
                  OPC_RecordChild2,
 
2529
                  OPC_CheckComplexPat, /*CP*/2, /*#*/2,
 
2530
                  OPC_EmitMergeInputChains, 1, 0, 
 
2531
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STHX), 0|OPFL_Chain|OPFL_MemRefs,
 
2532
                      0, 3, 1, 3, 4, 
 
2533
                0, 
 
2534
              83, 
 
2535
                OPC_CheckPredicate, 22,
 
2536
                OPC_RecordMemRef,
 
2537
                OPC_RecordNode,
 
2538
                OPC_RecordChild1,
 
2539
                OPC_Scope, 18, 
 
2540
                  OPC_CheckChild1Type, MVT::i32,
 
2541
                  OPC_RecordChild2,
 
2542
                  OPC_CheckComplexPat, /*CP*/2, /*#*/2,
 
2543
                  OPC_EmitMergeInputChains, 1, 0, 
 
2544
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STWX), 0|OPFL_Chain|OPFL_MemRefs,
 
2545
                      0, 3, 1, 3, 4, 
 
2546
                18, 
 
2547
                  OPC_CheckChild1Type, MVT::f32,
 
2548
                  OPC_RecordChild2,
 
2549
                  OPC_CheckComplexPat, /*CP*/2, /*#*/2,
 
2550
                  OPC_EmitMergeInputChains, 1, 0, 
 
2551
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STFSX), 0|OPFL_Chain|OPFL_MemRefs,
 
2552
                      0, 3, 1, 3, 4, 
 
2553
                18, 
 
2554
                  OPC_CheckChild1Type, MVT::f64,
 
2555
                  OPC_RecordChild2,
 
2556
                  OPC_CheckComplexPat, /*CP*/2, /*#*/2,
 
2557
                  OPC_EmitMergeInputChains, 1, 0, 
 
2558
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STFDX), 0|OPFL_Chain|OPFL_MemRefs,
 
2559
                      0, 3, 1, 3, 4, 
 
2560
                18, 
 
2561
                  OPC_CheckChild1Type, MVT::v4i32,
 
2562
                  OPC_RecordChild2,
 
2563
                  OPC_CheckComplexPat, /*CP*/0, /*#*/2,
 
2564
                  OPC_EmitMergeInputChains, 1, 0, 
 
2565
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STVX), 0|OPFL_Chain|OPFL_MemRefs,
 
2566
                      0, 3, 1, 3, 4, 
 
2567
                0, 
 
2568
              20|128,1, 
 
2569
                OPC_CheckPredicate, 19,
 
2570
                OPC_Scope, 23, 
 
2571
                  OPC_CheckPredicate, 20,
 
2572
                  OPC_RecordMemRef,
 
2573
                  OPC_RecordNode,
 
2574
                  OPC_RecordChild1,
 
2575
                  OPC_CheckChild1Type, MVT::i64,
 
2576
                  OPC_RecordChild2,
 
2577
                  OPC_CheckComplexPat, /*CP*/1, /*#*/2,
 
2578
                  OPC_EmitMergeInputChains, 1, 0, 
 
2579
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STB8), 0|OPFL_Chain|OPFL_MemRefs,
 
2580
                      0, 3, 1, 3, 4, 
 
2581
                23, 
 
2582
                  OPC_CheckPredicate, 21,
 
2583
                  OPC_RecordMemRef,
 
2584
                  OPC_RecordNode,
 
2585
                  OPC_RecordChild1,
 
2586
                  OPC_CheckChild1Type, MVT::i64,
 
2587
                  OPC_RecordChild2,
 
2588
                  OPC_CheckComplexPat, /*CP*/1, /*#*/2,
 
2589
                  OPC_EmitMergeInputChains, 1, 0, 
 
2590
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STH8), 0|OPFL_Chain|OPFL_MemRefs,
 
2591
                      0, 3, 1, 3, 4, 
 
2592
                23, 
 
2593
                  OPC_CheckPredicate, 23,
 
2594
                  OPC_RecordMemRef,
 
2595
                  OPC_RecordNode,
 
2596
                  OPC_RecordChild1,
 
2597
                  OPC_CheckChild1Type, MVT::i64,
 
2598
                  OPC_RecordChild2,
 
2599
                  OPC_CheckComplexPat, /*CP*/1, /*#*/2,
 
2600
                  OPC_EmitMergeInputChains, 1, 0, 
 
2601
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STW8), 0|OPFL_Chain|OPFL_MemRefs,
 
2602
                      0, 3, 1, 3, 4, 
 
2603
                23, 
 
2604
                  OPC_CheckPredicate, 20,
 
2605
                  OPC_RecordMemRef,
 
2606
                  OPC_RecordNode,
 
2607
                  OPC_RecordChild1,
 
2608
                  OPC_CheckChild1Type, MVT::i64,
 
2609
                  OPC_RecordChild2,
 
2610
                  OPC_CheckComplexPat, /*CP*/2, /*#*/2,
 
2611
                  OPC_EmitMergeInputChains, 1, 0, 
 
2612
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STBX8), 0|OPFL_Chain|OPFL_MemRefs,
 
2613
                      0, 3, 1, 3, 4, 
 
2614
                23, 
 
2615
                  OPC_CheckPredicate, 21,
 
2616
                  OPC_RecordMemRef,
 
2617
                  OPC_RecordNode,
 
2618
                  OPC_RecordChild1,
 
2619
                  OPC_CheckChild1Type, MVT::i64,
 
2620
                  OPC_RecordChild2,
 
2621
                  OPC_CheckComplexPat, /*CP*/2, /*#*/2,
 
2622
                  OPC_EmitMergeInputChains, 1, 0, 
 
2623
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STHX8), 0|OPFL_Chain|OPFL_MemRefs,
 
2624
                      0, 3, 1, 3, 4, 
 
2625
                23, 
 
2626
                  OPC_CheckPredicate, 23,
 
2627
                  OPC_RecordMemRef,
 
2628
                  OPC_RecordNode,
 
2629
                  OPC_RecordChild1,
 
2630
                  OPC_CheckChild1Type, MVT::i64,
 
2631
                  OPC_RecordChild2,
 
2632
                  OPC_CheckComplexPat, /*CP*/2, /*#*/2,
 
2633
                  OPC_EmitMergeInputChains, 1, 0, 
 
2634
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STWX8), 0|OPFL_Chain|OPFL_MemRefs,
 
2635
                      0, 3, 1, 3, 4, 
 
2636
                0, 
 
2637
              42, 
 
2638
                OPC_CheckPredicate, 22,
 
2639
                OPC_RecordMemRef,
 
2640
                OPC_RecordNode,
 
2641
                OPC_RecordChild1,
 
2642
                OPC_CheckChild1Type, MVT::i64,
 
2643
                OPC_RecordChild2,
 
2644
                OPC_Scope, 15, 
 
2645
                  OPC_CheckComplexPat, /*CP*/3, /*#*/2,
 
2646
                  OPC_EmitMergeInputChains, 1, 0, 
 
2647
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STD), 0|OPFL_Chain|OPFL_MemRefs,
 
2648
                      0, 3, 1, 3, 4, 
 
2649
                15, 
 
2650
                  OPC_CheckComplexPat, /*CP*/2, /*#*/2,
 
2651
                  OPC_EmitMergeInputChains, 1, 0, 
 
2652
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::STDX), 0|OPFL_Chain|OPFL_MemRefs,
 
2653
                      0, 3, 1, 3, 4, 
 
2654
                0, 
 
2655
              0, 
 
2656
            58, 
 
2657
              OPC_CheckPredicate, 24,
 
2658
              OPC_CheckPredicate, 25,
 
2659
              OPC_Scope, 25, 
 
2660
                OPC_CheckPredicate, 26,
 
2661
                OPC_RecordMemRef,
 
2662
                OPC_RecordNode,
 
2663
                OPC_RecordChild1,
 
2664
                OPC_CheckChild1Type, MVT::i32,
 
2665
                OPC_RecordChild2,
 
2666
                OPC_RecordChild3,
 
2667
                OPC_CheckComplexPat, /*CP*/4, /*#*/3,
 
2668
                OPC_EmitMergeInputChains, 1, 0, 
 
2669
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::STBU), 0|OPFL_Chain|OPFL_MemRefs,
 
2670
                    1, MVT::iPTR, 3, 1, 4, 2, 
 
2671
              25, 
 
2672
                OPC_CheckPredicate, 27,
 
2673
                OPC_RecordMemRef,
 
2674
                OPC_RecordNode,
 
2675
                OPC_RecordChild1,
 
2676
                OPC_CheckChild1Type, MVT::i32,
 
2677
                OPC_RecordChild2,
 
2678
                OPC_RecordChild3,
 
2679
                OPC_CheckComplexPat, /*CP*/4, /*#*/3,
 
2680
                OPC_EmitMergeInputChains, 1, 0, 
 
2681
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::STHU), 0|OPFL_Chain|OPFL_MemRefs,
 
2682
                    1, MVT::iPTR, 3, 1, 4, 2, 
 
2683
              0, 
 
2684
            72, 
 
2685
              OPC_CheckPredicate, 28,
 
2686
              OPC_CheckPredicate, 29,
 
2687
              OPC_RecordMemRef,
 
2688
              OPC_RecordNode,
 
2689
              OPC_RecordChild1,
 
2690
              OPC_Scope, 20, 
 
2691
                OPC_CheckChild1Type, MVT::i32,
 
2692
                OPC_RecordChild2,
 
2693
                OPC_RecordChild3,
 
2694
                OPC_CheckComplexPat, /*CP*/4, /*#*/3,
 
2695
                OPC_EmitMergeInputChains, 1, 0, 
 
2696
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::STWU), 0|OPFL_Chain|OPFL_MemRefs,
 
2697
                    1, MVT::iPTR, 3, 1, 4, 2, 
 
2698
              20, 
 
2699
                OPC_CheckChild1Type, MVT::f32,
 
2700
                OPC_RecordChild2,
 
2701
                OPC_RecordChild3,
 
2702
                OPC_CheckComplexPat, /*CP*/4, /*#*/3,
 
2703
                OPC_EmitMergeInputChains, 1, 0, 
 
2704
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::STFSU), 0|OPFL_Chain|OPFL_MemRefs,
 
2705
                    1, MVT::iPTR, 3, 1, 4, 2, 
 
2706
              20, 
 
2707
                OPC_CheckChild1Type, MVT::f64,
 
2708
                OPC_RecordChild2,
 
2709
                OPC_RecordChild3,
 
2710
                OPC_CheckComplexPat, /*CP*/4, /*#*/3,
 
2711
                OPC_EmitMergeInputChains, 1, 0, 
 
2712
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::STFDU), 0|OPFL_Chain|OPFL_MemRefs,
 
2713
                    1, MVT::iPTR, 3, 1, 4, 2, 
 
2714
              0, 
 
2715
            58, 
 
2716
              OPC_CheckPredicate, 24,
 
2717
              OPC_CheckPredicate, 25,
 
2718
              OPC_Scope, 25, 
 
2719
                OPC_CheckPredicate, 26,
 
2720
                OPC_RecordMemRef,
 
2721
                OPC_RecordNode,
 
2722
                OPC_RecordChild1,
 
2723
                OPC_CheckChild1Type, MVT::i64,
 
2724
                OPC_RecordChild2,
 
2725
                OPC_RecordChild3,
 
2726
                OPC_CheckComplexPat, /*CP*/4, /*#*/3,
 
2727
                OPC_EmitMergeInputChains, 1, 0, 
 
2728
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::STBU8), 0|OPFL_Chain|OPFL_MemRefs,
 
2729
                    1, MVT::iPTR, 3, 1, 4, 2, 
 
2730
              25, 
 
2731
                OPC_CheckPredicate, 27,
 
2732
                OPC_RecordMemRef,
 
2733
                OPC_RecordNode,
 
2734
                OPC_RecordChild1,
 
2735
                OPC_CheckChild1Type, MVT::i64,
 
2736
                OPC_RecordChild2,
 
2737
                OPC_RecordChild3,
 
2738
                OPC_CheckComplexPat, /*CP*/4, /*#*/3,
 
2739
                OPC_EmitMergeInputChains, 1, 0, 
 
2740
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::STHU8), 0|OPFL_Chain|OPFL_MemRefs,
 
2741
                    1, MVT::iPTR, 3, 1, 4, 2, 
 
2742
              0, 
 
2743
            27, 
 
2744
              OPC_CheckPredicate, 28,
 
2745
              OPC_CheckPredicate, 29,
 
2746
              OPC_RecordMemRef,
 
2747
              OPC_RecordNode,
 
2748
              OPC_RecordChild1,
 
2749
              OPC_CheckChild1Type, MVT::i64,
 
2750
              OPC_RecordChild2,
 
2751
              OPC_RecordChild3,
 
2752
              OPC_CheckComplexPat, /*CP*/4, /*#*/3,
 
2753
              OPC_EmitMergeInputChains, 1, 0, 
 
2754
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::STDU), 0|OPFL_Chain|OPFL_MemRefs,
 
2755
                  1, MVT::iPTR, 3, 1, 4, 2, 
 
2756
            0, 
 
2757
          26|128,1,  ISD::FSUB,
 
2758
            OPC_Scope, 72, 
 
2759
              OPC_MoveChild, 0,
 
2760
              OPC_SwitchOpcode , 30,  ISD::BUILD_VECTOR,
 
2761
                OPC_CheckPredicate, 30,
 
2762
                OPC_MoveParent,
 
2763
                OPC_MoveChild, 1,
 
2764
                OPC_CheckOpcode, ISD::FSUB,
 
2765
                OPC_MoveChild, 0,
 
2766
                OPC_CheckOpcode, ISD::FMUL,
 
2767
                OPC_RecordChild0,
 
2768
                OPC_RecordChild1,
 
2769
                OPC_MoveParent,
 
2770
                OPC_RecordChild1,
 
2771
                OPC_MoveParent,
 
2772
                OPC_CheckType, MVT::v4f32,
 
2773
                OPC_CheckPatternPredicate, 0,
 
2774
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VNMSUBFP), 0,
 
2775
                    1, MVT::v4f32, 3, 0, 1, 2, 
 
2776
              34,  ISD::FMUL,
 
2777
                OPC_RecordChild0,
 
2778
                OPC_RecordChild1,
 
2779
                OPC_MoveParent,
 
2780
                OPC_RecordChild1,
 
2781
                OPC_SwitchType , 12,  MVT::f64,
 
2782
                  OPC_CheckPatternPredicate, 0,
 
2783
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FMSUB), 0,
 
2784
                      1, MVT::f64, 3, 0, 1, 2, 
 
2785
                12,  MVT::f32,
 
2786
                  OPC_CheckPatternPredicate, 0,
 
2787
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FMSUBS), 0,
 
2788
                      1, MVT::f32, 3, 0, 1, 2, 
 
2789
                0, 
 
2790
              0, 
 
2791
            78, 
 
2792
              OPC_RecordChild0,
 
2793
              OPC_Scope, 37, 
 
2794
                OPC_MoveChild, 1,
 
2795
                OPC_CheckOpcode, ISD::FMUL,
 
2796
                OPC_RecordChild0,
 
2797
                OPC_RecordChild1,
 
2798
                OPC_MoveParent,
 
2799
                OPC_SwitchType , 12,  MVT::f64,
 
2800
                  OPC_CheckPatternPredicate, 0,
 
2801
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FNMSUB), 0,
 
2802
                      1, MVT::f64, 3, 1, 2, 0, 
 
2803
                12,  MVT::f32,
 
2804
                  OPC_CheckPatternPredicate, 0,
 
2805
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FNMSUBS), 0,
 
2806
                      1, MVT::f32, 3, 1, 2, 0, 
 
2807
                0, 
 
2808
              36, 
 
2809
                OPC_RecordChild1,
 
2810
                OPC_SwitchType , 9,  MVT::f64,
 
2811
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FSUB), 0,
 
2812
                      1, MVT::f64, 2, 0, 1, 
 
2813
                9,  MVT::f32,
 
2814
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FSUBS), 0,
 
2815
                      1, MVT::f32, 2, 0, 1, 
 
2816
                9,  MVT::v4f32,
 
2817
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUBFP), 0,
 
2818
                      1, MVT::v4f32, 2, 0, 1, 
 
2819
                0, 
 
2820
              0, 
 
2821
            0, 
 
2822
          102,  ISD::ATOMIC_LOAD_ADD,
 
2823
            OPC_Scope, 24, 
 
2824
              OPC_CheckPredicate, 31,
 
2825
              OPC_RecordMemRef,
 
2826
              OPC_RecordNode,
 
2827
              OPC_RecordChild1,
 
2828
              OPC_RecordChild2,
 
2829
              OPC_CheckType, MVT::i32,
 
2830
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2831
              OPC_EmitMergeInputChains, 1, 0, 
 
2832
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_ADD_I8), 0|OPFL_Chain|OPFL_MemRefs,
 
2833
                  1, MVT::i32, 3, 3, 4, 2, 
 
2834
            24, 
 
2835
              OPC_CheckPredicate, 32,
 
2836
              OPC_RecordMemRef,
 
2837
              OPC_RecordNode,
 
2838
              OPC_RecordChild1,
 
2839
              OPC_RecordChild2,
 
2840
              OPC_CheckType, MVT::i32,
 
2841
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2842
              OPC_EmitMergeInputChains, 1, 0, 
 
2843
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_ADD_I16), 0|OPFL_Chain|OPFL_MemRefs,
 
2844
                  1, MVT::i32, 3, 3, 4, 2, 
 
2845
            24, 
 
2846
              OPC_CheckPredicate, 33,
 
2847
              OPC_RecordMemRef,
 
2848
              OPC_RecordNode,
 
2849
              OPC_RecordChild1,
 
2850
              OPC_RecordChild2,
 
2851
              OPC_CheckType, MVT::i32,
 
2852
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2853
              OPC_EmitMergeInputChains, 1, 0, 
 
2854
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_ADD_I32), 0|OPFL_Chain|OPFL_MemRefs,
 
2855
                  1, MVT::i32, 3, 3, 4, 2, 
 
2856
            24, 
 
2857
              OPC_CheckPredicate, 34,
 
2858
              OPC_RecordMemRef,
 
2859
              OPC_RecordNode,
 
2860
              OPC_RecordChild1,
 
2861
              OPC_RecordChild2,
 
2862
              OPC_CheckType, MVT::i64,
 
2863
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2864
              OPC_EmitMergeInputChains, 1, 0, 
 
2865
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_ADD_I64), 0|OPFL_Chain|OPFL_MemRefs,
 
2866
                  1, MVT::i64, 3, 3, 4, 2, 
 
2867
            0, 
 
2868
          102,  ISD::ATOMIC_LOAD_SUB,
 
2869
            OPC_Scope, 24, 
 
2870
              OPC_CheckPredicate, 35,
 
2871
              OPC_RecordMemRef,
 
2872
              OPC_RecordNode,
 
2873
              OPC_RecordChild1,
 
2874
              OPC_RecordChild2,
 
2875
              OPC_CheckType, MVT::i32,
 
2876
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2877
              OPC_EmitMergeInputChains, 1, 0, 
 
2878
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_SUB_I8), 0|OPFL_Chain|OPFL_MemRefs,
 
2879
                  1, MVT::i32, 3, 3, 4, 2, 
 
2880
            24, 
 
2881
              OPC_CheckPredicate, 36,
 
2882
              OPC_RecordMemRef,
 
2883
              OPC_RecordNode,
 
2884
              OPC_RecordChild1,
 
2885
              OPC_RecordChild2,
 
2886
              OPC_CheckType, MVT::i32,
 
2887
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2888
              OPC_EmitMergeInputChains, 1, 0, 
 
2889
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_SUB_I16), 0|OPFL_Chain|OPFL_MemRefs,
 
2890
                  1, MVT::i32, 3, 3, 4, 2, 
 
2891
            24, 
 
2892
              OPC_CheckPredicate, 37,
 
2893
              OPC_RecordMemRef,
 
2894
              OPC_RecordNode,
 
2895
              OPC_RecordChild1,
 
2896
              OPC_RecordChild2,
 
2897
              OPC_CheckType, MVT::i32,
 
2898
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2899
              OPC_EmitMergeInputChains, 1, 0, 
 
2900
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_SUB_I32), 0|OPFL_Chain|OPFL_MemRefs,
 
2901
                  1, MVT::i32, 3, 3, 4, 2, 
 
2902
            24, 
 
2903
              OPC_CheckPredicate, 38,
 
2904
              OPC_RecordMemRef,
 
2905
              OPC_RecordNode,
 
2906
              OPC_RecordChild1,
 
2907
              OPC_RecordChild2,
 
2908
              OPC_CheckType, MVT::i64,
 
2909
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2910
              OPC_EmitMergeInputChains, 1, 0, 
 
2911
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_SUB_I64), 0|OPFL_Chain|OPFL_MemRefs,
 
2912
                  1, MVT::i64, 3, 3, 4, 2, 
 
2913
            0, 
 
2914
          102,  ISD::ATOMIC_LOAD_AND,
 
2915
            OPC_Scope, 24, 
 
2916
              OPC_CheckPredicate, 39,
 
2917
              OPC_RecordMemRef,
 
2918
              OPC_RecordNode,
 
2919
              OPC_RecordChild1,
 
2920
              OPC_RecordChild2,
 
2921
              OPC_CheckType, MVT::i32,
 
2922
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2923
              OPC_EmitMergeInputChains, 1, 0, 
 
2924
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_AND_I8), 0|OPFL_Chain|OPFL_MemRefs,
 
2925
                  1, MVT::i32, 3, 3, 4, 2, 
 
2926
            24, 
 
2927
              OPC_CheckPredicate, 40,
 
2928
              OPC_RecordMemRef,
 
2929
              OPC_RecordNode,
 
2930
              OPC_RecordChild1,
 
2931
              OPC_RecordChild2,
 
2932
              OPC_CheckType, MVT::i32,
 
2933
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2934
              OPC_EmitMergeInputChains, 1, 0, 
 
2935
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_AND_I16), 0|OPFL_Chain|OPFL_MemRefs,
 
2936
                  1, MVT::i32, 3, 3, 4, 2, 
 
2937
            24, 
 
2938
              OPC_CheckPredicate, 41,
 
2939
              OPC_RecordMemRef,
 
2940
              OPC_RecordNode,
 
2941
              OPC_RecordChild1,
 
2942
              OPC_RecordChild2,
 
2943
              OPC_CheckType, MVT::i32,
 
2944
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2945
              OPC_EmitMergeInputChains, 1, 0, 
 
2946
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_AND_I32), 0|OPFL_Chain|OPFL_MemRefs,
 
2947
                  1, MVT::i32, 3, 3, 4, 2, 
 
2948
            24, 
 
2949
              OPC_CheckPredicate, 42,
 
2950
              OPC_RecordMemRef,
 
2951
              OPC_RecordNode,
 
2952
              OPC_RecordChild1,
 
2953
              OPC_RecordChild2,
 
2954
              OPC_CheckType, MVT::i64,
 
2955
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2956
              OPC_EmitMergeInputChains, 1, 0, 
 
2957
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_AND_I64), 0|OPFL_Chain|OPFL_MemRefs,
 
2958
                  1, MVT::i64, 3, 3, 4, 2, 
 
2959
            0, 
 
2960
          102,  ISD::ATOMIC_LOAD_OR,
 
2961
            OPC_Scope, 24, 
 
2962
              OPC_CheckPredicate, 43,
 
2963
              OPC_RecordMemRef,
 
2964
              OPC_RecordNode,
 
2965
              OPC_RecordChild1,
 
2966
              OPC_RecordChild2,
 
2967
              OPC_CheckType, MVT::i32,
 
2968
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2969
              OPC_EmitMergeInputChains, 1, 0, 
 
2970
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_OR_I8), 0|OPFL_Chain|OPFL_MemRefs,
 
2971
                  1, MVT::i32, 3, 3, 4, 2, 
 
2972
            24, 
 
2973
              OPC_CheckPredicate, 44,
 
2974
              OPC_RecordMemRef,
 
2975
              OPC_RecordNode,
 
2976
              OPC_RecordChild1,
 
2977
              OPC_RecordChild2,
 
2978
              OPC_CheckType, MVT::i32,
 
2979
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2980
              OPC_EmitMergeInputChains, 1, 0, 
 
2981
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_OR_I16), 0|OPFL_Chain|OPFL_MemRefs,
 
2982
                  1, MVT::i32, 3, 3, 4, 2, 
 
2983
            24, 
 
2984
              OPC_CheckPredicate, 45,
 
2985
              OPC_RecordMemRef,
 
2986
              OPC_RecordNode,
 
2987
              OPC_RecordChild1,
 
2988
              OPC_RecordChild2,
 
2989
              OPC_CheckType, MVT::i32,
 
2990
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
2991
              OPC_EmitMergeInputChains, 1, 0, 
 
2992
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_OR_I32), 0|OPFL_Chain|OPFL_MemRefs,
 
2993
                  1, MVT::i32, 3, 3, 4, 2, 
 
2994
            24, 
 
2995
              OPC_CheckPredicate, 46,
 
2996
              OPC_RecordMemRef,
 
2997
              OPC_RecordNode,
 
2998
              OPC_RecordChild1,
 
2999
              OPC_RecordChild2,
 
3000
              OPC_CheckType, MVT::i64,
 
3001
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3002
              OPC_EmitMergeInputChains, 1, 0, 
 
3003
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_OR_I64), 0|OPFL_Chain|OPFL_MemRefs,
 
3004
                  1, MVT::i64, 3, 3, 4, 2, 
 
3005
            0, 
 
3006
          102,  ISD::ATOMIC_LOAD_XOR,
 
3007
            OPC_Scope, 24, 
 
3008
              OPC_CheckPredicate, 47,
 
3009
              OPC_RecordMemRef,
 
3010
              OPC_RecordNode,
 
3011
              OPC_RecordChild1,
 
3012
              OPC_RecordChild2,
 
3013
              OPC_CheckType, MVT::i32,
 
3014
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3015
              OPC_EmitMergeInputChains, 1, 0, 
 
3016
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_XOR_I8), 0|OPFL_Chain|OPFL_MemRefs,
 
3017
                  1, MVT::i32, 3, 3, 4, 2, 
 
3018
            24, 
 
3019
              OPC_CheckPredicate, 48,
 
3020
              OPC_RecordMemRef,
 
3021
              OPC_RecordNode,
 
3022
              OPC_RecordChild1,
 
3023
              OPC_RecordChild2,
 
3024
              OPC_CheckType, MVT::i32,
 
3025
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3026
              OPC_EmitMergeInputChains, 1, 0, 
 
3027
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_XOR_I16), 0|OPFL_Chain|OPFL_MemRefs,
 
3028
                  1, MVT::i32, 3, 3, 4, 2, 
 
3029
            24, 
 
3030
              OPC_CheckPredicate, 49,
 
3031
              OPC_RecordMemRef,
 
3032
              OPC_RecordNode,
 
3033
              OPC_RecordChild1,
 
3034
              OPC_RecordChild2,
 
3035
              OPC_CheckType, MVT::i32,
 
3036
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3037
              OPC_EmitMergeInputChains, 1, 0, 
 
3038
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_XOR_I32), 0|OPFL_Chain|OPFL_MemRefs,
 
3039
                  1, MVT::i32, 3, 3, 4, 2, 
 
3040
            24, 
 
3041
              OPC_CheckPredicate, 50,
 
3042
              OPC_RecordMemRef,
 
3043
              OPC_RecordNode,
 
3044
              OPC_RecordChild1,
 
3045
              OPC_RecordChild2,
 
3046
              OPC_CheckType, MVT::i64,
 
3047
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3048
              OPC_EmitMergeInputChains, 1, 0, 
 
3049
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_XOR_I64), 0|OPFL_Chain|OPFL_MemRefs,
 
3050
                  1, MVT::i64, 3, 3, 4, 2, 
 
3051
            0, 
 
3052
          102,  ISD::ATOMIC_LOAD_NAND,
 
3053
            OPC_Scope, 24, 
 
3054
              OPC_CheckPredicate, 51,
 
3055
              OPC_RecordMemRef,
 
3056
              OPC_RecordNode,
 
3057
              OPC_RecordChild1,
 
3058
              OPC_RecordChild2,
 
3059
              OPC_CheckType, MVT::i32,
 
3060
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3061
              OPC_EmitMergeInputChains, 1, 0, 
 
3062
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_NAND_I8), 0|OPFL_Chain|OPFL_MemRefs,
 
3063
                  1, MVT::i32, 3, 3, 4, 2, 
 
3064
            24, 
 
3065
              OPC_CheckPredicate, 52,
 
3066
              OPC_RecordMemRef,
 
3067
              OPC_RecordNode,
 
3068
              OPC_RecordChild1,
 
3069
              OPC_RecordChild2,
 
3070
              OPC_CheckType, MVT::i32,
 
3071
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3072
              OPC_EmitMergeInputChains, 1, 0, 
 
3073
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_NAND_I16), 0|OPFL_Chain|OPFL_MemRefs,
 
3074
                  1, MVT::i32, 3, 3, 4, 2, 
 
3075
            24, 
 
3076
              OPC_CheckPredicate, 53,
 
3077
              OPC_RecordMemRef,
 
3078
              OPC_RecordNode,
 
3079
              OPC_RecordChild1,
 
3080
              OPC_RecordChild2,
 
3081
              OPC_CheckType, MVT::i32,
 
3082
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3083
              OPC_EmitMergeInputChains, 1, 0, 
 
3084
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_NAND_I32), 0|OPFL_Chain|OPFL_MemRefs,
 
3085
                  1, MVT::i32, 3, 3, 4, 2, 
 
3086
            24, 
 
3087
              OPC_CheckPredicate, 54,
 
3088
              OPC_RecordMemRef,
 
3089
              OPC_RecordNode,
 
3090
              OPC_RecordChild1,
 
3091
              OPC_RecordChild2,
 
3092
              OPC_CheckType, MVT::i64,
 
3093
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3094
              OPC_EmitMergeInputChains, 1, 0, 
 
3095
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_LOAD_NAND_I64), 0|OPFL_Chain|OPFL_MemRefs,
 
3096
                  1, MVT::i64, 3, 3, 4, 2, 
 
3097
            0, 
 
3098
          110,  ISD::ATOMIC_CMP_SWAP,
 
3099
            OPC_Scope, 26, 
 
3100
              OPC_CheckPredicate, 55,
 
3101
              OPC_RecordMemRef,
 
3102
              OPC_RecordNode,
 
3103
              OPC_RecordChild1,
 
3104
              OPC_RecordChild2,
 
3105
              OPC_RecordChild3,
 
3106
              OPC_CheckType, MVT::i32,
 
3107
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3108
              OPC_EmitMergeInputChains, 1, 0, 
 
3109
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_CMP_SWAP_I8), 0|OPFL_Chain|OPFL_MemRefs,
 
3110
                  1, MVT::i32, 4, 4, 5, 2, 3, 
 
3111
            26, 
 
3112
              OPC_CheckPredicate, 56,
 
3113
              OPC_RecordMemRef,
 
3114
              OPC_RecordNode,
 
3115
              OPC_RecordChild1,
 
3116
              OPC_RecordChild2,
 
3117
              OPC_RecordChild3,
 
3118
              OPC_CheckType, MVT::i32,
 
3119
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3120
              OPC_EmitMergeInputChains, 1, 0, 
 
3121
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_CMP_SWAP_I16), 0|OPFL_Chain|OPFL_MemRefs,
 
3122
                  1, MVT::i32, 4, 4, 5, 2, 3, 
 
3123
            26, 
 
3124
              OPC_CheckPredicate, 57,
 
3125
              OPC_RecordMemRef,
 
3126
              OPC_RecordNode,
 
3127
              OPC_RecordChild1,
 
3128
              OPC_RecordChild2,
 
3129
              OPC_RecordChild3,
 
3130
              OPC_CheckType, MVT::i32,
 
3131
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3132
              OPC_EmitMergeInputChains, 1, 0, 
 
3133
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_CMP_SWAP_I32), 0|OPFL_Chain|OPFL_MemRefs,
 
3134
                  1, MVT::i32, 4, 4, 5, 2, 3, 
 
3135
            26, 
 
3136
              OPC_CheckPredicate, 58,
 
3137
              OPC_RecordMemRef,
 
3138
              OPC_RecordNode,
 
3139
              OPC_RecordChild1,
 
3140
              OPC_RecordChild2,
 
3141
              OPC_RecordChild3,
 
3142
              OPC_CheckType, MVT::i64,
 
3143
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3144
              OPC_EmitMergeInputChains, 1, 0, 
 
3145
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_CMP_SWAP_I64), 0|OPFL_Chain|OPFL_MemRefs,
 
3146
                  1, MVT::i64, 4, 4, 5, 2, 3, 
 
3147
            0, 
 
3148
          102,  ISD::ATOMIC_SWAP,
 
3149
            OPC_Scope, 24, 
 
3150
              OPC_CheckPredicate, 59,
 
3151
              OPC_RecordMemRef,
 
3152
              OPC_RecordNode,
 
3153
              OPC_RecordChild1,
 
3154
              OPC_RecordChild2,
 
3155
              OPC_CheckType, MVT::i32,
 
3156
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3157
              OPC_EmitMergeInputChains, 1, 0, 
 
3158
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_SWAP_I8), 0|OPFL_Chain|OPFL_MemRefs,
 
3159
                  1, MVT::i32, 3, 3, 4, 2, 
 
3160
            24, 
 
3161
              OPC_CheckPredicate, 60,
 
3162
              OPC_RecordMemRef,
 
3163
              OPC_RecordNode,
 
3164
              OPC_RecordChild1,
 
3165
              OPC_RecordChild2,
 
3166
              OPC_CheckType, MVT::i32,
 
3167
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3168
              OPC_EmitMergeInputChains, 1, 0, 
 
3169
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_SWAP_I16), 0|OPFL_Chain|OPFL_MemRefs,
 
3170
                  1, MVT::i32, 3, 3, 4, 2, 
 
3171
            24, 
 
3172
              OPC_CheckPredicate, 61,
 
3173
              OPC_RecordMemRef,
 
3174
              OPC_RecordNode,
 
3175
              OPC_RecordChild1,
 
3176
              OPC_RecordChild2,
 
3177
              OPC_CheckType, MVT::i32,
 
3178
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3179
              OPC_EmitMergeInputChains, 1, 0, 
 
3180
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_SWAP_I32), 0|OPFL_Chain|OPFL_MemRefs,
 
3181
                  1, MVT::i32, 3, 3, 4, 2, 
 
3182
            24, 
 
3183
              OPC_CheckPredicate, 62,
 
3184
              OPC_RecordMemRef,
 
3185
              OPC_RecordNode,
 
3186
              OPC_RecordChild1,
 
3187
              OPC_RecordChild2,
 
3188
              OPC_CheckType, MVT::i64,
 
3189
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3190
              OPC_EmitMergeInputChains, 1, 0, 
 
3191
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ATOMIC_SWAP_I64), 0|OPFL_Chain|OPFL_MemRefs,
 
3192
                  1, MVT::i64, 3, 3, 4, 2, 
 
3193
            0, 
 
3194
          52,  PPCISD::DYNALLOC,
 
3195
            OPC_RecordNode,
 
3196
            OPC_RecordChild1,
 
3197
            OPC_Scope, 23, 
 
3198
              OPC_CheckChild1Type, MVT::i32,
 
3199
              OPC_RecordChild2,
 
3200
              OPC_CheckChild2Type, MVT::iPTR,
 
3201
              OPC_CheckType, MVT::i32,
 
3202
              OPC_CheckComplexPat, /*CP*/1, /*#*/2,
 
3203
              OPC_EmitMergeInputChains, 1, 0, 
 
3204
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DYNALLOC), 0|OPFL_Chain,
 
3205
                  1, MVT::i32, 3, 1, 3, 4, 
 
3206
            23, 
 
3207
              OPC_CheckChild1Type, MVT::i64,
 
3208
              OPC_RecordChild2,
 
3209
              OPC_CheckChild2Type, MVT::iPTR,
 
3210
              OPC_CheckType, MVT::i64,
 
3211
              OPC_CheckComplexPat, /*CP*/1, /*#*/2,
 
3212
              OPC_EmitMergeInputChains, 1, 0, 
 
3213
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DYNALLOC8), 0|OPFL_Chain,
 
3214
                  1, MVT::i64, 3, 1, 3, 4, 
 
3215
            0, 
 
3216
          38,  PPCISD::LARX,
 
3217
            OPC_RecordNode,
 
3218
            OPC_RecordChild1,
 
3219
            OPC_SwitchType , 15,  MVT::i32,
 
3220
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3221
              OPC_EmitMergeInputChains, 1, 0, 
 
3222
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LWARX), 0|OPFL_Chain,
 
3223
                  1, MVT::i32, 2, 2, 3, 
 
3224
            15,  MVT::i64,
 
3225
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3226
              OPC_EmitMergeInputChains, 1, 0, 
 
3227
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LDARX), 0|OPFL_Chain,
 
3228
                  1, MVT::i64, 2, 2, 3, 
 
3229
            0, 
 
3230
          42,  PPCISD::STCX,
 
3231
            OPC_RecordNode,
 
3232
            OPC_RecordChild1,
 
3233
            OPC_Scope, 18, 
 
3234
              OPC_CheckChild1Type, MVT::i32,
 
3235
              OPC_RecordChild2,
 
3236
              OPC_CheckComplexPat, /*CP*/0, /*#*/2,
 
3237
              OPC_EmitMergeInputChains, 1, 0, 
 
3238
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::STWCX), 0|OPFL_Chain,
 
3239
                  0, 3, 1, 3, 4, 
 
3240
            18, 
 
3241
              OPC_CheckChild1Type, MVT::i64,
 
3242
              OPC_RecordChild2,
 
3243
              OPC_CheckComplexPat, /*CP*/0, /*#*/2,
 
3244
              OPC_EmitMergeInputChains, 1, 0, 
 
3245
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::STDCX), 0|OPFL_Chain,
 
3246
                  0, 3, 1, 3, 4, 
 
3247
            0, 
 
3248
          44,  PPCISD::LBRX,
 
3249
            OPC_RecordNode,
 
3250
            OPC_RecordChild1,
 
3251
            OPC_MoveChild, 2,
 
3252
            OPC_Scope, 18, 
 
3253
              OPC_CheckValueType, MVT::i16,
 
3254
              OPC_MoveParent,
 
3255
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3256
              OPC_EmitMergeInputChains, 1, 0, 
 
3257
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LHBRX), 0|OPFL_Chain,
 
3258
                  1, MVT::i32, 2, 2, 3, 
 
3259
            18, 
 
3260
              OPC_CheckValueType, MVT::i32,
 
3261
              OPC_MoveParent,
 
3262
              OPC_CheckComplexPat, /*CP*/0, /*#*/1,
 
3263
              OPC_EmitMergeInputChains, 1, 0, 
 
3264
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LWBRX), 0|OPFL_Chain,
 
3265
                  1, MVT::i32, 2, 2, 3, 
 
3266
            0, 
 
3267
          45,  PPCISD::STBRX,
 
3268
            OPC_RecordNode,
 
3269
            OPC_RecordChild1,
 
3270
            OPC_RecordChild2,
 
3271
            OPC_MoveChild, 3,
 
3272
            OPC_Scope, 18, 
 
3273
              OPC_CheckValueType, MVT::i16,
 
3274
              OPC_MoveParent,
 
3275
              OPC_CheckComplexPat, /*CP*/0, /*#*/2,
 
3276
              OPC_EmitMergeInputChains, 1, 0, 
 
3277
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::STHBRX), 0|OPFL_Chain,
 
3278
                  0, 3, 1, 3, 4, 
 
3279
            18, 
 
3280
              OPC_CheckValueType, MVT::i32,
 
3281
              OPC_MoveParent,
 
3282
              OPC_CheckComplexPat, /*CP*/0, /*#*/2,
 
3283
              OPC_EmitMergeInputChains, 1, 0, 
 
3284
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::STWBRX), 0|OPFL_Chain,
 
3285
                  0, 3, 1, 3, 4, 
 
3286
            0, 
 
3287
          18,  PPCISD::STFIWX,
 
3288
            OPC_RecordNode,
 
3289
            OPC_RecordChild1,
 
3290
            OPC_RecordChild2,
 
3291
            OPC_CheckComplexPat, /*CP*/0, /*#*/2,
 
3292
            OPC_EmitMergeInputChains, 1, 0, 
 
3293
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::STFIWX), 0|OPFL_Chain,
 
3294
                0, 3, 1, 3, 4, 
 
3295
          41,  PPCISD::LOAD,
 
3296
            OPC_RecordNode,
 
3297
            OPC_CaptureFlagInput,
 
3298
            OPC_RecordChild1,
 
3299
            OPC_CheckChild1Type, MVT::iPTR,
 
3300
            OPC_CheckType, MVT::i64,
 
3301
            OPC_Scope, 15, 
 
3302
              OPC_CheckComplexPat, /*CP*/3, /*#*/1,
 
3303
              OPC_EmitMergeInputChains, 1, 0, 
 
3304
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LD), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput,
 
3305
                  1, MVT::i64, 2, 2, 3, 
 
3306
            15, 
 
3307
              OPC_CheckComplexPat, /*CP*/2, /*#*/1,
 
3308
              OPC_EmitMergeInputChains, 1, 0, 
 
3309
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LDX), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput,
 
3310
                  1, MVT::i64, 2, 2, 3, 
 
3311
            0, 
 
3312
          39,  PPCISD::STD_32,
 
3313
            OPC_RecordNode,
 
3314
            OPC_RecordChild1,
 
3315
            OPC_CheckChild1Type, MVT::i32,
 
3316
            OPC_RecordChild2,
 
3317
            OPC_Scope, 15, 
 
3318
              OPC_CheckComplexPat, /*CP*/3, /*#*/2,
 
3319
              OPC_EmitMergeInputChains, 1, 0, 
 
3320
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::STD_32), 0|OPFL_Chain,
 
3321
                  0, 3, 1, 3, 4, 
 
3322
            15, 
 
3323
              OPC_CheckComplexPat, /*CP*/2, /*#*/2,
 
3324
              OPC_EmitMergeInputChains, 1, 0, 
 
3325
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::STDX_32), 0|OPFL_Chain,
 
3326
                  0, 3, 1, 3, 4, 
 
3327
            0, 
 
3328
          127|128,4,  ISD::XOR,
 
3329
            OPC_Scope, 36|128,1, 
 
3330
              OPC_MoveChild, 0,
 
3331
              OPC_SwitchOpcode , 41,  ISD::AND,
 
3332
                OPC_RecordChild0,
 
3333
                OPC_RecordChild1,
 
3334
                OPC_MoveParent,
 
3335
                OPC_MoveChild, 1,
 
3336
                OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
3337
                OPC_MoveParent,
 
3338
                OPC_SwitchType , 9,  MVT::i32,
 
3339
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::NAND), 0,
 
3340
                      1, MVT::i32, 2, 0, 1, 
 
3341
                9,  MVT::i64,
 
3342
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::NAND8), 0,
 
3343
                      1, MVT::i64, 2, 0, 1, 
 
3344
                0, 
 
3345
              41,  ISD::OR,
 
3346
                OPC_RecordChild0,
 
3347
                OPC_RecordChild1,
 
3348
                OPC_MoveParent,
 
3349
                OPC_MoveChild, 1,
 
3350
                OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
3351
                OPC_MoveParent,
 
3352
                OPC_SwitchType , 9,  MVT::i32,
 
3353
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::NOR), 0,
 
3354
                      1, MVT::i32, 2, 0, 1, 
 
3355
                9,  MVT::i64,
 
3356
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::NOR8), 0,
 
3357
                      1, MVT::i64, 2, 0, 1, 
 
3358
                0, 
 
3359
              72,  ISD::XOR,
 
3360
                OPC_RecordChild0,
 
3361
                OPC_Scope, 40, 
 
3362
                  OPC_RecordChild1,
 
3363
                  OPC_MoveParent,
 
3364
                  OPC_MoveChild, 1,
 
3365
                  OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
3366
                  OPC_MoveParent,
 
3367
                  OPC_SwitchType , 9,  MVT::i32,
 
3368
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::EQV), 0,
 
3369
                        1, MVT::i32, 2, 0, 1, 
 
3370
                  9,  MVT::i64,
 
3371
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::EQV8), 0,
 
3372
                        1, MVT::i64, 2, 0, 1, 
 
3373
                  0, 
 
3374
                27, 
 
3375
                  OPC_MoveChild, 1,
 
3376
                  OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
3377
                  OPC_MoveParent,
 
3378
                  OPC_MoveParent,
 
3379
                  OPC_RecordChild1,
 
3380
                  OPC_CheckType, MVT::i32,
 
3381
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::EQV), 0,
 
3382
                      1, MVT::i32, 2, 0, 1, 
 
3383
                0, 
 
3384
              0, 
 
3385
            32, 
 
3386
              OPC_RecordChild0,
 
3387
              OPC_MoveChild, 1,
 
3388
              OPC_CheckOpcode, ISD::XOR,
 
3389
              OPC_RecordChild0,
 
3390
              OPC_MoveChild, 1,
 
3391
              OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
3392
              OPC_MoveParent,
 
3393
              OPC_MoveParent,
 
3394
              OPC_CheckType, MVT::i32,
 
3395
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::EQV), 0,
 
3396
                  1, MVT::i32, 2, 1, 0, 
 
3397
            32, 
 
3398
              OPC_MoveChild, 0,
 
3399
              OPC_CheckOpcode, ISD::XOR,
 
3400
              OPC_RecordChild0,
 
3401
              OPC_MoveChild, 1,
 
3402
              OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
3403
              OPC_MoveParent,
 
3404
              OPC_MoveParent,
 
3405
              OPC_RecordChild1,
 
3406
              OPC_CheckType, MVT::i64,
 
3407
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::EQV8), 0,
 
3408
                  1, MVT::i64, 2, 0, 1, 
 
3409
            32, 
 
3410
              OPC_RecordChild0,
 
3411
              OPC_MoveChild, 1,
 
3412
              OPC_CheckOpcode, ISD::XOR,
 
3413
              OPC_RecordChild0,
 
3414
              OPC_MoveChild, 1,
 
3415
              OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
3416
              OPC_MoveParent,
 
3417
              OPC_MoveParent,
 
3418
              OPC_CheckType, MVT::i64,
 
3419
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::EQV8), 0,
 
3420
                  1, MVT::i64, 2, 1, 0, 
 
3421
            91, 
 
3422
              OPC_MoveChild, 0,
 
3423
              OPC_SwitchOpcode , 39,  ISD::OR,
 
3424
                OPC_RecordChild0,
 
3425
                OPC_RecordChild1,
 
3426
                OPC_MoveParent,
 
3427
                OPC_MoveChild, 1,
 
3428
                OPC_SwitchOpcode , 14,  ISD::BUILD_VECTOR,
 
3429
                  OPC_CheckPredicate, 63,
 
3430
                  OPC_MoveParent,
 
3431
                  OPC_CheckType, MVT::v4i32,
 
3432
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::VNOR), 0,
 
3433
                      1, MVT::v4i32, 2, 0, 1, 
 
3434
                14,  ISD::BIT_CONVERT,
 
3435
                  OPC_CheckPredicate, 64,
 
3436
                  OPC_MoveParent,
 
3437
                  OPC_CheckType, MVT::v4i32,
 
3438
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::VNOR), 0,
 
3439
                      1, MVT::v4i32, 2, 0, 1, 
 
3440
                0, 
 
3441
              21,  ISD::BUILD_VECTOR,
 
3442
                OPC_CheckPredicate, 63,
 
3443
                OPC_MoveParent,
 
3444
                OPC_MoveChild, 1,
 
3445
                OPC_CheckOpcode, ISD::OR,
 
3446
                OPC_RecordChild0,
 
3447
                OPC_RecordChild1,
 
3448
                OPC_MoveParent,
 
3449
                OPC_CheckType, MVT::v4i32,
 
3450
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VNOR), 0,
 
3451
                    1, MVT::v4i32, 2, 0, 1, 
 
3452
              21,  ISD::BIT_CONVERT,
 
3453
                OPC_CheckPredicate, 64,
 
3454
                OPC_MoveParent,
 
3455
                OPC_MoveChild, 1,
 
3456
                OPC_CheckOpcode, ISD::OR,
 
3457
                OPC_RecordChild0,
 
3458
                OPC_RecordChild1,
 
3459
                OPC_MoveParent,
 
3460
                OPC_CheckType, MVT::v4i32,
 
3461
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VNOR), 0,
 
3462
                    1, MVT::v4i32, 2, 0, 1, 
 
3463
              0, 
 
3464
            34|128,1, 
 
3465
              OPC_RecordChild0,
 
3466
              OPC_Scope, 25, 
 
3467
                OPC_MoveChild, 1,
 
3468
                OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
3469
                OPC_MoveParent,
 
3470
                OPC_CheckType, MVT::i32,
 
3471
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::NOR), 0,
 
3472
                    1, MVT::i32, 2, 0, 0, 
 
3473
              47, 
 
3474
                OPC_RecordChild1,
 
3475
                OPC_MoveChild, 1,
 
3476
                OPC_CheckOpcode, ISD::Constant,
 
3477
                OPC_Scope, 19, 
 
3478
                  OPC_CheckPredicate, 65,
 
3479
                  OPC_MoveParent,
 
3480
                  OPC_CheckType, MVT::i32,
 
3481
                  OPC_EmitConvertToTarget, 1,
 
3482
                  OPC_EmitNodeXForm, 1, 2,
 
3483
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::XORI), 0,
 
3484
                      1, MVT::i32, 2, 0, 3, 
 
3485
                19, 
 
3486
                  OPC_CheckPredicate, 66,
 
3487
                  OPC_MoveParent,
 
3488
                  OPC_CheckType, MVT::i32,
 
3489
                  OPC_EmitConvertToTarget, 1,
 
3490
                  OPC_EmitNodeXForm, 0, 2,
 
3491
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::XORIS), 0,
 
3492
                      1, MVT::i32, 2, 0, 3, 
 
3493
                0, 
 
3494
              36, 
 
3495
                OPC_MoveChild, 1,
 
3496
                OPC_SwitchOpcode , 14,  ISD::BUILD_VECTOR,
 
3497
                  OPC_CheckPredicate, 63,
 
3498
                  OPC_MoveParent,
 
3499
                  OPC_CheckType, MVT::v4i32,
 
3500
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::VNOR), 0,
 
3501
                      1, MVT::v4i32, 2, 0, 0, 
 
3502
                14,  ISD::BIT_CONVERT,
 
3503
                  OPC_CheckPredicate, 64,
 
3504
                  OPC_MoveParent,
 
3505
                  OPC_CheckType, MVT::v4i32,
 
3506
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::VNOR), 0,
 
3507
                      1, MVT::v4i32, 2, 0, 0, 
 
3508
                0, 
 
3509
              47, 
 
3510
                OPC_RecordChild1,
 
3511
                OPC_MoveChild, 1,
 
3512
                OPC_CheckOpcode, ISD::Constant,
 
3513
                OPC_Scope, 19, 
 
3514
                  OPC_CheckPredicate, 65,
 
3515
                  OPC_MoveParent,
 
3516
                  OPC_CheckType, MVT::i64,
 
3517
                  OPC_EmitConvertToTarget, 1,
 
3518
                  OPC_EmitNodeXForm, 1, 2,
 
3519
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::XORI8), 0,
 
3520
                      1, MVT::i64, 2, 0, 3, 
 
3521
                19, 
 
3522
                  OPC_CheckPredicate, 66,
 
3523
                  OPC_MoveParent,
 
3524
                  OPC_CheckType, MVT::i64,
 
3525
                  OPC_EmitConvertToTarget, 1,
 
3526
                  OPC_EmitNodeXForm, 0, 2,
 
3527
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::XORIS8), 0,
 
3528
                      1, MVT::i64, 2, 0, 3, 
 
3529
                0, 
 
3530
              0, 
 
3531
            38, 
 
3532
              OPC_MoveChild, 0,
 
3533
              OPC_SwitchOpcode , 15,  ISD::BUILD_VECTOR,
 
3534
                OPC_CheckPredicate, 63,
 
3535
                OPC_MoveParent,
 
3536
                OPC_RecordChild1,
 
3537
                OPC_CheckType, MVT::v4i32,
 
3538
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VNOR), 0,
 
3539
                    1, MVT::v4i32, 2, 0, 0, 
 
3540
              15,  ISD::BIT_CONVERT,
 
3541
                OPC_CheckPredicate, 64,
 
3542
                OPC_MoveParent,
 
3543
                OPC_RecordChild1,
 
3544
                OPC_CheckType, MVT::v4i32,
 
3545
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VNOR), 0,
 
3546
                    1, MVT::v4i32, 2, 0, 0, 
 
3547
              0, 
 
3548
            76, 
 
3549
              OPC_RecordChild0,
 
3550
              OPC_RecordChild1,
 
3551
              OPC_Scope, 35, 
 
3552
                OPC_MoveChild, 1,
 
3553
                OPC_CheckOpcode, ISD::Constant,
 
3554
                OPC_MoveParent,
 
3555
                OPC_CheckType, MVT::i32,
 
3556
                OPC_EmitConvertToTarget, 1,
 
3557
                OPC_EmitNodeXForm, 1, 2,
 
3558
                OPC_EmitNode, TARGET_OPCODE(PPC::XORI), 0,
 
3559
                    1, MVT::i32, 2, 0, 3, 
 
3560
                OPC_EmitConvertToTarget, 1,
 
3561
                OPC_EmitNodeXForm, 0, 5,
 
3562
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::XORIS), 0,
 
3563
                    1, MVT::i32, 2, 4, 6, 
 
3564
              11, 
 
3565
                OPC_CheckType, MVT::i32,
 
3566
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::XOR), 0,
 
3567
                    1, MVT::i32, 2, 0, 1, 
 
3568
              11, 
 
3569
                OPC_CheckType, MVT::v4i32,
 
3570
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VXOR), 0,
 
3571
                    1, MVT::v4i32, 2, 0, 1, 
 
3572
              11, 
 
3573
                OPC_CheckType, MVT::i64,
 
3574
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::XOR8), 0,
 
3575
                    1, MVT::i64, 2, 0, 1, 
 
3576
              0, 
 
3577
            0, 
 
3578
          75|128,3,  ISD::AND,
 
3579
            OPC_Scope, 45, 
 
3580
              OPC_RecordChild0,
 
3581
              OPC_MoveChild, 1,
 
3582
              OPC_CheckOpcode, ISD::XOR,
 
3583
              OPC_RecordChild0,
 
3584
              OPC_MoveChild, 1,
 
3585
              OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
3586
              OPC_MoveParent,
 
3587
              OPC_MoveParent,
 
3588
              OPC_SwitchType , 9,  MVT::i32,
 
3589
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::ANDC), 0,
 
3590
                    1, MVT::i32, 2, 0, 1, 
 
3591
              9,  MVT::i64,
 
3592
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::ANDC8), 0,
 
3593
                    1, MVT::i64, 2, 0, 1, 
 
3594
              0, 
 
3595
            85, 
 
3596
              OPC_MoveChild, 0,
 
3597
              OPC_SwitchOpcode , 41,  ISD::XOR,
 
3598
                OPC_RecordChild0,
 
3599
                OPC_MoveChild, 1,
 
3600
                OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
3601
                OPC_MoveParent,
 
3602
                OPC_MoveParent,
 
3603
                OPC_RecordChild1,
 
3604
                OPC_SwitchType , 9,  MVT::i32,
 
3605
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ANDC), 0,
 
3606
                      1, MVT::i32, 2, 1, 0, 
 
3607
                9,  MVT::i64,
 
3608
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ANDC8), 0,
 
3609
                      1, MVT::i64, 2, 1, 0, 
 
3610
                0, 
 
3611
              36,  ISD::ROTL,
 
3612
                OPC_RecordChild0,
 
3613
                OPC_RecordChild1,
 
3614
                OPC_CheckChild1Type, MVT::i32,
 
3615
                OPC_MoveParent,
 
3616
                OPC_RecordChild1,
 
3617
                OPC_MoveChild, 1,
 
3618
                OPC_CheckOpcode, ISD::Constant,
 
3619
                OPC_CheckPredicate, 67,
 
3620
                OPC_MoveParent,
 
3621
                OPC_CheckType, MVT::i32,
 
3622
                OPC_EmitConvertToTarget, 2,
 
3623
                OPC_EmitNodeXForm, 3, 3,
 
3624
                OPC_EmitConvertToTarget, 2,
 
3625
                OPC_EmitNodeXForm, 4, 5,
 
3626
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::RLWNM), 0,
 
3627
                    1, MVT::i32, 4, 0, 1, 4, 6, 
 
3628
              0, 
 
3629
            68, 
 
3630
              OPC_RecordChild0,
 
3631
              OPC_MoveChild, 1,
 
3632
              OPC_CheckOpcode, ISD::XOR,
 
3633
              OPC_Scope, 39, 
 
3634
                OPC_RecordChild0,
 
3635
                OPC_MoveChild, 1,
 
3636
                OPC_SwitchOpcode , 15,  ISD::BUILD_VECTOR,
 
3637
                  OPC_CheckPredicate, 63,
 
3638
                  OPC_MoveParent,
 
3639
                  OPC_MoveParent,
 
3640
                  OPC_CheckType, MVT::v4i32,
 
3641
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::VANDC), 0,
 
3642
                      1, MVT::v4i32, 2, 0, 1, 
 
3643
                15,  ISD::BIT_CONVERT,
 
3644
                  OPC_CheckPredicate, 64,
 
3645
                  OPC_MoveParent,
 
3646
                  OPC_MoveParent,
 
3647
                  OPC_CheckType, MVT::v4i32,
 
3648
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::VANDC), 0,
 
3649
                      1, MVT::v4i32, 2, 0, 1, 
 
3650
                0, 
 
3651
              20, 
 
3652
                OPC_MoveChild, 0,
 
3653
                OPC_CheckOpcode, ISD::BUILD_VECTOR,
 
3654
                OPC_CheckPredicate, 63,
 
3655
                OPC_MoveParent,
 
3656
                OPC_RecordChild1,
 
3657
                OPC_MoveParent,
 
3658
                OPC_CheckType, MVT::v4i32,
 
3659
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VANDC), 0,
 
3660
                    1, MVT::v4i32, 2, 0, 1, 
 
3661
              0, 
 
3662
            50, 
 
3663
              OPC_MoveChild, 0,
 
3664
              OPC_CheckOpcode, ISD::XOR,
 
3665
              OPC_Scope, 21, 
 
3666
                OPC_RecordChild0,
 
3667
                OPC_MoveChild, 1,
 
3668
                OPC_CheckOpcode, ISD::BUILD_VECTOR,
 
3669
                OPC_CheckPredicate, 63,
 
3670
                OPC_MoveParent,
 
3671
                OPC_MoveParent,
 
3672
                OPC_RecordChild1,
 
3673
                OPC_CheckType, MVT::v4i32,
 
3674
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VANDC), 0,
 
3675
                    1, MVT::v4i32, 2, 1, 0, 
 
3676
              21, 
 
3677
                OPC_MoveChild, 0,
 
3678
                OPC_CheckOpcode, ISD::BUILD_VECTOR,
 
3679
                OPC_CheckPredicate, 63,
 
3680
                OPC_MoveParent,
 
3681
                OPC_RecordChild1,
 
3682
                OPC_MoveParent,
 
3683
                OPC_RecordChild1,
 
3684
                OPC_CheckType, MVT::v4i32,
 
3685
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VANDC), 0,
 
3686
                    1, MVT::v4i32, 2, 1, 0, 
 
3687
              0, 
 
3688
            25, 
 
3689
              OPC_RecordChild0,
 
3690
              OPC_MoveChild, 1,
 
3691
              OPC_CheckOpcode, ISD::XOR,
 
3692
              OPC_MoveChild, 0,
 
3693
              OPC_CheckOpcode, ISD::BIT_CONVERT,
 
3694
              OPC_CheckPredicate, 64,
 
3695
              OPC_MoveParent,
 
3696
              OPC_RecordChild1,
 
3697
              OPC_MoveParent,
 
3698
              OPC_CheckType, MVT::v4i32,
 
3699
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VANDC), 0,
 
3700
                  1, MVT::v4i32, 2, 0, 1, 
 
3701
            50, 
 
3702
              OPC_MoveChild, 0,
 
3703
              OPC_CheckOpcode, ISD::XOR,
 
3704
              OPC_Scope, 21, 
 
3705
                OPC_RecordChild0,
 
3706
                OPC_MoveChild, 1,
 
3707
                OPC_CheckOpcode, ISD::BIT_CONVERT,
 
3708
                OPC_CheckPredicate, 64,
 
3709
                OPC_MoveParent,
 
3710
                OPC_MoveParent,
 
3711
                OPC_RecordChild1,
 
3712
                OPC_CheckType, MVT::v4i32,
 
3713
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VANDC), 0,
 
3714
                    1, MVT::v4i32, 2, 1, 0, 
 
3715
              21, 
 
3716
                OPC_MoveChild, 0,
 
3717
                OPC_CheckOpcode, ISD::BIT_CONVERT,
 
3718
                OPC_CheckPredicate, 64,
 
3719
                OPC_MoveParent,
 
3720
                OPC_RecordChild1,
 
3721
                OPC_MoveParent,
 
3722
                OPC_RecordChild1,
 
3723
                OPC_CheckType, MVT::v4i32,
 
3724
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VANDC), 0,
 
3725
                    1, MVT::v4i32, 2, 1, 0, 
 
3726
              0, 
 
3727
            127, 
 
3728
              OPC_RecordChild0,
 
3729
              OPC_RecordChild1,
 
3730
              OPC_Scope, 86, 
 
3731
                OPC_MoveChild, 1,
 
3732
                OPC_CheckOpcode, ISD::Constant,
 
3733
                OPC_Scope, 19, 
 
3734
                  OPC_CheckPredicate, 65,
 
3735
                  OPC_MoveParent,
 
3736
                  OPC_CheckType, MVT::i32,
 
3737
                  OPC_EmitConvertToTarget, 1,
 
3738
                  OPC_EmitNodeXForm, 1, 2,
 
3739
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ANDIo), 0,
 
3740
                      1, MVT::i32, 2, 0, 3, 
 
3741
                19, 
 
3742
                  OPC_CheckPredicate, 66,
 
3743
                  OPC_MoveParent,
 
3744
                  OPC_CheckType, MVT::i32,
 
3745
                  OPC_EmitConvertToTarget, 1,
 
3746
                  OPC_EmitNodeXForm, 0, 2,
 
3747
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ANDISo), 0,
 
3748
                      1, MVT::i32, 2, 0, 3, 
 
3749
                19, 
 
3750
                  OPC_CheckPredicate, 65,
 
3751
                  OPC_MoveParent,
 
3752
                  OPC_CheckType, MVT::i64,
 
3753
                  OPC_EmitConvertToTarget, 1,
 
3754
                  OPC_EmitNodeXForm, 1, 2,
 
3755
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ANDIo8), 0,
 
3756
                      1, MVT::i64, 2, 0, 3, 
 
3757
                19, 
 
3758
                  OPC_CheckPredicate, 66,
 
3759
                  OPC_MoveParent,
 
3760
                  OPC_CheckType, MVT::i64,
 
3761
                  OPC_EmitConvertToTarget, 1,
 
3762
                  OPC_EmitNodeXForm, 0, 2,
 
3763
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ANDISo8), 0,
 
3764
                      1, MVT::i64, 2, 0, 3, 
 
3765
                0, 
 
3766
              11, 
 
3767
                OPC_CheckType, MVT::i32,
 
3768
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::AND), 0,
 
3769
                    1, MVT::i32, 2, 0, 1, 
 
3770
              11, 
 
3771
                OPC_CheckType, MVT::v4i32,
 
3772
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VAND), 0,
 
3773
                    1, MVT::v4i32, 2, 0, 1, 
 
3774
              11, 
 
3775
                OPC_CheckType, MVT::i64,
 
3776
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::AND8), 0,
 
3777
                    1, MVT::i64, 2, 0, 1, 
 
3778
              0, 
 
3779
            0, 
 
3780
          127|128,1,  ISD::OR,
 
3781
            OPC_Scope, 45, 
 
3782
              OPC_RecordChild0,
 
3783
              OPC_MoveChild, 1,
 
3784
              OPC_CheckOpcode, ISD::XOR,
 
3785
              OPC_RecordChild0,
 
3786
              OPC_MoveChild, 1,
 
3787
              OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
3788
              OPC_MoveParent,
 
3789
              OPC_MoveParent,
 
3790
              OPC_SwitchType , 9,  MVT::i32,
 
3791
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::ORC), 0,
 
3792
                    1, MVT::i32, 2, 0, 1, 
 
3793
              9,  MVT::i64,
 
3794
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::ORC8), 0,
 
3795
                    1, MVT::i64, 2, 0, 1, 
 
3796
              0, 
 
3797
            45, 
 
3798
              OPC_MoveChild, 0,
 
3799
              OPC_CheckOpcode, ISD::XOR,
 
3800
              OPC_RecordChild0,
 
3801
              OPC_MoveChild, 1,
 
3802
              OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
3803
              OPC_MoveParent,
 
3804
              OPC_MoveParent,
 
3805
              OPC_RecordChild1,
 
3806
              OPC_SwitchType , 9,  MVT::i32,
 
3807
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::ORC), 0,
 
3808
                    1, MVT::i32, 2, 1, 0, 
 
3809
              9,  MVT::i64,
 
3810
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::ORC8), 0,
 
3811
                    1, MVT::i64, 2, 1, 0, 
 
3812
              0, 
 
3813
            31|128,1, 
 
3814
              OPC_RecordChild0,
 
3815
              OPC_RecordChild1,
 
3816
              OPC_Scope, 118, 
 
3817
                OPC_MoveChild, 1,
 
3818
                OPC_CheckOpcode, ISD::Constant,
 
3819
                OPC_Scope, 19, 
 
3820
                  OPC_CheckPredicate, 65,
 
3821
                  OPC_MoveParent,
 
3822
                  OPC_CheckType, MVT::i32,
 
3823
                  OPC_EmitConvertToTarget, 1,
 
3824
                  OPC_EmitNodeXForm, 1, 2,
 
3825
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ORI), 0,
 
3826
                      1, MVT::i32, 2, 0, 3, 
 
3827
                19, 
 
3828
                  OPC_CheckPredicate, 66,
 
3829
                  OPC_MoveParent,
 
3830
                  OPC_CheckType, MVT::i32,
 
3831
                  OPC_EmitConvertToTarget, 1,
 
3832
                  OPC_EmitNodeXForm, 0, 2,
 
3833
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ORIS), 0,
 
3834
                      1, MVT::i32, 2, 0, 3, 
 
3835
                19, 
 
3836
                  OPC_CheckPredicate, 65,
 
3837
                  OPC_MoveParent,
 
3838
                  OPC_CheckType, MVT::i64,
 
3839
                  OPC_EmitConvertToTarget, 1,
 
3840
                  OPC_EmitNodeXForm, 1, 2,
 
3841
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ORI8), 0,
 
3842
                      1, MVT::i64, 2, 0, 3, 
 
3843
                19, 
 
3844
                  OPC_CheckPredicate, 66,
 
3845
                  OPC_MoveParent,
 
3846
                  OPC_CheckType, MVT::i64,
 
3847
                  OPC_EmitConvertToTarget, 1,
 
3848
                  OPC_EmitNodeXForm, 0, 2,
 
3849
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ORIS8), 0,
 
3850
                      1, MVT::i64, 2, 0, 3, 
 
3851
                31, 
 
3852
                  OPC_MoveParent,
 
3853
                  OPC_CheckType, MVT::i32,
 
3854
                  OPC_EmitConvertToTarget, 1,
 
3855
                  OPC_EmitNodeXForm, 1, 2,
 
3856
                  OPC_EmitNode, TARGET_OPCODE(PPC::ORI), 0,
 
3857
                      1, MVT::i32, 2, 0, 3, 
 
3858
                  OPC_EmitConvertToTarget, 1,
 
3859
                  OPC_EmitNodeXForm, 0, 5,
 
3860
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ORIS), 0,
 
3861
                      1, MVT::i32, 2, 4, 6, 
 
3862
                0, 
 
3863
              11, 
 
3864
                OPC_CheckType, MVT::i32,
 
3865
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::OR), 0,
 
3866
                    1, MVT::i32, 2, 0, 1, 
 
3867
              11, 
 
3868
                OPC_CheckType, MVT::v4i32,
 
3869
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VOR), 0,
 
3870
                    1, MVT::v4i32, 2, 0, 1, 
 
3871
              11, 
 
3872
                OPC_CheckType, MVT::i64,
 
3873
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::OR8), 0,
 
3874
                    1, MVT::i64, 2, 0, 1, 
 
3875
              0, 
 
3876
            0, 
 
3877
          125,  PPCISD::Hi,
 
3878
            OPC_RecordChild0,
 
3879
            OPC_MoveChild, 0,
 
3880
            OPC_SwitchOpcode , 28,  ISD::TargetGlobalAddress,
 
3881
              OPC_MoveParent,
 
3882
              OPC_MoveChild, 1,
 
3883
              OPC_CheckInteger, 0, 
 
3884
              OPC_MoveParent,
 
3885
              OPC_SwitchType , 8,  MVT::i32,
 
3886
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LIS), 0,
 
3887
                    1, MVT::i32, 1, 0, 
 
3888
              8,  MVT::i64,
 
3889
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LIS8), 0,
 
3890
                    1, MVT::i64, 1, 0, 
 
3891
              0, 
 
3892
            28,  ISD::TargetConstantPool,
 
3893
              OPC_MoveParent,
 
3894
              OPC_MoveChild, 1,
 
3895
              OPC_CheckInteger, 0, 
 
3896
              OPC_MoveParent,
 
3897
              OPC_SwitchType , 8,  MVT::i32,
 
3898
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LIS), 0,
 
3899
                    1, MVT::i32, 1, 0, 
 
3900
              8,  MVT::i64,
 
3901
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LIS8), 0,
 
3902
                    1, MVT::i64, 1, 0, 
 
3903
              0, 
 
3904
            28,  ISD::TargetJumpTable,
 
3905
              OPC_MoveParent,
 
3906
              OPC_MoveChild, 1,
 
3907
              OPC_CheckInteger, 0, 
 
3908
              OPC_MoveParent,
 
3909
              OPC_SwitchType , 8,  MVT::i32,
 
3910
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LIS), 0,
 
3911
                    1, MVT::i32, 1, 0, 
 
3912
              8,  MVT::i64,
 
3913
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LIS8), 0,
 
3914
                    1, MVT::i64, 1, 0, 
 
3915
              0, 
 
3916
            28,  ISD::TargetBlockAddress,
 
3917
              OPC_MoveParent,
 
3918
              OPC_MoveChild, 1,
 
3919
              OPC_CheckInteger, 0, 
 
3920
              OPC_MoveParent,
 
3921
              OPC_SwitchType , 8,  MVT::i32,
 
3922
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LIS), 0,
 
3923
                    1, MVT::i32, 1, 0, 
 
3924
              8,  MVT::i64,
 
3925
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LIS8), 0,
 
3926
                    1, MVT::i64, 1, 0, 
 
3927
              0, 
 
3928
            0, 
 
3929
          125,  PPCISD::Lo,
 
3930
            OPC_RecordChild0,
 
3931
            OPC_MoveChild, 0,
 
3932
            OPC_SwitchOpcode , 28,  ISD::TargetGlobalAddress,
 
3933
              OPC_MoveParent,
 
3934
              OPC_MoveChild, 1,
 
3935
              OPC_CheckInteger, 0, 
 
3936
              OPC_MoveParent,
 
3937
              OPC_SwitchType , 8,  MVT::i32,
 
3938
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LI), 0,
 
3939
                    1, MVT::i32, 1, 0, 
 
3940
              8,  MVT::i64,
 
3941
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LI8), 0,
 
3942
                    1, MVT::i64, 1, 0, 
 
3943
              0, 
 
3944
            28,  ISD::TargetConstantPool,
 
3945
              OPC_MoveParent,
 
3946
              OPC_MoveChild, 1,
 
3947
              OPC_CheckInteger, 0, 
 
3948
              OPC_MoveParent,
 
3949
              OPC_SwitchType , 8,  MVT::i32,
 
3950
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LI), 0,
 
3951
                    1, MVT::i32, 1, 0, 
 
3952
              8,  MVT::i64,
 
3953
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LI8), 0,
 
3954
                    1, MVT::i64, 1, 0, 
 
3955
              0, 
 
3956
            28,  ISD::TargetJumpTable,
 
3957
              OPC_MoveParent,
 
3958
              OPC_MoveChild, 1,
 
3959
              OPC_CheckInteger, 0, 
 
3960
              OPC_MoveParent,
 
3961
              OPC_SwitchType , 8,  MVT::i32,
 
3962
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LI), 0,
 
3963
                    1, MVT::i32, 1, 0, 
 
3964
              8,  MVT::i64,
 
3965
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LI8), 0,
 
3966
                    1, MVT::i64, 1, 0, 
 
3967
              0, 
 
3968
            28,  ISD::TargetBlockAddress,
 
3969
              OPC_MoveParent,
 
3970
              OPC_MoveChild, 1,
 
3971
              OPC_CheckInteger, 0, 
 
3972
              OPC_MoveParent,
 
3973
              OPC_SwitchType , 8,  MVT::i32,
 
3974
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LI), 0,
 
3975
                    1, MVT::i32, 1, 0, 
 
3976
              8,  MVT::i64,
 
3977
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::LI8), 0,
 
3978
                    1, MVT::i64, 1, 0, 
 
3979
              0, 
 
3980
            0, 
 
3981
          25,  ISD::CALLSEQ_END,
 
3982
            OPC_RecordNode,
 
3983
            OPC_CaptureFlagInput,
 
3984
            OPC_RecordChild1,
 
3985
            OPC_MoveChild, 1,
 
3986
            OPC_CheckOpcode, ISD::TargetConstant,
 
3987
            OPC_MoveParent,
 
3988
            OPC_RecordChild2,
 
3989
            OPC_MoveChild, 2,
 
3990
            OPC_CheckOpcode, ISD::TargetConstant,
 
3991
            OPC_MoveParent,
 
3992
            OPC_EmitMergeInputChains, 1, 0, 
 
3993
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADJCALLSTACKUP), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput,
 
3994
                0, 2, 1, 2, 
 
3995
          75|128,1,  PPCISD::TC_RETURN,
 
3996
            OPC_RecordNode,
 
3997
            OPC_CaptureFlagInput,
 
3998
            OPC_RecordChild1,
 
3999
            OPC_Scope, 24|128,1, 
 
4000
              OPC_MoveChild, 1,
 
4001
              OPC_SwitchOpcode , 50,  ISD::Constant,
 
4002
                OPC_SwitchType , 22,  MVT::i32,
 
4003
                  OPC_MoveParent,
 
4004
                  OPC_RecordChild2,
 
4005
                  OPC_MoveChild, 2,
 
4006
                  OPC_CheckOpcode, ISD::Constant,
 
4007
                  OPC_MoveParent,
 
4008
                  OPC_EmitMergeInputChains, 1, 0, 
 
4009
                  OPC_EmitConvertToTarget, 1,
 
4010
                  OPC_EmitConvertToTarget, 2,
 
4011
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::TCRETURNai), 0|OPFL_Chain|OPFL_FlagInput|OPFL_Variadic2,
 
4012
                      0, 2, 3, 4, 
 
4013
                22,  MVT::i64,
 
4014
                  OPC_MoveParent,
 
4015
                  OPC_RecordChild2,
 
4016
                  OPC_MoveChild, 2,
 
4017
                  OPC_CheckOpcode, ISD::Constant,
 
4018
                  OPC_MoveParent,
 
4019
                  OPC_EmitMergeInputChains, 1, 0, 
 
4020
                  OPC_EmitConvertToTarget, 1,
 
4021
                  OPC_EmitConvertToTarget, 2,
 
4022
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::TCRETURNai8), 0|OPFL_Chain|OPFL_FlagInput|OPFL_Variadic2,
 
4023
                      0, 2, 3, 4, 
 
4024
                0, 
 
4025
              46,  ISD::TargetGlobalAddress,
 
4026
                OPC_SwitchType , 20,  MVT::i32,
 
4027
                  OPC_MoveParent,
 
4028
                  OPC_RecordChild2,
 
4029
                  OPC_MoveChild, 2,
 
4030
                  OPC_CheckOpcode, ISD::Constant,
 
4031
                  OPC_MoveParent,
 
4032
                  OPC_EmitMergeInputChains, 1, 0, 
 
4033
                  OPC_EmitConvertToTarget, 2,
 
4034
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::TCRETURNdi), 0|OPFL_Chain|OPFL_FlagInput|OPFL_Variadic2,
 
4035
                      0, 2, 1, 3, 
 
4036
                20,  MVT::i64,
 
4037
                  OPC_MoveParent,
 
4038
                  OPC_RecordChild2,
 
4039
                  OPC_MoveChild, 2,
 
4040
                  OPC_CheckOpcode, ISD::Constant,
 
4041
                  OPC_MoveParent,
 
4042
                  OPC_EmitMergeInputChains, 1, 0, 
 
4043
                  OPC_EmitConvertToTarget, 2,
 
4044
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::TCRETURNdi8), 0|OPFL_Chain|OPFL_FlagInput|OPFL_Variadic2,
 
4045
                      0, 2, 1, 3, 
 
4046
                0, 
 
4047
              46,  ISD::TargetExternalSymbol,
 
4048
                OPC_SwitchType , 20,  MVT::i32,
 
4049
                  OPC_MoveParent,
 
4050
                  OPC_RecordChild2,
 
4051
                  OPC_MoveChild, 2,
 
4052
                  OPC_CheckOpcode, ISD::Constant,
 
4053
                  OPC_MoveParent,
 
4054
                  OPC_EmitMergeInputChains, 1, 0, 
 
4055
                  OPC_EmitConvertToTarget, 2,
 
4056
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::TCRETURNdi), 0|OPFL_Chain|OPFL_FlagInput|OPFL_Variadic2,
 
4057
                      0, 2, 1, 3, 
 
4058
                20,  MVT::i64,
 
4059
                  OPC_MoveParent,
 
4060
                  OPC_RecordChild2,
 
4061
                  OPC_MoveChild, 2,
 
4062
                  OPC_CheckOpcode, ISD::Constant,
 
4063
                  OPC_MoveParent,
 
4064
                  OPC_EmitMergeInputChains, 1, 0, 
 
4065
                  OPC_EmitConvertToTarget, 2,
 
4066
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::TCRETURNdi8), 0|OPFL_Chain|OPFL_FlagInput|OPFL_Variadic2,
 
4067
                      0, 2, 1, 3, 
 
4068
                0, 
 
4069
              0, 
 
4070
            21, 
 
4071
              OPC_CheckChild1Type, MVT::i32,
 
4072
              OPC_RecordChild2,
 
4073
              OPC_MoveChild, 2,
 
4074
              OPC_CheckOpcode, ISD::Constant,
 
4075
              OPC_MoveParent,
 
4076
              OPC_EmitMergeInputChains, 1, 0, 
 
4077
              OPC_EmitConvertToTarget, 2,
 
4078
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::TCRETURNri), 0|OPFL_Chain|OPFL_FlagInput|OPFL_Variadic2,
 
4079
                  0, 2, 1, 3, 
 
4080
            21, 
 
4081
              OPC_CheckChild1Type, MVT::i64,
 
4082
              OPC_RecordChild2,
 
4083
              OPC_MoveChild, 2,
 
4084
              OPC_CheckOpcode, ISD::Constant,
 
4085
              OPC_MoveParent,
 
4086
              OPC_EmitMergeInputChains, 1, 0, 
 
4087
              OPC_EmitConvertToTarget, 2,
 
4088
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::TCRETURNri8), 0|OPFL_Chain|OPFL_FlagInput|OPFL_Variadic2,
 
4089
                  0, 2, 1, 3, 
 
4090
            0, 
 
4091
          55|128,1,  ISD::FNEG,
 
4092
            OPC_Scope, 27|128,1, 
 
4093
              OPC_MoveChild, 0,
 
4094
              OPC_SwitchOpcode , 82,  ISD::FADD,
 
4095
                OPC_Scope, 39, 
 
4096
                  OPC_MoveChild, 0,
 
4097
                  OPC_CheckOpcode, ISD::FMUL,
 
4098
                  OPC_RecordChild0,
 
4099
                  OPC_RecordChild1,
 
4100
                  OPC_MoveParent,
 
4101
                  OPC_RecordChild1,
 
4102
                  OPC_MoveParent,
 
4103
                  OPC_SwitchType , 12,  MVT::f64,
 
4104
                    OPC_CheckPatternPredicate, 0,
 
4105
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::FNMADD), 0,
 
4106
                        1, MVT::f64, 3, 0, 1, 2, 
 
4107
                  12,  MVT::f32,
 
4108
                    OPC_CheckPatternPredicate, 0,
 
4109
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::FNMADDS), 0,
 
4110
                        1, MVT::f32, 3, 0, 1, 2, 
 
4111
                  0, 
 
4112
                39, 
 
4113
                  OPC_RecordChild0,
 
4114
                  OPC_MoveChild, 1,
 
4115
                  OPC_CheckOpcode, ISD::FMUL,
 
4116
                  OPC_RecordChild0,
 
4117
                  OPC_RecordChild1,
 
4118
                  OPC_MoveParent,
 
4119
                  OPC_MoveParent,
 
4120
                  OPC_SwitchType , 12,  MVT::f64,
 
4121
                    OPC_CheckPatternPredicate, 0,
 
4122
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::FNMADD), 0,
 
4123
                        1, MVT::f64, 3, 1, 2, 0, 
 
4124
                  12,  MVT::f32,
 
4125
                    OPC_CheckPatternPredicate, 0,
 
4126
                    OPC_MorphNodeTo, TARGET_OPCODE(PPC::FNMADDS), 0,
 
4127
                        1, MVT::f32, 3, 1, 2, 0, 
 
4128
                  0, 
 
4129
                0, 
 
4130
              39,  ISD::FSUB,
 
4131
                OPC_MoveChild, 0,
 
4132
                OPC_CheckOpcode, ISD::FMUL,
 
4133
                OPC_RecordChild0,
 
4134
                OPC_RecordChild1,
 
4135
                OPC_MoveParent,
 
4136
                OPC_RecordChild1,
 
4137
                OPC_MoveParent,
 
4138
                OPC_SwitchType , 12,  MVT::f64,
 
4139
                  OPC_CheckPatternPredicate, 0,
 
4140
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FNMSUB), 0,
 
4141
                      1, MVT::f64, 3, 0, 1, 2, 
 
4142
                12,  MVT::f32,
 
4143
                  OPC_CheckPatternPredicate, 0,
 
4144
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FNMSUBS), 0,
 
4145
                      1, MVT::f32, 3, 0, 1, 2, 
 
4146
                0, 
 
4147
              24,  ISD::FABS,
 
4148
                OPC_RecordChild0,
 
4149
                OPC_MoveParent,
 
4150
                OPC_SwitchType , 8,  MVT::f32,
 
4151
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FNABSS), 0,
 
4152
                      1, MVT::f32, 1, 0, 
 
4153
                8,  MVT::f64,
 
4154
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FNABSD), 0,
 
4155
                      1, MVT::f64, 1, 0, 
 
4156
                0, 
 
4157
              0, 
 
4158
            23, 
 
4159
              OPC_RecordChild0,
 
4160
              OPC_SwitchType , 8,  MVT::f32,
 
4161
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::FNEGS), 0,
 
4162
                    1, MVT::f32, 1, 0, 
 
4163
              8,  MVT::f64,
 
4164
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::FNEGD), 0,
 
4165
                    1, MVT::f64, 1, 0, 
 
4166
              0, 
 
4167
            0, 
 
4168
          116,  ISD::SUB,
 
4169
            OPC_Scope, 28, 
 
4170
              OPC_MoveChild, 0,
 
4171
              OPC_CheckInteger, 0, 
 
4172
              OPC_MoveParent,
 
4173
              OPC_RecordChild1,
 
4174
              OPC_SwitchType , 8,  MVT::i32,
 
4175
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::NEG), 0,
 
4176
                    1, MVT::i32, 1, 0, 
 
4177
              8,  MVT::i64,
 
4178
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::NEG8), 0,
 
4179
                    1, MVT::i64, 1, 0, 
 
4180
              0, 
 
4181
            84, 
 
4182
              OPC_RecordChild0,
 
4183
              OPC_Scope, 21, 
 
4184
                OPC_MoveChild, 0,
 
4185
                OPC_CheckOpcode, ISD::Constant,
 
4186
                OPC_CheckPredicate, 0,
 
4187
                OPC_MoveParent,
 
4188
                OPC_RecordChild1,
 
4189
                OPC_CheckType, MVT::i32,
 
4190
                OPC_EmitConvertToTarget, 0,
 
4191
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SUBFIC), 0,
 
4192
                    1, MVT::i32, 2, 1, 2, 
 
4193
              58, 
 
4194
                OPC_RecordChild1,
 
4195
                OPC_SwitchType , 9,  MVT::i32,
 
4196
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::SUBF), 0,
 
4197
                      1, MVT::i32, 2, 1, 0, 
 
4198
                9,  MVT::v16i8,
 
4199
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUBUBM), 0,
 
4200
                      1, MVT::v16i8, 2, 0, 1, 
 
4201
                9,  MVT::v8i16,
 
4202
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUBUHM), 0,
 
4203
                      1, MVT::v8i16, 2, 0, 1, 
 
4204
                9,  MVT::v4i32,
 
4205
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSUBUWM), 0,
 
4206
                      1, MVT::v4i32, 2, 0, 1, 
 
4207
                9,  MVT::i64,
 
4208
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::SUBF8), 0,
 
4209
                      1, MVT::i64, 2, 1, 0, 
 
4210
                0, 
 
4211
              0, 
 
4212
            0, 
 
4213
          96,  ISD::ADDE,
 
4214
            OPC_CaptureFlagInput,
 
4215
            OPC_RecordChild0,
 
4216
            OPC_Scope, 65, 
 
4217
              OPC_MoveChild, 1,
 
4218
              OPC_Scope, 34, 
 
4219
                OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
4220
                OPC_MoveParent,
 
4221
                OPC_SwitchType , 8,  MVT::i32,
 
4222
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDME), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4223
                      1, MVT::i32, 1, 0, 
 
4224
                8,  MVT::i64,
 
4225
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDME8), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4226
                      1, MVT::i64, 1, 0, 
 
4227
                0, 
 
4228
              25, 
 
4229
                OPC_CheckInteger, 0, 
 
4230
                OPC_MoveParent,
 
4231
                OPC_SwitchType , 8,  MVT::i32,
 
4232
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDZE), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4233
                      1, MVT::i32, 1, 0, 
 
4234
                8,  MVT::i64,
 
4235
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDZE8), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4236
                      1, MVT::i64, 1, 0, 
 
4237
                0, 
 
4238
              0, 
 
4239
            25, 
 
4240
              OPC_RecordChild1,
 
4241
              OPC_SwitchType , 9,  MVT::i32,
 
4242
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDE), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4243
                    1, MVT::i32, 2, 0, 1, 
 
4244
              9,  MVT::i64,
 
4245
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDE8), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4246
                    1, MVT::i64, 2, 0, 1, 
 
4247
              0, 
 
4248
            0, 
 
4249
          98,  ISD::SUBE,
 
4250
            OPC_CaptureFlagInput,
 
4251
            OPC_Scope, 67, 
 
4252
              OPC_MoveChild, 0,
 
4253
              OPC_Scope, 35, 
 
4254
                OPC_CheckInteger, 127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,127|128,1, 
 
4255
                OPC_MoveParent,
 
4256
                OPC_RecordChild1,
 
4257
                OPC_SwitchType , 8,  MVT::i32,
 
4258
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::SUBFME), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4259
                      1, MVT::i32, 1, 0, 
 
4260
                8,  MVT::i64,
 
4261
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::SUBFME8), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4262
                      1, MVT::i64, 1, 0, 
 
4263
                0, 
 
4264
              26, 
 
4265
                OPC_CheckInteger, 0, 
 
4266
                OPC_MoveParent,
 
4267
                OPC_RecordChild1,
 
4268
                OPC_SwitchType , 8,  MVT::i32,
 
4269
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::SUBFZE), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4270
                      1, MVT::i32, 1, 0, 
 
4271
                8,  MVT::i64,
 
4272
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::SUBFZE8), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4273
                      1, MVT::i64, 1, 0, 
 
4274
                0, 
 
4275
              0, 
 
4276
            26, 
 
4277
              OPC_RecordChild0,
 
4278
              OPC_RecordChild1,
 
4279
              OPC_SwitchType , 9,  MVT::i32,
 
4280
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SUBFE), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4281
                    1, MVT::i32, 2, 1, 0, 
 
4282
              9,  MVT::i64,
 
4283
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SUBFE8), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4284
                    1, MVT::i64, 2, 1, 0, 
 
4285
              0, 
 
4286
            0, 
 
4287
          84|128,1,  PPCISD::VCMP,
 
4288
            OPC_RecordChild0,
 
4289
            OPC_RecordChild1,
 
4290
            OPC_MoveChild, 2,
 
4291
            OPC_Scope, 15, 
 
4292
              OPC_CheckInteger, 70|128,7, 
 
4293
              OPC_MoveParent,
 
4294
              OPC_CheckType, MVT::v4f32,
 
4295
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPBFP), 0,
 
4296
                  1, MVT::v4f32, 2, 0, 1, 
 
4297
            15, 
 
4298
              OPC_CheckInteger, 70|128,1, 
 
4299
              OPC_MoveParent,
 
4300
              OPC_CheckType, MVT::v4f32,
 
4301
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPEQFP), 0,
 
4302
                  1, MVT::v4f32, 2, 0, 1, 
 
4303
            15, 
 
4304
              OPC_CheckInteger, 70|128,3, 
 
4305
              OPC_MoveParent,
 
4306
              OPC_CheckType, MVT::v4f32,
 
4307
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGEFP), 0,
 
4308
                  1, MVT::v4f32, 2, 0, 1, 
 
4309
            15, 
 
4310
              OPC_CheckInteger, 70|128,5, 
 
4311
              OPC_MoveParent,
 
4312
              OPC_CheckType, MVT::v4f32,
 
4313
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTFP), 0,
 
4314
                  1, MVT::v4f32, 2, 0, 1, 
 
4315
            14, 
 
4316
              OPC_CheckInteger, 6, 
 
4317
              OPC_MoveParent,
 
4318
              OPC_CheckType, MVT::v16i8,
 
4319
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPEQUB), 0,
 
4320
                  1, MVT::v16i8, 2, 0, 1, 
 
4321
            15, 
 
4322
              OPC_CheckInteger, 6|128,6, 
 
4323
              OPC_MoveParent,
 
4324
              OPC_CheckType, MVT::v16i8,
 
4325
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTSB), 0,
 
4326
                  1, MVT::v16i8, 2, 0, 1, 
 
4327
            15, 
 
4328
              OPC_CheckInteger, 6|128,4, 
 
4329
              OPC_MoveParent,
 
4330
              OPC_CheckType, MVT::v16i8,
 
4331
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTUB), 0,
 
4332
                  1, MVT::v16i8, 2, 0, 1, 
 
4333
            14, 
 
4334
              OPC_CheckInteger, 70, 
 
4335
              OPC_MoveParent,
 
4336
              OPC_CheckType, MVT::v8i16,
 
4337
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPEQUH), 0,
 
4338
                  1, MVT::v8i16, 2, 0, 1, 
 
4339
            15, 
 
4340
              OPC_CheckInteger, 70|128,6, 
 
4341
              OPC_MoveParent,
 
4342
              OPC_CheckType, MVT::v8i16,
 
4343
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTSH), 0,
 
4344
                  1, MVT::v8i16, 2, 0, 1, 
 
4345
            15, 
 
4346
              OPC_CheckInteger, 70|128,4, 
 
4347
              OPC_MoveParent,
 
4348
              OPC_CheckType, MVT::v8i16,
 
4349
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTUH), 0,
 
4350
                  1, MVT::v8i16, 2, 0, 1, 
 
4351
            15, 
 
4352
              OPC_CheckInteger, 6|128,1, 
 
4353
              OPC_MoveParent,
 
4354
              OPC_CheckType, MVT::v4i32,
 
4355
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPEQUW), 0,
 
4356
                  1, MVT::v4i32, 2, 0, 1, 
 
4357
            15, 
 
4358
              OPC_CheckInteger, 6|128,7, 
 
4359
              OPC_MoveParent,
 
4360
              OPC_CheckType, MVT::v4i32,
 
4361
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTSW), 0,
 
4362
                  1, MVT::v4i32, 2, 0, 1, 
 
4363
            15, 
 
4364
              OPC_CheckInteger, 6|128,5, 
 
4365
              OPC_MoveParent,
 
4366
              OPC_CheckType, MVT::v4i32,
 
4367
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTUW), 0,
 
4368
                  1, MVT::v4i32, 2, 0, 1, 
 
4369
            0, 
 
4370
          84|128,1,  PPCISD::VCMPo,
 
4371
            OPC_RecordChild0,
 
4372
            OPC_RecordChild1,
 
4373
            OPC_MoveChild, 2,
 
4374
            OPC_Scope, 15, 
 
4375
              OPC_CheckInteger, 70|128,7, 
 
4376
              OPC_MoveParent,
 
4377
              OPC_CheckType, MVT::v4f32,
 
4378
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPBFPo), 0|OPFL_FlagOutput,
 
4379
                  1, MVT::v4f32, 2, 0, 1, 
 
4380
            15, 
 
4381
              OPC_CheckInteger, 70|128,1, 
 
4382
              OPC_MoveParent,
 
4383
              OPC_CheckType, MVT::v4f32,
 
4384
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPEQFPo), 0|OPFL_FlagOutput,
 
4385
                  1, MVT::v4f32, 2, 0, 1, 
 
4386
            15, 
 
4387
              OPC_CheckInteger, 70|128,3, 
 
4388
              OPC_MoveParent,
 
4389
              OPC_CheckType, MVT::v4f32,
 
4390
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGEFPo), 0|OPFL_FlagOutput,
 
4391
                  1, MVT::v4f32, 2, 0, 1, 
 
4392
            15, 
 
4393
              OPC_CheckInteger, 70|128,5, 
 
4394
              OPC_MoveParent,
 
4395
              OPC_CheckType, MVT::v4f32,
 
4396
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTFPo), 0|OPFL_FlagOutput,
 
4397
                  1, MVT::v4f32, 2, 0, 1, 
 
4398
            14, 
 
4399
              OPC_CheckInteger, 6, 
 
4400
              OPC_MoveParent,
 
4401
              OPC_CheckType, MVT::v16i8,
 
4402
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPEQUBo), 0|OPFL_FlagOutput,
 
4403
                  1, MVT::v16i8, 2, 0, 1, 
 
4404
            15, 
 
4405
              OPC_CheckInteger, 6|128,6, 
 
4406
              OPC_MoveParent,
 
4407
              OPC_CheckType, MVT::v16i8,
 
4408
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTSBo), 0|OPFL_FlagOutput,
 
4409
                  1, MVT::v16i8, 2, 0, 1, 
 
4410
            15, 
 
4411
              OPC_CheckInteger, 6|128,4, 
 
4412
              OPC_MoveParent,
 
4413
              OPC_CheckType, MVT::v16i8,
 
4414
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTUBo), 0|OPFL_FlagOutput,
 
4415
                  1, MVT::v16i8, 2, 0, 1, 
 
4416
            14, 
 
4417
              OPC_CheckInteger, 70, 
 
4418
              OPC_MoveParent,
 
4419
              OPC_CheckType, MVT::v8i16,
 
4420
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPEQUHo), 0|OPFL_FlagOutput,
 
4421
                  1, MVT::v8i16, 2, 0, 1, 
 
4422
            15, 
 
4423
              OPC_CheckInteger, 70|128,6, 
 
4424
              OPC_MoveParent,
 
4425
              OPC_CheckType, MVT::v8i16,
 
4426
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTSHo), 0|OPFL_FlagOutput,
 
4427
                  1, MVT::v8i16, 2, 0, 1, 
 
4428
            15, 
 
4429
              OPC_CheckInteger, 70|128,4, 
 
4430
              OPC_MoveParent,
 
4431
              OPC_CheckType, MVT::v8i16,
 
4432
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTUHo), 0|OPFL_FlagOutput,
 
4433
                  1, MVT::v8i16, 2, 0, 1, 
 
4434
            15, 
 
4435
              OPC_CheckInteger, 6|128,1, 
 
4436
              OPC_MoveParent,
 
4437
              OPC_CheckType, MVT::v4i32,
 
4438
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPEQUWo), 0|OPFL_FlagOutput,
 
4439
                  1, MVT::v4i32, 2, 0, 1, 
 
4440
            15, 
 
4441
              OPC_CheckInteger, 6|128,7, 
 
4442
              OPC_MoveParent,
 
4443
              OPC_CheckType, MVT::v4i32,
 
4444
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTSWo), 0|OPFL_FlagOutput,
 
4445
                  1, MVT::v4i32, 2, 0, 1, 
 
4446
            15, 
 
4447
              OPC_CheckInteger, 6|128,5, 
 
4448
              OPC_MoveParent,
 
4449
              OPC_CheckType, MVT::v4i32,
 
4450
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VCMPGTUWo), 0|OPFL_FlagOutput,
 
4451
                  1, MVT::v4i32, 2, 0, 1, 
 
4452
            0, 
 
4453
          64,  ISD::ADDC,
 
4454
            OPC_RecordChild0,
 
4455
            OPC_RecordChild1,
 
4456
            OPC_Scope, 35, 
 
4457
              OPC_MoveChild, 1,
 
4458
              OPC_CheckOpcode, ISD::Constant,
 
4459
              OPC_CheckPredicate, 0,
 
4460
              OPC_MoveParent,
 
4461
              OPC_SwitchType , 11,  MVT::i32,
 
4462
                OPC_EmitConvertToTarget, 1,
 
4463
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIC), 0|OPFL_FlagOutput,
 
4464
                    1, MVT::i32, 2, 0, 2, 
 
4465
              11,  MVT::i64,
 
4466
                OPC_EmitConvertToTarget, 1,
 
4467
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDIC8), 0|OPFL_FlagOutput,
 
4468
                    1, MVT::i64, 2, 0, 2, 
 
4469
              0, 
 
4470
            11, 
 
4471
              OPC_CheckType, MVT::i32,
 
4472
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDC), 0|OPFL_FlagOutput,
 
4473
                  1, MVT::i32, 2, 0, 1, 
 
4474
            11, 
 
4475
              OPC_CheckType, MVT::i64,
 
4476
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADDC8), 0|OPFL_FlagOutput,
 
4477
                  1, MVT::i64, 2, 0, 1, 
 
4478
            0, 
 
4479
          49,  ISD::MUL,
 
4480
            OPC_RecordChild0,
 
4481
            OPC_RecordChild1,
 
4482
            OPC_Scope, 20, 
 
4483
              OPC_MoveChild, 1,
 
4484
              OPC_CheckOpcode, ISD::Constant,
 
4485
              OPC_CheckPredicate, 0,
 
4486
              OPC_MoveParent,
 
4487
              OPC_CheckType, MVT::i32,
 
4488
              OPC_EmitConvertToTarget, 1,
 
4489
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::MULLI), 0,
 
4490
                  1, MVT::i32, 2, 0, 2, 
 
4491
            11, 
 
4492
              OPC_CheckType, MVT::i32,
 
4493
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::MULLW), 0,
 
4494
                  1, MVT::i32, 2, 0, 1, 
 
4495
            11, 
 
4496
              OPC_CheckType, MVT::i64,
 
4497
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::MULLD), 0,
 
4498
                  1, MVT::i64, 2, 0, 1, 
 
4499
            0, 
 
4500
          66,  ISD::SUBC,
 
4501
            OPC_RecordChild0,
 
4502
            OPC_Scope, 36, 
 
4503
              OPC_MoveChild, 0,
 
4504
              OPC_CheckOpcode, ISD::Constant,
 
4505
              OPC_CheckPredicate, 0,
 
4506
              OPC_MoveParent,
 
4507
              OPC_RecordChild1,
 
4508
              OPC_SwitchType , 11,  MVT::i32,
 
4509
                OPC_EmitConvertToTarget, 0,
 
4510
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SUBFIC), 0|OPFL_FlagOutput,
 
4511
                    1, MVT::i32, 2, 1, 2, 
 
4512
              11,  MVT::i64,
 
4513
                OPC_EmitConvertToTarget, 0,
 
4514
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SUBFIC8), 0|OPFL_FlagOutput,
 
4515
                    1, MVT::i64, 2, 1, 2, 
 
4516
              0, 
 
4517
            25, 
 
4518
              OPC_RecordChild1,
 
4519
              OPC_SwitchType , 9,  MVT::i32,
 
4520
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SUBFC), 0|OPFL_FlagOutput,
 
4521
                    1, MVT::i32, 2, 1, 0, 
 
4522
              9,  MVT::i64,
 
4523
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SUBFC8), 0|OPFL_FlagOutput,
 
4524
                    1, MVT::i64, 2, 1, 0, 
 
4525
              0, 
 
4526
            0, 
 
4527
          24|128,3,  ISD::VECTOR_SHUFFLE,
 
4528
            OPC_Scope, 96, 
 
4529
              OPC_RecordNode,
 
4530
              OPC_Scope, 22, 
 
4531
                OPC_CheckPredicate, 68,
 
4532
                OPC_RecordChild0,
 
4533
                OPC_MoveChild, 1,
 
4534
                OPC_CheckOpcode, ISD::UNDEF,
 
4535
                OPC_MoveParent,
 
4536
                OPC_CheckType, MVT::v16i8,
 
4537
                OPC_EmitNodeXForm, 5, 0,
 
4538
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSPLTB), 0,
 
4539
                    1, MVT::v16i8, 2, 2, 1, 
 
4540
              22, 
 
4541
                OPC_CheckPredicate, 69,
 
4542
                OPC_RecordChild0,
 
4543
                OPC_MoveChild, 1,
 
4544
                OPC_CheckOpcode, ISD::UNDEF,
 
4545
                OPC_MoveParent,
 
4546
                OPC_CheckType, MVT::v16i8,
 
4547
                OPC_EmitNodeXForm, 6, 0,
 
4548
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSPLTH), 0,
 
4549
                    1, MVT::v16i8, 2, 2, 1, 
 
4550
              22, 
 
4551
                OPC_CheckPredicate, 70,
 
4552
                OPC_RecordChild0,
 
4553
                OPC_MoveChild, 1,
 
4554
                OPC_CheckOpcode, ISD::UNDEF,
 
4555
                OPC_MoveParent,
 
4556
                OPC_CheckType, MVT::v16i8,
 
4557
                OPC_EmitNodeXForm, 7, 0,
 
4558
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSPLTW), 0,
 
4559
                    1, MVT::v16i8, 2, 2, 1, 
 
4560
              23, 
 
4561
                OPC_CheckPredicate, 71,
 
4562
                OPC_RecordChild0,
 
4563
                OPC_MoveChild, 1,
 
4564
                OPC_CheckOpcode, ISD::UNDEF,
 
4565
                OPC_MoveParent,
 
4566
                OPC_CheckType, MVT::v16i8,
 
4567
                OPC_EmitNodeXForm, 8, 0,
 
4568
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSLDOI), 0,
 
4569
                    1, MVT::v16i8, 3, 1, 1, 2, 
 
4570
              0, 
 
4571
            19, 
 
4572
              OPC_CheckPredicate, 72,
 
4573
              OPC_RecordChild0,
 
4574
              OPC_MoveChild, 1,
 
4575
              OPC_CheckOpcode, ISD::UNDEF,
 
4576
              OPC_MoveParent,
 
4577
              OPC_CheckType, MVT::v16i8,
 
4578
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VPKUWUM), 0,
 
4579
                  1, MVT::v16i8, 2, 0, 0, 
 
4580
            19, 
 
4581
              OPC_CheckPredicate, 73,
 
4582
              OPC_RecordChild0,
 
4583
              OPC_MoveChild, 1,
 
4584
              OPC_CheckOpcode, ISD::UNDEF,
 
4585
              OPC_MoveParent,
 
4586
              OPC_CheckType, MVT::v16i8,
 
4587
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VPKUHUM), 0,
 
4588
                  1, MVT::v16i8, 2, 0, 0, 
 
4589
            19, 
 
4590
              OPC_CheckPredicate, 74,
 
4591
              OPC_RecordChild0,
 
4592
              OPC_MoveChild, 1,
 
4593
              OPC_CheckOpcode, ISD::UNDEF,
 
4594
              OPC_MoveParent,
 
4595
              OPC_CheckType, MVT::v16i8,
 
4596
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMRGLB), 0,
 
4597
                  1, MVT::v16i8, 2, 0, 0, 
 
4598
            19, 
 
4599
              OPC_CheckPredicate, 75,
 
4600
              OPC_RecordChild0,
 
4601
              OPC_MoveChild, 1,
 
4602
              OPC_CheckOpcode, ISD::UNDEF,
 
4603
              OPC_MoveParent,
 
4604
              OPC_CheckType, MVT::v16i8,
 
4605
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMRGLH), 0,
 
4606
                  1, MVT::v16i8, 2, 0, 0, 
 
4607
            19, 
 
4608
              OPC_CheckPredicate, 76,
 
4609
              OPC_RecordChild0,
 
4610
              OPC_MoveChild, 1,
 
4611
              OPC_CheckOpcode, ISD::UNDEF,
 
4612
              OPC_MoveParent,
 
4613
              OPC_CheckType, MVT::v16i8,
 
4614
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMRGLW), 0,
 
4615
                  1, MVT::v16i8, 2, 0, 0, 
 
4616
            19, 
 
4617
              OPC_CheckPredicate, 77,
 
4618
              OPC_RecordChild0,
 
4619
              OPC_MoveChild, 1,
 
4620
              OPC_CheckOpcode, ISD::UNDEF,
 
4621
              OPC_MoveParent,
 
4622
              OPC_CheckType, MVT::v16i8,
 
4623
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMRGHB), 0,
 
4624
                  1, MVT::v16i8, 2, 0, 0, 
 
4625
            19, 
 
4626
              OPC_CheckPredicate, 78,
 
4627
              OPC_RecordChild0,
 
4628
              OPC_MoveChild, 1,
 
4629
              OPC_CheckOpcode, ISD::UNDEF,
 
4630
              OPC_MoveParent,
 
4631
              OPC_CheckType, MVT::v16i8,
 
4632
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMRGHH), 0,
 
4633
                  1, MVT::v16i8, 2, 0, 0, 
 
4634
            19, 
 
4635
              OPC_CheckPredicate, 79,
 
4636
              OPC_RecordChild0,
 
4637
              OPC_MoveChild, 1,
 
4638
              OPC_CheckOpcode, ISD::UNDEF,
 
4639
              OPC_MoveParent,
 
4640
              OPC_CheckType, MVT::v16i8,
 
4641
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMRGHW), 0,
 
4642
                  1, MVT::v16i8, 2, 0, 0, 
 
4643
            20, 
 
4644
              OPC_RecordNode,
 
4645
              OPC_CheckPredicate, 80,
 
4646
              OPC_RecordChild0,
 
4647
              OPC_RecordChild1,
 
4648
              OPC_CheckType, MVT::v16i8,
 
4649
              OPC_EmitNodeXForm, 9, 0,
 
4650
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSLDOI), 0,
 
4651
                  1, MVT::v16i8, 3, 1, 2, 3, 
 
4652
            15, 
 
4653
              OPC_CheckPredicate, 81,
 
4654
              OPC_RecordChild0,
 
4655
              OPC_RecordChild1,
 
4656
              OPC_CheckType, MVT::v16i8,
 
4657
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMRGHB), 0,
 
4658
                  1, MVT::v16i8, 2, 0, 1, 
 
4659
            15, 
 
4660
              OPC_CheckPredicate, 82,
 
4661
              OPC_RecordChild0,
 
4662
              OPC_RecordChild1,
 
4663
              OPC_CheckType, MVT::v16i8,
 
4664
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMRGHH), 0,
 
4665
                  1, MVT::v16i8, 2, 0, 1, 
 
4666
            15, 
 
4667
              OPC_CheckPredicate, 83,
 
4668
              OPC_RecordChild0,
 
4669
              OPC_RecordChild1,
 
4670
              OPC_CheckType, MVT::v16i8,
 
4671
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMRGHW), 0,
 
4672
                  1, MVT::v16i8, 2, 0, 1, 
 
4673
            15, 
 
4674
              OPC_CheckPredicate, 84,
 
4675
              OPC_RecordChild0,
 
4676
              OPC_RecordChild1,
 
4677
              OPC_CheckType, MVT::v16i8,
 
4678
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMRGLB), 0,
 
4679
                  1, MVT::v16i8, 2, 0, 1, 
 
4680
            15, 
 
4681
              OPC_CheckPredicate, 85,
 
4682
              OPC_RecordChild0,
 
4683
              OPC_RecordChild1,
 
4684
              OPC_CheckType, MVT::v16i8,
 
4685
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMRGLH), 0,
 
4686
                  1, MVT::v16i8, 2, 0, 1, 
 
4687
            15, 
 
4688
              OPC_CheckPredicate, 86,
 
4689
              OPC_RecordChild0,
 
4690
              OPC_RecordChild1,
 
4691
              OPC_CheckType, MVT::v16i8,
 
4692
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMRGLW), 0,
 
4693
                  1, MVT::v16i8, 2, 0, 1, 
 
4694
            15, 
 
4695
              OPC_CheckPredicate, 87,
 
4696
              OPC_RecordChild0,
 
4697
              OPC_RecordChild1,
 
4698
              OPC_CheckType, MVT::v16i8,
 
4699
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VPKUHUM), 0,
 
4700
                  1, MVT::v16i8, 2, 0, 1, 
 
4701
            15, 
 
4702
              OPC_CheckPredicate, 88,
 
4703
              OPC_RecordChild0,
 
4704
              OPC_RecordChild1,
 
4705
              OPC_CheckType, MVT::v16i8,
 
4706
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VPKUWUM), 0,
 
4707
                  1, MVT::v16i8, 2, 0, 1, 
 
4708
            0, 
 
4709
          17,  ISD::CALLSEQ_START,
 
4710
            OPC_RecordNode,
 
4711
            OPC_RecordChild1,
 
4712
            OPC_MoveChild, 1,
 
4713
            OPC_CheckOpcode, ISD::TargetConstant,
 
4714
            OPC_MoveParent,
 
4715
            OPC_EmitMergeInputChains, 1, 0, 
 
4716
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::ADJCALLSTACKDOWN), 0|OPFL_Chain|OPFL_FlagOutput,
 
4717
                0, 1, 1, 
 
4718
          101,  PPCISD::CALL_Darwin,
 
4719
            OPC_RecordNode,
 
4720
            OPC_CaptureFlagInput,
 
4721
            OPC_RecordChild1,
 
4722
            OPC_MoveChild, 1,
 
4723
            OPC_SwitchOpcode , 32,  ISD::Constant,
 
4724
              OPC_SwitchType , 13,  MVT::i32,
 
4725
                OPC_MoveParent,
 
4726
                OPC_EmitMergeInputChains, 1, 0, 
 
4727
                OPC_EmitConvertToTarget, 1,
 
4728
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::BLA_Darwin), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic1,
 
4729
                    0, 1, 2, 
 
4730
              13,  MVT::i64,
 
4731
                OPC_MoveParent,
 
4732
                OPC_EmitMergeInputChains, 1, 0, 
 
4733
                OPC_EmitConvertToTarget, 1,
 
4734
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::BLA8_Darwin), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic1,
 
4735
                    0, 1, 2, 
 
4736
              0, 
 
4737
            28,  ISD::TargetGlobalAddress,
 
4738
              OPC_SwitchType , 11,  MVT::i32,
 
4739
                OPC_MoveParent,
 
4740
                OPC_EmitMergeInputChains, 1, 0, 
 
4741
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::BL_Darwin), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic1,
 
4742
                    0, 1, 1, 
 
4743
              11,  MVT::i64,
 
4744
                OPC_MoveParent,
 
4745
                OPC_EmitMergeInputChains, 1, 0, 
 
4746
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::BL8_Darwin), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic1,
 
4747
                    0, 1, 1, 
 
4748
              0, 
 
4749
            28,  ISD::TargetExternalSymbol,
 
4750
              OPC_SwitchType , 11,  MVT::i32,
 
4751
                OPC_MoveParent,
 
4752
                OPC_EmitMergeInputChains, 1, 0, 
 
4753
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::BL_Darwin), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic1,
 
4754
                    0, 1, 1, 
 
4755
              11,  MVT::i64,
 
4756
                OPC_MoveParent,
 
4757
                OPC_EmitMergeInputChains, 1, 0, 
 
4758
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::BL8_Darwin), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic1,
 
4759
                    0, 1, 1, 
 
4760
              0, 
 
4761
            0, 
 
4762
          101,  PPCISD::CALL_SVR4,
 
4763
            OPC_RecordNode,
 
4764
            OPC_CaptureFlagInput,
 
4765
            OPC_RecordChild1,
 
4766
            OPC_MoveChild, 1,
 
4767
            OPC_SwitchOpcode , 32,  ISD::Constant,
 
4768
              OPC_SwitchType , 13,  MVT::i32,
 
4769
                OPC_MoveParent,
 
4770
                OPC_EmitMergeInputChains, 1, 0, 
 
4771
                OPC_EmitConvertToTarget, 1,
 
4772
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::BLA_SVR4), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic1,
 
4773
                    0, 1, 2, 
 
4774
              13,  MVT::i64,
 
4775
                OPC_MoveParent,
 
4776
                OPC_EmitMergeInputChains, 1, 0, 
 
4777
                OPC_EmitConvertToTarget, 1,
 
4778
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::BLA8_ELF), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic1,
 
4779
                    0, 1, 2, 
 
4780
              0, 
 
4781
            28,  ISD::TargetGlobalAddress,
 
4782
              OPC_SwitchType , 11,  MVT::i32,
 
4783
                OPC_MoveParent,
 
4784
                OPC_EmitMergeInputChains, 1, 0, 
 
4785
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::BL_SVR4), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic1,
 
4786
                    0, 1, 1, 
 
4787
              11,  MVT::i64,
 
4788
                OPC_MoveParent,
 
4789
                OPC_EmitMergeInputChains, 1, 0, 
 
4790
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::BL8_ELF), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic1,
 
4791
                    0, 1, 1, 
 
4792
              0, 
 
4793
            28,  ISD::TargetExternalSymbol,
 
4794
              OPC_SwitchType , 11,  MVT::i32,
 
4795
                OPC_MoveParent,
 
4796
                OPC_EmitMergeInputChains, 1, 0, 
 
4797
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::BL_SVR4), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic1,
 
4798
                    0, 1, 1, 
 
4799
              11,  MVT::i64,
 
4800
                OPC_MoveParent,
 
4801
                OPC_EmitMergeInputChains, 1, 0, 
 
4802
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::BL8_ELF), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic1,
 
4803
                    0, 1, 1, 
 
4804
              0, 
 
4805
            0, 
 
4806
          109,  ISD::SRA,
 
4807
            OPC_RecordChild0,
 
4808
            OPC_RecordChild1,
 
4809
            OPC_Scope, 35, 
 
4810
              OPC_MoveChild, 1,
 
4811
              OPC_CheckOpcode, ISD::Constant,
 
4812
              OPC_CheckType, MVT::i32,
 
4813
              OPC_MoveParent,
 
4814
              OPC_SwitchType , 11,  MVT::i32,
 
4815
                OPC_EmitConvertToTarget, 1,
 
4816
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SRAWI), 0,
 
4817
                    1, MVT::i32, 2, 0, 2, 
 
4818
              11,  MVT::i64,
 
4819
                OPC_EmitConvertToTarget, 1,
 
4820
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SRADI), 0,
 
4821
                    1, MVT::i64, 2, 0, 2, 
 
4822
              0, 
 
4823
            26, 
 
4824
              OPC_CheckChild1Type, MVT::i32,
 
4825
              OPC_SwitchType , 9,  MVT::i32,
 
4826
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SRAW), 0,
 
4827
                    1, MVT::i32, 2, 0, 1, 
 
4828
              9,  MVT::i64,
 
4829
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SRAD), 0,
 
4830
                    1, MVT::i64, 2, 0, 1, 
 
4831
              0, 
 
4832
            13, 
 
4833
              OPC_CheckChild1Type, MVT::v16i8,
 
4834
              OPC_CheckType, MVT::v16i8,
 
4835
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSRAB), 0,
 
4836
                  1, MVT::v16i8, 2, 0, 1, 
 
4837
            13, 
 
4838
              OPC_CheckChild1Type, MVT::v8i16,
 
4839
              OPC_CheckType, MVT::v8i16,
 
4840
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSRAH), 0,
 
4841
                  1, MVT::v8i16, 2, 0, 1, 
 
4842
            13, 
 
4843
              OPC_CheckChild1Type, MVT::v4i32,
 
4844
              OPC_CheckType, MVT::v4i32,
 
4845
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSRAW), 0,
 
4846
                  1, MVT::v4i32, 2, 0, 1, 
 
4847
            0, 
 
4848
          18,  PPCISD::MTFSB0,
 
4849
            OPC_CaptureFlagInput,
 
4850
            OPC_RecordChild0,
 
4851
            OPC_MoveChild, 0,
 
4852
            OPC_CheckOpcode, ISD::Constant,
 
4853
            OPC_CheckType, MVT::i32,
 
4854
            OPC_MoveParent,
 
4855
            OPC_EmitConvertToTarget, 0,
 
4856
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::MTFSB0), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4857
                0, 1, 1, 
 
4858
          18,  PPCISD::MTFSB1,
 
4859
            OPC_CaptureFlagInput,
 
4860
            OPC_RecordChild0,
 
4861
            OPC_MoveChild, 0,
 
4862
            OPC_CheckOpcode, ISD::Constant,
 
4863
            OPC_CheckType, MVT::i32,
 
4864
            OPC_MoveParent,
 
4865
            OPC_EmitConvertToTarget, 0,
 
4866
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::MTFSB1), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
4867
                0, 1, 1, 
 
4868
          23,  PPCISD::MTFSF,
 
4869
            OPC_CaptureFlagInput,
 
4870
            OPC_RecordChild0,
 
4871
            OPC_MoveChild, 0,
 
4872
            OPC_CheckOpcode, ISD::Constant,
 
4873
            OPC_CheckType, MVT::i32,
 
4874
            OPC_MoveParent,
 
4875
            OPC_RecordChild1,
 
4876
            OPC_RecordChild2,
 
4877
            OPC_EmitConvertToTarget, 0,
 
4878
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::MTFSF), 0|OPFL_FlagInput,
 
4879
                1, MVT::f64, 3, 3, 1, 2, 
 
4880
          20|128,1,  ISD::FADD,
 
4881
            OPC_Scope, 52, 
 
4882
              OPC_MoveChild, 0,
 
4883
              OPC_CheckOpcode, ISD::FMUL,
 
4884
              OPC_RecordChild0,
 
4885
              OPC_RecordChild1,
 
4886
              OPC_MoveParent,
 
4887
              OPC_RecordChild1,
 
4888
              OPC_SwitchType , 12,  MVT::f64,
 
4889
                OPC_CheckPatternPredicate, 0,
 
4890
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::FMADD), 0,
 
4891
                    1, MVT::f64, 3, 0, 1, 2, 
 
4892
              12,  MVT::f32,
 
4893
                OPC_CheckPatternPredicate, 0,
 
4894
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::FMADDS), 0,
 
4895
                    1, MVT::f32, 3, 0, 1, 2, 
 
4896
              12,  MVT::v4f32,
 
4897
                OPC_CheckPatternPredicate, 0,
 
4898
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMADDFP), 0,
 
4899
                    1, MVT::v4f32, 3, 0, 1, 2, 
 
4900
              0, 
 
4901
            92, 
 
4902
              OPC_RecordChild0,
 
4903
              OPC_Scope, 51, 
 
4904
                OPC_MoveChild, 1,
 
4905
                OPC_CheckOpcode, ISD::FMUL,
 
4906
                OPC_RecordChild0,
 
4907
                OPC_RecordChild1,
 
4908
                OPC_MoveParent,
 
4909
                OPC_SwitchType , 12,  MVT::f64,
 
4910
                  OPC_CheckPatternPredicate, 0,
 
4911
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FMADD), 0,
 
4912
                      1, MVT::f64, 3, 1, 2, 0, 
 
4913
                12,  MVT::f32,
 
4914
                  OPC_CheckPatternPredicate, 0,
 
4915
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FMADDS), 0,
 
4916
                      1, MVT::f32, 3, 1, 2, 0, 
 
4917
                12,  MVT::v4f32,
 
4918
                  OPC_CheckPatternPredicate, 0,
 
4919
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMADDFP), 0,
 
4920
                      1, MVT::v4f32, 3, 1, 2, 0, 
 
4921
                0, 
 
4922
              36, 
 
4923
                OPC_RecordChild1,
 
4924
                OPC_SwitchType , 9,  MVT::f64,
 
4925
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FADD), 0,
 
4926
                      1, MVT::f64, 2, 0, 1, 
 
4927
                9,  MVT::f32,
 
4928
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::FADDS), 0,
 
4929
                      1, MVT::f32, 2, 0, 1, 
 
4930
                9,  MVT::v4f32,
 
4931
                  OPC_MorphNodeTo, TARGET_OPCODE(PPC::VADDFP), 0,
 
4932
                      1, MVT::v4f32, 2, 0, 1, 
 
4933
                0, 
 
4934
              0, 
 
4935
            0, 
 
4936
          125,  ISD::SHL,
 
4937
            OPC_RecordChild0,
 
4938
            OPC_RecordChild1,
 
4939
            OPC_Scope, 51, 
 
4940
              OPC_MoveChild, 1,
 
4941
              OPC_CheckOpcode, ISD::Constant,
 
4942
              OPC_CheckType, MVT::i32,
 
4943
              OPC_MoveParent,
 
4944
              OPC_SwitchType , 21,  MVT::i32,
 
4945
                OPC_EmitConvertToTarget, 1,
 
4946
                OPC_EmitInteger, MVT::i32, 0, 
 
4947
                OPC_EmitConvertToTarget, 1,
 
4948
                OPC_EmitNodeXForm, 10, 4,
 
4949
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::RLWINM), 0,
 
4950
                    1, MVT::i32, 4, 0, 2, 3, 5, 
 
4951
              17,  MVT::i64,
 
4952
                OPC_EmitConvertToTarget, 1,
 
4953
                OPC_EmitConvertToTarget, 1,
 
4954
                OPC_EmitNodeXForm, 11, 3,
 
4955
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::RLDICR), 0,
 
4956
                    1, MVT::i64, 3, 0, 2, 4, 
 
4957
              0, 
 
4958
            26, 
 
4959
              OPC_CheckChild1Type, MVT::i32,
 
4960
              OPC_SwitchType , 9,  MVT::i32,
 
4961
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SLW), 0,
 
4962
                    1, MVT::i32, 2, 0, 1, 
 
4963
              9,  MVT::i64,
 
4964
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SLD), 0,
 
4965
                    1, MVT::i64, 2, 0, 1, 
 
4966
              0, 
 
4967
            13, 
 
4968
              OPC_CheckChild1Type, MVT::v16i8,
 
4969
              OPC_CheckType, MVT::v16i8,
 
4970
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSLB), 0,
 
4971
                  1, MVT::v16i8, 2, 0, 1, 
 
4972
            13, 
 
4973
              OPC_CheckChild1Type, MVT::v8i16,
 
4974
              OPC_CheckType, MVT::v8i16,
 
4975
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSLH), 0,
 
4976
                  1, MVT::v8i16, 2, 0, 1, 
 
4977
            13, 
 
4978
              OPC_CheckChild1Type, MVT::v4i32,
 
4979
              OPC_CheckType, MVT::v4i32,
 
4980
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSLW), 0,
 
4981
                  1, MVT::v4i32, 2, 0, 1, 
 
4982
            0, 
 
4983
          125,  ISD::SRL,
 
4984
            OPC_RecordChild0,
 
4985
            OPC_RecordChild1,
 
4986
            OPC_Scope, 51, 
 
4987
              OPC_MoveChild, 1,
 
4988
              OPC_CheckOpcode, ISD::Constant,
 
4989
              OPC_CheckType, MVT::i32,
 
4990
              OPC_MoveParent,
 
4991
              OPC_SwitchType , 21,  MVT::i32,
 
4992
                OPC_EmitConvertToTarget, 1,
 
4993
                OPC_EmitNodeXForm, 12, 2,
 
4994
                OPC_EmitConvertToTarget, 1,
 
4995
                OPC_EmitInteger, MVT::i32, 31, 
 
4996
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::RLWINM), 0,
 
4997
                    1, MVT::i32, 4, 0, 3, 4, 5, 
 
4998
              17,  MVT::i64,
 
4999
                OPC_EmitConvertToTarget, 1,
 
5000
                OPC_EmitNodeXForm, 13, 2,
 
5001
                OPC_EmitConvertToTarget, 1,
 
5002
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::RLDICL), 0,
 
5003
                    1, MVT::i64, 3, 0, 3, 4, 
 
5004
              0, 
 
5005
            26, 
 
5006
              OPC_CheckChild1Type, MVT::i32,
 
5007
              OPC_SwitchType , 9,  MVT::i32,
 
5008
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SRW), 0,
 
5009
                    1, MVT::i32, 2, 0, 1, 
 
5010
              9,  MVT::i64,
 
5011
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::SRD), 0,
 
5012
                    1, MVT::i64, 2, 0, 1, 
 
5013
              0, 
 
5014
            13, 
 
5015
              OPC_CheckChild1Type, MVT::v16i8,
 
5016
              OPC_CheckType, MVT::v16i8,
 
5017
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSRB), 0,
 
5018
                  1, MVT::v16i8, 2, 0, 1, 
 
5019
            13, 
 
5020
              OPC_CheckChild1Type, MVT::v8i16,
 
5021
              OPC_CheckType, MVT::v8i16,
 
5022
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSRH), 0,
 
5023
                  1, MVT::v8i16, 2, 0, 1, 
 
5024
            13, 
 
5025
              OPC_CheckChild1Type, MVT::v4i32,
 
5026
              OPC_CheckType, MVT::v4i32,
 
5027
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSRW), 0,
 
5028
                  1, MVT::v4i32, 2, 0, 1, 
 
5029
            0, 
 
5030
          91,  ISD::ROTL,
 
5031
            OPC_RecordChild0,
 
5032
            OPC_RecordChild1,
 
5033
            OPC_Scope, 47, 
 
5034
              OPC_MoveChild, 1,
 
5035
              OPC_CheckOpcode, ISD::Constant,
 
5036
              OPC_CheckType, MVT::i32,
 
5037
              OPC_MoveParent,
 
5038
              OPC_SwitchType , 19,  MVT::i32,
 
5039
                OPC_EmitConvertToTarget, 1,
 
5040
                OPC_EmitInteger, MVT::i32, 0, 
 
5041
                OPC_EmitInteger, MVT::i32, 31, 
 
5042
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::RLWINM), 0,
 
5043
                    1, MVT::i32, 4, 0, 2, 3, 4, 
 
5044
              15,  MVT::i64,
 
5045
                OPC_EmitConvertToTarget, 1,
 
5046
                OPC_EmitInteger, MVT::i32, 0, 
 
5047
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::RLDICL), 0,
 
5048
                    1, MVT::i64, 3, 0, 2, 3, 
 
5049
              0, 
 
5050
            38, 
 
5051
              OPC_CheckChild1Type, MVT::i32,
 
5052
              OPC_SwitchType , 17,  MVT::i32,
 
5053
                OPC_EmitInteger, MVT::i32, 0, 
 
5054
                OPC_EmitInteger, MVT::i32, 31, 
 
5055
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::RLWNM), 0,
 
5056
                    1, MVT::i32, 4, 0, 1, 2, 3, 
 
5057
              13,  MVT::i64,
 
5058
                OPC_EmitInteger, MVT::i32, 0, 
 
5059
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::RLDCL), 0,
 
5060
                    1, MVT::i64, 3, 0, 1, 2, 
 
5061
              0, 
 
5062
            0, 
 
5063
          18,  PPCISD::TOC_ENTRY,
 
5064
            OPC_RecordChild0,
 
5065
            OPC_MoveChild, 0,
 
5066
            OPC_CheckOpcode, ISD::TargetGlobalAddress,
 
5067
            OPC_MoveParent,
 
5068
            OPC_RecordChild1,
 
5069
            OPC_CheckType, MVT::i64,
 
5070
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::LDtoc), 0,
 
5071
                1, MVT::i64, 2, 0, 1, 
 
5072
          99,  ISD::Constant,
 
5073
            OPC_RecordNode,
 
5074
            OPC_Scope, 14, 
 
5075
              OPC_CheckPredicate, 0,
 
5076
              OPC_CheckType, MVT::i32,
 
5077
              OPC_EmitConvertToTarget, 0,
 
5078
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LI), 0,
 
5079
                  1, MVT::i32, 1, 1, 
 
5080
            17, 
 
5081
              OPC_CheckPredicate, 1,
 
5082
              OPC_CheckType, MVT::i32,
 
5083
              OPC_EmitConvertToTarget, 0,
 
5084
              OPC_EmitNodeXForm, 0, 1,
 
5085
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LIS), 0,
 
5086
                  1, MVT::i32, 1, 2, 
 
5087
            14, 
 
5088
              OPC_CheckPredicate, 0,
 
5089
              OPC_CheckType, MVT::i64,
 
5090
              OPC_EmitConvertToTarget, 0,
 
5091
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LI8), 0,
 
5092
                  1, MVT::i64, 1, 1, 
 
5093
            17, 
 
5094
              OPC_CheckPredicate, 1,
 
5095
              OPC_CheckType, MVT::i64,
 
5096
              OPC_EmitConvertToTarget, 0,
 
5097
              OPC_EmitNodeXForm, 0, 1,
 
5098
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::LIS8), 0,
 
5099
                  1, MVT::i64, 1, 2, 
 
5100
            29, 
 
5101
              OPC_CheckType, MVT::i32,
 
5102
              OPC_EmitConvertToTarget, 0,
 
5103
              OPC_EmitNodeXForm, 0, 1,
 
5104
              OPC_EmitNode, TARGET_OPCODE(PPC::LIS), 0,
 
5105
                  1, MVT::i32, 1, 2, 
 
5106
              OPC_EmitConvertToTarget, 0,
 
5107
              OPC_EmitNodeXForm, 1, 4,
 
5108
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::ORI), 0,
 
5109
                  1, MVT::i32, 2, 3, 5, 
 
5110
            0, 
 
5111
          66,  ISD::BUILD_VECTOR,
 
5112
            OPC_Scope, 51, 
 
5113
              OPC_RecordNode,
 
5114
              OPC_Scope, 15, 
 
5115
                OPC_CheckPredicate, 89,
 
5116
                OPC_CheckType, MVT::v16i8,
 
5117
                OPC_EmitNodeXForm, 14, 0,
 
5118
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSPLTISB), 0,
 
5119
                    1, MVT::v16i8, 1, 1, 
 
5120
              15, 
 
5121
                OPC_CheckPredicate, 90,
 
5122
                OPC_CheckType, MVT::v8i16,
 
5123
                OPC_EmitNodeXForm, 15, 0,
 
5124
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSPLTISH), 0,
 
5125
                    1, MVT::v8i16, 1, 1, 
 
5126
              15, 
 
5127
                OPC_CheckPredicate, 91,
 
5128
                OPC_CheckType, MVT::v4i32,
 
5129
                OPC_EmitNodeXForm, 16, 0,
 
5130
                OPC_MorphNodeTo, TARGET_OPCODE(PPC::VSPLTISW), 0,
 
5131
                    1, MVT::v4i32, 1, 1, 
 
5132
              0, 
 
5133
            11, 
 
5134
              OPC_CheckPredicate, 92,
 
5135
              OPC_CheckType, MVT::v4i32,
 
5136
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::V_SET0), 0,
 
5137
                  1, MVT::v4i32, 0, 
 
5138
            0, 
 
5139
          83,  ISD::BIT_CONVERT,
 
5140
            OPC_RecordChild0,
 
5141
            OPC_Scope, 19, 
 
5142
              OPC_CheckChild0Type, MVT::v8i16,
 
5143
              OPC_SwitchType , 3,  MVT::v16i8,
 
5144
                OPC_CompleteMatch, 1, 0, 
 
5145
 
 
5146
              3,  MVT::v4i32,
 
5147
                OPC_CompleteMatch, 1, 0, 
 
5148
 
 
5149
              3,  MVT::v4f32,
 
5150
                OPC_CompleteMatch, 1, 0, 
 
5151
 
 
5152
              0, 
 
5153
            19, 
 
5154
              OPC_CheckChild0Type, MVT::v4i32,
 
5155
              OPC_SwitchType , 3,  MVT::v16i8,
 
5156
                OPC_CompleteMatch, 1, 0, 
 
5157
 
 
5158
              3,  MVT::v8i16,
 
5159
                OPC_CompleteMatch, 1, 0, 
 
5160
 
 
5161
              3,  MVT::v4f32,
 
5162
                OPC_CompleteMatch, 1, 0, 
 
5163
 
 
5164
              0, 
 
5165
            19, 
 
5166
              OPC_CheckChild0Type, MVT::v4f32,
 
5167
              OPC_SwitchType , 3,  MVT::v16i8,
 
5168
                OPC_CompleteMatch, 1, 0, 
 
5169
 
 
5170
              3,  MVT::v8i16,
 
5171
                OPC_CompleteMatch, 1, 0, 
 
5172
 
 
5173
              3,  MVT::v4i32,
 
5174
                OPC_CompleteMatch, 1, 0, 
 
5175
 
 
5176
              0, 
 
5177
            19, 
 
5178
              OPC_CheckChild0Type, MVT::v16i8,
 
5179
              OPC_SwitchType , 3,  MVT::v8i16,
 
5180
                OPC_CompleteMatch, 1, 0, 
 
5181
 
 
5182
              3,  MVT::v4i32,
 
5183
                OPC_CompleteMatch, 1, 0, 
 
5184
 
 
5185
              3,  MVT::v4f32,
 
5186
                OPC_CompleteMatch, 1, 0, 
 
5187
 
 
5188
              0, 
 
5189
            0, 
 
5190
          19,  PPCISD::RET_FLAG,
 
5191
            OPC_RecordNode,
 
5192
            OPC_CaptureFlagInput,
 
5193
            OPC_EmitMergeInputChains, 1, 0, 
 
5194
            OPC_EmitInteger, MVT::i32, 20, 
 
5195
            OPC_EmitRegister, MVT::i32, 0 ,
 
5196
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::BLR), 0|OPFL_Chain|OPFL_FlagInput,
 
5197
                0, 2, 1, 2, 
 
5198
          17,  ISD::BR,
 
5199
            OPC_RecordNode,
 
5200
            OPC_RecordChild1,
 
5201
            OPC_MoveChild, 1,
 
5202
            OPC_CheckOpcode, ISD::BasicBlock,
 
5203
            OPC_MoveParent,
 
5204
            OPC_EmitMergeInputChains, 1, 0, 
 
5205
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::B), 0|OPFL_Chain,
 
5206
                0, 1, 1, 
 
5207
          28,  PPCISD::BCTRL_Darwin,
 
5208
            OPC_RecordNode,
 
5209
            OPC_CaptureFlagInput,
 
5210
            OPC_Scope, 11, 
 
5211
              OPC_CheckPatternPredicate, 1,
 
5212
              OPC_EmitMergeInputChains, 1, 0, 
 
5213
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::BCTRL_Darwin), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic0,
 
5214
                  0, 0, 
 
5215
            11, 
 
5216
              OPC_CheckPatternPredicate, 2,
 
5217
              OPC_EmitMergeInputChains, 1, 0, 
 
5218
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::BCTRL8_Darwin), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic0,
 
5219
                  0, 0, 
 
5220
            0, 
 
5221
          28,  PPCISD::BCTRL_SVR4,
 
5222
            OPC_RecordNode,
 
5223
            OPC_CaptureFlagInput,
 
5224
            OPC_Scope, 11, 
 
5225
              OPC_CheckPatternPredicate, 1,
 
5226
              OPC_EmitMergeInputChains, 1, 0, 
 
5227
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::BCTRL_SVR4), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic0,
 
5228
                  0, 0, 
 
5229
            11, 
 
5230
              OPC_CheckPatternPredicate, 2,
 
5231
              OPC_EmitMergeInputChains, 1, 0, 
 
5232
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::BCTRL8_ELF), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput|OPFL_Variadic0,
 
5233
                  0, 0, 
 
5234
            0, 
 
5235
          10,  ISD::TRAP,
 
5236
            OPC_RecordNode,
 
5237
            OPC_EmitMergeInputChains, 1, 0, 
 
5238
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::TRAP), 0|OPFL_Chain,
 
5239
                0, 0, 
 
5240
          28,  PPCISD::SHL,
 
5241
            OPC_RecordChild0,
 
5242
            OPC_RecordChild1,
 
5243
            OPC_CheckChild1Type, MVT::i32,
 
5244
            OPC_SwitchType , 9,  MVT::i32,
 
5245
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::SLW), 0,
 
5246
                  1, MVT::i32, 2, 0, 1, 
 
5247
            9,  MVT::i64,
 
5248
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::SLD), 0,
 
5249
                  1, MVT::i64, 2, 0, 1, 
 
5250
            0, 
 
5251
          28,  PPCISD::SRL,
 
5252
            OPC_RecordChild0,
 
5253
            OPC_RecordChild1,
 
5254
            OPC_CheckChild1Type, MVT::i32,
 
5255
            OPC_SwitchType , 9,  MVT::i32,
 
5256
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::SRW), 0,
 
5257
                  1, MVT::i32, 2, 0, 1, 
 
5258
            9,  MVT::i64,
 
5259
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::SRD), 0,
 
5260
                  1, MVT::i64, 2, 0, 1, 
 
5261
            0, 
 
5262
          28,  PPCISD::SRA,
 
5263
            OPC_RecordChild0,
 
5264
            OPC_RecordChild1,
 
5265
            OPC_CheckChild1Type, MVT::i32,
 
5266
            OPC_SwitchType , 9,  MVT::i32,
 
5267
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::SRAW), 0,
 
5268
                  1, MVT::i32, 2, 0, 1, 
 
5269
            9,  MVT::i64,
 
5270
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::SRAD), 0,
 
5271
                  1, MVT::i64, 2, 0, 1, 
 
5272
            0, 
 
5273
          23,  ISD::CTLZ,
 
5274
            OPC_RecordChild0,
 
5275
            OPC_SwitchType , 8,  MVT::i32,
 
5276
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::CNTLZW), 0,
 
5277
                  1, MVT::i32, 1, 0, 
 
5278
            8,  MVT::i64,
 
5279
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::CNTLZD), 0,
 
5280
                  1, MVT::i64, 1, 0, 
 
5281
            0, 
 
5282
          75,  ISD::SIGN_EXTEND_INREG,
 
5283
            OPC_RecordChild0,
 
5284
            OPC_MoveChild, 1,
 
5285
            OPC_Scope, 13, 
 
5286
              OPC_CheckValueType, MVT::i8,
 
5287
              OPC_MoveParent,
 
5288
              OPC_CheckType, MVT::i32,
 
5289
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::EXTSB), 0,
 
5290
                  1, MVT::i32, 1, 0, 
 
5291
            13, 
 
5292
              OPC_CheckValueType, MVT::i16,
 
5293
              OPC_MoveParent,
 
5294
              OPC_CheckType, MVT::i32,
 
5295
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::EXTSH), 0,
 
5296
                  1, MVT::i32, 1, 0, 
 
5297
            13, 
 
5298
              OPC_CheckValueType, MVT::i8,
 
5299
              OPC_MoveParent,
 
5300
              OPC_CheckType, MVT::i64,
 
5301
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::EXTSB8), 0,
 
5302
                  1, MVT::i64, 1, 0, 
 
5303
            13, 
 
5304
              OPC_CheckValueType, MVT::i16,
 
5305
              OPC_MoveParent,
 
5306
              OPC_CheckType, MVT::i64,
 
5307
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::EXTSH8), 0,
 
5308
                  1, MVT::i64, 1, 0, 
 
5309
            13, 
 
5310
              OPC_CheckValueType, MVT::i32,
 
5311
              OPC_MoveParent,
 
5312
              OPC_CheckType, MVT::i64,
 
5313
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::EXTSW), 0,
 
5314
                  1, MVT::i64, 1, 0, 
 
5315
            0, 
 
5316
          11,  PPCISD::FCTIWZ,
 
5317
            OPC_RecordChild0,
 
5318
            OPC_CheckType, MVT::f64,
 
5319
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::FCTIWZ), 0,
 
5320
                1, MVT::f64, 1, 0, 
 
5321
          13,  ISD::FP_ROUND,
 
5322
            OPC_RecordChild0,
 
5323
            OPC_CheckChild0Type, MVT::f64,
 
5324
            OPC_CheckType, MVT::f32,
 
5325
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::FRSP), 0,
 
5326
                1, MVT::f32, 1, 0, 
 
5327
          23,  ISD::FSQRT,
 
5328
            OPC_RecordChild0,
 
5329
            OPC_SwitchType , 8,  MVT::f64,
 
5330
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::FSQRT), 0,
 
5331
                  1, MVT::f64, 1, 0, 
 
5332
            8,  MVT::f32,
 
5333
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::FSQRTS), 0,
 
5334
                  1, MVT::f32, 1, 0, 
 
5335
            0, 
 
5336
          13,  ISD::FP_EXTEND,
 
5337
            OPC_RecordChild0,
 
5338
            OPC_CheckChild0Type, MVT::f32,
 
5339
            OPC_CheckType, MVT::f64,
 
5340
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::FMRSD), 0,
 
5341
                1, MVT::f64, 1, 0, 
 
5342
          23,  ISD::FABS,
 
5343
            OPC_RecordChild0,
 
5344
            OPC_SwitchType , 8,  MVT::f32,
 
5345
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::FABSS), 0,
 
5346
                  1, MVT::f32, 1, 0, 
 
5347
            8,  MVT::f64,
 
5348
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::FABSD), 0,
 
5349
                  1, MVT::f64, 1, 0, 
 
5350
            0, 
 
5351
          31,  PPCISD::MTCTR,
 
5352
            OPC_RecordNode,
 
5353
            OPC_CaptureFlagInput,
 
5354
            OPC_RecordChild1,
 
5355
            OPC_Scope, 12, 
 
5356
              OPC_CheckChild1Type, MVT::i32,
 
5357
              OPC_EmitMergeInputChains, 1, 0, 
 
5358
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::MTCTR), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput,
 
5359
                  0, 1, 1, 
 
5360
            12, 
 
5361
              OPC_CheckChild1Type, MVT::i64,
 
5362
              OPC_EmitMergeInputChains, 1, 0, 
 
5363
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::MTCTR8), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput,
 
5364
                  0, 1, 1, 
 
5365
            0, 
 
5366
          7,  PPCISD::MFFS,
 
5367
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::MFFS), 0|OPFL_FlagOutput,
 
5368
                1, MVT::f64, 0, 
 
5369
          14,  PPCISD::FADDRTZ,
 
5370
            OPC_CaptureFlagInput,
 
5371
            OPC_RecordChild0,
 
5372
            OPC_RecordChild1,
 
5373
            OPC_CheckType, MVT::f64,
 
5374
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::FADDrtz), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
5375
                1, MVT::f64, 2, 0, 1, 
 
5376
          26,  ISD::SDIV,
 
5377
            OPC_RecordChild0,
 
5378
            OPC_RecordChild1,
 
5379
            OPC_SwitchType , 9,  MVT::i32,
 
5380
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DIVW), 0,
 
5381
                  1, MVT::i32, 2, 0, 1, 
 
5382
            9,  MVT::i64,
 
5383
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DIVD), 0,
 
5384
                  1, MVT::i64, 2, 0, 1, 
 
5385
            0, 
 
5386
          26,  ISD::UDIV,
 
5387
            OPC_RecordChild0,
 
5388
            OPC_RecordChild1,
 
5389
            OPC_SwitchType , 9,  MVT::i32,
 
5390
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DIVWU), 0,
 
5391
                  1, MVT::i32, 2, 0, 1, 
 
5392
            9,  MVT::i64,
 
5393
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::DIVDU), 0,
 
5394
                  1, MVT::i64, 2, 0, 1, 
 
5395
            0, 
 
5396
          26,  ISD::MULHS,
 
5397
            OPC_RecordChild0,
 
5398
            OPC_RecordChild1,
 
5399
            OPC_SwitchType , 9,  MVT::i32,
 
5400
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::MULHW), 0,
 
5401
                  1, MVT::i32, 2, 0, 1, 
 
5402
            9,  MVT::i64,
 
5403
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::MULHD), 0,
 
5404
                  1, MVT::i64, 2, 0, 1, 
 
5405
            0, 
 
5406
          26,  ISD::MULHU,
 
5407
            OPC_RecordChild0,
 
5408
            OPC_RecordChild1,
 
5409
            OPC_SwitchType , 9,  MVT::i32,
 
5410
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::MULHWU), 0,
 
5411
                  1, MVT::i32, 2, 0, 1, 
 
5412
            9,  MVT::i64,
 
5413
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::MULHDU), 0,
 
5414
                  1, MVT::i64, 2, 0, 1, 
 
5415
            0, 
 
5416
          29,  PPCISD::FSEL,
 
5417
            OPC_RecordChild0,
 
5418
            OPC_RecordChild1,
 
5419
            OPC_RecordChild2,
 
5420
            OPC_SwitchType , 10,  MVT::f64,
 
5421
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::FSELD), 0,
 
5422
                  1, MVT::f64, 3, 0, 1, 2, 
 
5423
            10,  MVT::f32,
 
5424
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::FSELS), 0,
 
5425
                  1, MVT::f32, 3, 0, 1, 2, 
 
5426
            0, 
 
5427
          26,  ISD::FDIV,
 
5428
            OPC_RecordChild0,
 
5429
            OPC_RecordChild1,
 
5430
            OPC_SwitchType , 9,  MVT::f64,
 
5431
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::FDIV), 0,
 
5432
                  1, MVT::f64, 2, 0, 1, 
 
5433
            9,  MVT::f32,
 
5434
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::FDIVS), 0,
 
5435
                  1, MVT::f32, 2, 0, 1, 
 
5436
            0, 
 
5437
          45,  ISD::FMUL,
 
5438
            OPC_RecordChild0,
 
5439
            OPC_RecordChild1,
 
5440
            OPC_SwitchType , 9,  MVT::f64,
 
5441
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::FMUL), 0,
 
5442
                  1, MVT::f64, 2, 0, 1, 
 
5443
            9,  MVT::f32,
 
5444
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::FMULS), 0,
 
5445
                  1, MVT::f32, 2, 0, 1, 
 
5446
            17,  MVT::v4f32,
 
5447
              OPC_EmitNode, TARGET_OPCODE(PPC::V_SET0), 0,
 
5448
                  1, MVT::v4i32, 0, 
 
5449
              OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMADDFP), 0,
 
5450
                  1, MVT::v4f32, 3, 0, 1, 2, 
 
5451
            0, 
 
5452
          15,  PPCISD::VMADDFP,
 
5453
            OPC_RecordChild0,
 
5454
            OPC_RecordChild1,
 
5455
            OPC_RecordChild2,
 
5456
            OPC_CheckType, MVT::v4f32,
 
5457
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::VMADDFP), 0,
 
5458
                1, MVT::v4f32, 3, 0, 1, 2, 
 
5459
          15,  PPCISD::VNMSUBFP,
 
5460
            OPC_RecordChild0,
 
5461
            OPC_RecordChild1,
 
5462
            OPC_RecordChild2,
 
5463
            OPC_CheckType, MVT::v4f32,
 
5464
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::VNMSUBFP), 0,
 
5465
                1, MVT::v4f32, 3, 0, 1, 2, 
 
5466
          15,  PPCISD::VPERM,
 
5467
            OPC_RecordChild0,
 
5468
            OPC_RecordChild1,
 
5469
            OPC_RecordChild2,
 
5470
            OPC_CheckType, MVT::v16i8,
 
5471
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::VPERM), 0,
 
5472
                1, MVT::v16i8, 3, 0, 1, 2, 
 
5473
          7,  PPCISD::NOP,
 
5474
            OPC_CaptureFlagInput,
 
5475
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::NOP), 0|OPFL_FlagInput|OPFL_FlagOutput,
 
5476
                0, 0, 
 
5477
          11,  PPCISD::EXTSW_32,
 
5478
            OPC_RecordChild0,
 
5479
            OPC_CheckType, MVT::i32,
 
5480
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::EXTSW_32), 0,
 
5481
                1, MVT::i32, 1, 0, 
 
5482
          13,  ISD::SIGN_EXTEND,
 
5483
            OPC_RecordChild0,
 
5484
            OPC_CheckChild0Type, MVT::i32,
 
5485
            OPC_CheckType, MVT::i64,
 
5486
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::EXTSW_32_64), 0,
 
5487
                1, MVT::i64, 1, 0, 
 
5488
          15,  PPCISD::LOAD_TOC,
 
5489
            OPC_RecordNode,
 
5490
            OPC_CaptureFlagInput,
 
5491
            OPC_RecordChild1,
 
5492
            OPC_CheckChild1Type, MVT::i64,
 
5493
            OPC_EmitMergeInputChains, 1, 0, 
 
5494
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::LDinto_toc), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput,
 
5495
                0, 1, 1, 
 
5496
          11,  PPCISD::TOC_RESTORE,
 
5497
            OPC_RecordNode,
 
5498
            OPC_CaptureFlagInput,
 
5499
            OPC_EmitMergeInputChains, 1, 0, 
 
5500
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::LDtoc_restore), 0|OPFL_Chain|OPFL_FlagInput|OPFL_FlagOutput,
 
5501
                0, 0, 
 
5502
          11,  PPCISD::FCFID,
 
5503
            OPC_RecordChild0,
 
5504
            OPC_CheckType, MVT::f64,
 
5505
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::FCFID), 0,
 
5506
                1, MVT::f64, 1, 0, 
 
5507
          11,  PPCISD::FCTIDZ,
 
5508
            OPC_RecordChild0,
 
5509
            OPC_CheckType, MVT::f64,
 
5510
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::FCTIDZ), 0,
 
5511
                1, MVT::f64, 1, 0, 
 
5512
          14,  ISD::ANY_EXTEND,
 
5513
            OPC_RecordChild0,
 
5514
            OPC_CheckChild0Type, MVT::i32,
 
5515
            OPC_CheckType, MVT::i64,
 
5516
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::OR4To8), 0,
 
5517
                1, MVT::i64, 2, 0, 0, 
 
5518
          14,  ISD::TRUNCATE,
 
5519
            OPC_RecordChild0,
 
5520
            OPC_CheckChild0Type, MVT::i64,
 
5521
            OPC_CheckType, MVT::i32,
 
5522
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::OR8To4), 0,
 
5523
                1, MVT::i32, 2, 0, 0, 
 
5524
          30,  ISD::ZERO_EXTEND,
 
5525
            OPC_RecordChild0,
 
5526
            OPC_CheckChild0Type, MVT::i32,
 
5527
            OPC_CheckType, MVT::i64,
 
5528
            OPC_EmitNode, TARGET_OPCODE(PPC::OR4To8), 0,
 
5529
                1, MVT::i64, 2, 0, 0, 
 
5530
            OPC_EmitInteger, MVT::i32, 0, 
 
5531
            OPC_EmitInteger, MVT::i32, 32, 
 
5532
            OPC_MorphNodeTo, TARGET_OPCODE(PPC::RLDICL), 0,
 
5533
                1, MVT::i64, 3, 1, 2, 3, 
 
5534
          0, 
 
5535
    0
 
5536
  }; // Total Array size is 11495 bytes
 
5537
 
 
5538
  #undef TARGET_OPCODE
 
5539
  return SelectCodeCommon(N, MatcherTable,sizeof(MatcherTable));
 
5540
}
 
5541
 
 
5542
bool CheckPatternPredicate(unsigned PredNo) const {
 
5543
  switch (PredNo) {
 
5544
  default: assert(0 && "Invalid predicate in table?");
 
5545
  case 0: return (!NoExcessFPPrecision);
 
5546
  case 1: return (!PPCSubTarget.isPPC64());
 
5547
  case 2: return (PPCSubTarget.isPPC64());
 
5548
  }
 
5549
}
 
5550
 
 
5551
bool CheckNodePredicate(SDNode *Node, unsigned PredNo) const {
 
5552
  switch (PredNo) {
 
5553
  default: assert(0 && "Invalid predicate in table?");
 
5554
  case 0: { // Predicate_immSExt16
 
5555
    ConstantSDNode*N = cast<ConstantSDNode>(Node);
 
5556
 
 
5557
  // immSExt16 predicate - True if the immediate fits in a 16-bit sign extended
 
5558
  // field.  Used by instructions like 'addi'.
 
5559
  if (N->getValueType(0) == MVT::i32)
 
5560
    return (int32_t)N->getZExtValue() == (short)N->getZExtValue();
 
5561
  else
 
5562
    return (int64_t)N->getZExtValue() == (short)N->getZExtValue();
 
5563
 
 
5564
  }
 
5565
  case 1: { // Predicate_imm16ShiftedSExt
 
5566
    ConstantSDNode*N = cast<ConstantSDNode>(Node);
 
5567
 
 
5568
  // imm16ShiftedSExt predicate - True if only bits in the top 16-bits of the
 
5569
  // immediate are set.  Used by instructions like 'addis'.  Identical to 
 
5570
  // imm16ShiftedZExt in 32-bit mode.
 
5571
  if (N->getZExtValue() & 0xFFFF) return false;
 
5572
  if (N->getValueType(0) == MVT::i32)
 
5573
    return true;
 
5574
  // For 64-bit, make sure it is sext right.
 
5575
  return N->getZExtValue() == (uint64_t)(int)N->getZExtValue();
 
5576
 
 
5577
  }
 
5578
  case 2: { // Predicate_unindexedload
 
5579
    SDNode *N = Node;
 
5580
 
 
5581
  return cast<LoadSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
 
5582
 
 
5583
  }
 
5584
  case 3: { // Predicate_zextload
 
5585
    SDNode *N = Node;
 
5586
 
 
5587
  return cast<LoadSDNode>(N)->getExtensionType() == ISD::ZEXTLOAD;
 
5588
 
 
5589
  }
 
5590
  case 4: { // Predicate_zextloadi8
 
5591
    SDNode *N = Node;
 
5592
 
 
5593
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i8;
 
5594
 
 
5595
  }
 
5596
  case 5: { // Predicate_sextload
 
5597
    SDNode *N = Node;
 
5598
 
 
5599
  return cast<LoadSDNode>(N)->getExtensionType() == ISD::SEXTLOAD;
 
5600
 
 
5601
  }
 
5602
  case 6: { // Predicate_sextloadi16
 
5603
    SDNode *N = Node;
 
5604
 
 
5605
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i16;
 
5606
 
 
5607
  }
 
5608
  case 7: { // Predicate_zextloadi16
 
5609
    SDNode *N = Node;
 
5610
 
 
5611
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i16;
 
5612
 
 
5613
  }
 
5614
  case 8: { // Predicate_load
 
5615
    SDNode *N = Node;
 
5616
 
 
5617
  return cast<LoadSDNode>(N)->getExtensionType() == ISD::NON_EXTLOAD;
 
5618
 
 
5619
  }
 
5620
  case 9: { // Predicate_zextloadi1
 
5621
    SDNode *N = Node;
 
5622
 
 
5623
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i1;
 
5624
 
 
5625
  }
 
5626
  case 10: { // Predicate_extload
 
5627
    SDNode *N = Node;
 
5628
 
 
5629
  return cast<LoadSDNode>(N)->getExtensionType() == ISD::EXTLOAD;
 
5630
 
 
5631
  }
 
5632
  case 11: { // Predicate_extloadi1
 
5633
    SDNode *N = Node;
 
5634
 
 
5635
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i1;
 
5636
 
 
5637
  }
 
5638
  case 12: { // Predicate_extloadi8
 
5639
    SDNode *N = Node;
 
5640
 
 
5641
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i8;
 
5642
 
 
5643
  }
 
5644
  case 13: { // Predicate_extloadi16
 
5645
    SDNode *N = Node;
 
5646
 
 
5647
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i16;
 
5648
 
 
5649
  }
 
5650
  case 14: { // Predicate_sextloadi32
 
5651
    SDNode *N = Node;
 
5652
 
 
5653
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i32;
 
5654
 
 
5655
  }
 
5656
  case 15: { // Predicate_zextloadi32
 
5657
    SDNode *N = Node;
 
5658
 
 
5659
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i32;
 
5660
 
 
5661
  }
 
5662
  case 16: { // Predicate_extloadi32
 
5663
    SDNode *N = Node;
 
5664
 
 
5665
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::i32;
 
5666
 
 
5667
  }
 
5668
  case 17: { // Predicate_extloadf32
 
5669
    SDNode *N = Node;
 
5670
 
 
5671
  return cast<LoadSDNode>(N)->getMemoryVT() == MVT::f32;
 
5672
 
 
5673
  }
 
5674
  case 18: { // Predicate_unindexedstore
 
5675
    SDNode *N = Node;
 
5676
 
 
5677
  return cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
 
5678
 
 
5679
  }
 
5680
  case 19: { // Predicate_truncstore
 
5681
    SDNode *N = Node;
 
5682
 
 
5683
  return cast<StoreSDNode>(N)->isTruncatingStore();
 
5684
 
 
5685
  }
 
5686
  case 20: { // Predicate_truncstorei8
 
5687
    SDNode *N = Node;
 
5688
 
 
5689
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i8;
 
5690
 
 
5691
  }
 
5692
  case 21: { // Predicate_truncstorei16
 
5693
    SDNode *N = Node;
 
5694
 
 
5695
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i16;
 
5696
 
 
5697
  }
 
5698
  case 22: { // Predicate_store
 
5699
    SDNode *N = Node;
 
5700
 
 
5701
  return !cast<StoreSDNode>(N)->isTruncatingStore();
 
5702
 
 
5703
  }
 
5704
  case 23: { // Predicate_truncstorei32
 
5705
    SDNode *N = Node;
 
5706
 
 
5707
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i32;
 
5708
 
 
5709
  }
 
5710
  case 24: { // Predicate_itruncstore
 
5711
    SDNode *N = Node;
 
5712
 
 
5713
  return cast<StoreSDNode>(N)->isTruncatingStore();
 
5714
 
 
5715
  }
 
5716
  case 25: { // Predicate_pre_truncst
 
5717
    SDNode *N = Node;
 
5718
 
 
5719
  ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
 
5720
  return AM == ISD::PRE_INC || AM == ISD::PRE_DEC;
 
5721
 
 
5722
  }
 
5723
  case 26: { // Predicate_pre_truncsti8
 
5724
    SDNode *N = Node;
 
5725
 
 
5726
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i8;
 
5727
 
 
5728
  }
 
5729
  case 27: { // Predicate_pre_truncsti16
 
5730
    SDNode *N = Node;
 
5731
 
 
5732
  return cast<StoreSDNode>(N)->getMemoryVT() == MVT::i16;
 
5733
 
 
5734
  }
 
5735
  case 28: { // Predicate_istore
 
5736
    SDNode *N = Node;
 
5737
 
 
5738
  return !cast<StoreSDNode>(N)->isTruncatingStore();
 
5739
 
 
5740
  }
 
5741
  case 29: { // Predicate_pre_store
 
5742
    SDNode *N = Node;
 
5743
 
 
5744
  ISD::MemIndexedMode AM = cast<StoreSDNode>(N)->getAddressingMode();
 
5745
  return AM == ISD::PRE_INC || AM == ISD::PRE_DEC;
 
5746
 
 
5747
  }
 
5748
  case 30: { // Predicate_V_immneg0
 
5749
    SDNode *N = Node;
 
5750
 
 
5751
  return PPC::isAllNegativeZeroVector(N);
 
5752
 
 
5753
  }
 
5754
  case 31: { // Predicate_atomic_load_add_8
 
5755
    SDNode *N = Node;
 
5756
 
 
5757
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
5758
  
 
5759
  }
 
5760
  case 32: { // Predicate_atomic_load_add_16
 
5761
    SDNode *N = Node;
 
5762
 
 
5763
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
5764
  
 
5765
  }
 
5766
  case 33: { // Predicate_atomic_load_add_32
 
5767
    SDNode *N = Node;
 
5768
 
 
5769
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
5770
  
 
5771
  }
 
5772
  case 34: { // Predicate_atomic_load_add_64
 
5773
    SDNode *N = Node;
 
5774
 
 
5775
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
5776
  
 
5777
  }
 
5778
  case 35: { // Predicate_atomic_load_sub_8
 
5779
    SDNode *N = Node;
 
5780
 
 
5781
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
5782
  
 
5783
  }
 
5784
  case 36: { // Predicate_atomic_load_sub_16
 
5785
    SDNode *N = Node;
 
5786
 
 
5787
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
5788
  
 
5789
  }
 
5790
  case 37: { // Predicate_atomic_load_sub_32
 
5791
    SDNode *N = Node;
 
5792
 
 
5793
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
5794
  
 
5795
  }
 
5796
  case 38: { // Predicate_atomic_load_sub_64
 
5797
    SDNode *N = Node;
 
5798
 
 
5799
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
5800
  
 
5801
  }
 
5802
  case 39: { // Predicate_atomic_load_and_8
 
5803
    SDNode *N = Node;
 
5804
 
 
5805
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
5806
  
 
5807
  }
 
5808
  case 40: { // Predicate_atomic_load_and_16
 
5809
    SDNode *N = Node;
 
5810
 
 
5811
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
5812
  
 
5813
  }
 
5814
  case 41: { // Predicate_atomic_load_and_32
 
5815
    SDNode *N = Node;
 
5816
 
 
5817
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
5818
  
 
5819
  }
 
5820
  case 42: { // Predicate_atomic_load_and_64
 
5821
    SDNode *N = Node;
 
5822
 
 
5823
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
5824
  
 
5825
  }
 
5826
  case 43: { // Predicate_atomic_load_or_8
 
5827
    SDNode *N = Node;
 
5828
 
 
5829
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
5830
  
 
5831
  }
 
5832
  case 44: { // Predicate_atomic_load_or_16
 
5833
    SDNode *N = Node;
 
5834
 
 
5835
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
5836
  
 
5837
  }
 
5838
  case 45: { // Predicate_atomic_load_or_32
 
5839
    SDNode *N = Node;
 
5840
 
 
5841
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
5842
  
 
5843
  }
 
5844
  case 46: { // Predicate_atomic_load_or_64
 
5845
    SDNode *N = Node;
 
5846
 
 
5847
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
5848
  
 
5849
  }
 
5850
  case 47: { // Predicate_atomic_load_xor_8
 
5851
    SDNode *N = Node;
 
5852
 
 
5853
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
5854
  
 
5855
  }
 
5856
  case 48: { // Predicate_atomic_load_xor_16
 
5857
    SDNode *N = Node;
 
5858
 
 
5859
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
5860
  
 
5861
  }
 
5862
  case 49: { // Predicate_atomic_load_xor_32
 
5863
    SDNode *N = Node;
 
5864
 
 
5865
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
5866
  
 
5867
  }
 
5868
  case 50: { // Predicate_atomic_load_xor_64
 
5869
    SDNode *N = Node;
 
5870
 
 
5871
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
5872
  
 
5873
  }
 
5874
  case 51: { // Predicate_atomic_load_nand_8
 
5875
    SDNode *N = Node;
 
5876
 
 
5877
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
5878
  
 
5879
  }
 
5880
  case 52: { // Predicate_atomic_load_nand_16
 
5881
    SDNode *N = Node;
 
5882
 
 
5883
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
5884
  
 
5885
  }
 
5886
  case 53: { // Predicate_atomic_load_nand_32
 
5887
    SDNode *N = Node;
 
5888
 
 
5889
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
5890
  
 
5891
  }
 
5892
  case 54: { // Predicate_atomic_load_nand_64
 
5893
    SDNode *N = Node;
 
5894
 
 
5895
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
5896
  
 
5897
  }
 
5898
  case 55: { // Predicate_atomic_cmp_swap_8
 
5899
    SDNode *N = Node;
 
5900
 
 
5901
  return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
5902
 
 
5903
  }
 
5904
  case 56: { // Predicate_atomic_cmp_swap_16
 
5905
    SDNode *N = Node;
 
5906
 
 
5907
  return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
5908
 
 
5909
  }
 
5910
  case 57: { // Predicate_atomic_cmp_swap_32
 
5911
    SDNode *N = Node;
 
5912
 
 
5913
  return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
5914
 
 
5915
  }
 
5916
  case 58: { // Predicate_atomic_cmp_swap_64
 
5917
    SDNode *N = Node;
 
5918
 
 
5919
  return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
5920
 
 
5921
  }
 
5922
  case 59: { // Predicate_atomic_swap_8
 
5923
    SDNode *N = Node;
 
5924
 
 
5925
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i8;
 
5926
  
 
5927
  }
 
5928
  case 60: { // Predicate_atomic_swap_16
 
5929
    SDNode *N = Node;
 
5930
 
 
5931
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i16;
 
5932
  
 
5933
  }
 
5934
  case 61: { // Predicate_atomic_swap_32
 
5935
    SDNode *N = Node;
 
5936
 
 
5937
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i32;
 
5938
  
 
5939
  }
 
5940
  case 62: { // Predicate_atomic_swap_64
 
5941
    SDNode *N = Node;
 
5942
 
 
5943
    return cast<AtomicSDNode>(N)->getMemoryVT() == MVT::i64;
 
5944
  
 
5945
  }
 
5946
  case 63: { // Predicate_immAllOnesV
 
5947
    SDNode *N = Node;
 
5948
 
 
5949
  return ISD::isBuildVectorAllOnes(N);
 
5950
 
 
5951
  }
 
5952
  case 64: { // Predicate_immAllOnesV_bc
 
5953
    SDNode *N = Node;
 
5954
 
 
5955
  return ISD::isBuildVectorAllOnes(N);
 
5956
 
 
5957
  }
 
5958
  case 65: { // Predicate_immZExt16
 
5959
    ConstantSDNode*N = cast<ConstantSDNode>(Node);
 
5960
 
 
5961
  // immZExt16 predicate - True if the immediate fits in a 16-bit zero extended
 
5962
  // field.  Used by instructions like 'ori'.
 
5963
  return (uint64_t)N->getZExtValue() == (unsigned short)N->getZExtValue();
 
5964
 
 
5965
  }
 
5966
  case 66: { // Predicate_imm16ShiftedZExt
 
5967
    ConstantSDNode*N = cast<ConstantSDNode>(Node);
 
5968
 
 
5969
  // imm16ShiftedZExt predicate - True if only bits in the top 16-bits of the
 
5970
  // immediate are set.  Used by instructions like 'xoris'.
 
5971
  return (N->getZExtValue() & ~uint64_t(0xFFFF0000)) == 0;
 
5972
 
 
5973
  }
 
5974
  case 67: { // Predicate_maskimm32
 
5975
    ConstantSDNode*N = cast<ConstantSDNode>(Node);
 
5976
 
 
5977
  // maskImm predicate - True if immediate is a run of ones.
 
5978
  unsigned mb, me;
 
5979
  if (N->getValueType(0) == MVT::i32)
 
5980
    return isRunOfOnes((unsigned)N->getZExtValue(), mb, me);
 
5981
  else
 
5982
    return false;
 
5983
 
 
5984
  }
 
5985
  case 68: { // Predicate_vspltb_shuffle
 
5986
    SDNode *N = Node;
 
5987
 
 
5988
  return PPC::isSplatShuffleMask(cast<ShuffleVectorSDNode>(N), 1);
 
5989
 
 
5990
  }
 
5991
  case 69: { // Predicate_vsplth_shuffle
 
5992
    SDNode *N = Node;
 
5993
 
 
5994
  return PPC::isSplatShuffleMask(cast<ShuffleVectorSDNode>(N), 2);
 
5995
 
 
5996
  }
 
5997
  case 70: { // Predicate_vspltw_shuffle
 
5998
    SDNode *N = Node;
 
5999
 
 
6000
  return PPC::isSplatShuffleMask(cast<ShuffleVectorSDNode>(N), 4);
 
6001
 
 
6002
  }
 
6003
  case 71: { // Predicate_vsldoi_unary_shuffle
 
6004
    SDNode *N = Node;
 
6005
 
 
6006
  return PPC::isVSLDOIShuffleMask(N, true) != -1;
 
6007
 
 
6008
  }
 
6009
  case 72: { // Predicate_vpkuwum_unary_shuffle
 
6010
    SDNode *N = Node;
 
6011
 
 
6012
  return PPC::isVPKUWUMShuffleMask(cast<ShuffleVectorSDNode>(N), true);
 
6013
 
 
6014
  }
 
6015
  case 73: { // Predicate_vpkuhum_unary_shuffle
 
6016
    SDNode *N = Node;
 
6017
 
 
6018
  return PPC::isVPKUHUMShuffleMask(cast<ShuffleVectorSDNode>(N), true);
 
6019
 
 
6020
  }
 
6021
  case 74: { // Predicate_vmrglb_unary_shuffle
 
6022
    SDNode *N = Node;
 
6023
 
 
6024
  return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 1, true);
 
6025
 
 
6026
  }
 
6027
  case 75: { // Predicate_vmrglh_unary_shuffle
 
6028
    SDNode *N = Node;
 
6029
 
 
6030
  return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 2, true);
 
6031
 
 
6032
  }
 
6033
  case 76: { // Predicate_vmrglw_unary_shuffle
 
6034
    SDNode *N = Node;
 
6035
 
 
6036
  return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 4, true);
 
6037
 
 
6038
  }
 
6039
  case 77: { // Predicate_vmrghb_unary_shuffle
 
6040
    SDNode *N = Node;
 
6041
 
 
6042
  return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 1, true);
 
6043
 
 
6044
  }
 
6045
  case 78: { // Predicate_vmrghh_unary_shuffle
 
6046
    SDNode *N = Node;
 
6047
 
 
6048
  return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 2, true);
 
6049
 
 
6050
  }
 
6051
  case 79: { // Predicate_vmrghw_unary_shuffle
 
6052
    SDNode *N = Node;
 
6053
 
 
6054
  return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 4, true);
 
6055
 
 
6056
  }
 
6057
  case 80: { // Predicate_vsldoi_shuffle
 
6058
    SDNode *N = Node;
 
6059
 
 
6060
  return PPC::isVSLDOIShuffleMask(N, false) != -1;
 
6061
 
 
6062
  }
 
6063
  case 81: { // Predicate_vmrghb_shuffle
 
6064
    SDNode *N = Node;
 
6065
 
 
6066
  return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 1, false);
 
6067
 
 
6068
  }
 
6069
  case 82: { // Predicate_vmrghh_shuffle
 
6070
    SDNode *N = Node;
 
6071
 
 
6072
  return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 2, false);
 
6073
 
 
6074
  }
 
6075
  case 83: { // Predicate_vmrghw_shuffle
 
6076
    SDNode *N = Node;
 
6077
 
 
6078
  return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 4, false);
 
6079
 
 
6080
  }
 
6081
  case 84: { // Predicate_vmrglb_shuffle
 
6082
    SDNode *N = Node;
 
6083
 
 
6084
  return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 1, false);
 
6085
 
 
6086
  }
 
6087
  case 85: { // Predicate_vmrglh_shuffle
 
6088
    SDNode *N = Node;
 
6089
 
 
6090
  return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 2, false);
 
6091
 
 
6092
  }
 
6093
  case 86: { // Predicate_vmrglw_shuffle
 
6094
    SDNode *N = Node;
 
6095
 
 
6096
  return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 4, false);
 
6097
 
 
6098
  }
 
6099
  case 87: { // Predicate_vpkuhum_shuffle
 
6100
    SDNode *N = Node;
 
6101
 
 
6102
  return PPC::isVPKUHUMShuffleMask(cast<ShuffleVectorSDNode>(N), false);
 
6103
 
 
6104
  }
 
6105
  case 88: { // Predicate_vpkuwum_shuffle
 
6106
    SDNode *N = Node;
 
6107
 
 
6108
  return PPC::isVPKUWUMShuffleMask(cast<ShuffleVectorSDNode>(N), false);
 
6109
 
 
6110
  }
 
6111
  case 89: { // Predicate_vecspltisb
 
6112
    SDNode *N = Node;
 
6113
 
 
6114
  return PPC::get_VSPLTI_elt(N, 1, *CurDAG).getNode() != 0;
 
6115
 
 
6116
  }
 
6117
  case 90: { // Predicate_vecspltish
 
6118
    SDNode *N = Node;
 
6119
 
 
6120
  return PPC::get_VSPLTI_elt(N, 2, *CurDAG).getNode() != 0;
 
6121
 
 
6122
  }
 
6123
  case 91: { // Predicate_vecspltisw
 
6124
    SDNode *N = Node;
 
6125
 
 
6126
  return PPC::get_VSPLTI_elt(N, 4, *CurDAG).getNode() != 0;
 
6127
 
 
6128
  }
 
6129
  case 92: { // Predicate_immAllZerosV
 
6130
    SDNode *N = Node;
 
6131
 
 
6132
  return ISD::isBuildVectorAllZeros(N);
 
6133
 
 
6134
  }
 
6135
  }
 
6136
}
 
6137
 
 
6138
bool CheckComplexPattern(SDNode *Root, SDValue N,
 
6139
      unsigned PatternNo, SmallVectorImpl<SDValue> &Result) {
 
6140
  switch (PatternNo) {
 
6141
  default: assert(0 && "Invalid pattern # in table?");
 
6142
  case 0:
 
6143
    Result.resize(Result.size()+2);
 
6144
    return SelectAddrIdxOnly(Root, N, Result[Result.size()-2], Result[Result.size()-1]);
 
6145
  case 1:
 
6146
    Result.resize(Result.size()+2);
 
6147
    return SelectAddrImm(Root, N, Result[Result.size()-2], Result[Result.size()-1]);
 
6148
  case 2:
 
6149
    Result.resize(Result.size()+2);
 
6150
    return SelectAddrIdx(Root, N, Result[Result.size()-2], Result[Result.size()-1]);
 
6151
  case 3:
 
6152
    Result.resize(Result.size()+2);
 
6153
    return SelectAddrImmShift(Root, N, Result[Result.size()-2], Result[Result.size()-1]);
 
6154
  case 4:
 
6155
    Result.resize(Result.size()+1);
 
6156
    return SelectAddrImmOffs(Root, N, Result[Result.size()-1]);
 
6157
  }
 
6158
}
 
6159
 
 
6160
SDValue RunSDNodeXForm(SDValue V, unsigned XFormNo) {
 
6161
  switch (XFormNo) {
 
6162
  default: assert(0 && "Invalid xform # in table?");
 
6163
  case 0: {  
 
6164
    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
 
6165
 
 
6166
  // Transformation function: shift the immediate value down into the low bits.
 
6167
  return getI32Imm((unsigned)N->getZExtValue() >> 16);
 
6168
 
 
6169
  }
 
6170
  case 1: {  
 
6171
    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
 
6172
 
 
6173
  // Transformation function: get the low 16 bits.
 
6174
  return getI32Imm((unsigned short)N->getZExtValue());
 
6175
 
 
6176
  }
 
6177
  case 2: {  
 
6178
    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
 
6179
 
 
6180
  // Transformation function: shift the immediate value down into the low bits.
 
6181
  signed int Val = N->getZExtValue();
 
6182
  return getI32Imm((Val - (signed short)Val) >> 16);
 
6183
 
 
6184
  }
 
6185
  case 3: {  
 
6186
    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
 
6187
 
 
6188
  // Transformation function: get the start bit of a mask
 
6189
  unsigned mb = 0, me;
 
6190
  (void)isRunOfOnes((unsigned)N->getZExtValue(), mb, me);
 
6191
  return getI32Imm(mb);
 
6192
 
 
6193
  }
 
6194
  case 4: {  
 
6195
    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
 
6196
 
 
6197
  // Transformation function: get the end bit of a mask
 
6198
  unsigned mb, me = 0;
 
6199
  (void)isRunOfOnes((unsigned)N->getZExtValue(), mb, me);
 
6200
  return getI32Imm(me);
 
6201
 
 
6202
  }
 
6203
  case 5: {  
 
6204
    SDNode *N = V.getNode();
 
6205
 
 
6206
  return getI32Imm(PPC::getVSPLTImmediate(N, 1));
 
6207
 
 
6208
  }
 
6209
  case 6: {  
 
6210
    SDNode *N = V.getNode();
 
6211
 
 
6212
  return getI32Imm(PPC::getVSPLTImmediate(N, 2));
 
6213
 
 
6214
  }
 
6215
  case 7: {  
 
6216
    SDNode *N = V.getNode();
 
6217
 
 
6218
  return getI32Imm(PPC::getVSPLTImmediate(N, 4));
 
6219
 
 
6220
  }
 
6221
  case 8: {  
 
6222
    SDNode *N = V.getNode();
 
6223
 
 
6224
  return getI32Imm(PPC::isVSLDOIShuffleMask(N, true));
 
6225
 
 
6226
  }
 
6227
  case 9: {  
 
6228
    SDNode *N = V.getNode();
 
6229
 
 
6230
  return getI32Imm(PPC::isVSLDOIShuffleMask(N, false));
 
6231
 
 
6232
  }
 
6233
  case 10: {  
 
6234
    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
 
6235
 
 
6236
  // Transformation function: 31 - imm
 
6237
  return getI32Imm(31 - N->getZExtValue());
 
6238
 
 
6239
  }
 
6240
  case 11: {  
 
6241
    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
 
6242
 
 
6243
  // Transformation function: 63 - imm
 
6244
  return getI32Imm(63 - N->getZExtValue());
 
6245
 
 
6246
  }
 
6247
  case 12: {  
 
6248
    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
 
6249
 
 
6250
  // Transformation function: 32 - imm
 
6251
  return N->getZExtValue() ? getI32Imm(32 - N->getZExtValue()) : getI32Imm(0);
 
6252
 
 
6253
  }
 
6254
  case 13: {  
 
6255
    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
 
6256
 
 
6257
  // Transformation function: 64 - imm
 
6258
  return N->getZExtValue() ? getI32Imm(64 - N->getZExtValue()) : getI32Imm(0);
 
6259
 
 
6260
  }
 
6261
  case 14: {  
 
6262
    SDNode *N = V.getNode();
 
6263
 
 
6264
  return PPC::get_VSPLTI_elt(N, 1, *CurDAG);
 
6265
 
 
6266
  }
 
6267
  case 15: {  
 
6268
    SDNode *N = V.getNode();
 
6269
 
 
6270
  return PPC::get_VSPLTI_elt(N, 2, *CurDAG);
 
6271
 
 
6272
  }
 
6273
  case 16: {  
 
6274
    SDNode *N = V.getNode();
 
6275
 
 
6276
  return PPC::get_VSPLTI_elt(N, 4, *CurDAG);
 
6277
 
 
6278
  }
 
6279
  }
 
6280
}
 
6281