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