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