Switch lowering: fix assert in buildBitTests (PR23738)
[oota-llvm.git] / lib / CodeGen / SelectionDAG / SelectionDAGBuilder.cpp
1 //===-- SelectionDAGBuilder.cpp - Selection-DAG building ------------------===//
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 implements routines for translating from LLVM IR into SelectionDAG IR.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "SelectionDAGBuilder.h"
15 #include "SDNodeDbgValue.h"
16 #include "llvm/ADT/BitVector.h"
17 #include "llvm/ADT/Optional.h"
18 #include "llvm/ADT/SmallSet.h"
19 #include "llvm/ADT/Statistic.h"
20 #include "llvm/Analysis/AliasAnalysis.h"
21 #include "llvm/Analysis/BranchProbabilityInfo.h"
22 #include "llvm/Analysis/ConstantFolding.h"
23 #include "llvm/Analysis/TargetLibraryInfo.h"
24 #include "llvm/Analysis/ValueTracking.h"
25 #include "llvm/CodeGen/FastISel.h"
26 #include "llvm/CodeGen/FunctionLoweringInfo.h"
27 #include "llvm/CodeGen/GCMetadata.h"
28 #include "llvm/CodeGen/GCStrategy.h"
29 #include "llvm/CodeGen/MachineFrameInfo.h"
30 #include "llvm/CodeGen/MachineFunction.h"
31 #include "llvm/CodeGen/MachineInstrBuilder.h"
32 #include "llvm/CodeGen/MachineJumpTableInfo.h"
33 #include "llvm/CodeGen/MachineModuleInfo.h"
34 #include "llvm/CodeGen/MachineRegisterInfo.h"
35 #include "llvm/CodeGen/SelectionDAG.h"
36 #include "llvm/CodeGen/StackMaps.h"
37 #include "llvm/CodeGen/WinEHFuncInfo.h"
38 #include "llvm/IR/CallingConv.h"
39 #include "llvm/IR/Constants.h"
40 #include "llvm/IR/DataLayout.h"
41 #include "llvm/IR/DebugInfo.h"
42 #include "llvm/IR/DerivedTypes.h"
43 #include "llvm/IR/Function.h"
44 #include "llvm/IR/GlobalVariable.h"
45 #include "llvm/IR/InlineAsm.h"
46 #include "llvm/IR/Instructions.h"
47 #include "llvm/IR/IntrinsicInst.h"
48 #include "llvm/IR/Intrinsics.h"
49 #include "llvm/IR/LLVMContext.h"
50 #include "llvm/IR/Module.h"
51 #include "llvm/IR/Statepoint.h"
52 #include "llvm/MC/MCSymbol.h"
53 #include "llvm/Support/CommandLine.h"
54 #include "llvm/Support/Debug.h"
55 #include "llvm/Support/ErrorHandling.h"
56 #include "llvm/Support/MathExtras.h"
57 #include "llvm/Support/raw_ostream.h"
58 #include "llvm/Target/TargetFrameLowering.h"
59 #include "llvm/Target/TargetInstrInfo.h"
60 #include "llvm/Target/TargetIntrinsicInfo.h"
61 #include "llvm/Target/TargetLowering.h"
62 #include "llvm/Target/TargetOptions.h"
63 #include "llvm/Target/TargetSelectionDAGInfo.h"
64 #include "llvm/Target/TargetSubtargetInfo.h"
65 #include <algorithm>
66 using namespace llvm;
67
68 #define DEBUG_TYPE "isel"
69
70 /// LimitFloatPrecision - Generate low-precision inline sequences for
71 /// some float libcalls (6, 8 or 12 bits).
72 static unsigned LimitFloatPrecision;
73
74 static cl::opt<unsigned, true>
75 LimitFPPrecision("limit-float-precision",
76                  cl::desc("Generate low-precision inline sequences "
77                           "for some float libcalls"),
78                  cl::location(LimitFloatPrecision),
79                  cl::init(0));
80
81 // Limit the width of DAG chains. This is important in general to prevent
82 // prevent DAG-based analysis from blowing up. For example, alias analysis and
83 // load clustering may not complete in reasonable time. It is difficult to
84 // recognize and avoid this situation within each individual analysis, and
85 // future analyses are likely to have the same behavior. Limiting DAG width is
86 // the safe approach, and will be especially important with global DAGs.
87 //
88 // MaxParallelChains default is arbitrarily high to avoid affecting
89 // optimization, but could be lowered to improve compile time. Any ld-ld-st-st
90 // sequence over this should have been converted to llvm.memcpy by the
91 // frontend. It easy to induce this behavior with .ll code such as:
92 // %buffer = alloca [4096 x i8]
93 // %data = load [4096 x i8]* %argPtr
94 // store [4096 x i8] %data, [4096 x i8]* %buffer
95 static const unsigned MaxParallelChains = 64;
96
97 static SDValue getCopyFromPartsVector(SelectionDAG &DAG, SDLoc DL,
98                                       const SDValue *Parts, unsigned NumParts,
99                                       MVT PartVT, EVT ValueVT, const Value *V);
100
101 /// getCopyFromParts - Create a value that contains the specified legal parts
102 /// combined into the value they represent.  If the parts combine to a type
103 /// larger then ValueVT then AssertOp can be used to specify whether the extra
104 /// bits are known to be zero (ISD::AssertZext) or sign extended from ValueVT
105 /// (ISD::AssertSext).
106 static SDValue getCopyFromParts(SelectionDAG &DAG, SDLoc DL,
107                                 const SDValue *Parts,
108                                 unsigned NumParts, MVT PartVT, EVT ValueVT,
109                                 const Value *V,
110                                 ISD::NodeType AssertOp = ISD::DELETED_NODE) {
111   if (ValueVT.isVector())
112     return getCopyFromPartsVector(DAG, DL, Parts, NumParts,
113                                   PartVT, ValueVT, V);
114
115   assert(NumParts > 0 && "No parts to assemble!");
116   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
117   SDValue Val = Parts[0];
118
119   if (NumParts > 1) {
120     // Assemble the value from multiple parts.
121     if (ValueVT.isInteger()) {
122       unsigned PartBits = PartVT.getSizeInBits();
123       unsigned ValueBits = ValueVT.getSizeInBits();
124
125       // Assemble the power of 2 part.
126       unsigned RoundParts = NumParts & (NumParts - 1) ?
127         1 << Log2_32(NumParts) : NumParts;
128       unsigned RoundBits = PartBits * RoundParts;
129       EVT RoundVT = RoundBits == ValueBits ?
130         ValueVT : EVT::getIntegerVT(*DAG.getContext(), RoundBits);
131       SDValue Lo, Hi;
132
133       EVT HalfVT = EVT::getIntegerVT(*DAG.getContext(), RoundBits/2);
134
135       if (RoundParts > 2) {
136         Lo = getCopyFromParts(DAG, DL, Parts, RoundParts / 2,
137                               PartVT, HalfVT, V);
138         Hi = getCopyFromParts(DAG, DL, Parts + RoundParts / 2,
139                               RoundParts / 2, PartVT, HalfVT, V);
140       } else {
141         Lo = DAG.getNode(ISD::BITCAST, DL, HalfVT, Parts[0]);
142         Hi = DAG.getNode(ISD::BITCAST, DL, HalfVT, Parts[1]);
143       }
144
145       if (TLI.isBigEndian())
146         std::swap(Lo, Hi);
147
148       Val = DAG.getNode(ISD::BUILD_PAIR, DL, RoundVT, Lo, Hi);
149
150       if (RoundParts < NumParts) {
151         // Assemble the trailing non-power-of-2 part.
152         unsigned OddParts = NumParts - RoundParts;
153         EVT OddVT = EVT::getIntegerVT(*DAG.getContext(), OddParts * PartBits);
154         Hi = getCopyFromParts(DAG, DL,
155                               Parts + RoundParts, OddParts, PartVT, OddVT, V);
156
157         // Combine the round and odd parts.
158         Lo = Val;
159         if (TLI.isBigEndian())
160           std::swap(Lo, Hi);
161         EVT TotalVT = EVT::getIntegerVT(*DAG.getContext(), NumParts * PartBits);
162         Hi = DAG.getNode(ISD::ANY_EXTEND, DL, TotalVT, Hi);
163         Hi = DAG.getNode(ISD::SHL, DL, TotalVT, Hi,
164                          DAG.getConstant(Lo.getValueType().getSizeInBits(), DL,
165                                          TLI.getPointerTy()));
166         Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, TotalVT, Lo);
167         Val = DAG.getNode(ISD::OR, DL, TotalVT, Lo, Hi);
168       }
169     } else if (PartVT.isFloatingPoint()) {
170       // FP split into multiple FP parts (for ppcf128)
171       assert(ValueVT == EVT(MVT::ppcf128) && PartVT == MVT::f64 &&
172              "Unexpected split");
173       SDValue Lo, Hi;
174       Lo = DAG.getNode(ISD::BITCAST, DL, EVT(MVT::f64), Parts[0]);
175       Hi = DAG.getNode(ISD::BITCAST, DL, EVT(MVT::f64), Parts[1]);
176       if (TLI.hasBigEndianPartOrdering(ValueVT))
177         std::swap(Lo, Hi);
178       Val = DAG.getNode(ISD::BUILD_PAIR, DL, ValueVT, Lo, Hi);
179     } else {
180       // FP split into integer parts (soft fp)
181       assert(ValueVT.isFloatingPoint() && PartVT.isInteger() &&
182              !PartVT.isVector() && "Unexpected split");
183       EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), ValueVT.getSizeInBits());
184       Val = getCopyFromParts(DAG, DL, Parts, NumParts, PartVT, IntVT, V);
185     }
186   }
187
188   // There is now one part, held in Val.  Correct it to match ValueVT.
189   EVT PartEVT = Val.getValueType();
190
191   if (PartEVT == ValueVT)
192     return Val;
193
194   if (PartEVT.isInteger() && ValueVT.isInteger()) {
195     if (ValueVT.bitsLT(PartEVT)) {
196       // For a truncate, see if we have any information to
197       // indicate whether the truncated bits will always be
198       // zero or sign-extension.
199       if (AssertOp != ISD::DELETED_NODE)
200         Val = DAG.getNode(AssertOp, DL, PartEVT, Val,
201                           DAG.getValueType(ValueVT));
202       return DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
203     }
204     return DAG.getNode(ISD::ANY_EXTEND, DL, ValueVT, Val);
205   }
206
207   if (PartEVT.isFloatingPoint() && ValueVT.isFloatingPoint()) {
208     // FP_ROUND's are always exact here.
209     if (ValueVT.bitsLT(Val.getValueType()))
210       return DAG.getNode(ISD::FP_ROUND, DL, ValueVT, Val,
211                          DAG.getTargetConstant(1, DL, TLI.getPointerTy()));
212
213     return DAG.getNode(ISD::FP_EXTEND, DL, ValueVT, Val);
214   }
215
216   if (PartEVT.getSizeInBits() == ValueVT.getSizeInBits())
217     return DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
218
219   llvm_unreachable("Unknown mismatch!");
220 }
221
222 static void diagnosePossiblyInvalidConstraint(LLVMContext &Ctx, const Value *V,
223                                               const Twine &ErrMsg) {
224   const Instruction *I = dyn_cast_or_null<Instruction>(V);
225   if (!V)
226     return Ctx.emitError(ErrMsg);
227
228   const char *AsmError = ", possible invalid constraint for vector type";
229   if (const CallInst *CI = dyn_cast<CallInst>(I))
230     if (isa<InlineAsm>(CI->getCalledValue()))
231       return Ctx.emitError(I, ErrMsg + AsmError);
232
233   return Ctx.emitError(I, ErrMsg);
234 }
235
236 /// getCopyFromPartsVector - Create a value that contains the specified legal
237 /// parts combined into the value they represent.  If the parts combine to a
238 /// type larger then ValueVT then AssertOp can be used to specify whether the
239 /// extra bits are known to be zero (ISD::AssertZext) or sign extended from
240 /// ValueVT (ISD::AssertSext).
241 static SDValue getCopyFromPartsVector(SelectionDAG &DAG, SDLoc DL,
242                                       const SDValue *Parts, unsigned NumParts,
243                                       MVT PartVT, EVT ValueVT, const Value *V) {
244   assert(ValueVT.isVector() && "Not a vector value");
245   assert(NumParts > 0 && "No parts to assemble!");
246   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
247   SDValue Val = Parts[0];
248
249   // Handle a multi-element vector.
250   if (NumParts > 1) {
251     EVT IntermediateVT;
252     MVT RegisterVT;
253     unsigned NumIntermediates;
254     unsigned NumRegs =
255     TLI.getVectorTypeBreakdown(*DAG.getContext(), ValueVT, IntermediateVT,
256                                NumIntermediates, RegisterVT);
257     assert(NumRegs == NumParts && "Part count doesn't match vector breakdown!");
258     NumParts = NumRegs; // Silence a compiler warning.
259     assert(RegisterVT == PartVT && "Part type doesn't match vector breakdown!");
260     assert(RegisterVT == Parts[0].getSimpleValueType() &&
261            "Part type doesn't match part!");
262
263     // Assemble the parts into intermediate operands.
264     SmallVector<SDValue, 8> Ops(NumIntermediates);
265     if (NumIntermediates == NumParts) {
266       // If the register was not expanded, truncate or copy the value,
267       // as appropriate.
268       for (unsigned i = 0; i != NumParts; ++i)
269         Ops[i] = getCopyFromParts(DAG, DL, &Parts[i], 1,
270                                   PartVT, IntermediateVT, V);
271     } else if (NumParts > 0) {
272       // If the intermediate type was expanded, build the intermediate
273       // operands from the parts.
274       assert(NumParts % NumIntermediates == 0 &&
275              "Must expand into a divisible number of parts!");
276       unsigned Factor = NumParts / NumIntermediates;
277       for (unsigned i = 0; i != NumIntermediates; ++i)
278         Ops[i] = getCopyFromParts(DAG, DL, &Parts[i * Factor], Factor,
279                                   PartVT, IntermediateVT, V);
280     }
281
282     // Build a vector with BUILD_VECTOR or CONCAT_VECTORS from the
283     // intermediate operands.
284     Val = DAG.getNode(IntermediateVT.isVector() ? ISD::CONCAT_VECTORS
285                                                 : ISD::BUILD_VECTOR,
286                       DL, ValueVT, Ops);
287   }
288
289   // There is now one part, held in Val.  Correct it to match ValueVT.
290   EVT PartEVT = Val.getValueType();
291
292   if (PartEVT == ValueVT)
293     return Val;
294
295   if (PartEVT.isVector()) {
296     // If the element type of the source/dest vectors are the same, but the
297     // parts vector has more elements than the value vector, then we have a
298     // vector widening case (e.g. <2 x float> -> <4 x float>).  Extract the
299     // elements we want.
300     if (PartEVT.getVectorElementType() == ValueVT.getVectorElementType()) {
301       assert(PartEVT.getVectorNumElements() > ValueVT.getVectorNumElements() &&
302              "Cannot narrow, it would be a lossy transformation");
303       return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, ValueVT, Val,
304                          DAG.getConstant(0, DL, TLI.getVectorIdxTy()));
305     }
306
307     // Vector/Vector bitcast.
308     if (ValueVT.getSizeInBits() == PartEVT.getSizeInBits())
309       return DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
310
311     assert(PartEVT.getVectorNumElements() == ValueVT.getVectorNumElements() &&
312       "Cannot handle this kind of promotion");
313     // Promoted vector extract
314     bool Smaller = ValueVT.bitsLE(PartEVT);
315     return DAG.getNode((Smaller ? ISD::TRUNCATE : ISD::ANY_EXTEND),
316                        DL, ValueVT, Val);
317
318   }
319
320   // Trivial bitcast if the types are the same size and the destination
321   // vector type is legal.
322   if (PartEVT.getSizeInBits() == ValueVT.getSizeInBits() &&
323       TLI.isTypeLegal(ValueVT))
324     return DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
325
326   // Handle cases such as i8 -> <1 x i1>
327   if (ValueVT.getVectorNumElements() != 1) {
328     diagnosePossiblyInvalidConstraint(*DAG.getContext(), V,
329                                       "non-trivial scalar-to-vector conversion");
330     return DAG.getUNDEF(ValueVT);
331   }
332
333   if (ValueVT.getVectorNumElements() == 1 &&
334       ValueVT.getVectorElementType() != PartEVT) {
335     bool Smaller = ValueVT.bitsLE(PartEVT);
336     Val = DAG.getNode((Smaller ? ISD::TRUNCATE : ISD::ANY_EXTEND),
337                        DL, ValueVT.getScalarType(), Val);
338   }
339
340   return DAG.getNode(ISD::BUILD_VECTOR, DL, ValueVT, Val);
341 }
342
343 static void getCopyToPartsVector(SelectionDAG &DAG, SDLoc dl,
344                                  SDValue Val, SDValue *Parts, unsigned NumParts,
345                                  MVT PartVT, const Value *V);
346
347 /// getCopyToParts - Create a series of nodes that contain the specified value
348 /// split into legal parts.  If the parts contain more bits than Val, then, for
349 /// integers, ExtendKind can be used to specify how to generate the extra bits.
350 static void getCopyToParts(SelectionDAG &DAG, SDLoc DL,
351                            SDValue Val, SDValue *Parts, unsigned NumParts,
352                            MVT PartVT, const Value *V,
353                            ISD::NodeType ExtendKind = ISD::ANY_EXTEND) {
354   EVT ValueVT = Val.getValueType();
355
356   // Handle the vector case separately.
357   if (ValueVT.isVector())
358     return getCopyToPartsVector(DAG, DL, Val, Parts, NumParts, PartVT, V);
359
360   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
361   unsigned PartBits = PartVT.getSizeInBits();
362   unsigned OrigNumParts = NumParts;
363   assert(TLI.isTypeLegal(PartVT) && "Copying to an illegal type!");
364
365   if (NumParts == 0)
366     return;
367
368   assert(!ValueVT.isVector() && "Vector case handled elsewhere");
369   EVT PartEVT = PartVT;
370   if (PartEVT == ValueVT) {
371     assert(NumParts == 1 && "No-op copy with multiple parts!");
372     Parts[0] = Val;
373     return;
374   }
375
376   if (NumParts * PartBits > ValueVT.getSizeInBits()) {
377     // If the parts cover more bits than the value has, promote the value.
378     if (PartVT.isFloatingPoint() && ValueVT.isFloatingPoint()) {
379       assert(NumParts == 1 && "Do not know what to promote to!");
380       Val = DAG.getNode(ISD::FP_EXTEND, DL, PartVT, Val);
381     } else {
382       assert((PartVT.isInteger() || PartVT == MVT::x86mmx) &&
383              ValueVT.isInteger() &&
384              "Unknown mismatch!");
385       ValueVT = EVT::getIntegerVT(*DAG.getContext(), NumParts * PartBits);
386       Val = DAG.getNode(ExtendKind, DL, ValueVT, Val);
387       if (PartVT == MVT::x86mmx)
388         Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
389     }
390   } else if (PartBits == ValueVT.getSizeInBits()) {
391     // Different types of the same size.
392     assert(NumParts == 1 && PartEVT != ValueVT);
393     Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
394   } else if (NumParts * PartBits < ValueVT.getSizeInBits()) {
395     // If the parts cover less bits than value has, truncate the value.
396     assert((PartVT.isInteger() || PartVT == MVT::x86mmx) &&
397            ValueVT.isInteger() &&
398            "Unknown mismatch!");
399     ValueVT = EVT::getIntegerVT(*DAG.getContext(), NumParts * PartBits);
400     Val = DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
401     if (PartVT == MVT::x86mmx)
402       Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
403   }
404
405   // The value may have changed - recompute ValueVT.
406   ValueVT = Val.getValueType();
407   assert(NumParts * PartBits == ValueVT.getSizeInBits() &&
408          "Failed to tile the value with PartVT!");
409
410   if (NumParts == 1) {
411     if (PartEVT != ValueVT)
412       diagnosePossiblyInvalidConstraint(*DAG.getContext(), V,
413                                         "scalar-to-vector conversion failed");
414
415     Parts[0] = Val;
416     return;
417   }
418
419   // Expand the value into multiple parts.
420   if (NumParts & (NumParts - 1)) {
421     // The number of parts is not a power of 2.  Split off and copy the tail.
422     assert(PartVT.isInteger() && ValueVT.isInteger() &&
423            "Do not know what to expand to!");
424     unsigned RoundParts = 1 << Log2_32(NumParts);
425     unsigned RoundBits = RoundParts * PartBits;
426     unsigned OddParts = NumParts - RoundParts;
427     SDValue OddVal = DAG.getNode(ISD::SRL, DL, ValueVT, Val,
428                                  DAG.getIntPtrConstant(RoundBits, DL));
429     getCopyToParts(DAG, DL, OddVal, Parts + RoundParts, OddParts, PartVT, V);
430
431     if (TLI.isBigEndian())
432       // The odd parts were reversed by getCopyToParts - unreverse them.
433       std::reverse(Parts + RoundParts, Parts + NumParts);
434
435     NumParts = RoundParts;
436     ValueVT = EVT::getIntegerVT(*DAG.getContext(), NumParts * PartBits);
437     Val = DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
438   }
439
440   // The number of parts is a power of 2.  Repeatedly bisect the value using
441   // EXTRACT_ELEMENT.
442   Parts[0] = DAG.getNode(ISD::BITCAST, DL,
443                          EVT::getIntegerVT(*DAG.getContext(),
444                                            ValueVT.getSizeInBits()),
445                          Val);
446
447   for (unsigned StepSize = NumParts; StepSize > 1; StepSize /= 2) {
448     for (unsigned i = 0; i < NumParts; i += StepSize) {
449       unsigned ThisBits = StepSize * PartBits / 2;
450       EVT ThisVT = EVT::getIntegerVT(*DAG.getContext(), ThisBits);
451       SDValue &Part0 = Parts[i];
452       SDValue &Part1 = Parts[i+StepSize/2];
453
454       Part1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL,
455                           ThisVT, Part0, DAG.getIntPtrConstant(1, DL));
456       Part0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL,
457                           ThisVT, Part0, DAG.getIntPtrConstant(0, DL));
458
459       if (ThisBits == PartBits && ThisVT != PartVT) {
460         Part0 = DAG.getNode(ISD::BITCAST, DL, PartVT, Part0);
461         Part1 = DAG.getNode(ISD::BITCAST, DL, PartVT, Part1);
462       }
463     }
464   }
465
466   if (TLI.isBigEndian())
467     std::reverse(Parts, Parts + OrigNumParts);
468 }
469
470
471 /// getCopyToPartsVector - Create a series of nodes that contain the specified
472 /// value split into legal parts.
473 static void getCopyToPartsVector(SelectionDAG &DAG, SDLoc DL,
474                                  SDValue Val, SDValue *Parts, unsigned NumParts,
475                                  MVT PartVT, const Value *V) {
476   EVT ValueVT = Val.getValueType();
477   assert(ValueVT.isVector() && "Not a vector");
478   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
479
480   if (NumParts == 1) {
481     EVT PartEVT = PartVT;
482     if (PartEVT == ValueVT) {
483       // Nothing to do.
484     } else if (PartVT.getSizeInBits() == ValueVT.getSizeInBits()) {
485       // Bitconvert vector->vector case.
486       Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
487     } else if (PartVT.isVector() &&
488                PartEVT.getVectorElementType() == ValueVT.getVectorElementType() &&
489                PartEVT.getVectorNumElements() > ValueVT.getVectorNumElements()) {
490       EVT ElementVT = PartVT.getVectorElementType();
491       // Vector widening case, e.g. <2 x float> -> <4 x float>.  Shuffle in
492       // undef elements.
493       SmallVector<SDValue, 16> Ops;
494       for (unsigned i = 0, e = ValueVT.getVectorNumElements(); i != e; ++i)
495         Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL,
496                                   ElementVT, Val, DAG.getConstant(i, DL,
497                                                   TLI.getVectorIdxTy())));
498
499       for (unsigned i = ValueVT.getVectorNumElements(),
500            e = PartVT.getVectorNumElements(); i != e; ++i)
501         Ops.push_back(DAG.getUNDEF(ElementVT));
502
503       Val = DAG.getNode(ISD::BUILD_VECTOR, DL, PartVT, Ops);
504
505       // FIXME: Use CONCAT for 2x -> 4x.
506
507       //SDValue UndefElts = DAG.getUNDEF(VectorTy);
508       //Val = DAG.getNode(ISD::CONCAT_VECTORS, DL, PartVT, Val, UndefElts);
509     } else if (PartVT.isVector() &&
510                PartEVT.getVectorElementType().bitsGE(
511                  ValueVT.getVectorElementType()) &&
512                PartEVT.getVectorNumElements() == ValueVT.getVectorNumElements()) {
513
514       // Promoted vector extract
515       bool Smaller = PartEVT.bitsLE(ValueVT);
516       Val = DAG.getNode((Smaller ? ISD::TRUNCATE : ISD::ANY_EXTEND),
517                         DL, PartVT, Val);
518     } else{
519       // Vector -> scalar conversion.
520       assert(ValueVT.getVectorNumElements() == 1 &&
521              "Only trivial vector-to-scalar conversions should get here!");
522       Val = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL,
523                         PartVT, Val,
524                         DAG.getConstant(0, DL, TLI.getVectorIdxTy()));
525
526       bool Smaller = ValueVT.bitsLE(PartVT);
527       Val = DAG.getNode((Smaller ? ISD::TRUNCATE : ISD::ANY_EXTEND),
528                          DL, PartVT, Val);
529     }
530
531     Parts[0] = Val;
532     return;
533   }
534
535   // Handle a multi-element vector.
536   EVT IntermediateVT;
537   MVT RegisterVT;
538   unsigned NumIntermediates;
539   unsigned NumRegs = TLI.getVectorTypeBreakdown(*DAG.getContext(), ValueVT,
540                                                 IntermediateVT,
541                                                 NumIntermediates, RegisterVT);
542   unsigned NumElements = ValueVT.getVectorNumElements();
543
544   assert(NumRegs == NumParts && "Part count doesn't match vector breakdown!");
545   NumParts = NumRegs; // Silence a compiler warning.
546   assert(RegisterVT == PartVT && "Part type doesn't match vector breakdown!");
547
548   // Split the vector into intermediate operands.
549   SmallVector<SDValue, 8> Ops(NumIntermediates);
550   for (unsigned i = 0; i != NumIntermediates; ++i) {
551     if (IntermediateVT.isVector())
552       Ops[i] = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL,
553                            IntermediateVT, Val,
554                    DAG.getConstant(i * (NumElements / NumIntermediates), DL,
555                                    TLI.getVectorIdxTy()));
556     else
557       Ops[i] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL,
558                            IntermediateVT, Val,
559                            DAG.getConstant(i, DL, TLI.getVectorIdxTy()));
560   }
561
562   // Split the intermediate operands into legal parts.
563   if (NumParts == NumIntermediates) {
564     // If the register was not expanded, promote or copy the value,
565     // as appropriate.
566     for (unsigned i = 0; i != NumParts; ++i)
567       getCopyToParts(DAG, DL, Ops[i], &Parts[i], 1, PartVT, V);
568   } else if (NumParts > 0) {
569     // If the intermediate type was expanded, split each the value into
570     // legal parts.
571     assert(NumIntermediates != 0 && "division by zero");
572     assert(NumParts % NumIntermediates == 0 &&
573            "Must expand into a divisible number of parts!");
574     unsigned Factor = NumParts / NumIntermediates;
575     for (unsigned i = 0; i != NumIntermediates; ++i)
576       getCopyToParts(DAG, DL, Ops[i], &Parts[i*Factor], Factor, PartVT, V);
577   }
578 }
579
580 RegsForValue::RegsForValue() {}
581
582 RegsForValue::RegsForValue(const SmallVector<unsigned, 4> &regs, MVT regvt,
583                            EVT valuevt)
584     : ValueVTs(1, valuevt), RegVTs(1, regvt), Regs(regs) {}
585
586 RegsForValue::RegsForValue(LLVMContext &Context, const TargetLowering &tli,
587                            unsigned Reg, Type *Ty) {
588   ComputeValueVTs(tli, Ty, ValueVTs);
589
590   for (unsigned Value = 0, e = ValueVTs.size(); Value != e; ++Value) {
591     EVT ValueVT = ValueVTs[Value];
592     unsigned NumRegs = tli.getNumRegisters(Context, ValueVT);
593     MVT RegisterVT = tli.getRegisterType(Context, ValueVT);
594     for (unsigned i = 0; i != NumRegs; ++i)
595       Regs.push_back(Reg + i);
596     RegVTs.push_back(RegisterVT);
597     Reg += NumRegs;
598   }
599 }
600
601 /// getCopyFromRegs - Emit a series of CopyFromReg nodes that copies from
602 /// this value and returns the result as a ValueVT value.  This uses
603 /// Chain/Flag as the input and updates them for the output Chain/Flag.
604 /// If the Flag pointer is NULL, no flag is used.
605 SDValue RegsForValue::getCopyFromRegs(SelectionDAG &DAG,
606                                       FunctionLoweringInfo &FuncInfo,
607                                       SDLoc dl,
608                                       SDValue &Chain, SDValue *Flag,
609                                       const Value *V) const {
610   // A Value with type {} or [0 x %t] needs no registers.
611   if (ValueVTs.empty())
612     return SDValue();
613
614   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
615
616   // Assemble the legal parts into the final values.
617   SmallVector<SDValue, 4> Values(ValueVTs.size());
618   SmallVector<SDValue, 8> Parts;
619   for (unsigned Value = 0, Part = 0, e = ValueVTs.size(); Value != e; ++Value) {
620     // Copy the legal parts from the registers.
621     EVT ValueVT = ValueVTs[Value];
622     unsigned NumRegs = TLI.getNumRegisters(*DAG.getContext(), ValueVT);
623     MVT RegisterVT = RegVTs[Value];
624
625     Parts.resize(NumRegs);
626     for (unsigned i = 0; i != NumRegs; ++i) {
627       SDValue P;
628       if (!Flag) {
629         P = DAG.getCopyFromReg(Chain, dl, Regs[Part+i], RegisterVT);
630       } else {
631         P = DAG.getCopyFromReg(Chain, dl, Regs[Part+i], RegisterVT, *Flag);
632         *Flag = P.getValue(2);
633       }
634
635       Chain = P.getValue(1);
636       Parts[i] = P;
637
638       // If the source register was virtual and if we know something about it,
639       // add an assert node.
640       if (!TargetRegisterInfo::isVirtualRegister(Regs[Part+i]) ||
641           !RegisterVT.isInteger() || RegisterVT.isVector())
642         continue;
643
644       const FunctionLoweringInfo::LiveOutInfo *LOI =
645         FuncInfo.GetLiveOutRegInfo(Regs[Part+i]);
646       if (!LOI)
647         continue;
648
649       unsigned RegSize = RegisterVT.getSizeInBits();
650       unsigned NumSignBits = LOI->NumSignBits;
651       unsigned NumZeroBits = LOI->KnownZero.countLeadingOnes();
652
653       if (NumZeroBits == RegSize) {
654         // The current value is a zero.
655         // Explicitly express that as it would be easier for
656         // optimizations to kick in.
657         Parts[i] = DAG.getConstant(0, dl, RegisterVT);
658         continue;
659       }
660
661       // FIXME: We capture more information than the dag can represent.  For
662       // now, just use the tightest assertzext/assertsext possible.
663       bool isSExt = true;
664       EVT FromVT(MVT::Other);
665       if (NumSignBits == RegSize)
666         isSExt = true, FromVT = MVT::i1;   // ASSERT SEXT 1
667       else if (NumZeroBits >= RegSize-1)
668         isSExt = false, FromVT = MVT::i1;  // ASSERT ZEXT 1
669       else if (NumSignBits > RegSize-8)
670         isSExt = true, FromVT = MVT::i8;   // ASSERT SEXT 8
671       else if (NumZeroBits >= RegSize-8)
672         isSExt = false, FromVT = MVT::i8;  // ASSERT ZEXT 8
673       else if (NumSignBits > RegSize-16)
674         isSExt = true, FromVT = MVT::i16;  // ASSERT SEXT 16
675       else if (NumZeroBits >= RegSize-16)
676         isSExt = false, FromVT = MVT::i16; // ASSERT ZEXT 16
677       else if (NumSignBits > RegSize-32)
678         isSExt = true, FromVT = MVT::i32;  // ASSERT SEXT 32
679       else if (NumZeroBits >= RegSize-32)
680         isSExt = false, FromVT = MVT::i32; // ASSERT ZEXT 32
681       else
682         continue;
683
684       // Add an assertion node.
685       assert(FromVT != MVT::Other);
686       Parts[i] = DAG.getNode(isSExt ? ISD::AssertSext : ISD::AssertZext, dl,
687                              RegisterVT, P, DAG.getValueType(FromVT));
688     }
689
690     Values[Value] = getCopyFromParts(DAG, dl, Parts.begin(),
691                                      NumRegs, RegisterVT, ValueVT, V);
692     Part += NumRegs;
693     Parts.clear();
694   }
695
696   return DAG.getNode(ISD::MERGE_VALUES, dl, DAG.getVTList(ValueVTs), Values);
697 }
698
699 /// getCopyToRegs - Emit a series of CopyToReg nodes that copies the
700 /// specified value into the registers specified by this object.  This uses
701 /// Chain/Flag as the input and updates them for the output Chain/Flag.
702 /// If the Flag pointer is NULL, no flag is used.
703 void RegsForValue::getCopyToRegs(SDValue Val, SelectionDAG &DAG, SDLoc dl,
704                                  SDValue &Chain, SDValue *Flag, const Value *V,
705                                  ISD::NodeType PreferredExtendType) const {
706   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
707   ISD::NodeType ExtendKind = PreferredExtendType;
708
709   // Get the list of the values's legal parts.
710   unsigned NumRegs = Regs.size();
711   SmallVector<SDValue, 8> Parts(NumRegs);
712   for (unsigned Value = 0, Part = 0, e = ValueVTs.size(); Value != e; ++Value) {
713     EVT ValueVT = ValueVTs[Value];
714     unsigned NumParts = TLI.getNumRegisters(*DAG.getContext(), ValueVT);
715     MVT RegisterVT = RegVTs[Value];
716
717     if (ExtendKind == ISD::ANY_EXTEND && TLI.isZExtFree(Val, RegisterVT))
718       ExtendKind = ISD::ZERO_EXTEND;
719
720     getCopyToParts(DAG, dl, Val.getValue(Val.getResNo() + Value),
721                    &Parts[Part], NumParts, RegisterVT, V, ExtendKind);
722     Part += NumParts;
723   }
724
725   // Copy the parts into the registers.
726   SmallVector<SDValue, 8> Chains(NumRegs);
727   for (unsigned i = 0; i != NumRegs; ++i) {
728     SDValue Part;
729     if (!Flag) {
730       Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i]);
731     } else {
732       Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i], *Flag);
733       *Flag = Part.getValue(1);
734     }
735
736     Chains[i] = Part.getValue(0);
737   }
738
739   if (NumRegs == 1 || Flag)
740     // If NumRegs > 1 && Flag is used then the use of the last CopyToReg is
741     // flagged to it. That is the CopyToReg nodes and the user are considered
742     // a single scheduling unit. If we create a TokenFactor and return it as
743     // chain, then the TokenFactor is both a predecessor (operand) of the
744     // user as well as a successor (the TF operands are flagged to the user).
745     // c1, f1 = CopyToReg
746     // c2, f2 = CopyToReg
747     // c3     = TokenFactor c1, c2
748     // ...
749     //        = op c3, ..., f2
750     Chain = Chains[NumRegs-1];
751   else
752     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
753 }
754
755 /// AddInlineAsmOperands - Add this value to the specified inlineasm node
756 /// operand list.  This adds the code marker and includes the number of
757 /// values added into it.
758 void RegsForValue::AddInlineAsmOperands(unsigned Code, bool HasMatching,
759                                         unsigned MatchingIdx, SDLoc dl,
760                                         SelectionDAG &DAG,
761                                         std::vector<SDValue> &Ops) const {
762   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
763
764   unsigned Flag = InlineAsm::getFlagWord(Code, Regs.size());
765   if (HasMatching)
766     Flag = InlineAsm::getFlagWordForMatchingOp(Flag, MatchingIdx);
767   else if (!Regs.empty() &&
768            TargetRegisterInfo::isVirtualRegister(Regs.front())) {
769     // Put the register class of the virtual registers in the flag word.  That
770     // way, later passes can recompute register class constraints for inline
771     // assembly as well as normal instructions.
772     // Don't do this for tied operands that can use the regclass information
773     // from the def.
774     const MachineRegisterInfo &MRI = DAG.getMachineFunction().getRegInfo();
775     const TargetRegisterClass *RC = MRI.getRegClass(Regs.front());
776     Flag = InlineAsm::getFlagWordForRegClass(Flag, RC->getID());
777   }
778
779   SDValue Res = DAG.getTargetConstant(Flag, dl, MVT::i32);
780   Ops.push_back(Res);
781
782   unsigned SP = TLI.getStackPointerRegisterToSaveRestore();
783   for (unsigned Value = 0, Reg = 0, e = ValueVTs.size(); Value != e; ++Value) {
784     unsigned NumRegs = TLI.getNumRegisters(*DAG.getContext(), ValueVTs[Value]);
785     MVT RegisterVT = RegVTs[Value];
786     for (unsigned i = 0; i != NumRegs; ++i) {
787       assert(Reg < Regs.size() && "Mismatch in # registers expected");
788       unsigned TheReg = Regs[Reg++];
789       Ops.push_back(DAG.getRegister(TheReg, RegisterVT));
790
791       if (TheReg == SP && Code == InlineAsm::Kind_Clobber) {
792         // If we clobbered the stack pointer, MFI should know about it.
793         assert(DAG.getMachineFunction().getFrameInfo()->
794             hasInlineAsmWithSPAdjust());
795       }
796     }
797   }
798 }
799
800 void SelectionDAGBuilder::init(GCFunctionInfo *gfi, AliasAnalysis &aa,
801                                const TargetLibraryInfo *li) {
802   AA = &aa;
803   GFI = gfi;
804   LibInfo = li;
805   DL = DAG.getTarget().getDataLayout();
806   Context = DAG.getContext();
807   LPadToCallSiteMap.clear();
808 }
809
810 /// clear - Clear out the current SelectionDAG and the associated
811 /// state and prepare this SelectionDAGBuilder object to be used
812 /// for a new block. This doesn't clear out information about
813 /// additional blocks that are needed to complete switch lowering
814 /// or PHI node updating; that information is cleared out as it is
815 /// consumed.
816 void SelectionDAGBuilder::clear() {
817   NodeMap.clear();
818   UnusedArgNodeMap.clear();
819   PendingLoads.clear();
820   PendingExports.clear();
821   CurInst = nullptr;
822   HasTailCall = false;
823   SDNodeOrder = LowestSDNodeOrder;
824   StatepointLowering.clear();
825 }
826
827 /// clearDanglingDebugInfo - Clear the dangling debug information
828 /// map. This function is separated from the clear so that debug
829 /// information that is dangling in a basic block can be properly
830 /// resolved in a different basic block. This allows the
831 /// SelectionDAG to resolve dangling debug information attached
832 /// to PHI nodes.
833 void SelectionDAGBuilder::clearDanglingDebugInfo() {
834   DanglingDebugInfoMap.clear();
835 }
836
837 /// getRoot - Return the current virtual root of the Selection DAG,
838 /// flushing any PendingLoad items. This must be done before emitting
839 /// a store or any other node that may need to be ordered after any
840 /// prior load instructions.
841 ///
842 SDValue SelectionDAGBuilder::getRoot() {
843   if (PendingLoads.empty())
844     return DAG.getRoot();
845
846   if (PendingLoads.size() == 1) {
847     SDValue Root = PendingLoads[0];
848     DAG.setRoot(Root);
849     PendingLoads.clear();
850     return Root;
851   }
852
853   // Otherwise, we have to make a token factor node.
854   SDValue Root = DAG.getNode(ISD::TokenFactor, getCurSDLoc(), MVT::Other,
855                              PendingLoads);
856   PendingLoads.clear();
857   DAG.setRoot(Root);
858   return Root;
859 }
860
861 /// getControlRoot - Similar to getRoot, but instead of flushing all the
862 /// PendingLoad items, flush all the PendingExports items. It is necessary
863 /// to do this before emitting a terminator instruction.
864 ///
865 SDValue SelectionDAGBuilder::getControlRoot() {
866   SDValue Root = DAG.getRoot();
867
868   if (PendingExports.empty())
869     return Root;
870
871   // Turn all of the CopyToReg chains into one factored node.
872   if (Root.getOpcode() != ISD::EntryToken) {
873     unsigned i = 0, e = PendingExports.size();
874     for (; i != e; ++i) {
875       assert(PendingExports[i].getNode()->getNumOperands() > 1);
876       if (PendingExports[i].getNode()->getOperand(0) == Root)
877         break;  // Don't add the root if we already indirectly depend on it.
878     }
879
880     if (i == e)
881       PendingExports.push_back(Root);
882   }
883
884   Root = DAG.getNode(ISD::TokenFactor, getCurSDLoc(), MVT::Other,
885                      PendingExports);
886   PendingExports.clear();
887   DAG.setRoot(Root);
888   return Root;
889 }
890
891 void SelectionDAGBuilder::visit(const Instruction &I) {
892   // Set up outgoing PHI node register values before emitting the terminator.
893   if (isa<TerminatorInst>(&I))
894     HandlePHINodesInSuccessorBlocks(I.getParent());
895
896   ++SDNodeOrder;
897
898   CurInst = &I;
899
900   visit(I.getOpcode(), I);
901
902   if (!isa<TerminatorInst>(&I) && !HasTailCall)
903     CopyToExportRegsIfNeeded(&I);
904
905   CurInst = nullptr;
906 }
907
908 void SelectionDAGBuilder::visitPHI(const PHINode &) {
909   llvm_unreachable("SelectionDAGBuilder shouldn't visit PHI nodes!");
910 }
911
912 void SelectionDAGBuilder::visit(unsigned Opcode, const User &I) {
913   // Note: this doesn't use InstVisitor, because it has to work with
914   // ConstantExpr's in addition to instructions.
915   switch (Opcode) {
916   default: llvm_unreachable("Unknown instruction type encountered!");
917     // Build the switch statement using the Instruction.def file.
918 #define HANDLE_INST(NUM, OPCODE, CLASS) \
919     case Instruction::OPCODE: visit##OPCODE((const CLASS&)I); break;
920 #include "llvm/IR/Instruction.def"
921   }
922 }
923
924 // resolveDanglingDebugInfo - if we saw an earlier dbg_value referring to V,
925 // generate the debug data structures now that we've seen its definition.
926 void SelectionDAGBuilder::resolveDanglingDebugInfo(const Value *V,
927                                                    SDValue Val) {
928   DanglingDebugInfo &DDI = DanglingDebugInfoMap[V];
929   if (DDI.getDI()) {
930     const DbgValueInst *DI = DDI.getDI();
931     DebugLoc dl = DDI.getdl();
932     unsigned DbgSDNodeOrder = DDI.getSDNodeOrder();
933     DILocalVariable *Variable = DI->getVariable();
934     DIExpression *Expr = DI->getExpression();
935     assert(Variable->isValidLocationForIntrinsic(dl) &&
936            "Expected inlined-at fields to agree");
937     uint64_t Offset = DI->getOffset();
938     // A dbg.value for an alloca is always indirect.
939     bool IsIndirect = isa<AllocaInst>(V) || Offset != 0;
940     SDDbgValue *SDV;
941     if (Val.getNode()) {
942       if (!EmitFuncArgumentDbgValue(V, Variable, Expr, dl, Offset, IsIndirect,
943                                     Val)) {
944         SDV = DAG.getDbgValue(Variable, Expr, Val.getNode(), Val.getResNo(),
945                               IsIndirect, Offset, dl, DbgSDNodeOrder);
946         DAG.AddDbgValue(SDV, Val.getNode(), false);
947       }
948     } else
949       DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n");
950     DanglingDebugInfoMap[V] = DanglingDebugInfo();
951   }
952 }
953
954 /// getCopyFromRegs - If there was virtual register allocated for the value V
955 /// emit CopyFromReg of the specified type Ty. Return empty SDValue() otherwise.
956 SDValue SelectionDAGBuilder::getCopyFromRegs(const Value *V, Type *Ty) {
957   DenseMap<const Value *, unsigned>::iterator It = FuncInfo.ValueMap.find(V);
958   SDValue Result;
959
960   if (It != FuncInfo.ValueMap.end()) {
961     unsigned InReg = It->second;
962     RegsForValue RFV(*DAG.getContext(), DAG.getTargetLoweringInfo(), InReg,
963                      Ty);
964     SDValue Chain = DAG.getEntryNode();
965     Result = RFV.getCopyFromRegs(DAG, FuncInfo, getCurSDLoc(), Chain, nullptr, V);
966     resolveDanglingDebugInfo(V, Result);
967   }
968
969   return Result;
970 }
971
972 /// getValue - Return an SDValue for the given Value.
973 SDValue SelectionDAGBuilder::getValue(const Value *V) {
974   // If we already have an SDValue for this value, use it. It's important
975   // to do this first, so that we don't create a CopyFromReg if we already
976   // have a regular SDValue.
977   SDValue &N = NodeMap[V];
978   if (N.getNode()) return N;
979
980   // If there's a virtual register allocated and initialized for this
981   // value, use it.
982   SDValue copyFromReg = getCopyFromRegs(V, V->getType());
983   if (copyFromReg.getNode()) {
984     return copyFromReg;
985   }
986
987   // Otherwise create a new SDValue and remember it.
988   SDValue Val = getValueImpl(V);
989   NodeMap[V] = Val;
990   resolveDanglingDebugInfo(V, Val);
991   return Val;
992 }
993
994 // Return true if SDValue exists for the given Value
995 bool SelectionDAGBuilder::findValue(const Value *V) const {
996   return (NodeMap.find(V) != NodeMap.end()) ||
997     (FuncInfo.ValueMap.find(V) != FuncInfo.ValueMap.end());
998 }
999
1000 /// getNonRegisterValue - Return an SDValue for the given Value, but
1001 /// don't look in FuncInfo.ValueMap for a virtual register.
1002 SDValue SelectionDAGBuilder::getNonRegisterValue(const Value *V) {
1003   // If we already have an SDValue for this value, use it.
1004   SDValue &N = NodeMap[V];
1005   if (N.getNode()) return N;
1006
1007   // Otherwise create a new SDValue and remember it.
1008   SDValue Val = getValueImpl(V);
1009   NodeMap[V] = Val;
1010   resolveDanglingDebugInfo(V, Val);
1011   return Val;
1012 }
1013
1014 /// getValueImpl - Helper function for getValue and getNonRegisterValue.
1015 /// Create an SDValue for the given value.
1016 SDValue SelectionDAGBuilder::getValueImpl(const Value *V) {
1017   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
1018
1019   if (const Constant *C = dyn_cast<Constant>(V)) {
1020     EVT VT = TLI.getValueType(V->getType(), true);
1021
1022     if (const ConstantInt *CI = dyn_cast<ConstantInt>(C))
1023       return DAG.getConstant(*CI, getCurSDLoc(), VT);
1024
1025     if (const GlobalValue *GV = dyn_cast<GlobalValue>(C))
1026       return DAG.getGlobalAddress(GV, getCurSDLoc(), VT);
1027
1028     if (isa<ConstantPointerNull>(C)) {
1029       unsigned AS = V->getType()->getPointerAddressSpace();
1030       return DAG.getConstant(0, getCurSDLoc(), TLI.getPointerTy(AS));
1031     }
1032
1033     if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C))
1034       return DAG.getConstantFP(*CFP, getCurSDLoc(), VT);
1035
1036     if (isa<UndefValue>(C) && !V->getType()->isAggregateType())
1037       return DAG.getUNDEF(VT);
1038
1039     if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
1040       visit(CE->getOpcode(), *CE);
1041       SDValue N1 = NodeMap[V];
1042       assert(N1.getNode() && "visit didn't populate the NodeMap!");
1043       return N1;
1044     }
1045
1046     if (isa<ConstantStruct>(C) || isa<ConstantArray>(C)) {
1047       SmallVector<SDValue, 4> Constants;
1048       for (User::const_op_iterator OI = C->op_begin(), OE = C->op_end();
1049            OI != OE; ++OI) {
1050         SDNode *Val = getValue(*OI).getNode();
1051         // If the operand is an empty aggregate, there are no values.
1052         if (!Val) continue;
1053         // Add each leaf value from the operand to the Constants list
1054         // to form a flattened list of all the values.
1055         for (unsigned i = 0, e = Val->getNumValues(); i != e; ++i)
1056           Constants.push_back(SDValue(Val, i));
1057       }
1058
1059       return DAG.getMergeValues(Constants, getCurSDLoc());
1060     }
1061
1062     if (const ConstantDataSequential *CDS =
1063           dyn_cast<ConstantDataSequential>(C)) {
1064       SmallVector<SDValue, 4> Ops;
1065       for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
1066         SDNode *Val = getValue(CDS->getElementAsConstant(i)).getNode();
1067         // Add each leaf value from the operand to the Constants list
1068         // to form a flattened list of all the values.
1069         for (unsigned i = 0, e = Val->getNumValues(); i != e; ++i)
1070           Ops.push_back(SDValue(Val, i));
1071       }
1072
1073       if (isa<ArrayType>(CDS->getType()))
1074         return DAG.getMergeValues(Ops, getCurSDLoc());
1075       return NodeMap[V] = DAG.getNode(ISD::BUILD_VECTOR, getCurSDLoc(),
1076                                       VT, Ops);
1077     }
1078
1079     if (C->getType()->isStructTy() || C->getType()->isArrayTy()) {
1080       assert((isa<ConstantAggregateZero>(C) || isa<UndefValue>(C)) &&
1081              "Unknown struct or array constant!");
1082
1083       SmallVector<EVT, 4> ValueVTs;
1084       ComputeValueVTs(TLI, C->getType(), ValueVTs);
1085       unsigned NumElts = ValueVTs.size();
1086       if (NumElts == 0)
1087         return SDValue(); // empty struct
1088       SmallVector<SDValue, 4> Constants(NumElts);
1089       for (unsigned i = 0; i != NumElts; ++i) {
1090         EVT EltVT = ValueVTs[i];
1091         if (isa<UndefValue>(C))
1092           Constants[i] = DAG.getUNDEF(EltVT);
1093         else if (EltVT.isFloatingPoint())
1094           Constants[i] = DAG.getConstantFP(0, getCurSDLoc(), EltVT);
1095         else
1096           Constants[i] = DAG.getConstant(0, getCurSDLoc(), EltVT);
1097       }
1098
1099       return DAG.getMergeValues(Constants, getCurSDLoc());
1100     }
1101
1102     if (const BlockAddress *BA = dyn_cast<BlockAddress>(C))
1103       return DAG.getBlockAddress(BA, VT);
1104
1105     VectorType *VecTy = cast<VectorType>(V->getType());
1106     unsigned NumElements = VecTy->getNumElements();
1107
1108     // Now that we know the number and type of the elements, get that number of
1109     // elements into the Ops array based on what kind of constant it is.
1110     SmallVector<SDValue, 16> Ops;
1111     if (const ConstantVector *CV = dyn_cast<ConstantVector>(C)) {
1112       for (unsigned i = 0; i != NumElements; ++i)
1113         Ops.push_back(getValue(CV->getOperand(i)));
1114     } else {
1115       assert(isa<ConstantAggregateZero>(C) && "Unknown vector constant!");
1116       EVT EltVT = TLI.getValueType(VecTy->getElementType());
1117
1118       SDValue Op;
1119       if (EltVT.isFloatingPoint())
1120         Op = DAG.getConstantFP(0, getCurSDLoc(), EltVT);
1121       else
1122         Op = DAG.getConstant(0, getCurSDLoc(), EltVT);
1123       Ops.assign(NumElements, Op);
1124     }
1125
1126     // Create a BUILD_VECTOR node.
1127     return NodeMap[V] = DAG.getNode(ISD::BUILD_VECTOR, getCurSDLoc(), VT, Ops);
1128   }
1129
1130   // If this is a static alloca, generate it as the frameindex instead of
1131   // computation.
1132   if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
1133     DenseMap<const AllocaInst*, int>::iterator SI =
1134       FuncInfo.StaticAllocaMap.find(AI);
1135     if (SI != FuncInfo.StaticAllocaMap.end())
1136       return DAG.getFrameIndex(SI->second, TLI.getPointerTy());
1137   }
1138
1139   // If this is an instruction which fast-isel has deferred, select it now.
1140   if (const Instruction *Inst = dyn_cast<Instruction>(V)) {
1141     unsigned InReg = FuncInfo.InitializeRegForValue(Inst);
1142     RegsForValue RFV(*DAG.getContext(), TLI, InReg, Inst->getType());
1143     SDValue Chain = DAG.getEntryNode();
1144     return RFV.getCopyFromRegs(DAG, FuncInfo, getCurSDLoc(), Chain, nullptr, V);
1145   }
1146
1147   llvm_unreachable("Can't get register for value!");
1148 }
1149
1150 void SelectionDAGBuilder::visitRet(const ReturnInst &I) {
1151   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
1152   SDValue Chain = getControlRoot();
1153   SmallVector<ISD::OutputArg, 8> Outs;
1154   SmallVector<SDValue, 8> OutVals;
1155
1156   if (!FuncInfo.CanLowerReturn) {
1157     unsigned DemoteReg = FuncInfo.DemoteRegister;
1158     const Function *F = I.getParent()->getParent();
1159
1160     // Emit a store of the return value through the virtual register.
1161     // Leave Outs empty so that LowerReturn won't try to load return
1162     // registers the usual way.
1163     SmallVector<EVT, 1> PtrValueVTs;
1164     ComputeValueVTs(TLI, PointerType::getUnqual(F->getReturnType()),
1165                     PtrValueVTs);
1166
1167     SDValue RetPtr = DAG.getRegister(DemoteReg, PtrValueVTs[0]);
1168     SDValue RetOp = getValue(I.getOperand(0));
1169
1170     SmallVector<EVT, 4> ValueVTs;
1171     SmallVector<uint64_t, 4> Offsets;
1172     ComputeValueVTs(TLI, I.getOperand(0)->getType(), ValueVTs, &Offsets);
1173     unsigned NumValues = ValueVTs.size();
1174
1175     SmallVector<SDValue, 4> Chains(NumValues);
1176     for (unsigned i = 0; i != NumValues; ++i) {
1177       SDValue Add = DAG.getNode(ISD::ADD, getCurSDLoc(),
1178                                 RetPtr.getValueType(), RetPtr,
1179                                 DAG.getIntPtrConstant(Offsets[i],
1180                                                       getCurSDLoc()));
1181       Chains[i] =
1182         DAG.getStore(Chain, getCurSDLoc(),
1183                      SDValue(RetOp.getNode(), RetOp.getResNo() + i),
1184                      // FIXME: better loc info would be nice.
1185                      Add, MachinePointerInfo(), false, false, 0);
1186     }
1187
1188     Chain = DAG.getNode(ISD::TokenFactor, getCurSDLoc(),
1189                         MVT::Other, Chains);
1190   } else if (I.getNumOperands() != 0) {
1191     SmallVector<EVT, 4> ValueVTs;
1192     ComputeValueVTs(TLI, I.getOperand(0)->getType(), ValueVTs);
1193     unsigned NumValues = ValueVTs.size();
1194     if (NumValues) {
1195       SDValue RetOp = getValue(I.getOperand(0));
1196
1197       const Function *F = I.getParent()->getParent();
1198
1199       ISD::NodeType ExtendKind = ISD::ANY_EXTEND;
1200       if (F->getAttributes().hasAttribute(AttributeSet::ReturnIndex,
1201                                           Attribute::SExt))
1202         ExtendKind = ISD::SIGN_EXTEND;
1203       else if (F->getAttributes().hasAttribute(AttributeSet::ReturnIndex,
1204                                                Attribute::ZExt))
1205         ExtendKind = ISD::ZERO_EXTEND;
1206
1207       LLVMContext &Context = F->getContext();
1208       bool RetInReg = F->getAttributes().hasAttribute(AttributeSet::ReturnIndex,
1209                                                       Attribute::InReg);
1210
1211       for (unsigned j = 0; j != NumValues; ++j) {
1212         EVT VT = ValueVTs[j];
1213
1214         if (ExtendKind != ISD::ANY_EXTEND && VT.isInteger())
1215           VT = TLI.getTypeForExtArgOrReturn(Context, VT, ExtendKind);
1216
1217         unsigned NumParts = TLI.getNumRegisters(Context, VT);
1218         MVT PartVT = TLI.getRegisterType(Context, VT);
1219         SmallVector<SDValue, 4> Parts(NumParts);
1220         getCopyToParts(DAG, getCurSDLoc(),
1221                        SDValue(RetOp.getNode(), RetOp.getResNo() + j),
1222                        &Parts[0], NumParts, PartVT, &I, ExtendKind);
1223
1224         // 'inreg' on function refers to return value
1225         ISD::ArgFlagsTy Flags = ISD::ArgFlagsTy();
1226         if (RetInReg)
1227           Flags.setInReg();
1228
1229         // Propagate extension type if any
1230         if (ExtendKind == ISD::SIGN_EXTEND)
1231           Flags.setSExt();
1232         else if (ExtendKind == ISD::ZERO_EXTEND)
1233           Flags.setZExt();
1234
1235         for (unsigned i = 0; i < NumParts; ++i) {
1236           Outs.push_back(ISD::OutputArg(Flags, Parts[i].getValueType(),
1237                                         VT, /*isfixed=*/true, 0, 0));
1238           OutVals.push_back(Parts[i]);
1239         }
1240       }
1241     }
1242   }
1243
1244   bool isVarArg = DAG.getMachineFunction().getFunction()->isVarArg();
1245   CallingConv::ID CallConv =
1246     DAG.getMachineFunction().getFunction()->getCallingConv();
1247   Chain = DAG.getTargetLoweringInfo().LowerReturn(
1248       Chain, CallConv, isVarArg, Outs, OutVals, getCurSDLoc(), DAG);
1249
1250   // Verify that the target's LowerReturn behaved as expected.
1251   assert(Chain.getNode() && Chain.getValueType() == MVT::Other &&
1252          "LowerReturn didn't return a valid chain!");
1253
1254   // Update the DAG with the new chain value resulting from return lowering.
1255   DAG.setRoot(Chain);
1256 }
1257
1258 /// CopyToExportRegsIfNeeded - If the given value has virtual registers
1259 /// created for it, emit nodes to copy the value into the virtual
1260 /// registers.
1261 void SelectionDAGBuilder::CopyToExportRegsIfNeeded(const Value *V) {
1262   // Skip empty types
1263   if (V->getType()->isEmptyTy())
1264     return;
1265
1266   DenseMap<const Value *, unsigned>::iterator VMI = FuncInfo.ValueMap.find(V);
1267   if (VMI != FuncInfo.ValueMap.end()) {
1268     assert(!V->use_empty() && "Unused value assigned virtual registers!");
1269     CopyValueToVirtualRegister(V, VMI->second);
1270   }
1271 }
1272
1273 /// ExportFromCurrentBlock - If this condition isn't known to be exported from
1274 /// the current basic block, add it to ValueMap now so that we'll get a
1275 /// CopyTo/FromReg.
1276 void SelectionDAGBuilder::ExportFromCurrentBlock(const Value *V) {
1277   // No need to export constants.
1278   if (!isa<Instruction>(V) && !isa<Argument>(V)) return;
1279
1280   // Already exported?
1281   if (FuncInfo.isExportedInst(V)) return;
1282
1283   unsigned Reg = FuncInfo.InitializeRegForValue(V);
1284   CopyValueToVirtualRegister(V, Reg);
1285 }
1286
1287 bool SelectionDAGBuilder::isExportableFromCurrentBlock(const Value *V,
1288                                                      const BasicBlock *FromBB) {
1289   // The operands of the setcc have to be in this block.  We don't know
1290   // how to export them from some other block.
1291   if (const Instruction *VI = dyn_cast<Instruction>(V)) {
1292     // Can export from current BB.
1293     if (VI->getParent() == FromBB)
1294       return true;
1295
1296     // Is already exported, noop.
1297     return FuncInfo.isExportedInst(V);
1298   }
1299
1300   // If this is an argument, we can export it if the BB is the entry block or
1301   // if it is already exported.
1302   if (isa<Argument>(V)) {
1303     if (FromBB == &FromBB->getParent()->getEntryBlock())
1304       return true;
1305
1306     // Otherwise, can only export this if it is already exported.
1307     return FuncInfo.isExportedInst(V);
1308   }
1309
1310   // Otherwise, constants can always be exported.
1311   return true;
1312 }
1313
1314 /// Return branch probability calculated by BranchProbabilityInfo for IR blocks.
1315 uint32_t SelectionDAGBuilder::getEdgeWeight(const MachineBasicBlock *Src,
1316                                             const MachineBasicBlock *Dst) const {
1317   BranchProbabilityInfo *BPI = FuncInfo.BPI;
1318   if (!BPI)
1319     return 0;
1320   const BasicBlock *SrcBB = Src->getBasicBlock();
1321   const BasicBlock *DstBB = Dst->getBasicBlock();
1322   return BPI->getEdgeWeight(SrcBB, DstBB);
1323 }
1324
1325 void SelectionDAGBuilder::
1326 addSuccessorWithWeight(MachineBasicBlock *Src, MachineBasicBlock *Dst,
1327                        uint32_t Weight /* = 0 */) {
1328   if (!Weight)
1329     Weight = getEdgeWeight(Src, Dst);
1330   Src->addSuccessor(Dst, Weight);
1331 }
1332
1333
1334 static bool InBlock(const Value *V, const BasicBlock *BB) {
1335   if (const Instruction *I = dyn_cast<Instruction>(V))
1336     return I->getParent() == BB;
1337   return true;
1338 }
1339
1340 /// EmitBranchForMergedCondition - Helper method for FindMergedConditions.
1341 /// This function emits a branch and is used at the leaves of an OR or an
1342 /// AND operator tree.
1343 ///
1344 void
1345 SelectionDAGBuilder::EmitBranchForMergedCondition(const Value *Cond,
1346                                                   MachineBasicBlock *TBB,
1347                                                   MachineBasicBlock *FBB,
1348                                                   MachineBasicBlock *CurBB,
1349                                                   MachineBasicBlock *SwitchBB,
1350                                                   uint32_t TWeight,
1351                                                   uint32_t FWeight) {
1352   const BasicBlock *BB = CurBB->getBasicBlock();
1353
1354   // If the leaf of the tree is a comparison, merge the condition into
1355   // the caseblock.
1356   if (const CmpInst *BOp = dyn_cast<CmpInst>(Cond)) {
1357     // The operands of the cmp have to be in this block.  We don't know
1358     // how to export them from some other block.  If this is the first block
1359     // of the sequence, no exporting is needed.
1360     if (CurBB == SwitchBB ||
1361         (isExportableFromCurrentBlock(BOp->getOperand(0), BB) &&
1362          isExportableFromCurrentBlock(BOp->getOperand(1), BB))) {
1363       ISD::CondCode Condition;
1364       if (const ICmpInst *IC = dyn_cast<ICmpInst>(Cond)) {
1365         Condition = getICmpCondCode(IC->getPredicate());
1366       } else if (const FCmpInst *FC = dyn_cast<FCmpInst>(Cond)) {
1367         Condition = getFCmpCondCode(FC->getPredicate());
1368         if (TM.Options.NoNaNsFPMath)
1369           Condition = getFCmpCodeWithoutNaN(Condition);
1370       } else {
1371         (void)Condition; // silence warning.
1372         llvm_unreachable("Unknown compare instruction");
1373       }
1374
1375       CaseBlock CB(Condition, BOp->getOperand(0), BOp->getOperand(1), nullptr,
1376                    TBB, FBB, CurBB, TWeight, FWeight);
1377       SwitchCases.push_back(CB);
1378       return;
1379     }
1380   }
1381
1382   // Create a CaseBlock record representing this branch.
1383   CaseBlock CB(ISD::SETEQ, Cond, ConstantInt::getTrue(*DAG.getContext()),
1384                nullptr, TBB, FBB, CurBB, TWeight, FWeight);
1385   SwitchCases.push_back(CB);
1386 }
1387
1388 /// Scale down both weights to fit into uint32_t.
1389 static void ScaleWeights(uint64_t &NewTrue, uint64_t &NewFalse) {
1390   uint64_t NewMax = (NewTrue > NewFalse) ? NewTrue : NewFalse;
1391   uint32_t Scale = (NewMax / UINT32_MAX) + 1;
1392   NewTrue = NewTrue / Scale;
1393   NewFalse = NewFalse / Scale;
1394 }
1395
1396 /// FindMergedConditions - If Cond is an expression like
1397 void SelectionDAGBuilder::FindMergedConditions(const Value *Cond,
1398                                                MachineBasicBlock *TBB,
1399                                                MachineBasicBlock *FBB,
1400                                                MachineBasicBlock *CurBB,
1401                                                MachineBasicBlock *SwitchBB,
1402                                                unsigned Opc, uint32_t TWeight,
1403                                                uint32_t FWeight) {
1404   // If this node is not part of the or/and tree, emit it as a branch.
1405   const Instruction *BOp = dyn_cast<Instruction>(Cond);
1406   if (!BOp || !(isa<BinaryOperator>(BOp) || isa<CmpInst>(BOp)) ||
1407       (unsigned)BOp->getOpcode() != Opc || !BOp->hasOneUse() ||
1408       BOp->getParent() != CurBB->getBasicBlock() ||
1409       !InBlock(BOp->getOperand(0), CurBB->getBasicBlock()) ||
1410       !InBlock(BOp->getOperand(1), CurBB->getBasicBlock())) {
1411     EmitBranchForMergedCondition(Cond, TBB, FBB, CurBB, SwitchBB,
1412                                  TWeight, FWeight);
1413     return;
1414   }
1415
1416   //  Create TmpBB after CurBB.
1417   MachineFunction::iterator BBI = CurBB;
1418   MachineFunction &MF = DAG.getMachineFunction();
1419   MachineBasicBlock *TmpBB = MF.CreateMachineBasicBlock(CurBB->getBasicBlock());
1420   CurBB->getParent()->insert(++BBI, TmpBB);
1421
1422   if (Opc == Instruction::Or) {
1423     // Codegen X | Y as:
1424     // BB1:
1425     //   jmp_if_X TBB
1426     //   jmp TmpBB
1427     // TmpBB:
1428     //   jmp_if_Y TBB
1429     //   jmp FBB
1430     //
1431
1432     // We have flexibility in setting Prob for BB1 and Prob for TmpBB.
1433     // The requirement is that
1434     //   TrueProb for BB1 + (FalseProb for BB1 * TrueProb for TmpBB)
1435     //     = TrueProb for orignal BB.
1436     // Assuming the orignal weights are A and B, one choice is to set BB1's
1437     // weights to A and A+2B, and set TmpBB's weights to A and 2B. This choice
1438     // assumes that
1439     //   TrueProb for BB1 == FalseProb for BB1 * TrueProb for TmpBB.
1440     // Another choice is to assume TrueProb for BB1 equals to TrueProb for
1441     // TmpBB, but the math is more complicated.
1442
1443     uint64_t NewTrueWeight = TWeight;
1444     uint64_t NewFalseWeight = (uint64_t)TWeight + 2 * (uint64_t)FWeight;
1445     ScaleWeights(NewTrueWeight, NewFalseWeight);
1446     // Emit the LHS condition.
1447     FindMergedConditions(BOp->getOperand(0), TBB, TmpBB, CurBB, SwitchBB, Opc,
1448                          NewTrueWeight, NewFalseWeight);
1449
1450     NewTrueWeight = TWeight;
1451     NewFalseWeight = 2 * (uint64_t)FWeight;
1452     ScaleWeights(NewTrueWeight, NewFalseWeight);
1453     // Emit the RHS condition into TmpBB.
1454     FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, SwitchBB, Opc,
1455                          NewTrueWeight, NewFalseWeight);
1456   } else {
1457     assert(Opc == Instruction::And && "Unknown merge op!");
1458     // Codegen X & Y as:
1459     // BB1:
1460     //   jmp_if_X TmpBB
1461     //   jmp FBB
1462     // TmpBB:
1463     //   jmp_if_Y TBB
1464     //   jmp FBB
1465     //
1466     //  This requires creation of TmpBB after CurBB.
1467
1468     // We have flexibility in setting Prob for BB1 and Prob for TmpBB.
1469     // The requirement is that
1470     //   FalseProb for BB1 + (TrueProb for BB1 * FalseProb for TmpBB)
1471     //     = FalseProb for orignal BB.
1472     // Assuming the orignal weights are A and B, one choice is to set BB1's
1473     // weights to 2A+B and B, and set TmpBB's weights to 2A and B. This choice
1474     // assumes that
1475     //   FalseProb for BB1 == TrueProb for BB1 * FalseProb for TmpBB.
1476
1477     uint64_t NewTrueWeight = 2 * (uint64_t)TWeight + (uint64_t)FWeight;
1478     uint64_t NewFalseWeight = FWeight;
1479     ScaleWeights(NewTrueWeight, NewFalseWeight);
1480     // Emit the LHS condition.
1481     FindMergedConditions(BOp->getOperand(0), TmpBB, FBB, CurBB, SwitchBB, Opc,
1482                          NewTrueWeight, NewFalseWeight);
1483
1484     NewTrueWeight = 2 * (uint64_t)TWeight;
1485     NewFalseWeight = FWeight;
1486     ScaleWeights(NewTrueWeight, NewFalseWeight);
1487     // Emit the RHS condition into TmpBB.
1488     FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, SwitchBB, Opc,
1489                          NewTrueWeight, NewFalseWeight);
1490   }
1491 }
1492
1493 /// If the set of cases should be emitted as a series of branches, return true.
1494 /// If we should emit this as a bunch of and/or'd together conditions, return
1495 /// false.
1496 bool
1497 SelectionDAGBuilder::ShouldEmitAsBranches(const std::vector<CaseBlock> &Cases) {
1498   if (Cases.size() != 2) return true;
1499
1500   // If this is two comparisons of the same values or'd or and'd together, they
1501   // will get folded into a single comparison, so don't emit two blocks.
1502   if ((Cases[0].CmpLHS == Cases[1].CmpLHS &&
1503        Cases[0].CmpRHS == Cases[1].CmpRHS) ||
1504       (Cases[0].CmpRHS == Cases[1].CmpLHS &&
1505        Cases[0].CmpLHS == Cases[1].CmpRHS)) {
1506     return false;
1507   }
1508
1509   // Handle: (X != null) | (Y != null) --> (X|Y) != 0
1510   // Handle: (X == null) & (Y == null) --> (X|Y) == 0
1511   if (Cases[0].CmpRHS == Cases[1].CmpRHS &&
1512       Cases[0].CC == Cases[1].CC &&
1513       isa<Constant>(Cases[0].CmpRHS) &&
1514       cast<Constant>(Cases[0].CmpRHS)->isNullValue()) {
1515     if (Cases[0].CC == ISD::SETEQ && Cases[0].TrueBB == Cases[1].ThisBB)
1516       return false;
1517     if (Cases[0].CC == ISD::SETNE && Cases[0].FalseBB == Cases[1].ThisBB)
1518       return false;
1519   }
1520
1521   return true;
1522 }
1523
1524 void SelectionDAGBuilder::visitBr(const BranchInst &I) {
1525   MachineBasicBlock *BrMBB = FuncInfo.MBB;
1526
1527   // Update machine-CFG edges.
1528   MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)];
1529
1530   if (I.isUnconditional()) {
1531     // Update machine-CFG edges.
1532     BrMBB->addSuccessor(Succ0MBB);
1533
1534     // If this is not a fall-through branch or optimizations are switched off,
1535     // emit the branch.
1536     if (Succ0MBB != NextBlock(BrMBB) || TM.getOptLevel() == CodeGenOpt::None)
1537       DAG.setRoot(DAG.getNode(ISD::BR, getCurSDLoc(),
1538                               MVT::Other, getControlRoot(),
1539                               DAG.getBasicBlock(Succ0MBB)));
1540
1541     return;
1542   }
1543
1544   // If this condition is one of the special cases we handle, do special stuff
1545   // now.
1546   const Value *CondVal = I.getCondition();
1547   MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)];
1548
1549   // If this is a series of conditions that are or'd or and'd together, emit
1550   // this as a sequence of branches instead of setcc's with and/or operations.
1551   // As long as jumps are not expensive, this should improve performance.
1552   // For example, instead of something like:
1553   //     cmp A, B
1554   //     C = seteq
1555   //     cmp D, E
1556   //     F = setle
1557   //     or C, F
1558   //     jnz foo
1559   // Emit:
1560   //     cmp A, B
1561   //     je foo
1562   //     cmp D, E
1563   //     jle foo
1564   //
1565   if (const BinaryOperator *BOp = dyn_cast<BinaryOperator>(CondVal)) {
1566     if (!DAG.getTargetLoweringInfo().isJumpExpensive() &&
1567         BOp->hasOneUse() && (BOp->getOpcode() == Instruction::And ||
1568                              BOp->getOpcode() == Instruction::Or)) {
1569       FindMergedConditions(BOp, Succ0MBB, Succ1MBB, BrMBB, BrMBB,
1570                            BOp->getOpcode(), getEdgeWeight(BrMBB, Succ0MBB),
1571                            getEdgeWeight(BrMBB, Succ1MBB));
1572       // If the compares in later blocks need to use values not currently
1573       // exported from this block, export them now.  This block should always
1574       // be the first entry.
1575       assert(SwitchCases[0].ThisBB == BrMBB && "Unexpected lowering!");
1576
1577       // Allow some cases to be rejected.
1578       if (ShouldEmitAsBranches(SwitchCases)) {
1579         for (unsigned i = 1, e = SwitchCases.size(); i != e; ++i) {
1580           ExportFromCurrentBlock(SwitchCases[i].CmpLHS);
1581           ExportFromCurrentBlock(SwitchCases[i].CmpRHS);
1582         }
1583
1584         // Emit the branch for this block.
1585         visitSwitchCase(SwitchCases[0], BrMBB);
1586         SwitchCases.erase(SwitchCases.begin());
1587         return;
1588       }
1589
1590       // Okay, we decided not to do this, remove any inserted MBB's and clear
1591       // SwitchCases.
1592       for (unsigned i = 1, e = SwitchCases.size(); i != e; ++i)
1593         FuncInfo.MF->erase(SwitchCases[i].ThisBB);
1594
1595       SwitchCases.clear();
1596     }
1597   }
1598
1599   // Create a CaseBlock record representing this branch.
1600   CaseBlock CB(ISD::SETEQ, CondVal, ConstantInt::getTrue(*DAG.getContext()),
1601                nullptr, Succ0MBB, Succ1MBB, BrMBB);
1602
1603   // Use visitSwitchCase to actually insert the fast branch sequence for this
1604   // cond branch.
1605   visitSwitchCase(CB, BrMBB);
1606 }
1607
1608 /// visitSwitchCase - Emits the necessary code to represent a single node in
1609 /// the binary search tree resulting from lowering a switch instruction.
1610 void SelectionDAGBuilder::visitSwitchCase(CaseBlock &CB,
1611                                           MachineBasicBlock *SwitchBB) {
1612   SDValue Cond;
1613   SDValue CondLHS = getValue(CB.CmpLHS);
1614   SDLoc dl = getCurSDLoc();
1615
1616   // Build the setcc now.
1617   if (!CB.CmpMHS) {
1618     // Fold "(X == true)" to X and "(X == false)" to !X to
1619     // handle common cases produced by branch lowering.
1620     if (CB.CmpRHS == ConstantInt::getTrue(*DAG.getContext()) &&
1621         CB.CC == ISD::SETEQ)
1622       Cond = CondLHS;
1623     else if (CB.CmpRHS == ConstantInt::getFalse(*DAG.getContext()) &&
1624              CB.CC == ISD::SETEQ) {
1625       SDValue True = DAG.getConstant(1, dl, CondLHS.getValueType());
1626       Cond = DAG.getNode(ISD::XOR, dl, CondLHS.getValueType(), CondLHS, True);
1627     } else
1628       Cond = DAG.getSetCC(dl, MVT::i1, CondLHS, getValue(CB.CmpRHS), CB.CC);
1629   } else {
1630     assert(CB.CC == ISD::SETLE && "Can handle only LE ranges now");
1631
1632     const APInt& Low = cast<ConstantInt>(CB.CmpLHS)->getValue();
1633     const APInt& High = cast<ConstantInt>(CB.CmpRHS)->getValue();
1634
1635     SDValue CmpOp = getValue(CB.CmpMHS);
1636     EVT VT = CmpOp.getValueType();
1637
1638     if (cast<ConstantInt>(CB.CmpLHS)->isMinValue(true)) {
1639       Cond = DAG.getSetCC(dl, MVT::i1, CmpOp, DAG.getConstant(High, dl, VT),
1640                           ISD::SETLE);
1641     } else {
1642       SDValue SUB = DAG.getNode(ISD::SUB, dl,
1643                                 VT, CmpOp, DAG.getConstant(Low, dl, VT));
1644       Cond = DAG.getSetCC(dl, MVT::i1, SUB,
1645                           DAG.getConstant(High-Low, dl, VT), ISD::SETULE);
1646     }
1647   }
1648
1649   // Update successor info
1650   addSuccessorWithWeight(SwitchBB, CB.TrueBB, CB.TrueWeight);
1651   // TrueBB and FalseBB are always different unless the incoming IR is
1652   // degenerate. This only happens when running llc on weird IR.
1653   if (CB.TrueBB != CB.FalseBB)
1654     addSuccessorWithWeight(SwitchBB, CB.FalseBB, CB.FalseWeight);
1655
1656   // If the lhs block is the next block, invert the condition so that we can
1657   // fall through to the lhs instead of the rhs block.
1658   if (CB.TrueBB == NextBlock(SwitchBB)) {
1659     std::swap(CB.TrueBB, CB.FalseBB);
1660     SDValue True = DAG.getConstant(1, dl, Cond.getValueType());
1661     Cond = DAG.getNode(ISD::XOR, dl, Cond.getValueType(), Cond, True);
1662   }
1663
1664   SDValue BrCond = DAG.getNode(ISD::BRCOND, dl,
1665                                MVT::Other, getControlRoot(), Cond,
1666                                DAG.getBasicBlock(CB.TrueBB));
1667
1668   // Insert the false branch. Do this even if it's a fall through branch,
1669   // this makes it easier to do DAG optimizations which require inverting
1670   // the branch condition.
1671   BrCond = DAG.getNode(ISD::BR, dl, MVT::Other, BrCond,
1672                        DAG.getBasicBlock(CB.FalseBB));
1673
1674   DAG.setRoot(BrCond);
1675 }
1676
1677 /// visitJumpTable - Emit JumpTable node in the current MBB
1678 void SelectionDAGBuilder::visitJumpTable(JumpTable &JT) {
1679   // Emit the code for the jump table
1680   assert(JT.Reg != -1U && "Should lower JT Header first!");
1681   EVT PTy = DAG.getTargetLoweringInfo().getPointerTy();
1682   SDValue Index = DAG.getCopyFromReg(getControlRoot(), getCurSDLoc(),
1683                                      JT.Reg, PTy);
1684   SDValue Table = DAG.getJumpTable(JT.JTI, PTy);
1685   SDValue BrJumpTable = DAG.getNode(ISD::BR_JT, getCurSDLoc(),
1686                                     MVT::Other, Index.getValue(1),
1687                                     Table, Index);
1688   DAG.setRoot(BrJumpTable);
1689 }
1690
1691 /// visitJumpTableHeader - This function emits necessary code to produce index
1692 /// in the JumpTable from switch case.
1693 void SelectionDAGBuilder::visitJumpTableHeader(JumpTable &JT,
1694                                                JumpTableHeader &JTH,
1695                                                MachineBasicBlock *SwitchBB) {
1696   SDLoc dl = getCurSDLoc();
1697
1698   // Subtract the lowest switch case value from the value being switched on and
1699   // conditional branch to default mbb if the result is greater than the
1700   // difference between smallest and largest cases.
1701   SDValue SwitchOp = getValue(JTH.SValue);
1702   EVT VT = SwitchOp.getValueType();
1703   SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, SwitchOp,
1704                             DAG.getConstant(JTH.First, dl, VT));
1705
1706   // The SDNode we just created, which holds the value being switched on minus
1707   // the smallest case value, needs to be copied to a virtual register so it
1708   // can be used as an index into the jump table in a subsequent basic block.
1709   // This value may be smaller or larger than the target's pointer type, and
1710   // therefore require extension or truncating.
1711   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
1712   SwitchOp = DAG.getZExtOrTrunc(Sub, dl, TLI.getPointerTy());
1713
1714   unsigned JumpTableReg = FuncInfo.CreateReg(TLI.getPointerTy());
1715   SDValue CopyTo = DAG.getCopyToReg(getControlRoot(), dl,
1716                                     JumpTableReg, SwitchOp);
1717   JT.Reg = JumpTableReg;
1718
1719   // Emit the range check for the jump table, and branch to the default block
1720   // for the switch statement if the value being switched on exceeds the largest
1721   // case in the switch.
1722   SDValue CMP =
1723       DAG.getSetCC(dl, TLI.getSetCCResultType(*DAG.getContext(),
1724                                               Sub.getValueType()),
1725                    Sub, DAG.getConstant(JTH.Last - JTH.First, dl, VT),
1726                    ISD::SETUGT);
1727
1728   SDValue BrCond = DAG.getNode(ISD::BRCOND, dl,
1729                                MVT::Other, CopyTo, CMP,
1730                                DAG.getBasicBlock(JT.Default));
1731
1732   // Avoid emitting unnecessary branches to the next block.
1733   if (JT.MBB != NextBlock(SwitchBB))
1734     BrCond = DAG.getNode(ISD::BR, dl, MVT::Other, BrCond,
1735                          DAG.getBasicBlock(JT.MBB));
1736
1737   DAG.setRoot(BrCond);
1738 }
1739
1740 /// Codegen a new tail for a stack protector check ParentMBB which has had its
1741 /// tail spliced into a stack protector check success bb.
1742 ///
1743 /// For a high level explanation of how this fits into the stack protector
1744 /// generation see the comment on the declaration of class
1745 /// StackProtectorDescriptor.
1746 void SelectionDAGBuilder::visitSPDescriptorParent(StackProtectorDescriptor &SPD,
1747                                                   MachineBasicBlock *ParentBB) {
1748
1749   // First create the loads to the guard/stack slot for the comparison.
1750   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
1751   EVT PtrTy = TLI.getPointerTy();
1752
1753   MachineFrameInfo *MFI = ParentBB->getParent()->getFrameInfo();
1754   int FI = MFI->getStackProtectorIndex();
1755
1756   const Value *IRGuard = SPD.getGuard();
1757   SDValue GuardPtr = getValue(IRGuard);
1758   SDValue StackSlotPtr = DAG.getFrameIndex(FI, PtrTy);
1759
1760   unsigned Align =
1761     TLI.getDataLayout()->getPrefTypeAlignment(IRGuard->getType());
1762
1763   SDValue Guard;
1764   SDLoc dl = getCurSDLoc();
1765
1766   // If GuardReg is set and useLoadStackGuardNode returns true, retrieve the
1767   // guard value from the virtual register holding the value. Otherwise, emit a
1768   // volatile load to retrieve the stack guard value.
1769   unsigned GuardReg = SPD.getGuardReg();
1770
1771   if (GuardReg && TLI.useLoadStackGuardNode())
1772     Guard = DAG.getCopyFromReg(DAG.getEntryNode(), dl, GuardReg,
1773                                PtrTy);
1774   else
1775     Guard = DAG.getLoad(PtrTy, dl, DAG.getEntryNode(),
1776                         GuardPtr, MachinePointerInfo(IRGuard, 0),
1777                         true, false, false, Align);
1778
1779   SDValue StackSlot = DAG.getLoad(PtrTy, dl, DAG.getEntryNode(),
1780                                   StackSlotPtr,
1781                                   MachinePointerInfo::getFixedStack(FI),
1782                                   true, false, false, Align);
1783
1784   // Perform the comparison via a subtract/getsetcc.
1785   EVT VT = Guard.getValueType();
1786   SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, Guard, StackSlot);
1787
1788   SDValue Cmp =
1789       DAG.getSetCC(dl, TLI.getSetCCResultType(*DAG.getContext(),
1790                                                          Sub.getValueType()),
1791                    Sub, DAG.getConstant(0, dl, VT), ISD::SETNE);
1792
1793   // If the sub is not 0, then we know the guard/stackslot do not equal, so
1794   // branch to failure MBB.
1795   SDValue BrCond = DAG.getNode(ISD::BRCOND, dl,
1796                                MVT::Other, StackSlot.getOperand(0),
1797                                Cmp, DAG.getBasicBlock(SPD.getFailureMBB()));
1798   // Otherwise branch to success MBB.
1799   SDValue Br = DAG.getNode(ISD::BR, dl,
1800                            MVT::Other, BrCond,
1801                            DAG.getBasicBlock(SPD.getSuccessMBB()));
1802
1803   DAG.setRoot(Br);
1804 }
1805
1806 /// Codegen the failure basic block for a stack protector check.
1807 ///
1808 /// A failure stack protector machine basic block consists simply of a call to
1809 /// __stack_chk_fail().
1810 ///
1811 /// For a high level explanation of how this fits into the stack protector
1812 /// generation see the comment on the declaration of class
1813 /// StackProtectorDescriptor.
1814 void
1815 SelectionDAGBuilder::visitSPDescriptorFailure(StackProtectorDescriptor &SPD) {
1816   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
1817   SDValue Chain =
1818       TLI.makeLibCall(DAG, RTLIB::STACKPROTECTOR_CHECK_FAIL, MVT::isVoid,
1819                       nullptr, 0, false, getCurSDLoc(), false, false).second;
1820   DAG.setRoot(Chain);
1821 }
1822
1823 /// visitBitTestHeader - This function emits necessary code to produce value
1824 /// suitable for "bit tests"
1825 void SelectionDAGBuilder::visitBitTestHeader(BitTestBlock &B,
1826                                              MachineBasicBlock *SwitchBB) {
1827   SDLoc dl = getCurSDLoc();
1828
1829   // Subtract the minimum value
1830   SDValue SwitchOp = getValue(B.SValue);
1831   EVT VT = SwitchOp.getValueType();
1832   SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, SwitchOp,
1833                             DAG.getConstant(B.First, dl, VT));
1834
1835   // Check range
1836   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
1837   SDValue RangeCmp =
1838       DAG.getSetCC(dl, TLI.getSetCCResultType(*DAG.getContext(),
1839                                               Sub.getValueType()),
1840                    Sub, DAG.getConstant(B.Range, dl, VT), ISD::SETUGT);
1841
1842   // Determine the type of the test operands.
1843   bool UsePtrType = false;
1844   if (!TLI.isTypeLegal(VT))
1845     UsePtrType = true;
1846   else {
1847     for (unsigned i = 0, e = B.Cases.size(); i != e; ++i)
1848       if (!isUIntN(VT.getSizeInBits(), B.Cases[i].Mask)) {
1849         // Switch table case range are encoded into series of masks.
1850         // Just use pointer type, it's guaranteed to fit.
1851         UsePtrType = true;
1852         break;
1853       }
1854   }
1855   if (UsePtrType) {
1856     VT = TLI.getPointerTy();
1857     Sub = DAG.getZExtOrTrunc(Sub, dl, VT);
1858   }
1859
1860   B.RegVT = VT.getSimpleVT();
1861   B.Reg = FuncInfo.CreateReg(B.RegVT);
1862   SDValue CopyTo = DAG.getCopyToReg(getControlRoot(), dl, B.Reg, Sub);
1863
1864   MachineBasicBlock* MBB = B.Cases[0].ThisBB;
1865
1866   addSuccessorWithWeight(SwitchBB, B.Default);
1867   addSuccessorWithWeight(SwitchBB, MBB);
1868
1869   SDValue BrRange = DAG.getNode(ISD::BRCOND, dl,
1870                                 MVT::Other, CopyTo, RangeCmp,
1871                                 DAG.getBasicBlock(B.Default));
1872
1873   // Avoid emitting unnecessary branches to the next block.
1874   if (MBB != NextBlock(SwitchBB))
1875     BrRange = DAG.getNode(ISD::BR, dl, MVT::Other, BrRange,
1876                           DAG.getBasicBlock(MBB));
1877
1878   DAG.setRoot(BrRange);
1879 }
1880
1881 /// visitBitTestCase - this function produces one "bit test"
1882 void SelectionDAGBuilder::visitBitTestCase(BitTestBlock &BB,
1883                                            MachineBasicBlock* NextMBB,
1884                                            uint32_t BranchWeightToNext,
1885                                            unsigned Reg,
1886                                            BitTestCase &B,
1887                                            MachineBasicBlock *SwitchBB) {
1888   SDLoc dl = getCurSDLoc();
1889   MVT VT = BB.RegVT;
1890   SDValue ShiftOp = DAG.getCopyFromReg(getControlRoot(), dl, Reg, VT);
1891   SDValue Cmp;
1892   unsigned PopCount = countPopulation(B.Mask);
1893   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
1894   if (PopCount == 1) {
1895     // Testing for a single bit; just compare the shift count with what it
1896     // would need to be to shift a 1 bit in that position.
1897     Cmp = DAG.getSetCC(
1898         dl, TLI.getSetCCResultType(*DAG.getContext(), VT), ShiftOp,
1899         DAG.getConstant(countTrailingZeros(B.Mask), dl, VT), ISD::SETEQ);
1900   } else if (PopCount == BB.Range) {
1901     // There is only one zero bit in the range, test for it directly.
1902     Cmp = DAG.getSetCC(
1903         dl, TLI.getSetCCResultType(*DAG.getContext(), VT), ShiftOp,
1904         DAG.getConstant(countTrailingOnes(B.Mask), dl, VT), ISD::SETNE);
1905   } else {
1906     // Make desired shift
1907     SDValue SwitchVal = DAG.getNode(ISD::SHL, dl, VT,
1908                                     DAG.getConstant(1, dl, VT), ShiftOp);
1909
1910     // Emit bit tests and jumps
1911     SDValue AndOp = DAG.getNode(ISD::AND, dl,
1912                                 VT, SwitchVal, DAG.getConstant(B.Mask, dl, VT));
1913     Cmp = DAG.getSetCC(dl, TLI.getSetCCResultType(*DAG.getContext(), VT), AndOp,
1914                        DAG.getConstant(0, dl, VT), ISD::SETNE);
1915   }
1916
1917   // The branch weight from SwitchBB to B.TargetBB is B.ExtraWeight.
1918   addSuccessorWithWeight(SwitchBB, B.TargetBB, B.ExtraWeight);
1919   // The branch weight from SwitchBB to NextMBB is BranchWeightToNext.
1920   addSuccessorWithWeight(SwitchBB, NextMBB, BranchWeightToNext);
1921
1922   SDValue BrAnd = DAG.getNode(ISD::BRCOND, dl,
1923                               MVT::Other, getControlRoot(),
1924                               Cmp, DAG.getBasicBlock(B.TargetBB));
1925
1926   // Avoid emitting unnecessary branches to the next block.
1927   if (NextMBB != NextBlock(SwitchBB))
1928     BrAnd = DAG.getNode(ISD::BR, dl, MVT::Other, BrAnd,
1929                         DAG.getBasicBlock(NextMBB));
1930
1931   DAG.setRoot(BrAnd);
1932 }
1933
1934 void SelectionDAGBuilder::visitInvoke(const InvokeInst &I) {
1935   MachineBasicBlock *InvokeMBB = FuncInfo.MBB;
1936
1937   // Retrieve successors.
1938   MachineBasicBlock *Return = FuncInfo.MBBMap[I.getSuccessor(0)];
1939   MachineBasicBlock *LandingPad = FuncInfo.MBBMap[I.getSuccessor(1)];
1940
1941   const Value *Callee(I.getCalledValue());
1942   const Function *Fn = dyn_cast<Function>(Callee);
1943   if (isa<InlineAsm>(Callee))
1944     visitInlineAsm(&I);
1945   else if (Fn && Fn->isIntrinsic()) {
1946     switch (Fn->getIntrinsicID()) {
1947     default:
1948       llvm_unreachable("Cannot invoke this intrinsic");
1949     case Intrinsic::donothing:
1950       // Ignore invokes to @llvm.donothing: jump directly to the next BB.
1951       break;
1952     case Intrinsic::experimental_patchpoint_void:
1953     case Intrinsic::experimental_patchpoint_i64:
1954       visitPatchpoint(&I, LandingPad);
1955       break;
1956     case Intrinsic::experimental_gc_statepoint:
1957       LowerStatepoint(ImmutableStatepoint(&I), LandingPad);
1958       break;
1959     }
1960   } else
1961     LowerCallTo(&I, getValue(Callee), false, LandingPad);
1962
1963   // If the value of the invoke is used outside of its defining block, make it
1964   // available as a virtual register.
1965   // We already took care of the exported value for the statepoint instruction
1966   // during call to the LowerStatepoint.
1967   if (!isStatepoint(I)) {
1968     CopyToExportRegsIfNeeded(&I);
1969   }
1970
1971   // Update successor info
1972   addSuccessorWithWeight(InvokeMBB, Return);
1973   addSuccessorWithWeight(InvokeMBB, LandingPad);
1974
1975   // Drop into normal successor.
1976   DAG.setRoot(DAG.getNode(ISD::BR, getCurSDLoc(),
1977                           MVT::Other, getControlRoot(),
1978                           DAG.getBasicBlock(Return)));
1979 }
1980
1981 void SelectionDAGBuilder::visitResume(const ResumeInst &RI) {
1982   llvm_unreachable("SelectionDAGBuilder shouldn't visit resume instructions!");
1983 }
1984
1985 void SelectionDAGBuilder::visitLandingPad(const LandingPadInst &LP) {
1986   assert(FuncInfo.MBB->isLandingPad() &&
1987          "Call to landingpad not in landing pad!");
1988
1989   MachineBasicBlock *MBB = FuncInfo.MBB;
1990   MachineModuleInfo &MMI = DAG.getMachineFunction().getMMI();
1991   AddLandingPadInfo(LP, MMI, MBB);
1992
1993   // If there aren't registers to copy the values into (e.g., during SjLj
1994   // exceptions), then don't bother to create these DAG nodes.
1995   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
1996   if (TLI.getExceptionPointerRegister() == 0 &&
1997       TLI.getExceptionSelectorRegister() == 0)
1998     return;
1999
2000   SmallVector<EVT, 2> ValueVTs;
2001   SDLoc dl = getCurSDLoc();
2002   ComputeValueVTs(TLI, LP.getType(), ValueVTs);
2003   assert(ValueVTs.size() == 2 && "Only two-valued landingpads are supported");
2004
2005   // Get the two live-in registers as SDValues. The physregs have already been
2006   // copied into virtual registers.
2007   SDValue Ops[2];
2008   if (FuncInfo.ExceptionPointerVirtReg) {
2009     Ops[0] = DAG.getZExtOrTrunc(
2010         DAG.getCopyFromReg(DAG.getEntryNode(), dl,
2011                            FuncInfo.ExceptionPointerVirtReg, TLI.getPointerTy()),
2012         dl, ValueVTs[0]);
2013   } else {
2014     Ops[0] = DAG.getConstant(0, dl, TLI.getPointerTy());
2015   }
2016   Ops[1] = DAG.getZExtOrTrunc(
2017       DAG.getCopyFromReg(DAG.getEntryNode(), dl,
2018                          FuncInfo.ExceptionSelectorVirtReg, TLI.getPointerTy()),
2019       dl, ValueVTs[1]);
2020
2021   // Merge into one.
2022   SDValue Res = DAG.getNode(ISD::MERGE_VALUES, dl,
2023                             DAG.getVTList(ValueVTs), Ops);
2024   setValue(&LP, Res);
2025 }
2026
2027 unsigned
2028 SelectionDAGBuilder::visitLandingPadClauseBB(GlobalValue *ClauseGV,
2029                                              MachineBasicBlock *LPadBB) {
2030   SDValue Chain = getControlRoot();
2031   SDLoc dl = getCurSDLoc();
2032
2033   // Get the typeid that we will dispatch on later.
2034   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2035   const TargetRegisterClass *RC = TLI.getRegClassFor(TLI.getPointerTy());
2036   unsigned VReg = FuncInfo.MF->getRegInfo().createVirtualRegister(RC);
2037   unsigned TypeID = DAG.getMachineFunction().getMMI().getTypeIDFor(ClauseGV);
2038   SDValue Sel = DAG.getConstant(TypeID, dl, TLI.getPointerTy());
2039   Chain = DAG.getCopyToReg(Chain, dl, VReg, Sel);
2040
2041   // Branch to the main landing pad block.
2042   MachineBasicBlock *ClauseMBB = FuncInfo.MBB;
2043   ClauseMBB->addSuccessor(LPadBB);
2044   DAG.setRoot(DAG.getNode(ISD::BR, dl, MVT::Other, Chain,
2045                           DAG.getBasicBlock(LPadBB)));
2046   return VReg;
2047 }
2048
2049 void SelectionDAGBuilder::sortAndRangeify(CaseClusterVector &Clusters) {
2050 #ifndef NDEBUG
2051   for (const CaseCluster &CC : Clusters)
2052     assert(CC.Low == CC.High && "Input clusters must be single-case");
2053 #endif
2054
2055   std::sort(Clusters.begin(), Clusters.end(),
2056             [](const CaseCluster &a, const CaseCluster &b) {
2057     return a.Low->getValue().slt(b.Low->getValue());
2058   });
2059
2060   // Merge adjacent clusters with the same destination.
2061   const unsigned N = Clusters.size();
2062   unsigned DstIndex = 0;
2063   for (unsigned SrcIndex = 0; SrcIndex < N; ++SrcIndex) {
2064     CaseCluster &CC = Clusters[SrcIndex];
2065     const ConstantInt *CaseVal = CC.Low;
2066     MachineBasicBlock *Succ = CC.MBB;
2067
2068     if (DstIndex != 0 && Clusters[DstIndex - 1].MBB == Succ &&
2069         (CaseVal->getValue() - Clusters[DstIndex - 1].High->getValue()) == 1) {
2070       // If this case has the same successor and is a neighbour, merge it into
2071       // the previous cluster.
2072       Clusters[DstIndex - 1].High = CaseVal;
2073       Clusters[DstIndex - 1].Weight += CC.Weight;
2074       assert(Clusters[DstIndex - 1].Weight >= CC.Weight && "Weight overflow!");
2075     } else {
2076       std::memmove(&Clusters[DstIndex++], &Clusters[SrcIndex],
2077                    sizeof(Clusters[SrcIndex]));
2078     }
2079   }
2080   Clusters.resize(DstIndex);
2081 }
2082
2083 void SelectionDAGBuilder::UpdateSplitBlock(MachineBasicBlock *First,
2084                                            MachineBasicBlock *Last) {
2085   // Update JTCases.
2086   for (unsigned i = 0, e = JTCases.size(); i != e; ++i)
2087     if (JTCases[i].first.HeaderBB == First)
2088       JTCases[i].first.HeaderBB = Last;
2089
2090   // Update BitTestCases.
2091   for (unsigned i = 0, e = BitTestCases.size(); i != e; ++i)
2092     if (BitTestCases[i].Parent == First)
2093       BitTestCases[i].Parent = Last;
2094 }
2095
2096 void SelectionDAGBuilder::visitIndirectBr(const IndirectBrInst &I) {
2097   MachineBasicBlock *IndirectBrMBB = FuncInfo.MBB;
2098
2099   // Update machine-CFG edges with unique successors.
2100   SmallSet<BasicBlock*, 32> Done;
2101   for (unsigned i = 0, e = I.getNumSuccessors(); i != e; ++i) {
2102     BasicBlock *BB = I.getSuccessor(i);
2103     bool Inserted = Done.insert(BB).second;
2104     if (!Inserted)
2105         continue;
2106
2107     MachineBasicBlock *Succ = FuncInfo.MBBMap[BB];
2108     addSuccessorWithWeight(IndirectBrMBB, Succ);
2109   }
2110
2111   DAG.setRoot(DAG.getNode(ISD::BRIND, getCurSDLoc(),
2112                           MVT::Other, getControlRoot(),
2113                           getValue(I.getAddress())));
2114 }
2115
2116 void SelectionDAGBuilder::visitUnreachable(const UnreachableInst &I) {
2117   if (DAG.getTarget().Options.TrapUnreachable)
2118     DAG.setRoot(DAG.getNode(ISD::TRAP, getCurSDLoc(), MVT::Other, DAG.getRoot()));
2119 }
2120
2121 void SelectionDAGBuilder::visitFSub(const User &I) {
2122   // -0.0 - X --> fneg
2123   Type *Ty = I.getType();
2124   if (isa<Constant>(I.getOperand(0)) &&
2125       I.getOperand(0) == ConstantFP::getZeroValueForNegation(Ty)) {
2126     SDValue Op2 = getValue(I.getOperand(1));
2127     setValue(&I, DAG.getNode(ISD::FNEG, getCurSDLoc(),
2128                              Op2.getValueType(), Op2));
2129     return;
2130   }
2131
2132   visitBinary(I, ISD::FSUB);
2133 }
2134
2135 void SelectionDAGBuilder::visitBinary(const User &I, unsigned OpCode) {
2136   SDValue Op1 = getValue(I.getOperand(0));
2137   SDValue Op2 = getValue(I.getOperand(1));
2138
2139   bool nuw = false;
2140   bool nsw = false;
2141   bool exact = false;
2142   if (const OverflowingBinaryOperator *OFBinOp =
2143           dyn_cast<const OverflowingBinaryOperator>(&I)) {
2144     nuw = OFBinOp->hasNoUnsignedWrap();
2145     nsw = OFBinOp->hasNoSignedWrap();
2146   }
2147   if (const PossiblyExactOperator *ExactOp =
2148           dyn_cast<const PossiblyExactOperator>(&I))
2149     exact = ExactOp->isExact();
2150
2151   SDValue BinNodeValue = DAG.getNode(OpCode, getCurSDLoc(), Op1.getValueType(),
2152                                      Op1, Op2, nuw, nsw, exact);
2153   setValue(&I, BinNodeValue);
2154 }
2155
2156 void SelectionDAGBuilder::visitShift(const User &I, unsigned Opcode) {
2157   SDValue Op1 = getValue(I.getOperand(0));
2158   SDValue Op2 = getValue(I.getOperand(1));
2159
2160   EVT ShiftTy =
2161       DAG.getTargetLoweringInfo().getShiftAmountTy(Op2.getValueType());
2162
2163   // Coerce the shift amount to the right type if we can.
2164   if (!I.getType()->isVectorTy() && Op2.getValueType() != ShiftTy) {
2165     unsigned ShiftSize = ShiftTy.getSizeInBits();
2166     unsigned Op2Size = Op2.getValueType().getSizeInBits();
2167     SDLoc DL = getCurSDLoc();
2168
2169     // If the operand is smaller than the shift count type, promote it.
2170     if (ShiftSize > Op2Size)
2171       Op2 = DAG.getNode(ISD::ZERO_EXTEND, DL, ShiftTy, Op2);
2172
2173     // If the operand is larger than the shift count type but the shift
2174     // count type has enough bits to represent any shift value, truncate
2175     // it now. This is a common case and it exposes the truncate to
2176     // optimization early.
2177     else if (ShiftSize >= Log2_32_Ceil(Op2.getValueType().getSizeInBits()))
2178       Op2 = DAG.getNode(ISD::TRUNCATE, DL, ShiftTy, Op2);
2179     // Otherwise we'll need to temporarily settle for some other convenient
2180     // type.  Type legalization will make adjustments once the shiftee is split.
2181     else
2182       Op2 = DAG.getZExtOrTrunc(Op2, DL, MVT::i32);
2183   }
2184
2185   bool nuw = false;
2186   bool nsw = false;
2187   bool exact = false;
2188
2189   if (Opcode == ISD::SRL || Opcode == ISD::SRA || Opcode == ISD::SHL) {
2190
2191     if (const OverflowingBinaryOperator *OFBinOp =
2192             dyn_cast<const OverflowingBinaryOperator>(&I)) {
2193       nuw = OFBinOp->hasNoUnsignedWrap();
2194       nsw = OFBinOp->hasNoSignedWrap();
2195     }
2196     if (const PossiblyExactOperator *ExactOp =
2197             dyn_cast<const PossiblyExactOperator>(&I))
2198       exact = ExactOp->isExact();
2199   }
2200
2201   SDValue Res = DAG.getNode(Opcode, getCurSDLoc(), Op1.getValueType(), Op1, Op2,
2202                             nuw, nsw, exact);
2203   setValue(&I, Res);
2204 }
2205
2206 void SelectionDAGBuilder::visitSDiv(const User &I) {
2207   SDValue Op1 = getValue(I.getOperand(0));
2208   SDValue Op2 = getValue(I.getOperand(1));
2209
2210   // Turn exact SDivs into multiplications.
2211   // FIXME: This should be in DAGCombiner, but it doesn't have access to the
2212   // exact bit.
2213   if (isa<BinaryOperator>(&I) && cast<BinaryOperator>(&I)->isExact() &&
2214       !isa<ConstantSDNode>(Op1) &&
2215       isa<ConstantSDNode>(Op2) && !cast<ConstantSDNode>(Op2)->isNullValue())
2216     setValue(&I, DAG.getTargetLoweringInfo()
2217                      .BuildExactSDIV(Op1, Op2, getCurSDLoc(), DAG));
2218   else
2219     setValue(&I, DAG.getNode(ISD::SDIV, getCurSDLoc(), Op1.getValueType(),
2220                              Op1, Op2));
2221 }
2222
2223 void SelectionDAGBuilder::visitICmp(const User &I) {
2224   ICmpInst::Predicate predicate = ICmpInst::BAD_ICMP_PREDICATE;
2225   if (const ICmpInst *IC = dyn_cast<ICmpInst>(&I))
2226     predicate = IC->getPredicate();
2227   else if (const ConstantExpr *IC = dyn_cast<ConstantExpr>(&I))
2228     predicate = ICmpInst::Predicate(IC->getPredicate());
2229   SDValue Op1 = getValue(I.getOperand(0));
2230   SDValue Op2 = getValue(I.getOperand(1));
2231   ISD::CondCode Opcode = getICmpCondCode(predicate);
2232
2233   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(I.getType());
2234   setValue(&I, DAG.getSetCC(getCurSDLoc(), DestVT, Op1, Op2, Opcode));
2235 }
2236
2237 void SelectionDAGBuilder::visitFCmp(const User &I) {
2238   FCmpInst::Predicate predicate = FCmpInst::BAD_FCMP_PREDICATE;
2239   if (const FCmpInst *FC = dyn_cast<FCmpInst>(&I))
2240     predicate = FC->getPredicate();
2241   else if (const ConstantExpr *FC = dyn_cast<ConstantExpr>(&I))
2242     predicate = FCmpInst::Predicate(FC->getPredicate());
2243   SDValue Op1 = getValue(I.getOperand(0));
2244   SDValue Op2 = getValue(I.getOperand(1));
2245   ISD::CondCode Condition = getFCmpCondCode(predicate);
2246   if (TM.Options.NoNaNsFPMath)
2247     Condition = getFCmpCodeWithoutNaN(Condition);
2248   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(I.getType());
2249   setValue(&I, DAG.getSetCC(getCurSDLoc(), DestVT, Op1, Op2, Condition));
2250 }
2251
2252 void SelectionDAGBuilder::visitSelect(const User &I) {
2253   SmallVector<EVT, 4> ValueVTs;
2254   ComputeValueVTs(DAG.getTargetLoweringInfo(), I.getType(), ValueVTs);
2255   unsigned NumValues = ValueVTs.size();
2256   if (NumValues == 0) return;
2257
2258   SmallVector<SDValue, 4> Values(NumValues);
2259   SDValue Cond     = getValue(I.getOperand(0));
2260   SDValue LHSVal   = getValue(I.getOperand(1));
2261   SDValue RHSVal   = getValue(I.getOperand(2));
2262   auto BaseOps = {Cond};
2263   ISD::NodeType OpCode = Cond.getValueType().isVector() ?
2264     ISD::VSELECT : ISD::SELECT;
2265
2266   // Min/max matching is only viable if all output VTs are the same.
2267   if (std::equal(ValueVTs.begin(), ValueVTs.end(), ValueVTs.begin())) {
2268     Value *LHS, *RHS;
2269     SelectPatternFlavor SPF = matchSelectPattern(const_cast<User*>(&I), LHS, RHS);
2270     ISD::NodeType Opc = ISD::DELETED_NODE;
2271     switch (SPF) {
2272     case SPF_UMAX: Opc = ISD::UMAX; break;
2273     case SPF_UMIN: Opc = ISD::UMIN; break;
2274     case SPF_SMAX: Opc = ISD::SMAX; break;
2275     case SPF_SMIN: Opc = ISD::SMIN; break;
2276     default: break;
2277     }
2278
2279     EVT VT = ValueVTs[0];
2280     LLVMContext &Ctx = *DAG.getContext();
2281     auto &TLI = DAG.getTargetLoweringInfo();
2282     while (TLI.getTypeAction(Ctx, VT) == TargetLoweringBase::TypeSplitVector)
2283       VT = TLI.getTypeToTransformTo(Ctx, VT);
2284
2285     if (Opc != ISD::DELETED_NODE && TLI.isOperationLegalOrCustom(Opc, VT) &&
2286         // If the underlying comparison instruction is used by any other instruction,
2287         // the consumed instructions won't be destroyed, so it is not profitable
2288         // to convert to a min/max.
2289         cast<SelectInst>(&I)->getCondition()->hasOneUse()) {
2290       OpCode = Opc;
2291       LHSVal = getValue(LHS);
2292       RHSVal = getValue(RHS);
2293       BaseOps = {};
2294     }
2295   }
2296
2297   for (unsigned i = 0; i != NumValues; ++i) {
2298     SmallVector<SDValue, 3> Ops(BaseOps.begin(), BaseOps.end());
2299     Ops.push_back(SDValue(LHSVal.getNode(), LHSVal.getResNo() + i));
2300     Ops.push_back(SDValue(RHSVal.getNode(), RHSVal.getResNo() + i));
2301     Values[i] = DAG.getNode(OpCode, getCurSDLoc(),
2302                             LHSVal.getNode()->getValueType(LHSVal.getResNo()+i),
2303                             Ops);
2304   }
2305
2306   setValue(&I, DAG.getNode(ISD::MERGE_VALUES, getCurSDLoc(),
2307                            DAG.getVTList(ValueVTs), Values));
2308 }
2309
2310 void SelectionDAGBuilder::visitTrunc(const User &I) {
2311   // TruncInst cannot be a no-op cast because sizeof(src) > sizeof(dest).
2312   SDValue N = getValue(I.getOperand(0));
2313   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(I.getType());
2314   setValue(&I, DAG.getNode(ISD::TRUNCATE, getCurSDLoc(), DestVT, N));
2315 }
2316
2317 void SelectionDAGBuilder::visitZExt(const User &I) {
2318   // ZExt cannot be a no-op cast because sizeof(src) < sizeof(dest).
2319   // ZExt also can't be a cast to bool for same reason. So, nothing much to do
2320   SDValue N = getValue(I.getOperand(0));
2321   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(I.getType());
2322   setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, getCurSDLoc(), DestVT, N));
2323 }
2324
2325 void SelectionDAGBuilder::visitSExt(const User &I) {
2326   // SExt cannot be a no-op cast because sizeof(src) < sizeof(dest).
2327   // SExt also can't be a cast to bool for same reason. So, nothing much to do
2328   SDValue N = getValue(I.getOperand(0));
2329   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(I.getType());
2330   setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, getCurSDLoc(), DestVT, N));
2331 }
2332
2333 void SelectionDAGBuilder::visitFPTrunc(const User &I) {
2334   // FPTrunc is never a no-op cast, no need to check
2335   SDValue N = getValue(I.getOperand(0));
2336   SDLoc dl = getCurSDLoc();
2337   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2338   EVT DestVT = TLI.getValueType(I.getType());
2339   setValue(&I, DAG.getNode(ISD::FP_ROUND, dl, DestVT, N,
2340                            DAG.getTargetConstant(0, dl, TLI.getPointerTy())));
2341 }
2342
2343 void SelectionDAGBuilder::visitFPExt(const User &I) {
2344   // FPExt is never a no-op cast, no need to check
2345   SDValue N = getValue(I.getOperand(0));
2346   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(I.getType());
2347   setValue(&I, DAG.getNode(ISD::FP_EXTEND, getCurSDLoc(), DestVT, N));
2348 }
2349
2350 void SelectionDAGBuilder::visitFPToUI(const User &I) {
2351   // FPToUI is never a no-op cast, no need to check
2352   SDValue N = getValue(I.getOperand(0));
2353   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(I.getType());
2354   setValue(&I, DAG.getNode(ISD::FP_TO_UINT, getCurSDLoc(), DestVT, N));
2355 }
2356
2357 void SelectionDAGBuilder::visitFPToSI(const User &I) {
2358   // FPToSI is never a no-op cast, no need to check
2359   SDValue N = getValue(I.getOperand(0));
2360   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(I.getType());
2361   setValue(&I, DAG.getNode(ISD::FP_TO_SINT, getCurSDLoc(), DestVT, N));
2362 }
2363
2364 void SelectionDAGBuilder::visitUIToFP(const User &I) {
2365   // UIToFP is never a no-op cast, no need to check
2366   SDValue N = getValue(I.getOperand(0));
2367   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(I.getType());
2368   setValue(&I, DAG.getNode(ISD::UINT_TO_FP, getCurSDLoc(), DestVT, N));
2369 }
2370
2371 void SelectionDAGBuilder::visitSIToFP(const User &I) {
2372   // SIToFP is never a no-op cast, no need to check
2373   SDValue N = getValue(I.getOperand(0));
2374   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(I.getType());
2375   setValue(&I, DAG.getNode(ISD::SINT_TO_FP, getCurSDLoc(), DestVT, N));
2376 }
2377
2378 void SelectionDAGBuilder::visitPtrToInt(const User &I) {
2379   // What to do depends on the size of the integer and the size of the pointer.
2380   // We can either truncate, zero extend, or no-op, accordingly.
2381   SDValue N = getValue(I.getOperand(0));
2382   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(I.getType());
2383   setValue(&I, DAG.getZExtOrTrunc(N, getCurSDLoc(), DestVT));
2384 }
2385
2386 void SelectionDAGBuilder::visitIntToPtr(const User &I) {
2387   // What to do depends on the size of the integer and the size of the pointer.
2388   // We can either truncate, zero extend, or no-op, accordingly.
2389   SDValue N = getValue(I.getOperand(0));
2390   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(I.getType());
2391   setValue(&I, DAG.getZExtOrTrunc(N, getCurSDLoc(), DestVT));
2392 }
2393
2394 void SelectionDAGBuilder::visitBitCast(const User &I) {
2395   SDValue N = getValue(I.getOperand(0));
2396   SDLoc dl = getCurSDLoc();
2397   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(I.getType());
2398
2399   // BitCast assures us that source and destination are the same size so this is
2400   // either a BITCAST or a no-op.
2401   if (DestVT != N.getValueType())
2402     setValue(&I, DAG.getNode(ISD::BITCAST, dl,
2403                              DestVT, N)); // convert types.
2404   // Check if the original LLVM IR Operand was a ConstantInt, because getValue()
2405   // might fold any kind of constant expression to an integer constant and that
2406   // is not what we are looking for. Only regcognize a bitcast of a genuine
2407   // constant integer as an opaque constant.
2408   else if(ConstantInt *C = dyn_cast<ConstantInt>(I.getOperand(0)))
2409     setValue(&I, DAG.getConstant(C->getValue(), dl, DestVT, /*isTarget=*/false,
2410                                  /*isOpaque*/true));
2411   else
2412     setValue(&I, N);            // noop cast.
2413 }
2414
2415 void SelectionDAGBuilder::visitAddrSpaceCast(const User &I) {
2416   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2417   const Value *SV = I.getOperand(0);
2418   SDValue N = getValue(SV);
2419   EVT DestVT = TLI.getValueType(I.getType());
2420
2421   unsigned SrcAS = SV->getType()->getPointerAddressSpace();
2422   unsigned DestAS = I.getType()->getPointerAddressSpace();
2423
2424   if (!TLI.isNoopAddrSpaceCast(SrcAS, DestAS))
2425     N = DAG.getAddrSpaceCast(getCurSDLoc(), DestVT, N, SrcAS, DestAS);
2426
2427   setValue(&I, N);
2428 }
2429
2430 void SelectionDAGBuilder::visitInsertElement(const User &I) {
2431   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2432   SDValue InVec = getValue(I.getOperand(0));
2433   SDValue InVal = getValue(I.getOperand(1));
2434   SDValue InIdx = DAG.getSExtOrTrunc(getValue(I.getOperand(2)),
2435                                      getCurSDLoc(), TLI.getVectorIdxTy());
2436   setValue(&I, DAG.getNode(ISD::INSERT_VECTOR_ELT, getCurSDLoc(),
2437                            TLI.getValueType(I.getType()), InVec, InVal, InIdx));
2438 }
2439
2440 void SelectionDAGBuilder::visitExtractElement(const User &I) {
2441   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2442   SDValue InVec = getValue(I.getOperand(0));
2443   SDValue InIdx = DAG.getSExtOrTrunc(getValue(I.getOperand(1)),
2444                                      getCurSDLoc(), TLI.getVectorIdxTy());
2445   setValue(&I, DAG.getNode(ISD::EXTRACT_VECTOR_ELT, getCurSDLoc(),
2446                            TLI.getValueType(I.getType()), InVec, InIdx));
2447 }
2448
2449 // Utility for visitShuffleVector - Return true if every element in Mask,
2450 // beginning from position Pos and ending in Pos+Size, falls within the
2451 // specified sequential range [L, L+Pos). or is undef.
2452 static bool isSequentialInRange(const SmallVectorImpl<int> &Mask,
2453                                 unsigned Pos, unsigned Size, int Low) {
2454   for (unsigned i = Pos, e = Pos+Size; i != e; ++i, ++Low)
2455     if (Mask[i] >= 0 && Mask[i] != Low)
2456       return false;
2457   return true;
2458 }
2459
2460 void SelectionDAGBuilder::visitShuffleVector(const User &I) {
2461   SDValue Src1 = getValue(I.getOperand(0));
2462   SDValue Src2 = getValue(I.getOperand(1));
2463
2464   SmallVector<int, 8> Mask;
2465   ShuffleVectorInst::getShuffleMask(cast<Constant>(I.getOperand(2)), Mask);
2466   unsigned MaskNumElts = Mask.size();
2467
2468   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2469   EVT VT = TLI.getValueType(I.getType());
2470   EVT SrcVT = Src1.getValueType();
2471   unsigned SrcNumElts = SrcVT.getVectorNumElements();
2472
2473   if (SrcNumElts == MaskNumElts) {
2474     setValue(&I, DAG.getVectorShuffle(VT, getCurSDLoc(), Src1, Src2,
2475                                       &Mask[0]));
2476     return;
2477   }
2478
2479   // Normalize the shuffle vector since mask and vector length don't match.
2480   if (SrcNumElts < MaskNumElts && MaskNumElts % SrcNumElts == 0) {
2481     // Mask is longer than the source vectors and is a multiple of the source
2482     // vectors.  We can use concatenate vector to make the mask and vectors
2483     // lengths match.
2484     if (SrcNumElts*2 == MaskNumElts) {
2485       // First check for Src1 in low and Src2 in high
2486       if (isSequentialInRange(Mask, 0, SrcNumElts, 0) &&
2487           isSequentialInRange(Mask, SrcNumElts, SrcNumElts, SrcNumElts)) {
2488         // The shuffle is concatenating two vectors together.
2489         setValue(&I, DAG.getNode(ISD::CONCAT_VECTORS, getCurSDLoc(),
2490                                  VT, Src1, Src2));
2491         return;
2492       }
2493       // Then check for Src2 in low and Src1 in high
2494       if (isSequentialInRange(Mask, 0, SrcNumElts, SrcNumElts) &&
2495           isSequentialInRange(Mask, SrcNumElts, SrcNumElts, 0)) {
2496         // The shuffle is concatenating two vectors together.
2497         setValue(&I, DAG.getNode(ISD::CONCAT_VECTORS, getCurSDLoc(),
2498                                  VT, Src2, Src1));
2499         return;
2500       }
2501     }
2502
2503     // Pad both vectors with undefs to make them the same length as the mask.
2504     unsigned NumConcat = MaskNumElts / SrcNumElts;
2505     bool Src1U = Src1.getOpcode() == ISD::UNDEF;
2506     bool Src2U = Src2.getOpcode() == ISD::UNDEF;
2507     SDValue UndefVal = DAG.getUNDEF(SrcVT);
2508
2509     SmallVector<SDValue, 8> MOps1(NumConcat, UndefVal);
2510     SmallVector<SDValue, 8> MOps2(NumConcat, UndefVal);
2511     MOps1[0] = Src1;
2512     MOps2[0] = Src2;
2513
2514     Src1 = Src1U ? DAG.getUNDEF(VT) : DAG.getNode(ISD::CONCAT_VECTORS,
2515                                                   getCurSDLoc(), VT, MOps1);
2516     Src2 = Src2U ? DAG.getUNDEF(VT) : DAG.getNode(ISD::CONCAT_VECTORS,
2517                                                   getCurSDLoc(), VT, MOps2);
2518
2519     // Readjust mask for new input vector length.
2520     SmallVector<int, 8> MappedOps;
2521     for (unsigned i = 0; i != MaskNumElts; ++i) {
2522       int Idx = Mask[i];
2523       if (Idx >= (int)SrcNumElts)
2524         Idx -= SrcNumElts - MaskNumElts;
2525       MappedOps.push_back(Idx);
2526     }
2527
2528     setValue(&I, DAG.getVectorShuffle(VT, getCurSDLoc(), Src1, Src2,
2529                                       &MappedOps[0]));
2530     return;
2531   }
2532
2533   if (SrcNumElts > MaskNumElts) {
2534     // Analyze the access pattern of the vector to see if we can extract
2535     // two subvectors and do the shuffle. The analysis is done by calculating
2536     // the range of elements the mask access on both vectors.
2537     int MinRange[2] = { static_cast<int>(SrcNumElts),
2538                         static_cast<int>(SrcNumElts)};
2539     int MaxRange[2] = {-1, -1};
2540
2541     for (unsigned i = 0; i != MaskNumElts; ++i) {
2542       int Idx = Mask[i];
2543       unsigned Input = 0;
2544       if (Idx < 0)
2545         continue;
2546
2547       if (Idx >= (int)SrcNumElts) {
2548         Input = 1;
2549         Idx -= SrcNumElts;
2550       }
2551       if (Idx > MaxRange[Input])
2552         MaxRange[Input] = Idx;
2553       if (Idx < MinRange[Input])
2554         MinRange[Input] = Idx;
2555     }
2556
2557     // Check if the access is smaller than the vector size and can we find
2558     // a reasonable extract index.
2559     int RangeUse[2] = { -1, -1 };  // 0 = Unused, 1 = Extract, -1 = Can not
2560                                    // Extract.
2561     int StartIdx[2];  // StartIdx to extract from
2562     for (unsigned Input = 0; Input < 2; ++Input) {
2563       if (MinRange[Input] >= (int)SrcNumElts && MaxRange[Input] < 0) {
2564         RangeUse[Input] = 0; // Unused
2565         StartIdx[Input] = 0;
2566         continue;
2567       }
2568
2569       // Find a good start index that is a multiple of the mask length. Then
2570       // see if the rest of the elements are in range.
2571       StartIdx[Input] = (MinRange[Input]/MaskNumElts)*MaskNumElts;
2572       if (MaxRange[Input] - StartIdx[Input] < (int)MaskNumElts &&
2573           StartIdx[Input] + MaskNumElts <= SrcNumElts)
2574         RangeUse[Input] = 1; // Extract from a multiple of the mask length.
2575     }
2576
2577     if (RangeUse[0] == 0 && RangeUse[1] == 0) {
2578       setValue(&I, DAG.getUNDEF(VT)); // Vectors are not used.
2579       return;
2580     }
2581     if (RangeUse[0] >= 0 && RangeUse[1] >= 0) {
2582       // Extract appropriate subvector and generate a vector shuffle
2583       for (unsigned Input = 0; Input < 2; ++Input) {
2584         SDValue &Src = Input == 0 ? Src1 : Src2;
2585         if (RangeUse[Input] == 0)
2586           Src = DAG.getUNDEF(VT);
2587         else {
2588           SDLoc dl = getCurSDLoc();
2589           Src = DAG.getNode(
2590               ISD::EXTRACT_SUBVECTOR, dl, VT, Src,
2591               DAG.getConstant(StartIdx[Input], dl, TLI.getVectorIdxTy()));
2592         }
2593       }
2594
2595       // Calculate new mask.
2596       SmallVector<int, 8> MappedOps;
2597       for (unsigned i = 0; i != MaskNumElts; ++i) {
2598         int Idx = Mask[i];
2599         if (Idx >= 0) {
2600           if (Idx < (int)SrcNumElts)
2601             Idx -= StartIdx[0];
2602           else
2603             Idx -= SrcNumElts + StartIdx[1] - MaskNumElts;
2604         }
2605         MappedOps.push_back(Idx);
2606       }
2607
2608       setValue(&I, DAG.getVectorShuffle(VT, getCurSDLoc(), Src1, Src2,
2609                                         &MappedOps[0]));
2610       return;
2611     }
2612   }
2613
2614   // We can't use either concat vectors or extract subvectors so fall back to
2615   // replacing the shuffle with extract and build vector.
2616   // to insert and build vector.
2617   EVT EltVT = VT.getVectorElementType();
2618   EVT IdxVT = TLI.getVectorIdxTy();
2619   SDLoc dl = getCurSDLoc();
2620   SmallVector<SDValue,8> Ops;
2621   for (unsigned i = 0; i != MaskNumElts; ++i) {
2622     int Idx = Mask[i];
2623     SDValue Res;
2624
2625     if (Idx < 0) {
2626       Res = DAG.getUNDEF(EltVT);
2627     } else {
2628       SDValue &Src = Idx < (int)SrcNumElts ? Src1 : Src2;
2629       if (Idx >= (int)SrcNumElts) Idx -= SrcNumElts;
2630
2631       Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
2632                         EltVT, Src, DAG.getConstant(Idx, dl, IdxVT));
2633     }
2634
2635     Ops.push_back(Res);
2636   }
2637
2638   setValue(&I, DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops));
2639 }
2640
2641 void SelectionDAGBuilder::visitInsertValue(const InsertValueInst &I) {
2642   const Value *Op0 = I.getOperand(0);
2643   const Value *Op1 = I.getOperand(1);
2644   Type *AggTy = I.getType();
2645   Type *ValTy = Op1->getType();
2646   bool IntoUndef = isa<UndefValue>(Op0);
2647   bool FromUndef = isa<UndefValue>(Op1);
2648
2649   unsigned LinearIndex = ComputeLinearIndex(AggTy, I.getIndices());
2650
2651   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2652   SmallVector<EVT, 4> AggValueVTs;
2653   ComputeValueVTs(TLI, AggTy, AggValueVTs);
2654   SmallVector<EVT, 4> ValValueVTs;
2655   ComputeValueVTs(TLI, ValTy, ValValueVTs);
2656
2657   unsigned NumAggValues = AggValueVTs.size();
2658   unsigned NumValValues = ValValueVTs.size();
2659   SmallVector<SDValue, 4> Values(NumAggValues);
2660
2661   // Ignore an insertvalue that produces an empty object
2662   if (!NumAggValues) {
2663     setValue(&I, DAG.getUNDEF(MVT(MVT::Other)));
2664     return;
2665   }
2666
2667   SDValue Agg = getValue(Op0);
2668   unsigned i = 0;
2669   // Copy the beginning value(s) from the original aggregate.
2670   for (; i != LinearIndex; ++i)
2671     Values[i] = IntoUndef ? DAG.getUNDEF(AggValueVTs[i]) :
2672                 SDValue(Agg.getNode(), Agg.getResNo() + i);
2673   // Copy values from the inserted value(s).
2674   if (NumValValues) {
2675     SDValue Val = getValue(Op1);
2676     for (; i != LinearIndex + NumValValues; ++i)
2677       Values[i] = FromUndef ? DAG.getUNDEF(AggValueVTs[i]) :
2678                   SDValue(Val.getNode(), Val.getResNo() + i - LinearIndex);
2679   }
2680   // Copy remaining value(s) from the original aggregate.
2681   for (; i != NumAggValues; ++i)
2682     Values[i] = IntoUndef ? DAG.getUNDEF(AggValueVTs[i]) :
2683                 SDValue(Agg.getNode(), Agg.getResNo() + i);
2684
2685   setValue(&I, DAG.getNode(ISD::MERGE_VALUES, getCurSDLoc(),
2686                            DAG.getVTList(AggValueVTs), Values));
2687 }
2688
2689 void SelectionDAGBuilder::visitExtractValue(const ExtractValueInst &I) {
2690   const Value *Op0 = I.getOperand(0);
2691   Type *AggTy = Op0->getType();
2692   Type *ValTy = I.getType();
2693   bool OutOfUndef = isa<UndefValue>(Op0);
2694
2695   unsigned LinearIndex = ComputeLinearIndex(AggTy, I.getIndices());
2696
2697   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2698   SmallVector<EVT, 4> ValValueVTs;
2699   ComputeValueVTs(TLI, ValTy, ValValueVTs);
2700
2701   unsigned NumValValues = ValValueVTs.size();
2702
2703   // Ignore a extractvalue that produces an empty object
2704   if (!NumValValues) {
2705     setValue(&I, DAG.getUNDEF(MVT(MVT::Other)));
2706     return;
2707   }
2708
2709   SmallVector<SDValue, 4> Values(NumValValues);
2710
2711   SDValue Agg = getValue(Op0);
2712   // Copy out the selected value(s).
2713   for (unsigned i = LinearIndex; i != LinearIndex + NumValValues; ++i)
2714     Values[i - LinearIndex] =
2715       OutOfUndef ?
2716         DAG.getUNDEF(Agg.getNode()->getValueType(Agg.getResNo() + i)) :
2717         SDValue(Agg.getNode(), Agg.getResNo() + i);
2718
2719   setValue(&I, DAG.getNode(ISD::MERGE_VALUES, getCurSDLoc(),
2720                            DAG.getVTList(ValValueVTs), Values));
2721 }
2722
2723 void SelectionDAGBuilder::visitGetElementPtr(const User &I) {
2724   Value *Op0 = I.getOperand(0);
2725   // Note that the pointer operand may be a vector of pointers. Take the scalar
2726   // element which holds a pointer.
2727   Type *Ty = Op0->getType()->getScalarType();
2728   unsigned AS = Ty->getPointerAddressSpace();
2729   SDValue N = getValue(Op0);
2730   SDLoc dl = getCurSDLoc();
2731
2732   for (GetElementPtrInst::const_op_iterator OI = I.op_begin()+1, E = I.op_end();
2733        OI != E; ++OI) {
2734     const Value *Idx = *OI;
2735     if (StructType *StTy = dyn_cast<StructType>(Ty)) {
2736       unsigned Field = cast<Constant>(Idx)->getUniqueInteger().getZExtValue();
2737       if (Field) {
2738         // N = N + Offset
2739         uint64_t Offset = DL->getStructLayout(StTy)->getElementOffset(Field);
2740         N = DAG.getNode(ISD::ADD, dl, N.getValueType(), N,
2741                         DAG.getConstant(Offset, dl, N.getValueType()));
2742       }
2743
2744       Ty = StTy->getElementType(Field);
2745     } else {
2746       Ty = cast<SequentialType>(Ty)->getElementType();
2747       MVT PtrTy = DAG.getTargetLoweringInfo().getPointerTy(AS);
2748       unsigned PtrSize = PtrTy.getSizeInBits();
2749       APInt ElementSize(PtrSize, DL->getTypeAllocSize(Ty));
2750
2751       // If this is a constant subscript, handle it quickly.
2752       if (const auto *CI = dyn_cast<ConstantInt>(Idx)) {
2753         if (CI->isZero())
2754           continue;
2755         APInt Offs = ElementSize * CI->getValue().sextOrTrunc(PtrSize);
2756         SDValue OffsVal = DAG.getConstant(Offs, dl, PtrTy);
2757         N = DAG.getNode(ISD::ADD, dl, N.getValueType(), N, OffsVal);
2758         continue;
2759       }
2760
2761       // N = N + Idx * ElementSize;
2762       SDValue IdxN = getValue(Idx);
2763
2764       // If the index is smaller or larger than intptr_t, truncate or extend
2765       // it.
2766       IdxN = DAG.getSExtOrTrunc(IdxN, dl, N.getValueType());
2767
2768       // If this is a multiply by a power of two, turn it into a shl
2769       // immediately.  This is a very common case.
2770       if (ElementSize != 1) {
2771         if (ElementSize.isPowerOf2()) {
2772           unsigned Amt = ElementSize.logBase2();
2773           IdxN = DAG.getNode(ISD::SHL, dl,
2774                              N.getValueType(), IdxN,
2775                              DAG.getConstant(Amt, dl, IdxN.getValueType()));
2776         } else {
2777           SDValue Scale = DAG.getConstant(ElementSize, dl, IdxN.getValueType());
2778           IdxN = DAG.getNode(ISD::MUL, dl,
2779                              N.getValueType(), IdxN, Scale);
2780         }
2781       }
2782
2783       N = DAG.getNode(ISD::ADD, dl,
2784                       N.getValueType(), N, IdxN);
2785     }
2786   }
2787
2788   setValue(&I, N);
2789 }
2790
2791 void SelectionDAGBuilder::visitAlloca(const AllocaInst &I) {
2792   // If this is a fixed sized alloca in the entry block of the function,
2793   // allocate it statically on the stack.
2794   if (FuncInfo.StaticAllocaMap.count(&I))
2795     return;   // getValue will auto-populate this.
2796
2797   SDLoc dl = getCurSDLoc();
2798   Type *Ty = I.getAllocatedType();
2799   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2800   uint64_t TySize = TLI.getDataLayout()->getTypeAllocSize(Ty);
2801   unsigned Align =
2802       std::max((unsigned)TLI.getDataLayout()->getPrefTypeAlignment(Ty),
2803                I.getAlignment());
2804
2805   SDValue AllocSize = getValue(I.getArraySize());
2806
2807   EVT IntPtr = TLI.getPointerTy();
2808   if (AllocSize.getValueType() != IntPtr)
2809     AllocSize = DAG.getZExtOrTrunc(AllocSize, dl, IntPtr);
2810
2811   AllocSize = DAG.getNode(ISD::MUL, dl, IntPtr,
2812                           AllocSize,
2813                           DAG.getConstant(TySize, dl, IntPtr));
2814
2815   // Handle alignment.  If the requested alignment is less than or equal to
2816   // the stack alignment, ignore it.  If the size is greater than or equal to
2817   // the stack alignment, we note this in the DYNAMIC_STACKALLOC node.
2818   unsigned StackAlign =
2819       DAG.getSubtarget().getFrameLowering()->getStackAlignment();
2820   if (Align <= StackAlign)
2821     Align = 0;
2822
2823   // Round the size of the allocation up to the stack alignment size
2824   // by add SA-1 to the size.
2825   AllocSize = DAG.getNode(ISD::ADD, dl,
2826                           AllocSize.getValueType(), AllocSize,
2827                           DAG.getIntPtrConstant(StackAlign - 1, dl));
2828
2829   // Mask out the low bits for alignment purposes.
2830   AllocSize = DAG.getNode(ISD::AND, dl,
2831                           AllocSize.getValueType(), AllocSize,
2832                           DAG.getIntPtrConstant(~(uint64_t)(StackAlign - 1),
2833                                                 dl));
2834
2835   SDValue Ops[] = { getRoot(), AllocSize, DAG.getIntPtrConstant(Align, dl) };
2836   SDVTList VTs = DAG.getVTList(AllocSize.getValueType(), MVT::Other);
2837   SDValue DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, dl, VTs, Ops);
2838   setValue(&I, DSA);
2839   DAG.setRoot(DSA.getValue(1));
2840
2841   assert(FuncInfo.MF->getFrameInfo()->hasVarSizedObjects());
2842 }
2843
2844 void SelectionDAGBuilder::visitLoad(const LoadInst &I) {
2845   if (I.isAtomic())
2846     return visitAtomicLoad(I);
2847
2848   const Value *SV = I.getOperand(0);
2849   SDValue Ptr = getValue(SV);
2850
2851   Type *Ty = I.getType();
2852
2853   bool isVolatile = I.isVolatile();
2854   bool isNonTemporal = I.getMetadata(LLVMContext::MD_nontemporal) != nullptr;
2855
2856   // The IR notion of invariant_load only guarantees that all *non-faulting*
2857   // invariant loads result in the same value.  The MI notion of invariant load
2858   // guarantees that the load can be legally moved to any location within its
2859   // containing function.  The MI notion of invariant_load is stronger than the
2860   // IR notion of invariant_load -- an MI invariant_load is an IR invariant_load
2861   // with a guarantee that the location being loaded from is dereferenceable
2862   // throughout the function's lifetime.
2863
2864   bool isInvariant = I.getMetadata(LLVMContext::MD_invariant_load) != nullptr &&
2865     isDereferenceablePointer(SV, *DAG.getTarget().getDataLayout());
2866   unsigned Alignment = I.getAlignment();
2867
2868   AAMDNodes AAInfo;
2869   I.getAAMetadata(AAInfo);
2870   const MDNode *Ranges = I.getMetadata(LLVMContext::MD_range);
2871
2872   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2873   SmallVector<EVT, 4> ValueVTs;
2874   SmallVector<uint64_t, 4> Offsets;
2875   ComputeValueVTs(TLI, Ty, ValueVTs, &Offsets);
2876   unsigned NumValues = ValueVTs.size();
2877   if (NumValues == 0)
2878     return;
2879
2880   SDValue Root;
2881   bool ConstantMemory = false;
2882   if (isVolatile || NumValues > MaxParallelChains)
2883     // Serialize volatile loads with other side effects.
2884     Root = getRoot();
2885   else if (AA->pointsToConstantMemory(
2886              AliasAnalysis::Location(SV, AA->getTypeStoreSize(Ty), AAInfo))) {
2887     // Do not serialize (non-volatile) loads of constant memory with anything.
2888     Root = DAG.getEntryNode();
2889     ConstantMemory = true;
2890   } else {
2891     // Do not serialize non-volatile loads against each other.
2892     Root = DAG.getRoot();
2893   }
2894
2895   SDLoc dl = getCurSDLoc();
2896
2897   if (isVolatile)
2898     Root = TLI.prepareVolatileOrAtomicLoad(Root, dl, DAG);
2899
2900   SmallVector<SDValue, 4> Values(NumValues);
2901   SmallVector<SDValue, 4> Chains(std::min(unsigned(MaxParallelChains),
2902                                           NumValues));
2903   EVT PtrVT = Ptr.getValueType();
2904   unsigned ChainI = 0;
2905   for (unsigned i = 0; i != NumValues; ++i, ++ChainI) {
2906     // Serializing loads here may result in excessive register pressure, and
2907     // TokenFactor places arbitrary choke points on the scheduler. SD scheduling
2908     // could recover a bit by hoisting nodes upward in the chain by recognizing
2909     // they are side-effect free or do not alias. The optimizer should really
2910     // avoid this case by converting large object/array copies to llvm.memcpy
2911     // (MaxParallelChains should always remain as failsafe).
2912     if (ChainI == MaxParallelChains) {
2913       assert(PendingLoads.empty() && "PendingLoads must be serialized first");
2914       SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2915                                   makeArrayRef(Chains.data(), ChainI));
2916       Root = Chain;
2917       ChainI = 0;
2918     }
2919     SDValue A = DAG.getNode(ISD::ADD, dl,
2920                             PtrVT, Ptr,
2921                             DAG.getConstant(Offsets[i], dl, PtrVT));
2922     SDValue L = DAG.getLoad(ValueVTs[i], dl, Root,
2923                             A, MachinePointerInfo(SV, Offsets[i]), isVolatile,
2924                             isNonTemporal, isInvariant, Alignment, AAInfo,
2925                             Ranges);
2926
2927     Values[i] = L;
2928     Chains[ChainI] = L.getValue(1);
2929   }
2930
2931   if (!ConstantMemory) {
2932     SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2933                                 makeArrayRef(Chains.data(), ChainI));
2934     if (isVolatile)
2935       DAG.setRoot(Chain);
2936     else
2937       PendingLoads.push_back(Chain);
2938   }
2939
2940   setValue(&I, DAG.getNode(ISD::MERGE_VALUES, dl,
2941                            DAG.getVTList(ValueVTs), Values));
2942 }
2943
2944 void SelectionDAGBuilder::visitStore(const StoreInst &I) {
2945   if (I.isAtomic())
2946     return visitAtomicStore(I);
2947
2948   const Value *SrcV = I.getOperand(0);
2949   const Value *PtrV = I.getOperand(1);
2950
2951   SmallVector<EVT, 4> ValueVTs;
2952   SmallVector<uint64_t, 4> Offsets;
2953   ComputeValueVTs(DAG.getTargetLoweringInfo(), SrcV->getType(),
2954                   ValueVTs, &Offsets);
2955   unsigned NumValues = ValueVTs.size();
2956   if (NumValues == 0)
2957     return;
2958
2959   // Get the lowered operands. Note that we do this after
2960   // checking if NumResults is zero, because with zero results
2961   // the operands won't have values in the map.
2962   SDValue Src = getValue(SrcV);
2963   SDValue Ptr = getValue(PtrV);
2964
2965   SDValue Root = getRoot();
2966   SmallVector<SDValue, 4> Chains(std::min(unsigned(MaxParallelChains),
2967                                           NumValues));
2968   EVT PtrVT = Ptr.getValueType();
2969   bool isVolatile = I.isVolatile();
2970   bool isNonTemporal = I.getMetadata(LLVMContext::MD_nontemporal) != nullptr;
2971   unsigned Alignment = I.getAlignment();
2972   SDLoc dl = getCurSDLoc();
2973
2974   AAMDNodes AAInfo;
2975   I.getAAMetadata(AAInfo);
2976
2977   unsigned ChainI = 0;
2978   for (unsigned i = 0; i != NumValues; ++i, ++ChainI) {
2979     // See visitLoad comments.
2980     if (ChainI == MaxParallelChains) {
2981       SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2982                                   makeArrayRef(Chains.data(), ChainI));
2983       Root = Chain;
2984       ChainI = 0;
2985     }
2986     SDValue Add = DAG.getNode(ISD::ADD, dl, PtrVT, Ptr,
2987                               DAG.getConstant(Offsets[i], dl, PtrVT));
2988     SDValue St = DAG.getStore(Root, dl,
2989                               SDValue(Src.getNode(), Src.getResNo() + i),
2990                               Add, MachinePointerInfo(PtrV, Offsets[i]),
2991                               isVolatile, isNonTemporal, Alignment, AAInfo);
2992     Chains[ChainI] = St;
2993   }
2994
2995   SDValue StoreNode = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2996                                   makeArrayRef(Chains.data(), ChainI));
2997   DAG.setRoot(StoreNode);
2998 }
2999
3000 void SelectionDAGBuilder::visitMaskedStore(const CallInst &I) {
3001   SDLoc sdl = getCurSDLoc();
3002
3003   // llvm.masked.store.*(Src0, Ptr, alignemt, Mask)
3004   Value  *PtrOperand = I.getArgOperand(1);
3005   SDValue Ptr = getValue(PtrOperand);
3006   SDValue Src0 = getValue(I.getArgOperand(0));
3007   SDValue Mask = getValue(I.getArgOperand(3));
3008   EVT VT = Src0.getValueType();
3009   unsigned Alignment = (cast<ConstantInt>(I.getArgOperand(2)))->getZExtValue();
3010   if (!Alignment)
3011     Alignment = DAG.getEVTAlignment(VT);
3012
3013   AAMDNodes AAInfo;
3014   I.getAAMetadata(AAInfo);
3015
3016   MachineMemOperand *MMO =
3017     DAG.getMachineFunction().
3018     getMachineMemOperand(MachinePointerInfo(PtrOperand),
3019                           MachineMemOperand::MOStore,  VT.getStoreSize(),
3020                           Alignment, AAInfo);
3021   SDValue StoreNode = DAG.getMaskedStore(getRoot(), sdl, Src0, Ptr, Mask, VT,
3022                                          MMO, false);
3023   DAG.setRoot(StoreNode);
3024   setValue(&I, StoreNode);
3025 }
3026
3027 // Gather/scatter receive a vector of pointers.
3028 // This vector of pointers may be represented as a base pointer + vector of 
3029 // indices, it depends on GEP and instruction preceeding GEP
3030 // that calculates indices
3031 static bool getUniformBase(Value *& Ptr, SDValue& Base, SDValue& Index,
3032                            SelectionDAGBuilder* SDB) {
3033
3034   assert (Ptr->getType()->isVectorTy() && "Uexpected pointer type");
3035   GetElementPtrInst *Gep = dyn_cast<GetElementPtrInst>(Ptr);
3036   if (!Gep || Gep->getNumOperands() > 2)
3037     return false;
3038   ShuffleVectorInst *ShuffleInst = 
3039     dyn_cast<ShuffleVectorInst>(Gep->getPointerOperand());
3040   if (!ShuffleInst || !ShuffleInst->getMask()->isNullValue() ||
3041       cast<Instruction>(ShuffleInst->getOperand(0))->getOpcode() !=
3042       Instruction::InsertElement)
3043     return false;
3044
3045   Ptr = cast<InsertElementInst>(ShuffleInst->getOperand(0))->getOperand(1);
3046
3047   SelectionDAG& DAG = SDB->DAG;
3048   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
3049   // Check is the Ptr is inside current basic block
3050   // If not, look for the shuffle instruction
3051   if (SDB->findValue(Ptr))
3052     Base = SDB->getValue(Ptr);
3053   else if (SDB->findValue(ShuffleInst)) {
3054     SDValue ShuffleNode = SDB->getValue(ShuffleInst);
3055     SDLoc sdl = ShuffleNode;
3056     Base = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, sdl,
3057                        ShuffleNode.getValueType().getScalarType(), ShuffleNode,
3058                        DAG.getConstant(0, sdl, TLI.getVectorIdxTy()));
3059     SDB->setValue(Ptr, Base);
3060   }
3061   else
3062     return false;
3063
3064   Value *IndexVal = Gep->getOperand(1);
3065   if (SDB->findValue(IndexVal)) {
3066     Index = SDB->getValue(IndexVal);
3067
3068     if (SExtInst* Sext = dyn_cast<SExtInst>(IndexVal)) {
3069       IndexVal = Sext->getOperand(0);
3070       if (SDB->findValue(IndexVal))
3071         Index = SDB->getValue(IndexVal);
3072     }
3073     return true;
3074   }
3075   return false;
3076 }
3077
3078 void SelectionDAGBuilder::visitMaskedScatter(const CallInst &I) {
3079   SDLoc sdl = getCurSDLoc();
3080
3081   // llvm.masked.scatter.*(Src0, Ptrs, alignemt, Mask)
3082   Value  *Ptr = I.getArgOperand(1);
3083   SDValue Src0 = getValue(I.getArgOperand(0));
3084   SDValue Mask = getValue(I.getArgOperand(3));
3085   EVT VT = Src0.getValueType();
3086   unsigned Alignment = (cast<ConstantInt>(I.getArgOperand(2)))->getZExtValue();
3087   if (!Alignment)
3088     Alignment = DAG.getEVTAlignment(VT);
3089   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
3090
3091   AAMDNodes AAInfo;
3092   I.getAAMetadata(AAInfo);
3093
3094   SDValue Base;
3095   SDValue Index;
3096   Value *BasePtr = Ptr;
3097   bool UniformBase = getUniformBase(BasePtr, Base, Index, this);
3098
3099   Value *MemOpBasePtr = UniformBase ? BasePtr : nullptr;
3100   MachineMemOperand *MMO = DAG.getMachineFunction().
3101     getMachineMemOperand(MachinePointerInfo(MemOpBasePtr),
3102                          MachineMemOperand::MOStore,  VT.getStoreSize(),
3103                          Alignment, AAInfo);
3104   if (!UniformBase) {
3105     Base = DAG.getTargetConstant(0, sdl, TLI.getPointerTy());
3106     Index = getValue(Ptr);
3107   }
3108   SDValue Ops[] = { getRoot(), Src0, Mask, Base, Index };
3109   SDValue Scatter = DAG.getMaskedScatter(DAG.getVTList(MVT::Other), VT, sdl,
3110                                          Ops, MMO);
3111   DAG.setRoot(Scatter);
3112   setValue(&I, Scatter);
3113 }
3114
3115 void SelectionDAGBuilder::visitMaskedLoad(const CallInst &I) {
3116   SDLoc sdl = getCurSDLoc();
3117
3118   // @llvm.masked.load.*(Ptr, alignment, Mask, Src0)
3119   Value  *PtrOperand = I.getArgOperand(0);
3120   SDValue Ptr = getValue(PtrOperand);
3121   SDValue Src0 = getValue(I.getArgOperand(3));
3122   SDValue Mask = getValue(I.getArgOperand(2));
3123
3124   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
3125   EVT VT = TLI.getValueType(I.getType());
3126   unsigned Alignment = (cast<ConstantInt>(I.getArgOperand(1)))->getZExtValue();
3127   if (!Alignment)
3128     Alignment = DAG.getEVTAlignment(VT);
3129
3130   AAMDNodes AAInfo;
3131   I.getAAMetadata(AAInfo);
3132   const MDNode *Ranges = I.getMetadata(LLVMContext::MD_range);
3133
3134   SDValue InChain = DAG.getRoot();
3135   if (AA->pointsToConstantMemory(
3136       AliasAnalysis::Location(PtrOperand,
3137                               AA->getTypeStoreSize(I.getType()),
3138                               AAInfo))) {
3139     // Do not serialize (non-volatile) loads of constant memory with anything.
3140     InChain = DAG.getEntryNode();
3141   }
3142
3143   MachineMemOperand *MMO =
3144     DAG.getMachineFunction().
3145     getMachineMemOperand(MachinePointerInfo(PtrOperand),
3146                           MachineMemOperand::MOLoad,  VT.getStoreSize(),
3147                           Alignment, AAInfo, Ranges);
3148
3149   SDValue Load = DAG.getMaskedLoad(VT, sdl, InChain, Ptr, Mask, Src0, VT, MMO,
3150                                    ISD::NON_EXTLOAD);
3151   SDValue OutChain = Load.getValue(1);
3152   DAG.setRoot(OutChain);
3153   setValue(&I, Load);
3154 }
3155
3156 void SelectionDAGBuilder::visitMaskedGather(const CallInst &I) {
3157   SDLoc sdl = getCurSDLoc();
3158
3159   // @llvm.masked.gather.*(Ptrs, alignment, Mask, Src0)
3160   Value  *Ptr = I.getArgOperand(0);
3161   SDValue Src0 = getValue(I.getArgOperand(3));
3162   SDValue Mask = getValue(I.getArgOperand(2));
3163
3164   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
3165   EVT VT = TLI.getValueType(I.getType());
3166   unsigned Alignment = (cast<ConstantInt>(I.getArgOperand(1)))->getZExtValue();
3167   if (!Alignment)
3168     Alignment = DAG.getEVTAlignment(VT);
3169
3170   AAMDNodes AAInfo;
3171   I.getAAMetadata(AAInfo);
3172   const MDNode *Ranges = I.getMetadata(LLVMContext::MD_range);
3173
3174   SDValue Root = DAG.getRoot();
3175   SDValue Base;
3176   SDValue Index;
3177   Value *BasePtr = Ptr;
3178   bool UniformBase = getUniformBase(BasePtr, Base, Index, this);
3179   bool ConstantMemory = false;
3180   if (UniformBase && AA->pointsToConstantMemory(
3181       AliasAnalysis::Location(BasePtr,
3182                                     AA->getTypeStoreSize(I.getType()),
3183                               AAInfo))) {
3184     // Do not serialize (non-volatile) loads of constant memory with anything.
3185     Root = DAG.getEntryNode();
3186     ConstantMemory = true;
3187   }
3188
3189   MachineMemOperand *MMO =
3190     DAG.getMachineFunction().
3191     getMachineMemOperand(MachinePointerInfo(UniformBase ? BasePtr : nullptr),
3192                          MachineMemOperand::MOLoad,  VT.getStoreSize(),
3193                          Alignment, AAInfo, Ranges);
3194
3195   if (!UniformBase) {
3196     Base = DAG.getTargetConstant(0, sdl, TLI.getPointerTy());
3197     Index = getValue(Ptr);
3198   }
3199   SDValue Ops[] = { Root, Src0, Mask, Base, Index };
3200   SDValue Gather = DAG.getMaskedGather(DAG.getVTList(VT, MVT::Other), VT, sdl,
3201                                        Ops, MMO);
3202
3203   SDValue OutChain = Gather.getValue(1);
3204   if (!ConstantMemory)
3205     PendingLoads.push_back(OutChain);
3206   setValue(&I, Gather);
3207 }
3208
3209 void SelectionDAGBuilder::visitAtomicCmpXchg(const AtomicCmpXchgInst &I) {
3210   SDLoc dl = getCurSDLoc();
3211   AtomicOrdering SuccessOrder = I.getSuccessOrdering();
3212   AtomicOrdering FailureOrder = I.getFailureOrdering();
3213   SynchronizationScope Scope = I.getSynchScope();
3214
3215   SDValue InChain = getRoot();
3216
3217   MVT MemVT = getValue(I.getCompareOperand()).getSimpleValueType();
3218   SDVTList VTs = DAG.getVTList(MemVT, MVT::i1, MVT::Other);
3219   SDValue L = DAG.getAtomicCmpSwap(
3220       ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS, dl, MemVT, VTs, InChain,
3221       getValue(I.getPointerOperand()), getValue(I.getCompareOperand()),
3222       getValue(I.getNewValOperand()), MachinePointerInfo(I.getPointerOperand()),
3223       /*Alignment=*/ 0, SuccessOrder, FailureOrder, Scope);
3224
3225   SDValue OutChain = L.getValue(2);
3226
3227   setValue(&I, L);
3228   DAG.setRoot(OutChain);
3229 }