[SystemZ] Fix expansion of ISD::FPOW and ISD::FSINCOS
[oota-llvm.git] / lib / Target / SystemZ / SystemZISelLowering.cpp
1 //===-- SystemZISelLowering.cpp - SystemZ DAG lowering implementation -----===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the SystemZTargetLowering class.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "SystemZISelLowering.h"
15 #include "SystemZCallingConv.h"
16 #include "SystemZConstantPoolValue.h"
17 #include "SystemZMachineFunctionInfo.h"
18 #include "SystemZTargetMachine.h"
19 #include "llvm/CodeGen/CallingConvLower.h"
20 #include "llvm/CodeGen/MachineInstrBuilder.h"
21 #include "llvm/CodeGen/MachineRegisterInfo.h"
22 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
23 #include "llvm/IR/Intrinsics.h"
24 #include <cctype>
25
26 using namespace llvm;
27
28 #define DEBUG_TYPE "systemz-lower"
29
30 namespace {
31 // Represents a sequence for extracting a 0/1 value from an IPM result:
32 // (((X ^ XORValue) + AddValue) >> Bit)
33 struct IPMConversion {
34   IPMConversion(unsigned xorValue, int64_t addValue, unsigned bit)
35     : XORValue(xorValue), AddValue(addValue), Bit(bit) {}
36
37   int64_t XORValue;
38   int64_t AddValue;
39   unsigned Bit;
40 };
41
42 // Represents information about a comparison.
43 struct Comparison {
44   Comparison(SDValue Op0In, SDValue Op1In)
45     : Op0(Op0In), Op1(Op1In), Opcode(0), ICmpType(0), CCValid(0), CCMask(0) {}
46
47   // The operands to the comparison.
48   SDValue Op0, Op1;
49
50   // The opcode that should be used to compare Op0 and Op1.
51   unsigned Opcode;
52
53   // A SystemZICMP value.  Only used for integer comparisons.
54   unsigned ICmpType;
55
56   // The mask of CC values that Opcode can produce.
57   unsigned CCValid;
58
59   // The mask of CC values for which the original condition is true.
60   unsigned CCMask;
61 };
62 } // end anonymous namespace
63
64 // Classify VT as either 32 or 64 bit.
65 static bool is32Bit(EVT VT) {
66   switch (VT.getSimpleVT().SimpleTy) {
67   case MVT::i32:
68     return true;
69   case MVT::i64:
70     return false;
71   default:
72     llvm_unreachable("Unsupported type");
73   }
74 }
75
76 // Return a version of MachineOperand that can be safely used before the
77 // final use.
78 static MachineOperand earlyUseOperand(MachineOperand Op) {
79   if (Op.isReg())
80     Op.setIsKill(false);
81   return Op;
82 }
83
84 SystemZTargetLowering::SystemZTargetLowering(const TargetMachine &TM,
85                                              const SystemZSubtarget &STI)
86     : TargetLowering(TM), Subtarget(STI) {
87   MVT PtrVT = MVT::getIntegerVT(8 * TM.getPointerSize());
88
89   // Set up the register classes.
90   if (Subtarget.hasHighWord())
91     addRegisterClass(MVT::i32, &SystemZ::GRX32BitRegClass);
92   else
93     addRegisterClass(MVT::i32, &SystemZ::GR32BitRegClass);
94   addRegisterClass(MVT::i64, &SystemZ::GR64BitRegClass);
95   if (Subtarget.hasVector()) {
96     addRegisterClass(MVT::f32, &SystemZ::VR32BitRegClass);
97     addRegisterClass(MVT::f64, &SystemZ::VR64BitRegClass);
98   } else {
99     addRegisterClass(MVT::f32, &SystemZ::FP32BitRegClass);
100     addRegisterClass(MVT::f64, &SystemZ::FP64BitRegClass);
101   }
102   addRegisterClass(MVT::f128, &SystemZ::FP128BitRegClass);
103
104   if (Subtarget.hasVector()) {
105     addRegisterClass(MVT::v16i8, &SystemZ::VR128BitRegClass);
106     addRegisterClass(MVT::v8i16, &SystemZ::VR128BitRegClass);
107     addRegisterClass(MVT::v4i32, &SystemZ::VR128BitRegClass);
108     addRegisterClass(MVT::v2i64, &SystemZ::VR128BitRegClass);
109     addRegisterClass(MVT::v4f32, &SystemZ::VR128BitRegClass);
110     addRegisterClass(MVT::v2f64, &SystemZ::VR128BitRegClass);
111   }
112
113   // Compute derived properties from the register classes
114   computeRegisterProperties(Subtarget.getRegisterInfo());
115
116   // Set up special registers.
117   setExceptionPointerRegister(SystemZ::R6D);
118   setExceptionSelectorRegister(SystemZ::R7D);
119   setStackPointerRegisterToSaveRestore(SystemZ::R15D);
120
121   // TODO: It may be better to default to latency-oriented scheduling, however
122   // LLVM's current latency-oriented scheduler can't handle physreg definitions
123   // such as SystemZ has with CC, so set this to the register-pressure
124   // scheduler, because it can.
125   setSchedulingPreference(Sched::RegPressure);
126
127   setBooleanContents(ZeroOrOneBooleanContent);
128   setBooleanVectorContents(ZeroOrNegativeOneBooleanContent);
129
130   // Instructions are strings of 2-byte aligned 2-byte values.
131   setMinFunctionAlignment(2);
132
133   // Handle operations that are handled in a similar way for all types.
134   for (unsigned I = MVT::FIRST_INTEGER_VALUETYPE;
135        I <= MVT::LAST_FP_VALUETYPE;
136        ++I) {
137     MVT VT = MVT::SimpleValueType(I);
138     if (isTypeLegal(VT)) {
139       // Lower SET_CC into an IPM-based sequence.
140       setOperationAction(ISD::SETCC, VT, Custom);
141
142       // Expand SELECT(C, A, B) into SELECT_CC(X, 0, A, B, NE).
143       setOperationAction(ISD::SELECT, VT, Expand);
144
145       // Lower SELECT_CC and BR_CC into separate comparisons and branches.
146       setOperationAction(ISD::SELECT_CC, VT, Custom);
147       setOperationAction(ISD::BR_CC,     VT, Custom);
148     }
149   }
150
151   // Expand jump table branches as address arithmetic followed by an
152   // indirect jump.
153   setOperationAction(ISD::BR_JT, MVT::Other, Expand);
154
155   // Expand BRCOND into a BR_CC (see above).
156   setOperationAction(ISD::BRCOND, MVT::Other, Expand);
157
158   // Handle integer types.
159   for (unsigned I = MVT::FIRST_INTEGER_VALUETYPE;
160        I <= MVT::LAST_INTEGER_VALUETYPE;
161        ++I) {
162     MVT VT = MVT::SimpleValueType(I);
163     if (isTypeLegal(VT)) {
164       // Expand individual DIV and REMs into DIVREMs.
165       setOperationAction(ISD::SDIV, VT, Expand);
166       setOperationAction(ISD::UDIV, VT, Expand);
167       setOperationAction(ISD::SREM, VT, Expand);
168       setOperationAction(ISD::UREM, VT, Expand);
169       setOperationAction(ISD::SDIVREM, VT, Custom);
170       setOperationAction(ISD::UDIVREM, VT, Custom);
171
172       // Lower ATOMIC_LOAD and ATOMIC_STORE into normal volatile loads and
173       // stores, putting a serialization instruction after the stores.
174       setOperationAction(ISD::ATOMIC_LOAD,  VT, Custom);
175       setOperationAction(ISD::ATOMIC_STORE, VT, Custom);
176
177       // Lower ATOMIC_LOAD_SUB into ATOMIC_LOAD_ADD if LAA and LAAG are
178       // available, or if the operand is constant.
179       setOperationAction(ISD::ATOMIC_LOAD_SUB, VT, Custom);
180
181       // Use POPCNT on z196 and above.
182       if (Subtarget.hasPopulationCount())
183         setOperationAction(ISD::CTPOP, VT, Custom);
184       else
185         setOperationAction(ISD::CTPOP, VT, Expand);
186
187       // No special instructions for these.
188       setOperationAction(ISD::CTTZ,            VT, Expand);
189       setOperationAction(ISD::CTTZ_ZERO_UNDEF, VT, Expand);
190       setOperationAction(ISD::CTLZ_ZERO_UNDEF, VT, Expand);
191       setOperationAction(ISD::ROTR,            VT, Expand);
192
193       // Use *MUL_LOHI where possible instead of MULH*.
194       setOperationAction(ISD::MULHS, VT, Expand);
195       setOperationAction(ISD::MULHU, VT, Expand);
196       setOperationAction(ISD::SMUL_LOHI, VT, Custom);
197       setOperationAction(ISD::UMUL_LOHI, VT, Custom);
198
199       // Only z196 and above have native support for conversions to unsigned.
200       if (!Subtarget.hasFPExtension())
201         setOperationAction(ISD::FP_TO_UINT, VT, Expand);
202     }
203   }
204
205   // Type legalization will convert 8- and 16-bit atomic operations into
206   // forms that operate on i32s (but still keeping the original memory VT).
207   // Lower them into full i32 operations.
208   setOperationAction(ISD::ATOMIC_SWAP,      MVT::i32, Custom);
209   setOperationAction(ISD::ATOMIC_LOAD_ADD,  MVT::i32, Custom);
210   setOperationAction(ISD::ATOMIC_LOAD_SUB,  MVT::i32, Custom);
211   setOperationAction(ISD::ATOMIC_LOAD_AND,  MVT::i32, Custom);
212   setOperationAction(ISD::ATOMIC_LOAD_OR,   MVT::i32, Custom);
213   setOperationAction(ISD::ATOMIC_LOAD_XOR,  MVT::i32, Custom);
214   setOperationAction(ISD::ATOMIC_LOAD_NAND, MVT::i32, Custom);
215   setOperationAction(ISD::ATOMIC_LOAD_MIN,  MVT::i32, Custom);
216   setOperationAction(ISD::ATOMIC_LOAD_MAX,  MVT::i32, Custom);
217   setOperationAction(ISD::ATOMIC_LOAD_UMIN, MVT::i32, Custom);
218   setOperationAction(ISD::ATOMIC_LOAD_UMAX, MVT::i32, Custom);
219   setOperationAction(ISD::ATOMIC_CMP_SWAP,  MVT::i32, Custom);
220
221   // z10 has instructions for signed but not unsigned FP conversion.
222   // Handle unsigned 32-bit types as signed 64-bit types.
223   if (!Subtarget.hasFPExtension()) {
224     setOperationAction(ISD::UINT_TO_FP, MVT::i32, Promote);
225     setOperationAction(ISD::UINT_TO_FP, MVT::i64, Expand);
226   }
227
228   // We have native support for a 64-bit CTLZ, via FLOGR.
229   setOperationAction(ISD::CTLZ, MVT::i32, Promote);
230   setOperationAction(ISD::CTLZ, MVT::i64, Legal);
231
232   // Give LowerOperation the chance to replace 64-bit ORs with subregs.
233   setOperationAction(ISD::OR, MVT::i64, Custom);
234
235   // FIXME: Can we support these natively?
236   setOperationAction(ISD::SRL_PARTS, MVT::i64, Expand);
237   setOperationAction(ISD::SHL_PARTS, MVT::i64, Expand);
238   setOperationAction(ISD::SRA_PARTS, MVT::i64, Expand);
239
240   // We have native instructions for i8, i16 and i32 extensions, but not i1.
241   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
242   for (MVT VT : MVT::integer_valuetypes()) {
243     setLoadExtAction(ISD::SEXTLOAD, VT, MVT::i1, Promote);
244     setLoadExtAction(ISD::ZEXTLOAD, VT, MVT::i1, Promote);
245     setLoadExtAction(ISD::EXTLOAD,  VT, MVT::i1, Promote);
246   }
247
248   // Handle the various types of symbolic address.
249   setOperationAction(ISD::ConstantPool,     PtrVT, Custom);
250   setOperationAction(ISD::GlobalAddress,    PtrVT, Custom);
251   setOperationAction(ISD::GlobalTLSAddress, PtrVT, Custom);
252   setOperationAction(ISD::BlockAddress,     PtrVT, Custom);
253   setOperationAction(ISD::JumpTable,        PtrVT, Custom);
254
255   // We need to handle dynamic allocations specially because of the
256   // 160-byte area at the bottom of the stack.
257   setOperationAction(ISD::DYNAMIC_STACKALLOC, PtrVT, Custom);
258
259   // Use custom expanders so that we can force the function to use
260   // a frame pointer.
261   setOperationAction(ISD::STACKSAVE,    MVT::Other, Custom);
262   setOperationAction(ISD::STACKRESTORE, MVT::Other, Custom);
263
264   // Handle prefetches with PFD or PFDRL.
265   setOperationAction(ISD::PREFETCH, MVT::Other, Custom);
266
267   for (MVT VT : MVT::vector_valuetypes()) {
268     // Assume by default that all vector operations need to be expanded.
269     for (unsigned Opcode = 0; Opcode < ISD::BUILTIN_OP_END; ++Opcode)
270       if (getOperationAction(Opcode, VT) == Legal)
271         setOperationAction(Opcode, VT, Expand);
272
273     // Likewise all truncating stores and extending loads.
274     for (MVT InnerVT : MVT::vector_valuetypes()) {
275       setTruncStoreAction(VT, InnerVT, Expand);
276       setLoadExtAction(ISD::SEXTLOAD, VT, InnerVT, Expand);
277       setLoadExtAction(ISD::ZEXTLOAD, VT, InnerVT, Expand);
278       setLoadExtAction(ISD::EXTLOAD, VT, InnerVT, Expand);
279     }
280
281     if (isTypeLegal(VT)) {
282       // These operations are legal for anything that can be stored in a
283       // vector register, even if there is no native support for the format
284       // as such.  In particular, we can do these for v4f32 even though there
285       // are no specific instructions for that format.
286       setOperationAction(ISD::LOAD, VT, Legal);
287       setOperationAction(ISD::STORE, VT, Legal);
288       setOperationAction(ISD::VSELECT, VT, Legal);
289       setOperationAction(ISD::BITCAST, VT, Legal);
290       setOperationAction(ISD::UNDEF, VT, Legal);
291
292       // Likewise, except that we need to replace the nodes with something
293       // more specific.
294       setOperationAction(ISD::BUILD_VECTOR, VT, Custom);
295       setOperationAction(ISD::VECTOR_SHUFFLE, VT, Custom);
296     }
297   }
298
299   // Handle integer vector types.
300   for (MVT VT : MVT::integer_vector_valuetypes()) {
301     if (isTypeLegal(VT)) {
302       // These operations have direct equivalents.
303       setOperationAction(ISD::EXTRACT_VECTOR_ELT, VT, Legal);
304       setOperationAction(ISD::INSERT_VECTOR_ELT, VT, Legal);
305       setOperationAction(ISD::ADD, VT, Legal);
306       setOperationAction(ISD::SUB, VT, Legal);
307       if (VT != MVT::v2i64)
308         setOperationAction(ISD::MUL, VT, Legal);
309       setOperationAction(ISD::AND, VT, Legal);
310       setOperationAction(ISD::OR, VT, Legal);
311       setOperationAction(ISD::XOR, VT, Legal);
312       setOperationAction(ISD::CTPOP, VT, Custom);
313       setOperationAction(ISD::CTTZ, VT, Legal);
314       setOperationAction(ISD::CTLZ, VT, Legal);
315       setOperationAction(ISD::CTTZ_ZERO_UNDEF, VT, Custom);
316       setOperationAction(ISD::CTLZ_ZERO_UNDEF, VT, Custom);
317
318       // Convert a GPR scalar to a vector by inserting it into element 0.
319       setOperationAction(ISD::SCALAR_TO_VECTOR, VT, Custom);
320
321       // Use a series of unpacks for extensions.
322       setOperationAction(ISD::SIGN_EXTEND_VECTOR_INREG, VT, Custom);
323       setOperationAction(ISD::ZERO_EXTEND_VECTOR_INREG, VT, Custom);
324
325       // Detect shifts by a scalar amount and convert them into
326       // V*_BY_SCALAR.
327       setOperationAction(ISD::SHL, VT, Custom);
328       setOperationAction(ISD::SRA, VT, Custom);
329       setOperationAction(ISD::SRL, VT, Custom);
330
331       // At present ROTL isn't matched by DAGCombiner.  ROTR should be
332       // converted into ROTL.
333       setOperationAction(ISD::ROTL, VT, Expand);
334       setOperationAction(ISD::ROTR, VT, Expand);
335
336       // Map SETCCs onto one of VCE, VCH or VCHL, swapping the operands
337       // and inverting the result as necessary.
338       setOperationAction(ISD::SETCC, VT, Custom);
339     }
340   }
341
342   if (Subtarget.hasVector()) {
343     // There should be no need to check for float types other than v2f64
344     // since <2 x f32> isn't a legal type.
345     setOperationAction(ISD::FP_TO_SINT, MVT::v2i64, Legal);
346     setOperationAction(ISD::FP_TO_UINT, MVT::v2i64, Legal);
347     setOperationAction(ISD::SINT_TO_FP, MVT::v2i64, Legal);
348     setOperationAction(ISD::UINT_TO_FP, MVT::v2i64, Legal);
349   }
350
351   // Handle floating-point types.
352   for (unsigned I = MVT::FIRST_FP_VALUETYPE;
353        I <= MVT::LAST_FP_VALUETYPE;
354        ++I) {
355     MVT VT = MVT::SimpleValueType(I);
356     if (isTypeLegal(VT)) {
357       // We can use FI for FRINT.
358       setOperationAction(ISD::FRINT, VT, Legal);
359
360       // We can use the extended form of FI for other rounding operations.
361       if (Subtarget.hasFPExtension()) {
362         setOperationAction(ISD::FNEARBYINT, VT, Legal);
363         setOperationAction(ISD::FFLOOR, VT, Legal);
364         setOperationAction(ISD::FCEIL, VT, Legal);
365         setOperationAction(ISD::FTRUNC, VT, Legal);
366         setOperationAction(ISD::FROUND, VT, Legal);
367       }
368
369       // No special instructions for these.
370       setOperationAction(ISD::FSIN, VT, Expand);
371       setOperationAction(ISD::FCOS, VT, Expand);
372       setOperationAction(ISD::FSINCOS, VT, Expand);
373       setOperationAction(ISD::FREM, VT, Expand);
374       setOperationAction(ISD::FPOW, VT, Expand);
375     }
376   }
377
378   // Handle floating-point vector types.
379   if (Subtarget.hasVector()) {
380     // Scalar-to-vector conversion is just a subreg.
381     setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v4f32, Legal);
382     setOperationAction(ISD::SCALAR_TO_VECTOR, MVT::v2f64, Legal);
383
384     // Some insertions and extractions can be done directly but others
385     // need to go via integers.
386     setOperationAction(ISD::INSERT_VECTOR_ELT, MVT::v4f32, Custom);
387     setOperationAction(ISD::INSERT_VECTOR_ELT, MVT::v2f64, Custom);
388     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v4f32, Custom);
389     setOperationAction(ISD::EXTRACT_VECTOR_ELT, MVT::v2f64, Custom);
390
391     // These operations have direct equivalents.
392     setOperationAction(ISD::FADD, MVT::v2f64, Legal);
393     setOperationAction(ISD::FNEG, MVT::v2f64, Legal);
394     setOperationAction(ISD::FSUB, MVT::v2f64, Legal);
395     setOperationAction(ISD::FMUL, MVT::v2f64, Legal);
396     setOperationAction(ISD::FMA, MVT::v2f64, Legal);
397     setOperationAction(ISD::FDIV, MVT::v2f64, Legal);
398     setOperationAction(ISD::FABS, MVT::v2f64, Legal);
399     setOperationAction(ISD::FSQRT, MVT::v2f64, Legal);
400     setOperationAction(ISD::FRINT, MVT::v2f64, Legal);
401     setOperationAction(ISD::FNEARBYINT, MVT::v2f64, Legal);
402     setOperationAction(ISD::FFLOOR, MVT::v2f64, Legal);
403     setOperationAction(ISD::FCEIL, MVT::v2f64, Legal);
404     setOperationAction(ISD::FTRUNC, MVT::v2f64, Legal);
405     setOperationAction(ISD::FROUND, MVT::v2f64, Legal);
406   }
407
408   // We have fused multiply-addition for f32 and f64 but not f128.
409   setOperationAction(ISD::FMA, MVT::f32,  Legal);
410   setOperationAction(ISD::FMA, MVT::f64,  Legal);
411   setOperationAction(ISD::FMA, MVT::f128, Expand);
412
413   // Needed so that we don't try to implement f128 constant loads using
414   // a load-and-extend of a f80 constant (in cases where the constant
415   // would fit in an f80).
416   for (MVT VT : MVT::fp_valuetypes())
417     setLoadExtAction(ISD::EXTLOAD, VT, MVT::f80, Expand);
418
419   // Floating-point truncation and stores need to be done separately.
420   setTruncStoreAction(MVT::f64,  MVT::f32, Expand);
421   setTruncStoreAction(MVT::f128, MVT::f32, Expand);
422   setTruncStoreAction(MVT::f128, MVT::f64, Expand);
423
424   // We have 64-bit FPR<->GPR moves, but need special handling for
425   // 32-bit forms.
426   if (!Subtarget.hasVector()) {
427     setOperationAction(ISD::BITCAST, MVT::i32, Custom);
428     setOperationAction(ISD::BITCAST, MVT::f32, Custom);
429   }
430
431   // VASTART and VACOPY need to deal with the SystemZ-specific varargs
432   // structure, but VAEND is a no-op.
433   setOperationAction(ISD::VASTART, MVT::Other, Custom);
434   setOperationAction(ISD::VACOPY,  MVT::Other, Custom);
435   setOperationAction(ISD::VAEND,   MVT::Other, Expand);
436
437   // Codes for which we want to perform some z-specific combinations.
438   setTargetDAGCombine(ISD::SIGN_EXTEND);
439   setTargetDAGCombine(ISD::STORE);
440   setTargetDAGCombine(ISD::EXTRACT_VECTOR_ELT);
441   setTargetDAGCombine(ISD::FP_ROUND);
442
443   // Handle intrinsics.
444   setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::Other, Custom);
445   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
446
447   // We want to use MVC in preference to even a single load/store pair.
448   MaxStoresPerMemcpy = 0;
449   MaxStoresPerMemcpyOptSize = 0;
450
451   // The main memset sequence is a byte store followed by an MVC.
452   // Two STC or MV..I stores win over that, but the kind of fused stores
453   // generated by target-independent code don't when the byte value is
454   // variable.  E.g.  "STC <reg>;MHI <reg>,257;STH <reg>" is not better
455   // than "STC;MVC".  Handle the choice in target-specific code instead.
456   MaxStoresPerMemset = 0;
457   MaxStoresPerMemsetOptSize = 0;
458 }
459
460 EVT SystemZTargetLowering::getSetCCResultType(const DataLayout &DL,
461                                               LLVMContext &, EVT VT) const {
462   if (!VT.isVector())
463     return MVT::i32;
464   return VT.changeVectorElementTypeToInteger();
465 }
466
467 bool SystemZTargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const {
468   VT = VT.getScalarType();
469
470   if (!VT.isSimple())
471     return false;
472
473   switch (VT.getSimpleVT().SimpleTy) {
474   case MVT::f32:
475   case MVT::f64:
476     return true;
477   case MVT::f128:
478     return false;
479   default:
480     break;
481   }
482
483   return false;
484 }
485
486 bool SystemZTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const {
487   // We can load zero using LZ?R and negative zero using LZ?R;LC?BR.
488   return Imm.isZero() || Imm.isNegZero();
489 }
490
491 bool SystemZTargetLowering::isLegalICmpImmediate(int64_t Imm) const {
492   // We can use CGFI or CLGFI.
493   return isInt<32>(Imm) || isUInt<32>(Imm);
494 }
495
496 bool SystemZTargetLowering::isLegalAddImmediate(int64_t Imm) const {
497   // We can use ALGFI or SLGFI.
498   return isUInt<32>(Imm) || isUInt<32>(-Imm);
499 }
500
501 bool SystemZTargetLowering::allowsMisalignedMemoryAccesses(EVT VT,
502                                                            unsigned,
503                                                            unsigned,
504                                                            bool *Fast) const {
505   // Unaligned accesses should never be slower than the expanded version.
506   // We check specifically for aligned accesses in the few cases where
507   // they are required.
508   if (Fast)
509     *Fast = true;
510   return true;
511 }
512
513 bool SystemZTargetLowering::isLegalAddressingMode(const DataLayout &DL,
514                                                   const AddrMode &AM, Type *Ty,
515                                                   unsigned AS) const {
516   // Punt on globals for now, although they can be used in limited
517   // RELATIVE LONG cases.
518   if (AM.BaseGV)
519     return false;
520
521   // Require a 20-bit signed offset.
522   if (!isInt<20>(AM.BaseOffs))
523     return false;
524
525   // Indexing is OK but no scale factor can be applied.
526   return AM.Scale == 0 || AM.Scale == 1;
527 }
528
529 bool SystemZTargetLowering::isTruncateFree(Type *FromType, Type *ToType) const {
530   if (!FromType->isIntegerTy() || !ToType->isIntegerTy())
531     return false;
532   unsigned FromBits = FromType->getPrimitiveSizeInBits();
533   unsigned ToBits = ToType->getPrimitiveSizeInBits();
534   return FromBits > ToBits;
535 }
536
537 bool SystemZTargetLowering::isTruncateFree(EVT FromVT, EVT ToVT) const {
538   if (!FromVT.isInteger() || !ToVT.isInteger())
539     return false;
540   unsigned FromBits = FromVT.getSizeInBits();
541   unsigned ToBits = ToVT.getSizeInBits();
542   return FromBits > ToBits;
543 }
544
545 //===----------------------------------------------------------------------===//
546 // Inline asm support
547 //===----------------------------------------------------------------------===//
548
549 TargetLowering::ConstraintType
550 SystemZTargetLowering::getConstraintType(StringRef Constraint) const {
551   if (Constraint.size() == 1) {
552     switch (Constraint[0]) {
553     case 'a': // Address register
554     case 'd': // Data register (equivalent to 'r')
555     case 'f': // Floating-point register
556     case 'h': // High-part register
557     case 'r': // General-purpose register
558       return C_RegisterClass;
559
560     case 'Q': // Memory with base and unsigned 12-bit displacement
561     case 'R': // Likewise, plus an index
562     case 'S': // Memory with base and signed 20-bit displacement
563     case 'T': // Likewise, plus an index
564     case 'm': // Equivalent to 'T'.
565       return C_Memory;
566
567     case 'I': // Unsigned 8-bit constant
568     case 'J': // Unsigned 12-bit constant
569     case 'K': // Signed 16-bit constant
570     case 'L': // Signed 20-bit displacement (on all targets we support)
571     case 'M': // 0x7fffffff
572       return C_Other;
573
574     default:
575       break;
576     }
577   }
578   return TargetLowering::getConstraintType(Constraint);
579 }
580
581 TargetLowering::ConstraintWeight SystemZTargetLowering::
582 getSingleConstraintMatchWeight(AsmOperandInfo &info,
583                                const char *constraint) const {
584   ConstraintWeight weight = CW_Invalid;
585   Value *CallOperandVal = info.CallOperandVal;
586   // If we don't have a value, we can't do a match,
587   // but allow it at the lowest weight.
588   if (!CallOperandVal)
589     return CW_Default;
590   Type *type = CallOperandVal->getType();
591   // Look at the constraint type.
592   switch (*constraint) {
593   default:
594     weight = TargetLowering::getSingleConstraintMatchWeight(info, constraint);
595     break;
596
597   case 'a': // Address register
598   case 'd': // Data register (equivalent to 'r')
599   case 'h': // High-part register
600   case 'r': // General-purpose register
601     if (CallOperandVal->getType()->isIntegerTy())
602       weight = CW_Register;
603     break;
604
605   case 'f': // Floating-point register
606     if (type->isFloatingPointTy())
607       weight = CW_Register;
608     break;
609
610   case 'I': // Unsigned 8-bit constant
611     if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
612       if (isUInt<8>(C->getZExtValue()))
613         weight = CW_Constant;
614     break;
615
616   case 'J': // Unsigned 12-bit constant
617     if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
618       if (isUInt<12>(C->getZExtValue()))
619         weight = CW_Constant;
620     break;
621
622   case 'K': // Signed 16-bit constant
623     if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
624       if (isInt<16>(C->getSExtValue()))
625         weight = CW_Constant;
626     break;
627
628   case 'L': // Signed 20-bit displacement (on all targets we support)
629     if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
630       if (isInt<20>(C->getSExtValue()))
631         weight = CW_Constant;
632     break;
633
634   case 'M': // 0x7fffffff
635     if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
636       if (C->getZExtValue() == 0x7fffffff)
637         weight = CW_Constant;
638     break;
639   }
640   return weight;
641 }
642
643 // Parse a "{tNNN}" register constraint for which the register type "t"
644 // has already been verified.  MC is the class associated with "t" and
645 // Map maps 0-based register numbers to LLVM register numbers.
646 static std::pair<unsigned, const TargetRegisterClass *>
647 parseRegisterNumber(StringRef Constraint, const TargetRegisterClass *RC,
648                     const unsigned *Map) {
649   assert(*(Constraint.end()-1) == '}' && "Missing '}'");
650   if (isdigit(Constraint[2])) {
651     unsigned Index;
652     bool Failed =
653         Constraint.slice(2, Constraint.size() - 1).getAsInteger(10, Index);
654     if (!Failed && Index < 16 && Map[Index])
655       return std::make_pair(Map[Index], RC);
656   }
657   return std::make_pair(0U, nullptr);
658 }
659
660 std::pair<unsigned, const TargetRegisterClass *>
661 SystemZTargetLowering::getRegForInlineAsmConstraint(
662     const TargetRegisterInfo *TRI, StringRef Constraint, MVT VT) const {
663   if (Constraint.size() == 1) {
664     // GCC Constraint Letters
665     switch (Constraint[0]) {
666     default: break;
667     case 'd': // Data register (equivalent to 'r')
668     case 'r': // General-purpose register
669       if (VT == MVT::i64)
670         return std::make_pair(0U, &SystemZ::GR64BitRegClass);
671       else if (VT == MVT::i128)
672         return std::make_pair(0U, &SystemZ::GR128BitRegClass);
673       return std::make_pair(0U, &SystemZ::GR32BitRegClass);
674
675     case 'a': // Address register
676       if (VT == MVT::i64)
677         return std::make_pair(0U, &SystemZ::ADDR64BitRegClass);
678       else if (VT == MVT::i128)
679         return std::make_pair(0U, &SystemZ::ADDR128BitRegClass);
680       return std::make_pair(0U, &SystemZ::ADDR32BitRegClass);
681
682     case 'h': // High-part register (an LLVM extension)
683       return std::make_pair(0U, &SystemZ::GRH32BitRegClass);
684
685     case 'f': // Floating-point register
686       if (VT == MVT::f64)
687         return std::make_pair(0U, &SystemZ::FP64BitRegClass);
688       else if (VT == MVT::f128)
689         return std::make_pair(0U, &SystemZ::FP128BitRegClass);
690       return std::make_pair(0U, &SystemZ::FP32BitRegClass);
691     }
692   }
693   if (Constraint.size() > 0 && Constraint[0] == '{') {
694     // We need to override the default register parsing for GPRs and FPRs
695     // because the interpretation depends on VT.  The internal names of
696     // the registers are also different from the external names
697     // (F0D and F0S instead of F0, etc.).
698     if (Constraint[1] == 'r') {
699       if (VT == MVT::i32)
700         return parseRegisterNumber(Constraint, &SystemZ::GR32BitRegClass,
701                                    SystemZMC::GR32Regs);
702       if (VT == MVT::i128)
703         return parseRegisterNumber(Constraint, &SystemZ::GR128BitRegClass,
704                                    SystemZMC::GR128Regs);
705       return parseRegisterNumber(Constraint, &SystemZ::GR64BitRegClass,
706                                  SystemZMC::GR64Regs);
707     }
708     if (Constraint[1] == 'f') {
709       if (VT == MVT::f32)
710         return parseRegisterNumber(Constraint, &SystemZ::FP32BitRegClass,
711                                    SystemZMC::FP32Regs);
712       if (VT == MVT::f128)
713         return parseRegisterNumber(Constraint, &SystemZ::FP128BitRegClass,
714                                    SystemZMC::FP128Regs);
715       return parseRegisterNumber(Constraint, &SystemZ::FP64BitRegClass,
716                                  SystemZMC::FP64Regs);
717     }
718   }
719   return TargetLowering::getRegForInlineAsmConstraint(TRI, Constraint, VT);
720 }
721
722 void SystemZTargetLowering::
723 LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint,
724                              std::vector<SDValue> &Ops,
725                              SelectionDAG &DAG) const {
726   // Only support length 1 constraints for now.
727   if (Constraint.length() == 1) {
728     switch (Constraint[0]) {
729     case 'I': // Unsigned 8-bit constant
730       if (auto *C = dyn_cast<ConstantSDNode>(Op))
731         if (isUInt<8>(C->getZExtValue()))
732           Ops.push_back(DAG.getTargetConstant(C->getZExtValue(), SDLoc(Op),
733                                               Op.getValueType()));
734       return;
735
736     case 'J': // Unsigned 12-bit constant
737       if (auto *C = dyn_cast<ConstantSDNode>(Op))
738         if (isUInt<12>(C->getZExtValue()))
739           Ops.push_back(DAG.getTargetConstant(C->getZExtValue(), SDLoc(Op),
740                                               Op.getValueType()));
741       return;
742
743     case 'K': // Signed 16-bit constant
744       if (auto *C = dyn_cast<ConstantSDNode>(Op))
745         if (isInt<16>(C->getSExtValue()))
746           Ops.push_back(DAG.getTargetConstant(C->getSExtValue(), SDLoc(Op),
747                                               Op.getValueType()));
748       return;
749
750     case 'L': // Signed 20-bit displacement (on all targets we support)
751       if (auto *C = dyn_cast<ConstantSDNode>(Op))
752         if (isInt<20>(C->getSExtValue()))
753           Ops.push_back(DAG.getTargetConstant(C->getSExtValue(), SDLoc(Op),
754                                               Op.getValueType()));
755       return;
756
757     case 'M': // 0x7fffffff
758       if (auto *C = dyn_cast<ConstantSDNode>(Op))
759         if (C->getZExtValue() == 0x7fffffff)
760           Ops.push_back(DAG.getTargetConstant(C->getZExtValue(), SDLoc(Op),
761                                               Op.getValueType()));
762       return;
763     }
764   }
765   TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
766 }
767
768 //===----------------------------------------------------------------------===//
769 // Calling conventions
770 //===----------------------------------------------------------------------===//
771
772 #include "SystemZGenCallingConv.inc"
773
774 bool SystemZTargetLowering::allowTruncateForTailCall(Type *FromType,
775                                                      Type *ToType) const {
776   return isTruncateFree(FromType, ToType);
777 }
778
779 bool SystemZTargetLowering::mayBeEmittedAsTailCall(CallInst *CI) const {
780   if (!CI->isTailCall())
781     return false;
782   return true;
783 }
784
785 // We do not yet support 128-bit single-element vector types.  If the user
786 // attempts to use such types as function argument or return type, prefer
787 // to error out instead of emitting code violating the ABI.
788 static void VerifyVectorType(MVT VT, EVT ArgVT) {
789   if (ArgVT.isVector() && !VT.isVector())
790     report_fatal_error("Unsupported vector argument or return type");
791 }
792
793 static void VerifyVectorTypes(const SmallVectorImpl<ISD::InputArg> &Ins) {
794   for (unsigned i = 0; i < Ins.size(); ++i)
795     VerifyVectorType(Ins[i].VT, Ins[i].ArgVT);
796 }
797
798 static void VerifyVectorTypes(const SmallVectorImpl<ISD::OutputArg> &Outs) {
799   for (unsigned i = 0; i < Outs.size(); ++i)
800     VerifyVectorType(Outs[i].VT, Outs[i].ArgVT);
801 }
802
803 // Value is a value that has been passed to us in the location described by VA
804 // (and so has type VA.getLocVT()).  Convert Value to VA.getValVT(), chaining
805 // any loads onto Chain.
806 static SDValue convertLocVTToValVT(SelectionDAG &DAG, SDLoc DL,
807                                    CCValAssign &VA, SDValue Chain,
808                                    SDValue Value) {
809   // If the argument has been promoted from a smaller type, insert an
810   // assertion to capture this.
811   if (VA.getLocInfo() == CCValAssign::SExt)
812     Value = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), Value,
813                         DAG.getValueType(VA.getValVT()));
814   else if (VA.getLocInfo() == CCValAssign::ZExt)
815     Value = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), Value,
816                         DAG.getValueType(VA.getValVT()));
817
818   if (VA.isExtInLoc())
819     Value = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Value);
820   else if (VA.getLocInfo() == CCValAssign::Indirect)
821     Value = DAG.getLoad(VA.getValVT(), DL, Chain, Value,
822                         MachinePointerInfo(), false, false, false, 0);
823   else if (VA.getLocInfo() == CCValAssign::BCvt) {
824     // If this is a short vector argument loaded from the stack,
825     // extend from i64 to full vector size and then bitcast.
826     assert(VA.getLocVT() == MVT::i64);
827     assert(VA.getValVT().isVector());
828     Value = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v2i64,
829                         Value, DAG.getUNDEF(MVT::i64));
830     Value = DAG.getNode(ISD::BITCAST, DL, VA.getValVT(), Value);
831   } else
832     assert(VA.getLocInfo() == CCValAssign::Full && "Unsupported getLocInfo");
833   return Value;
834 }
835
836 // Value is a value of type VA.getValVT() that we need to copy into
837 // the location described by VA.  Return a copy of Value converted to
838 // VA.getValVT().  The caller is responsible for handling indirect values.
839 static SDValue convertValVTToLocVT(SelectionDAG &DAG, SDLoc DL,
840                                    CCValAssign &VA, SDValue Value) {
841   switch (VA.getLocInfo()) {
842   case CCValAssign::SExt:
843     return DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), Value);
844   case CCValAssign::ZExt:
845     return DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), Value);
846   case CCValAssign::AExt:
847     return DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), Value);
848   case CCValAssign::BCvt:
849     // If this is a short vector argument to be stored to the stack,
850     // bitcast to v2i64 and then extract first element.
851     assert(VA.getLocVT() == MVT::i64);
852     assert(VA.getValVT().isVector());
853     Value = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Value);
854     return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VA.getLocVT(), Value,
855                        DAG.getConstant(0, DL, MVT::i32));
856   case CCValAssign::Full:
857     return Value;
858   default:
859     llvm_unreachable("Unhandled getLocInfo()");
860   }
861 }
862
863 SDValue SystemZTargetLowering::
864 LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool IsVarArg,
865                      const SmallVectorImpl<ISD::InputArg> &Ins,
866                      SDLoc DL, SelectionDAG &DAG,
867                      SmallVectorImpl<SDValue> &InVals) const {
868   MachineFunction &MF = DAG.getMachineFunction();
869   MachineFrameInfo *MFI = MF.getFrameInfo();
870   MachineRegisterInfo &MRI = MF.getRegInfo();
871   SystemZMachineFunctionInfo *FuncInfo =
872       MF.getInfo<SystemZMachineFunctionInfo>();
873   auto *TFL =
874       static_cast<const SystemZFrameLowering *>(Subtarget.getFrameLowering());
875
876   // Detect unsupported vector argument types.
877   if (Subtarget.hasVector())
878     VerifyVectorTypes(Ins);
879
880   // Assign locations to all of the incoming arguments.
881   SmallVector<CCValAssign, 16> ArgLocs;
882   SystemZCCState CCInfo(CallConv, IsVarArg, MF, ArgLocs, *DAG.getContext());
883   CCInfo.AnalyzeFormalArguments(Ins, CC_SystemZ);
884
885   unsigned NumFixedGPRs = 0;
886   unsigned NumFixedFPRs = 0;
887   for (unsigned I = 0, E = ArgLocs.size(); I != E; ++I) {
888     SDValue ArgValue;
889     CCValAssign &VA = ArgLocs[I];
890     EVT LocVT = VA.getLocVT();
891     if (VA.isRegLoc()) {
892       // Arguments passed in registers
893       const TargetRegisterClass *RC;
894       switch (LocVT.getSimpleVT().SimpleTy) {
895       default:
896         // Integers smaller than i64 should be promoted to i64.
897         llvm_unreachable("Unexpected argument type");
898       case MVT::i32:
899         NumFixedGPRs += 1;
900         RC = &SystemZ::GR32BitRegClass;
901         break;
902       case MVT::i64:
903         NumFixedGPRs += 1;
904         RC = &SystemZ::GR64BitRegClass;
905         break;
906       case MVT::f32:
907         NumFixedFPRs += 1;
908         RC = &SystemZ::FP32BitRegClass;
909         break;
910       case MVT::f64:
911         NumFixedFPRs += 1;
912         RC = &SystemZ::FP64BitRegClass;
913         break;
914       case MVT::v16i8:
915       case MVT::v8i16:
916       case MVT::v4i32:
917       case MVT::v2i64:
918       case MVT::v4f32:
919       case MVT::v2f64:
920         RC = &SystemZ::VR128BitRegClass;
921         break;
922       }
923
924       unsigned VReg = MRI.createVirtualRegister(RC);
925       MRI.addLiveIn(VA.getLocReg(), VReg);
926       ArgValue = DAG.getCopyFromReg(Chain, DL, VReg, LocVT);
927     } else {
928       assert(VA.isMemLoc() && "Argument not register or memory");
929
930       // Create the frame index object for this incoming parameter.
931       int FI = MFI->CreateFixedObject(LocVT.getSizeInBits() / 8,
932                                       VA.getLocMemOffset(), true);
933
934       // Create the SelectionDAG nodes corresponding to a load
935       // from this parameter.  Unpromoted ints and floats are
936       // passed as right-justified 8-byte values.
937       EVT PtrVT = getPointerTy(DAG.getDataLayout());
938       SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
939       if (VA.getLocVT() == MVT::i32 || VA.getLocVT() == MVT::f32)
940         FIN = DAG.getNode(ISD::ADD, DL, PtrVT, FIN,
941                           DAG.getIntPtrConstant(4, DL));
942       ArgValue = DAG.getLoad(LocVT, DL, Chain, FIN,
943                              MachinePointerInfo::getFixedStack(MF, FI), false,
944                              false, false, 0);
945     }
946
947     // Convert the value of the argument register into the value that's
948     // being passed.
949     InVals.push_back(convertLocVTToValVT(DAG, DL, VA, Chain, ArgValue));
950   }
951
952   if (IsVarArg) {
953     // Save the number of non-varargs registers for later use by va_start, etc.
954     FuncInfo->setVarArgsFirstGPR(NumFixedGPRs);
955     FuncInfo->setVarArgsFirstFPR(NumFixedFPRs);
956
957     // Likewise the address (in the form of a frame index) of where the
958     // first stack vararg would be.  The 1-byte size here is arbitrary.
959     int64_t StackSize = CCInfo.getNextStackOffset();
960     FuncInfo->setVarArgsFrameIndex(MFI->CreateFixedObject(1, StackSize, true));
961
962     // ...and a similar frame index for the caller-allocated save area
963     // that will be used to store the incoming registers.
964     int64_t RegSaveOffset = TFL->getOffsetOfLocalArea();
965     unsigned RegSaveIndex = MFI->CreateFixedObject(1, RegSaveOffset, true);
966     FuncInfo->setRegSaveFrameIndex(RegSaveIndex);
967
968     // Store the FPR varargs in the reserved frame slots.  (We store the
969     // GPRs as part of the prologue.)
970     if (NumFixedFPRs < SystemZ::NumArgFPRs) {
971       SDValue MemOps[SystemZ::NumArgFPRs];
972       for (unsigned I = NumFixedFPRs; I < SystemZ::NumArgFPRs; ++I) {
973         unsigned Offset = TFL->getRegSpillOffset(SystemZ::ArgFPRs[I]);
974         int FI = MFI->CreateFixedObject(8, RegSaveOffset + Offset, true);
975         SDValue FIN = DAG.getFrameIndex(FI, getPointerTy(DAG.getDataLayout()));
976         unsigned VReg = MF.addLiveIn(SystemZ::ArgFPRs[I],
977                                      &SystemZ::FP64BitRegClass);
978         SDValue ArgValue = DAG.getCopyFromReg(Chain, DL, VReg, MVT::f64);
979         MemOps[I] = DAG.getStore(ArgValue.getValue(1), DL, ArgValue, FIN,
980                                  MachinePointerInfo::getFixedStack(MF, FI),
981                                  false, false, 0);
982       }
983       // Join the stores, which are independent of one another.
984       Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
985                           makeArrayRef(&MemOps[NumFixedFPRs],
986                                        SystemZ::NumArgFPRs-NumFixedFPRs));
987     }
988   }
989
990   return Chain;
991 }
992
993 static bool canUseSiblingCall(const CCState &ArgCCInfo,
994                               SmallVectorImpl<CCValAssign> &ArgLocs) {
995   // Punt if there are any indirect or stack arguments, or if the call
996   // needs the call-saved argument register R6.
997   for (unsigned I = 0, E = ArgLocs.size(); I != E; ++I) {
998     CCValAssign &VA = ArgLocs[I];
999     if (VA.getLocInfo() == CCValAssign::Indirect)
1000       return false;
1001     if (!VA.isRegLoc())
1002       return false;
1003     unsigned Reg = VA.getLocReg();
1004     if (Reg == SystemZ::R6H || Reg == SystemZ::R6L || Reg == SystemZ::R6D)
1005       return false;
1006   }
1007   return true;
1008 }
1009
1010 SDValue
1011 SystemZTargetLowering::LowerCall(CallLoweringInfo &CLI,
1012                                  SmallVectorImpl<SDValue> &InVals) const {
1013   SelectionDAG &DAG = CLI.DAG;
1014   SDLoc &DL = CLI.DL;
1015   SmallVectorImpl<ISD::OutputArg> &Outs = CLI.Outs;
1016   SmallVectorImpl<SDValue> &OutVals = CLI.OutVals;
1017   SmallVectorImpl<ISD::InputArg> &Ins = CLI.Ins;
1018   SDValue Chain = CLI.Chain;
1019   SDValue Callee = CLI.Callee;
1020   bool &IsTailCall = CLI.IsTailCall;
1021   CallingConv::ID CallConv = CLI.CallConv;
1022   bool IsVarArg = CLI.IsVarArg;
1023   MachineFunction &MF = DAG.getMachineFunction();
1024   EVT PtrVT = getPointerTy(MF.getDataLayout());
1025
1026   // Detect unsupported vector argument and return types.
1027   if (Subtarget.hasVector()) {
1028     VerifyVectorTypes(Outs);
1029     VerifyVectorTypes(Ins);
1030   }
1031
1032   // Analyze the operands of the call, assigning locations to each operand.
1033   SmallVector<CCValAssign, 16> ArgLocs;
1034   SystemZCCState ArgCCInfo(CallConv, IsVarArg, MF, ArgLocs, *DAG.getContext());
1035   ArgCCInfo.AnalyzeCallOperands(Outs, CC_SystemZ);
1036
1037   // We don't support GuaranteedTailCallOpt, only automatically-detected
1038   // sibling calls.
1039   if (IsTailCall && !canUseSiblingCall(ArgCCInfo, ArgLocs))
1040     IsTailCall = false;
1041
1042   // Get a count of how many bytes are to be pushed on the stack.
1043   unsigned NumBytes = ArgCCInfo.getNextStackOffset();
1044
1045   // Mark the start of the call.
1046   if (!IsTailCall)
1047     Chain = DAG.getCALLSEQ_START(Chain,
1048                                  DAG.getConstant(NumBytes, DL, PtrVT, true),
1049                                  DL);
1050
1051   // Copy argument values to their designated locations.
1052   SmallVector<std::pair<unsigned, SDValue>, 9> RegsToPass;
1053   SmallVector<SDValue, 8> MemOpChains;
1054   SDValue StackPtr;
1055   for (unsigned I = 0, E = ArgLocs.size(); I != E; ++I) {
1056     CCValAssign &VA = ArgLocs[I];
1057     SDValue ArgValue = OutVals[I];
1058
1059     if (VA.getLocInfo() == CCValAssign::Indirect) {
1060       // Store the argument in a stack slot and pass its address.
1061       SDValue SpillSlot = DAG.CreateStackTemporary(VA.getValVT());
1062       int FI = cast<FrameIndexSDNode>(SpillSlot)->getIndex();
1063       MemOpChains.push_back(DAG.getStore(
1064           Chain, DL, ArgValue, SpillSlot,
1065           MachinePointerInfo::getFixedStack(MF, FI), false, false, 0));
1066       ArgValue = SpillSlot;
1067     } else
1068       ArgValue = convertValVTToLocVT(DAG, DL, VA, ArgValue);
1069
1070     if (VA.isRegLoc())
1071       // Queue up the argument copies and emit them at the end.
1072       RegsToPass.push_back(std::make_pair(VA.getLocReg(), ArgValue));
1073     else {
1074       assert(VA.isMemLoc() && "Argument not register or memory");
1075
1076       // Work out the address of the stack slot.  Unpromoted ints and
1077       // floats are passed as right-justified 8-byte values.
1078       if (!StackPtr.getNode())
1079         StackPtr = DAG.getCopyFromReg(Chain, DL, SystemZ::R15D, PtrVT);
1080       unsigned Offset = SystemZMC::CallFrameSize + VA.getLocMemOffset();
1081       if (VA.getLocVT() == MVT::i32 || VA.getLocVT() == MVT::f32)
1082         Offset += 4;
1083       SDValue Address = DAG.getNode(ISD::ADD, DL, PtrVT, StackPtr,
1084                                     DAG.getIntPtrConstant(Offset, DL));
1085
1086       // Emit the store.
1087       MemOpChains.push_back(DAG.getStore(Chain, DL, ArgValue, Address,
1088                                          MachinePointerInfo(),
1089                                          false, false, 0));
1090     }
1091   }
1092
1093   // Join the stores, which are independent of one another.
1094   if (!MemOpChains.empty())
1095     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOpChains);
1096
1097   // Accept direct calls by converting symbolic call addresses to the
1098   // associated Target* opcodes.  Force %r1 to be used for indirect
1099   // tail calls.
1100   SDValue Glue;
1101   if (auto *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
1102     Callee = DAG.getTargetGlobalAddress(G->getGlobal(), DL, PtrVT);
1103     Callee = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Callee);
1104   } else if (auto *E = dyn_cast<ExternalSymbolSDNode>(Callee)) {
1105     Callee = DAG.getTargetExternalSymbol(E->getSymbol(), PtrVT);
1106     Callee = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Callee);
1107   } else if (IsTailCall) {
1108     Chain = DAG.getCopyToReg(Chain, DL, SystemZ::R1D, Callee, Glue);
1109     Glue = Chain.getValue(1);
1110     Callee = DAG.getRegister(SystemZ::R1D, Callee.getValueType());
1111   }
1112
1113   // Build a sequence of copy-to-reg nodes, chained and glued together.
1114   for (unsigned I = 0, E = RegsToPass.size(); I != E; ++I) {
1115     Chain = DAG.getCopyToReg(Chain, DL, RegsToPass[I].first,
1116                              RegsToPass[I].second, Glue);
1117     Glue = Chain.getValue(1);
1118   }
1119
1120   // The first call operand is the chain and the second is the target address.
1121   SmallVector<SDValue, 8> Ops;
1122   Ops.push_back(Chain);
1123   Ops.push_back(Callee);
1124
1125   // Add argument registers to the end of the list so that they are
1126   // known live into the call.
1127   for (unsigned I = 0, E = RegsToPass.size(); I != E; ++I)
1128     Ops.push_back(DAG.getRegister(RegsToPass[I].first,
1129                                   RegsToPass[I].second.getValueType()));
1130
1131   // Add a register mask operand representing the call-preserved registers.
1132   const TargetRegisterInfo *TRI = Subtarget.getRegisterInfo();
1133   const uint32_t *Mask = TRI->getCallPreservedMask(MF, CallConv);
1134   assert(Mask && "Missing call preserved mask for calling convention");
1135   Ops.push_back(DAG.getRegisterMask(Mask));
1136
1137   // Glue the call to the argument copies, if any.
1138   if (Glue.getNode())
1139     Ops.push_back(Glue);
1140
1141   // Emit the call.
1142   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
1143   if (IsTailCall)
1144     return DAG.getNode(SystemZISD::SIBCALL, DL, NodeTys, Ops);
1145   Chain = DAG.getNode(SystemZISD::CALL, DL, NodeTys, Ops);
1146   Glue = Chain.getValue(1);
1147
1148   // Mark the end of the call, which is glued to the call itself.
1149   Chain = DAG.getCALLSEQ_END(Chain,
1150                              DAG.getConstant(NumBytes, DL, PtrVT, true),
1151                              DAG.getConstant(0, DL, PtrVT, true),
1152                              Glue, DL);
1153   Glue = Chain.getValue(1);
1154
1155   // Assign locations to each value returned by this call.
1156   SmallVector<CCValAssign, 16> RetLocs;
1157   CCState RetCCInfo(CallConv, IsVarArg, MF, RetLocs, *DAG.getContext());
1158   RetCCInfo.AnalyzeCallResult(Ins, RetCC_SystemZ);
1159
1160   // Copy all of the result registers out of their specified physreg.
1161   for (unsigned I = 0, E = RetLocs.size(); I != E; ++I) {
1162     CCValAssign &VA = RetLocs[I];
1163
1164     // Copy the value out, gluing the copy to the end of the call sequence.
1165     SDValue RetValue = DAG.getCopyFromReg(Chain, DL, VA.getLocReg(),
1166                                           VA.getLocVT(), Glue);
1167     Chain = RetValue.getValue(1);
1168     Glue = RetValue.getValue(2);
1169
1170     // Convert the value of the return register into the value that's
1171     // being returned.
1172     InVals.push_back(convertLocVTToValVT(DAG, DL, VA, Chain, RetValue));
1173   }
1174
1175   return Chain;
1176 }
1177
1178 bool SystemZTargetLowering::
1179 CanLowerReturn(CallingConv::ID CallConv,
1180                MachineFunction &MF, bool isVarArg,
1181                const SmallVectorImpl<ISD::OutputArg> &Outs,
1182                LLVMContext &Context) const {
1183   // Detect unsupported vector return types.
1184   if (Subtarget.hasVector())
1185     VerifyVectorTypes(Outs);
1186
1187   SmallVector<CCValAssign, 16> RetLocs;
1188   CCState RetCCInfo(CallConv, isVarArg, MF, RetLocs, Context);
1189   return RetCCInfo.CheckReturn(Outs, RetCC_SystemZ);
1190 }
1191
1192 SDValue
1193 SystemZTargetLowering::LowerReturn(SDValue Chain,
1194                                    CallingConv::ID CallConv, bool IsVarArg,
1195                                    const SmallVectorImpl<ISD::OutputArg> &Outs,
1196                                    const SmallVectorImpl<SDValue> &OutVals,
1197                                    SDLoc DL, SelectionDAG &DAG) const {
1198   MachineFunction &MF = DAG.getMachineFunction();
1199
1200   // Detect unsupported vector return types.
1201   if (Subtarget.hasVector())
1202     VerifyVectorTypes(Outs);
1203
1204   // Assign locations to each returned value.
1205   SmallVector<CCValAssign, 16> RetLocs;
1206   CCState RetCCInfo(CallConv, IsVarArg, MF, RetLocs, *DAG.getContext());
1207   RetCCInfo.AnalyzeReturn(Outs, RetCC_SystemZ);
1208
1209   // Quick exit for void returns
1210   if (RetLocs.empty())
1211     return DAG.getNode(SystemZISD::RET_FLAG, DL, MVT::Other, Chain);
1212
1213   // Copy the result values into the output registers.
1214   SDValue Glue;
1215   SmallVector<SDValue, 4> RetOps;
1216   RetOps.push_back(Chain);
1217   for (unsigned I = 0, E = RetLocs.size(); I != E; ++I) {
1218     CCValAssign &VA = RetLocs[I];
1219     SDValue RetValue = OutVals[I];
1220
1221     // Make the return register live on exit.
1222     assert(VA.isRegLoc() && "Can only return in registers!");
1223
1224     // Promote the value as required.
1225     RetValue = convertValVTToLocVT(DAG, DL, VA, RetValue);
1226
1227     // Chain and glue the copies together.
1228     unsigned Reg = VA.getLocReg();
1229     Chain = DAG.getCopyToReg(Chain, DL, Reg, RetValue, Glue);
1230     Glue = Chain.getValue(1);
1231     RetOps.push_back(DAG.getRegister(Reg, VA.getLocVT()));
1232   }
1233
1234   // Update chain and glue.
1235   RetOps[0] = Chain;
1236   if (Glue.getNode())
1237     RetOps.push_back(Glue);
1238
1239   return DAG.getNode(SystemZISD::RET_FLAG, DL, MVT::Other, RetOps);
1240 }
1241
1242 SDValue SystemZTargetLowering::
1243 prepareVolatileOrAtomicLoad(SDValue Chain, SDLoc DL, SelectionDAG &DAG) const {
1244   return DAG.getNode(SystemZISD::SERIALIZE, DL, MVT::Other, Chain);
1245 }
1246
1247 // Return true if Op is an intrinsic node with chain that returns the CC value
1248 // as its only (other) argument.  Provide the associated SystemZISD opcode and
1249 // the mask of valid CC values if so.
1250 static bool isIntrinsicWithCCAndChain(SDValue Op, unsigned &Opcode,
1251                                       unsigned &CCValid) {
1252   unsigned Id = cast<ConstantSDNode>(Op.getOperand(1))->getZExtValue();
1253   switch (Id) {
1254   case Intrinsic::s390_tbegin:
1255     Opcode = SystemZISD::TBEGIN;
1256     CCValid = SystemZ::CCMASK_TBEGIN;
1257     return true;
1258
1259   case Intrinsic::s390_tbegin_nofloat:
1260     Opcode = SystemZISD::TBEGIN_NOFLOAT;
1261     CCValid = SystemZ::CCMASK_TBEGIN;
1262     return true;
1263
1264   case Intrinsic::s390_tend:
1265     Opcode = SystemZISD::TEND;
1266     CCValid = SystemZ::CCMASK_TEND;
1267     return true;
1268
1269   default:
1270     return false;
1271   }
1272 }
1273
1274 // Return true if Op is an intrinsic node without chain that returns the
1275 // CC value as its final argument.  Provide the associated SystemZISD
1276 // opcode and the mask of valid CC values if so.
1277 static bool isIntrinsicWithCC(SDValue Op, unsigned &Opcode, unsigned &CCValid) {
1278   unsigned Id = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
1279   switch (Id) {
1280   case Intrinsic::s390_vpkshs:
1281   case Intrinsic::s390_vpksfs:
1282   case Intrinsic::s390_vpksgs:
1283     Opcode = SystemZISD::PACKS_CC;
1284     CCValid = SystemZ::CCMASK_VCMP;
1285     return true;
1286
1287   case Intrinsic::s390_vpklshs:
1288   case Intrinsic::s390_vpklsfs:
1289   case Intrinsic::s390_vpklsgs:
1290     Opcode = SystemZISD::PACKLS_CC;
1291     CCValid = SystemZ::CCMASK_VCMP;
1292     return true;
1293
1294   case Intrinsic::s390_vceqbs:
1295   case Intrinsic::s390_vceqhs:
1296   case Intrinsic::s390_vceqfs:
1297   case Intrinsic::s390_vceqgs:
1298     Opcode = SystemZISD::VICMPES;
1299     CCValid = SystemZ::CCMASK_VCMP;
1300     return true;
1301
1302   case Intrinsic::s390_vchbs:
1303   case Intrinsic::s390_vchhs:
1304   case Intrinsic::s390_vchfs:
1305   case Intrinsic::s390_vchgs:
1306     Opcode = SystemZISD::VICMPHS;
1307     CCValid = SystemZ::CCMASK_VCMP;
1308     return true;
1309
1310   case Intrinsic::s390_vchlbs:
1311   case Intrinsic::s390_vchlhs:
1312   case Intrinsic::s390_vchlfs:
1313   case Intrinsic::s390_vchlgs:
1314     Opcode = SystemZISD::VICMPHLS;
1315     CCValid = SystemZ::CCMASK_VCMP;
1316     return true;
1317
1318   case Intrinsic::s390_vtm:
1319     Opcode = SystemZISD::VTM;
1320     CCValid = SystemZ::CCMASK_VCMP;
1321     return true;
1322
1323   case Intrinsic::s390_vfaebs:
1324   case Intrinsic::s390_vfaehs:
1325   case Intrinsic::s390_vfaefs:
1326     Opcode = SystemZISD::VFAE_CC;
1327     CCValid = SystemZ::CCMASK_ANY;
1328     return true;
1329
1330   case Intrinsic::s390_vfaezbs:
1331   case Intrinsic::s390_vfaezhs:
1332   case Intrinsic::s390_vfaezfs:
1333     Opcode = SystemZISD::VFAEZ_CC;
1334     CCValid = SystemZ::CCMASK_ANY;
1335     return true;
1336
1337   case Intrinsic::s390_vfeebs:
1338   case Intrinsic::s390_vfeehs:
1339   case Intrinsic::s390_vfeefs:
1340     Opcode = SystemZISD::VFEE_CC;
1341     CCValid = SystemZ::CCMASK_ANY;
1342     return true;
1343
1344   case Intrinsic::s390_vfeezbs:
1345   case Intrinsic::s390_vfeezhs:
1346   case Intrinsic::s390_vfeezfs:
1347     Opcode = SystemZISD::VFEEZ_CC;
1348     CCValid = SystemZ::CCMASK_ANY;
1349     return true;
1350
1351   case Intrinsic::s390_vfenebs:
1352   case Intrinsic::s390_vfenehs:
1353   case Intrinsic::s390_vfenefs:
1354     Opcode = SystemZISD::VFENE_CC;
1355     CCValid = SystemZ::CCMASK_ANY;
1356     return true;
1357
1358   case Intrinsic::s390_vfenezbs:
1359   case Intrinsic::s390_vfenezhs:
1360   case Intrinsic::s390_vfenezfs:
1361     Opcode = SystemZISD::VFENEZ_CC;
1362     CCValid = SystemZ::CCMASK_ANY;
1363     return true;
1364
1365   case Intrinsic::s390_vistrbs:
1366   case Intrinsic::s390_vistrhs:
1367   case Intrinsic::s390_vistrfs:
1368     Opcode = SystemZISD::VISTR_CC;
1369     CCValid = SystemZ::CCMASK_0 | SystemZ::CCMASK_3;
1370     return true;
1371
1372   case Intrinsic::s390_vstrcbs:
1373   case Intrinsic::s390_vstrchs:
1374   case Intrinsic::s390_vstrcfs:
1375     Opcode = SystemZISD::VSTRC_CC;
1376     CCValid = SystemZ::CCMASK_ANY;
1377     return true;
1378
1379   case Intrinsic::s390_vstrczbs:
1380   case Intrinsic::s390_vstrczhs:
1381   case Intrinsic::s390_vstrczfs:
1382     Opcode = SystemZISD::VSTRCZ_CC;
1383     CCValid = SystemZ::CCMASK_ANY;
1384     return true;
1385
1386   case Intrinsic::s390_vfcedbs:
1387     Opcode = SystemZISD::VFCMPES;
1388     CCValid = SystemZ::CCMASK_VCMP;
1389     return true;
1390
1391   case Intrinsic::s390_vfchdbs:
1392     Opcode = SystemZISD::VFCMPHS;
1393     CCValid = SystemZ::CCMASK_VCMP;
1394     return true;
1395
1396   case Intrinsic::s390_vfchedbs:
1397     Opcode = SystemZISD::VFCMPHES;
1398     CCValid = SystemZ::CCMASK_VCMP;
1399     return true;
1400
1401   case Intrinsic::s390_vftcidb:
1402     Opcode = SystemZISD::VFTCI;
1403     CCValid = SystemZ::CCMASK_VCMP;
1404     return true;
1405
1406   default:
1407     return false;
1408   }
1409 }
1410
1411 // Emit an intrinsic with chain with a glued value instead of its CC result.
1412 static SDValue emitIntrinsicWithChainAndGlue(SelectionDAG &DAG, SDValue Op,
1413                                              unsigned Opcode) {
1414   // Copy all operands except the intrinsic ID.
1415   unsigned NumOps = Op.getNumOperands();
1416   SmallVector<SDValue, 6> Ops;
1417   Ops.reserve(NumOps - 1);
1418   Ops.push_back(Op.getOperand(0));
1419   for (unsigned I = 2; I < NumOps; ++I)
1420     Ops.push_back(Op.getOperand(I));
1421
1422   assert(Op->getNumValues() == 2 && "Expected only CC result and chain");
1423   SDVTList RawVTs = DAG.getVTList(MVT::Other, MVT::Glue);
1424   SDValue Intr = DAG.getNode(Opcode, SDLoc(Op), RawVTs, Ops);
1425   SDValue OldChain = SDValue(Op.getNode(), 1);
1426   SDValue NewChain = SDValue(Intr.getNode(), 0);
1427   DAG.ReplaceAllUsesOfValueWith(OldChain, NewChain);
1428   return Intr;
1429 }
1430
1431 // Emit an intrinsic with a glued value instead of its CC result.
1432 static SDValue emitIntrinsicWithGlue(SelectionDAG &DAG, SDValue Op,
1433                                      unsigned Opcode) {
1434   // Copy all operands except the intrinsic ID.
1435   unsigned NumOps = Op.getNumOperands();
1436   SmallVector<SDValue, 6> Ops;
1437   Ops.reserve(NumOps - 1);
1438   for (unsigned I = 1; I < NumOps; ++I)
1439     Ops.push_back(Op.getOperand(I));
1440
1441   if (Op->getNumValues() == 1)
1442     return DAG.getNode(Opcode, SDLoc(Op), MVT::Glue, Ops);
1443   assert(Op->getNumValues() == 2 && "Expected exactly one non-CC result");
1444   SDVTList RawVTs = DAG.getVTList(Op->getValueType(0), MVT::Glue);
1445   return DAG.getNode(Opcode, SDLoc(Op), RawVTs, Ops);
1446 }
1447
1448 // CC is a comparison that will be implemented using an integer or
1449 // floating-point comparison.  Return the condition code mask for
1450 // a branch on true.  In the integer case, CCMASK_CMP_UO is set for
1451 // unsigned comparisons and clear for signed ones.  In the floating-point
1452 // case, CCMASK_CMP_UO has its normal mask meaning (unordered).
1453 static unsigned CCMaskForCondCode(ISD::CondCode CC) {
1454 #define CONV(X) \
1455   case ISD::SET##X: return SystemZ::CCMASK_CMP_##X; \
1456   case ISD::SETO##X: return SystemZ::CCMASK_CMP_##X; \
1457   case ISD::SETU##X: return SystemZ::CCMASK_CMP_UO | SystemZ::CCMASK_CMP_##X
1458
1459   switch (CC) {
1460   default:
1461     llvm_unreachable("Invalid integer condition!");
1462
1463   CONV(EQ);
1464   CONV(NE);
1465   CONV(GT);
1466   CONV(GE);
1467   CONV(LT);
1468   CONV(LE);
1469
1470   case ISD::SETO:  return SystemZ::CCMASK_CMP_O;
1471   case ISD::SETUO: return SystemZ::CCMASK_CMP_UO;
1472   }
1473 #undef CONV
1474 }
1475
1476 // Return a sequence for getting a 1 from an IPM result when CC has a
1477 // value in CCMask and a 0 when CC has a value in CCValid & ~CCMask.
1478 // The handling of CC values outside CCValid doesn't matter.
1479 static IPMConversion getIPMConversion(unsigned CCValid, unsigned CCMask) {
1480   // Deal with cases where the result can be taken directly from a bit
1481   // of the IPM result.
1482   if (CCMask == (CCValid & (SystemZ::CCMASK_1 | SystemZ::CCMASK_3)))
1483     return IPMConversion(0, 0, SystemZ::IPM_CC);
1484   if (CCMask == (CCValid & (SystemZ::CCMASK_2 | SystemZ::CCMASK_3)))
1485     return IPMConversion(0, 0, SystemZ::IPM_CC + 1);
1486
1487   // Deal with cases where we can add a value to force the sign bit
1488   // to contain the right value.  Putting the bit in 31 means we can
1489   // use SRL rather than RISBG(L), and also makes it easier to get a
1490   // 0/-1 value, so it has priority over the other tests below.
1491   //
1492   // These sequences rely on the fact that the upper two bits of the
1493   // IPM result are zero.
1494   uint64_t TopBit = uint64_t(1) << 31;
1495   if (CCMask == (CCValid & SystemZ::CCMASK_0))
1496     return IPMConversion(0, -(1 << SystemZ::IPM_CC), 31);
1497   if (CCMask == (CCValid & (SystemZ::CCMASK_0 | SystemZ::CCMASK_1)))
1498     return IPMConversion(0, -(2 << SystemZ::IPM_CC), 31);
1499   if (CCMask == (CCValid & (SystemZ::CCMASK_0
1500                             | SystemZ::CCMASK_1
1501                             | SystemZ::CCMASK_2)))
1502     return IPMConversion(0, -(3 << SystemZ::IPM_CC), 31);
1503   if (CCMask == (CCValid & SystemZ::CCMASK_3))
1504     return IPMConversion(0, TopBit - (3 << SystemZ::IPM_CC), 31);
1505   if (CCMask == (CCValid & (SystemZ::CCMASK_1
1506                             | SystemZ::CCMASK_2
1507                             | SystemZ::CCMASK_3)))
1508     return IPMConversion(0, TopBit - (1 << SystemZ::IPM_CC), 31);
1509
1510   // Next try inverting the value and testing a bit.  0/1 could be
1511   // handled this way too, but we dealt with that case above.
1512   if (CCMask == (CCValid & (SystemZ::CCMASK_0 | SystemZ::CCMASK_2)))
1513     return IPMConversion(-1, 0, SystemZ::IPM_CC);
1514
1515   // Handle cases where adding a value forces a non-sign bit to contain
1516   // the right value.
1517   if (CCMask == (CCValid & (SystemZ::CCMASK_1 | SystemZ::CCMASK_2)))
1518     return IPMConversion(0, 1 << SystemZ::IPM_CC, SystemZ::IPM_CC + 1);
1519   if (CCMask == (CCValid & (SystemZ::CCMASK_0 | SystemZ::CCMASK_3)))
1520     return IPMConversion(0, -(1 << SystemZ::IPM_CC), SystemZ::IPM_CC + 1);
1521
1522   // The remaining cases are 1, 2, 0/1/3 and 0/2/3.  All these are
1523   // can be done by inverting the low CC bit and applying one of the
1524   // sign-based extractions above.
1525   if (CCMask == (CCValid & SystemZ::CCMASK_1))
1526     return IPMConversion(1 << SystemZ::IPM_CC, -(1 << SystemZ::IPM_CC), 31);
1527   if (CCMask == (CCValid & SystemZ::CCMASK_2))
1528     return IPMConversion(1 << SystemZ::IPM_CC,
1529                          TopBit - (3 << SystemZ::IPM_CC), 31);
1530   if (CCMask == (CCValid & (SystemZ::CCMASK_0
1531                             | SystemZ::CCMASK_1
1532                             | SystemZ::CCMASK_3)))
1533     return IPMConversion(1 << SystemZ::IPM_CC, -(3 << SystemZ::IPM_CC), 31);
1534   if (CCMask == (CCValid & (SystemZ::CCMASK_0
1535                             | SystemZ::CCMASK_2
1536                             | SystemZ::CCMASK_3)))
1537     return IPMConversion(1 << SystemZ::IPM_CC,
1538                          TopBit - (1 << SystemZ::IPM_CC), 31);
1539
1540   llvm_unreachable("Unexpected CC combination");
1541 }
1542
1543 // If C can be converted to a comparison against zero, adjust the operands
1544 // as necessary.
1545 static void adjustZeroCmp(SelectionDAG &DAG, SDLoc DL, Comparison &C) {
1546   if (C.ICmpType == SystemZICMP::UnsignedOnly)
1547     return;
1548
1549   auto *ConstOp1 = dyn_cast<ConstantSDNode>(C.Op1.getNode());
1550   if (!ConstOp1)
1551     return;
1552
1553   int64_t Value = ConstOp1->getSExtValue();
1554   if ((Value == -1 && C.CCMask == SystemZ::CCMASK_CMP_GT) ||
1555       (Value == -1 && C.CCMask == SystemZ::CCMASK_CMP_LE) ||
1556       (Value == 1 && C.CCMask == SystemZ::CCMASK_CMP_LT) ||
1557       (Value == 1 && C.CCMask == SystemZ::CCMASK_CMP_GE)) {
1558     C.CCMask ^= SystemZ::CCMASK_CMP_EQ;
1559     C.Op1 = DAG.getConstant(0, DL, C.Op1.getValueType());
1560   }
1561 }
1562
1563 // If a comparison described by C is suitable for CLI(Y), CHHSI or CLHHSI,
1564 // adjust the operands as necessary.
1565 static void adjustSubwordCmp(SelectionDAG &DAG, SDLoc DL, Comparison &C) {
1566   // For us to make any changes, it must a comparison between a single-use
1567   // load and a constant.
1568   if (!C.Op0.hasOneUse() ||
1569       C.Op0.getOpcode() != ISD::LOAD ||
1570       C.Op1.getOpcode() != ISD::Constant)
1571     return;
1572
1573   // We must have an 8- or 16-bit load.
1574   auto *Load = cast<LoadSDNode>(C.Op0);
1575   unsigned NumBits = Load->getMemoryVT().getStoreSizeInBits();
1576   if (NumBits != 8 && NumBits != 16)
1577     return;
1578
1579   // The load must be an extending one and the constant must be within the
1580   // range of the unextended value.
1581   auto *ConstOp1 = cast<ConstantSDNode>(C.Op1);
1582   uint64_t Value = ConstOp1->getZExtValue();
1583   uint64_t Mask = (1 << NumBits) - 1;
1584   if (Load->getExtensionType() == ISD::SEXTLOAD) {
1585     // Make sure that ConstOp1 is in range of C.Op0.
1586     int64_t SignedValue = ConstOp1->getSExtValue();
1587     if (uint64_t(SignedValue) + (uint64_t(1) << (NumBits - 1)) > Mask)
1588       return;
1589     if (C.ICmpType != SystemZICMP::SignedOnly) {
1590       // Unsigned comparison between two sign-extended values is equivalent
1591       // to unsigned comparison between two zero-extended values.
1592       Value &= Mask;
1593     } else if (NumBits == 8) {
1594       // Try to treat the comparison as unsigned, so that we can use CLI.
1595       // Adjust CCMask and Value as necessary.
1596       if (Value == 0 && C.CCMask == SystemZ::CCMASK_CMP_LT)
1597         // Test whether the high bit of the byte is set.
1598         Value = 127, C.CCMask = SystemZ::CCMASK_CMP_GT;
1599       else if (Value == 0 && C.CCMask == SystemZ::CCMASK_CMP_GE)
1600         // Test whether the high bit of the byte is clear.
1601         Value = 128, C.CCMask = SystemZ::CCMASK_CMP_LT;
1602       else
1603         // No instruction exists for this combination.
1604         return;
1605       C.ICmpType = SystemZICMP::UnsignedOnly;
1606     }
1607   } else if (Load->getExtensionType() == ISD::ZEXTLOAD) {
1608     if (Value > Mask)
1609       return;
1610     assert(C.ICmpType == SystemZICMP::Any &&
1611            "Signedness shouldn't matter here.");
1612   } else
1613     return;
1614
1615   // Make sure that the first operand is an i32 of the right extension type.
1616   ISD::LoadExtType ExtType = (C.ICmpType == SystemZICMP::SignedOnly ?
1617                               ISD::SEXTLOAD :
1618                               ISD::ZEXTLOAD);
1619   if (C.Op0.getValueType() != MVT::i32 ||
1620       Load->getExtensionType() != ExtType)
1621     C.Op0 = DAG.getExtLoad(ExtType, SDLoc(Load), MVT::i32,
1622                            Load->getChain(), Load->getBasePtr(),
1623                            Load->getPointerInfo(), Load->getMemoryVT(),
1624                            Load->isVolatile(), Load->isNonTemporal(),
1625                            Load->isInvariant(), Load->getAlignment());
1626
1627   // Make sure that the second operand is an i32 with the right value.
1628   if (C.Op1.getValueType() != MVT::i32 ||
1629       Value != ConstOp1->getZExtValue())
1630     C.Op1 = DAG.getConstant(Value, DL, MVT::i32);
1631 }
1632
1633 // Return true if Op is either an unextended load, or a load suitable
1634 // for integer register-memory comparisons of type ICmpType.
1635 static bool isNaturalMemoryOperand(SDValue Op, unsigned ICmpType) {
1636   auto *Load = dyn_cast<LoadSDNode>(Op.getNode());
1637   if (Load) {
1638     // There are no instructions to compare a register with a memory byte.
1639     if (Load->getMemoryVT() == MVT::i8)
1640       return false;
1641     // Otherwise decide on extension type.
1642     switch (Load->getExtensionType()) {
1643     case ISD::NON_EXTLOAD:
1644       return true;
1645     case ISD::SEXTLOAD:
1646       return ICmpType != SystemZICMP::UnsignedOnly;
1647     case ISD::ZEXTLOAD:
1648       return ICmpType != SystemZICMP::SignedOnly;
1649     default:
1650       break;
1651     }
1652   }
1653   return false;
1654 }
1655
1656 // Return true if it is better to swap the operands of C.
1657 static bool shouldSwapCmpOperands(const Comparison &C) {
1658   // Leave f128 comparisons alone, since they have no memory forms.
1659   if (C.Op0.getValueType() == MVT::f128)
1660     return false;
1661
1662   // Always keep a floating-point constant second, since comparisons with
1663   // zero can use LOAD TEST and comparisons with other constants make a
1664   // natural memory operand.
1665   if (isa<ConstantFPSDNode>(C.Op1))
1666     return false;
1667
1668   // Never swap comparisons with zero since there are many ways to optimize
1669   // those later.
1670   auto *ConstOp1 = dyn_cast<ConstantSDNode>(C.Op1);
1671   if (ConstOp1 && ConstOp1->getZExtValue() == 0)
1672     return false;
1673
1674   // Also keep natural memory operands second if the loaded value is
1675   // only used here.  Several comparisons have memory forms.
1676   if (isNaturalMemoryOperand(C.Op1, C.ICmpType) && C.Op1.hasOneUse())
1677     return false;
1678
1679   // Look for cases where Cmp0 is a single-use load and Cmp1 isn't.
1680   // In that case we generally prefer the memory to be second.
1681   if (isNaturalMemoryOperand(C.Op0, C.ICmpType) && C.Op0.hasOneUse()) {
1682     // The only exceptions are when the second operand is a constant and
1683     // we can use things like CHHSI.
1684     if (!ConstOp1)
1685       return true;
1686     // The unsigned memory-immediate instructions can handle 16-bit
1687     // unsigned integers.
1688     if (C.ICmpType != SystemZICMP::SignedOnly &&
1689         isUInt<16>(ConstOp1->getZExtValue()))
1690       return false;
1691     // The signed memory-immediate instructions can handle 16-bit
1692     // signed integers.
1693     if (C.ICmpType != SystemZICMP::UnsignedOnly &&
1694         isInt<16>(ConstOp1->getSExtValue()))
1695       return false;
1696     return true;
1697   }
1698
1699   // Try to promote the use of CGFR and CLGFR.
1700   unsigned Opcode0 = C.Op0.getOpcode();
1701   if (C.ICmpType != SystemZICMP::UnsignedOnly && Opcode0 == ISD::SIGN_EXTEND)
1702     return true;
1703   if (C.ICmpType != SystemZICMP::SignedOnly && Opcode0 == ISD::ZERO_EXTEND)
1704     return true;
1705   if (C.ICmpType != SystemZICMP::SignedOnly &&
1706       Opcode0 == ISD::AND &&
1707       C.Op0.getOperand(1).getOpcode() == ISD::Constant &&
1708       cast<ConstantSDNode>(C.Op0.getOperand(1))->getZExtValue() == 0xffffffff)
1709     return true;
1710
1711   return false;
1712 }
1713
1714 // Return a version of comparison CC mask CCMask in which the LT and GT
1715 // actions are swapped.
1716 static unsigned reverseCCMask(unsigned CCMask) {
1717   return ((CCMask & SystemZ::CCMASK_CMP_EQ) |
1718           (CCMask & SystemZ::CCMASK_CMP_GT ? SystemZ::CCMASK_CMP_LT : 0) |
1719           (CCMask & SystemZ::CCMASK_CMP_LT ? SystemZ::CCMASK_CMP_GT : 0) |
1720           (CCMask & SystemZ::CCMASK_CMP_UO));
1721 }
1722
1723 // Check whether C tests for equality between X and Y and whether X - Y
1724 // or Y - X is also computed.  In that case it's better to compare the
1725 // result of the subtraction against zero.
1726 static void adjustForSubtraction(SelectionDAG &DAG, SDLoc DL, Comparison &C) {
1727   if (C.CCMask == SystemZ::CCMASK_CMP_EQ ||
1728       C.CCMask == SystemZ::CCMASK_CMP_NE) {
1729     for (auto I = C.Op0->use_begin(), E = C.Op0->use_end(); I != E; ++I) {
1730       SDNode *N = *I;
1731       if (N->getOpcode() == ISD::SUB &&
1732           ((N->getOperand(0) == C.Op0 && N->getOperand(1) == C.Op1) ||
1733            (N->getOperand(0) == C.Op1 && N->getOperand(1) == C.Op0))) {
1734         C.Op0 = SDValue(N, 0);
1735         C.Op1 = DAG.getConstant(0, DL, N->getValueType(0));
1736         return;
1737       }
1738     }
1739   }
1740 }
1741
1742 // Check whether C compares a floating-point value with zero and if that
1743 // floating-point value is also negated.  In this case we can use the
1744 // negation to set CC, so avoiding separate LOAD AND TEST and
1745 // LOAD (NEGATIVE/COMPLEMENT) instructions.
1746 static void adjustForFNeg(Comparison &C) {
1747   auto *C1 = dyn_cast<ConstantFPSDNode>(C.Op1);
1748   if (C1 && C1->isZero()) {
1749     for (auto I = C.Op0->use_begin(), E = C.Op0->use_end(); I != E; ++I) {
1750       SDNode *N = *I;
1751       if (N->getOpcode() == ISD::FNEG) {
1752         C.Op0 = SDValue(N, 0);
1753         C.CCMask = reverseCCMask(C.CCMask);
1754         return;
1755       }
1756     }
1757   }
1758 }
1759
1760 // Check whether C compares (shl X, 32) with 0 and whether X is
1761 // also sign-extended.  In that case it is better to test the result
1762 // of the sign extension using LTGFR.
1763 //
1764 // This case is important because InstCombine transforms a comparison
1765 // with (sext (trunc X)) into a comparison with (shl X, 32).
1766 static void adjustForLTGFR(Comparison &C) {
1767   // Check for a comparison between (shl X, 32) and 0.
1768   if (C.Op0.getOpcode() == ISD::SHL &&
1769       C.Op0.getValueType() == MVT::i64 &&
1770       C.Op1.getOpcode() == ISD::Constant &&
1771       cast<ConstantSDNode>(C.Op1)->getZExtValue() == 0) {
1772     auto *C1 = dyn_cast<ConstantSDNode>(C.Op0.getOperand(1));
1773     if (C1 && C1->getZExtValue() == 32) {
1774       SDValue ShlOp0 = C.Op0.getOperand(0);
1775       // See whether X has any SIGN_EXTEND_INREG uses.
1776       for (auto I = ShlOp0->use_begin(), E = ShlOp0->use_end(); I != E; ++I) {
1777         SDNode *N = *I;
1778         if (N->getOpcode() == ISD::SIGN_EXTEND_INREG &&
1779             cast<VTSDNode>(N->getOperand(1))->getVT() == MVT::i32) {
1780           C.Op0 = SDValue(N, 0);
1781           return;
1782         }
1783       }
1784     }
1785   }
1786 }
1787
1788 // If C compares the truncation of an extending load, try to compare
1789 // the untruncated value instead.  This exposes more opportunities to
1790 // reuse CC.
1791 static void adjustICmpTruncate(SelectionDAG &DAG, SDLoc DL, Comparison &C) {
1792   if (C.Op0.getOpcode() == ISD::TRUNCATE &&
1793       C.Op0.getOperand(0).getOpcode() == ISD::LOAD &&
1794       C.Op1.getOpcode() == ISD::Constant &&
1795       cast<ConstantSDNode>(C.Op1)->getZExtValue() == 0) {
1796     auto *L = cast<LoadSDNode>(C.Op0.getOperand(0));
1797     if (L->getMemoryVT().getStoreSizeInBits()
1798         <= C.Op0.getValueType().getSizeInBits()) {
1799       unsigned Type = L->getExtensionType();
1800       if ((Type == ISD::ZEXTLOAD && C.ICmpType != SystemZICMP::SignedOnly) ||
1801           (Type == ISD::SEXTLOAD && C.ICmpType != SystemZICMP::UnsignedOnly)) {
1802         C.Op0 = C.Op0.getOperand(0);
1803         C.Op1 = DAG.getConstant(0, DL, C.Op0.getValueType());
1804       }
1805     }
1806   }
1807 }
1808
1809 // Return true if shift operation N has an in-range constant shift value.
1810 // Store it in ShiftVal if so.
1811 static bool isSimpleShift(SDValue N, unsigned &ShiftVal) {
1812   auto *Shift = dyn_cast<ConstantSDNode>(N.getOperand(1));
1813   if (!Shift)
1814     return false;
1815
1816   uint64_t Amount = Shift->getZExtValue();
1817   if (Amount >= N.getValueType().getSizeInBits())
1818     return false;
1819
1820   ShiftVal = Amount;
1821   return true;
1822 }
1823
1824 // Check whether an AND with Mask is suitable for a TEST UNDER MASK
1825 // instruction and whether the CC value is descriptive enough to handle
1826 // a comparison of type Opcode between the AND result and CmpVal.
1827 // CCMask says which comparison result is being tested and BitSize is
1828 // the number of bits in the operands.  If TEST UNDER MASK can be used,
1829 // return the corresponding CC mask, otherwise return 0.
1830 static unsigned getTestUnderMaskCond(unsigned BitSize, unsigned CCMask,
1831                                      uint64_t Mask, uint64_t CmpVal,
1832                                      unsigned ICmpType) {
1833   assert(Mask != 0 && "ANDs with zero should have been removed by now");
1834
1835   // Check whether the mask is suitable for TMHH, TMHL, TMLH or TMLL.
1836   if (!SystemZ::isImmLL(Mask) && !SystemZ::isImmLH(Mask) &&
1837       !SystemZ::isImmHL(Mask) && !SystemZ::isImmHH(Mask))
1838     return 0;
1839
1840   // Work out the masks for the lowest and highest bits.
1841   unsigned HighShift = 63 - countLeadingZeros(Mask);
1842   uint64_t High = uint64_t(1) << HighShift;
1843   uint64_t Low = uint64_t(1) << countTrailingZeros(Mask);
1844
1845   // Signed ordered comparisons are effectively unsigned if the sign
1846   // bit is dropped.
1847   bool EffectivelyUnsigned = (ICmpType != SystemZICMP::SignedOnly);
1848
1849   // Check for equality comparisons with 0, or the equivalent.
1850   if (CmpVal == 0) {
1851     if (CCMask == SystemZ::CCMASK_CMP_EQ)
1852       return SystemZ::CCMASK_TM_ALL_0;
1853     if (CCMask == SystemZ::CCMASK_CMP_NE)
1854       return SystemZ::CCMASK_TM_SOME_1;
1855   }
1856   if (EffectivelyUnsigned && CmpVal <= Low) {
1857     if (CCMask == SystemZ::CCMASK_CMP_LT)
1858       return SystemZ::CCMASK_TM_ALL_0;
1859     if (CCMask == SystemZ::CCMASK_CMP_GE)
1860       return SystemZ::CCMASK_TM_SOME_1;
1861   }
1862   if (EffectivelyUnsigned && CmpVal < Low) {
1863     if (CCMask == SystemZ::CCMASK_CMP_LE)
1864       return SystemZ::CCMASK_TM_ALL_0;
1865     if (CCMask == SystemZ::CCMASK_CMP_GT)
1866       return SystemZ::CCMASK_TM_SOME_1;
1867   }
1868
1869   // Check for equality comparisons with the mask, or the equivalent.
1870   if (CmpVal == Mask) {
1871     if (CCMask == SystemZ::CCMASK_CMP_EQ)
1872       return SystemZ::CCMASK_TM_ALL_1;
1873     if (CCMask == SystemZ::CCMASK_CMP_NE)
1874       return SystemZ::CCMASK_TM_SOME_0;
1875   }
1876   if (EffectivelyUnsigned && CmpVal >= Mask - Low && CmpVal < Mask) {
1877     if (CCMask == SystemZ::CCMASK_CMP_GT)
1878       return SystemZ::CCMASK_TM_ALL_1;
1879     if (CCMask == SystemZ::CCMASK_CMP_LE)
1880       return SystemZ::CCMASK_TM_SOME_0;
1881   }
1882   if (EffectivelyUnsigned && CmpVal > Mask - Low && CmpVal <= Mask) {
1883     if (CCMask == SystemZ::CCMASK_CMP_GE)
1884       return SystemZ::CCMASK_TM_ALL_1;
1885     if (CCMask == SystemZ::CCMASK_CMP_LT)
1886       return SystemZ::CCMASK_TM_SOME_0;
1887   }
1888
1889   // Check for ordered comparisons with the top bit.
1890   if (EffectivelyUnsigned && CmpVal >= Mask - High && CmpVal < High) {
1891     if (CCMask == SystemZ::CCMASK_CMP_LE)
1892       return SystemZ::CCMASK_TM_MSB_0;
1893     if (CCMask == SystemZ::CCMASK_CMP_GT)
1894       return SystemZ::CCMASK_TM_MSB_1;
1895   }
1896   if (EffectivelyUnsigned && CmpVal > Mask - High && CmpVal <= High) {
1897     if (CCMask == SystemZ::CCMASK_CMP_LT)
1898       return SystemZ::CCMASK_TM_MSB_0;
1899     if (CCMask == SystemZ::CCMASK_CMP_GE)
1900       return SystemZ::CCMASK_TM_MSB_1;
1901   }
1902
1903   // If there are just two bits, we can do equality checks for Low and High
1904   // as well.
1905   if (Mask == Low + High) {
1906     if (CCMask == SystemZ::CCMASK_CMP_EQ && CmpVal == Low)
1907       return SystemZ::CCMASK_TM_MIXED_MSB_0;
1908     if (CCMask == SystemZ::CCMASK_CMP_NE && CmpVal == Low)
1909       return SystemZ::CCMASK_TM_MIXED_MSB_0 ^ SystemZ::CCMASK_ANY;
1910     if (CCMask == SystemZ::CCMASK_CMP_EQ && CmpVal == High)
1911       return SystemZ::CCMASK_TM_MIXED_MSB_1;
1912     if (CCMask == SystemZ::CCMASK_CMP_NE && CmpVal == High)
1913       return SystemZ::CCMASK_TM_MIXED_MSB_1 ^ SystemZ::CCMASK_ANY;
1914   }
1915
1916   // Looks like we've exhausted our options.
1917   return 0;
1918 }
1919
1920 // See whether C can be implemented as a TEST UNDER MASK instruction.
1921 // Update the arguments with the TM version if so.
1922 static void adjustForTestUnderMask(SelectionDAG &DAG, SDLoc DL, Comparison &C) {
1923   // Check that we have a comparison with a constant.
1924   auto *ConstOp1 = dyn_cast<ConstantSDNode>(C.Op1);
1925   if (!ConstOp1)
1926     return;
1927   uint64_t CmpVal = ConstOp1->getZExtValue();
1928
1929   // Check whether the nonconstant input is an AND with a constant mask.
1930   Comparison NewC(C);
1931   uint64_t MaskVal;
1932   ConstantSDNode *Mask = nullptr;
1933   if (C.Op0.getOpcode() == ISD::AND) {
1934     NewC.Op0 = C.Op0.getOperand(0);
1935     NewC.Op1 = C.Op0.getOperand(1);
1936     Mask = dyn_cast<ConstantSDNode>(NewC.Op1);
1937     if (!Mask)
1938       return;
1939     MaskVal = Mask->getZExtValue();
1940   } else {
1941     // There is no instruction to compare with a 64-bit immediate
1942     // so use TMHH instead if possible.  We need an unsigned ordered
1943     // comparison with an i64 immediate.
1944     if (NewC.Op0.getValueType() != MVT::i64 ||
1945         NewC.CCMask == SystemZ::CCMASK_CMP_EQ ||
1946         NewC.CCMask == SystemZ::CCMASK_CMP_NE ||
1947         NewC.ICmpType == SystemZICMP::SignedOnly)
1948       return;
1949     // Convert LE and GT comparisons into LT and GE.
1950     if (NewC.CCMask == SystemZ::CCMASK_CMP_LE ||
1951         NewC.CCMask == SystemZ::CCMASK_CMP_GT) {
1952       if (CmpVal == uint64_t(-1))
1953         return;
1954       CmpVal += 1;
1955       NewC.CCMask ^= SystemZ::CCMASK_CMP_EQ;
1956     }
1957     // If the low N bits of Op1 are zero than the low N bits of Op0 can
1958     // be masked off without changing the result.
1959     MaskVal = -(CmpVal & -CmpVal);
1960     NewC.ICmpType = SystemZICMP::UnsignedOnly;
1961   }
1962   if (!MaskVal)
1963     return;
1964
1965   // Check whether the combination of mask, comparison value and comparison
1966   // type are suitable.
1967   unsigned BitSize = NewC.Op0.getValueType().getSizeInBits();
1968   unsigned NewCCMask, ShiftVal;
1969   if (NewC.ICmpType != SystemZICMP::SignedOnly &&
1970       NewC.Op0.getOpcode() == ISD::SHL &&
1971       isSimpleShift(NewC.Op0, ShiftVal) &&
1972       (NewCCMask = getTestUnderMaskCond(BitSize, NewC.CCMask,
1973                                         MaskVal >> ShiftVal,
1974                                         CmpVal >> ShiftVal,
1975                                         SystemZICMP::Any))) {
1976     NewC.Op0 = NewC.Op0.getOperand(0);
1977     MaskVal >>= ShiftVal;
1978   } else if (NewC.ICmpType != SystemZICMP::SignedOnly &&
1979              NewC.Op0.getOpcode() == ISD::SRL &&
1980              isSimpleShift(NewC.Op0, ShiftVal) &&
1981              (NewCCMask = getTestUnderMaskCond(BitSize, NewC.CCMask,
1982                                                MaskVal << ShiftVal,
1983                                                CmpVal << ShiftVal,
1984                                                SystemZICMP::UnsignedOnly))) {
1985     NewC.Op0 = NewC.Op0.getOperand(0);
1986     MaskVal <<= ShiftVal;
1987   } else {
1988     NewCCMask = getTestUnderMaskCond(BitSize, NewC.CCMask, MaskVal, CmpVal,
1989                                      NewC.ICmpType);
1990     if (!NewCCMask)
1991       return;
1992   }
1993
1994   // Go ahead and make the change.
1995   C.Opcode = SystemZISD::TM;
1996   C.Op0 = NewC.Op0;
1997   if (Mask && Mask->getZExtValue() == MaskVal)
1998     C.Op1 = SDValue(Mask, 0);
1999   else
2000     C.Op1 = DAG.getConstant(MaskVal, DL, C.Op0.getValueType());
2001   C.CCValid = SystemZ::CCMASK_TM;
2002   C.CCMask = NewCCMask;
2003 }
2004
2005 // Return a Comparison that tests the condition-code result of intrinsic
2006 // node Call against constant integer CC using comparison code Cond.
2007 // Opcode is the opcode of the SystemZISD operation for the intrinsic
2008 // and CCValid is the set of possible condition-code results.
2009 static Comparison getIntrinsicCmp(SelectionDAG &DAG, unsigned Opcode,
2010                                   SDValue Call, unsigned CCValid, uint64_t CC,
2011                                   ISD::CondCode Cond) {
2012   Comparison C(Call, SDValue());
2013   C.Opcode = Opcode;
2014   C.CCValid = CCValid;
2015   if (Cond == ISD::SETEQ)
2016     // bit 3 for CC==0, bit 0 for CC==3, always false for CC>3.
2017     C.CCMask = CC < 4 ? 1 << (3 - CC) : 0;
2018   else if (Cond == ISD::SETNE)
2019     // ...and the inverse of that.
2020     C.CCMask = CC < 4 ? ~(1 << (3 - CC)) : -1;
2021   else if (Cond == ISD::SETLT || Cond == ISD::SETULT)
2022     // bits above bit 3 for CC==0 (always false), bits above bit 0 for CC==3,
2023     // always true for CC>3.
2024     C.CCMask = CC < 4 ? ~0U << (4 - CC) : -1;
2025   else if (Cond == ISD::SETGE || Cond == ISD::SETUGE)
2026     // ...and the inverse of that.
2027     C.CCMask = CC < 4 ? ~(~0U << (4 - CC)) : 0;
2028   else if (Cond == ISD::SETLE || Cond == ISD::SETULE)
2029     // bit 3 and above for CC==0, bit 0 and above for CC==3 (always true),
2030     // always true for CC>3.
2031     C.CCMask = CC < 4 ? ~0U << (3 - CC) : -1;
2032   else if (Cond == ISD::SETGT || Cond == ISD::SETUGT)
2033     // ...and the inverse of that.
2034     C.CCMask = CC < 4 ? ~(~0U << (3 - CC)) : 0;
2035   else
2036     llvm_unreachable("Unexpected integer comparison type");
2037   C.CCMask &= CCValid;
2038   return C;
2039 }
2040
2041 // Decide how to implement a comparison of type Cond between CmpOp0 with CmpOp1.
2042 static Comparison getCmp(SelectionDAG &DAG, SDValue CmpOp0, SDValue CmpOp1,
2043                          ISD::CondCode Cond, SDLoc DL) {
2044   if (CmpOp1.getOpcode() == ISD::Constant) {
2045     uint64_t Constant = cast<ConstantSDNode>(CmpOp1)->getZExtValue();
2046     unsigned Opcode, CCValid;
2047     if (CmpOp0.getOpcode() == ISD::INTRINSIC_W_CHAIN &&
2048         CmpOp0.getResNo() == 0 && CmpOp0->hasNUsesOfValue(1, 0) &&
2049         isIntrinsicWithCCAndChain(CmpOp0, Opcode, CCValid))
2050       return getIntrinsicCmp(DAG, Opcode, CmpOp0, CCValid, Constant, Cond);
2051     if (CmpOp0.getOpcode() == ISD::INTRINSIC_WO_CHAIN &&
2052         CmpOp0.getResNo() == CmpOp0->getNumValues() - 1 &&
2053         isIntrinsicWithCC(CmpOp0, Opcode, CCValid))
2054       return getIntrinsicCmp(DAG, Opcode, CmpOp0, CCValid, Constant, Cond);
2055   }
2056   Comparison C(CmpOp0, CmpOp1);
2057   C.CCMask = CCMaskForCondCode(Cond);
2058   if (C.Op0.getValueType().isFloatingPoint()) {
2059     C.CCValid = SystemZ::CCMASK_FCMP;
2060     C.Opcode = SystemZISD::FCMP;
2061     adjustForFNeg(C);
2062   } else {
2063     C.CCValid = SystemZ::CCMASK_ICMP;
2064     C.Opcode = SystemZISD::ICMP;
2065     // Choose the type of comparison.  Equality and inequality tests can
2066     // use either signed or unsigned comparisons.  The choice also doesn't
2067     // matter if both sign bits are known to be clear.  In those cases we
2068     // want to give the main isel code the freedom to choose whichever
2069     // form fits best.
2070     if (C.CCMask == SystemZ::CCMASK_CMP_EQ ||
2071         C.CCMask == SystemZ::CCMASK_CMP_NE ||
2072         (DAG.SignBitIsZero(C.Op0) && DAG.SignBitIsZero(C.Op1)))
2073       C.ICmpType = SystemZICMP::Any;
2074     else if (C.CCMask & SystemZ::CCMASK_CMP_UO)
2075       C.ICmpType = SystemZICMP::UnsignedOnly;
2076     else
2077       C.ICmpType = SystemZICMP::SignedOnly;
2078     C.CCMask &= ~SystemZ::CCMASK_CMP_UO;
2079     adjustZeroCmp(DAG, DL, C);
2080     adjustSubwordCmp(DAG, DL, C);
2081     adjustForSubtraction(DAG, DL, C);
2082     adjustForLTGFR(C);
2083     adjustICmpTruncate(DAG, DL, C);
2084   }
2085
2086   if (shouldSwapCmpOperands(C)) {
2087     std::swap(C.Op0, C.Op1);
2088     C.CCMask = reverseCCMask(C.CCMask);
2089   }
2090
2091   adjustForTestUnderMask(DAG, DL, C);
2092   return C;
2093 }
2094
2095 // Emit the comparison instruction described by C.
2096 static SDValue emitCmp(SelectionDAG &DAG, SDLoc DL, Comparison &C) {
2097   if (!C.Op1.getNode()) {
2098     SDValue Op;
2099     switch (C.Op0.getOpcode()) {
2100     case ISD::INTRINSIC_W_CHAIN:
2101       Op = emitIntrinsicWithChainAndGlue(DAG, C.Op0, C.Opcode);
2102       break;
2103     case ISD::INTRINSIC_WO_CHAIN:
2104       Op = emitIntrinsicWithGlue(DAG, C.Op0, C.Opcode);
2105       break;
2106     default:
2107       llvm_unreachable("Invalid comparison operands");
2108     }
2109     return SDValue(Op.getNode(), Op->getNumValues() - 1);
2110   }
2111   if (C.Opcode == SystemZISD::ICMP)
2112     return DAG.getNode(SystemZISD::ICMP, DL, MVT::Glue, C.Op0, C.Op1,
2113                        DAG.getConstant(C.ICmpType, DL, MVT::i32));
2114   if (C.Opcode == SystemZISD::TM) {
2115     bool RegisterOnly = (bool(C.CCMask & SystemZ::CCMASK_TM_MIXED_MSB_0) !=
2116                          bool(C.CCMask & SystemZ::CCMASK_TM_MIXED_MSB_1));
2117     return DAG.getNode(SystemZISD::TM, DL, MVT::Glue, C.Op0, C.Op1,
2118                        DAG.getConstant(RegisterOnly, DL, MVT::i32));
2119   }
2120   return DAG.getNode(C.Opcode, DL, MVT::Glue, C.Op0, C.Op1);
2121 }
2122
2123 // Implement a 32-bit *MUL_LOHI operation by extending both operands to
2124 // 64 bits.  Extend is the extension type to use.  Store the high part
2125 // in Hi and the low part in Lo.
2126 static void lowerMUL_LOHI32(SelectionDAG &DAG, SDLoc DL,
2127                             unsigned Extend, SDValue Op0, SDValue Op1,
2128                             SDValue &Hi, SDValue &Lo) {
2129   Op0 = DAG.getNode(Extend, DL, MVT::i64, Op0);
2130   Op1 = DAG.getNode(Extend, DL, MVT::i64, Op1);
2131   SDValue Mul = DAG.getNode(ISD::MUL, DL, MVT::i64, Op0, Op1);
2132   Hi = DAG.getNode(ISD::SRL, DL, MVT::i64, Mul,
2133                    DAG.getConstant(32, DL, MVT::i64));
2134   Hi = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Hi);
2135   Lo = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Mul);
2136 }
2137
2138 // Lower a binary operation that produces two VT results, one in each
2139 // half of a GR128 pair.  Op0 and Op1 are the VT operands to the operation,
2140 // Extend extends Op0 to a GR128, and Opcode performs the GR128 operation
2141 // on the extended Op0 and (unextended) Op1.  Store the even register result
2142 // in Even and the odd register result in Odd.
2143 static void lowerGR128Binary(SelectionDAG &DAG, SDLoc DL, EVT VT,
2144                              unsigned Extend, unsigned Opcode,
2145                              SDValue Op0, SDValue Op1,
2146                              SDValue &Even, SDValue &Odd) {
2147   SDNode *In128 = DAG.getMachineNode(Extend, DL, MVT::Untyped, Op0);
2148   SDValue Result = DAG.getNode(Opcode, DL, MVT::Untyped,
2149                                SDValue(In128, 0), Op1);
2150   bool Is32Bit = is32Bit(VT);
2151   Even = DAG.getTargetExtractSubreg(SystemZ::even128(Is32Bit), DL, VT, Result);
2152   Odd = DAG.getTargetExtractSubreg(SystemZ::odd128(Is32Bit), DL, VT, Result);
2153 }
2154
2155 // Return an i32 value that is 1 if the CC value produced by Glue is
2156 // in the mask CCMask and 0 otherwise.  CC is known to have a value
2157 // in CCValid, so other values can be ignored.
2158 static SDValue emitSETCC(SelectionDAG &DAG, SDLoc DL, SDValue Glue,
2159                          unsigned CCValid, unsigned CCMask) {
2160   IPMConversion Conversion = getIPMConversion(CCValid, CCMask);
2161   SDValue Result = DAG.getNode(SystemZISD::IPM, DL, MVT::i32, Glue);
2162
2163   if (Conversion.XORValue)
2164     Result = DAG.getNode(ISD::XOR, DL, MVT::i32, Result,
2165                          DAG.getConstant(Conversion.XORValue, DL, MVT::i32));
2166
2167   if (Conversion.AddValue)
2168     Result = DAG.getNode(ISD::ADD, DL, MVT::i32, Result,
2169                          DAG.getConstant(Conversion.AddValue, DL, MVT::i32));
2170
2171   // The SHR/AND sequence should get optimized to an RISBG.
2172   Result = DAG.getNode(ISD::SRL, DL, MVT::i32, Result,
2173                        DAG.getConstant(Conversion.Bit, DL, MVT::i32));
2174   if (Conversion.Bit != 31)
2175     Result = DAG.getNode(ISD::AND, DL, MVT::i32, Result,
2176                          DAG.getConstant(1, DL, MVT::i32));
2177   return Result;
2178 }
2179
2180 // Return the SystemISD vector comparison operation for CC, or 0 if it cannot
2181 // be done directly.  IsFP is true if CC is for a floating-point rather than
2182 // integer comparison.
2183 static unsigned getVectorComparison(ISD::CondCode CC, bool IsFP) {
2184   switch (CC) {
2185   case ISD::SETOEQ:
2186   case ISD::SETEQ:
2187     return IsFP ? SystemZISD::VFCMPE : SystemZISD::VICMPE;
2188
2189   case ISD::SETOGE:
2190   case ISD::SETGE:
2191     return IsFP ? SystemZISD::VFCMPHE : static_cast<SystemZISD::NodeType>(0);
2192
2193   case ISD::SETOGT:
2194   case ISD::SETGT:
2195     return IsFP ? SystemZISD::VFCMPH : SystemZISD::VICMPH;
2196
2197   case ISD::SETUGT:
2198     return IsFP ? static_cast<SystemZISD::NodeType>(0) : SystemZISD::VICMPHL;
2199
2200   default:
2201     return 0;
2202   }
2203 }
2204
2205 // Return the SystemZISD vector comparison operation for CC or its inverse,
2206 // or 0 if neither can be done directly.  Indicate in Invert whether the
2207 // result is for the inverse of CC.  IsFP is true if CC is for a
2208 // floating-point rather than integer comparison.
2209 static unsigned getVectorComparisonOrInvert(ISD::CondCode CC, bool IsFP,
2210                                             bool &Invert) {
2211   if (unsigned Opcode = getVectorComparison(CC, IsFP)) {
2212     Invert = false;
2213     return Opcode;
2214   }
2215
2216   CC = ISD::getSetCCInverse(CC, !IsFP);
2217   if (unsigned Opcode = getVectorComparison(CC, IsFP)) {
2218     Invert = true;
2219     return Opcode;
2220   }
2221
2222   return 0;
2223 }
2224
2225 // Return a v2f64 that contains the extended form of elements Start and Start+1
2226 // of v4f32 value Op.
2227 static SDValue expandV4F32ToV2F64(SelectionDAG &DAG, int Start, SDLoc DL,
2228                                   SDValue Op) {
2229   int Mask[] = { Start, -1, Start + 1, -1 };
2230   Op = DAG.getVectorShuffle(MVT::v4f32, DL, Op, DAG.getUNDEF(MVT::v4f32), Mask);
2231   return DAG.getNode(SystemZISD::VEXTEND, DL, MVT::v2f64, Op);
2232 }
2233
2234 // Build a comparison of vectors CmpOp0 and CmpOp1 using opcode Opcode,
2235 // producing a result of type VT.
2236 static SDValue getVectorCmp(SelectionDAG &DAG, unsigned Opcode, SDLoc DL,
2237                             EVT VT, SDValue CmpOp0, SDValue CmpOp1) {
2238   // There is no hardware support for v4f32, so extend the vector into
2239   // two v2f64s and compare those.
2240   if (CmpOp0.getValueType() == MVT::v4f32) {
2241     SDValue H0 = expandV4F32ToV2F64(DAG, 0, DL, CmpOp0);
2242     SDValue L0 = expandV4F32ToV2F64(DAG, 2, DL, CmpOp0);
2243     SDValue H1 = expandV4F32ToV2F64(DAG, 0, DL, CmpOp1);
2244     SDValue L1 = expandV4F32ToV2F64(DAG, 2, DL, CmpOp1);
2245     SDValue HRes = DAG.getNode(Opcode, DL, MVT::v2i64, H0, H1);
2246     SDValue LRes = DAG.getNode(Opcode, DL, MVT::v2i64, L0, L1);
2247     return DAG.getNode(SystemZISD::PACK, DL, VT, HRes, LRes);
2248   }
2249   return DAG.getNode(Opcode, DL, VT, CmpOp0, CmpOp1);
2250 }
2251
2252 // Lower a vector comparison of type CC between CmpOp0 and CmpOp1, producing
2253 // an integer mask of type VT.
2254 static SDValue lowerVectorSETCC(SelectionDAG &DAG, SDLoc DL, EVT VT,
2255                                 ISD::CondCode CC, SDValue CmpOp0,
2256                                 SDValue CmpOp1) {
2257   bool IsFP = CmpOp0.getValueType().isFloatingPoint();
2258   bool Invert = false;
2259   SDValue Cmp;
2260   switch (CC) {
2261     // Handle tests for order using (or (ogt y x) (oge x y)).
2262   case ISD::SETUO:
2263     Invert = true;
2264   case ISD::SETO: {
2265     assert(IsFP && "Unexpected integer comparison");
2266     SDValue LT = getVectorCmp(DAG, SystemZISD::VFCMPH, DL, VT, CmpOp1, CmpOp0);
2267     SDValue GE = getVectorCmp(DAG, SystemZISD::VFCMPHE, DL, VT, CmpOp0, CmpOp1);
2268     Cmp = DAG.getNode(ISD::OR, DL, VT, LT, GE);
2269     break;
2270   }
2271
2272     // Handle <> tests using (or (ogt y x) (ogt x y)).
2273   case ISD::SETUEQ:
2274     Invert = true;
2275   case ISD::SETONE: {
2276     assert(IsFP && "Unexpected integer comparison");
2277     SDValue LT = getVectorCmp(DAG, SystemZISD::VFCMPH, DL, VT, CmpOp1, CmpOp0);
2278     SDValue GT = getVectorCmp(DAG, SystemZISD::VFCMPH, DL, VT, CmpOp0, CmpOp1);
2279     Cmp = DAG.getNode(ISD::OR, DL, VT, LT, GT);
2280     break;
2281   }
2282
2283     // Otherwise a single comparison is enough.  It doesn't really
2284     // matter whether we try the inversion or the swap first, since
2285     // there are no cases where both work.
2286   default:
2287     if (unsigned Opcode = getVectorComparisonOrInvert(CC, IsFP, Invert))
2288       Cmp = getVectorCmp(DAG, Opcode, DL, VT, CmpOp0, CmpOp1);
2289     else {
2290       CC = ISD::getSetCCSwappedOperands(CC);
2291       if (unsigned Opcode = getVectorComparisonOrInvert(CC, IsFP, Invert))
2292         Cmp = getVectorCmp(DAG, Opcode, DL, VT, CmpOp1, CmpOp0);
2293       else
2294         llvm_unreachable("Unhandled comparison");
2295     }
2296     break;
2297   }
2298   if (Invert) {
2299     SDValue Mask = DAG.getNode(SystemZISD::BYTE_MASK, DL, MVT::v16i8,
2300                                DAG.getConstant(65535, DL, MVT::i32));
2301     Mask = DAG.getNode(ISD::BITCAST, DL, VT, Mask);
2302     Cmp = DAG.getNode(ISD::XOR, DL, VT, Cmp, Mask);
2303   }
2304   return Cmp;
2305 }
2306
2307 SDValue SystemZTargetLowering::lowerSETCC(SDValue Op,
2308                                           SelectionDAG &DAG) const {
2309   SDValue CmpOp0   = Op.getOperand(0);
2310   SDValue CmpOp1   = Op.getOperand(1);
2311   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
2312   SDLoc DL(Op);
2313   EVT VT = Op.getValueType();
2314   if (VT.isVector())
2315     return lowerVectorSETCC(DAG, DL, VT, CC, CmpOp0, CmpOp1);
2316
2317   Comparison C(getCmp(DAG, CmpOp0, CmpOp1, CC, DL));
2318   SDValue Glue = emitCmp(DAG, DL, C);
2319   return emitSETCC(DAG, DL, Glue, C.CCValid, C.CCMask);
2320 }
2321
2322 SDValue SystemZTargetLowering::lowerBR_CC(SDValue Op, SelectionDAG &DAG) const {
2323   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get();
2324   SDValue CmpOp0   = Op.getOperand(2);
2325   SDValue CmpOp1   = Op.getOperand(3);
2326   SDValue Dest     = Op.getOperand(4);
2327   SDLoc DL(Op);
2328
2329   Comparison C(getCmp(DAG, CmpOp0, CmpOp1, CC, DL));
2330   SDValue Glue = emitCmp(DAG, DL, C);
2331   return DAG.getNode(SystemZISD::BR_CCMASK, DL, Op.getValueType(),
2332                      Op.getOperand(0), DAG.getConstant(C.CCValid, DL, MVT::i32),
2333                      DAG.getConstant(C.CCMask, DL, MVT::i32), Dest, Glue);
2334 }
2335
2336 // Return true if Pos is CmpOp and Neg is the negative of CmpOp,
2337 // allowing Pos and Neg to be wider than CmpOp.
2338 static bool isAbsolute(SDValue CmpOp, SDValue Pos, SDValue Neg) {
2339   return (Neg.getOpcode() == ISD::SUB &&
2340           Neg.getOperand(0).getOpcode() == ISD::Constant &&
2341           cast<ConstantSDNode>(Neg.getOperand(0))->getZExtValue() == 0 &&
2342           Neg.getOperand(1) == Pos &&
2343           (Pos == CmpOp ||
2344            (Pos.getOpcode() == ISD::SIGN_EXTEND &&
2345             Pos.getOperand(0) == CmpOp)));
2346 }
2347
2348 // Return the absolute or negative absolute of Op; IsNegative decides which.
2349 static SDValue getAbsolute(SelectionDAG &DAG, SDLoc DL, SDValue Op,
2350                            bool IsNegative) {
2351   Op = DAG.getNode(SystemZISD::IABS, DL, Op.getValueType(), Op);
2352   if (IsNegative)
2353     Op = DAG.getNode(ISD::SUB, DL, Op.getValueType(),
2354                      DAG.getConstant(0, DL, Op.getValueType()), Op);
2355   return Op;
2356 }
2357
2358 SDValue SystemZTargetLowering::lowerSELECT_CC(SDValue Op,
2359                                               SelectionDAG &DAG) const {
2360   SDValue CmpOp0   = Op.getOperand(0);
2361   SDValue CmpOp1   = Op.getOperand(1);
2362   SDValue TrueOp   = Op.getOperand(2);
2363   SDValue FalseOp  = Op.getOperand(3);
2364   ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
2365   SDLoc DL(Op);
2366
2367   Comparison C(getCmp(DAG, CmpOp0, CmpOp1, CC, DL));
2368
2369   // Check for absolute and negative-absolute selections, including those
2370   // where the comparison value is sign-extended (for LPGFR and LNGFR).
2371   // This check supplements the one in DAGCombiner.
2372   if (C.Opcode == SystemZISD::ICMP &&
2373       C.CCMask != SystemZ::CCMASK_CMP_EQ &&
2374       C.CCMask != SystemZ::CCMASK_CMP_NE &&
2375       C.Op1.getOpcode() == ISD::Constant &&
2376       cast<ConstantSDNode>(C.Op1)->getZExtValue() == 0) {
2377     if (isAbsolute(C.Op0, TrueOp, FalseOp))
2378       return getAbsolute(DAG, DL, TrueOp, C.CCMask & SystemZ::CCMASK_CMP_LT);
2379     if (isAbsolute(C.Op0, FalseOp, TrueOp))
2380       return getAbsolute(DAG, DL, FalseOp, C.CCMask & SystemZ::CCMASK_CMP_GT);
2381   }
2382
2383   SDValue Glue = emitCmp(DAG, DL, C);
2384
2385   // Special case for handling -1/0 results.  The shifts we use here
2386   // should get optimized with the IPM conversion sequence.
2387   auto *TrueC = dyn_cast<ConstantSDNode>(TrueOp);
2388   auto *FalseC = dyn_cast<ConstantSDNode>(FalseOp);
2389   if (TrueC && FalseC) {
2390     int64_t TrueVal = TrueC->getSExtValue();
2391     int64_t FalseVal = FalseC->getSExtValue();
2392     if ((TrueVal == -1 && FalseVal == 0) || (TrueVal == 0 && FalseVal == -1)) {
2393       // Invert the condition if we want -1 on false.
2394       if (TrueVal == 0)
2395         C.CCMask ^= C.CCValid;
2396       SDValue Result = emitSETCC(DAG, DL, Glue, C.CCValid, C.CCMask);
2397       EVT VT = Op.getValueType();
2398       // Extend the result to VT.  Upper bits are ignored.
2399       if (!is32Bit(VT))
2400         Result = DAG.getNode(ISD::ANY_EXTEND, DL, VT, Result);
2401       // Sign-extend from the low bit.
2402       SDValue ShAmt = DAG.getConstant(VT.getSizeInBits() - 1, DL, MVT::i32);
2403       SDValue Shl = DAG.getNode(ISD::SHL, DL, VT, Result, ShAmt);
2404       return DAG.getNode(ISD::SRA, DL, VT, Shl, ShAmt);
2405     }
2406   }
2407
2408   SDValue Ops[] = {TrueOp, FalseOp, DAG.getConstant(C.CCValid, DL, MVT::i32),
2409                    DAG.getConstant(C.CCMask, DL, MVT::i32), Glue};
2410
2411   SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::Glue);
2412   return DAG.getNode(SystemZISD::SELECT_CCMASK, DL, VTs, Ops);
2413 }
2414
2415 SDValue SystemZTargetLowering::lowerGlobalAddress(GlobalAddressSDNode *Node,
2416                                                   SelectionDAG &DAG) const {
2417   SDLoc DL(Node);
2418   const GlobalValue *GV = Node->getGlobal();
2419   int64_t Offset = Node->getOffset();
2420   EVT PtrVT = getPointerTy(DAG.getDataLayout());
2421   Reloc::Model RM = DAG.getTarget().getRelocationModel();
2422   CodeModel::Model CM = DAG.getTarget().getCodeModel();
2423
2424   SDValue Result;
2425   if (Subtarget.isPC32DBLSymbol(GV, RM, CM)) {
2426     // Assign anchors at 1<<12 byte boundaries.
2427     uint64_t Anchor = Offset & ~uint64_t(0xfff);
2428     Result = DAG.getTargetGlobalAddress(GV, DL, PtrVT, Anchor);
2429     Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
2430
2431     // The offset can be folded into the address if it is aligned to a halfword.
2432     Offset -= Anchor;
2433     if (Offset != 0 && (Offset & 1) == 0) {
2434       SDValue Full = DAG.getTargetGlobalAddress(GV, DL, PtrVT, Anchor + Offset);
2435       Result = DAG.getNode(SystemZISD::PCREL_OFFSET, DL, PtrVT, Full, Result);
2436       Offset = 0;
2437     }
2438   } else {
2439     Result = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0, SystemZII::MO_GOT);
2440     Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
2441     Result = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), Result,
2442                          MachinePointerInfo::getGOT(DAG.getMachineFunction()),
2443                          false, false, false, 0);
2444   }
2445
2446   // If there was a non-zero offset that we didn't fold, create an explicit
2447   // addition for it.
2448   if (Offset != 0)
2449     Result = DAG.getNode(ISD::ADD, DL, PtrVT, Result,
2450                          DAG.getConstant(Offset, DL, PtrVT));
2451
2452   return Result;
2453 }
2454
2455 SDValue SystemZTargetLowering::lowerTLSGetOffset(GlobalAddressSDNode *Node,
2456                                                  SelectionDAG &DAG,
2457                                                  unsigned Opcode,
2458                                                  SDValue GOTOffset) const {
2459   SDLoc DL(Node);
2460   EVT PtrVT = getPointerTy(DAG.getDataLayout());
2461   SDValue Chain = DAG.getEntryNode();
2462   SDValue Glue;
2463
2464   // __tls_get_offset takes the GOT offset in %r2 and the GOT in %r12.
2465   SDValue GOT = DAG.getGLOBAL_OFFSET_TABLE(PtrVT);
2466   Chain = DAG.getCopyToReg(Chain, DL, SystemZ::R12D, GOT, Glue);
2467   Glue = Chain.getValue(1);
2468   Chain = DAG.getCopyToReg(Chain, DL, SystemZ::R2D, GOTOffset, Glue);
2469   Glue = Chain.getValue(1);
2470
2471   // The first call operand is the chain and the second is the TLS symbol.
2472   SmallVector<SDValue, 8> Ops;
2473   Ops.push_back(Chain);
2474   Ops.push_back(DAG.getTargetGlobalAddress(Node->getGlobal(), DL,
2475                                            Node->getValueType(0),
2476                                            0, 0));
2477
2478   // Add argument registers to the end of the list so that they are
2479   // known live into the call.
2480   Ops.push_back(DAG.getRegister(SystemZ::R2D, PtrVT));
2481   Ops.push_back(DAG.getRegister(SystemZ::R12D, PtrVT));
2482
2483   // Add a register mask operand representing the call-preserved registers.
2484   const TargetRegisterInfo *TRI = Subtarget.getRegisterInfo();
2485   const uint32_t *Mask =
2486       TRI->getCallPreservedMask(DAG.getMachineFunction(), CallingConv::C);
2487   assert(Mask && "Missing call preserved mask for calling convention");
2488   Ops.push_back(DAG.getRegisterMask(Mask));
2489
2490   // Glue the call to the argument copies.
2491   Ops.push_back(Glue);
2492
2493   // Emit the call.
2494   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
2495   Chain = DAG.getNode(Opcode, DL, NodeTys, Ops);
2496   Glue = Chain.getValue(1);
2497
2498   // Copy the return value from %r2.
2499   return DAG.getCopyFromReg(Chain, DL, SystemZ::R2D, PtrVT, Glue);
2500 }
2501
2502 SDValue SystemZTargetLowering::lowerGlobalTLSAddress(GlobalAddressSDNode *Node,
2503                                                      SelectionDAG &DAG) const {
2504   if (DAG.getTarget().Options.EmulatedTLS)
2505     return LowerToTLSEmulatedModel(Node, DAG);
2506   SDLoc DL(Node);
2507   const GlobalValue *GV = Node->getGlobal();
2508   EVT PtrVT = getPointerTy(DAG.getDataLayout());
2509   TLSModel::Model model = DAG.getTarget().getTLSModel(GV);
2510
2511   // The high part of the thread pointer is in access register 0.
2512   SDValue TPHi = DAG.getNode(SystemZISD::EXTRACT_ACCESS, DL, MVT::i32,
2513                              DAG.getConstant(0, DL, MVT::i32));
2514   TPHi = DAG.getNode(ISD::ANY_EXTEND, DL, PtrVT, TPHi);
2515
2516   // The low part of the thread pointer is in access register 1.
2517   SDValue TPLo = DAG.getNode(SystemZISD::EXTRACT_ACCESS, DL, MVT::i32,
2518                              DAG.getConstant(1, DL, MVT::i32));
2519   TPLo = DAG.getNode(ISD::ZERO_EXTEND, DL, PtrVT, TPLo);
2520
2521   // Merge them into a single 64-bit address.
2522   SDValue TPHiShifted = DAG.getNode(ISD::SHL, DL, PtrVT, TPHi,
2523                                     DAG.getConstant(32, DL, PtrVT));
2524   SDValue TP = DAG.getNode(ISD::OR, DL, PtrVT, TPHiShifted, TPLo);
2525
2526   // Get the offset of GA from the thread pointer, based on the TLS model.
2527   SDValue Offset;
2528   switch (model) {
2529     case TLSModel::GeneralDynamic: {
2530       // Load the GOT offset of the tls_index (module ID / per-symbol offset).
2531       SystemZConstantPoolValue *CPV =
2532         SystemZConstantPoolValue::Create(GV, SystemZCP::TLSGD);
2533
2534       Offset = DAG.getConstantPool(CPV, PtrVT, 8);
2535       Offset = DAG.getLoad(
2536           PtrVT, DL, DAG.getEntryNode(), Offset,
2537           MachinePointerInfo::getConstantPool(DAG.getMachineFunction()), false,
2538           false, false, 0);
2539
2540       // Call __tls_get_offset to retrieve the offset.
2541       Offset = lowerTLSGetOffset(Node, DAG, SystemZISD::TLS_GDCALL, Offset);
2542       break;
2543     }
2544
2545     case TLSModel::LocalDynamic: {
2546       // Load the GOT offset of the module ID.
2547       SystemZConstantPoolValue *CPV =
2548         SystemZConstantPoolValue::Create(GV, SystemZCP::TLSLDM);
2549
2550       Offset = DAG.getConstantPool(CPV, PtrVT, 8);
2551       Offset = DAG.getLoad(
2552           PtrVT, DL, DAG.getEntryNode(), Offset,
2553           MachinePointerInfo::getConstantPool(DAG.getMachineFunction()), false,
2554           false, false, 0);
2555
2556       // Call __tls_get_offset to retrieve the module base offset.
2557       Offset = lowerTLSGetOffset(Node, DAG, SystemZISD::TLS_LDCALL, Offset);
2558
2559       // Note: The SystemZLDCleanupPass will remove redundant computations
2560       // of the module base offset.  Count total number of local-dynamic
2561       // accesses to trigger execution of that pass.
2562       SystemZMachineFunctionInfo* MFI =
2563         DAG.getMachineFunction().getInfo<SystemZMachineFunctionInfo>();
2564       MFI->incNumLocalDynamicTLSAccesses();
2565
2566       // Add the per-symbol offset.
2567       CPV = SystemZConstantPoolValue::Create(GV, SystemZCP::DTPOFF);
2568
2569       SDValue DTPOffset = DAG.getConstantPool(CPV, PtrVT, 8);
2570       DTPOffset = DAG.getLoad(
2571           PtrVT, DL, DAG.getEntryNode(), DTPOffset,
2572           MachinePointerInfo::getConstantPool(DAG.getMachineFunction()), false,
2573           false, false, 0);
2574
2575       Offset = DAG.getNode(ISD::ADD, DL, PtrVT, Offset, DTPOffset);
2576       break;
2577     }
2578
2579     case TLSModel::InitialExec: {
2580       // Load the offset from the GOT.
2581       Offset = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0,
2582                                           SystemZII::MO_INDNTPOFF);
2583       Offset = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Offset);
2584       Offset = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), Offset,
2585                            MachinePointerInfo::getGOT(DAG.getMachineFunction()),
2586                            false, false, false, 0);
2587       break;
2588     }
2589
2590     case TLSModel::LocalExec: {
2591       // Force the offset into the constant pool and load it from there.
2592       SystemZConstantPoolValue *CPV =
2593         SystemZConstantPoolValue::Create(GV, SystemZCP::NTPOFF);
2594
2595       Offset = DAG.getConstantPool(CPV, PtrVT, 8);
2596       Offset = DAG.getLoad(
2597           PtrVT, DL, DAG.getEntryNode(), Offset,
2598           MachinePointerInfo::getConstantPool(DAG.getMachineFunction()), false,
2599           false, false, 0);
2600       break;
2601     }
2602   }
2603
2604   // Add the base and offset together.
2605   return DAG.getNode(ISD::ADD, DL, PtrVT, TP, Offset);
2606 }
2607
2608 SDValue SystemZTargetLowering::lowerBlockAddress(BlockAddressSDNode *Node,
2609                                                  SelectionDAG &DAG) const {
2610   SDLoc DL(Node);
2611   const BlockAddress *BA = Node->getBlockAddress();
2612   int64_t Offset = Node->getOffset();
2613   EVT PtrVT = getPointerTy(DAG.getDataLayout());
2614
2615   SDValue Result = DAG.getTargetBlockAddress(BA, PtrVT, Offset);
2616   Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
2617   return Result;
2618 }
2619
2620 SDValue SystemZTargetLowering::lowerJumpTable(JumpTableSDNode *JT,
2621                                               SelectionDAG &DAG) const {
2622   SDLoc DL(JT);
2623   EVT PtrVT = getPointerTy(DAG.getDataLayout());
2624   SDValue Result = DAG.getTargetJumpTable(JT->getIndex(), PtrVT);
2625
2626   // Use LARL to load the address of the table.
2627   return DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
2628 }
2629
2630 SDValue SystemZTargetLowering::lowerConstantPool(ConstantPoolSDNode *CP,
2631                                                  SelectionDAG &DAG) const {
2632   SDLoc DL(CP);
2633   EVT PtrVT = getPointerTy(DAG.getDataLayout());
2634
2635   SDValue Result;
2636   if (CP->isMachineConstantPoolEntry())
2637     Result = DAG.getTargetConstantPool(CP->getMachineCPVal(), PtrVT,
2638                                        CP->getAlignment());
2639   else
2640     Result = DAG.getTargetConstantPool(CP->getConstVal(), PtrVT,
2641                                        CP->getAlignment(), CP->getOffset());
2642
2643   // Use LARL to load the address of the constant pool entry.
2644   return DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
2645 }
2646
2647 SDValue SystemZTargetLowering::lowerBITCAST(SDValue Op,
2648                                             SelectionDAG &DAG) const {
2649   SDLoc DL(Op);
2650   SDValue In = Op.getOperand(0);
2651   EVT InVT = In.getValueType();
2652   EVT ResVT = Op.getValueType();
2653
2654   // Convert loads directly.  This is normally done by DAGCombiner,
2655   // but we need this case for bitcasts that are created during lowering
2656   // and which are then lowered themselves.
2657   if (auto *LoadN = dyn_cast<LoadSDNode>(In))
2658     return DAG.getLoad(ResVT, DL, LoadN->getChain(), LoadN->getBasePtr(),
2659                        LoadN->getMemOperand());
2660
2661   if (InVT == MVT::i32 && ResVT == MVT::f32) {
2662     SDValue In64;
2663     if (Subtarget.hasHighWord()) {
2664       SDNode *U64 = DAG.getMachineNode(TargetOpcode::IMPLICIT_DEF, DL,
2665                                        MVT::i64);
2666       In64 = DAG.getTargetInsertSubreg(SystemZ::subreg_h32, DL,
2667                                        MVT::i64, SDValue(U64, 0), In);
2668     } else {
2669       In64 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, In);
2670       In64 = DAG.getNode(ISD::SHL, DL, MVT::i64, In64,
2671                          DAG.getConstant(32, DL, MVT::i64));
2672     }
2673     SDValue Out64 = DAG.getNode(ISD::BITCAST, DL, MVT::f64, In64);
2674     return DAG.getTargetExtractSubreg(SystemZ::subreg_r32,
2675                                       DL, MVT::f32, Out64);
2676   }
2677   if (InVT == MVT::f32 && ResVT == MVT::i32) {
2678     SDNode *U64 = DAG.getMachineNode(TargetOpcode::IMPLICIT_DEF, DL, MVT::f64);
2679     SDValue In64 = DAG.getTargetInsertSubreg(SystemZ::subreg_r32, DL,
2680                                              MVT::f64, SDValue(U64, 0), In);
2681     SDValue Out64 = DAG.getNode(ISD::BITCAST, DL, MVT::i64, In64);
2682     if (Subtarget.hasHighWord())
2683       return DAG.getTargetExtractSubreg(SystemZ::subreg_h32, DL,
2684                                         MVT::i32, Out64);
2685     SDValue Shift = DAG.getNode(ISD::SRL, DL, MVT::i64, Out64,
2686                                 DAG.getConstant(32, DL, MVT::i64));
2687     return DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Shift);
2688   }
2689   llvm_unreachable("Unexpected bitcast combination");
2690 }
2691
2692 SDValue SystemZTargetLowering::lowerVASTART(SDValue Op,
2693                                             SelectionDAG &DAG) const {
2694   MachineFunction &MF = DAG.getMachineFunction();
2695   SystemZMachineFunctionInfo *FuncInfo =
2696     MF.getInfo<SystemZMachineFunctionInfo>();
2697   EVT PtrVT = getPointerTy(DAG.getDataLayout());
2698
2699   SDValue Chain   = Op.getOperand(0);
2700   SDValue Addr    = Op.getOperand(1);
2701   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
2702   SDLoc DL(Op);
2703
2704   // The initial values of each field.
2705   const unsigned NumFields = 4;
2706   SDValue Fields[NumFields] = {
2707     DAG.getConstant(FuncInfo->getVarArgsFirstGPR(), DL, PtrVT),
2708     DAG.getConstant(FuncInfo->getVarArgsFirstFPR(), DL, PtrVT),
2709     DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT),
2710     DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(), PtrVT)
2711   };
2712
2713   // Store each field into its respective slot.
2714   SDValue MemOps[NumFields];
2715   unsigned Offset = 0;
2716   for (unsigned I = 0; I < NumFields; ++I) {
2717     SDValue FieldAddr = Addr;
2718     if (Offset != 0)
2719       FieldAddr = DAG.getNode(ISD::ADD, DL, PtrVT, FieldAddr,
2720                               DAG.getIntPtrConstant(Offset, DL));
2721     MemOps[I] = DAG.getStore(Chain, DL, Fields[I], FieldAddr,
2722                              MachinePointerInfo(SV, Offset),
2723                              false, false, 0);
2724     Offset += 8;
2725   }
2726   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOps);
2727 }
2728
2729 SDValue SystemZTargetLowering::lowerVACOPY(SDValue Op,
2730                                            SelectionDAG &DAG) const {
2731   SDValue Chain      = Op.getOperand(0);
2732   SDValue DstPtr     = Op.getOperand(1);
2733   SDValue SrcPtr     = Op.getOperand(2);
2734   const Value *DstSV = cast<SrcValueSDNode>(Op.getOperand(3))->getValue();
2735   const Value *SrcSV = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
2736   SDLoc DL(Op);
2737
2738   return DAG.getMemcpy(Chain, DL, DstPtr, SrcPtr, DAG.getIntPtrConstant(32, DL),
2739                        /*Align*/8, /*isVolatile*/false, /*AlwaysInline*/false,
2740                        /*isTailCall*/false,
2741                        MachinePointerInfo(DstSV), MachinePointerInfo(SrcSV));
2742 }
2743
2744 SDValue SystemZTargetLowering::
2745 lowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const {
2746   SDValue Chain = Op.getOperand(0);
2747   SDValue Size  = Op.getOperand(1);
2748   SDLoc DL(Op);
2749
2750   unsigned SPReg = getStackPointerRegisterToSaveRestore();
2751
2752   // Get a reference to the stack pointer.
2753   SDValue OldSP = DAG.getCopyFromReg(Chain, DL, SPReg, MVT::i64);
2754
2755   // Get the new stack pointer value.
2756   SDValue NewSP = DAG.getNode(ISD::SUB, DL, MVT::i64, OldSP, Size);
2757
2758   // Copy the new stack pointer back.
2759   Chain = DAG.getCopyToReg(Chain, DL, SPReg, NewSP);
2760
2761   // The allocated data lives above the 160 bytes allocated for the standard
2762   // frame, plus any outgoing stack arguments.  We don't know how much that
2763   // amounts to yet, so emit a special ADJDYNALLOC placeholder.
2764   SDValue ArgAdjust = DAG.getNode(SystemZISD::ADJDYNALLOC, DL, MVT::i64);
2765   SDValue Result = DAG.getNode(ISD::ADD, DL, MVT::i64, NewSP, ArgAdjust);
2766
2767   SDValue Ops[2] = { Result, Chain };
2768   return DAG.getMergeValues(Ops, DL);
2769 }
2770
2771 SDValue SystemZTargetLowering::lowerSMUL_LOHI(SDValue Op,
2772                                               SelectionDAG &DAG) const {
2773   EVT VT = Op.getValueType();
2774   SDLoc DL(Op);
2775   SDValue Ops[2];
2776   if (is32Bit(VT))
2777     // Just do a normal 64-bit multiplication and extract the results.
2778     // We define this so that it can be used for constant division.
2779     lowerMUL_LOHI32(DAG, DL, ISD::SIGN_EXTEND, Op.getOperand(0),
2780                     Op.getOperand(1), Ops[1], Ops[0]);
2781   else {
2782     // Do a full 128-bit multiplication based on UMUL_LOHI64:
2783     //
2784     //   (ll * rl) + ((lh * rl) << 64) + ((ll * rh) << 64)
2785     //
2786     // but using the fact that the upper halves are either all zeros
2787     // or all ones:
2788     //
2789     //   (ll * rl) - ((lh & rl) << 64) - ((ll & rh) << 64)
2790     //
2791     // and grouping the right terms together since they are quicker than the
2792     // multiplication:
2793     //
2794     //   (ll * rl) - (((lh & rl) + (ll & rh)) << 64)
2795     SDValue C63 = DAG.getConstant(63, DL, MVT::i64);
2796     SDValue LL = Op.getOperand(0);
2797     SDValue RL = Op.getOperand(1);
2798     SDValue LH = DAG.getNode(ISD::SRA, DL, VT, LL, C63);
2799     SDValue RH = DAG.getNode(ISD::SRA, DL, VT, RL, C63);
2800     // UMUL_LOHI64 returns the low result in the odd register and the high
2801     // result in the even register.  SMUL_LOHI is defined to return the
2802     // low half first, so the results are in reverse order.
2803     lowerGR128Binary(DAG, DL, VT, SystemZ::AEXT128_64, SystemZISD::UMUL_LOHI64,
2804                      LL, RL, Ops[1], Ops[0]);
2805     SDValue NegLLTimesRH = DAG.getNode(ISD::AND, DL, VT, LL, RH);
2806     SDValue NegLHTimesRL = DAG.getNode(ISD::AND, DL, VT, LH, RL);
2807     SDValue NegSum = DAG.getNode(ISD::ADD, DL, VT, NegLLTimesRH, NegLHTimesRL);
2808     Ops[1] = DAG.getNode(ISD::SUB, DL, VT, Ops[1], NegSum);
2809   }
2810   return DAG.getMergeValues(Ops, DL);
2811 }
2812
2813 SDValue SystemZTargetLowering::lowerUMUL_LOHI(SDValue Op,
2814                                               SelectionDAG &DAG) const {
2815   EVT VT = Op.getValueType();
2816   SDLoc DL(Op);
2817   SDValue Ops[2];
2818   if (is32Bit(VT))
2819     // Just do a normal 64-bit multiplication and extract the results.
2820     // We define this so that it can be used for constant division.
2821     lowerMUL_LOHI32(DAG, DL, ISD::ZERO_EXTEND, Op.getOperand(0),
2822                     Op.getOperand(1), Ops[1], Ops[0]);
2823   else
2824     // UMUL_LOHI64 returns the low result in the odd register and the high
2825     // result in the even register.  UMUL_LOHI is defined to return the
2826     // low half first, so the results are in reverse order.
2827     lowerGR128Binary(DAG, DL, VT, SystemZ::AEXT128_64, SystemZISD::UMUL_LOHI64,
2828                      Op.getOperand(0), Op.getOperand(1), Ops[1], Ops[0]);
2829   return DAG.getMergeValues(Ops, DL);
2830 }
2831
2832 SDValue SystemZTargetLowering::lowerSDIVREM(SDValue Op,
2833                                             SelectionDAG &DAG) const {
2834   SDValue Op0 = Op.getOperand(0);
2835   SDValue Op1 = Op.getOperand(1);
2836   EVT VT = Op.getValueType();
2837   SDLoc DL(Op);
2838   unsigned Opcode;
2839
2840   // We use DSGF for 32-bit division.
2841   if (is32Bit(VT)) {
2842     Op0 = DAG.getNode(ISD::SIGN_EXTEND, DL, MVT::i64, Op0);
2843     Opcode = SystemZISD::SDIVREM32;
2844   } else if (DAG.ComputeNumSignBits(Op1) > 32) {
2845     Op1 = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Op1);
2846     Opcode = SystemZISD::SDIVREM32;
2847   } else    
2848     Opcode = SystemZISD::SDIVREM64;
2849
2850   // DSG(F) takes a 64-bit dividend, so the even register in the GR128
2851   // input is "don't care".  The instruction returns the remainder in
2852   // the even register and the quotient in the odd register.
2853   SDValue Ops[2];
2854   lowerGR128Binary(DAG, DL, VT, SystemZ::AEXT128_64, Opcode,
2855                    Op0, Op1, Ops[1], Ops[0]);
2856   return DAG.getMergeValues(Ops, DL);
2857 }
2858
2859 SDValue SystemZTargetLowering::lowerUDIVREM(SDValue Op,
2860                                             SelectionDAG &DAG) const {
2861   EVT VT = Op.getValueType();
2862   SDLoc DL(Op);
2863
2864   // DL(G) uses a double-width dividend, so we need to clear the even
2865   // register in the GR128 input.  The instruction returns the remainder
2866   // in the even register and the quotient in the odd register.
2867   SDValue Ops[2];
2868   if (is32Bit(VT))
2869     lowerGR128Binary(DAG, DL, VT, SystemZ::ZEXT128_32, SystemZISD::UDIVREM32,
2870                      Op.getOperand(0), Op.getOperand(1), Ops[1], Ops[0]);
2871   else
2872     lowerGR128Binary(DAG, DL, VT, SystemZ::ZEXT128_64, SystemZISD::UDIVREM64,
2873                      Op.getOperand(0), Op.getOperand(1), Ops[1], Ops[0]);
2874   return DAG.getMergeValues(Ops, DL);
2875 }
2876
2877 SDValue SystemZTargetLowering::lowerOR(SDValue Op, SelectionDAG &DAG) const {
2878   assert(Op.getValueType() == MVT::i64 && "Should be 64-bit operation");
2879
2880   // Get the known-zero masks for each operand.
2881   SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1) };
2882   APInt KnownZero[2], KnownOne[2];
2883   DAG.computeKnownBits(Ops[0], KnownZero[0], KnownOne[0]);
2884   DAG.computeKnownBits(Ops[1], KnownZero[1], KnownOne[1]);
2885
2886   // See if the upper 32 bits of one operand and the lower 32 bits of the
2887   // other are known zero.  They are the low and high operands respectively.
2888   uint64_t Masks[] = { KnownZero[0].getZExtValue(),
2889                        KnownZero[1].getZExtValue() };
2890   unsigned High, Low;
2891   if ((Masks[0] >> 32) == 0xffffffff && uint32_t(Masks[1]) == 0xffffffff)
2892     High = 1, Low = 0;
2893   else if ((Masks[1] >> 32) == 0xffffffff && uint32_t(Masks[0]) == 0xffffffff)
2894     High = 0, Low = 1;
2895   else
2896     return Op;
2897
2898   SDValue LowOp = Ops[Low];
2899   SDValue HighOp = Ops[High];
2900
2901   // If the high part is a constant, we're better off using IILH.
2902   if (HighOp.getOpcode() == ISD::Constant)
2903     return Op;
2904
2905   // If the low part is a constant that is outside the range of LHI,
2906   // then we're better off using IILF.
2907   if (LowOp.getOpcode() == ISD::Constant) {
2908     int64_t Value = int32_t(cast<ConstantSDNode>(LowOp)->getZExtValue());
2909     if (!isInt<16>(Value))
2910       return Op;
2911   }
2912
2913   // Check whether the high part is an AND that doesn't change the
2914   // high 32 bits and just masks out low bits.  We can skip it if so.
2915   if (HighOp.getOpcode() == ISD::AND &&
2916       HighOp.getOperand(1).getOpcode() == ISD::Constant) {
2917     SDValue HighOp0 = HighOp.getOperand(0);
2918     uint64_t Mask = cast<ConstantSDNode>(HighOp.getOperand(1))->getZExtValue();
2919     if (DAG.MaskedValueIsZero(HighOp0, APInt(64, ~(Mask | 0xffffffff))))
2920       HighOp = HighOp0;
2921   }
2922
2923   // Take advantage of the fact that all GR32 operations only change the
2924   // low 32 bits by truncating Low to an i32 and inserting it directly
2925   // using a subreg.  The interesting cases are those where the truncation
2926   // can be folded.
2927   SDLoc DL(Op);
2928   SDValue Low32 = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, LowOp);
2929   return DAG.getTargetInsertSubreg(SystemZ::subreg_l32, DL,
2930                                    MVT::i64, HighOp, Low32);
2931 }
2932
2933 SDValue SystemZTargetLowering::lowerCTPOP(SDValue Op,
2934                                           SelectionDAG &DAG) const {
2935   EVT VT = Op.getValueType();
2936   SDLoc DL(Op);
2937   Op = Op.getOperand(0);
2938
2939   // Handle vector types via VPOPCT.
2940   if (VT.isVector()) {
2941     Op = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, Op);
2942     Op = DAG.getNode(SystemZISD::POPCNT, DL, MVT::v16i8, Op);
2943     switch (VT.getVectorElementType().getSizeInBits()) {
2944     case 8:
2945       break;
2946     case 16: {
2947       Op = DAG.getNode(ISD::BITCAST, DL, VT, Op);
2948       SDValue Shift = DAG.getConstant(8, DL, MVT::i32);
2949       SDValue Tmp = DAG.getNode(SystemZISD::VSHL_BY_SCALAR, DL, VT, Op, Shift);
2950       Op = DAG.getNode(ISD::ADD, DL, VT, Op, Tmp);
2951       Op = DAG.getNode(SystemZISD::VSRL_BY_SCALAR, DL, VT, Op, Shift);
2952       break;
2953     }
2954     case 32: {
2955       SDValue Tmp = DAG.getNode(SystemZISD::BYTE_MASK, DL, MVT::v16i8,
2956                                 DAG.getConstant(0, DL, MVT::i32));
2957       Op = DAG.getNode(SystemZISD::VSUM, DL, VT, Op, Tmp);
2958       break;
2959     }
2960     case 64: {
2961       SDValue Tmp = DAG.getNode(SystemZISD::BYTE_MASK, DL, MVT::v16i8,
2962                                 DAG.getConstant(0, DL, MVT::i32));
2963       Op = DAG.getNode(SystemZISD::VSUM, DL, MVT::v4i32, Op, Tmp);
2964       Op = DAG.getNode(SystemZISD::VSUM, DL, VT, Op, Tmp);
2965       break;
2966     }
2967     default:
2968       llvm_unreachable("Unexpected type");
2969     }
2970     return Op;
2971   }
2972
2973   // Get the known-zero mask for the operand.
2974   APInt KnownZero, KnownOne;
2975   DAG.computeKnownBits(Op, KnownZero, KnownOne);
2976   unsigned NumSignificantBits = (~KnownZero).getActiveBits();
2977   if (NumSignificantBits == 0)
2978     return DAG.getConstant(0, DL, VT);
2979
2980   // Skip known-zero high parts of the operand.
2981   int64_t OrigBitSize = VT.getSizeInBits();
2982   int64_t BitSize = (int64_t)1 << Log2_32_Ceil(NumSignificantBits);
2983   BitSize = std::min(BitSize, OrigBitSize);
2984
2985   // The POPCNT instruction counts the number of bits in each byte.
2986   Op = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Op);
2987   Op = DAG.getNode(SystemZISD::POPCNT, DL, MVT::i64, Op);
2988   Op = DAG.getNode(ISD::TRUNCATE, DL, VT, Op);
2989
2990   // Add up per-byte counts in a binary tree.  All bits of Op at
2991   // position larger than BitSize remain zero throughout.
2992   for (int64_t I = BitSize / 2; I >= 8; I = I / 2) {
2993     SDValue Tmp = DAG.getNode(ISD::SHL, DL, VT, Op, DAG.getConstant(I, DL, VT));
2994     if (BitSize != OrigBitSize)
2995       Tmp = DAG.getNode(ISD::AND, DL, VT, Tmp,
2996                         DAG.getConstant(((uint64_t)1 << BitSize) - 1, DL, VT));
2997     Op = DAG.getNode(ISD::ADD, DL, VT, Op, Tmp);
2998   }
2999
3000   // Extract overall result from high byte.
3001   if (BitSize > 8)
3002     Op = DAG.getNode(ISD::SRL, DL, VT, Op,
3003                      DAG.getConstant(BitSize - 8, DL, VT));
3004
3005   return Op;
3006 }
3007
3008 // Op is an atomic load.  Lower it into a normal volatile load.
3009 SDValue SystemZTargetLowering::lowerATOMIC_LOAD(SDValue Op,
3010                                                 SelectionDAG &DAG) const {
3011   auto *Node = cast<AtomicSDNode>(Op.getNode());
3012   return DAG.getExtLoad(ISD::EXTLOAD, SDLoc(Op), Op.getValueType(),
3013                         Node->getChain(), Node->getBasePtr(),
3014                         Node->getMemoryVT(), Node->getMemOperand());
3015 }
3016
3017 // Op is an atomic store.  Lower it into a normal volatile store followed
3018 // by a serialization.
3019 SDValue SystemZTargetLowering::lowerATOMIC_STORE(SDValue Op,
3020                                                  SelectionDAG &DAG) const {
3021   auto *Node = cast<AtomicSDNode>(Op.getNode());
3022   SDValue Chain = DAG.getTruncStore(Node->getChain(), SDLoc(Op), Node->getVal(),
3023                                     Node->getBasePtr(), Node->getMemoryVT(),
3024                                     Node->getMemOperand());
3025   return SDValue(DAG.getMachineNode(SystemZ::Serialize, SDLoc(Op), MVT::Other,
3026                                     Chain), 0);
3027 }
3028
3029 // Op is an 8-, 16-bit or 32-bit ATOMIC_LOAD_* operation.  Lower the first
3030 // two into the fullword ATOMIC_LOADW_* operation given by Opcode.
3031 SDValue SystemZTargetLowering::lowerATOMIC_LOAD_OP(SDValue Op,
3032                                                    SelectionDAG &DAG,
3033                                                    unsigned Opcode) const {
3034   auto *Node = cast<AtomicSDNode>(Op.getNode());
3035
3036   // 32-bit operations need no code outside the main loop.
3037   EVT NarrowVT = Node->getMemoryVT();
3038   EVT WideVT = MVT::i32;
3039   if (NarrowVT == WideVT)
3040     return Op;
3041
3042   int64_t BitSize = NarrowVT.getSizeInBits();
3043   SDValue ChainIn = Node->getChain();
3044   SDValue Addr = Node->getBasePtr();
3045   SDValue Src2 = Node->getVal();
3046   MachineMemOperand *MMO = Node->getMemOperand();
3047   SDLoc DL(Node);
3048   EVT PtrVT = Addr.getValueType();
3049
3050   // Convert atomic subtracts of constants into additions.
3051   if (Opcode == SystemZISD::ATOMIC_LOADW_SUB)
3052     if (auto *Const = dyn_cast<ConstantSDNode>(Src2)) {
3053       Opcode = SystemZISD::ATOMIC_LOADW_ADD;
3054       Src2 = DAG.getConstant(-Const->getSExtValue(), DL, Src2.getValueType());
3055     }
3056
3057   // Get the address of the containing word.
3058   SDValue AlignedAddr = DAG.getNode(ISD::AND, DL, PtrVT, Addr,
3059                                     DAG.getConstant(-4, DL, PtrVT));
3060
3061   // Get the number of bits that the word must be rotated left in order
3062   // to bring the field to the top bits of a GR32.
3063   SDValue BitShift = DAG.getNode(ISD::SHL, DL, PtrVT, Addr,
3064                                  DAG.getConstant(3, DL, PtrVT));
3065   BitShift = DAG.getNode(ISD::TRUNCATE, DL, WideVT, BitShift);
3066
3067   // Get the complementing shift amount, for rotating a field in the top
3068   // bits back to its proper position.
3069   SDValue NegBitShift = DAG.getNode(ISD::SUB, DL, WideVT,
3070                                     DAG.getConstant(0, DL, WideVT), BitShift);
3071
3072   // Extend the source operand to 32 bits and prepare it for the inner loop.
3073   // ATOMIC_SWAPW uses RISBG to rotate the field left, but all other
3074   // operations require the source to be shifted in advance.  (This shift
3075   // can be folded if the source is constant.)  For AND and NAND, the lower
3076   // bits must be set, while for other opcodes they should be left clear.
3077   if (Opcode != SystemZISD::ATOMIC_SWAPW)
3078     Src2 = DAG.getNode(ISD::SHL, DL, WideVT, Src2,
3079                        DAG.getConstant(32 - BitSize, DL, WideVT));
3080   if (Opcode == SystemZISD::ATOMIC_LOADW_AND ||
3081       Opcode == SystemZISD::ATOMIC_LOADW_NAND)
3082     Src2 = DAG.getNode(ISD::OR, DL, WideVT, Src2,
3083                        DAG.getConstant(uint32_t(-1) >> BitSize, DL, WideVT));
3084
3085   // Construct the ATOMIC_LOADW_* node.
3086   SDVTList VTList = DAG.getVTList(WideVT, MVT::Other);
3087   SDValue Ops[] = { ChainIn, AlignedAddr, Src2, BitShift, NegBitShift,
3088                     DAG.getConstant(BitSize, DL, WideVT) };
3089   SDValue AtomicOp = DAG.getMemIntrinsicNode(Opcode, DL, VTList, Ops,
3090                                              NarrowVT, MMO);
3091
3092   // Rotate the result of the final CS so that the field is in the lower
3093   // bits of a GR32, then truncate it.
3094   SDValue ResultShift = DAG.getNode(ISD::ADD, DL, WideVT, BitShift,
3095                                     DAG.getConstant(BitSize, DL, WideVT));
3096   SDValue Result = DAG.getNode(ISD::ROTL, DL, WideVT, AtomicOp, ResultShift);
3097
3098   SDValue RetOps[2] = { Result, AtomicOp.getValue(1) };
3099   return DAG.getMergeValues(RetOps, DL);
3100 }
3101
3102 // Op is an ATOMIC_LOAD_SUB operation.  Lower 8- and 16-bit operations
3103 // into ATOMIC_LOADW_SUBs and decide whether to convert 32- and 64-bit
3104 // operations into additions.
3105 SDValue SystemZTargetLowering::lowerATOMIC_LOAD_SUB(SDValue Op,
3106                                                     SelectionDAG &DAG) const {
3107   auto *Node = cast<AtomicSDNode>(Op.getNode());
3108   EVT MemVT = Node->getMemoryVT();
3109   if (MemVT == MVT::i32 || MemVT == MVT::i64) {
3110     // A full-width operation.
3111     assert(Op.getValueType() == MemVT && "Mismatched VTs");
3112     SDValue Src2 = Node->getVal();
3113     SDValue NegSrc2;
3114     SDLoc DL(Src2);
3115
3116     if (auto *Op2 = dyn_cast<ConstantSDNode>(Src2)) {
3117       // Use an addition if the operand is constant and either LAA(G) is
3118       // available or the negative value is in the range of A(G)FHI.
3119       int64_t Value = (-Op2->getAPIntValue()).getSExtValue();
3120       if (isInt<32>(Value) || Subtarget.hasInterlockedAccess1())
3121         NegSrc2 = DAG.getConstant(Value, DL, MemVT);
3122     } else if (Subtarget.hasInterlockedAccess1())
3123       // Use LAA(G) if available.
3124       NegSrc2 = DAG.getNode(ISD::SUB, DL, MemVT, DAG.getConstant(0, DL, MemVT),
3125                             Src2);
3126
3127     if (NegSrc2.getNode())
3128       return DAG.getAtomic(ISD::ATOMIC_LOAD_ADD, DL, MemVT,
3129                            Node->getChain(), Node->getBasePtr(), NegSrc2,
3130                            Node->getMemOperand(), Node->getOrdering(),
3131                            Node->getSynchScope());
3132
3133     // Use the node as-is.
3134     return Op;
3135   }
3136
3137   return lowerATOMIC_LOAD_OP(Op, DAG, SystemZISD::ATOMIC_LOADW_SUB);
3138 }
3139
3140 // Node is an 8- or 16-bit ATOMIC_CMP_SWAP operation.  Lower the first two
3141 // into a fullword ATOMIC_CMP_SWAPW operation.
3142 SDValue SystemZTargetLowering::lowerATOMIC_CMP_SWAP(SDValue Op,
3143                                                     SelectionDAG &DAG) const {
3144   auto *Node = cast<AtomicSDNode>(Op.getNode());
3145
3146   // We have native support for 32-bit compare and swap.
3147   EVT NarrowVT = Node->getMemoryVT();
3148   EVT WideVT = MVT::i32;
3149   if (NarrowVT == WideVT)
3150     return Op;
3151
3152   int64_t BitSize = NarrowVT.getSizeInBits();
3153   SDValue ChainIn = Node->getOperand(0);
3154   SDValue Addr = Node->getOperand(1);
3155   SDValue CmpVal = Node->getOperand(2);
3156   SDValue SwapVal = Node->getOperand(3);
3157   MachineMemOperand *MMO = Node->getMemOperand();
3158   SDLoc DL(Node);
3159   EVT PtrVT = Addr.getValueType();
3160
3161   // Get the address of the containing word.
3162   SDValue AlignedAddr = DAG.getNode(ISD::AND, DL, PtrVT, Addr,
3163                                     DAG.getConstant(-4, DL, PtrVT));
3164
3165   // Get the number of bits that the word must be rotated left in order
3166   // to bring the field to the top bits of a GR32.
3167   SDValue BitShift = DAG.getNode(ISD::SHL, DL, PtrVT, Addr,
3168                                  DAG.getConstant(3, DL, PtrVT));
3169   BitShift = DAG.getNode(ISD::TRUNCATE, DL, WideVT, BitShift);
3170
3171   // Get the complementing shift amount, for rotating a field in the top
3172   // bits back to its proper position.
3173   SDValue NegBitShift = DAG.getNode(ISD::SUB, DL, WideVT,
3174                                     DAG.getConstant(0, DL, WideVT), BitShift);
3175
3176   // Construct the ATOMIC_CMP_SWAPW node.
3177   SDVTList VTList = DAG.getVTList(WideVT, MVT::Other);
3178   SDValue Ops[] = { ChainIn, AlignedAddr, CmpVal, SwapVal, BitShift,
3179                     NegBitShift, DAG.getConstant(BitSize, DL, WideVT) };
3180   SDValue AtomicOp = DAG.getMemIntrinsicNode(SystemZISD::ATOMIC_CMP_SWAPW, DL,
3181                                              VTList, Ops, NarrowVT, MMO);
3182   return AtomicOp;
3183 }
3184
3185 SDValue SystemZTargetLowering::lowerSTACKSAVE(SDValue Op,
3186                                               SelectionDAG &DAG) const {
3187   MachineFunction &MF = DAG.getMachineFunction();
3188   MF.getInfo<SystemZMachineFunctionInfo>()->setManipulatesSP(true);
3189   return DAG.getCopyFromReg(Op.getOperand(0), SDLoc(Op),
3190                             SystemZ::R15D, Op.getValueType());
3191 }
3192
3193 SDValue SystemZTargetLowering::lowerSTACKRESTORE(SDValue Op,
3194                                                  SelectionDAG &DAG) const {
3195   MachineFunction &MF = DAG.getMachineFunction();
3196   MF.getInfo<SystemZMachineFunctionInfo>()->setManipulatesSP(true);
3197   return DAG.getCopyToReg(Op.getOperand(0), SDLoc(Op),
3198                           SystemZ::R15D, Op.getOperand(1));
3199 }
3200
3201 SDValue SystemZTargetLowering::lowerPREFETCH(SDValue Op,
3202                                              SelectionDAG &DAG) const {
3203   bool IsData = cast<ConstantSDNode>(Op.getOperand(4))->getZExtValue();
3204   if (!IsData)
3205     // Just preserve the chain.
3206     return Op.getOperand(0);
3207
3208   SDLoc DL(Op);
3209   bool IsWrite = cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue();
3210   unsigned Code = IsWrite ? SystemZ::PFD_WRITE : SystemZ::PFD_READ;
3211   auto *Node = cast<MemIntrinsicSDNode>(Op.getNode());
3212   SDValue Ops[] = {
3213     Op.getOperand(0),
3214     DAG.getConstant(Code, DL, MVT::i32),
3215     Op.getOperand(1)
3216   };
3217   return DAG.getMemIntrinsicNode(SystemZISD::PREFETCH, DL,
3218                                  Node->getVTList(), Ops,
3219                                  Node->getMemoryVT(), Node->getMemOperand());
3220 }
3221
3222 // Return an i32 that contains the value of CC immediately after After,
3223 // whose final operand must be MVT::Glue.
3224 static SDValue getCCResult(SelectionDAG &DAG, SDNode *After) {
3225   SDLoc DL(After);
3226   SDValue Glue = SDValue(After, After->getNumValues() - 1);
3227   SDValue IPM = DAG.getNode(SystemZISD::IPM, DL, MVT::i32, Glue);
3228   return DAG.getNode(ISD::SRL, DL, MVT::i32, IPM,
3229                      DAG.getConstant(SystemZ::IPM_CC, DL, MVT::i32));
3230 }
3231
3232 SDValue
3233 SystemZTargetLowering::lowerINTRINSIC_W_CHAIN(SDValue Op,
3234                                               SelectionDAG &DAG) const {
3235   unsigned Opcode, CCValid;
3236   if (isIntrinsicWithCCAndChain(Op, Opcode, CCValid)) {
3237     assert(Op->getNumValues() == 2 && "Expected only CC result and chain");
3238     SDValue Glued = emitIntrinsicWithChainAndGlue(DAG, Op, Opcode);
3239     SDValue CC = getCCResult(DAG, Glued.getNode());
3240     DAG.ReplaceAllUsesOfValueWith(SDValue(Op.getNode(), 0), CC);
3241     return SDValue();
3242   }
3243
3244   return SDValue();
3245 }
3246
3247 SDValue
3248 SystemZTargetLowering::lowerINTRINSIC_WO_CHAIN(SDValue Op,
3249                                                SelectionDAG &DAG) const {
3250   unsigned Opcode, CCValid;
3251   if (isIntrinsicWithCC(Op, Opcode, CCValid)) {
3252     SDValue Glued = emitIntrinsicWithGlue(DAG, Op, Opcode);
3253     SDValue CC = getCCResult(DAG, Glued.getNode());
3254     if (Op->getNumValues() == 1)
3255       return CC;
3256     assert(Op->getNumValues() == 2 && "Expected a CC and non-CC result");
3257     return DAG.getNode(ISD::MERGE_VALUES, SDLoc(Op), Op->getVTList(),
3258                     Glued, CC);
3259   }
3260
3261   unsigned Id = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
3262   switch (Id) {
3263   case Intrinsic::s390_vpdi:
3264     return DAG.getNode(SystemZISD::PERMUTE_DWORDS, SDLoc(Op), Op.getValueType(),
3265                        Op.getOperand(1), Op.getOperand(2), Op.getOperand(3));
3266
3267   case Intrinsic::s390_vperm:
3268     return DAG.getNode(SystemZISD::PERMUTE, SDLoc(Op), Op.getValueType(),
3269                        Op.getOperand(1), Op.getOperand(2), Op.getOperand(3));
3270
3271   case Intrinsic::s390_vuphb:
3272   case Intrinsic::s390_vuphh:
3273   case Intrinsic::s390_vuphf:
3274     return DAG.getNode(SystemZISD::UNPACK_HIGH, SDLoc(Op), Op.getValueType(),
3275                        Op.getOperand(1));
3276
3277   case Intrinsic::s390_vuplhb:
3278   case Intrinsic::s390_vuplhh:
3279   case Intrinsic::s390_vuplhf:
3280     return DAG.getNode(SystemZISD::UNPACKL_HIGH, SDLoc(Op), Op.getValueType(),
3281                        Op.getOperand(1));
3282
3283   case Intrinsic::s390_vuplb:
3284   case Intrinsic::s390_vuplhw:
3285   case Intrinsic::s390_vuplf:
3286     return DAG.getNode(SystemZISD::UNPACK_LOW, SDLoc(Op), Op.getValueType(),
3287                        Op.getOperand(1));
3288
3289   case Intrinsic::s390_vupllb:
3290   case Intrinsic::s390_vupllh:
3291   case Intrinsic::s390_vupllf:
3292     return DAG.getNode(SystemZISD::UNPACKL_LOW, SDLoc(Op), Op.getValueType(),
3293                        Op.getOperand(1));
3294
3295   case Intrinsic::s390_vsumb:
3296   case Intrinsic::s390_vsumh:
3297   case Intrinsic::s390_vsumgh:
3298   case Intrinsic::s390_vsumgf:
3299   case Intrinsic::s390_vsumqf:
3300   case Intrinsic::s390_vsumqg:
3301     return DAG.getNode(SystemZISD::VSUM, SDLoc(Op), Op.getValueType(),
3302                        Op.getOperand(1), Op.getOperand(2));
3303   }
3304
3305   return SDValue();
3306 }
3307