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