5f34dd24605635ce825b10fdc9ac6e478ce24af2
[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     // A dbg.value for an alloca is always indirect.
996     bool IsIndirect = isa<AllocaInst>(V) || Offset != 0;
997     SDDbgValue *SDV;
998     if (Val.getNode()) {
999       if (!EmitFuncArgumentDbgValue(V, Variable, Offset, IsIndirect, Val)) {
1000         SDV = DAG.getDbgValue(Variable, Val.getNode(),
1001                               Val.getResNo(), IsIndirect,
1002                               Offset, dl, DbgSDNodeOrder);
1003         DAG.AddDbgValue(SDV, Val.getNode(), false);
1004       }
1005     } else
1006       DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n");
1007     DanglingDebugInfoMap[V] = DanglingDebugInfo();
1008   }
1011 /// getValue - Return an SDValue for the given Value.
1012 SDValue SelectionDAGBuilder::getValue(const Value *V) {
1013   // If we already have an SDValue for this value, use it. It's important
1014   // to do this first, so that we don't create a CopyFromReg if we already
1015   // have a regular SDValue.
1016   SDValue &N = NodeMap[V];
1017   if (N.getNode()) return N;
1019   // If there's a virtual register allocated and initialized for this
1020   // value, use it.
1021   DenseMap<const Value *, unsigned>::iterator It = FuncInfo.ValueMap.find(V);
1022   if (It != FuncInfo.ValueMap.end()) {
1023     unsigned InReg = It->second;
1024     RegsForValue RFV(*DAG.getContext(), *TM.getTargetLowering(),
1025                      InReg, V->getType());
1026     SDValue Chain = DAG.getEntryNode();
1027     N = RFV.getCopyFromRegs(DAG, FuncInfo, getCurSDLoc(), Chain, nullptr, V);
1028     resolveDanglingDebugInfo(V, N);
1029     return N;
1030   }
1032   // Otherwise create a new SDValue and remember it.
1033   SDValue Val = getValueImpl(V);
1034   NodeMap[V] = Val;
1035   resolveDanglingDebugInfo(V, Val);
1036   return Val;
1039 /// getNonRegisterValue - Return an SDValue for the given Value, but
1040 /// don't look in FuncInfo.ValueMap for a virtual register.
1041 SDValue SelectionDAGBuilder::getNonRegisterValue(const Value *V) {
1042   // If we already have an SDValue for this value, use it.
1043   SDValue &N = NodeMap[V];
1044   if (N.getNode()) return N;
1046   // Otherwise create a new SDValue and remember it.
1047   SDValue Val = getValueImpl(V);
1048   NodeMap[V] = Val;
1049   resolveDanglingDebugInfo(V, Val);
1050   return Val;
1053 /// getValueImpl - Helper function for getValue and getNonRegisterValue.
1054 /// Create an SDValue for the given value.
1055 SDValue SelectionDAGBuilder::getValueImpl(const Value *V) {
1056   const TargetLowering *TLI = TM.getTargetLowering();
1058   if (const Constant *C = dyn_cast<Constant>(V)) {
1059     EVT VT = TLI->getValueType(V->getType(), true);
1061     if (const ConstantInt *CI = dyn_cast<ConstantInt>(C))
1062       return DAG.getConstant(*CI, VT);
1064     if (const GlobalValue *GV = dyn_cast<GlobalValue>(C))
1065       return DAG.getGlobalAddress(GV, getCurSDLoc(), VT);
1067     if (isa<ConstantPointerNull>(C)) {
1068       unsigned AS = V->getType()->getPointerAddressSpace();
1069       return DAG.getConstant(0, TLI->getPointerTy(AS));
1070     }
1072     if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C))
1073       return DAG.getConstantFP(*CFP, VT);
1075     if (isa<UndefValue>(C) && !V->getType()->isAggregateType())
1076       return DAG.getUNDEF(VT);
1078     if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
1079       visit(CE->getOpcode(), *CE);
1080       SDValue N1 = NodeMap[V];
1081       assert(N1.getNode() && "visit didn't populate the NodeMap!");
1082       return N1;
1083     }
1085     if (isa<ConstantStruct>(C) || isa<ConstantArray>(C)) {
1086       SmallVector<SDValue, 4> Constants;
1087       for (User::const_op_iterator OI = C->op_begin(), OE = C->op_end();
1088            OI != OE; ++OI) {
1089         SDNode *Val = getValue(*OI).getNode();
1090         // If the operand is an empty aggregate, there are no values.
1091         if (!Val) continue;
1092         // Add each leaf value from the operand to the Constants list
1093         // to form a flattened list of all the values.
1094         for (unsigned i = 0, e = Val->getNumValues(); i != e; ++i)
1095           Constants.push_back(SDValue(Val, i));
1096       }
1098       return DAG.getMergeValues(&Constants[0], Constants.size(),
1099                                 getCurSDLoc());
1100     }
1102     if (const ConstantDataSequential *CDS =
1103           dyn_cast<ConstantDataSequential>(C)) {
1104       SmallVector<SDValue, 4> Ops;
1105       for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
1106         SDNode *Val = getValue(CDS->getElementAsConstant(i)).getNode();
1107         // Add each leaf value from the operand to the Constants list
1108         // to form a flattened list of all the values.
1109         for (unsigned i = 0, e = Val->getNumValues(); i != e; ++i)
1110           Ops.push_back(SDValue(Val, i));
1111       }
1113       if (isa<ArrayType>(CDS->getType()))
1114         return DAG.getMergeValues(&Ops[0], Ops.size(), getCurSDLoc());
1115       return NodeMap[V] = DAG.getNode(ISD::BUILD_VECTOR, getCurSDLoc(),
1116                                       VT, &Ops[0], Ops.size());
1117     }
1119     if (C->getType()->isStructTy() || C->getType()->isArrayTy()) {
1120       assert((isa<ConstantAggregateZero>(C) || isa<UndefValue>(C)) &&
1121              "Unknown struct or array constant!");
1123       SmallVector<EVT, 4> ValueVTs;
1124       ComputeValueVTs(*TLI, C->getType(), ValueVTs);
1125       unsigned NumElts = ValueVTs.size();
1126       if (NumElts == 0)
1127         return SDValue(); // empty struct
1128       SmallVector<SDValue, 4> Constants(NumElts);
1129       for (unsigned i = 0; i != NumElts; ++i) {
1130         EVT EltVT = ValueVTs[i];
1131         if (isa<UndefValue>(C))
1132           Constants[i] = DAG.getUNDEF(EltVT);
1133         else if (EltVT.isFloatingPoint())
1134           Constants[i] = DAG.getConstantFP(0, EltVT);
1135         else
1136           Constants[i] = DAG.getConstant(0, EltVT);
1137       }
1139       return DAG.getMergeValues(&Constants[0], NumElts,
1140                                 getCurSDLoc());
1141     }
1143     if (const BlockAddress *BA = dyn_cast<BlockAddress>(C))
1144       return DAG.getBlockAddress(BA, VT);
1146     VectorType *VecTy = cast<VectorType>(V->getType());
1147     unsigned NumElements = VecTy->getNumElements();
1149     // Now that we know the number and type of the elements, get that number of
1150     // elements into the Ops array based on what kind of constant it is.
1151     SmallVector<SDValue, 16> Ops;
1152     if (const ConstantVector *CV = dyn_cast<ConstantVector>(C)) {
1153       for (unsigned i = 0; i != NumElements; ++i)
1154         Ops.push_back(getValue(CV->getOperand(i)));
1155     } else {
1156       assert(isa<ConstantAggregateZero>(C) && "Unknown vector constant!");
1157       EVT EltVT = TLI->getValueType(VecTy->getElementType());
1159       SDValue Op;
1160       if (EltVT.isFloatingPoint())
1161         Op = DAG.getConstantFP(0, EltVT);
1162       else
1163         Op = DAG.getConstant(0, EltVT);
1164       Ops.assign(NumElements, Op);
1165     }
1167     // Create a BUILD_VECTOR node.
1168     return NodeMap[V] = DAG.getNode(ISD::BUILD_VECTOR, getCurSDLoc(),
1169                                     VT, &Ops[0], Ops.size());
1170   }
1172   // If this is a static alloca, generate it as the frameindex instead of
1173   // computation.
1174   if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
1175     DenseMap<const AllocaInst*, int>::iterator SI =
1176       FuncInfo.StaticAllocaMap.find(AI);
1177     if (SI != FuncInfo.StaticAllocaMap.end())
1178       return DAG.getFrameIndex(SI->second, TLI->getPointerTy());
1179   }
1181   // If this is an instruction which fast-isel has deferred, select it now.
1182   if (const Instruction *Inst = dyn_cast<Instruction>(V)) {
1183     unsigned InReg = FuncInfo.InitializeRegForValue(Inst);
1184     RegsForValue RFV(*DAG.getContext(), *TLI, InReg, Inst->getType());
1185     SDValue Chain = DAG.getEntryNode();
1186     return RFV.getCopyFromRegs(DAG, FuncInfo, getCurSDLoc(), Chain, nullptr, V);
1187   }
1189   llvm_unreachable("Can't get register for value!");
1192 void SelectionDAGBuilder::visitRet(const ReturnInst &I) {
1193   const TargetLowering *TLI = TM.getTargetLowering();
1194   SDValue Chain = getControlRoot();
1195   SmallVector<ISD::OutputArg, 8> Outs;
1196   SmallVector<SDValue, 8> OutVals;
1198   if (!FuncInfo.CanLowerReturn) {
1199     unsigned DemoteReg = FuncInfo.DemoteRegister;
1200     const Function *F = I.getParent()->getParent();
1202     // Emit a store of the return value through the virtual register.
1203     // Leave Outs empty so that LowerReturn won't try to load return
1204     // registers the usual way.
1205     SmallVector<EVT, 1> PtrValueVTs;
1206     ComputeValueVTs(*TLI, PointerType::getUnqual(F->getReturnType()),
1207                     PtrValueVTs);
1209     SDValue RetPtr = DAG.getRegister(DemoteReg, PtrValueVTs[0]);
1210     SDValue RetOp = getValue(I.getOperand(0));
1212     SmallVector<EVT, 4> ValueVTs;
1213     SmallVector<uint64_t, 4> Offsets;
1214     ComputeValueVTs(*TLI, I.getOperand(0)->getType(), ValueVTs, &Offsets);
1215     unsigned NumValues = ValueVTs.size();
1217     SmallVector<SDValue, 4> Chains(NumValues);
1218     for (unsigned i = 0; i != NumValues; ++i) {
1219       SDValue Add = DAG.getNode(ISD::ADD, getCurSDLoc(),
1220                                 RetPtr.getValueType(), RetPtr,
1221                                 DAG.getIntPtrConstant(Offsets[i]));
1222       Chains[i] =
1223         DAG.getStore(Chain, getCurSDLoc(),
1224                      SDValue(RetOp.getNode(), RetOp.getResNo() + i),
1225                      // FIXME: better loc info would be nice.
1226                      Add, MachinePointerInfo(), false, false, 0);
1227     }
1229     Chain = DAG.getNode(ISD::TokenFactor, getCurSDLoc(),
1230                         MVT::Other, &Chains[0], NumValues);
1231   } else if (I.getNumOperands() != 0) {
1232     SmallVector<EVT, 4> ValueVTs;
1233     ComputeValueVTs(*TLI, I.getOperand(0)->getType(), ValueVTs);
1234     unsigned NumValues = ValueVTs.size();
1235     if (NumValues) {
1236       SDValue RetOp = getValue(I.getOperand(0));
1237       for (unsigned j = 0, f = NumValues; j != f; ++j) {
1238         EVT VT = ValueVTs[j];
1240         ISD::NodeType ExtendKind = ISD::ANY_EXTEND;
1242         const Function *F = I.getParent()->getParent();
1243         if (F->getAttributes().hasAttribute(AttributeSet::ReturnIndex,
1244                                             Attribute::SExt))
1245           ExtendKind = ISD::SIGN_EXTEND;
1246         else if (F->getAttributes().hasAttribute(AttributeSet::ReturnIndex,
1247                                                  Attribute::ZExt))
1248           ExtendKind = ISD::ZERO_EXTEND;
1250         if (ExtendKind != ISD::ANY_EXTEND && VT.isInteger())
1251           VT = TLI->getTypeForExtArgOrReturn(VT.getSimpleVT(), ExtendKind);
1253         unsigned NumParts = TLI->getNumRegisters(*DAG.getContext(), VT);
1254         MVT PartVT = TLI->getRegisterType(*DAG.getContext(), VT);
1255         SmallVector<SDValue, 4> Parts(NumParts);
1256         getCopyToParts(DAG, getCurSDLoc(),
1257                        SDValue(RetOp.getNode(), RetOp.getResNo() + j),
1258                        &Parts[0], NumParts, PartVT, &I, ExtendKind);
1260         // 'inreg' on function refers to return value
1261         ISD::ArgFlagsTy Flags = ISD::ArgFlagsTy();
1262         if (F->getAttributes().hasAttribute(AttributeSet::ReturnIndex,
1263                                             Attribute::InReg))
1264           Flags.setInReg();
1266         // Propagate extension type if any
1267         if (ExtendKind == ISD::SIGN_EXTEND)
1268           Flags.setSExt();
1269         else if (ExtendKind == ISD::ZERO_EXTEND)
1270           Flags.setZExt();
1272         for (unsigned i = 0; i < NumParts; ++i) {
1273           Outs.push_back(ISD::OutputArg(Flags, Parts[i].getValueType(),
1274                                         VT, /*isfixed=*/true, 0, 0));
1275           OutVals.push_back(Parts[i]);
1276         }
1277       }
1278     }
1279   }
1281   bool isVarArg = DAG.getMachineFunction().getFunction()->isVarArg();
1282   CallingConv::ID CallConv =
1283     DAG.getMachineFunction().getFunction()->getCallingConv();
1284   Chain = TM.getTargetLowering()->LowerReturn(Chain, CallConv, isVarArg,
1285                                               Outs, OutVals, getCurSDLoc(),
1286                                               DAG);
1288   // Verify that the target's LowerReturn behaved as expected.
1289   assert(Chain.getNode() && Chain.getValueType() == MVT::Other &&
1290          "LowerReturn didn't return a valid chain!");
1292   // Update the DAG with the new chain value resulting from return lowering.
1293   DAG.setRoot(Chain);
1296 /// CopyToExportRegsIfNeeded - If the given value has virtual registers
1297 /// created for it, emit nodes to copy the value into the virtual
1298 /// registers.
1299 void SelectionDAGBuilder::CopyToExportRegsIfNeeded(const Value *V) {
1300   // Skip empty types
1301   if (V->getType()->isEmptyTy())
1302     return;
1304   DenseMap<const Value *, unsigned>::iterator VMI = FuncInfo.ValueMap.find(V);
1305   if (VMI != FuncInfo.ValueMap.end()) {
1306     assert(!V->use_empty() && "Unused value assigned virtual registers!");
1307     CopyValueToVirtualRegister(V, VMI->second);
1308   }
1311 /// ExportFromCurrentBlock - If this condition isn't known to be exported from
1312 /// the current basic block, add it to ValueMap now so that we'll get a
1313 /// CopyTo/FromReg.
1314 void SelectionDAGBuilder::ExportFromCurrentBlock(const Value *V) {
1315   // No need to export constants.
1316   if (!isa<Instruction>(V) && !isa<Argument>(V)) return;
1318   // Already exported?
1319   if (FuncInfo.isExportedInst(V)) return;
1321   unsigned Reg = FuncInfo.InitializeRegForValue(V);
1322   CopyValueToVirtualRegister(V, Reg);
1325 bool SelectionDAGBuilder::isExportableFromCurrentBlock(const Value *V,
1326                                                      const BasicBlock *FromBB) {
1327   // The operands of the setcc have to be in this block.  We don't know
1328   // how to export them from some other block.
1329   if (const Instruction *VI = dyn_cast<Instruction>(V)) {
1330     // Can export from current BB.
1331     if (VI->getParent() == FromBB)
1332       return true;
1334     // Is already exported, noop.
1335     return FuncInfo.isExportedInst(V);
1336   }
1338   // If this is an argument, we can export it if the BB is the entry block or
1339   // if it is already exported.
1340   if (isa<Argument>(V)) {
1341     if (FromBB == &FromBB->getParent()->getEntryBlock())
1342       return true;
1344     // Otherwise, can only export this if it is already exported.
1345     return FuncInfo.isExportedInst(V);
1346   }
1348   // Otherwise, constants can always be exported.
1349   return true;
1352 /// Return branch probability calculated by BranchProbabilityInfo for IR blocks.
1353 uint32_t SelectionDAGBuilder::getEdgeWeight(const MachineBasicBlock *Src,
1354                                             const MachineBasicBlock *Dst) const {
1355   BranchProbabilityInfo *BPI = FuncInfo.BPI;
1356   if (!BPI)
1357     return 0;
1358   const BasicBlock *SrcBB = Src->getBasicBlock();
1359   const BasicBlock *DstBB = Dst->getBasicBlock();
1360   return BPI->getEdgeWeight(SrcBB, DstBB);
1363 void SelectionDAGBuilder::
1364 addSuccessorWithWeight(MachineBasicBlock *Src, MachineBasicBlock *Dst,
1365                        uint32_t Weight /* = 0 */) {
1366   if (!Weight)
1367     Weight = getEdgeWeight(Src, Dst);
1368   Src->addSuccessor(Dst, Weight);
1372 static bool InBlock(const Value *V, const BasicBlock *BB) {
1373   if (const Instruction *I = dyn_cast<Instruction>(V))
1374     return I->getParent() == BB;
1375   return true;
1378 /// EmitBranchForMergedCondition - Helper method for FindMergedConditions.
1379 /// This function emits a branch and is used at the leaves of an OR or an
1380 /// AND operator tree.
1381 ///
1382 void
1383 SelectionDAGBuilder::EmitBranchForMergedCondition(const Value *Cond,
1384                                                   MachineBasicBlock *TBB,
1385                                                   MachineBasicBlock *FBB,
1386                                                   MachineBasicBlock *CurBB,
1387                                                   MachineBasicBlock *SwitchBB,
1388                                                   uint32_t TWeight,
1389                                                   uint32_t FWeight) {
1390   const BasicBlock *BB = CurBB->getBasicBlock();
1392   // If the leaf of the tree is a comparison, merge the condition into
1393   // the caseblock.
1394   if (const CmpInst *BOp = dyn_cast<CmpInst>(Cond)) {
1395     // The operands of the cmp have to be in this block.  We don't know
1396     // how to export them from some other block.  If this is the first block
1397     // of the sequence, no exporting is needed.
1398     if (CurBB == SwitchBB ||
1399         (isExportableFromCurrentBlock(BOp->getOperand(0), BB) &&
1400          isExportableFromCurrentBlock(BOp->getOperand(1), BB))) {
1401       ISD::CondCode Condition;
1402       if (const ICmpInst *IC = dyn_cast<ICmpInst>(Cond)) {
1403         Condition = getICmpCondCode(IC->getPredicate());
1404       } else if (const FCmpInst *FC = dyn_cast<FCmpInst>(Cond)) {
1405         Condition = getFCmpCondCode(FC->getPredicate());
1406         if (TM.Options.NoNaNsFPMath)
1407           Condition = getFCmpCodeWithoutNaN(Condition);
1408       } else {
1409         Condition = ISD::SETEQ; // silence warning.
1410         llvm_unreachable("Unknown compare instruction");
1411       }
1413       CaseBlock CB(Condition, BOp->getOperand(0), BOp->getOperand(1), nullptr,
1414                    TBB, FBB, CurBB, TWeight, FWeight);
1415       SwitchCases.push_back(CB);
1416       return;
1417     }
1418   }
1420   // Create a CaseBlock record representing this branch.
1421   CaseBlock CB(ISD::SETEQ, Cond, ConstantInt::getTrue(*DAG.getContext()),
1422                nullptr, TBB, FBB, CurBB, TWeight, FWeight);
1423   SwitchCases.push_back(CB);
1426 /// Scale down both weights to fit into uint32_t.
1427 static void ScaleWeights(uint64_t &NewTrue, uint64_t &NewFalse) {
1428   uint64_t NewMax = (NewTrue > NewFalse) ? NewTrue : NewFalse;
1429   uint32_t Scale = (NewMax / UINT32_MAX) + 1;
1430   NewTrue = NewTrue / Scale;
1431   NewFalse = NewFalse / Scale;
1434 /// FindMergedConditions - If Cond is an expression like
1435 void SelectionDAGBuilder::FindMergedConditions(const Value *Cond,
1436                                                MachineBasicBlock *TBB,
1437                                                MachineBasicBlock *FBB,
1438                                                MachineBasicBlock *CurBB,
1439                                                MachineBasicBlock *SwitchBB,
1440                                                unsigned Opc, uint32_t TWeight,
1441                                                uint32_t FWeight) {
1442   // If this node is not part of the or/and tree, emit it as a branch.
1443   const Instruction *BOp = dyn_cast<Instruction>(Cond);
1444   if (!BOp || !(isa<BinaryOperator>(BOp) || isa<CmpInst>(BOp)) ||
1445       (unsigned)BOp->getOpcode() != Opc || !BOp->hasOneUse() ||
1446       BOp->getParent() != CurBB->getBasicBlock() ||
1447       !InBlock(BOp->getOperand(0), CurBB->getBasicBlock()) ||
1448       !InBlock(BOp->getOperand(1), CurBB->getBasicBlock())) {
1449     EmitBranchForMergedCondition(Cond, TBB, FBB, CurBB, SwitchBB,
1450                                  TWeight, FWeight);
1451     return;
1452   }
1454   //  Create TmpBB after CurBB.
1455   MachineFunction::iterator BBI = CurBB;
1456   MachineFunction &MF = DAG.getMachineFunction();
1457   MachineBasicBlock *TmpBB = MF.CreateMachineBasicBlock(CurBB->getBasicBlock());
1458   CurBB->getParent()->insert(++BBI, TmpBB);
1460   if (Opc == Instruction::Or) {
1461     // Codegen X | Y as:
1462     // BB1:
1463     //   jmp_if_X TBB
1464     //   jmp TmpBB
1465     // TmpBB:
1466     //   jmp_if_Y TBB
1467     //   jmp FBB
1468     //
1470     // We have flexibility in setting Prob for BB1 and Prob for TmpBB.
1471     // The requirement is that
1472     //   TrueProb for BB1 + (FalseProb for BB1 * TrueProb for TmpBB)
1473     //     = TrueProb for orignal BB.
1474     // Assuming the orignal weights are A and B, one choice is to set BB1's
1475     // weights to A and A+2B, and set TmpBB's weights to A and 2B. This choice
1476     // assumes that
1477     //   TrueProb for BB1 == FalseProb for BB1 * TrueProb for TmpBB.
1478     // Another choice is to assume TrueProb for BB1 equals to TrueProb for
1479     // TmpBB, but the math is more complicated.
1481     uint64_t NewTrueWeight = TWeight;
1482     uint64_t NewFalseWeight = (uint64_t)TWeight + 2 * (uint64_t)FWeight;
1483     ScaleWeights(NewTrueWeight, NewFalseWeight);
1484     // Emit the LHS condition.
1485     FindMergedConditions(BOp->getOperand(0), TBB, TmpBB, CurBB, SwitchBB, Opc,
1486                          NewTrueWeight, NewFalseWeight);
1488     NewTrueWeight = TWeight;
1489     NewFalseWeight = 2 * (uint64_t)FWeight;
1490     ScaleWeights(NewTrueWeight, NewFalseWeight);
1491     // Emit the RHS condition into TmpBB.
1492     FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, SwitchBB, Opc,
1493                          NewTrueWeight, NewFalseWeight);
1494   } else {
1495     assert(Opc == Instruction::And && "Unknown merge op!");
1496     // Codegen X & Y as:
1497     // BB1:
1498     //   jmp_if_X TmpBB
1499     //   jmp FBB
1500     // TmpBB:
1501     //   jmp_if_Y TBB
1502     //   jmp FBB
1503     //
1504     //  This requires creation of TmpBB after CurBB.
1506     // We have flexibility in setting Prob for BB1 and Prob for TmpBB.
1507     // The requirement is that
1508     //   FalseProb for BB1 + (TrueProb for BB1 * FalseProb for TmpBB)
1509     //     = FalseProb for orignal BB.
1510     // Assuming the orignal weights are A and B, one choice is to set BB1's
1511     // weights to 2A+B and B, and set TmpBB's weights to 2A and B. This choice
1512     // assumes that
1513     //   FalseProb for BB1 == TrueProb for BB1 * FalseProb for TmpBB.
1515     uint64_t NewTrueWeight = 2 * (uint64_t)TWeight + (uint64_t)FWeight;
1516     uint64_t NewFalseWeight = FWeight;
1517     ScaleWeights(NewTrueWeight, NewFalseWeight);
1518     // Emit the LHS condition.
1519     FindMergedConditions(BOp->getOperand(0), TmpBB, FBB, CurBB, SwitchBB, Opc,
1520                          NewTrueWeight, NewFalseWeight);
1522     NewTrueWeight = 2 * (uint64_t)TWeight;
1523     NewFalseWeight = FWeight;
1524     ScaleWeights(NewTrueWeight, NewFalseWeight);
1525     // Emit the RHS condition into TmpBB.
1526     FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, SwitchBB, Opc,
1527                          NewTrueWeight, NewFalseWeight);
1528   }
1531 /// If the set of cases should be emitted as a series of branches, return true.
1532 /// If we should emit this as a bunch of and/or'd together conditions, return
1533 /// false.
1534 bool
1535 SelectionDAGBuilder::ShouldEmitAsBranches(const std::vector<CaseBlock> &Cases) {
1536   if (Cases.size() != 2) return true;
1538   // If this is two comparisons of the same values or'd or and'd together, they
1539   // will get folded into a single comparison, so don't emit two blocks.
1540   if ((Cases[0].CmpLHS == Cases[1].CmpLHS &&
1541        Cases[0].CmpRHS == Cases[1].CmpRHS) ||
1542       (Cases[0].CmpRHS == Cases[1].CmpLHS &&
1543        Cases[0].CmpLHS == Cases[1].CmpRHS)) {
1544     return false;
1545   }
1547   // Handle: (X != null) | (Y != null) --> (X|Y) != 0
1548   // Handle: (X == null) & (Y == null) --> (X|Y) == 0
1549   if (Cases[0].CmpRHS == Cases[1].CmpRHS &&
1550       Cases[0].CC == Cases[1].CC &&
1551       isa<Constant>(Cases[0].CmpRHS) &&
1552       cast<Constant>(Cases[0].CmpRHS)->isNullValue()) {
1553     if (Cases[0].CC == ISD::SETEQ && Cases[0].TrueBB == Cases[1].ThisBB)
1554       return false;
1555     if (Cases[0].CC == ISD::SETNE && Cases[0].FalseBB == Cases[1].ThisBB)
1556       return false;
1557   }
1559   return true;
1562 void SelectionDAGBuilder::visitBr(const BranchInst &I) {
1563   MachineBasicBlock *BrMBB = FuncInfo.MBB;
1565   // Update machine-CFG edges.
1566   MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)];
1568   // Figure out which block is immediately after the current one.
1569   MachineBasicBlock *NextBlock = nullptr;
1570   MachineFunction::iterator BBI = BrMBB;
1571   if (++BBI != FuncInfo.MF->end())
1572     NextBlock = BBI;
1574   if (I.isUnconditional()) {
1575     // Update machine-CFG edges.
1576     BrMBB->addSuccessor(Succ0MBB);
1578     // If this is not a fall-through branch or optimizations are switched off,
1579     // emit the branch.
1580     if (Succ0MBB != NextBlock || TM.getOptLevel() == CodeGenOpt::None)
1581       DAG.setRoot(DAG.getNode(ISD::BR, getCurSDLoc(),
1582                               MVT::Other, getControlRoot(),
1583                               DAG.getBasicBlock(Succ0MBB)));
1585     return;
1586   }
1588   // If this condition is one of the special cases we handle, do special stuff
1589   // now.
1590   const Value *CondVal = I.getCondition();
1591   MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)];
1593   // If this is a series of conditions that are or'd or and'd together, emit
1594   // this as a sequence of branches instead of setcc's with and/or operations.
1595   // As long as jumps are not expensive, this should improve performance.
1596   // For example, instead of something like:
1597   //     cmp A, B
1598   //     C = seteq
1599   //     cmp D, E
1600   //     F = setle
1601   //     or C, F
1602   //     jnz foo
1603   // Emit:
1604   //     cmp A, B
1605   //     je foo
1606   //     cmp D, E
1607   //     jle foo
1608   //
1609   if (const BinaryOperator *BOp = dyn_cast<BinaryOperator>(CondVal)) {
1610     if (!TM.getTargetLowering()->isJumpExpensive() &&
1611         BOp->hasOneUse() &&
1612         (BOp->getOpcode() == Instruction::And ||
1613          BOp->getOpcode() == Instruction::Or)) {
1614       FindMergedConditions(BOp, Succ0MBB, Succ1MBB, BrMBB, BrMBB,
1615                            BOp->getOpcode(), getEdgeWeight(BrMBB, Succ0MBB),
1616                            getEdgeWeight(BrMBB, Succ1MBB));
1617       // If the compares in later blocks need to use values not currently
1618       // exported from this block, export them now.  This block should always
1619       // be the first entry.
1620       assert(SwitchCases[0].ThisBB == BrMBB && "Unexpected lowering!");
1622       // Allow some cases to be rejected.
1623       if (ShouldEmitAsBranches(SwitchCases)) {
1624         for (unsigned i = 1, e = SwitchCases.size(); i != e; ++i) {
1625           ExportFromCurrentBlock(SwitchCases[i].CmpLHS);
1626           ExportFromCurrentBlock(SwitchCases[i].CmpRHS);
1627         }
1629         // Emit the branch for this block.
1630         visitSwitchCase(SwitchCases[0], BrMBB);
1631         SwitchCases.erase(SwitchCases.begin());
1632         return;
1633       }
1635       // Okay, we decided not to do this, remove any inserted MBB's and clear
1636       // SwitchCases.
1637       for (unsigned i = 1, e = SwitchCases.size(); i != e; ++i)
1638         FuncInfo.MF->erase(SwitchCases[i].ThisBB);
1640       SwitchCases.clear();
1641     }
1642   }
1644   // Create a CaseBlock record representing this branch.
1645   CaseBlock CB(ISD::SETEQ, CondVal, ConstantInt::getTrue(*DAG.getContext()),
1646                nullptr, Succ0MBB, Succ1MBB, BrMBB);
1648   // Use visitSwitchCase to actually insert the fast branch sequence for this
1649   // cond branch.
1650   visitSwitchCase(CB, BrMBB);
1653 /// visitSwitchCase - Emits the necessary code to represent a single node in
1654 /// the binary search tree resulting from lowering a switch instruction.
1655 void SelectionDAGBuilder::visitSwitchCase(CaseBlock &CB,
1656                                           MachineBasicBlock *SwitchBB) {
1657   SDValue Cond;
1658   SDValue CondLHS = getValue(CB.CmpLHS);
1659   SDLoc dl = getCurSDLoc();
1661   // Build the setcc now.
1662   if (!CB.CmpMHS) {
1663     // Fold "(X == true)" to X and "(X == false)" to !X to
1664     // handle common cases produced by branch lowering.
1665     if (CB.CmpRHS == ConstantInt::getTrue(*DAG.getContext()) &&
1666         CB.CC == ISD::SETEQ)
1667       Cond = CondLHS;
1668     else if (CB.CmpRHS == ConstantInt::getFalse(*DAG.getContext()) &&
1669              CB.CC == ISD::SETEQ) {
1670       SDValue True = DAG.getConstant(1, CondLHS.getValueType());
1671       Cond = DAG.getNode(ISD::XOR, dl, CondLHS.getValueType(), CondLHS, True);
1672     } else
1673       Cond = DAG.getSetCC(dl, MVT::i1, CondLHS, getValue(CB.CmpRHS), CB.CC);
1674   } else {
1675     assert(CB.CC == ISD::SETLE && "Can handle only LE ranges now");
1677     const APInt& Low = cast<ConstantInt>(CB.CmpLHS)->getValue();
1678     const APInt& High  = cast<ConstantInt>(CB.CmpRHS)->getValue();
1680     SDValue CmpOp = getValue(CB.CmpMHS);
1681     EVT VT = CmpOp.getValueType();
1683     if (cast<ConstantInt>(CB.CmpLHS)->isMinValue(true)) {
1684       Cond = DAG.getSetCC(dl, MVT::i1, CmpOp, DAG.getConstant(High, VT),
1685                           ISD::SETLE);
1686     } else {
1687       SDValue SUB = DAG.getNode(ISD::SUB, dl,
1688                                 VT, CmpOp, DAG.getConstant(Low, VT));
1689       Cond = DAG.getSetCC(dl, MVT::i1, SUB,
1690                           DAG.getConstant(High-Low, VT), ISD::SETULE);
1691     }
1692   }
1694   // Update successor info
1695   addSuccessorWithWeight(SwitchBB, CB.TrueBB, CB.TrueWeight);
1696   // TrueBB and FalseBB are always different unless the incoming IR is
1697   // degenerate. This only happens when running llc on weird IR.
1698   if (CB.TrueBB != CB.FalseBB)
1699     addSuccessorWithWeight(SwitchBB, CB.FalseBB, CB.FalseWeight);
1701   // Set NextBlock to be the MBB immediately after the current one, if any.
1702   // This is used to avoid emitting unnecessary branches to the next block.
1703   MachineBasicBlock *NextBlock = nullptr;
1704   MachineFunction::iterator BBI = SwitchBB;
1705   if (++BBI != FuncInfo.MF->end())
1706     NextBlock = BBI;
1708   // If the lhs block is the next block, invert the condition so that we can
1709   // fall through to the lhs instead of the rhs block.
1710   if (CB.TrueBB == NextBlock) {
1711     std::swap(CB.TrueBB, CB.FalseBB);
1712     SDValue True = DAG.getConstant(1, Cond.getValueType());
1713     Cond = DAG.getNode(ISD::XOR, dl, Cond.getValueType(), Cond, True);
1714   }
1716   SDValue BrCond = DAG.getNode(ISD::BRCOND, dl,
1717                                MVT::Other, getControlRoot(), Cond,
1718                                DAG.getBasicBlock(CB.TrueBB));
1720   // Insert the false branch. Do this even if it's a fall through branch,
1721   // this makes it easier to do DAG optimizations which require inverting
1722   // the branch condition.
1723   BrCond = DAG.getNode(ISD::BR, dl, MVT::Other, BrCond,
1724                        DAG.getBasicBlock(CB.FalseBB));
1726   DAG.setRoot(BrCond);
1729 /// visitJumpTable - Emit JumpTable node in the current MBB
1730 void SelectionDAGBuilder::visitJumpTable(JumpTable &JT) {
1731   // Emit the code for the jump table
1732   assert(JT.Reg != -1U && "Should lower JT Header first!");
1733   EVT PTy = TM.getTargetLowering()->getPointerTy();
1734   SDValue Index = DAG.getCopyFromReg(getControlRoot(), getCurSDLoc(),
1735                                      JT.Reg, PTy);
1736   SDValue Table = DAG.getJumpTable(JT.JTI, PTy);
1737   SDValue BrJumpTable = DAG.getNode(ISD::BR_JT, getCurSDLoc(),
1738                                     MVT::Other, Index.getValue(1),
1739                                     Table, Index);
1740   DAG.setRoot(BrJumpTable);
1743 /// visitJumpTableHeader - This function emits necessary code to produce index
1744 /// in the JumpTable from switch case.
1745 void SelectionDAGBuilder::visitJumpTableHeader(JumpTable &JT,
1746                                                JumpTableHeader &JTH,
1747                                                MachineBasicBlock *SwitchBB) {
1748   // Subtract the lowest switch case value from the value being switched on and
1749   // conditional branch to default mbb if the result is greater than the
1750   // difference between smallest and largest cases.
1751   SDValue SwitchOp = getValue(JTH.SValue);
1752   EVT VT = SwitchOp.getValueType();
1753   SDValue Sub = DAG.getNode(ISD::SUB, getCurSDLoc(), VT, SwitchOp,
1754                             DAG.getConstant(JTH.First, VT));
1756   // The SDNode we just created, which holds the value being switched on minus
1757   // the smallest case value, needs to be copied to a virtual register so it
1758   // can be used as an index into the jump table in a subsequent basic block.
1759   // This value may be smaller or larger than the target's pointer type, and
1760   // therefore require extension or truncating.
1761   const TargetLowering *TLI = TM.getTargetLowering();
1762   SwitchOp = DAG.getZExtOrTrunc(Sub, getCurSDLoc(), TLI->getPointerTy());
1764   unsigned JumpTableReg = FuncInfo.CreateReg(TLI->getPointerTy());
1765   SDValue CopyTo = DAG.getCopyToReg(getControlRoot(), getCurSDLoc(),
1766                                     JumpTableReg, SwitchOp);
1767   JT.Reg = JumpTableReg;
1769   // Emit the range check for the jump table, and branch to the default block
1770   // for the switch statement if the value being switched on exceeds the largest
1771   // case in the switch.
1772   SDValue CMP = DAG.getSetCC(getCurSDLoc(),
1773                              TLI->getSetCCResultType(*DAG.getContext(),
1774                                                      Sub.getValueType()),
1775                              Sub,
1776                              DAG.getConstant(JTH.Last - JTH.First,VT),
1777                              ISD::SETUGT);
1779   // Set NextBlock to be the MBB immediately after the current one, if any.
1780   // This is used to avoid emitting unnecessary branches to the next block.
1781   MachineBasicBlock *NextBlock = nullptr;
1782   MachineFunction::iterator BBI = SwitchBB;
1784   if (++BBI != FuncInfo.MF->end())
1785     NextBlock = BBI;
1787   SDValue BrCond = DAG.getNode(ISD::BRCOND, getCurSDLoc(),
1788                                MVT::Other, CopyTo, CMP,
1789                                DAG.getBasicBlock(JT.Default));
1791   if (JT.MBB != NextBlock)
1792     BrCond = DAG.getNode(ISD::BR, getCurSDLoc(), MVT::Other, BrCond,
1793                          DAG.getBasicBlock(JT.MBB));
1795   DAG.setRoot(BrCond);
1798 /// Codegen a new tail for a stack protector check ParentMBB which has had its
1799 /// tail spliced into a stack protector check success bb.
1800 ///
1801 /// For a high level explanation of how this fits into the stack protector
1802 /// generation see the comment on the declaration of class
1803 /// StackProtectorDescriptor.
1804 void SelectionDAGBuilder::visitSPDescriptorParent(StackProtectorDescriptor &SPD,
1805                                                   MachineBasicBlock *ParentBB) {
1807   // First create the loads to the guard/stack slot for the comparison.
1808   const TargetLowering *TLI = TM.getTargetLowering();
1809   EVT PtrTy = TLI->getPointerTy();
1811   MachineFrameInfo *MFI = ParentBB->getParent()->getFrameInfo();
1812   int FI = MFI->getStackProtectorIndex();
1814   const Value *IRGuard = SPD.getGuard();
1815   SDValue GuardPtr = getValue(IRGuard);
1816   SDValue StackSlotPtr = DAG.getFrameIndex(FI, PtrTy);
1818   unsigned Align =
1819     TLI->getDataLayout()->getPrefTypeAlignment(IRGuard->getType());
1820   SDValue Guard = DAG.getLoad(PtrTy, getCurSDLoc(), DAG.getEntryNode(),
1821                               GuardPtr, MachinePointerInfo(IRGuard, 0),
1822                               true, false, false, Align);
1824   SDValue StackSlot = DAG.getLoad(PtrTy, getCurSDLoc(), DAG.getEntryNode(),
1825                                   StackSlotPtr,
1826                                   MachinePointerInfo::getFixedStack(FI),
1827                                   true, false, false, Align);
1829   // Perform the comparison via a subtract/getsetcc.
1830   EVT VT = Guard.getValueType();
1831   SDValue Sub = DAG.getNode(ISD::SUB, getCurSDLoc(), VT, Guard, StackSlot);
1833   SDValue Cmp = DAG.getSetCC(getCurSDLoc(),
1834                              TLI->getSetCCResultType(*DAG.getContext(),
1835                                                      Sub.getValueType()),
1836                              Sub, DAG.getConstant(0, VT),
1837                              ISD::SETNE);
1839   // If the sub is not 0, then we know the guard/stackslot do not equal, so
1840   // branch to failure MBB.
1841   SDValue BrCond = DAG.getNode(ISD::BRCOND, getCurSDLoc(),
1842                                MVT::Other, StackSlot.getOperand(0),
1843                                Cmp, DAG.getBasicBlock(SPD.getFailureMBB()));
1844   // Otherwise branch to success MBB.
1845   SDValue Br = DAG.getNode(ISD::BR, getCurSDLoc(),
1846                            MVT::Other, BrCond,
1847                            DAG.getBasicBlock(SPD.getSuccessMBB()));
1849   DAG.setRoot(Br);
1852 /// Codegen the failure basic block for a stack protector check.
1853 ///
1854 /// A failure stack protector machine basic block consists simply of a call to
1855 /// __stack_chk_fail().
1856 ///
1857 /// For a high level explanation of how this fits into the stack protector
1858 /// generation see the comment on the declaration of class
1859 /// StackProtectorDescriptor.
1860 void
1861 SelectionDAGBuilder::visitSPDescriptorFailure(StackProtectorDescriptor &SPD) {
1862   const TargetLowering *TLI = TM.getTargetLowering();
1863   SDValue Chain = TLI->makeLibCall(DAG, RTLIB::STACKPROTECTOR_CHECK_FAIL,
1864                                    MVT::isVoid, nullptr, 0, false,
1865                                    getCurSDLoc(), false, false).second;
1866   DAG.setRoot(Chain);
1869 /// visitBitTestHeader - This function emits necessary code to produce value
1870 /// suitable for "bit tests"
1871 void SelectionDAGBuilder::visitBitTestHeader(BitTestBlock &B,
1872                                              MachineBasicBlock *SwitchBB) {
1873   // Subtract the minimum value
1874   SDValue SwitchOp = getValue(B.SValue);
1875   EVT VT = SwitchOp.getValueType();
1876   SDValue Sub = DAG.getNode(ISD::SUB, getCurSDLoc(), VT, SwitchOp,
1877                             DAG.getConstant(B.First, VT));
1879   // Check range
1880   const TargetLowering *TLI = TM.getTargetLowering();
1881   SDValue RangeCmp = DAG.getSetCC(getCurSDLoc(),
1882                                   TLI->getSetCCResultType(*DAG.getContext(),
1883                                                          Sub.getValueType()),
1884                                   Sub, DAG.getConstant(B.Range, VT),
1885                                   ISD::SETUGT);
1887   // Determine the type of the test operands.
1888   bool UsePtrType = false;
1889   if (!TLI->isTypeLegal(VT))
1890     UsePtrType = true;
1891   else {
1892     for (unsigned i = 0, e = B.Cases.size(); i != e; ++i)
1893       if (!isUIntN(VT.getSizeInBits(), B.Cases[i].Mask)) {
1894         // Switch table case range are encoded into series of masks.
1895         // Just use pointer type, it's guaranteed to fit.
1896         UsePtrType = true;
1897         break;
1898       }
1899   }
1900   if (UsePtrType) {
1901     VT = TLI->getPointerTy();
1902     Sub = DAG.getZExtOrTrunc(Sub, getCurSDLoc(), VT);
1903   }
1905   B.RegVT = VT.getSimpleVT();
1906   B.Reg = FuncInfo.CreateReg(B.RegVT);
1907   SDValue CopyTo = DAG.getCopyToReg(getControlRoot(), getCurSDLoc(),
1908                                     B.Reg, Sub);
1910   // Set NextBlock to be the MBB immediately after the current one, if any.
1911   // This is used to avoid emitting unnecessary branches to the next block.
1912   MachineBasicBlock *NextBlock = nullptr;
1913   MachineFunction::iterator BBI = SwitchBB;
1914   if (++BBI != FuncInfo.MF->end())
1915     NextBlock = BBI;
1917   MachineBasicBlock* MBB = B.Cases[0].ThisBB;
1919   addSuccessorWithWeight(SwitchBB, B.Default);
1920   addSuccessorWithWeight(SwitchBB, MBB);
1922   SDValue BrRange = DAG.getNode(ISD::BRCOND, getCurSDLoc(),
1923                                 MVT::Other, CopyTo, RangeCmp,
1924                                 DAG.getBasicBlock(B.Default));
1926   if (MBB != NextBlock)
1927     BrRange = DAG.getNode(ISD::BR, getCurSDLoc(), MVT::Other, CopyTo,
1928                           DAG.getBasicBlock(MBB));
1930   DAG.setRoot(BrRange);
1933 /// visitBitTestCase - this function produces one "bit test"
1934 void SelectionDAGBuilder::visitBitTestCase(BitTestBlock &BB,
1935                                            MachineBasicBlock* NextMBB,
1936                                            uint32_t BranchWeightToNext,
1937                                            unsigned Reg,
1938                                            BitTestCase &B,
1939                                            MachineBasicBlock *SwitchBB) {
1940   MVT VT = BB.RegVT;
1941   SDValue ShiftOp = DAG.getCopyFromReg(getControlRoot(), getCurSDLoc(),
1942                                        Reg, VT);
1943   SDValue Cmp;
1944   unsigned PopCount = CountPopulation_64(B.Mask);
1945   const TargetLowering *TLI = TM.getTargetLowering();
1946   if (PopCount == 1) {
1947     // Testing for a single bit; just compare the shift count with what it
1948     // would need to be to shift a 1 bit in that position.
1949     Cmp = DAG.getSetCC(getCurSDLoc(),
1950                        TLI->getSetCCResultType(*DAG.getContext(), VT),
1951                        ShiftOp,
1952                        DAG.getConstant(countTrailingZeros(B.Mask), VT),
1953                        ISD::SETEQ);
1954   } else if (PopCount == BB.Range) {
1955     // There is only one zero bit in the range, test for it directly.
1956     Cmp = DAG.getSetCC(getCurSDLoc(),
1957                        TLI->getSetCCResultType(*DAG.getContext(), VT),
1958                        ShiftOp,
1959                        DAG.getConstant(CountTrailingOnes_64(B.Mask), VT),
1960                        ISD::SETNE);
1961   } else {
1962     // Make desired shift
1963     SDValue SwitchVal = DAG.getNode(ISD::SHL, getCurSDLoc(), VT,
1964                                     DAG.getConstant(1, VT), ShiftOp);
1966     // Emit bit tests and jumps
1967     SDValue AndOp = DAG.getNode(ISD::AND, getCurSDLoc(),
1968                                 VT, SwitchVal, DAG.getConstant(B.Mask, VT));
1969     Cmp = DAG.getSetCC(getCurSDLoc(),
1970                        TLI->getSetCCResultType(*DAG.getContext(), VT),
1971                        AndOp, DAG.getConstant(0, VT),
1972                        ISD::SETNE);
1973   }
1975   // The branch weight from SwitchBB to B.TargetBB is B.ExtraWeight.
1976   addSuccessorWithWeight(SwitchBB, B.TargetBB, B.ExtraWeight);
1977   // The branch weight from SwitchBB to NextMBB is BranchWeightToNext.
1978   addSuccessorWithWeight(SwitchBB, NextMBB, BranchWeightToNext);
1980   SDValue BrAnd = DAG.getNode(ISD::BRCOND, getCurSDLoc(),
1981                               MVT::Other, getControlRoot(),
1982                               Cmp, DAG.getBasicBlock(B.TargetBB));
1984   // Set NextBlock to be the MBB immediately after the current one, if any.
1985   // This is used to avoid emitting unnecessary branches to the next block.
1986   MachineBasicBlock *NextBlock = nullptr;
1987   MachineFunction::iterator BBI = SwitchBB;
1988   if (++BBI != FuncInfo.MF->end())
1989     NextBlock = BBI;
1991   if (NextMBB != NextBlock)
1992     BrAnd = DAG.getNode(ISD::BR, getCurSDLoc(), MVT::Other, BrAnd,
1993                         DAG.getBasicBlock(NextMBB));
1995   DAG.setRoot(BrAnd);
1998 void SelectionDAGBuilder::visitInvoke(const InvokeInst &I) {
1999   MachineBasicBlock *InvokeMBB = FuncInfo.MBB;
2001   // Retrieve successors.
2002   MachineBasicBlock *Return = FuncInfo.MBBMap[I.getSuccessor(0)];
2003   MachineBasicBlock *LandingPad = FuncInfo.MBBMap[I.getSuccessor(1)];
2005   const Value *Callee(I.getCalledValue());
2006   const Function *Fn = dyn_cast<Function>(Callee);
2007   if (isa<InlineAsm>(Callee))
2008     visitInlineAsm(&I);
2009   else if (Fn && Fn->isIntrinsic()) {
2010     assert(Fn->getIntrinsicID() == Intrinsic::donothing);
2011     // Ignore invokes to @llvm.donothing: jump directly to the next BB.
2012   } else
2013     LowerCallTo(&I, getValue(Callee), false, LandingPad);
2015   // If the value of the invoke is used outside of its defining block, make it
2016   // available as a virtual register.
2017   CopyToExportRegsIfNeeded(&I);
2019   // Update successor info
2020   addSuccessorWithWeight(InvokeMBB, Return);
2021   addSuccessorWithWeight(InvokeMBB, LandingPad);
2023   // Drop into normal successor.
2024   DAG.setRoot(DAG.getNode(ISD::BR, getCurSDLoc(),
2025                           MVT::Other, getControlRoot(),
2026                           DAG.getBasicBlock(Return)));
2029 void SelectionDAGBuilder::visitResume(const ResumeInst &RI) {
2030   llvm_unreachable("SelectionDAGBuilder shouldn't visit resume instructions!");
2033 void SelectionDAGBuilder::visitLandingPad(const LandingPadInst &LP) {
2034   assert(FuncInfo.MBB->isLandingPad() &&
2035          "Call to landingpad not in landing pad!");
2037   MachineBasicBlock *MBB = FuncInfo.MBB;
2038   MachineModuleInfo &MMI = DAG.getMachineFunction().getMMI();
2039   AddLandingPadInfo(LP, MMI, MBB);
2041   // If there aren't registers to copy the values into (e.g., during SjLj
2042   // exceptions), then don't bother to create these DAG nodes.
2043   const TargetLowering *TLI = TM.getTargetLowering();
2044   if (TLI->getExceptionPointerRegister() == 0 &&
2045       TLI->getExceptionSelectorRegister() == 0)
2046     return;
2048   SmallVector<EVT, 2> ValueVTs;
2049   ComputeValueVTs(*TLI, LP.getType(), ValueVTs);
2050   assert(ValueVTs.size() == 2 && "Only two-valued landingpads are supported");
2052   // Get the two live-in registers as SDValues. The physregs have already been
2053   // copied into virtual registers.
2054   SDValue Ops[2];
2055   Ops[0] = DAG.getZExtOrTrunc(
2056     DAG.getCopyFromReg(DAG.getEntryNode(), getCurSDLoc(),
2057                        FuncInfo.ExceptionPointerVirtReg, TLI->getPointerTy()),
2058     getCurSDLoc(), ValueVTs[0]);
2059   Ops[1] = DAG.getZExtOrTrunc(
2060     DAG.getCopyFromReg(DAG.getEntryNode(), getCurSDLoc(),
2061                        FuncInfo.ExceptionSelectorVirtReg, TLI->getPointerTy()),
2062     getCurSDLoc(), ValueVTs[1]);
2064   // Merge into one.
2065   SDValue Res = DAG.getNode(ISD::MERGE_VALUES, getCurSDLoc(),
2066                             DAG.getVTList(ValueVTs),
2067                             &Ops[0], 2);
2068   setValue(&LP, Res);
2071 /// handleSmallSwitchCaseRange - Emit a series of specific tests (suitable for
2072 /// small case ranges).
2073 bool SelectionDAGBuilder::handleSmallSwitchRange(CaseRec& CR,
2074                                                  CaseRecVector& WorkList,
2075                                                  const Value* SV,
2076                                                  MachineBasicBlock *Default,
2077                                                  MachineBasicBlock *SwitchBB) {
2078   // Size is the number of Cases represented by this range.
2079   size_t Size = CR.Range.second - CR.Range.first;
2080   if (Size > 3)
2081     return false;
2083   // Get the MachineFunction which holds the current MBB.  This is used when
2084   // inserting any additional MBBs necessary to represent the switch.
2085   MachineFunction *CurMF = FuncInfo.MF;
2087   // Figure out which block is immediately after the current one.
2088   MachineBasicBlock *NextBlock = nullptr;
2089   MachineFunction::iterator BBI = CR.CaseBB;
2091   if (++BBI != FuncInfo.MF->end())
2092     NextBlock = BBI;
2094   BranchProbabilityInfo *BPI = FuncInfo.BPI;
2095   // If any two of the cases has the same destination, and if one value
2096   // is the same as the other, but has one bit unset that the other has set,
2097   // use bit manipulation to do two compares at once.  For example:
2098   // "if (X == 6 || X == 4)" -> "if ((X|2) == 6)"
2099   // TODO: This could be extended to merge any 2 cases in switches with 3 cases.
2100   // TODO: Handle cases where CR.CaseBB != SwitchBB.
2101   if (Size == 2 && CR.CaseBB == SwitchBB) {
2102     Case &Small = *CR.Range.first;
2103     Case &Big = *(CR.Range.second-1);
2105     if (Small.Low == Small.High && Big.Low == Big.High && Small.BB == Big.BB) {
2106       const APInt& SmallValue = cast<ConstantInt>(Small.Low)->getValue();
2107       const APInt& BigValue = cast<ConstantInt>(Big.Low)->getValue();
2109       // Check that there is only one bit different.
2110       if (BigValue.countPopulation() == SmallValue.countPopulation() + 1 &&
2111           (SmallValue | BigValue) == BigValue) {
2112         // Isolate the common bit.
2113         APInt CommonBit = BigValue & ~SmallValue;
2114         assert((SmallValue | CommonBit) == BigValue &&
2115                CommonBit.countPopulation() == 1 && "Not a common bit?");
2117         SDValue CondLHS = getValue(SV);
2118         EVT VT = CondLHS.getValueType();
2119         SDLoc DL = getCurSDLoc();
2121         SDValue Or = DAG.getNode(ISD::OR, DL, VT, CondLHS,
2122                                  DAG.getConstant(CommonBit, VT));
2123         SDValue Cond = DAG.getSetCC(DL, MVT::i1,
2124                                     Or, DAG.getConstant(BigValue, VT),
2125                                     ISD::SETEQ);
2127         // Update successor info.
2128         // Both Small and Big will jump to Small.BB, so we sum up the weights.
2129         addSuccessorWithWeight(SwitchBB, Small.BB,
2130                                Small.ExtraWeight + Big.ExtraWeight);
2131         addSuccessorWithWeight(SwitchBB, Default,
2132           // The default destination is the first successor in IR.
2133           BPI ? BPI->getEdgeWeight(SwitchBB->getBasicBlock(), (unsigned)0) : 0);
2135         // Insert the true branch.
2136         SDValue BrCond = DAG.getNode(ISD::BRCOND, DL, MVT::Other,
2137                                      getControlRoot(), Cond,
2138                                      DAG.getBasicBlock(Small.BB));
2140         // Insert the false branch.
2141         BrCond = DAG.getNode(ISD::BR, DL, MVT::Other, BrCond,
2142                              DAG.getBasicBlock(Default));
2144         DAG.setRoot(BrCond);
2145         return true;
2146       }
2147     }
2148   }
2150   // Order cases by weight so the most likely case will be checked first.
2151   uint32_t UnhandledWeights = 0;
2152   if (BPI) {
2153     for (CaseItr I = CR.Range.first, IE = CR.Range.second; I != IE; ++I) {
2154       uint32_t IWeight = I->ExtraWeight;
2155       UnhandledWeights += IWeight;
2156       for (CaseItr J = CR.Range.first; J < I; ++J) {
2157         uint32_t JWeight = J->ExtraWeight;
2158         if (IWeight > JWeight)
2159           std::swap(*I, *J);
2160       }
2161     }
2162   }
2163   // Rearrange the case blocks so that the last one falls through if possible.
2164   Case &BackCase = *(CR.Range.second-1);
2165   if (Size > 1 &&
2166       NextBlock && Default != NextBlock && BackCase.BB != NextBlock) {
2167     // The last case block won't fall through into 'NextBlock' if we emit the
2168     // branches in this order.  See if rearranging a case value would help.
2169     // We start at the bottom as it's the case with the least weight.
2170     for (Case *I = &*(CR.Range.second-2), *E = &*CR.Range.first-1; I != E; --I)
2171       if (I->BB == NextBlock) {
2172         std::swap(*I, BackCase);
2173         break;
2174       }
2175   }
2177   // Create a CaseBlock record representing a conditional branch to
2178   // the Case's target mbb if the value being switched on SV is equal
2179   // to C.
2180   MachineBasicBlock *CurBlock = CR.CaseBB;
2181   for (CaseItr I = CR.Range.first, E = CR.Range.second; I != E; ++I) {
2182     MachineBasicBlock *FallThrough;
2183     if (I != E-1) {
2184       FallThrough = CurMF->CreateMachineBasicBlock(CurBlock->getBasicBlock());
2185       CurMF->insert(BBI, FallThrough);
2187       // Put SV in a virtual register to make it available from the new blocks.
2188       ExportFromCurrentBlock(SV);
2189     } else {
2190       // If the last case doesn't match, go to the default block.
2191       FallThrough = Default;
2192     }
2194     const Value *RHS, *LHS, *MHS;
2195     ISD::CondCode CC;
2196     if (I->High == I->Low) {
2197       // This is just small small case range :) containing exactly 1 case
2198       CC = ISD::SETEQ;
2199       LHS = SV; RHS = I->High; MHS = nullptr;
2200     } else {
2201       CC = ISD::SETLE;
2202       LHS = I->Low; MHS = SV; RHS = I->High;
2203     }
2205     // The false weight should be sum of all un-handled cases.
2206     UnhandledWeights -= I->ExtraWeight;
2207     CaseBlock CB(CC, LHS, RHS, MHS, /* truebb */ I->BB, /* falsebb */ FallThrough,
2208                  /* me */ CurBlock,
2209                  /* trueweight */ I->ExtraWeight,
2210                  /* falseweight */ UnhandledWeights);
2212     // If emitting the first comparison, just call visitSwitchCase to emit the
2213     // code into the current block.  Otherwise, push the CaseBlock onto the
2214     // vector to be later processed by SDISel, and insert the node's MBB
2215     // before the next MBB.
2216     if (CurBlock == SwitchBB)
2217       visitSwitchCase(CB, SwitchBB);
2218     else
2219       SwitchCases.push_back(CB);
2221     CurBlock = FallThrough;
2222   }
2224   return true;
2227 static inline bool areJTsAllowed(const TargetLowering &TLI) {
2228   return TLI.supportJumpTables() &&
2229           (TLI.isOperationLegalOrCustom(ISD::BR_JT, MVT::Other) ||
2230            TLI.isOperationLegalOrCustom(ISD::BRIND, MVT::Other));
2233 static APInt ComputeRange(const APInt &First, const APInt &Last) {
2234   uint32_t BitWidth = std::max(Last.getBitWidth(), First.getBitWidth()) + 1;
2235   APInt LastExt = Last.sext(BitWidth), FirstExt = First.sext(BitWidth);
2236   return (LastExt - FirstExt + 1ULL);
2239 /// handleJTSwitchCase - Emit jumptable for current switch case range
2240 bool SelectionDAGBuilder::handleJTSwitchCase(CaseRec &CR,
2241                                              CaseRecVector &WorkList,
2242                                              const Value *SV,
2243                                              MachineBasicBlock *Default,
2244                                              MachineBasicBlock *SwitchBB) {
2245   Case& FrontCase = *CR.Range.first;
2246   Case& BackCase  = *(CR.Range.second-1);
2248   const APInt &First = cast<ConstantInt>(FrontCase.Low)->getValue();
2249   const APInt &Last  = cast<ConstantInt>(BackCase.High)->getValue();
2251   APInt TSize(First.getBitWidth(), 0);
2252   for (CaseItr I = CR.Range.first, E = CR.Range.second; I != E; ++I)
2253     TSize += I->size();
2255   const TargetLowering *TLI = TM.getTargetLowering();
2256   if (!areJTsAllowed(*TLI) || TSize.ult(TLI->getMinimumJumpTableEntries()))
2257     return false;
2259   APInt Range = ComputeRange(First, Last);
2260   // The density is TSize / Range. Require at least 40%.
2261   // It should not be possible for IntTSize to saturate for sane code, but make
2262   // sure we handle Range saturation correctly.
2263   uint64_t IntRange = Range.getLimitedValue(UINT64_MAX/10);
2264   uint64_t IntTSize = TSize.getLimitedValue(UINT64_MAX/10);
2265   if (IntTSize * 10 < IntRange * 4)
2266     return false;
2268   DEBUG(dbgs() << "Lowering jump table\n"
2269                << "First entry: " << First << ". Last entry: " << Last << '\n'
2270                << "Range: " << Range << ". Size: " << TSize << ".\n\n");
2272   // Get the MachineFunction which holds the current MBB.  This is used when
2273   // inserting any additional MBBs necessary to represent the switch.
2274   MachineFunction *CurMF = FuncInfo.MF;
2276   // Figure out which block is immediately after the current one.
2277   MachineFunction::iterator BBI = CR.CaseBB;
2278   ++BBI;
2280   const BasicBlock *LLVMBB = CR.CaseBB->getBasicBlock();
2282   // Create a new basic block to hold the code for loading the address
2283   // of the jump table, and jumping to it.  Update successor information;
2284   // we will either branch to the default case for the switch, or the jump
2285   // table.
2286   MachineBasicBlock *JumpTableBB = CurMF->CreateMachineBasicBlock(LLVMBB);
2287   CurMF->insert(BBI, JumpTableBB);
2289   addSuccessorWithWeight(CR.CaseBB, Default);
2290   addSuccessorWithWeight(CR.CaseBB, JumpTableBB);
2292   // Build a vector of destination BBs, corresponding to each target
2293   // of the jump table. If the value of the jump table slot corresponds to
2294   // a case statement, push the case's BB onto the vector, otherwise, push
2295   // the default BB.
2296   std::vector<MachineBasicBlock*> DestBBs;
2297   APInt TEI = First;
2298   for (CaseItr I = CR.Range.first, E = CR.Range.second; I != E; ++TEI) {
2299     const APInt &Low = cast<ConstantInt>(I->Low)->getValue();
2300     const APInt &High = cast<ConstantInt>(I->High)->getValue();
2302     if (Low.sle(TEI) && TEI.sle(High)) {
2303       DestBBs.push_back(I->BB);
2304       if (TEI==High)
2305         ++I;
2306     } else {
2307       DestBBs.push_back(Default);
2308     }
2309   }
2311   // Calculate weight for each unique destination in CR.
2312   DenseMap<MachineBasicBlock*, uint32_t> DestWeights;
2313   if (FuncInfo.BPI)
2314     for (CaseItr I = CR.Range.first, E = CR.Range.second; I != E; ++I) {
2315       DenseMap<MachineBasicBlock*, uint32_t>::iterator Itr =
2316           DestWeights.find(I->BB);
2317       if (Itr != DestWeights.end())
2318         Itr->second += I->ExtraWeight;
2319       else
2320         DestWeights[I->BB] = I->ExtraWeight;
2321     }
2323   // Update successor info. Add one edge to each unique successor.
2324   BitVector SuccsHandled(CR.CaseBB->getParent()->getNumBlockIDs());
2325   for (std::vector<MachineBasicBlock*>::iterator I = DestBBs.begin(),
2326          E = DestBBs.end(); I != E; ++I) {
2327     if (!SuccsHandled[(*I)->getNumber()]) {
2328       SuccsHandled[(*I)->getNumber()] = true;
2329       DenseMap<MachineBasicBlock*, uint32_t>::iterator Itr =
2330           DestWeights.find(*I);
2331       addSuccessorWithWeight(JumpTableBB, *I,
2332                              Itr != DestWeights.end() ? Itr->second : 0);
2333     }
2334   }
2336   // Create a jump table index for this jump table.
2337   unsigned JTEncoding = TLI->getJumpTableEncoding();
2338   unsigned JTI = CurMF->getOrCreateJumpTableInfo(JTEncoding)
2339                        ->createJumpTableIndex(DestBBs);
2341   // Set the jump table information so that we can codegen it as a second
2342   // MachineBasicBlock
2343   JumpTable JT(-1U, JTI, JumpTableBB, Default);
2344   JumpTableHeader JTH(First, Last, SV, CR.CaseBB, (CR.CaseBB == SwitchBB));
2345   if (CR.CaseBB == SwitchBB)
2346     visitJumpTableHeader(JT, JTH, SwitchBB);
2348   JTCases.push_back(JumpTableBlock(JTH, JT));
2349   return true;
2352 /// handleBTSplitSwitchCase - emit comparison and split binary search tree into
2353 /// 2 subtrees.
2354 bool SelectionDAGBuilder::handleBTSplitSwitchCase(CaseRec& CR,
2355                                                   CaseRecVector& WorkList,
2356                                                   const Value* SV,
2357                                                   MachineBasicBlock* Default,
2358                                                   MachineBasicBlock* SwitchBB) {
2359   // Get the MachineFunction which holds the current MBB.  This is used when
2360   // inserting any additional MBBs necessary to represent the switch.
2361   MachineFunction *CurMF = FuncInfo.MF;
2363   // Figure out which block is immediately after the current one.
2364   MachineFunction::iterator BBI = CR.CaseBB;
2365   ++BBI;
2367   Case& FrontCase = *CR.Range.first;
2368   Case& BackCase  = *(CR.Range.second-1);
2369   const BasicBlock *LLVMBB = CR.CaseBB->getBasicBlock();
2371   // Size is the number of Cases represented by this range.
2372   unsigned Size = CR.Range.second - CR.Range.first;
2374   const APInt &First = cast<ConstantInt>(FrontCase.Low)->getValue();
2375   const APInt &Last  = cast<ConstantInt>(BackCase.High)->getValue();
2376   double FMetric = 0;
2377   CaseItr Pivot = CR.Range.first + Size/2;
2379   // Select optimal pivot, maximizing sum density of LHS and RHS. This will
2380   // (heuristically) allow us to emit JumpTable's later.
2381   APInt TSize(First.getBitWidth(), 0);
2382   for (CaseItr I = CR.Range.first, E = CR.Range.second;
2383        I!=E; ++I)
2384     TSize += I->size();
2386   APInt LSize = FrontCase.size();
2387   APInt RSize = TSize-LSize;
2388   DEBUG(dbgs() << "Selecting best pivot: \n"
2389                << "First: " << First << ", Last: " << Last <<'\n'
2390                << "LSize: " << LSize << ", RSize: " << RSize << '\n');
2391   for (CaseItr I = CR.Range.first, J=I+1, E = CR.Range.second;
2392        J!=E; ++I, ++J) {
2393     const APInt &LEnd = cast<ConstantInt>(I->High)->getValue();
2394     const APInt &RBegin = cast<ConstantInt>(J->Low)->getValue();
2395     APInt Range = ComputeRange(LEnd, RBegin);
2396     assert((Range - 2ULL).isNonNegative() &&
2397            "Invalid case distance");
2398     // Use volatile double here to avoid excess precision issues on some hosts,
2399     // e.g. that use 80-bit X87 registers.
2400     volatile double LDensity =
2401        (double)LSize.roundToDouble() /
2402                            (LEnd - First + 1ULL).roundToDouble();
2403     volatile double RDensity =
2404       (double)RSize.roundToDouble() /
2405                            (Last - RBegin + 1ULL).roundToDouble();
2406     volatile double Metric = Range.logBase2()*(LDensity+RDensity);
2407     // Should always split in some non-trivial place
2408     DEBUG(dbgs() <<"=>Step\n"
2409                  << "LEnd: " << LEnd << ", RBegin: " << RBegin << '\n'
2410                  << "LDensity: " << LDensity
2411                  << ", RDensity: " << RDensity << '\n'
2412                  << "Metric: " << Metric << '\n');
2413     if (FMetric < Metric) {
2414       Pivot = J;
2415       FMetric = Metric;
2416       DEBUG(dbgs() << "Current metric set to: " << FMetric << '\n');
2417     }
2419     LSize += J->size();
2420     RSize -= J->size();
2421   }
2423   const TargetLowering *TLI = TM.getTargetLowering();
2424   if (areJTsAllowed(*TLI)) {
2425     // If our case is dense we *really* should handle it earlier!
2426     assert((FMetric > 0) && "Should handle dense range earlier!");
2427   } else {
2428     Pivot = CR.Range.first + Size/2;
2429   }
2431   CaseRange LHSR(CR.Range.first, Pivot);
2432   CaseRange RHSR(Pivot, CR.Range.second);
2433   const Constant *C = Pivot->Low;
2434   MachineBasicBlock *FalseBB = nullptr, *TrueBB = nullptr;
2436   // We know that we branch to the LHS if the Value being switched on is
2437   // less than the Pivot value, C.  We use this to optimize our binary
2438   // tree a bit, by recognizing that if SV is greater than or equal to the
2439   // LHS's Case Value, and that Case Value is exactly one less than the
2440   // Pivot's Value, then we can branch directly to the LHS's Target,
2441   // rather than creating a leaf node for it.
2442   if ((LHSR.second - LHSR.first) == 1 &&
2443       LHSR.first->High == CR.GE &&
2444       cast<ConstantInt>(C)->getValue() ==
2445       (cast<ConstantInt>(CR.GE)->getValue() + 1LL)) {
2446     TrueBB = LHSR.first->BB;
2447   } else {
2448     TrueBB = CurMF->CreateMachineBasicBlock(LLVMBB);
2449     CurMF->insert(BBI, TrueBB);
2450     WorkList.push_back(CaseRec(TrueBB, C, CR.GE, LHSR));
2452     // Put SV in a virtual register to make it available from the new blocks.
2453     ExportFromCurrentBlock(SV);
2454   }
2456   // Similar to the optimization above, if the Value being switched on is
2457   // known to be less than the Constant CR.LT, and the current Case Value
2458   // is CR.LT - 1, then we can branch directly to the target block for
2459   // the current Case Value, rather than emitting a RHS leaf node for it.
2460   if ((RHSR.second - RHSR.first) == 1 && CR.LT &&
2461       cast<ConstantInt>(RHSR.first->Low)->getValue() ==
2462       (cast<ConstantInt>(CR.LT)->getValue() - 1LL)) {
2463     FalseBB = RHSR.first->BB;
2464   } else {
2465     FalseBB = CurMF->CreateMachineBasicBlock(LLVMBB);
2466     CurMF->insert(BBI, FalseBB);
2467     WorkList.push_back(CaseRec(FalseBB,CR.LT,C,RHSR));
2469     // Put SV in a virtual register to make it available from the new blocks.
2470     ExportFromCurrentBlock(SV);
2471   }
2473   // Create a CaseBlock record representing a conditional branch to
2474   // the LHS node if the value being switched on SV is less than C.
2475   // Otherwise, branch to LHS.
2476   CaseBlock CB(ISD::SETLT, SV, C, nullptr, TrueBB, FalseBB, CR.CaseBB);
2478   if (CR.CaseBB == SwitchBB)
2479     visitSwitchCase(CB, SwitchBB);
2480   else
2481     SwitchCases.push_back(CB);
2483   return true;
2486 /// handleBitTestsSwitchCase - if current case range has few destination and
2487 /// range span less, than machine word bitwidth, encode case range into series
2488 /// of masks and emit bit tests with these masks.
2489 bool SelectionDAGBuilder::handleBitTestsSwitchCase(CaseRec& CR,
2490                                                    CaseRecVector& WorkList,
2491                                                    const Value* SV,
2492                                                    MachineBasicBlock* Default,
2493                                                    MachineBasicBlock* SwitchBB) {
2494   const TargetLowering *TLI = TM.getTargetLowering();
2495   EVT PTy = TLI->getPointerTy();
2496   unsigned IntPtrBits = PTy.getSizeInBits();
2498   Case& FrontCase = *CR.Range.first;
2499   Case& BackCase  = *(CR.Range.second-1);
2501   // Get the MachineFunction which holds the current MBB.  This is used when
2502   // inserting any additional MBBs necessary to represent the switch.
2503   MachineFunction *CurMF = FuncInfo.MF;
2505   // If target does not have legal shift left, do not emit bit tests at all.
2506   if (!TLI->isOperationLegal(ISD::SHL, PTy))
2507     return false;
2509   size_t numCmps = 0;
2510   for (CaseItr I = CR.Range.first, E = CR.Range.second;
2511        I!=E; ++I) {
2512     // Single case counts one, case range - two.
2513     numCmps += (I->Low == I->High ? 1 : 2);
2514   }
2516   // Count unique destinations
2517   SmallSet<MachineBasicBlock*, 4> Dests;
2518   for (CaseItr I = CR.Range.first, E = CR.Range.second; I!=E; ++I) {
2519     Dests.insert(I->BB);
2520     if (Dests.size() > 3)
2521       // Don't bother the code below, if there are too much unique destinations
2522       return false;
2523   }
2524   DEBUG(dbgs() << "Total number of unique destinations: "
2525         << Dests.size() << '\n'
2526         << "Total number of comparisons: " << numCmps << '\n');
2528   // Compute span of values.
2529   const APInt& minValue = cast<ConstantInt>(FrontCase.Low)->getValue();
2530   const APInt& maxValue = cast<ConstantInt>(BackCase.High)->getValue();
2531   APInt cmpRange = maxValue - minValue;
2533   DEBUG(dbgs() << "Compare range: " << cmpRange << '\n'
2534                << "Low bound: " << minValue << '\n'
2535                << "High bound: " << maxValue << '\n');
2537   if (cmpRange.uge(IntPtrBits) ||
2538       (!(Dests.size() == 1 && numCmps >= 3) &&
2539        !(Dests.size() == 2 && numCmps >= 5) &&
2540        !(Dests.size() >= 3 && numCmps >= 6)))
2541     return false;
2543   DEBUG(dbgs() << "Emitting bit tests\n");
2544   APInt lowBound = APInt::getNullValue(cmpRange.getBitWidth());
2546   // Optimize the case where all the case values fit in a
2547   // word without having to subtract minValue. In this case,
2548   // we can optimize away the subtraction.
2549   if (minValue.isNonNegative() && maxValue.slt(IntPtrBits)) {
2550     cmpRange = maxValue;
2551   } else {
2552     lowBound = minValue;
2553   }
2555   CaseBitsVector CasesBits;
2556   unsigned i, count = 0;
2558   for (CaseItr I = CR.Range.first, E = CR.Range.second; I!=E; ++I) {
2559     MachineBasicBlock* Dest = I->BB;
2560     for (i = 0; i < count; ++i)
2561       if (Dest == CasesBits[i].BB)
2562         break;
2564     if (i == count) {
2565       assert((count < 3) && "Too much destinations to test!");
2566       CasesBits.push_back(CaseBits(0, Dest, 0, 0/*Weight*/));
2567       count++;
2568     }
2570     const APInt& lowValue = cast<ConstantInt>(I->Low)->getValue();
2571     const APInt& highValue = cast<ConstantInt>(I->High)->getValue();
2573     uint64_t lo = (lowValue - lowBound).getZExtValue();
2574     uint64_t hi = (highValue - lowBound).getZExtValue();
2575     CasesBits[i].ExtraWeight += I->ExtraWeight;
2577     for (uint64_t j = lo; j <= hi; j++) {
2578       CasesBits[i].Mask |=  1ULL << j;
2579       CasesBits[i].Bits++;
2580     }
2582   }
2583   std::sort(CasesBits.begin(), CasesBits.end(), CaseBitsCmp());
2585   BitTestInfo BTC;
2587   // Figure out which block is immediately after the current one.
2588   MachineFunction::iterator BBI = CR.CaseBB;
2589   ++BBI;
2591   const BasicBlock *LLVMBB = CR.CaseBB->getBasicBlock();
2593   DEBUG(dbgs() << "Cases:\n");
2594   for (unsigned i = 0, e = CasesBits.size(); i!=e; ++i) {
2595     DEBUG(dbgs() << "Mask: " << CasesBits[i].Mask
2596                  << ", Bits: " << CasesBits[i].Bits
2597                  << ", BB: " << CasesBits[i].BB << '\n');
2599     MachineBasicBlock *CaseBB = CurMF->CreateMachineBasicBlock(LLVMBB);
2600     CurMF->insert(BBI, CaseBB);
2601     BTC.push_back(BitTestCase(CasesBits[i].Mask,
2602                               CaseBB,
2603                               CasesBits[i].BB, CasesBits[i].ExtraWeight));
2605     // Put SV in a virtual register to make it available from the new blocks.
2606     ExportFromCurrentBlock(SV);
2607   }
2609   BitTestBlock BTB(lowBound, cmpRange, SV,
2610                    -1U, MVT::Other, (CR.CaseBB == SwitchBB),
2611                    CR.CaseBB, Default, BTC);
2613   if (CR.CaseBB == SwitchBB)
2614     visitBitTestHeader(BTB, SwitchBB);
2616   BitTestCases.push_back(BTB);
2618   return true;
2621 /// Clusterify - Transform simple list of Cases into list of CaseRange's
2622 size_t SelectionDAGBuilder::Clusterify(CaseVector& Cases,
2623                                        const SwitchInst& SI) {
2624   size_t numCmps = 0;
2626   BranchProbabilityInfo *BPI = FuncInfo.BPI;
2627   // Start with "simple" cases
2628   for (SwitchInst::ConstCaseIt i = SI.case_begin(), e = SI.case_end();
2629        i != e; ++i) {
2630     const BasicBlock *SuccBB = i.getCaseSuccessor();
2631     MachineBasicBlock *SMBB = FuncInfo.MBBMap[SuccBB];
2633     uint32_t ExtraWeight =
2634       BPI ? BPI->getEdgeWeight(SI.getParent(), i.getSuccessorIndex()) : 0;
2636     Cases.push_back(Case(i.getCaseValue(), i.getCaseValue(),
2637                          SMBB, ExtraWeight));
2638   }
2639   std::sort(Cases.begin(), Cases.end(), CaseCmp());
2641   // Merge case into clusters
2642   if (Cases.size() >= 2)
2643     // Must recompute end() each iteration because it may be
2644     // invalidated by erase if we hold on to it
2645     for (CaseItr I = Cases.begin(), J = std::next(Cases.begin());
2646          J != Cases.end(); ) {
2647       const APInt& nextValue = cast<ConstantInt>(J->Low)->getValue();
2648       const APInt& currentValue = cast<ConstantInt>(I->High)->getValue();
2649       MachineBasicBlock* nextBB = J->BB;
2650       MachineBasicBlock* currentBB = I->BB;
2652       // If the two neighboring cases go to the same destination, merge them
2653       // into a single case.
2654       if ((nextValue - currentValue == 1) && (currentBB == nextBB)) {
2655         I->High = J->High;
2656         I->ExtraWeight += J->ExtraWeight;
2657         J = Cases.erase(J);
2658       } else {
2659         I = J++;
2660       }
2661     }
2663   for (CaseItr I=Cases.begin(), E=Cases.end(); I!=E; ++I, ++numCmps) {
2664     if (I->Low != I->High)
2665       // A range counts double, since it requires two compares.
2666       ++numCmps;
2667   }
2669   return numCmps;
2672 void SelectionDAGBuilder::UpdateSplitBlock(MachineBasicBlock *First,
2673                                            MachineBasicBlock *Last) {
2674   // Update JTCases.
2675   for (unsigned i = 0, e = JTCases.size(); i != e; ++i)
2676     if (JTCases[i].first.HeaderBB == First)
2677       JTCases[i].first.HeaderBB = Last;
2679   // Update BitTestCases.
2680   for (unsigned i = 0, e = BitTestCases.size(); i != e; ++i)
2681     if (BitTestCases[i].Parent == First)
2682       BitTestCases[i].Parent = Last;
2685 void SelectionDAGBuilder::visitSwitch(const SwitchInst &SI) {
2686   MachineBasicBlock *SwitchMBB = FuncInfo.MBB;
2688   // Figure out which block is immediately after the current one.
2689   MachineBasicBlock *NextBlock = nullptr;
2690   MachineBasicBlock *Default = FuncInfo.MBBMap[SI.getDefaultDest()];
2692   // If there is only the default destination, branch to it if it is not the
2693   // next basic block.  Otherwise, just fall through.
2694   if (!SI.getNumCases()) {
2695     // Update machine-CFG edges.
2697     // If this is not a fall-through branch, emit the branch.
2698     SwitchMBB->addSuccessor(Default);
2699     if (Default != NextBlock)
2700       DAG.setRoot(DAG.getNode(ISD::BR, getCurSDLoc(),
2701                               MVT::Other, getControlRoot(),
2702                               DAG.getBasicBlock(Default)));
2704     return;
2705   }
2707   // If there are any non-default case statements, create a vector of Cases
2708   // representing each one, and sort the vector so that we can efficiently
2709   // create a binary search tree from them.
2710   CaseVector Cases;
2711   size_t numCmps = Clusterify(Cases, SI);
2712   DEBUG(dbgs() << "Clusterify finished. Total clusters: " << Cases.size()
2713                << ". Total compares: " << numCmps << '\n');
2714   (void)numCmps;
2716   // Get the Value to be switched on and default basic blocks, which will be
2717   // inserted into CaseBlock records, representing basic blocks in the binary
2718   // search tree.
2719   const Value *SV = SI.getCondition();
2721   // Push the initial CaseRec onto the worklist
2722   CaseRecVector WorkList;
2723   WorkList.push_back(CaseRec(SwitchMBB,nullptr,nullptr,
2724                              CaseRange(Cases.begin(),Cases.end())));
2726   while (!WorkList.empty()) {
2727     // Grab a record representing a case range to process off the worklist
2728     CaseRec CR = WorkList.back();
2729     WorkList.pop_back();
2731     if (handleBitTestsSwitchCase(CR, WorkList, SV, Default, SwitchMBB))
2732       continue;
2734     // If the range has few cases (two or less) emit a series of specific
2735     // tests.
2736     if (handleSmallSwitchRange(CR, WorkList, SV, Default, SwitchMBB))
2737       continue;
2739     // If the switch has more than N blocks, and is at least 40% dense, and the
2740     // target supports indirect branches, then emit a jump table rather than
2741     // lowering the switch to a binary tree of conditional branches.
2742     // N defaults to 4 and is controlled via TLS.getMinimumJumpTableEntries().
2743     if (handleJTSwitchCase(CR, WorkList, SV, Default, SwitchMBB))
2744       continue;
2746     // Emit binary tree. We need to pick a pivot, and push left and right ranges
2747     // onto the worklist. Leafs are handled via handleSmallSwitchRange() call.
2748     handleBTSplitSwitchCase(CR, WorkList, SV, Default, SwitchMBB);
2749   }
2752 void SelectionDAGBuilder::visitIndirectBr(const IndirectBrInst &I) {
2753   MachineBasicBlock *IndirectBrMBB = FuncInfo.MBB;
2755   // Update machine-CFG edges with unique successors.
2756   SmallSet<BasicBlock*, 32> Done;
2757   for (unsigned i = 0, e = I.getNumSuccessors(); i != e; ++i) {
2758     BasicBlock *BB = I.getSuccessor(i);
2759     bool Inserted = Done.insert(BB);
2760     if (!Inserted)
2761         continue;
2763     MachineBasicBlock *Succ = FuncInfo.MBBMap[BB];
2764     addSuccessorWithWeight(IndirectBrMBB, Succ);
2765   }
2767   DAG.setRoot(DAG.getNode(ISD::BRIND, getCurSDLoc(),
2768                           MVT::Other, getControlRoot(),
2769                           getValue(I.getAddress())));
2772 void SelectionDAGBuilder::visitUnreachable(const UnreachableInst &I) {
2773   if (DAG.getTarget().Options.TrapUnreachable)
2774     DAG.setRoot(DAG.getNode(ISD::TRAP, getCurSDLoc(), MVT::Other, DAG.getRoot()));
2777 void SelectionDAGBuilder::visitFSub(const User &I) {
2778   // -0.0 - X --> fneg
2779   Type *Ty = I.getType();
2780   if (isa<Constant>(I.getOperand(0)) &&
2781       I.getOperand(0) == ConstantFP::getZeroValueForNegation(Ty)) {
2782     SDValue Op2 = getValue(I.getOperand(1));
2783     setValue(&I, DAG.getNode(ISD::FNEG, getCurSDLoc(),
2784                              Op2.getValueType(), Op2));
2785     return;
2786   }
2788   visitBinary(I, ISD::FSUB);
2791 void SelectionDAGBuilder::visitBinary(const User &I, unsigned OpCode) {
2792   SDValue Op1 = getValue(I.getOperand(0));
2793   SDValue Op2 = getValue(I.getOperand(1));
2794   setValue(&I, DAG.getNode(OpCode, getCurSDLoc(),
2795                            Op1.getValueType(), Op1, Op2));
2798 void SelectionDAGBuilder::visitShift(const User &I, unsigned Opcode) {
2799   SDValue Op1 = getValue(I.getOperand(0));
2800   SDValue Op2 = getValue(I.getOperand(1));
2802   EVT ShiftTy = TM.getTargetLowering()->getShiftAmountTy(Op2.getValueType());
2804   // Coerce the shift amount to the right type if we can.
2805   if (!I.getType()->isVectorTy() && Op2.getValueType() != ShiftTy) {
2806     unsigned ShiftSize = ShiftTy.getSizeInBits();
2807     unsigned Op2Size = Op2.getValueType().getSizeInBits();
2808     SDLoc DL = getCurSDLoc();
2810     // If the operand is smaller than the shift count type, promote it.
2811     if (ShiftSize > Op2Size)
2812       Op2 = DAG.getNode(ISD::ZERO_EXTEND, DL, ShiftTy, Op2);
2814     // If the operand is larger than the shift count type but the shift
2815     // count type has enough bits to represent any shift value, truncate
2816     // it now. This is a common case and it exposes the truncate to
2817     // optimization early.
2818     else if (ShiftSize >= Log2_32_Ceil(Op2.getValueType().getSizeInBits()))
2819       Op2 = DAG.getNode(ISD::TRUNCATE, DL, ShiftTy, Op2);
2820     // Otherwise we'll need to temporarily settle for some other convenient
2821     // type.  Type legalization will make adjustments once the shiftee is split.
2822     else
2823       Op2 = DAG.getZExtOrTrunc(Op2, DL, MVT::i32);
2824   }
2826   setValue(&I, DAG.getNode(Opcode, getCurSDLoc(),
2827                            Op1.getValueType(), Op1, Op2));
2830 void SelectionDAGBuilder::visitSDiv(const User &I) {
2831   SDValue Op1 = getValue(I.getOperand(0));
2832   SDValue Op2 = getValue(I.getOperand(1));
2834   // Turn exact SDivs into multiplications.
2835   // FIXME: This should be in DAGCombiner, but it doesn't have access to the
2836   // exact bit.
2837   if (isa<BinaryOperator>(&I) && cast<BinaryOperator>(&I)->isExact() &&
2838       !isa<ConstantSDNode>(Op1) &&
2839       isa<ConstantSDNode>(Op2) && !cast<ConstantSDNode>(Op2)->isNullValue())
2840     setValue(&I, TM.getTargetLowering()->BuildExactSDIV(Op1, Op2,
2841                                                         getCurSDLoc(), DAG));
2842   else
2843     setValue(&I, DAG.getNode(ISD::SDIV, getCurSDLoc(), Op1.getValueType(),
2844                              Op1, Op2));
2847 void SelectionDAGBuilder::visitICmp(const User &I) {
2848   ICmpInst::Predicate predicate = ICmpInst::BAD_ICMP_PREDICATE;
2849   if (const ICmpInst *IC = dyn_cast<ICmpInst>(&I))
2850     predicate = IC->getPredicate();
2851   else if (const ConstantExpr *IC = dyn_cast<ConstantExpr>(&I))
2852     predicate = ICmpInst::Predicate(IC->getPredicate());
2853   SDValue Op1 = getValue(I.getOperand(0));
2854   SDValue Op2 = getValue(I.getOperand(1));
2855   ISD::CondCode Opcode = getICmpCondCode(predicate);
2857   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
2858   setValue(&I, DAG.getSetCC(getCurSDLoc(), DestVT, Op1, Op2, Opcode));
2861 void SelectionDAGBuilder::visitFCmp(const User &I) {
2862   FCmpInst::Predicate predicate = FCmpInst::BAD_FCMP_PREDICATE;
2863   if (const FCmpInst *FC = dyn_cast<FCmpInst>(&I))
2864     predicate = FC->getPredicate();
2865   else if (const ConstantExpr *FC = dyn_cast<ConstantExpr>(&I))
2866     predicate = FCmpInst::Predicate(FC->getPredicate());
2867   SDValue Op1 = getValue(I.getOperand(0));
2868   SDValue Op2 = getValue(I.getOperand(1));
2869   ISD::CondCode Condition = getFCmpCondCode(predicate);
2870   if (TM.Options.NoNaNsFPMath)
2871     Condition = getFCmpCodeWithoutNaN(Condition);
2872   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
2873   setValue(&I, DAG.getSetCC(getCurSDLoc(), DestVT, Op1, Op2, Condition));
2876 void SelectionDAGBuilder::visitSelect(const User &I) {
2877   SmallVector<EVT, 4> ValueVTs;
2878   ComputeValueVTs(*TM.getTargetLowering(), I.getType(), ValueVTs);
2879   unsigned NumValues = ValueVTs.size();
2880   if (NumValues == 0) return;
2882   SmallVector<SDValue, 4> Values(NumValues);
2883   SDValue Cond     = getValue(I.getOperand(0));
2884   SDValue TrueVal  = getValue(I.getOperand(1));
2885   SDValue FalseVal = getValue(I.getOperand(2));
2886   ISD::NodeType OpCode = Cond.getValueType().isVector() ?
2887     ISD::VSELECT : ISD::SELECT;
2889   for (unsigned i = 0; i != NumValues; ++i)
2890     Values[i] = DAG.getNode(OpCode, getCurSDLoc(),
2891                             TrueVal.getNode()->getValueType(TrueVal.getResNo()+i),
2892                             Cond,
2893                             SDValue(TrueVal.getNode(),
2894                                     TrueVal.getResNo() + i),
2895                             SDValue(FalseVal.getNode(),
2896                                     FalseVal.getResNo() + i));
2898   setValue(&I, DAG.getNode(ISD::MERGE_VALUES, getCurSDLoc(),
2899                            DAG.getVTList(ValueVTs),
2900                            &Values[0], NumValues));
2903 void SelectionDAGBuilder::visitTrunc(const User &I) {
2904   // TruncInst cannot be a no-op cast because sizeof(src) > sizeof(dest).
2905   SDValue N = getValue(I.getOperand(0));
2906   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
2907   setValue(&I, DAG.getNode(ISD::TRUNCATE, getCurSDLoc(), DestVT, N));
2910 void SelectionDAGBuilder::visitZExt(const User &I) {
2911   // ZExt cannot be a no-op cast because sizeof(src) < sizeof(dest).
2912   // ZExt also can't be a cast to bool for same reason. So, nothing much to do
2913   SDValue N = getValue(I.getOperand(0));
2914   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
2915   setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, getCurSDLoc(), DestVT, N));
2918 void SelectionDAGBuilder::visitSExt(const User &I) {
2919   // SExt cannot be a no-op cast because sizeof(src) < sizeof(dest).
2920   // SExt also can't be a cast to bool for same reason. So, nothing much to do
2921   SDValue N = getValue(I.getOperand(0));
2922   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
2923   setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, getCurSDLoc(), DestVT, N));
2926 void SelectionDAGBuilder::visitFPTrunc(const User &I) {
2927   // FPTrunc is never a no-op cast, no need to check
2928   SDValue N = getValue(I.getOperand(0));
2929   const TargetLowering *TLI = TM.getTargetLowering();
2930   EVT DestVT = TLI->getValueType(I.getType());
2931   setValue(&I, DAG.getNode(ISD::FP_ROUND, getCurSDLoc(),
2932                            DestVT, N,
2933                            DAG.getTargetConstant(0, TLI->getPointerTy())));
2936 void SelectionDAGBuilder::visitFPExt(const User &I) {
2937   // FPExt is never a no-op cast, no need to check
2938   SDValue N = getValue(I.getOperand(0));
2939   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
2940   setValue(&I, DAG.getNode(ISD::FP_EXTEND, getCurSDLoc(), DestVT, N));
2943 void SelectionDAGBuilder::visitFPToUI(const User &I) {
2944   // FPToUI is never a no-op cast, no need to check
2945   SDValue N = getValue(I.getOperand(0));
2946   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
2947   setValue(&I, DAG.getNode(ISD::FP_TO_UINT, getCurSDLoc(), DestVT, N));
2950 void SelectionDAGBuilder::visitFPToSI(const User &I) {
2951   // FPToSI is never a no-op cast, no need to check
2952   SDValue N = getValue(I.getOperand(0));
2953   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
2954   setValue(&I, DAG.getNode(ISD::FP_TO_SINT, getCurSDLoc(), DestVT, N));
2957 void SelectionDAGBuilder::visitUIToFP(const User &I) {
2958   // UIToFP is never a no-op cast, no need to check
2959   SDValue N = getValue(I.getOperand(0));
2960   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
2961   setValue(&I, DAG.getNode(ISD::UINT_TO_FP, getCurSDLoc(), DestVT, N));
2964 void SelectionDAGBuilder::visitSIToFP(const User &I) {
2965   // SIToFP is never a no-op cast, no need to check
2966   SDValue N = getValue(I.getOperand(0));
2967   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
2968   setValue(&I, DAG.getNode(ISD::SINT_TO_FP, getCurSDLoc(), DestVT, N));
2971 void SelectionDAGBuilder::visitPtrToInt(const User &I) {
2972   // What to do depends on the size of the integer and the size of the pointer.
2973   // We can either truncate, zero extend, or no-op, accordingly.
2974   SDValue N = getValue(I.getOperand(0));
2975   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
2976   setValue(&I, DAG.getZExtOrTrunc(N, getCurSDLoc(), DestVT));
2979 void SelectionDAGBuilder::visitIntToPtr(const User &I) {
2980   // What to do depends on the size of the integer and the size of the pointer.
2981   // We can either truncate, zero extend, or no-op, accordingly.
2982   SDValue N = getValue(I.getOperand(0));
2983   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
2984   setValue(&I, DAG.getZExtOrTrunc(N, getCurSDLoc(), DestVT));
2987 void SelectionDAGBuilder::visitBitCast(const User &I) {
2988   SDValue N = getValue(I.getOperand(0));
2989   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
2991   // BitCast assures us that source and destination are the same size so this is
2992   // either a BITCAST or a no-op.
2993   if (DestVT != N.getValueType())
2994     setValue(&I, DAG.getNode(ISD::BITCAST, getCurSDLoc(),
2995                              DestVT, N)); // convert types.
2996   // Check if the original LLVM IR Operand was a ConstantInt, because getValue()
2997   // might fold any kind of constant expression to an integer constant and that
2998   // is not what we are looking for. Only regcognize a bitcast of a genuine
2999   // constant integer as an opaque constant.
3000   else if(ConstantInt *C = dyn_cast<ConstantInt>(I.getOperand(0)))
3001     setValue(&I, DAG.getConstant(C->getValue(), DestVT, /*isTarget=*/false,
3002                                  /*isOpaque*/true));
3003   else
3004     setValue(&I, N);            // noop cast.
3007 void SelectionDAGBuilder::visitAddrSpaceCast(const User &I) {
3008   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
3009   const Value *SV = I.getOperand(0);
3010   SDValue N = getValue(SV);
3011   EVT DestVT = TM.getTargetLowering()->getValueType(I.getType());
3013   unsigned SrcAS = SV->getType()->getPointerAddressSpace();
3014   unsigned DestAS = I.getType()->getPointerAddressSpace();
3016   if (!TLI.isNoopAddrSpaceCast(SrcAS, DestAS))
3017     N = DAG.getAddrSpaceCast(getCurSDLoc(), DestVT, N, SrcAS, DestAS);
3019   setValue(&I, N);
3022 void SelectionDAGBuilder::visitInsertElement(const User &I) {
3023   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
3024   SDValue InVec = getValue(I.getOperand(0));
3025   SDValue InVal = getValue(I.getOperand(1));
3026   SDValue InIdx = DAG.getSExtOrTrunc(getValue(I.getOperand(2)),
3027                                      getCurSDLoc(), TLI.getVectorIdxTy());
3028   setValue(&I, DAG.getNode(ISD::INSERT_VECTOR_ELT, getCurSDLoc(),
3029                            TM.getTargetLowering()->getValueType(I.getType()),
3030                            InVec, InVal, InIdx));
3033 void SelectionDAGBuilder::visitExtractElement(const User &I) {
3034   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
3035   SDValue InVec = getValue(I.getOperand(0));
3036   SDValue InIdx = DAG.getSExtOrTrunc(getValue(I.getOperand(1)),
3037                                      getCurSDLoc(), TLI.getVectorIdxTy());
3038   setValue(&I, DAG.getNode(ISD::EXTRACT_VECTOR_ELT, getCurSDLoc(),
3039                            TM.getTargetLowering()->getValueType(I.getType()),
3040                            InVec, InIdx));
3043 // Utility for visitShuffleVector - Return true if every element in Mask,
3044 // beginning from position Pos and ending in Pos+Size, falls within the
3045 // specified sequential range [L, L+Pos). or is undef.
3046 static bool isSequentialInRange(const SmallVectorImpl<int> &Mask,
3047                                 unsigned Pos, unsigned Size, int Low) {
3048   for (unsigned i = Pos, e = Pos+Size; i != e; ++i, ++Low)
3049     if (Mask[i] >= 0 && Mask[i] != Low)
3050       return false;
3051   return true;
3054 void SelectionDAGBuilder::visitShuffleVector(const User &I) {
3055   SDValue Src1 = getValue(I.getOperand(0));
3056   SDValue Src2 = getValue(I.getOperand(1));
3058   SmallVector<int, 8> Mask;
3059   ShuffleVectorInst::getShuffleMask(cast<Constant>(I.getOperand(2)), Mask);
3060   unsigned MaskNumElts = Mask.size();
3062   const TargetLowering *TLI = TM.getTargetLowering();
3063   EVT VT = TLI->getValueType(I.getType());
3064   EVT SrcVT = Src1.getValueType();
3065   unsigned SrcNumElts = SrcVT.getVectorNumElements();
3067   if (SrcNumElts == MaskNumElts) {
3068     setValue(&I, DAG.getVectorShuffle(VT, getCurSDLoc(), Src1, Src2,
3069                                       &Mask[0]));
3070     return;
3071   }
3073   // Normalize the shuffle vector since mask and vector length don't match.
3074   if (SrcNumElts < MaskNumElts && MaskNumElts % SrcNumElts == 0) {
3075     // Mask is longer than the source vectors and is a multiple of the source
3076     // vectors.  We can use concatenate vector to make the mask and vectors
3077     // lengths match.
3078     if (SrcNumElts*2 == MaskNumElts) {
3079       // First check for Src1 in low and Src2 in high
3080       if (isSequentialInRange(Mask, 0, SrcNumElts, 0) &&
3081           isSequentialInRange(Mask, SrcNumElts, SrcNumElts, SrcNumElts)) {
3082         // The shuffle is concatenating two vectors together.
3083         setValue(&I, DAG.getNode(ISD::CONCAT_VECTORS, getCurSDLoc(),
3084                                  VT, Src1, Src2));
3085         return;
3086       }
3087       // Then check for Src2 in low and Src1 in high
3088       if (isSequentialInRange(Mask, 0, SrcNumElts, SrcNumElts) &&
3089           isSequentialInRange(Mask, SrcNumElts, SrcNumElts, 0)) {
3090         // The shuffle is concatenating two vectors together.
3091         setValue(&I, DAG.getNode(ISD::CONCAT_VECTORS, getCurSDLoc(),
3092                                  VT, Src2, Src1));
3093         return;
3094       }
3095     }
3097     // Pad both vectors with undefs to make them the same length as the mask.
3098     unsigned NumConcat = MaskNumElts / SrcNumElts;
3099     bool Src1U = Src1.getOpcode() == ISD::UNDEF;
3100     bool Src2U = Src2.getOpcode() == ISD::UNDEF;
3101     SDValue UndefVal = DAG.getUNDEF(SrcVT);
3103     SmallVector<SDValue, 8> MOps1(NumConcat, UndefVal);
3104     SmallVector<SDValue, 8> MOps2(NumConcat, UndefVal);
3105     MOps1[0] = Src1;
3106     MOps2[0] = Src2;
3108     Src1 = Src1U ? DAG.getUNDEF(VT) : DAG.getNode(ISD::CONCAT_VECTORS,
3109                                                   getCurSDLoc(), VT,
3110                                                   &MOps1[0], NumConcat);
3111     Src2 = Src2U ? DAG.getUNDEF(VT) : DAG.getNode(ISD::CONCAT_VECTORS,
3112                                                   getCurSDLoc(), VT,
3113                                                   &MOps2[0], NumConcat);
3115     // Readjust mask for new input vector length.
3116     SmallVector<int, 8> MappedOps;
3117     for (unsigned i = 0; i != MaskNumElts; ++i) {
3118       int Idx = Mask[i];
3119       if (Idx >= (int)SrcNumElts)
3120         Idx -= SrcNumElts - MaskNumElts;
3121       MappedOps.push_back(Idx);
3122     }
3124     setValue(&I, DAG.getVectorShuffle(VT, getCurSDLoc(), Src1, Src2,
3125                                       &MappedOps[0]));
3126     return;
3127   }
3129   if (SrcNumElts > MaskNumElts) {
3130     // Analyze the access pattern of the vector to see if we can extract
3131     // two subvectors and do the shuffle. The analysis is done by calculating
3132     // the range of elements the mask access on both vectors.
3133     int MinRange[2] = { static_cast<int>(SrcNumElts),
3134                         static_cast<int>(SrcNumElts)};
3135     int MaxRange[2] = {-1, -1};
3137     for (unsigned i = 0; i != MaskNumElts; ++i) {
3138       int Idx = Mask[i];
3139       unsigned Input = 0;
3140       if (Idx < 0)
3141         continue;
3143       if (Idx >= (int)SrcNumElts) {
3144         Input = 1;
3145         Idx -= SrcNumElts;
3146       }
3147       if (Idx > MaxRange[Input])
3148         MaxRange[Input] = Idx;
3149       if (Idx < MinRange[Input])
3150         MinRange[Input] = Idx;
3151     }
3153     // Check if the access is smaller than the vector size and can we find
3154     // a reasonable extract index.
3155     int RangeUse[2] = { -1, -1 };  // 0 = Unused, 1 = Extract, -1 = Can not
3156                                    // Extract.
3157     int StartIdx[2];  // StartIdx to extract from
3158     for (unsigned Input = 0; Input < 2; ++Input) {
3159       if (MinRange[Input] >= (int)SrcNumElts && MaxRange[Input] < 0) {
3160         RangeUse[Input] = 0; // Unused
3161         StartIdx[Input] = 0;
3162         continue;
3163       }
3165       // Find a good start index that is a multiple of the mask length. Then
3166       // see if the rest of the elements are in range.
3167       StartIdx[Input] = (MinRange[Input]/MaskNumElts)*MaskNumElts;
3168       if (MaxRange[Input] - StartIdx[Input] < (int)MaskNumElts &&
3169           StartIdx[Input] + MaskNumElts <= SrcNumElts)
3170         RangeUse[Input] = 1; // Extract from a multiple of the mask length.
3171     }
3173     if (RangeUse[0] == 0 && RangeUse[1] == 0) {
3174       setValue(&I, DAG.getUNDEF(VT)); // Vectors are not used.
3175       return;
3176     }
3177     if (RangeUse[0] >= 0 && RangeUse[1] >= 0) {
3178       // Extract appropriate subvector and generate a vector shuffle
3179       for (unsigned Input = 0; Input < 2; ++Input) {
3180         SDValue &Src = Input == 0 ? Src1 : Src2;
3181         if (RangeUse[Input] == 0)
3182           Src = DAG.getUNDEF(VT);
3183         else
3184           Src = DAG.getNode(ISD::EXTRACT_SUBVECTOR, getCurSDLoc(), VT,
3185                             Src, DAG.getConstant(StartIdx[Input],
3186                                                  TLI->getVectorIdxTy()));
3187       }
3189       // Calculate new mask.
3190       SmallVector<int, 8> MappedOps;
3191       for (unsigned i = 0; i != MaskNumElts; ++i) {
3192         int Idx = Mask[i];
3193         if (Idx >= 0) {
3194           if (Idx < (int)SrcNumElts)
3195             Idx -= StartIdx[0];
3196           else
3197             Idx -= SrcNumElts + StartIdx[1] - MaskNumElts;
3198         }
3199         MappedOps.push_back(Idx);
3200       }
3202       setValue(&I, DAG.getVectorShuffle(VT, getCurSDLoc(), Src1, Src2,
3203                                         &MappedOps[0]));
3204       return;
3205     }
3206   }
3208   // We can't use either concat vectors or extract subvectors so fall back to
3209   // replacing the shuffle with extract and build vector.
3210   // to insert and build vector.
3211   EVT EltVT = VT.getVectorElementType();
3212   EVT IdxVT = TLI->getVectorIdxTy();
3213   SmallVector<SDValue,8> Ops;
3214   for (unsigned i = 0; i != MaskNumElts; ++i) {
3215     int Idx = Mask[i];
3216     SDValue Res;
3218     if (Idx < 0) {
3219       Res = DAG.getUNDEF(EltVT);
3220     } else {
3221       SDValue &Src = Idx < (int)SrcNumElts ? Src1 : Src2;
3222       if (Idx >= (int)SrcNumElts) Idx -= SrcNumElts;
3224       Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, getCurSDLoc(),
3225                         EltVT, Src, DAG.getConstant(Idx, IdxVT));
3226     }
3228     Ops.push_back(Res);
3229   }
3231   setValue(&I, DAG.getNode(ISD::BUILD_VECTOR, getCurSDLoc(),
3232                            VT, &Ops[0], Ops.size()));
3235 void SelectionDAGBuilder::visitInsertValue(const InsertValueInst &I) {
3236   const Value *Op0 = I.getOperand(0);
3237   const Value *Op1 = I.getOperand(1);
3238   Type *AggTy = I.getType();
3239   Type *ValTy = Op1->getType();
3240   bool IntoUndef = isa<UndefValue>(Op0);
3241   bool FromUndef = isa<UndefValue>(Op1);
3243   unsigned LinearIndex = ComputeLinearIndex(AggTy, I.getIndices());
3245   const TargetLowering *TLI = TM.getTargetLowering();
3246   SmallVector<EVT, 4> AggValueVTs;
3247   ComputeValueVTs(*TLI, AggTy, AggValueVTs);
3248   SmallVector<EVT, 4> ValValueVTs;
3249   ComputeValueVTs(*TLI, ValTy, ValValueVTs);
3251   unsigned NumAggValues = AggValueVTs.size();
3252   unsigned NumValValues = ValValueVTs.size();
3253   SmallVector<SDValue, 4> Values(NumAggValues);
3255   SDValue Agg = getValue(Op0);
3256   unsigned i = 0;
3257   // Copy the beginning value(s) from the original aggregate.
3258   for (; i != LinearIndex; ++i)
3259     Values[i] = IntoUndef ? DAG.getUNDEF(AggValueVTs[i]) :
3260                 SDValue(Agg.getNode(), Agg.getResNo() + i);
3261   // Copy values from the inserted value(s).
3262   if (NumValValues) {
3263     SDValue Val = getValue(Op1);
3264     for (; i != LinearIndex + NumValValues; ++i)
3265       Values[i] = FromUndef ? DAG.getUNDEF(AggValueVTs[i]) :
3266                   SDValue(Val.getNode(), Val.getResNo() + i - LinearIndex);
3267   }
3268   // Copy remaining value(s) from the original aggregate.
3269   for (; i != NumAggValues; ++i)
3270     Values[i] = IntoUndef ? DAG.getUNDEF(AggValueVTs[i]) :
3271                 SDValue(Agg.getNode(), Agg.getResNo() + i);
3273   setValue(&I, DAG.getNode(ISD::MERGE_VALUES, getCurSDLoc(),
3274                            DAG.getVTList(AggValueVTs),
3275                            &Values[0], NumAggValues));
3278 void SelectionDAGBuilder::visitExtractValue(const ExtractValueInst &I) {
3279   const Value *Op0 = I.getOperand(0);
3280   Type *AggTy = Op0->getType();
3281   Type *ValTy = I.getType();
3282   bool OutOfUndef = isa<UndefValue>(Op0);
3284   unsigned LinearIndex = ComputeLinearIndex(AggTy, I.getIndices());
3286   const TargetLowering *TLI = TM.getTargetLowering();
3287   SmallVector<EVT, 4> ValValueVTs;
3288   ComputeValueVTs(*TLI, ValTy, ValValueVTs);
3290   unsigned NumValValues = ValValueVTs.size();
3292   // Ignore a extractvalue that produces an empty object
3293   if (!NumValValues) {
3294     setValue(&I, DAG.getUNDEF(MVT(MVT::Other)));
3295     return;
3296   }
3298   SmallVector<SDValue, 4> Values(NumValValues);
3300   SDValue Agg = getValue(Op0);
3301   // Copy out the selected value(s).
3302   for (unsigned i = LinearIndex; i != LinearIndex + NumValValues; ++i)
3303     Values[i - LinearIndex] =
3304       OutOfUndef ?
3305         DAG.getUNDEF(Agg.getNode()->getValueType(Agg.getResNo() + i)) :
3306         SDValue(Agg.getNode(), Agg.getResNo() + i);
3308   setValue(&I, DAG.getNode(ISD::MERGE_VALUES, getCurSDLoc(),
3309                            DAG.getVTList(ValValueVTs),
3310                            &Values[0], NumValValues));
3313 void SelectionDAGBuilder::visitGetElementPtr(const User &I) {
3314   Value *Op0 = I.getOperand(0);
3315   // Note that the pointer operand may be a vector of pointers. Take the scalar
3316   // element which holds a pointer.
3317   Type *Ty = Op0->getType()->getScalarType();
3318   unsigned AS = Ty->getPointerAddressSpace();
3319   SDValue N = getValue(Op0);
3321   for (GetElementPtrInst::const_op_iterator OI = I.op_begin()+1, E = I.op_end();
3322        OI != E; ++OI) {
3323     const Value *Idx = *OI;
3324     if (StructType *StTy = dyn_cast<StructType>(Ty)) {
3325       unsigned Field = cast<Constant>(Idx)->getUniqueInteger().getZExtValue();
3326       if (Field) {
3327         // N = N + Offset
3328         uint64_t Offset = DL->getStructLayout(StTy)->getElementOffset(Field);
3329         N = DAG.getNode(ISD::ADD, getCurSDLoc(), N.getValueType(), N,
3330                         DAG.getConstant(Offset, N.getValueType()));
3331       }
3333       Ty = StTy->getElementType(Field);
3334     } else {
3335       Ty = cast<SequentialType>(Ty)->getElementType();
3337       // If this is a constant subscript, handle it quickly.
3338       const TargetLowering *TLI = TM.getTargetLowering();
3339       if (const ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) {
3340         if (CI->isZero()) continue;
3341         uint64_t Offs =
3342             DL->getTypeAllocSize(Ty)*cast<ConstantInt>(CI)->getSExtValue();
3343         SDValue OffsVal;
3344         EVT PTy = TLI->getPointerTy(AS);
3345         unsigned PtrBits = PTy.getSizeInBits();
3346         if (PtrBits < 64)
3347           OffsVal = DAG.getNode(ISD::TRUNCATE, getCurSDLoc(), PTy,
3348                                 DAG.getConstant(Offs, MVT::i64));
3349         else
3350           OffsVal = DAG.getConstant(Offs, PTy);
3352         N = DAG.getNode(ISD::ADD, getCurSDLoc(), N.getValueType(), N,
3353                         OffsVal);
3354         continue;
3355       }
3357       // N = N + Idx * ElementSize;
3358       APInt ElementSize = APInt(TLI->getPointerSizeInBits(AS),
3359                                 DL->getTypeAllocSize(Ty));
3360       SDValue IdxN = getValue(Idx);
3362       // If the index is smaller or larger than intptr_t, truncate or extend
3363       // it.
3364       IdxN = DAG.getSExtOrTrunc(IdxN, getCurSDLoc(), N.getValueType());
3366       // If this is a multiply by a power of two, turn it into a shl
3367       // immediately.  This is a very common case.
3368       if (ElementSize != 1) {
3369         if (ElementSize.isPowerOf2()) {
3370           unsigned Amt = ElementSize.logBase2();
3371           IdxN = DAG.getNode(ISD::SHL, getCurSDLoc(),
3372                              N.getValueType(), IdxN,
3373                              DAG.getConstant(Amt, IdxN.getValueType()));
3374         } else {
3375           SDValue Scale = DAG.getConstant(ElementSize, IdxN.getValueType());
3376           IdxN = DAG.getNode(ISD::MUL, getCurSDLoc(),
3377                              N.getValueType(), IdxN, Scale);
3378         }
3379       }
3381       N = DAG.getNode(ISD::ADD, getCurSDLoc(),
3382                       N.getValueType(), N, IdxN);
3383     }
3384   }
3386   setValue(&I, N);
3389 void SelectionDAGBuilder::visitAlloca(const AllocaInst &I) {
3390   // If this is a fixed sized alloca in the entry block of the function,
3391   // allocate it statically on the stack.
3392   if (FuncInfo.StaticAllocaMap.count(&I))
3393     return;   // getValue will auto-populate this.
3395   Type *Ty = I.getAllocatedType();
3396   const TargetLowering *TLI = TM.getTargetLowering();
3397   uint64_t TySize = TLI->getDataLayout()->getTypeAllocSize(Ty);
3398   unsigned Align =
3399     std::max((unsigned)TLI->getDataLayout()->getPrefTypeAlignment(Ty),
3400              I.getAlignment());
3402   SDValue AllocSize = getValue(I.getArraySize());
3404   EVT IntPtr = TLI->getPointerTy();
3405   if (AllocSize.getValueType() != IntPtr)
3406     AllocSize = DAG.getZExtOrTrunc(AllocSize, getCurSDLoc(), IntPtr);
3408   AllocSize = DAG.getNode(ISD::MUL, getCurSDLoc(), IntPtr,
3409                           AllocSize,
3410                           DAG.getConstant(TySize, IntPtr));
3412   // Handle alignment.  If the requested alignment is less than or equal to
3413   // the stack alignment, ignore it.  If the size is greater than or equal to
3414   // the stack alignment, we note this in the DYNAMIC_STACKALLOC node.
3415   unsigned StackAlign = TM.getFrameLowering()->getStackAlignment();
3416   if (Align <= StackAlign)
3417     Align = 0;
3419   // Round the size of the allocation up to the stack alignment size
3420   // by add SA-1 to the size.
3421   AllocSize = DAG.getNode(ISD::ADD, getCurSDLoc(),
3422                           AllocSize.getValueType(), AllocSize,
3423                           DAG.getIntPtrConstant(StackAlign-1));
3425   // Mask out the low bits for alignment purposes.
3426   AllocSize = DAG.getNode(ISD::AND, getCurSDLoc(),
3427                           AllocSize.getValueType(), AllocSize,
3428                           DAG.getIntPtrConstant(~(uint64_t)(StackAlign-1)));
3430   SDValue Ops[] = { getRoot(), AllocSize, DAG.getIntPtrConstant(Align) };
3431   SDVTList VTs = DAG.getVTList(AllocSize.getValueType(), MVT::Other);
3432   SDValue DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, getCurSDLoc(),
3433                             VTs, Ops, 3);
3434   setValue(&I, DSA);
3435   DAG.setRoot(DSA.getValue(1));
3437   assert(FuncInfo.MF->getFrameInfo()->hasVarSizedObjects());
3440 void SelectionDAGBuilder::visitLoad(const LoadInst &I) {
3441   if (I.isAtomic())
3442     return visitAtomicLoad(I);
3444   const Value *SV = I.getOperand(0);
3445   SDValue Ptr = getValue(SV);
3447   Type *Ty = I.getType();
3449   bool isVolatile = I.isVolatile();
3450   bool isNonTemporal = I.getMetadata("nontemporal") != nullptr;
3451   bool isInvariant = I.getMetadata("invariant.load") != nullptr;
3452   unsigned Alignment = I.getAlignment();
3453   const MDNode *TBAAInfo = I.getMetadata(LLVMContext::MD_tbaa);
3454   const MDNode *Ranges = I.getMetadata(LLVMContext::MD_range);
3456   SmallVector<EVT, 4> ValueVTs;
3457   SmallVector<uint64_t, 4> Offsets;
3458   ComputeValueVTs(*TM.getTargetLowering(), Ty, ValueVTs, &Offsets);
3459   unsigned NumValues = ValueVTs.size();
3460   if (NumValues == 0)
3461     return;
3463   SDValue Root;
3464   bool ConstantMemory = false;
3465   if (isVolatile || NumValues > MaxParallelChains)
3466     // Serialize volatile loads with other side effects.
3467     Root = getRoot();
3468   else if (AA->pointsToConstantMemory(
3469              AliasAnalysis::Location(SV, AA->getTypeStoreSize(Ty), TBAAInfo))) {
3470     // Do not serialize (non-volatile) loads of constant memory with anything.
3471     Root = DAG.getEntryNode();
3472     ConstantMemory = true;
3473   } else {
3474     // Do not serialize non-volatile loads against each other.
3475     Root = DAG.getRoot();
3476   }
3478   const TargetLowering *TLI = TM.getTargetLowering();
3479   if (isVolatile)
3480     Root = TLI->prepareVolatileOrAtomicLoad(Root, getCurSDLoc(), DAG);
3482   SmallVector<SDValue, 4> Values(NumValues);
3483   SmallVector<SDValue, 4> Chains(std::min(unsigned(MaxParallelChains),
3484                                           NumValues));
3485   EVT PtrVT = Ptr.getValueType();
3486   unsigned ChainI = 0;
3487   for (unsigned i = 0; i != NumValues; ++i, ++ChainI) {
3488     // Serializing loads here may result in excessive register pressure, and
3489     // TokenFactor places arbitrary choke points on the scheduler. SD scheduling
3490     // could recover a bit by hoisting nodes upward in the chain by recognizing
3491     // they are side-effect free or do not alias. The optimizer should really
3492     // avoid this case by converting large object/array copies to llvm.memcpy
3493     // (MaxParallelChains should always remain as failsafe).
3494     if (ChainI == MaxParallelChains) {
3495       assert(PendingLoads.empty() && "PendingLoads must be serialized first");
3496       SDValue Chain = DAG.getNode(ISD::TokenFactor, getCurSDLoc(),
3497                                   MVT::Other, &Chains[0], ChainI);
3498       Root = Chain;
3499       ChainI = 0;
3500     }
3501     SDValue A = DAG.getNode(ISD::ADD, getCurSDLoc(),
3502                             PtrVT, Ptr,
3503                             DAG.getConstant(Offsets[i], PtrVT));
3504     SDValue L = DAG.getLoad(ValueVTs[i], getCurSDLoc(), Root,
3505                             A, MachinePointerInfo(SV, Offsets[i]), isVolatile,
3506                             isNonTemporal, isInvariant, Alignment, TBAAInfo,
3507                             Ranges);
3509     Values[i] = L;
3510     Chains[ChainI] = L.getValue(1);
3511   }
3513   if (!ConstantMemory) {
3514     SDValue Chain = DAG.getNode(ISD::TokenFactor, getCurSDLoc(),
3515                                 MVT::Other, &Chains[0], ChainI);
3516     if (isVolatile)
3517       DAG.setRoot(Chain);
3518     else
3519       PendingLoads.push_back(Chain);
3520   }
3522   setValue(&I, DAG.getNode(ISD::MERGE_VALUES, getCurSDLoc(),
3523                            DAG.getVTList(ValueVTs),
3524                            &Values[0], NumValues));
3527 void SelectionDAGBuilder::visitStore(const StoreInst &I) {
3528   if (I.isAtomic())
3529     return visitAtomicStore(I);
3531   const Value *SrcV = I.getOperand(0);
3532   const Value *PtrV = I.getOperand(1);
3534   SmallVector<EVT, 4> ValueVTs;
3535   SmallVector<uint64_t, 4> Offsets;
3536   ComputeValueVTs(*TM.getTargetLowering(), SrcV->getType(), ValueVTs, &Offsets);
3537   unsigned NumValues = ValueVTs.size();
3538   if (NumValues == 0)
3539     return;
3541   // Get the lowered operands. Note that we do this after
3542   // checking if NumResults is zero, because with zero results
3543   // the operands won't have values in the map.
3544   SDValue Src = getValue(SrcV);
3545   SDValue Ptr = getValue(PtrV);
3547   SDValue Root = getRoot();
3548   SmallVector<SDValue, 4> Chains(std::min(unsigned(MaxParallelChains),
3549                                           NumValues));
3550   EVT PtrVT = Ptr.getValueType();
3551   bool isVolatile = I.isVolatile();
3552   bool isNonTemporal = I.getMetadata("nontemporal") != nullptr;
3553   unsigned Alignment = I.getAlignment();
3554   const MDNode *TBAAInfo = I.getMetadata(LLVMContext::MD_tbaa);
3556   unsigned ChainI = 0;
3557   for (unsigned i = 0; i != NumValues; ++i, ++ChainI) {
3558     // See visitLoad comments.
3559     if (ChainI == MaxParallelChains) {
3560       SDValue Chain = DAG.getNode(ISD::TokenFactor, getCurSDLoc(),
3561                                   MVT::Other, &Chains[0], ChainI);
3562       Root = Chain;
3563       ChainI = 0;
3564     }
3565     SDValue Add = DAG.getNode(ISD::ADD, getCurSDLoc(), PtrVT, Ptr,
3566                               DAG.getConstant(Offsets[i], PtrVT));
3567     SDValue St = DAG.getStore(Root, getCurSDLoc(),
3568                               SDValue(Src.getNode(), Src.getResNo() + i),
3569                               Add, MachinePointerInfo(PtrV, Offsets[i]),
3570                               isVolatile, isNonTemporal, Alignment, TBAAInfo);
3571     Chains[ChainI] = St;
3572   }
3574   SDValue StoreNode = DAG.getNode(ISD::TokenFactor, getCurSDLoc(),
3575                                   MVT::Other, &Chains[0], ChainI);
3576   DAG.setRoot(StoreNode);
3579 static SDValue InsertFenceForAtomic(SDValue Chain, AtomicOrdering Order,
3580                                     SynchronizationScope Scope,
3581                                     bool Before, SDLoc dl,
3582                                     SelectionDAG &DAG,
3583                                     const TargetLowering &TLI) {
3584   // Fence, if necessary
3585   if (Before) {
3586     if (Order == AcquireRelease || Order == SequentiallyConsistent)
3587       Order = Release;
3588     else if (Order == Acquire || Order == Monotonic)
3589       return Chain;
3590   } else {
3591     if (Order == AcquireRelease)
3592       Order = Acquire;
3593     else if (Order == Release || Order == Monotonic)
3594       return Chain;
3595   }
3596   SDValue Ops[3];
3597   Ops[0] = Chain;
3598   Ops[1] = DAG.getConstant(Order, TLI.getPointerTy());
3599   Ops[2] = DAG.getConstant(Scope, TLI.getPointerTy());
3600   return DAG.getNode(ISD::ATOMIC_FENCE, dl, MVT::Other, Ops, 3);
3603 void SelectionDAGBuilder::visitAtomicCmpXchg(const AtomicCmpXchgInst &I) {
3604   SDLoc dl = getCurSDLoc();
3605   AtomicOrdering SuccessOrder = I.getSuccessOrdering();
3606   AtomicOrdering FailureOrder = I.getFailureOrdering();
3607   SynchronizationScope Scope = I.getSynchScope();
3609   SDValue InChain = getRoot();
3611   const TargetLowering *TLI = TM.getTargetLowering();
3612   if (TLI->getInsertFencesForAtomic())
3613     InChain = InsertFenceForAtomic(InChain, SuccessOrder, Scope, true, dl,
3614                                    DAG, *TLI);
3616   SDValue L =
3617     DAG.getAtomic(ISD::ATOMIC_CMP_SWAP, dl,
3618                   getValue(I.getCompareOperand()).getSimpleValueType(),
3619                   InChain,
3620                   getValue(I.getPointerOperand()),
3621                   getValue(I.getCompareOperand()),
3622                   getValue(I.getNewValOperand()),
3623                   MachinePointerInfo(I.getPointerOperand()), 0 /* Alignment */,
3624                   TLI->getInsertFencesForAtomic() ? Monotonic : SuccessOrder,
3625                   TLI->getInsertFencesForAtomic() ? Monotonic : FailureOrder,
3626                   Scope);
3628   SDValue OutChain = L.getValue(1);