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