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