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