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/SmallSet.h"
  19 #include "llvm/Analysis/AliasAnalysis.h"
  20 #include "llvm/Analysis/ConstantFolding.h"
  21 #include "llvm/Constants.h"
  22 #include "llvm/CallingConv.h"
  23 #include "llvm/DerivedTypes.h"
  24 #include "llvm/Function.h"
  25 #include "llvm/GlobalVariable.h"
  26 #include "llvm/InlineAsm.h"
  27 #include "llvm/Instructions.h"
  28 #include "llvm/Intrinsics.h"
  29 #include "llvm/IntrinsicInst.h"
  30 #include "llvm/LLVMContext.h"
  31 #include "llvm/Module.h"
  32 #include "llvm/CodeGen/Analysis.h"
  33 #include "llvm/CodeGen/FastISel.h"
  34 #include "llvm/CodeGen/FunctionLoweringInfo.h"
  35 #include "llvm/CodeGen/GCStrategy.h"
  36 #include "llvm/CodeGen/GCMetadata.h"
  37 #include "llvm/CodeGen/MachineFunction.h"
  38 #include "llvm/CodeGen/MachineFrameInfo.h"
  39 #include "llvm/CodeGen/MachineInstrBuilder.h"
  40 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  41 #include "llvm/CodeGen/MachineModuleInfo.h"
  42 #include "llvm/CodeGen/MachineRegisterInfo.h"
  43 #include "llvm/CodeGen/PseudoSourceValue.h"
  44 #include "llvm/CodeGen/SelectionDAG.h"
  45 #include "llvm/Analysis/DebugInfo.h"
  46 #include "llvm/Target/TargetRegisterInfo.h"
  47 #include "llvm/Target/TargetData.h"
  48 #include "llvm/Target/TargetFrameInfo.h"
  49 #include "llvm/Target/TargetInstrInfo.h"
  50 #include "llvm/Target/TargetIntrinsicInfo.h"
  51 #include "llvm/Target/TargetLowering.h"
  52 #include "llvm/Target/TargetOptions.h"
  53 #include "llvm/Support/Compiler.h"
  54 #include "llvm/Support/CommandLine.h"
  55 #include "llvm/Support/Debug.h"
  56 #include "llvm/Support/ErrorHandling.h"
  57 #include "llvm/Support/MathExtras.h"
  58 #include "llvm/Support/raw_ostream.h"
  59 #include <algorithm>
  60 using namespace llvm;
  61
  62 /// LimitFloatPrecision - Generate low-precision inline sequences for
  63 /// some float libcalls (6, 8 or 12 bits).
  64 static unsigned LimitFloatPrecision;
  65
  66 static cl::opt<unsigned, true>
  67 LimitFPPrecision("limit-float-precision",
  68                  cl::desc("Generate low-precision inline sequences "
  69                           "for some float libcalls"),
  70                  cl::location(LimitFloatPrecision),
  71                  cl::init(0));
  72
  73 static SDValue getCopyFromPartsVector(SelectionDAG &DAG, DebugLoc DL,
  74                                       const SDValue *Parts, unsigned NumParts,
  75                                       EVT PartVT, EVT ValueVT);
  76
  77 /// getCopyFromParts - Create a value that contains the specified legal parts
  78 /// combined into the value they represent.  If the parts combine to a type
  79 /// larger then ValueVT then AssertOp can be used to specify whether the extra
  80 /// bits are known to be zero (ISD::AssertZext) or sign extended from ValueVT
  81 /// (ISD::AssertSext).
  82 static SDValue getCopyFromParts(SelectionDAG &DAG, DebugLoc DL,
  83                                 const SDValue *Parts,
  84                                 unsigned NumParts, EVT PartVT, EVT ValueVT,
  85                                 ISD::NodeType AssertOp = ISD::DELETED_NODE) {
  86   if (ValueVT.isVector())
  87     return getCopyFromPartsVector(DAG, DL, Parts, NumParts, PartVT, ValueVT);
  88
  89   assert(NumParts > 0 && "No parts to assemble!");
  90   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
  91   SDValue Val = Parts[0];
  92
  93   if (NumParts > 1) {
  94     // Assemble the value from multiple parts.
  95     if (ValueVT.isInteger()) {
  96       unsigned PartBits = PartVT.getSizeInBits();
  97       unsigned ValueBits = ValueVT.getSizeInBits();
  98
  99       // Assemble the power of 2 part.
 100       unsigned RoundParts = NumParts & (NumParts - 1) ?
 101         1 << Log2_32(NumParts) : NumParts;
 102       unsigned RoundBits = PartBits * RoundParts;
 103       EVT RoundVT = RoundBits == ValueBits ?
 104         ValueVT : EVT::getIntegerVT(*DAG.getContext(), RoundBits);
 105       SDValue Lo, Hi;
 106
 107       EVT HalfVT = EVT::getIntegerVT(*DAG.getContext(), RoundBits/2);
 108
 109       if (RoundParts > 2) {
 110         Lo = getCopyFromParts(DAG, DL, Parts, RoundParts / 2,
 111                               PartVT, HalfVT);
 112         Hi = getCopyFromParts(DAG, DL, Parts + RoundParts / 2,
 113                               RoundParts / 2, PartVT, HalfVT);
 114       } else {
 115         Lo = DAG.getNode(ISD::BIT_CONVERT, DL, HalfVT, Parts[0]);
 116         Hi = DAG.getNode(ISD::BIT_CONVERT, DL, HalfVT, Parts[1]);
 117       }
 118
 119       if (TLI.isBigEndian())
 120         std::swap(Lo, Hi);
 121
 122       Val = DAG.getNode(ISD::BUILD_PAIR, DL, RoundVT, Lo, Hi);
 123
 124       if (RoundParts < NumParts) {
 125         // Assemble the trailing non-power-of-2 part.
 126         unsigned OddParts = NumParts - RoundParts;
 127         EVT OddVT = EVT::getIntegerVT(*DAG.getContext(), OddParts * PartBits);
 128         Hi = getCopyFromParts(DAG, DL,
 129                               Parts + RoundParts, OddParts, PartVT, OddVT);
 130
 131         // Combine the round and odd parts.
 132         Lo = Val;
 133         if (TLI.isBigEndian())
 134           std::swap(Lo, Hi);
 135         EVT TotalVT = EVT::getIntegerVT(*DAG.getContext(), NumParts * PartBits);
 136         Hi = DAG.getNode(ISD::ANY_EXTEND, DL, TotalVT, Hi);
 137         Hi = DAG.getNode(ISD::SHL, DL, TotalVT, Hi,
 138                          DAG.getConstant(Lo.getValueType().getSizeInBits(),
 139                                          TLI.getPointerTy()));
 140         Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, TotalVT, Lo);
 141         Val = DAG.getNode(ISD::OR, DL, TotalVT, Lo, Hi);
 142       }
 143     } else if (PartVT.isFloatingPoint()) {
 144       // FP split into multiple FP parts (for ppcf128)
 145       assert(ValueVT == EVT(MVT::ppcf128) && PartVT == EVT(MVT::f64) &&
 146              "Unexpected split");
 147       SDValue Lo, Hi;
 148       Lo = DAG.getNode(ISD::BIT_CONVERT, DL, EVT(MVT::f64), Parts[0]);
 149       Hi = DAG.getNode(ISD::BIT_CONVERT, DL, EVT(MVT::f64), Parts[1]);
 150       if (TLI.isBigEndian())
 151         std::swap(Lo, Hi);
 152       Val = DAG.getNode(ISD::BUILD_PAIR, DL, ValueVT, Lo, Hi);
 153     } else {
 154       // FP split into integer parts (soft fp)
 155       assert(ValueVT.isFloatingPoint() && PartVT.isInteger() &&
 156              !PartVT.isVector() && "Unexpected split");
 157       EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), ValueVT.getSizeInBits());
 158       Val = getCopyFromParts(DAG, DL, Parts, NumParts, PartVT, IntVT);
 159     }
 160   }
 161
 162   // There is now one part, held in Val.  Correct it to match ValueVT.
 163   PartVT = Val.getValueType();
 164
 165   if (PartVT == ValueVT)
 166     return Val;
 167
 168   if (PartVT.isInteger() && ValueVT.isInteger()) {
 169     if (ValueVT.bitsLT(PartVT)) {
 170       // For a truncate, see if we have any information to
 171       // indicate whether the truncated bits will always be
 172       // zero or sign-extension.
 173       if (AssertOp != ISD::DELETED_NODE)
 174         Val = DAG.getNode(AssertOp, DL, PartVT, Val,
 175                           DAG.getValueType(ValueVT));
 176       return DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
 177     }
 178     return DAG.getNode(ISD::ANY_EXTEND, DL, ValueVT, Val);
 179   }
 180
 181   if (PartVT.isFloatingPoint() && ValueVT.isFloatingPoint()) {
 182     // FP_ROUND's are always exact here.
 183     if (ValueVT.bitsLT(Val.getValueType()))
 184       return DAG.getNode(ISD::FP_ROUND, DL, ValueVT, Val,
 185                          DAG.getIntPtrConstant(1));
 186
 187     return DAG.getNode(ISD::FP_EXTEND, DL, ValueVT, Val);
 188   }
 189
 190   if (PartVT.getSizeInBits() == ValueVT.getSizeInBits())
 191     return DAG.getNode(ISD::BIT_CONVERT, DL, ValueVT, Val);
 192
 193   llvm_unreachable("Unknown mismatch!");
 194   return SDValue();
 195 }
 196
 197 /// getCopyFromParts - Create a value that contains the specified legal parts
 198 /// combined into the value they represent.  If the parts combine to a type
 199 /// larger then ValueVT then AssertOp can be used to specify whether the extra
 200 /// bits are known to be zero (ISD::AssertZext) or sign extended from ValueVT
 201 /// (ISD::AssertSext).
 202 static SDValue getCopyFromPartsVector(SelectionDAG &DAG, DebugLoc DL,
 203                                       const SDValue *Parts, unsigned NumParts,
 204                                       EVT PartVT, EVT ValueVT) {
 205   assert(ValueVT.isVector() && "Not a vector value");
 206   assert(NumParts > 0 && "No parts to assemble!");
 207   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
 208   SDValue Val = Parts[0];
 209
 210   // Handle a multi-element vector.
 211   if (NumParts > 1) {
 212     EVT IntermediateVT, RegisterVT;
 213     unsigned NumIntermediates;
 214     unsigned NumRegs =
 215     TLI.getVectorTypeBreakdown(*DAG.getContext(), ValueVT, IntermediateVT,
 216                                NumIntermediates, RegisterVT);
 217     assert(NumRegs == NumParts && "Part count doesn't match vector breakdown!");
 218     NumParts = NumRegs; // Silence a compiler warning.
 219     assert(RegisterVT == PartVT && "Part type doesn't match vector breakdown!");
 220     assert(RegisterVT == Parts[0].getValueType() &&
 221            "Part type doesn't match part!");
 222
 223     // Assemble the parts into intermediate operands.
 224     SmallVector<SDValue, 8> Ops(NumIntermediates);
 225     if (NumIntermediates == NumParts) {
 226       // If the register was not expanded, truncate or copy the value,
 227       // as appropriate.
 228       for (unsigned i = 0; i != NumParts; ++i)
 229         Ops[i] = getCopyFromParts(DAG, DL, &Parts[i], 1,
 230                                   PartVT, IntermediateVT);
 231     } else if (NumParts > 0) {
 232       // If the intermediate type was expanded, build the intermediate
 233       // operands from the parts.
 234       assert(NumParts % NumIntermediates == 0 &&
 235              "Must expand into a divisible number of parts!");
 236       unsigned Factor = NumParts / NumIntermediates;
 237       for (unsigned i = 0; i != NumIntermediates; ++i)
 238         Ops[i] = getCopyFromParts(DAG, DL, &Parts[i * Factor], Factor,
 239                                   PartVT, IntermediateVT);
 240     }
 241
 242     // Build a vector with BUILD_VECTOR or CONCAT_VECTORS from the
 243     // intermediate operands.
 244     Val = DAG.getNode(IntermediateVT.isVector() ?
 245                       ISD::CONCAT_VECTORS : ISD::BUILD_VECTOR, DL,
 246                       ValueVT, &Ops[0], NumIntermediates);
 247   }
 248
 249   // There is now one part, held in Val.  Correct it to match ValueVT.
 250   PartVT = Val.getValueType();
 251
 252   if (PartVT == ValueVT)
 253     return Val;
 254
 255   if (PartVT.isVector()) {
 256     // If the element type of the source/dest vectors are the same, but the
 257     // parts vector has more elements than the value vector, then we have a
 258     // vector widening case (e.g. <2 x float> -> <4 x float>).  Extract the
 259     // elements we want.
 260     if (PartVT.getVectorElementType() == ValueVT.getVectorElementType()) {
 261       assert(PartVT.getVectorNumElements() > ValueVT.getVectorNumElements() &&
 262              "Cannot narrow, it would be a lossy transformation");
 263       return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, ValueVT, Val,
 264                          DAG.getIntPtrConstant(0));
 265     }
 266
 267     // Vector/Vector bitcast.
 268     return DAG.getNode(ISD::BIT_CONVERT, DL, ValueVT, Val);
 269   }
 270
 271   assert(ValueVT.getVectorElementType() == PartVT &&
 272          ValueVT.getVectorNumElements() == 1 &&
 273          "Only trivial scalar-to-vector conversions should get here!");
 274   return DAG.getNode(ISD::BUILD_VECTOR, DL, ValueVT, Val);
 275 }
 276
 277
 278
 279
 280 static void getCopyToPartsVector(SelectionDAG &DAG, DebugLoc dl,
 281                                  SDValue Val, SDValue *Parts, unsigned NumParts,
 282                                  EVT PartVT);
 283
 284 /// getCopyToParts - Create a series of nodes that contain the specified value
 285 /// split into legal parts.  If the parts contain more bits than Val, then, for
 286 /// integers, ExtendKind can be used to specify how to generate the extra bits.
 287 static void getCopyToParts(SelectionDAG &DAG, DebugLoc DL,
 288                            SDValue Val, SDValue *Parts, unsigned NumParts,
 289                            EVT PartVT,
 290                            ISD::NodeType ExtendKind = ISD::ANY_EXTEND) {
 291   EVT ValueVT = Val.getValueType();
 292
 293   // Handle the vector case separately.
 294   if (ValueVT.isVector())
 295     return getCopyToPartsVector(DAG, DL, Val, Parts, NumParts, PartVT);
 296
 297   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
 298   unsigned PartBits = PartVT.getSizeInBits();
 299   unsigned OrigNumParts = NumParts;
 300   assert(TLI.isTypeLegal(PartVT) && "Copying to an illegal type!");
 301
 302   if (NumParts == 0)
 303     return;
 304
 305   assert(!ValueVT.isVector() && "Vector case handled elsewhere");
 306   if (PartVT == ValueVT) {
 307     assert(NumParts == 1 && "No-op copy with multiple parts!");
 308     Parts[0] = Val;
 309     return;
 310   }
 311
 312   if (NumParts * PartBits > ValueVT.getSizeInBits()) {
 313     // If the parts cover more bits than the value has, promote the value.
 314     if (PartVT.isFloatingPoint() && ValueVT.isFloatingPoint()) {
 315       assert(NumParts == 1 && "Do not know what to promote to!");
 316       Val = DAG.getNode(ISD::FP_EXTEND, DL, PartVT, Val);
 317     } else {
 318       assert(PartVT.isInteger() && ValueVT.isInteger() &&
 319              "Unknown mismatch!");
 320       ValueVT = EVT::getIntegerVT(*DAG.getContext(), NumParts * PartBits);
 321       Val = DAG.getNode(ExtendKind, DL, ValueVT, Val);
 322     }
 323   } else if (PartBits == ValueVT.getSizeInBits()) {
 324     // Different types of the same size.
 325     assert(NumParts == 1 && PartVT != ValueVT);
 326     Val = DAG.getNode(ISD::BIT_CONVERT, DL, PartVT, Val);
 327   } else if (NumParts * PartBits < ValueVT.getSizeInBits()) {
 328     // If the parts cover less bits than value has, truncate the value.
 329     assert(PartVT.isInteger() && ValueVT.isInteger() &&
 330            "Unknown mismatch!");
 331     ValueVT = EVT::getIntegerVT(*DAG.getContext(), NumParts * PartBits);
 332     Val = DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
 333   }
 334
 335   // The value may have changed - recompute ValueVT.
 336   ValueVT = Val.getValueType();
 337   assert(NumParts * PartBits == ValueVT.getSizeInBits() &&
 338          "Failed to tile the value with PartVT!");
 339
 340   if (NumParts == 1) {
 341     assert(PartVT == ValueVT && "Type conversion failed!");
 342     Parts[0] = Val;
 343     return;
 344   }
 345
 346   // Expand the value into multiple parts.
 347   if (NumParts & (NumParts - 1)) {
 348     // The number of parts is not a power of 2.  Split off and copy the tail.
 349     assert(PartVT.isInteger() && ValueVT.isInteger() &&
 350            "Do not know what to expand to!");
 351     unsigned RoundParts = 1 << Log2_32(NumParts);
 352     unsigned RoundBits = RoundParts * PartBits;
 353     unsigned OddParts = NumParts - RoundParts;
 354     SDValue OddVal = DAG.getNode(ISD::SRL, DL, ValueVT, Val,
 355                                  DAG.getIntPtrConstant(RoundBits));
 356     getCopyToParts(DAG, DL, OddVal, Parts + RoundParts, OddParts, PartVT);
 357
 358     if (TLI.isBigEndian())
 359       // The odd parts were reversed by getCopyToParts - unreverse them.
 360       std::reverse(Parts + RoundParts, Parts + NumParts);
 361
 362     NumParts = RoundParts;
 363     ValueVT = EVT::getIntegerVT(*DAG.getContext(), NumParts * PartBits);
 364     Val = DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
 365   }
 366
 367   // The number of parts is a power of 2.  Repeatedly bisect the value using
 368   // EXTRACT_ELEMENT.
 369   Parts[0] = DAG.getNode(ISD::BIT_CONVERT, DL,
 370                          EVT::getIntegerVT(*DAG.getContext(),
 371                                            ValueVT.getSizeInBits()),
 372                          Val);
 373
 374   for (unsigned StepSize = NumParts; StepSize > 1; StepSize /= 2) {
 375     for (unsigned i = 0; i < NumParts; i += StepSize) {
 376       unsigned ThisBits = StepSize * PartBits / 2;
 377       EVT ThisVT = EVT::getIntegerVT(*DAG.getContext(), ThisBits);
 378       SDValue &Part0 = Parts[i];
 379       SDValue &Part1 = Parts[i+StepSize/2];
 380
 381       Part1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL,
 382                           ThisVT, Part0, DAG.getIntPtrConstant(1));
 383       Part0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL,
 384                           ThisVT, Part0, DAG.getIntPtrConstant(0));
 385
 386       if (ThisBits == PartBits && ThisVT != PartVT) {
 387         Part0 = DAG.getNode(ISD::BIT_CONVERT, DL, PartVT, Part0);
 388         Part1 = DAG.getNode(ISD::BIT_CONVERT, DL, PartVT, Part1);
 389       }
 390     }
 391   }
 392
 393   if (TLI.isBigEndian())
 394     std::reverse(Parts, Parts + OrigNumParts);
 395 }
 396
 397
 398 /// getCopyToPartsVector - Create a series of nodes that contain the specified
 399 /// value split into legal parts.
 400 static void getCopyToPartsVector(SelectionDAG &DAG, DebugLoc DL,
 401                                  SDValue Val, SDValue *Parts, unsigned NumParts,
 402                                  EVT PartVT) {
 403   EVT ValueVT = Val.getValueType();
 404   assert(ValueVT.isVector() && "Not a vector");
 405   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
 406
 407   if (NumParts == 1) {
 408     if (PartVT == ValueVT) {
 409       // Nothing to do.
 410     } else if (PartVT.getSizeInBits() == ValueVT.getSizeInBits()) {
 411       // Bitconvert vector->vector case.
 412       Val = DAG.getNode(ISD::BIT_CONVERT, DL, PartVT, Val);
 413     } else if (PartVT.isVector() &&
 414                PartVT.getVectorElementType() == ValueVT.getVectorElementType()&&
 415                PartVT.getVectorNumElements() > ValueVT.getVectorNumElements()) {
 416       EVT ElementVT = PartVT.getVectorElementType();
 417       // Vector widening case, e.g. <2 x float> -> <4 x float>.  Shuffle in
 418       // undef elements.
 419       SmallVector<SDValue, 16> Ops;
 420       for (unsigned i = 0, e = ValueVT.getVectorNumElements(); i != e; ++i)
 421         Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL,
 422                                   ElementVT, Val, DAG.getIntPtrConstant(i)));
 423
 424       for (unsigned i = ValueVT.getVectorNumElements(),
 425            e = PartVT.getVectorNumElements(); i != e; ++i)
 426         Ops.push_back(DAG.getUNDEF(ElementVT));
 427
 428       Val = DAG.getNode(ISD::BUILD_VECTOR, DL, PartVT, &Ops[0], Ops.size());
 429
 430       // FIXME: Use CONCAT for 2x -> 4x.
 431
 432       //SDValue UndefElts = DAG.getUNDEF(VectorTy);
 433       //Val = DAG.getNode(ISD::CONCAT_VECTORS, DL, PartVT, Val, UndefElts);
 434     } else {
 435       // Vector -> scalar conversion.
 436       assert(ValueVT.getVectorElementType() == PartVT &&
 437              ValueVT.getVectorNumElements() == 1 &&
 438              "Only trivial vector-to-scalar conversions should get here!");
 439       Val = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL,
 440                         PartVT, Val, DAG.getIntPtrConstant(0));
 441     }
 442
 443     Parts[0] = Val;
 444     return;
 445   }
 446
 447   // Handle a multi-element vector.
 448   EVT IntermediateVT, RegisterVT;
 449   unsigned NumIntermediates;
 450   unsigned NumRegs = TLI.getVectorTypeBreakdown(*DAG.getContext(), ValueVT,
 451                                                 IntermediateVT,
 452                                                 NumIntermediates, RegisterVT);
 453   unsigned NumElements = ValueVT.getVectorNumElements();
 454
 455   assert(NumRegs == NumParts && "Part count doesn't match vector breakdown!");
 456   NumParts = NumRegs; // Silence a compiler warning.
 457   assert(RegisterVT == PartVT && "Part type doesn't match vector breakdown!");
 458
 459   // Split the vector into intermediate operands.
 460   SmallVector<SDValue, 8> Ops(NumIntermediates);
 461   for (unsigned i = 0; i != NumIntermediates; ++i) {
 462     if (IntermediateVT.isVector())
 463       Ops[i] = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL,
 464                            IntermediateVT, Val,
 465                    DAG.getIntPtrConstant(i * (NumElements / NumIntermediates)));
 466     else
 467       Ops[i] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL,
 468                            IntermediateVT, Val, DAG.getIntPtrConstant(i));
 469   }
 470
 471   // Split the intermediate operands into legal parts.
 472   if (NumParts == NumIntermediates) {
 473     // If the register was not expanded, promote or copy the value,
 474     // as appropriate.
 475     for (unsigned i = 0; i != NumParts; ++i)
 476       getCopyToParts(DAG, DL, Ops[i], &Parts[i], 1, PartVT);
 477   } else if (NumParts > 0) {
 478     // If the intermediate type was expanded, split each the value into
 479     // legal parts.
 480     assert(NumParts % NumIntermediates == 0 &&
 481            "Must expand into a divisible number of parts!");
 482     unsigned Factor = NumParts / NumIntermediates;
 483     for (unsigned i = 0; i != NumIntermediates; ++i)
 484       getCopyToParts(DAG, DL, Ops[i], &Parts[i*Factor], Factor, PartVT);
 485   }
 486 }
 487
 488
 489
 490
 491 namespace {
 492   /// RegsForValue - This struct represents the registers (physical or virtual)
 493   /// that a particular set of values is assigned, and the type information
 494   /// about the value. The most common situation is to represent one value at a
 495   /// time, but struct or array values are handled element-wise as multiple
 496   /// values.  The splitting of aggregates is performed recursively, so that we
 497   /// never have aggregate-typed registers. The values at this point do not
 498   /// necessarily have legal types, so each value may require one or more
 499   /// registers of some legal type.
 500   ///
 501   struct RegsForValue {
 502     /// ValueVTs - The value types of the values, which may not be legal, and
 503     /// may need be promoted or synthesized from one or more registers.
 504     ///
 505     SmallVector<EVT, 4> ValueVTs;
 506
 507     /// RegVTs - The value types of the registers. This is the same size as
 508     /// ValueVTs and it records, for each value, what the type of the assigned
 509     /// register or registers are. (Individual values are never synthesized
 510     /// from more than one type of register.)
 511     ///
 512     /// With virtual registers, the contents of RegVTs is redundant with TLI's
 513     /// getRegisterType member function, however when with physical registers
 514     /// it is necessary to have a separate record of the types.
 515     ///
 516     SmallVector<EVT, 4> RegVTs;
 517
 518     /// Regs - This list holds the registers assigned to the values.
 519     /// Each legal or promoted value requires one register, and each
 520     /// expanded value requires multiple registers.
 521     ///
 522     SmallVector<unsigned, 4> Regs;
 523
 524     RegsForValue() {}
 525
 526     RegsForValue(const SmallVector<unsigned, 4> &regs,
 527                  EVT regvt, EVT valuevt)
 528       : ValueVTs(1, valuevt), RegVTs(1, regvt), Regs(regs) {}
 529
 530     RegsForValue(LLVMContext &Context, const TargetLowering &tli,
 531                  unsigned Reg, const Type *Ty) {
 532       ComputeValueVTs(tli, Ty, ValueVTs);
 533
 534       for (unsigned Value = 0, e = ValueVTs.size(); Value != e; ++Value) {
 535         EVT ValueVT = ValueVTs[Value];
 536         unsigned NumRegs = tli.getNumRegisters(Context, ValueVT);
 537         EVT RegisterVT = tli.getRegisterType(Context, ValueVT);
 538         for (unsigned i = 0; i != NumRegs; ++i)
 539           Regs.push_back(Reg + i);
 540         RegVTs.push_back(RegisterVT);
 541         Reg += NumRegs;
 542       }
 543     }
 544
 545     /// areValueTypesLegal - Return true if types of all the values are legal.
 546     bool areValueTypesLegal(const TargetLowering &TLI) {
 547       for (unsigned Value = 0, e = ValueVTs.size(); Value != e; ++Value) {
 548         EVT RegisterVT = RegVTs[Value];
 549         if (!TLI.isTypeLegal(RegisterVT))
 550           return false;
 551       }
 552       return true;
 553     }
 554
 555     /// append - Add the specified values to this one.
 556     void append(const RegsForValue &RHS) {
 557       ValueVTs.append(RHS.ValueVTs.begin(), RHS.ValueVTs.end());
 558       RegVTs.append(RHS.RegVTs.begin(), RHS.RegVTs.end());
 559       Regs.append(RHS.Regs.begin(), RHS.Regs.end());
 560     }
 561
 562     /// getCopyFromRegs - Emit a series of CopyFromReg nodes that copies from
 563     /// this value and returns the result as a ValueVTs value.  This uses
 564     /// Chain/Flag as the input and updates them for the output Chain/Flag.
 565     /// If the Flag pointer is NULL, no flag is used.
 566     SDValue getCopyFromRegs(SelectionDAG &DAG, FunctionLoweringInfo &FuncInfo,
 567                             DebugLoc dl,
 568                             SDValue &Chain, SDValue *Flag) const;
 569
 570     /// getCopyToRegs - Emit a series of CopyToReg nodes that copies the
 571     /// specified value into the registers specified by this object.  This uses
 572     /// Chain/Flag as the input and updates them for the output Chain/Flag.
 573     /// If the Flag pointer is NULL, no flag is used.
 574     void getCopyToRegs(SDValue Val, SelectionDAG &DAG, DebugLoc dl,
 575                        SDValue &Chain, SDValue *Flag) const;
 576
 577     /// AddInlineAsmOperands - Add this value to the specified inlineasm node
 578     /// operand list.  This adds the code marker, matching input operand index
 579     /// (if applicable), and includes the number of values added into it.
 580     void AddInlineAsmOperands(unsigned Kind,
 581                               bool HasMatching, unsigned MatchingIdx,
 582                               SelectionDAG &DAG,
 583                               std::vector<SDValue> &Ops) const;
 584   };
 585 }
 586
 587 /// getCopyFromRegs - Emit a series of CopyFromReg nodes that copies from
 588 /// this value and returns the result as a ValueVT value.  This uses
 589 /// Chain/Flag as the input and updates them for the output Chain/Flag.
 590 /// If the Flag pointer is NULL, no flag is used.
 591 SDValue RegsForValue::getCopyFromRegs(SelectionDAG &DAG,
 592                                       FunctionLoweringInfo &FuncInfo,
 593                                       DebugLoc dl,
 594                                       SDValue &Chain, SDValue *Flag) const {
 595   // A Value with type {} or [0 x %t] needs no registers.
 596   if (ValueVTs.empty())
 597     return SDValue();
 598
 599   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
 600
 601   // Assemble the legal parts into the final values.
 602   SmallVector<SDValue, 4> Values(ValueVTs.size());
 603   SmallVector<SDValue, 8> Parts;
 604   for (unsigned Value = 0, Part = 0, e = ValueVTs.size(); Value != e; ++Value) {
 605     // Copy the legal parts from the registers.
 606     EVT ValueVT = ValueVTs[Value];
 607     unsigned NumRegs = TLI.getNumRegisters(*DAG.getContext(), ValueVT);
 608     EVT RegisterVT = RegVTs[Value];
 609
 610     Parts.resize(NumRegs);
 611     for (unsigned i = 0; i != NumRegs; ++i) {
 612       SDValue P;
 613       if (Flag == 0) {
 614         P = DAG.getCopyFromReg(Chain, dl, Regs[Part+i], RegisterVT);
 615       } else {
 616         P = DAG.getCopyFromReg(Chain, dl, Regs[Part+i], RegisterVT, *Flag);
 617         *Flag = P.getValue(2);
 618       }
 619
 620       Chain = P.getValue(1);
 621
 622       // If the source register was virtual and if we know something about it,
 623       // add an assert node.
 624       if (TargetRegisterInfo::isVirtualRegister(Regs[Part+i]) &&
 625           RegisterVT.isInteger() && !RegisterVT.isVector()) {
 626         unsigned SlotNo = Regs[Part+i]-TargetRegisterInfo::FirstVirtualRegister;
 627         if (FuncInfo.LiveOutRegInfo.size() > SlotNo) {
 628           const FunctionLoweringInfo::LiveOutInfo &LOI =
 629             FuncInfo.LiveOutRegInfo[SlotNo];
 630
 631           unsigned RegSize = RegisterVT.getSizeInBits();
 632           unsigned NumSignBits = LOI.NumSignBits;
 633           unsigned NumZeroBits = LOI.KnownZero.countLeadingOnes();
 634
 635           // FIXME: We capture more information than the dag can represent.  For
 636           // now, just use the tightest assertzext/assertsext possible.
 637           bool isSExt = true;
 638           EVT FromVT(MVT::Other);
 639           if (NumSignBits == RegSize)
 640             isSExt = true, FromVT = MVT::i1;   // ASSERT SEXT 1
 641           else if (NumZeroBits >= RegSize-1)
 642             isSExt = false, FromVT = MVT::i1;  // ASSERT ZEXT 1
 643           else if (NumSignBits > RegSize-8)
 644             isSExt = true, FromVT = MVT::i8;   // ASSERT SEXT 8
 645           else if (NumZeroBits >= RegSize-8)
 646             isSExt = false, FromVT = MVT::i8;  // ASSERT ZEXT 8
 647           else if (NumSignBits > RegSize-16)
 648             isSExt = true, FromVT = MVT::i16;  // ASSERT SEXT 16
 649           else if (NumZeroBits >= RegSize-16)
 650             isSExt = false, FromVT = MVT::i16; // ASSERT ZEXT 16
 651           else if (NumSignBits > RegSize-32)
 652             isSExt = true, FromVT = MVT::i32;  // ASSERT SEXT 32
 653           else if (NumZeroBits >= RegSize-32)
 654             isSExt = false, FromVT = MVT::i32; // ASSERT ZEXT 32
 655
 656           if (FromVT != MVT::Other)
 657             P = DAG.getNode(isSExt ? ISD::AssertSext : ISD::AssertZext, dl,
 658                             RegisterVT, P, DAG.getValueType(FromVT));
 659         }
 660       }
 661
 662       Parts[i] = P;
 663     }
 664
 665     Values[Value] = getCopyFromParts(DAG, dl, Parts.begin(),
 666                                      NumRegs, RegisterVT, ValueVT);
 667     Part += NumRegs;
 668     Parts.clear();
 669   }
 670
 671   return DAG.getNode(ISD::MERGE_VALUES, dl,
 672                      DAG.getVTList(&ValueVTs[0], ValueVTs.size()),
 673                      &Values[0], ValueVTs.size());
 674 }
 675
 676 /// getCopyToRegs - Emit a series of CopyToReg nodes that copies the
 677 /// specified value into the registers specified by this object.  This uses
 678 /// Chain/Flag as the input and updates them for the output Chain/Flag.
 679 /// If the Flag pointer is NULL, no flag is used.
 680 void RegsForValue::getCopyToRegs(SDValue Val, SelectionDAG &DAG, DebugLoc dl,
 681                                  SDValue &Chain, SDValue *Flag) const {
 682   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
 683
 684   // Get the list of the values's legal parts.
 685   unsigned NumRegs = Regs.size();
 686   SmallVector<SDValue, 8> Parts(NumRegs);
 687   for (unsigned Value = 0, Part = 0, e = ValueVTs.size(); Value != e; ++Value) {
 688     EVT ValueVT = ValueVTs[Value];
 689     unsigned NumParts = TLI.getNumRegisters(*DAG.getContext(), ValueVT);
 690     EVT RegisterVT = RegVTs[Value];
 691
 692     getCopyToParts(DAG, dl, Val.getValue(Val.getResNo() + Value),
 693                    &Parts[Part], NumParts, RegisterVT);
 694     Part += NumParts;
 695   }
 696
 697   // Copy the parts into the registers.
 698   SmallVector<SDValue, 8> Chains(NumRegs);
 699   for (unsigned i = 0; i != NumRegs; ++i) {
 700     SDValue Part;
 701     if (Flag == 0) {
 702       Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i]);
 703     } else {
 704       Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i], *Flag);
 705       *Flag = Part.getValue(1);
 706     }
 707
 708     Chains[i] = Part.getValue(0);
 709   }
 710
 711   if (NumRegs == 1 || Flag)
 712     // If NumRegs > 1 && Flag is used then the use of the last CopyToReg is
 713     // flagged to it. That is the CopyToReg nodes and the user are considered
 714     // a single scheduling unit. If we create a TokenFactor and return it as
 715     // chain, then the TokenFactor is both a predecessor (operand) of the
 716     // user as well as a successor (the TF operands are flagged to the user).
 717     // c1, f1 = CopyToReg
 718     // c2, f2 = CopyToReg
 719     // c3     = TokenFactor c1, c2
 720     // ...
 721     //        = op c3, ..., f2
 722     Chain = Chains[NumRegs-1];
 723   else
 724     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Chains[0], NumRegs);
 725 }
 726
 727 /// AddInlineAsmOperands - Add this value to the specified inlineasm node
 728 /// operand list.  This adds the code marker and includes the number of
 729 /// values added into it.
 730 void RegsForValue::AddInlineAsmOperands(unsigned Code, bool HasMatching,
 731                                         unsigned MatchingIdx,
 732                                         SelectionDAG &DAG,
 733                                         std::vector<SDValue> &Ops) const {
 734   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
 735
 736   unsigned Flag = InlineAsm::getFlagWord(Code, Regs.size());
 737   if (HasMatching)
 738     Flag = InlineAsm::getFlagWordForMatchingOp(Flag, MatchingIdx);
 739   SDValue Res = DAG.getTargetConstant(Flag, MVT::i32);
 740   Ops.push_back(Res);
 741
 742   for (unsigned Value = 0, Reg = 0, e = ValueVTs.size(); Value != e; ++Value) {
 743     unsigned NumRegs = TLI.getNumRegisters(*DAG.getContext(), ValueVTs[Value]);
 744     EVT RegisterVT = RegVTs[Value];
 745     for (unsigned i = 0; i != NumRegs; ++i) {
 746       assert(Reg < Regs.size() && "Mismatch in # registers expected");
 747       Ops.push_back(DAG.getRegister(Regs[Reg++], RegisterVT));
 748     }
 749   }
 750 }
 751
 752 void SelectionDAGBuilder::init(GCFunctionInfo *gfi, AliasAnalysis &aa) {
 753   AA = &aa;
 754   GFI = gfi;
 755   TD = DAG.getTarget().getTargetData();
 756 }
 757
 758 /// clear - Clear out the current SelectionDAG and the associated
 759 /// state and prepare this SelectionDAGBuilder object to be used
 760 /// for a new block. This doesn't clear out information about
 761 /// additional blocks that are needed to complete switch lowering
 762 /// or PHI node updating; that information is cleared out as it is
 763 /// consumed.
 764 void SelectionDAGBuilder::clear() {
 765   NodeMap.clear();
 766   UnusedArgNodeMap.clear();
 767   PendingLoads.clear();
 768   PendingExports.clear();
 769   DanglingDebugInfoMap.clear();
 770   CurDebugLoc = DebugLoc();
 771   HasTailCall = false;
 772 }
 773
 774 /// getRoot - Return the current virtual root of the Selection DAG,
 775 /// flushing any PendingLoad items. This must be done before emitting
 776 /// a store or any other node that may need to be ordered after any
 777 /// prior load instructions.
 778 ///
 779 SDValue SelectionDAGBuilder::getRoot() {
 780   if (PendingLoads.empty())
 781     return DAG.getRoot();
 782
 783   if (PendingLoads.size() == 1) {
 784     SDValue Root = PendingLoads[0];
 785     DAG.setRoot(Root);
 786     PendingLoads.clear();
 787     return Root;
 788   }
 789
 790   // Otherwise, we have to make a token factor node.
 791   SDValue Root = DAG.getNode(ISD::TokenFactor, getCurDebugLoc(), MVT::Other,
 792                                &PendingLoads[0], PendingLoads.size());
 793   PendingLoads.clear();
 794   DAG.setRoot(Root);
 795   return Root;
 796 }
 797
 798 /// getControlRoot - Similar to getRoot, but instead of flushing all the
 799 /// PendingLoad items, flush all the PendingExports items. It is necessary
 800 /// to do this before emitting a terminator instruction.
 801 ///
 802 SDValue SelectionDAGBuilder::getControlRoot() {
 803   SDValue Root = DAG.getRoot();
 804
 805   if (PendingExports.empty())
 806     return Root;
 807
 808   // Turn all of the CopyToReg chains into one factored node.
 809   if (Root.getOpcode() != ISD::EntryToken) {
 810     unsigned i = 0, e = PendingExports.size();
 811     for (; i != e; ++i) {
 812       assert(PendingExports[i].getNode()->getNumOperands() > 1);
 813       if (PendingExports[i].getNode()->getOperand(0) == Root)
 814         break;  // Don't add the root if we already indirectly depend on it.
 815     }
 816
 817     if (i == e)
 818       PendingExports.push_back(Root);
 819   }
 820
 821   Root = DAG.getNode(ISD::TokenFactor, getCurDebugLoc(), MVT::Other,
 822                      &PendingExports[0],
 823                      PendingExports.size());
 824   PendingExports.clear();
 825   DAG.setRoot(Root);
 826   return Root;
 827 }
 828
 829 void SelectionDAGBuilder::AssignOrderingToNode(const SDNode *Node) {
 830   if (DAG.GetOrdering(Node) != 0) return; // Already has ordering.
 831   DAG.AssignOrdering(Node, SDNodeOrder);
 832
 833   for (unsigned I = 0, E = Node->getNumOperands(); I != E; ++I)
 834     AssignOrderingToNode(Node->getOperand(I).getNode());
 835 }
 836
 837 void SelectionDAGBuilder::visit(const Instruction &I) {
 838   // Set up outgoing PHI node register values before emitting the terminator.
 839   if (isa<TerminatorInst>(&I))
 840     HandlePHINodesInSuccessorBlocks(I.getParent());
 841
 842   CurDebugLoc = I.getDebugLoc();
 843
 844   visit(I.getOpcode(), I);
 845
 846   if (!isa<TerminatorInst>(&I) && !HasTailCall)
 847     CopyToExportRegsIfNeeded(&I);
 848
 849   CurDebugLoc = DebugLoc();
 850 }
 851
 852 void SelectionDAGBuilder::visitPHI(const PHINode &) {
 853   llvm_unreachable("SelectionDAGBuilder shouldn't visit PHI nodes!");
 854 }
 855
 856 void SelectionDAGBuilder::visit(unsigned Opcode, const User &I) {
 857   // Note: this doesn't use InstVisitor, because it has to work with
 858   // ConstantExpr's in addition to instructions.
 859   switch (Opcode) {
 860   default: llvm_unreachable("Unknown instruction type encountered!");
 861     // Build the switch statement using the Instruction.def file.
 862 #define HANDLE_INST(NUM, OPCODE, CLASS) \
 863     case Instruction::OPCODE: visit##OPCODE((CLASS&)I); break;
 864 #include "llvm/Instruction.def"
 865   }
 866
 867   // Assign the ordering to the freshly created DAG nodes.
 868   if (NodeMap.count(&I)) {
 869     ++SDNodeOrder;
 870     AssignOrderingToNode(getValue(&I).getNode());
 871   }
 872 }
 873
 874 // resolveDanglingDebugInfo - if we saw an earlier dbg_value referring to V,
 875 // generate the debug data structures now that we've seen its definition.
 876 void SelectionDAGBuilder::resolveDanglingDebugInfo(const Value *V,
 877                                                    SDValue Val) {
 878   DanglingDebugInfo &DDI = DanglingDebugInfoMap[V];
 879   MDNode *Variable = NULL;
 880   uint64_t Offset = 0;
 881
 882   if (const DbgValueInst *DI = dyn_cast_or_null<DbgValueInst>(DDI.getDI())) {
 883     Variable = DI->getVariable();
 884     Offset = DI->getOffset();
 885   } else if (const DbgDeclareInst *DI =
 886              dyn_cast_or_null<DbgDeclareInst>(DDI.getDI()))
 887     Variable = DI->getVariable();
 888   else {
 889     assert (DDI.getDI() == NULL && "Invalid debug info intrinsic!");
 890     return;
 891   }
 892
 893   if (Variable) {
 894     DebugLoc dl = DDI.getdl();
 895     unsigned DbgSDNodeOrder = DDI.getSDNodeOrder();
 896     SDDbgValue *SDV;
 897     if (Val.getNode()) {
 898       if (!EmitFuncArgumentDbgValue(V, Variable, Offset, Val)) {
 899         SDV = DAG.getDbgValue(Variable, Val.getNode(),
 900                               Val.getResNo(), Offset, dl, DbgSDNodeOrder);
 901         DAG.AddDbgValue(SDV, Val.getNode(), false);
 902       }
 903     } else {
 904       SDV = DAG.getDbgValue(Variable, UndefValue::get(V->getType()),
 905                             Offset, dl, SDNodeOrder);
 906       DAG.AddDbgValue(SDV, 0, false);
 907     }
 908     DanglingDebugInfoMap[V] = DanglingDebugInfo();
 909   }
 910 }
 911
 912 // getValue - Return an SDValue for the given Value.
 913 SDValue SelectionDAGBuilder::getValue(const Value *V) {
 914   // If we already have an SDValue for this value, use it. It's important
 915   // to do this first, so that we don't create a CopyFromReg if we already
 916   // have a regular SDValue.
 917   SDValue &N = NodeMap[V];
 918   if (N.getNode()) return N;
 919
 920   // If there's a virtual register allocated and initialized for this
 921   // value, use it.
 922   DenseMap<const Value *, unsigned>::iterator It = FuncInfo.ValueMap.find(V);
 923   if (It != FuncInfo.ValueMap.end()) {
 924     unsigned InReg = It->second;
 925     RegsForValue RFV(*DAG.getContext(), TLI, InReg, V->getType());
 926     SDValue Chain = DAG.getEntryNode();
 927     return N = RFV.getCopyFromRegs(DAG, FuncInfo, getCurDebugLoc(), Chain,NULL);
 928   }
 929
 930   // Otherwise create a new SDValue and remember it.
 931   SDValue Val = getValueImpl(V);
 932   NodeMap[V] = Val;
 933   resolveDanglingDebugInfo(V, Val);
 934   return Val;
 935 }
 936
 937 /// getNonRegisterValue - Return an SDValue for the given Value, but
 938 /// don't look in FuncInfo.ValueMap for a virtual register.
 939 SDValue SelectionDAGBuilder::getNonRegisterValue(const Value *V) {
 940   // If we already have an SDValue for this value, use it.
 941   SDValue &N = NodeMap[V];
 942   if (N.getNode()) return N;
 943
 944   // Otherwise create a new SDValue and remember it.
 945   SDValue Val = getValueImpl(V);
 946   NodeMap[V] = Val;
 947   resolveDanglingDebugInfo(V, Val);
 948   return Val;
 949 }
 950
 951 /// getValueImpl - Helper function for getValue and getNonRegisterValue.
 952 /// Create an SDValue for the given value.
 953 SDValue SelectionDAGBuilder::getValueImpl(const Value *V) {
 954   if (const Constant *C = dyn_cast<Constant>(V)) {
 955     EVT VT = TLI.getValueType(V->getType(), true);
 956
 957     if (const ConstantInt *CI = dyn_cast<ConstantInt>(C))
 958       return DAG.getConstant(*CI, VT);
 959
 960     if (const GlobalValue *GV = dyn_cast<GlobalValue>(C))
 961       return DAG.getGlobalAddress(GV, getCurDebugLoc(), VT);
 962
 963     if (isa<ConstantPointerNull>(C))
 964       return DAG.getConstant(0, TLI.getPointerTy());
 965
 966     if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C))
 967       return DAG.getConstantFP(*CFP, VT);
 968
 969     if (isa<UndefValue>(C) && !V->getType()->isAggregateType())
 970       return DAG.getUNDEF(VT);
 971
 972     if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
 973       visit(CE->getOpcode(), *CE);
 974       SDValue N1 = NodeMap[V];
 975       assert(N1.getNode() && "visit didn't populate the NodeMap!");
 976       return N1;
 977     }
 978
 979     if (isa<ConstantStruct>(C) || isa<ConstantArray>(C)) {
 980       SmallVector<SDValue, 4> Constants;
 981       for (User::const_op_iterator OI = C->op_begin(), OE = C->op_end();
 982            OI != OE; ++OI) {
 983         SDNode *Val = getValue(*OI).getNode();
 984         // If the operand is an empty aggregate, there are no values.
 985         if (!Val) continue;
 986         // Add each leaf value from the operand to the Constants list
 987         // to form a flattened list of all the values.
 988         for (unsigned i = 0, e = Val->getNumValues(); i != e; ++i)
 989           Constants.push_back(SDValue(Val, i));
 990       }
 991
 992       return DAG.getMergeValues(&Constants[0], Constants.size(),
 993                                 getCurDebugLoc());
 994     }
 995
 996     if (C->getType()->isStructTy() || C->getType()->isArrayTy()) {
 997       assert((isa<ConstantAggregateZero>(C) || isa<UndefValue>(C)) &&
 998              "Unknown struct or array constant!");
 999
1000       SmallVector<EVT, 4> ValueVTs;
1001       ComputeValueVTs(TLI, C->getType(), ValueVTs);
1002       unsigned NumElts = ValueVTs.size();
1003       if (NumElts == 0)
1004         return SDValue(); // empty struct
1005       SmallVector<SDValue, 4> Constants(NumElts);
1006       for (unsigned i = 0; i != NumElts; ++i) {
1007         EVT EltVT = ValueVTs[i];
1008         if (isa<UndefValue>(C))
1009           Constants[i] = DAG.getUNDEF(EltVT);
1010         else if (EltVT.isFloatingPoint())
1011           Constants[i] = DAG.getConstantFP(0, EltVT);
1012         else
1013           Constants[i] = DAG.getConstant(0, EltVT);
1014       }
1015
1016       return DAG.getMergeValues(&Constants[0], NumElts,
1017                                 getCurDebugLoc());
1018     }
1019
1020     if (const BlockAddress *BA = dyn_cast<BlockAddress>(C))
1021       return DAG.getBlockAddress(BA, VT);
1022
1023     const VectorType *VecTy = cast<VectorType>(V->getType());
1024     unsigned NumElements = VecTy->getNumElements();
1025
1026     // Now that we know the number and type of the elements, get that number of
1027     // elements into the Ops array based on what kind of constant it is.
1028     SmallVector<SDValue, 16> Ops;
1029     if (const ConstantVector *CP = dyn_cast<ConstantVector>(C)) {
1030       for (unsigned i = 0; i != NumElements; ++i)
1031         Ops.push_back(getValue(CP->getOperand(i)));
1032     } else {
1033       assert(isa<ConstantAggregateZero>(C) && "Unknown vector constant!");
1034       EVT EltVT = TLI.getValueType(VecTy->getElementType());
1035
1036       SDValue Op;
1037       if (EltVT.isFloatingPoint())
1038         Op = DAG.getConstantFP(0, EltVT);
1039       else
1040         Op = DAG.getConstant(0, EltVT);
1041       Ops.assign(NumElements, Op);
1042     }
1043
1044     // Create a BUILD_VECTOR node.
1045     return NodeMap[V] = DAG.getNode(ISD::BUILD_VECTOR, getCurDebugLoc(),
1046                                     VT, &Ops[0], Ops.size());
1047   }
1048
1049   // If this is a static alloca, generate it as the frameindex instead of
1050   // computation.
1051   if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
1052     DenseMap<const AllocaInst*, int>::iterator SI =
1053       FuncInfo.StaticAllocaMap.find(AI);
1054     if (SI != FuncInfo.StaticAllocaMap.end())
1055       return DAG.getFrameIndex(SI->second, TLI.getPointerTy());
1056   }
1057
1058   // If this is an instruction which fast-isel has deferred, select it now.
1059   if (const Instruction *Inst = dyn_cast<Instruction>(V)) {
1060     unsigned InReg = FuncInfo.InitializeRegForValue(Inst);
1061     RegsForValue RFV(*DAG.getContext(), TLI, InReg, Inst->getType());
1062     SDValue Chain = DAG.getEntryNode();
1063     return RFV.getCopyFromRegs(DAG, FuncInfo, getCurDebugLoc(), Chain, NULL);
1064   }
1065
1066   llvm_unreachable("Can't get register for value!");
1067   return SDValue();
1068 }
1069
1070 void SelectionDAGBuilder::visitRet(const ReturnInst &I) {
1071   SDValue Chain = getControlRoot();
1072   SmallVector<ISD::OutputArg, 8> Outs;
1073   SmallVector<SDValue, 8> OutVals;
1074
1075   if (!FuncInfo.CanLowerReturn) {
1076     unsigned DemoteReg = FuncInfo.DemoteRegister;
1077     const Function *F = I.getParent()->getParent();
1078
1079     // Emit a store of the return value through the virtual register.
1080     // Leave Outs empty so that LowerReturn won't try to load return
1081     // registers the usual way.
1082     SmallVector<EVT, 1> PtrValueVTs;
1083     ComputeValueVTs(TLI, PointerType::getUnqual(F->getReturnType()),
1084                     PtrValueVTs);
1085
1086     SDValue RetPtr = DAG.getRegister(DemoteReg, PtrValueVTs[0]);
1087     SDValue RetOp = getValue(I.getOperand(0));
1088
1089     SmallVector<EVT, 4> ValueVTs;
1090     SmallVector<uint64_t, 4> Offsets;
1091     ComputeValueVTs(TLI, I.getOperand(0)->getType(), ValueVTs, &Offsets);
1092     unsigned NumValues = ValueVTs.size();
1093
1094     SmallVector<SDValue, 4> Chains(NumValues);
1095     for (unsigned i = 0; i != NumValues; ++i) {
1096       SDValue Add = DAG.getNode(ISD::ADD, getCurDebugLoc(),
1097                                 RetPtr.getValueType(), RetPtr,
1098                                 DAG.getIntPtrConstant(Offsets[i]));
1099       Chains[i] =
1100         DAG.getStore(Chain, getCurDebugLoc(),
1101                      SDValue(RetOp.getNode(), RetOp.getResNo() + i),
1102                      Add, NULL, Offsets[i], false, false, 0);
1103     }
1104
1105     Chain = DAG.getNode(ISD::TokenFactor, getCurDebugLoc(),
1106                         MVT::Other, &Chains[0], NumValues);
1107   } else if (I.getNumOperands() != 0) {
1108     SmallVector<EVT, 4> ValueVTs;
1109     ComputeValueVTs(TLI, I.getOperand(0)->getType(), ValueVTs);
1110     unsigned NumValues = ValueVTs.size();
1111     if (NumValues) {
1112       SDValue RetOp = getValue(I.getOperand(0));
1113       for (unsigned j = 0, f = NumValues; j != f; ++j) {
1114         EVT VT = ValueVTs[j];
1115
1116         ISD::NodeType ExtendKind = ISD::ANY_EXTEND;
1117
1118         const Function *F = I.getParent()->getParent();
1119         if (F->paramHasAttr(0, Attribute::SExt))
1120           ExtendKind = ISD::SIGN_EXTEND;
1121         else if (F->paramHasAttr(0, Attribute::ZExt))
1122           ExtendKind = ISD::ZERO_EXTEND;
1123
1124         // FIXME: C calling convention requires the return type to be promoted
1125         // to at least 32-bit. But this is not necessary for non-C calling
1126         // conventions. The frontend should mark functions whose return values
1127         // require promoting with signext or zeroext attributes.
1128         if (ExtendKind != ISD::ANY_EXTEND && VT.isInteger()) {
1129           EVT MinVT = TLI.getRegisterType(*DAG.getContext(), MVT::i32);
1130           if (VT.bitsLT(MinVT))
1131             VT = MinVT;
1132         }
1133
1134         unsigned NumParts = TLI.getNumRegisters(*DAG.getContext(), VT);
1135         EVT PartVT = TLI.getRegisterType(*DAG.getContext(), VT);
1136         SmallVector<SDValue, 4> Parts(NumParts);
1137         getCopyToParts(DAG, getCurDebugLoc(),
1138                        SDValue(RetOp.getNode(), RetOp.getResNo() + j),
1139                        &Parts[0], NumParts, PartVT, ExtendKind);
1140
1141         // 'inreg' on function refers to return value
1142         ISD::ArgFlagsTy Flags = ISD::ArgFlagsTy();
1143         if (F->paramHasAttr(0, Attribute::InReg))
1144           Flags.setInReg();
1145
1146         // Propagate extension type if any
1147         if (F->paramHasAttr(0, Attribute::SExt))
1148           Flags.setSExt();
1149         else if (F->paramHasAttr(0, Attribute::ZExt))
1150           Flags.setZExt();
1151
1152         for (unsigned i = 0; i < NumParts; ++i) {
1153           Outs.push_back(ISD::OutputArg(Flags, Parts[i].getValueType(),
1154                                         /*isfixed=*/true));
1155           OutVals.push_back(Parts[i]);
1156         }
1157       }
1158     }
1159   }
1160
1161   bool isVarArg = DAG.getMachineFunction().getFunction()->isVarArg();
1162   CallingConv::ID CallConv =
1163     DAG.getMachineFunction().getFunction()->getCallingConv();
1164   Chain = TLI.LowerReturn(Chain, CallConv, isVarArg,
1165                           Outs, OutVals, getCurDebugLoc(), DAG);
1166
1167   // Verify that the target's LowerReturn behaved as expected.
1168   assert(Chain.getNode() && Chain.getValueType() == MVT::Other &&
1169          "LowerReturn didn't return a valid chain!");
1170
1171   // Update the DAG with the new chain value resulting from return lowering.
1172   DAG.setRoot(Chain);
1173 }
1174
1175 /// CopyToExportRegsIfNeeded - If the given value has virtual registers
1176 /// created for it, emit nodes to copy the value into the virtual
1177 /// registers.
1178 void SelectionDAGBuilder::CopyToExportRegsIfNeeded(const Value *V) {
1179   DenseMap<const Value *, unsigned>::iterator VMI = FuncInfo.ValueMap.find(V);
1180   if (VMI != FuncInfo.ValueMap.end()) {
1181     assert(!V->use_empty() && "Unused value assigned virtual registers!");
1182     CopyValueToVirtualRegister(V, VMI->second);
1183   }
1184 }
1185
1186 /// ExportFromCurrentBlock - If this condition isn't known to be exported from
1187 /// the current basic block, add it to ValueMap now so that we'll get a
1188 /// CopyTo/FromReg.
1189 void SelectionDAGBuilder::ExportFromCurrentBlock(const Value *V) {
1190   // No need to export constants.
1191   if (!isa<Instruction>(V) && !isa<Argument>(V)) return;
1192
1193   // Already exported?
1194   if (FuncInfo.isExportedInst(V)) return;
1195
1196   unsigned Reg = FuncInfo.InitializeRegForValue(V);
1197   CopyValueToVirtualRegister(V, Reg);
1198 }
1199
1200 bool SelectionDAGBuilder::isExportableFromCurrentBlock(const Value *V,
1201                                                      const BasicBlock *FromBB) {
1202   // The operands of the setcc have to be in this block.  We don't know
1203   // how to export them from some other block.
1204   if (const Instruction *VI = dyn_cast<Instruction>(V)) {
1205     // Can export from current BB.
1206     if (VI->getParent() == FromBB)
1207       return true;
1208
1209     // Is already exported, noop.
1210     return FuncInfo.isExportedInst(V);
1211   }
1212
1213   // If this is an argument, we can export it if the BB is the entry block or
1214   // if it is already exported.
1215   if (isa<Argument>(V)) {
1216     if (FromBB == &FromBB->getParent()->getEntryBlock())
1217       return true;
1218
1219     // Otherwise, can only export this if it is already exported.
1220     return FuncInfo.isExportedInst(V);
1221   }
1222
1223   // Otherwise, constants can always be exported.
1224   return true;
1225 }
1226
1227 static bool InBlock(const Value *V, const BasicBlock *BB) {
1228   if (const Instruction *I = dyn_cast<Instruction>(V))
1229     return I->getParent() == BB;
1230   return true;
1231 }
1232
1233 /// EmitBranchForMergedCondition - Helper method for FindMergedConditions.
1234 /// This function emits a branch and is used at the leaves of an OR or an
1235 /// AND operator tree.
1236 ///
1237 void
1238 SelectionDAGBuilder::EmitBranchForMergedCondition(const Value *Cond,
1239                                                   MachineBasicBlock *TBB,
1240                                                   MachineBasicBlock *FBB,
1241                                                   MachineBasicBlock *CurBB,
1242                                                   MachineBasicBlock *SwitchBB) {
1243   const BasicBlock *BB = CurBB->getBasicBlock();
1244
1245   // If the leaf of the tree is a comparison, merge the condition into
1246   // the caseblock.
1247   if (const CmpInst *BOp = dyn_cast<CmpInst>(Cond)) {
1248     // The operands of the cmp have to be in this block.  We don't know
1249     // how to export them from some other block.  If this is the first block
1250     // of the sequence, no exporting is needed.
1251     if (CurBB == SwitchBB ||
1252         (isExportableFromCurrentBlock(BOp->getOperand(0), BB) &&
1253          isExportableFromCurrentBlock(BOp->getOperand(1), BB))) {
1254       ISD::CondCode Condition;
1255       if (const ICmpInst *IC = dyn_cast<ICmpInst>(Cond)) {
1256         Condition = getICmpCondCode(IC->getPredicate());
1257       } else if (const FCmpInst *FC = dyn_cast<FCmpInst>(Cond)) {
1258         Condition = getFCmpCondCode(FC->getPredicate());
1259       } else {
1260         Condition = ISD::SETEQ; // silence warning.
1261         llvm_unreachable("Unknown compare instruction");
1262       }
1263
1264       CaseBlock CB(Condition, BOp->getOperand(0),
1265                    BOp->getOperand(1), NULL, TBB, FBB, CurBB);
1266       SwitchCases.push_back(CB);
1267       return;
1268     }
1269   }
1270
1271   // Create a CaseBlock record representing this branch.
1272   CaseBlock CB(ISD::SETEQ, Cond, ConstantInt::getTrue(*DAG.getContext()),
1273                NULL, TBB, FBB, CurBB);
1274   SwitchCases.push_back(CB);
1275 }
1276
1277 /// FindMergedConditions - If Cond is an expression like
1278 void SelectionDAGBuilder::FindMergedConditions(const Value *Cond,
1279                                                MachineBasicBlock *TBB,
1280                                                MachineBasicBlock *FBB,
1281                                                MachineBasicBlock *CurBB,
1282                                                MachineBasicBlock *SwitchBB,
1283                                                unsigned Opc) {
1284   // If this node is not part of the or/and tree, emit it as a branch.
1285   const Instruction *BOp = dyn_cast<Instruction>(Cond);
1286   if (!BOp || !(isa<BinaryOperator>(BOp) || isa<CmpInst>(BOp)) ||
1287       (unsigned)BOp->getOpcode() != Opc || !BOp->hasOneUse() ||
1288       BOp->getParent() != CurBB->getBasicBlock() ||
1289       !InBlock(BOp->getOperand(0), CurBB->getBasicBlock()) ||
1290       !InBlock(BOp->getOperand(1), CurBB->getBasicBlock())) {
1291     EmitBranchForMergedCondition(Cond, TBB, FBB, CurBB, SwitchBB);
1292     return;
1293   }
1294
1295   //  Create TmpBB after CurBB.
1296   MachineFunction::iterator BBI = CurBB;
1297   MachineFunction &MF = DAG.getMachineFunction();
1298   MachineBasicBlock *TmpBB = MF.CreateMachineBasicBlock(CurBB->getBasicBlock());
1299   CurBB->getParent()->insert(++BBI, TmpBB);
1300
1301   if (Opc == Instruction::Or) {
1302     // Codegen X | Y as:
1303     //   jmp_if_X TBB
1304     //   jmp TmpBB
1305     // TmpBB:
1306     //   jmp_if_Y TBB
1307     //   jmp FBB
1308     //
1309
1310     // Emit the LHS condition.
1311     FindMergedConditions(BOp->getOperand(0), TBB, TmpBB, CurBB, SwitchBB, Opc);
1312
1313     // Emit the RHS condition into TmpBB.
1314     FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, SwitchBB, Opc);
1315   } else {
1316     assert(Opc == Instruction::And && "Unknown merge op!");
1317     // Codegen X & Y as:
1318     //   jmp_if_X TmpBB
1319     //   jmp FBB
1320     // TmpBB:
1321     //   jmp_if_Y TBB
1322     //   jmp FBB
1323     //
1324     //  This requires creation of TmpBB after CurBB.
1325
1326     // Emit the LHS condition.
1327     FindMergedConditions(BOp->getOperand(0), TmpBB, FBB, CurBB, SwitchBB, Opc);
1328
1329     // Emit the RHS condition into TmpBB.
1330     FindMergedConditions(BOp->getOperand(1), TBB, FBB, TmpBB, SwitchBB, Opc);
1331   }
1332 }
1333
1334 /// If the set of cases should be emitted as a series of branches, return true.
1335 /// If we should emit this as a bunch of and/or'd together conditions, return
1336 /// false.
1337 bool
1338 SelectionDAGBuilder::ShouldEmitAsBranches(const std::vector<CaseBlock> &Cases){
1339   if (Cases.size() != 2) return true;
1340
1341   // If this is two comparisons of the same values or'd or and'd together, they
1342   // will get folded into a single comparison, so don't emit two blocks.
1343   if ((Cases[0].CmpLHS == Cases[1].CmpLHS &&
1344        Cases[0].CmpRHS == Cases[1].CmpRHS) ||
1345       (Cases[0].CmpRHS == Cases[1].CmpLHS &&
1346        Cases[0].CmpLHS == Cases[1].CmpRHS)) {
1347     return false;
1348   }
1349
1350   // Handle: (X != null) | (Y != null) --> (X|Y) != 0
1351   // Handle: (X == null) & (Y == null) --> (X|Y) == 0
1352   if (Cases[0].CmpRHS == Cases[1].CmpRHS &&
1353       Cases[0].CC == Cases[1].CC &&
1354       isa<Constant>(Cases[0].CmpRHS) &&
1355       cast<Constant>(Cases[0].CmpRHS)->isNullValue()) {
1356     if (Cases[0].CC == ISD::SETEQ && Cases[0].TrueBB == Cases[1].ThisBB)
1357       return false;
1358     if (Cases[0].CC == ISD::SETNE && Cases[0].FalseBB == Cases[1].ThisBB)
1359       return false;
1360   }
1361
1362   return true;
1363 }
1364
1365 void SelectionDAGBuilder::visitBr(const BranchInst &I) {
1366   MachineBasicBlock *BrMBB = FuncInfo.MBB;
1367
1368   // Update machine-CFG edges.
1369   MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)];
1370
1371   // Figure out which block is immediately after the current one.
1372   MachineBasicBlock *NextBlock = 0;
1373   MachineFunction::iterator BBI = BrMBB;
1374   if (++BBI != FuncInfo.MF->end())
1375     NextBlock = BBI;
1376
1377   if (I.isUnconditional()) {
1378     // Update machine-CFG edges.
1379     BrMBB->addSuccessor(Succ0MBB);
1380
1381     // If this is not a fall-through branch, emit the branch.
1382     if (Succ0MBB != NextBlock)
1383       DAG.setRoot(DAG.getNode(ISD::BR, getCurDebugLoc(),
1384                               MVT::Other, getControlRoot(),
1385                               DAG.getBasicBlock(Succ0MBB)));
1386
1387     return;
1388   }
1389
1390   // If this condition is one of the special cases we handle, do special stuff
1391   // now.
1392   const Value *CondVal = I.getCondition();
1393   MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)];
1394
1395   // If this is a series of conditions that are or'd or and'd together, emit
1396   // this as a sequence of branches instead of setcc's with and/or operations.
1397   // For example, instead of something like:
1398   //     cmp A, B
1399   //     C = seteq
1400   //     cmp D, E
1401   //     F = setle
1402   //     or C, F
1403   //     jnz foo
1404   // Emit:
1405   //     cmp A, B
1406   //     je foo
1407   //     cmp D, E
1408   //     jle foo
1409   //
1410   if (const BinaryOperator *BOp = dyn_cast<BinaryOperator>(CondVal)) {
1411     if (BOp->hasOneUse() &&
1412         (BOp->getOpcode() == Instruction::And ||
1413          BOp->getOpcode() == Instruction::Or)) {
1414       FindMergedConditions(BOp, Succ0MBB, Succ1MBB, BrMBB, BrMBB,
1415                            BOp->getOpcode());
1416       // If the compares in later blocks need to use values not currently
1417       // exported from this block, export them now.  This block should always
1418       // be the first entry.
1419       assert(SwitchCases[0].ThisBB == BrMBB && "Unexpected lowering!");
1420
1421       // Allow some cases to be rejected.
1422       if (ShouldEmitAsBranches(SwitchCases)) {
1423         for (unsigned i = 1, e = SwitchCases.size(); i != e; ++i) {
1424           ExportFromCurrentBlock(SwitchCases[i].CmpLHS);
1425           ExportFromCurrentBlock(SwitchCases[i].CmpRHS);
1426         }
1427
1428         // Emit the branch for this block.
1429         visitSwitchCase(SwitchCases[0], BrMBB);
1430         SwitchCases.erase(SwitchCases.begin());
1431         return;
1432       }
1433
1434       // Okay, we decided not to do this, remove any inserted MBB's and clear
1435       // SwitchCases.
1436       for (unsigned i = 1, e = SwitchCases.size(); i != e; ++i)
1437         FuncInfo.MF->erase(SwitchCases[i].ThisBB);
1438
1439       SwitchCases.clear();
1440     }
1441   }
1442
1443   // Create a CaseBlock record representing this branch.
1444   CaseBlock CB(ISD::SETEQ, CondVal, ConstantInt::getTrue(*DAG.getContext()),
1445                NULL, Succ0MBB, Succ1MBB, BrMBB);
1446
1447   // Use visitSwitchCase to actually insert the fast branch sequence for this
1448   // cond branch.
1449   visitSwitchCase(CB, BrMBB);
1450 }
1451
1452 /// visitSwitchCase - Emits the necessary code to represent a single node in
1453 /// the binary search tree resulting from lowering a switch instruction.
1454 void SelectionDAGBuilder::visitSwitchCase(CaseBlock &CB,
1455                                           MachineBasicBlock *SwitchBB) {
1456   SDValue Cond;
1457   SDValue CondLHS = getValue(CB.CmpLHS);
1458   DebugLoc dl = getCurDebugLoc();
1459
1460   // Build the setcc now.
1461   if (CB.CmpMHS == NULL) {
1462     // Fold "(X == true)" to X and "(X == false)" to !X to
1463     // handle common cases produced by branch lowering.
1464     if (CB.CmpRHS == ConstantInt::getTrue(*DAG.getContext()) &&
1465         CB.CC == ISD::SETEQ)
1466       Cond = CondLHS;
1467     else if (CB.CmpRHS == ConstantInt::getFalse(*DAG.getContext()) &&
1468              CB.CC == ISD::SETEQ) {
1469       SDValue True = DAG.getConstant(1, CondLHS.getValueType());
1470       Cond = DAG.getNode(ISD::XOR, dl, CondLHS.getValueType(), CondLHS, True);
1471     } else
1472       Cond = DAG.getSetCC(dl, MVT::i1, CondLHS, getValue(CB.CmpRHS), CB.CC);
1473   } else {
1474     assert(CB.CC == ISD::SETLE && "Can handle only LE ranges now");
1475
1476     const APInt& Low = cast<ConstantInt>(CB.CmpLHS)->getValue();
1477     const APInt& High  = cast<ConstantInt>(CB.CmpRHS)->getValue();
1478
1479     SDValue CmpOp = getValue(CB.CmpMHS);
1480     EVT VT = CmpOp.getValueType();
1481
1482     if (cast<ConstantInt>(CB.CmpLHS)->isMinValue(true)) {
1483       Cond = DAG.getSetCC(dl, MVT::i1, CmpOp, DAG.getConstant(High, VT),
1484                           ISD::SETLE);
1485     } else {
1486       SDValue SUB = DAG.getNode(ISD::SUB, dl,
1487                                 VT, CmpOp, DAG.getConstant(Low, VT));
1488       Cond = DAG.getSetCC(dl, MVT::i1, SUB,
1489                           DAG.getConstant(High-Low, VT), ISD::SETULE);
1490     }
1491   }
1492
1493   // Update successor info
1494   SwitchBB->addSuccessor(CB.TrueBB);
1495   SwitchBB->addSuccessor(CB.FalseBB);
1496
1497   // Set NextBlock to be the MBB immediately after the current one, if any.
1498   // This is used to avoid emitting unnecessary branches to the next block.
1499   MachineBasicBlock *NextBlock = 0;
1500   MachineFunction::iterator BBI = SwitchBB;
1501   if (++BBI != FuncInfo.MF->end())
1502     NextBlock = BBI;
1503
1504   // If the lhs block is the next block, invert the condition so that we can
1505   // fall through to the lhs instead of the rhs block.
1506   if (CB.TrueBB == NextBlock) {
1507     std::swap(CB.TrueBB, CB.FalseBB);
1508     SDValue True = DAG.getConstant(1, Cond.getValueType());
1509     Cond = DAG.getNode(ISD::XOR, dl, Cond.getValueType(), Cond, True);
1510   }
1511
1512   SDValue BrCond = DAG.getNode(ISD::BRCOND, dl,
1513                                MVT::Other, getControlRoot(), Cond,
1514                                DAG.getBasicBlock(CB.TrueBB));
1515
1516   // Insert the false branch.
1517   if (CB.FalseBB != NextBlock)
1518     BrCond = DAG.getNode(ISD::BR, dl, MVT::Other, BrCond,
1519                          DAG.getBasicBlock(CB.FalseBB));
1520
1521   DAG.setRoot(BrCond);
1522 }
1523
1524 /// visitJumpTable - Emit JumpTable node in the current MBB
1525 void SelectionDAGBuilder::visitJumpTable(JumpTable &JT) {
1526   // Emit the code for the jump table
1527   assert(JT.Reg != -1U && "Should lower JT Header first!");
1528   EVT PTy = TLI.getPointerTy();
1529   SDValue Index = DAG.getCopyFromReg(getControlRoot(), getCurDebugLoc(),
1530                                      JT.Reg, PTy);
1531   SDValue Table = DAG.getJumpTable(JT.JTI, PTy);
1532   SDValue BrJumpTable = DAG.getNode(ISD::BR_JT, getCurDebugLoc(),
1533                                     MVT::Other, Index.getValue(1),
1534                                     Table, Index);
1535   DAG.setRoot(BrJumpTable);
1536 }
1537
1538 /// visitJumpTableHeader - This function emits necessary code to produce index
1539 /// in the JumpTable from switch case.
1540 void SelectionDAGBuilder::visitJumpTableHeader(JumpTable &JT,
1541                                                JumpTableHeader &JTH,
1542                                                MachineBasicBlock *SwitchBB) {
1543   // Subtract the lowest switch case value from the value being switched on and
1544   // conditional branch to default mbb if the result is greater than the
1545   // difference between smallest and largest cases.
1546   SDValue SwitchOp = getValue(JTH.SValue);
1547   EVT VT = SwitchOp.getValueType();
1548   SDValue Sub = DAG.getNode(ISD::SUB, getCurDebugLoc(), VT, SwitchOp,
1549                             DAG.getConstant(JTH.First, VT));
1550
1551   // The SDNode we just created, which holds the value being switched on minus
1552   // the smallest case value, needs to be copied to a virtual register so it
1553   // can be used as an index into the jump table in a subsequent basic block.
1554   // This value may be smaller or larger than the target's pointer type, and
1555   // therefore require extension or truncating.
1556   SwitchOp = DAG.getZExtOrTrunc(Sub, getCurDebugLoc(), TLI.getPointerTy());
1557
1558   unsigned JumpTableReg = FuncInfo.CreateReg(TLI.getPointerTy());
1559   SDValue CopyTo = DAG.getCopyToReg(getControlRoot(), getCurDebugLoc(),
1560                                     JumpTableReg, SwitchOp);
1561   JT.Reg = JumpTableReg;
1562
1563   // Emit the range check for the jump table, and branch to the default block
1564   // for the switch statement if the value being switched on exceeds the largest
1565   // case in the switch.
1566   SDValue CMP = DAG.getSetCC(getCurDebugLoc(),
1567                              TLI.getSetCCResultType(Sub.getValueType()), Sub,
1568                              DAG.getConstant(JTH.Last-JTH.First,VT),
1569                              ISD::SETUGT);
1570
1571   // Set NextBlock to be the MBB immediately after the current one, if any.
1572   // This is used to avoid emitting unnecessary branches to the next block.
1573   MachineBasicBlock *NextBlock = 0;
1574   MachineFunction::iterator BBI = SwitchBB;
1575
1576   if (++BBI != FuncInfo.MF->end())
1577     NextBlock = BBI;
1578
1579   SDValue BrCond = DAG.getNode(ISD::BRCOND, getCurDebugLoc(),
1580                                MVT::Other, CopyTo, CMP,
1581                                DAG.getBasicBlock(JT.Default));
1582
1583   if (JT.MBB != NextBlock)
1584     BrCond = DAG.getNode(ISD::BR, getCurDebugLoc(), MVT::Other, BrCond,
1585                          DAG.getBasicBlock(JT.MBB));
1586
1587   DAG.setRoot(BrCond);
1588 }
1589
1590 /// visitBitTestHeader - This function emits necessary code to produce value
1591 /// suitable for "bit tests"
1592 void SelectionDAGBuilder::visitBitTestHeader(BitTestBlock &B,
1593                                              MachineBasicBlock *SwitchBB) {
1594   // Subtract the minimum value
1595   SDValue SwitchOp = getValue(B.SValue);
1596   EVT VT = SwitchOp.getValueType();
1597   SDValue Sub = DAG.getNode(ISD::SUB, getCurDebugLoc(), VT, SwitchOp,
1598                             DAG.getConstant(B.First, VT));
1599
1600   // Check range
1601   SDValue RangeCmp = DAG.getSetCC(getCurDebugLoc(),
1602                                   TLI.getSetCCResultType(Sub.getValueType()),
1603                                   Sub, DAG.getConstant(B.Range, VT),
1604                                   ISD::SETUGT);
1605
1606   SDValue ShiftOp = DAG.getZExtOrTrunc(Sub, getCurDebugLoc(),
1607                                        TLI.getPointerTy());
1608
1609   B.Reg = FuncInfo.CreateReg(TLI.getPointerTy());
1610   SDValue CopyTo = DAG.getCopyToReg(getControlRoot(), getCurDebugLoc(),
1611                                     B.Reg, ShiftOp);
1612
1613   // Set NextBlock to be the MBB immediately after the current one, if any.
1614   // This is used to avoid emitting unnecessary branches to the next block.
1615   MachineBasicBlock *NextBlock = 0;
1616   MachineFunction::iterator BBI = SwitchBB;
1617   if (++BBI != FuncInfo.MF->end())
1618     NextBlock = BBI;
1619
1620   MachineBasicBlock* MBB = B.Cases[0].ThisBB;
1621
1622   SwitchBB->addSuccessor(B.Default);
1623   SwitchBB->addSuccessor(MBB);
1624
1625   SDValue BrRange = DAG.getNode(ISD::BRCOND, getCurDebugLoc(),
1626                                 MVT::Other, CopyTo, RangeCmp,
1627                                 DAG.getBasicBlock(B.Default));
1628
1629   if (MBB != NextBlock)
1630     BrRange = DAG.getNode(ISD::BR, getCurDebugLoc(), MVT::Other, CopyTo,
1631                           DAG.getBasicBlock(MBB));
1632
1633   DAG.setRoot(BrRange);
1634 }
1635
1636 /// visitBitTestCase - this function produces one "bit test"
1637 void SelectionDAGBuilder::visitBitTestCase(MachineBasicBlock* NextMBB,
1638                                            unsigned Reg,
1639                                            BitTestCase &B,
1640                                            MachineBasicBlock *SwitchBB) {
1641   SDValue ShiftOp = DAG.getCopyFromReg(getControlRoot(), getCurDebugLoc(), Reg,
1642                                        TLI.getPointerTy());
1643   SDValue Cmp;
1644   if (CountPopulation_64(B.Mask) == 1) {
1645     // Testing for a single bit; just compare the shift count with what it
1646     // would need to be to shift a 1 bit in that position.
1647     Cmp = DAG.getSetCC(getCurDebugLoc(),
1648                        TLI.getSetCCResultType(ShiftOp.getValueType()),
1649                        ShiftOp,
1650                        DAG.getConstant(CountTrailingZeros_64(B.Mask),
1651                                        TLI.getPointerTy()),
1652                        ISD::SETEQ);
1653   } else {
1654     // Make desired shift
1655     SDValue SwitchVal = DAG.getNode(ISD::SHL, getCurDebugLoc(),
1656                                     TLI.getPointerTy(),
1657                                     DAG.getConstant(1, TLI.getPointerTy()),
1658                                     ShiftOp);
1659
1660     // Emit bit tests and jumps
1661     SDValue AndOp = DAG.getNode(ISD::AND, getCurDebugLoc(),
1662                                 TLI.getPointerTy(), SwitchVal,
1663                                 DAG.getConstant(B.Mask, TLI.getPointerTy()));
1664     Cmp = DAG.getSetCC(getCurDebugLoc(),
1665                        TLI.getSetCCResultType(AndOp.getValueType()),
1666                        AndOp, DAG.getConstant(0, TLI.getPointerTy()),
1667                        ISD::SETNE);
1668   }
1669
1670   SwitchBB->addSuccessor(B.TargetBB);
1671   SwitchBB->addSuccessor(NextMBB);
1672
1673   SDValue BrAnd = DAG.getNode(ISD::BRCOND, getCurDebugLoc(),
1674                               MVT::Other, getControlRoot(),
1675                               Cmp, DAG.getBasicBlock(B.TargetBB));
1676
1677   // Set NextBlock to be the MBB immediately after the current one, if any.
1678   // This is used to avoid emitting unnecessary branches to the next block.
1679   MachineBasicBlock *NextBlock = 0;
1680   MachineFunction::iterator BBI = SwitchBB;
1681   if (++BBI != FuncInfo.MF->end())
1682     NextBlock = BBI;
1683
1684   if (NextMBB != NextBlock)
1685     BrAnd = DAG.getNode(ISD::BR, getCurDebugLoc(), MVT::Other, BrAnd,
1686                         DAG.getBasicBlock(NextMBB));
1687
1688   DAG.setRoot(BrAnd);
1689 }
1690
1691 void SelectionDAGBuilder::visitInvoke(const InvokeInst &I) {
1692   MachineBasicBlock *InvokeMBB = FuncInfo.MBB;
1693
1694   // Retrieve successors.
1695   MachineBasicBlock *Return = FuncInfo.MBBMap[I.getSuccessor(0)];
1696   MachineBasicBlock *LandingPad = FuncInfo.MBBMap[I.getSuccessor(1)];
1697
1698   const Value *Callee(I.getCalledValue());
1699   if (isa<InlineAsm>(Callee))
1700     visitInlineAsm(&I);
1701   else
1702     LowerCallTo(&I, getValue(Callee), false, LandingPad);
1703
1704   // If the value of the invoke is used outside of its defining block, make it
1705   // available as a virtual register.
1706   CopyToExportRegsIfNeeded(&I);
1707
1708   // Update successor info
1709   InvokeMBB->addSuccessor(Return);
1710   InvokeMBB->addSuccessor(LandingPad);
1711
1712   // Drop into normal successor.
1713   DAG.setRoot(DAG.getNode(ISD::BR, getCurDebugLoc(),
1714                           MVT::Other, getControlRoot(),
1715                           DAG.getBasicBlock(Return)));
1716 }
1717
1718 void SelectionDAGBuilder::visitUnwind(const UnwindInst &I) {
1719 }
1720
1721 /// handleSmallSwitchCaseRange - Emit a series of specific tests (suitable for
1722 /// small case ranges).
1723 bool SelectionDAGBuilder::handleSmallSwitchRange(CaseRec& CR,
1724                                                  CaseRecVector& WorkList,
1725                                                  const Value* SV,
1726                                                  MachineBasicBlock *Default,
1727                                                  MachineBasicBlock *SwitchBB) {
1728   Case& BackCase  = *(CR.Range.second-1);
1729
1730   // Size is the number of Cases represented by this range.
1731   size_t Size = CR.Range.second - CR.Range.first;
1732   if (Size > 3)
1733     return false;
1734
1735   // Get the MachineFunction which holds the current MBB.  This is used when
1736   // inserting any additional MBBs necessary to represent the switch.
1737   MachineFunction *CurMF = FuncInfo.MF;
1738
1739   // Figure out which block is immediately after the current one.
1740   MachineBasicBlock *NextBlock = 0;
1741   MachineFunction::iterator BBI = CR.CaseBB;
1742
1743   if (++BBI != FuncInfo.MF->end())
1744     NextBlock = BBI;
1745
1746   // TODO: If any two of the cases has the same destination, and if one value
1747   // is the same as the other, but has one bit unset that the other has set,
1748   // use bit manipulation to do two compares at once.  For example:
1749   // "if (X == 6 || X == 4)" -> "if ((X|2) == 6)"
1750
1751   // Rearrange the case blocks so that the last one falls through if possible.
1752   if (NextBlock && Default != NextBlock && BackCase.BB != NextBlock) {
1753     // The last case block won't fall through into 'NextBlock' if we emit the
1754     // branches in this order.  See if rearranging a case value would help.
1755     for (CaseItr I = CR.Range.first, E = CR.Range.second-1; I != E; ++I) {
1756       if (I->BB == NextBlock) {
1757         std::swap(*I, BackCase);
1758         break;
1759       }
1760     }
1761   }
1762
1763   // Create a CaseBlock record representing a conditional branch to
1764   // the Case's target mbb if the value being switched on SV is equal
1765   // to C.
1766   MachineBasicBlock *CurBlock = CR.CaseBB;
1767   for (CaseItr I = CR.Range.first, E = CR.Range.second; I != E; ++I) {
1768     MachineBasicBlock *FallThrough;
1769     if (I != E-1) {
1770       FallThrough = CurMF->CreateMachineBasicBlock(CurBlock->getBasicBlock());
1771       CurMF->insert(BBI, FallThrough);
1772
1773       // Put SV in a virtual register to make it available from the new blocks.
1774       ExportFromCurrentBlock(SV);
1775     } else {
1776       // If the last case doesn't match, go to the default block.
1777       FallThrough = Default;
1778     }
1779
1780     const Value *RHS, *LHS, *MHS;
1781     ISD::CondCode CC;
1782     if (I->High == I->Low) {
1783       // This is just small small case range :) containing exactly 1 case
1784       CC = ISD::SETEQ;
1785       LHS = SV; RHS = I->High; MHS = NULL;
1786     } else {
1787       CC = ISD::SETLE;
1788       LHS = I->Low; MHS = SV; RHS = I->High;
1789     }
1790     CaseBlock CB(CC, LHS, RHS, MHS, I->BB, FallThrough, CurBlock);
1791
1792     // If emitting the first comparison, just call visitSwitchCase to emit the
1793     // code into the current block.  Otherwise, push the CaseBlock onto the
1794     // vector to be later processed by SDISel, and insert the node's MBB
1795     // before the next MBB.
1796     if (CurBlock == SwitchBB)
1797       visitSwitchCase(CB, SwitchBB);
1798     else
1799       SwitchCases.push_back(CB);
1800
1801     CurBlock = FallThrough;
1802   }
1803
1804   return true;
1805 }
1806
1807 static inline bool areJTsAllowed(const TargetLowering &TLI) {
1808   return !DisableJumpTables &&
1809           (TLI.isOperationLegalOrCustom(ISD::BR_JT, MVT::Other) ||
1810            TLI.isOperationLegalOrCustom(ISD::BRIND, MVT::Other));
1811 }
1812
1813 static APInt ComputeRange(const APInt &First, const APInt &Last) {
1814   APInt LastExt(Last), FirstExt(First);
1815   uint32_t BitWidth = std::max(Last.getBitWidth(), First.getBitWidth()) + 1;
1816   LastExt.sext(BitWidth); FirstExt.sext(BitWidth);
1817   return (LastExt - FirstExt + 1ULL);
1818 }
1819
1820 /// handleJTSwitchCase - Emit jumptable for current switch case range
1821 bool SelectionDAGBuilder::handleJTSwitchCase(CaseRec& CR,
1822                                              CaseRecVector& WorkList,
1823                                              const Value* SV,
1824                                              MachineBasicBlock* Default,
1825                                              MachineBasicBlock *SwitchBB) {
1826   Case& FrontCase = *CR.Range.first;
1827   Case& BackCase  = *(CR.Range.second-1);
1828
1829   const APInt &First = cast<ConstantInt>(FrontCase.Low)->getValue();
1830   const APInt &Last  = cast<ConstantInt>(BackCase.High)->getValue();
1831
1832   APInt TSize(First.getBitWidth(), 0);
1833   for (CaseItr I = CR.Range.first, E = CR.Range.second;
1834        I!=E; ++I)
1835     TSize += I->size();
1836
1837   if (!areJTsAllowed(TLI) || TSize.ult(4))
1838     return false;
1839
1840   APInt Range = ComputeRange(First, Last);
1841   double Density = TSize.roundToDouble() / Range.roundToDouble();
1842   if (Density < 0.4)
1843     return false;
1844
1845   DEBUG(dbgs() << "Lowering jump table\n"
1846                << "First entry: " << First << ". Last entry: " << Last << '\n'
1847                << "Range: " << Range
1848                << "Size: " << TSize << ". Density: " << Density << "\n\n");
1849
1850   // Get the MachineFunction which holds the current MBB.  This is used when
1851   // inserting any additional MBBs necessary to represent the switch.
1852   MachineFunction *CurMF = FuncInfo.MF;
1853
1854   // Figure out which block is immediately after the current one.
1855   MachineFunction::iterator BBI = CR.CaseBB;
1856   ++BBI;
1857
1858   const BasicBlock *LLVMBB = CR.CaseBB->getBasicBlock();
1859
1860   // Create a new basic block to hold the code for loading the address
1861   // of the jump table, and jumping to it.  Update successor information;
1862   // we will either branch to the default case for the switch, or the jump
1863   // table.
1864   MachineBasicBlock *JumpTableBB = CurMF->CreateMachineBasicBlock(LLVMBB);
1865   CurMF->insert(BBI, JumpTableBB);
1866   CR.CaseBB->addSuccessor(Default);
1867   CR.CaseBB->addSuccessor(JumpTableBB);
1868
1869   // Build a vector of destination BBs, corresponding to each target
1870   // of the jump table. If the value of the jump table slot corresponds to
1871   // a case statement, push the case's BB onto the vector, otherwise, push
1872   // the default BB.
1873   std::vector<MachineBasicBlock*> DestBBs;
1874   APInt TEI = First;
1875   for (CaseItr I = CR.Range.first, E = CR.Range.second; I != E; ++TEI) {
1876     const APInt &Low = cast<ConstantInt>(I->Low)->getValue();
1877     const APInt &High = cast<ConstantInt>(I->High)->getValue();
1878
1879     if (Low.sle(TEI) && TEI.sle(High)) {
1880       DestBBs.push_back(I->BB);
1881       if (TEI==High)
1882         ++I;
1883     } else {
1884       DestBBs.push_back(Default);
1885     }
1886   }
1887
1888   // Update successor info. Add one edge to each unique successor.
1889   BitVector SuccsHandled(CR.CaseBB->getParent()->getNumBlockIDs());
1890   for (std::vector<MachineBasicBlock*>::iterator I = DestBBs.begin(),
1891          E = DestBBs.end(); I != E; ++I) {
1892     if (!SuccsHandled[(*I)->getNumber()]) {
1893       SuccsHandled[(*I)->getNumber()] = true;
1894       JumpTableBB->addSuccessor(*I);
1895     }
1896   }
1897
1898   // Create a jump table index for this jump table.
1899   unsigned JTEncoding = TLI.getJumpTableEncoding();
1900   unsigned JTI = CurMF->getOrCreateJumpTableInfo(JTEncoding)
1901                        ->createJumpTableIndex(DestBBs);
1902
1903   // Set the jump table information so that we can codegen it as a second
1904   // MachineBasicBlock
1905   JumpTable JT(-1U, JTI, JumpTableBB, Default);
1906   JumpTableHeader JTH(First, Last, SV, CR.CaseBB, (CR.CaseBB == SwitchBB));
1907   if (CR.CaseBB == SwitchBB)
1908     visitJumpTableHeader(JT, JTH, SwitchBB);
1909
1910   JTCases.push_back(JumpTableBlock(JTH, JT));
1911
1912   return true;
1913 }
1914
1915 /// handleBTSplitSwitchCase - emit comparison and split binary search tree into
1916 /// 2 subtrees.
1917 bool SelectionDAGBuilder::handleBTSplitSwitchCase(CaseRec& CR,
1918                                                   CaseRecVector& WorkList,
1919                                                   const Value* SV,
1920                                                   MachineBasicBlock *Default,
1921                                                   MachineBasicBlock *SwitchBB) {
1922   // Get the MachineFunction which holds the current MBB.  This is used when
1923   // inserting any additional MBBs necessary to represent the switch.
1924   MachineFunction *CurMF = FuncInfo.MF;
1925
1926   // Figure out which block is immediately after the current one.
1927   MachineFunction::iterator BBI = CR.CaseBB;
1928   ++BBI;
1929
1930   Case& FrontCase = *CR.Range.first;
1931   Case& BackCase  = *(CR.Range.second-1);
1932   const BasicBlock *LLVMBB = CR.CaseBB->getBasicBlock();
1933
1934   // Size is the number of Cases represented by this range.
1935   unsigned Size = CR.Range.second - CR.Range.first;
1936
1937   const APInt &First = cast<ConstantInt>(FrontCase.Low)->getValue();
1938   const APInt &Last  = cast<ConstantInt>(BackCase.High)->getValue();
1939   double FMetric = 0;
1940   CaseItr Pivot = CR.Range.first + Size/2;
1941
1942   // Select optimal pivot, maximizing sum density of LHS and RHS. This will
1943   // (heuristically) allow us to emit JumpTable's later.
1944   APInt TSize(First.getBitWidth(), 0);
1945   for (CaseItr I = CR.Range.first, E = CR.Range.second;
1946        I!=E; ++I)
1947     TSize += I->size();
1948
1949   APInt LSize = FrontCase.size();
1950   APInt RSize = TSize-LSize;
1951   DEBUG(dbgs() << "Selecting best pivot: \n"
1952                << "First: " << First << ", Last: " << Last <<'\n'
1953                << "LSize: " << LSize << ", RSize: " << RSize << '\n');
1954   for (CaseItr I = CR.Range.first, J=I+1, E = CR.Range.second;
1955        J!=E; ++I, ++J) {
1956     const APInt &LEnd = cast<ConstantInt>(I->High)->getValue();
1957     const APInt &RBegin = cast<ConstantInt>(J->Low)->getValue();
1958     APInt Range = ComputeRange(LEnd, RBegin);
1959     assert((Range - 2ULL).isNonNegative() &&
1960            "Invalid case distance");
1961     double LDensity = (double)LSize.roundToDouble() /
1962                            (LEnd - First + 1ULL).roundToDouble();
1963     double RDensity = (double)RSize.roundToDouble() /
1964                            (Last - RBegin + 1ULL).roundToDouble();
1965     double Metric = Range.logBase2()*(LDensity+RDensity);
1966     // Should always split in some non-trivial place
1967     DEBUG(dbgs() <<"=>Step\n"
1968                  << "LEnd: " << LEnd << ", RBegin: " << RBegin << '\n'
1969                  << "LDensity: " << LDensity
1970                  << ", RDensity: " << RDensity << '\n'
1971                  << "Metric: " << Metric << '\n');
1972     if (FMetric < Metric) {
1973       Pivot = J;
1974       FMetric = Metric;
1975       DEBUG(dbgs() << "Current metric set to: " << FMetric << '\n');
1976     }
1977
1978     LSize += J->size();
1979     RSize -= J->size();
1980   }
1981   if (areJTsAllowed(TLI)) {
1982     // If our case is dense we *really* should handle it earlier!
1983     assert((FMetric > 0) && "Should handle dense range earlier!");
1984   } else {
1985     Pivot = CR.Range.first + Size/2;
1986   }
1987
1988   CaseRange LHSR(CR.Range.first, Pivot);
1989   CaseRange RHSR(Pivot, CR.Range.second);
1990   Constant *C = Pivot->Low;
1991   MachineBasicBlock *FalseBB = 0, *TrueBB = 0;
1992
1993   // We know that we branch to the LHS if the Value being switched on is
1994   // less than the Pivot value, C.  We use this to optimize our binary
1995   // tree a bit, by recognizing that if SV is greater than or equal to the
1996   // LHS's Case Value, and that Case Value is exactly one less than the
1997   // Pivot's Value, then we can branch directly to the LHS's Target,
1998   // rather than creating a leaf node for it.
1999   if ((LHSR.second - LHSR.first) == 1 &&
2000       LHSR.first->High == CR.GE &&
2001       cast<ConstantInt>(C)->getValue() ==
2002       (cast<ConstantInt>(CR.GE)->getValue() + 1LL)) {
2003     TrueBB = LHSR.first->BB;
2004   } else {
2005     TrueBB = CurMF->CreateMachineBasicBlock(LLVMBB);
2006     CurMF->insert(BBI, TrueBB);
2007     WorkList.push_back(CaseRec(TrueBB, C, CR.GE, LHSR));
2008
2009     // Put SV in a virtual register to make it available from the new blocks.
2010     ExportFromCurrentBlock(SV);
2011   }
2012
2013   // Similar to the optimization above, if the Value being switched on is
2014   // known to be less than the Constant CR.LT, and the current Case Value
2015   // is CR.LT - 1, then we can branch directly to the target block for
2016   // the current Case Value, rather than emitting a RHS leaf node for it.
2017   if ((RHSR.second - RHSR.first) == 1 && CR.LT &&
2018       cast<ConstantInt>(RHSR.first->Low)->getValue() ==
2019       (cast<ConstantInt>(CR.LT)->getValue() - 1LL)) {
2020     FalseBB = RHSR.first->BB;
2021   } else {
2022     FalseBB = CurMF->CreateMachineBasicBlock(LLVMBB);
2023     CurMF->insert(BBI, FalseBB);
2024     WorkList.push_back(CaseRec(FalseBB,CR.LT,C,RHSR));
2025
2026     // Put SV in a virtual register to make it available from the new blocks.
2027     ExportFromCurrentBlock(SV);
2028   }
2029
2030   // Create a CaseBlock record representing a conditional branch to
2031   // the LHS node if the value being switched on SV is less than C.
2032   // Otherwise, branch to LHS.
2033   CaseBlock CB(ISD::SETLT, SV, C, NULL, TrueBB, FalseBB, CR.CaseBB);
2034
2035   if (CR.CaseBB == SwitchBB)
2036     visitSwitchCase(CB, SwitchBB);
2037   else
2038     SwitchCases.push_back(CB);
2039
2040   return true;
2041 }
2042
2043 /// handleBitTestsSwitchCase - if current case range has few destination and
2044 /// range span less, than machine word bitwidth, encode case range into series
2045 /// of masks and emit bit tests with these masks.
2046 bool SelectionDAGBuilder::handleBitTestsSwitchCase(CaseRec& CR,
2047                                                    CaseRecVector& WorkList,
2048                                                    const Value* SV,
2049                                                    MachineBasicBlock* Default,
2050                                                    MachineBasicBlock *SwitchBB){
2051   EVT PTy = TLI.getPointerTy();
2052   unsigned IntPtrBits = PTy.getSizeInBits();
2053
2054   Case& FrontCase = *CR.Range.first;
2055   Case& BackCase  = *(CR.Range.second-1);
2056
2057   // Get the MachineFunction which holds the current MBB.  This is used when
2058   // inserting any additional MBBs necessary to represent the switch.
2059   MachineFunction *CurMF = FuncInfo.MF;
2060
2061   // If target does not have legal shift left, do not emit bit tests at all.
2062   if (!TLI.isOperationLegal(ISD::SHL, TLI.getPointerTy()))
2063     return false;
2064
2065   size_t numCmps = 0;
2066   for (CaseItr I = CR.Range.first, E = CR.Range.second;
2067        I!=E; ++I) {
2068     // Single case counts one, case range - two.
2069     numCmps += (I->Low == I->High ? 1 : 2);
2070   }
2071
2072   // Count unique destinations
2073   SmallSet<MachineBasicBlock*, 4> Dests;
2074   for (CaseItr I = CR.Range.first, E = CR.Range.second; I!=E; ++I) {
2075     Dests.insert(I->BB);
2076     if (Dests.size() > 3)
2077       // Don't bother the code below, if there are too much unique destinations
2078       return false;
2079   }
2080   DEBUG(dbgs() << "Total number of unique destinations: "
2081         << Dests.size() << '\n'
2082         << "Total number of comparisons: " << numCmps << '\n');
2083
2084   // Compute span of values.
2085   const APInt& minValue = cast<ConstantInt>(FrontCase.Low)->getValue();
2086   const APInt& maxValue = cast<ConstantInt>(BackCase.High)->getValue();
2087   APInt cmpRange = maxValue - minValue;
2088
2089   DEBUG(dbgs() << "Compare range: " << cmpRange << '\n'
2090                << "Low bound: " << minValue << '\n'
2091                << "High bound: " << maxValue << '\n');
2092
2093   if (cmpRange.uge(IntPtrBits) ||
2094       (!(Dests.size() == 1 && numCmps >= 3) &&
2095        !(Dests.size() == 2 && numCmps >= 5) &&
2096        !(Dests.size() >= 3 && numCmps >= 6)))
2097     return false;
2098
2099   DEBUG(dbgs() << "Emitting bit tests\n");
2100   APInt lowBound = APInt::getNullValue(cmpRange.getBitWidth());
2101
2102   // Optimize the case where all the case values fit in a
2103   // word without having to subtract minValue. In this case,
2104   // we can optimize away the subtraction.
2105   if (minValue.isNonNegative() && maxValue.slt(IntPtrBits)) {
2106     cmpRange = maxValue;
2107   } else {
2108     lowBound = minValue;
2109   }
2110
2111   CaseBitsVector CasesBits;
2112   unsigned i, count = 0;
2113
2114   for (CaseItr I = CR.Range.first, E = CR.Range.second; I!=E; ++I) {
2115     MachineBasicBlock* Dest = I->BB;
2116     for (i = 0; i < count; ++i)
2117       if (Dest == CasesBits[i].BB)
2118         break;
2119
2120     if (i == count) {
2121       assert((count < 3) && "Too much destinations to test!");
2122       CasesBits.push_back(CaseBits(0, Dest, 0));
2123       count++;
2124     }
2125
2126     const APInt& lowValue = cast<ConstantInt>(I->Low)->getValue();
2127     const APInt& highValue = cast<ConstantInt>(I->High)->getValue();
2128
2129     uint64_t lo = (lowValue - lowBound).getZExtValue();
2130     uint64_t hi = (highValue - lowBound).getZExtValue();
2131
2132     for (uint64_t j = lo; j <= hi; j++) {
2133       CasesBits[i].Mask |=  1ULL << j;
2134       CasesBits[i].Bits++;
2135     }
2136
2137   }
2138   std::sort(CasesBits.begin(), CasesBits.end(), CaseBitsCmp());
2139
2140   BitTestInfo BTC;
2141
2142   // Figure out which block is immediately after the current one.
2143   MachineFunction::iterator BBI = CR.CaseBB;
2144   ++BBI;
2145
2146   const BasicBlock *LLVMBB = CR.CaseBB->getBasicBlock();
2147
2148   DEBUG(dbgs() << "Cases:\n");
2149   for (unsigned i = 0, e = CasesBits.size(); i!=e; ++i) {
2150     DEBUG(dbgs() << "Mask: " << CasesBits[i].Mask
2151                  << ", Bits: " << CasesBits[i].Bits
2152                  << ", BB: " << CasesBits[i].BB << '\n');
2153
2154     MachineBasicBlock *CaseBB = CurMF->CreateMachineBasicBlock(LLVMBB);
2155     CurMF->insert(BBI, CaseBB);
2156     BTC.push_back(BitTestCase(CasesBits[i].Mask,
2157                               CaseBB,
2158                               CasesBits[i].BB));
2159
2160     // Put SV in a virtual register to make it available from the new blocks.
2161     ExportFromCurrentBlock(SV);
2162   }
2163
2164   BitTestBlock BTB(lowBound, cmpRange, SV,
2165                    -1U, (CR.CaseBB == SwitchBB),
2166                    CR.CaseBB, Default, BTC);
2167
2168   if (CR.CaseBB == SwitchBB)
2169     visitBitTestHeader(BTB, SwitchBB);
2170
2171   BitTestCases.push_back(BTB);
2172
2173   return true;
2174 }
2175
2176 /// Clusterify - Transform simple list of Cases into list of CaseRange's
2177 size_t SelectionDAGBuilder::Clusterify(CaseVector& Cases,
2178                                        const SwitchInst& SI) {
2179   size_t numCmps = 0;
2180
2181   // Start with "simple" cases
2182   for (size_t i = 1; i < SI.getNumSuccessors(); ++i) {
2183     MachineBasicBlock *SMBB = FuncInfo.MBBMap[SI.getSuccessor(i)];
2184     Cases.push_back(Case(SI.getSuccessorValue(i),
2185                          SI.getSuccessorValue(i),
2186                          SMBB));
2187   }
2188   std::sort(Cases.begin(), Cases.end(), CaseCmp());
2189
2190   // Merge case into clusters
2191   if (Cases.size() >= 2)
2192     // Must recompute end() each iteration because it may be
2193     // invalidated by erase if we hold on to it
2194     for (CaseItr I = Cases.begin(), J = ++(Cases.begin()); J != Cases.end(); ) {
2195       const APInt& nextValue = cast<ConstantInt>(J->Low)->getValue();
2196       const APInt& currentValue = cast<ConstantInt>(I->High)->getValue();
2197       MachineBasicBlock* nextBB = J->BB;
2198       MachineBasicBlock* currentBB = I->BB;
2199
2200       // If the two neighboring cases go to the same destination, merge them
2201       // into a single case.
2202       if ((nextValue - currentValue == 1) && (currentBB == nextBB)) {
2203         I->High = J->High;
2204         J = Cases.erase(J);
2205       } else {
2206         I = J++;
2207       }
2208     }
2209
2210   for (CaseItr I=Cases.begin(), E=Cases.end(); I!=E; ++I, ++numCmps) {
2211     if (I->Low != I->High)
2212       // A range counts double, since it requires two compares.
2213       ++numCmps;
2214   }
2215
2216   return numCmps;
2217 }
2218
2219 void SelectionDAGBuilder::visitSwitch(const SwitchInst &SI) {
2220   MachineBasicBlock *SwitchMBB = FuncInfo.MBB;
2221
2222   // Figure out which block is immediately after the current one.
2223   MachineBasicBlock *NextBlock = 0;
2224   MachineBasicBlock *Default = FuncInfo.MBBMap[SI.getDefaultDest()];
2225
2226   // If there is only the default destination, branch to it if it is not the
2227   // next basic block.  Otherwise, just fall through.
2228   if (SI.getNumOperands() == 2) {
2229     // Update machine-CFG edges.
2230
2231     // If this is not a fall-through branch, emit the branch.
2232     SwitchMBB->addSuccessor(Default);
2233     if (Default != NextBlock)
2234       DAG.setRoot(DAG.getNode(ISD::BR, getCurDebugLoc(),
2235                               MVT::Other, getControlRoot(),
2236                               DAG.getBasicBlock(Default)));
2237
2238     return;
2239   }
2240
2241   // If there are any non-default case statements, create a vector of Cases
2242   // representing each one, and sort the vector so that we can efficiently
2243   // create a binary search tree from them.
2244   CaseVector Cases;
2245   size_t numCmps = Clusterify(Cases, SI);
2246   DEBUG(dbgs() << "Clusterify finished. Total clusters: " << Cases.size()
2247                << ". Total compares: " << numCmps << '\n');
2248   numCmps = 0;
2249
2250   // Get the Value to be switched on and default basic blocks, which will be
2251   // inserted into CaseBlock records, representing basic blocks in the binary
2252   // search tree.
2253   const Value *SV = SI.getOperand(0);
2254
2255   // Push the initial CaseRec onto the worklist
2256   CaseRecVector WorkList;
2257   WorkList.push_back(CaseRec(SwitchMBB,0,0,
2258                              CaseRange(Cases.begin(),Cases.end())));
2259
2260   while (!WorkList.empty()) {
2261     // Grab a record representing a case range to process off the worklist
2262     CaseRec CR = WorkList.back();
2263     WorkList.pop_back();
2264
2265     if (handleBitTestsSwitchCase(CR, WorkList, SV, Default, SwitchMBB))
2266       continue;
2267
2268     // If the range has few cases (two or less) emit a series of specific
2269     // tests.
2270     if (handleSmallSwitchRange(CR, WorkList, SV, Default, SwitchMBB))
2271       continue;
2272
2273     // If the switch has more than 5 blocks, and at least 40% dense, and the
2274     // target supports indirect branches, then emit a jump table rather than
2275     // lowering the switch to a binary tree of conditional branches.
2276     if (handleJTSwitchCase(CR, WorkList, SV, Default, SwitchMBB))
2277       continue;
2278
2279     // Emit binary tree. We need to pick a pivot, and push left and right ranges
2280     // onto the worklist. Leafs are handled via handleSmallSwitchRange() call.
2281     handleBTSplitSwitchCase(CR, WorkList, SV, Default, SwitchMBB);
2282   }
2283 }
2284
2285 void SelectionDAGBuilder::visitIndirectBr(const IndirectBrInst &I) {
2286   MachineBasicBlock *IndirectBrMBB = FuncInfo.MBB;
2287
2288   // Update machine-CFG edges with unique successors.
2289   SmallVector<BasicBlock*, 32> succs;
2290   succs.reserve(I.getNumSuccessors());
2291   for (unsigned i = 0, e = I.getNumSuccessors(); i != e; ++i)
2292     succs.push_back(I.getSuccessor(i));
2293   array_pod_sort(succs.begin(), succs.end());
2294   succs.erase(std::unique(succs.begin(), succs.end()), succs.end());
2295   for (unsigned i = 0, e = succs.size(); i != e; ++i)
2296     IndirectBrMBB->addSuccessor(FuncInfo.MBBMap[succs[i]]);
2297
2298   DAG.setRoot(DAG.getNode(ISD::BRIND, getCurDebugLoc(),
2299                           MVT::Other, getControlRoot(),
2300                           getValue(I.getAddress())));
2301 }
2302
2303 void SelectionDAGBuilder::visitFSub(const User &I) {
2304   // -0.0 - X --> fneg
2305   const Type *Ty = I.getType();
2306   if (Ty->isVectorTy()) {
2307     if (ConstantVector *CV = dyn_cast<ConstantVector>(I.getOperand(0))) {
2308       const VectorType *DestTy = cast<VectorType>(I.getType());
2309       const Type *ElTy = DestTy->getElementType();
2310       unsigned VL = DestTy->getNumElements();
2311       std::vector<Constant*> NZ(VL, ConstantFP::getNegativeZero(ElTy));
2312       Constant *CNZ = ConstantVector::get(&NZ[0], NZ.size());
2313       if (CV == CNZ) {
2314         SDValue Op2 = getValue(I.getOperand(1));
2315         setValue(&I, DAG.getNode(ISD::FNEG, getCurDebugLoc(),
2316                                  Op2.getValueType(), Op2));
2317         return;
2318       }
2319     }
2320   }
2321
2322   if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0)))
2323     if (CFP->isExactlyValue(ConstantFP::getNegativeZero(Ty)->getValueAPF())) {
2324       SDValue Op2 = getValue(I.getOperand(1));
2325       setValue(&I, DAG.getNode(ISD::FNEG, getCurDebugLoc(),
2326                                Op2.getValueType(), Op2));
2327       return;
2328     }
2329
2330   visitBinary(I, ISD::FSUB);
2331 }
2332
2333 void SelectionDAGBuilder::visitBinary(const User &I, unsigned OpCode) {
2334   SDValue Op1 = getValue(I.getOperand(0));
2335   SDValue Op2 = getValue(I.getOperand(1));
2336   setValue(&I, DAG.getNode(OpCode, getCurDebugLoc(),
2337                            Op1.getValueType(), Op1, Op2));
2338 }
2339
2340 void SelectionDAGBuilder::visitShift(const User &I, unsigned Opcode) {
2341   SDValue Op1 = getValue(I.getOperand(0));
2342   SDValue Op2 = getValue(I.getOperand(1));
2343   if (!I.getType()->isVectorTy() &&
2344       Op2.getValueType() != TLI.getShiftAmountTy()) {
2345     // If the operand is smaller than the shift count type, promote it.
2346     EVT PTy = TLI.getPointerTy();
2347     EVT STy = TLI.getShiftAmountTy();
2348     if (STy.bitsGT(Op2.getValueType()))
2349       Op2 = DAG.getNode(ISD::ANY_EXTEND, getCurDebugLoc(),
2350                         TLI.getShiftAmountTy(), Op2);
2351     // If the operand is larger than the shift count type but the shift
2352     // count type has enough bits to represent any shift value, truncate
2353     // it now. This is a common case and it exposes the truncate to
2354     // optimization early.
2355     else if (STy.getSizeInBits() >=
2356              Log2_32_Ceil(Op2.getValueType().getSizeInBits()))
2357       Op2 = DAG.getNode(ISD::TRUNCATE, getCurDebugLoc(),
2358                         TLI.getShiftAmountTy(), Op2);
2359     // Otherwise we'll need to temporarily settle for some other
2360     // convenient type; type legalization will make adjustments as
2361     // needed.
2362     else if (PTy.bitsLT(Op2.getValueType()))
2363       Op2 = DAG.getNode(ISD::TRUNCATE, getCurDebugLoc(),
2364                         TLI.getPointerTy(), Op2);
2365     else if (PTy.bitsGT(Op2.getValueType()))
2366       Op2 = DAG.getNode(ISD::ANY_EXTEND, getCurDebugLoc(),
2367                         TLI.getPointerTy(), Op2);
2368   }
2369
2370   setValue(&I, DAG.getNode(Opcode, getCurDebugLoc(),
2371                            Op1.getValueType(), Op1, Op2));
2372 }
2373
2374 void SelectionDAGBuilder::visitICmp(const User &I) {
2375   ICmpInst::Predicate predicate = ICmpInst::BAD_ICMP_PREDICATE;
2376   if (const ICmpInst *IC = dyn_cast<ICmpInst>(&I))
2377     predicate = IC->getPredicate();
2378   else if (const ConstantExpr *IC = dyn_cast<ConstantExpr>(&I))
2379     predicate = ICmpInst::Predicate(IC->getPredicate());
2380   SDValue Op1 = getValue(I.getOperand(0));
2381   SDValue Op2 = getValue(I.getOperand(1));
2382   ISD::CondCode Opcode = getICmpCondCode(predicate);
2383
2384   EVT DestVT = TLI.getValueType(I.getType());
2385   setValue(&I, DAG.getSetCC(getCurDebugLoc(), DestVT, Op1, Op2, Opcode));
2386 }
2387
2388 void SelectionDAGBuilder::visitFCmp(const User &I) {
2389   FCmpInst::Predicate predicate = FCmpInst::BAD_FCMP_PREDICATE;
2390   if (const FCmpInst *FC = dyn_cast<FCmpInst>(&I))
2391     predicate = FC->getPredicate();
2392   else if (const ConstantExpr *FC = dyn_cast<ConstantExpr>(&I))
2393     predicate = FCmpInst::Predicate(FC->getPredicate());
2394   SDValue Op1 = getValue(I.getOperand(0));
2395   SDValue Op2 = getValue(I.getOperand(1));
2396   ISD::CondCode Condition = getFCmpCondCode(predicate);
2397   EVT DestVT = TLI.getValueType(I.getType());
2398   setValue(&I, DAG.getSetCC(getCurDebugLoc(), DestVT, Op1, Op2, Condition));
2399 }
2400
2401 void SelectionDAGBuilder::visitSelect(const User &I) {
2402   SmallVector<EVT, 4> ValueVTs;
2403   ComputeValueVTs(TLI, I.getType(), ValueVTs);
2404   unsigned NumValues = ValueVTs.size();
2405   if (NumValues == 0) return;
2406
2407   SmallVector<SDValue, 4> Values(NumValues);
2408   SDValue Cond     = getValue(I.getOperand(0));
2409   SDValue TrueVal  = getValue(I.getOperand(1));
2410   SDValue FalseVal = getValue(I.getOperand(2));
2411
2412   for (unsigned i = 0; i != NumValues; ++i)
2413     Values[i] = DAG.getNode(ISD::SELECT, getCurDebugLoc(),
2414                           TrueVal.getNode()->getValueType(TrueVal.getResNo()+i),
2415                             Cond,
2416                             SDValue(TrueVal.getNode(),
2417                                     TrueVal.getResNo() + i),
2418                             SDValue(FalseVal.getNode(),
2419                                     FalseVal.getResNo() + i));
2420
2421   setValue(&I, DAG.getNode(ISD::MERGE_VALUES, getCurDebugLoc(),
2422                            DAG.getVTList(&ValueVTs[0], NumValues),
2423                            &Values[0], NumValues));
2424 }
2425
2426 void SelectionDAGBuilder::visitTrunc(const User &I) {
2427   // TruncInst cannot be a no-op cast because sizeof(src) > sizeof(dest).
2428   SDValue N = getValue(I.getOperand(0));
2429   EVT DestVT = TLI.getValueType(I.getType());
2430   setValue(&I, DAG.getNode(ISD::TRUNCATE, getCurDebugLoc(), DestVT, N));
2431 }
2432
2433 void SelectionDAGBuilder::visitZExt(const User &I) {
2434   // ZExt cannot be a no-op cast because sizeof(src) < sizeof(dest).
2435   // ZExt also can't be a cast to bool for same reason. So, nothing much to do
2436   SDValue N = getValue(I.getOperand(0));
2437   EVT DestVT = TLI.getValueType(I.getType());
2438   setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, getCurDebugLoc(), DestVT, N));
2439 }
2440
2441 void SelectionDAGBuilder::visitSExt(const User &I) {
2442   // SExt cannot be a no-op cast because sizeof(src) < sizeof(dest).
2443   // SExt also can't be a cast to bool for same reason. So, nothing much to do
2444   SDValue N = getValue(I.getOperand(0));
2445   EVT DestVT = TLI.getValueType(I.getType());
2446   setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, getCurDebugLoc(), DestVT, N));
2447 }
2448
2449 void SelectionDAGBuilder::visitFPTrunc(const User &I) {
2450   // FPTrunc is never a no-op cast, no need to check
2451   SDValue N = getValue(I.getOperand(0));
2452   EVT DestVT = TLI.getValueType(I.getType());
2453   setValue(&I, DAG.getNode(ISD::FP_ROUND, getCurDebugLoc(),
2454                            DestVT, N, DAG.getIntPtrConstant(0)));
2455 }
2456
2457 void SelectionDAGBuilder::visitFPExt(const User &I){
2458   // FPTrunc is never a no-op cast, no need to check
2459   SDValue N = getValue(I.getOperand(0));
2460   EVT DestVT = TLI.getValueType(I.getType());
2461   setValue(&I, DAG.getNode(ISD::FP_EXTEND, getCurDebugLoc(), DestVT, N));
2462 }
2463
2464 void SelectionDAGBuilder::visitFPToUI(const User &I) {
2465   // FPToUI is never a no-op cast, no need to check
2466   SDValue N = getValue(I.getOperand(0));
2467   EVT DestVT = TLI.getValueType(I.getType());
2468   setValue(&I, DAG.getNode(ISD::FP_TO_UINT, getCurDebugLoc(), DestVT, N));
2469 }
2470
2471 void SelectionDAGBuilder::visitFPToSI(const User &I) {
2472   // FPToSI is never a no-op cast, no need to check
2473   SDValue N = getValue(I.getOperand(0));
2474   EVT DestVT = TLI.getValueType(I.getType());
2475   setValue(&I, DAG.getNode(ISD::FP_TO_SINT, getCurDebugLoc(), DestVT, N));
2476 }
2477
2478 void SelectionDAGBuilder::visitUIToFP(const User &I) {
2479   // UIToFP is never a no-op cast, no need to check
2480   SDValue N = getValue(I.getOperand(0));
2481   EVT DestVT = TLI.getValueType(I.getType());
2482   setValue(&I, DAG.getNode(ISD::UINT_TO_FP, getCurDebugLoc(), DestVT, N));
2483 }
2484
2485 void SelectionDAGBuilder::visitSIToFP(const User &I){
2486   // SIToFP is never a no-op cast, no need to check
2487   SDValue N = getValue(I.getOperand(0));
2488   EVT DestVT = TLI.getValueType(I.getType());
2489   setValue(&I, DAG.getNode(ISD::SINT_TO_FP, getCurDebugLoc(), DestVT, N));
2490 }
2491
2492 void SelectionDAGBuilder::visitPtrToInt(const User &I) {
2493   // What to do depends on the size of the integer and the size of the pointer.
2494   // We can either truncate, zero extend, or no-op, accordingly.
2495   SDValue N = getValue(I.getOperand(0));
2496   EVT DestVT = TLI.getValueType(I.getType());
2497   setValue(&I, DAG.getZExtOrTrunc(N, getCurDebugLoc(), DestVT));
2498 }
2499
2500 void SelectionDAGBuilder::visitIntToPtr(const User &I) {
2501   // What to do depends on the size of the integer and the size of the pointer.
2502   // We can either truncate, zero extend, or no-op, accordingly.
2503   SDValue N = getValue(I.getOperand(0));
2504   EVT DestVT = TLI.getValueType(I.getType());
2505   setValue(&I, DAG.getZExtOrTrunc(N, getCurDebugLoc(), DestVT));
2506 }
2507
2508 void SelectionDAGBuilder::visitBitCast(const User &I) {
2509   SDValue N = getValue(I.getOperand(0));
2510   EVT DestVT = TLI.getValueType(I.getType());
2511
2512   // BitCast assures us that source and destination are the same size so this is
2513   // either a BIT_CONVERT or a no-op.
2514   if (DestVT != N.getValueType())
2515     setValue(&I, DAG.getNode(ISD::BIT_CONVERT, getCurDebugLoc(),
2516                              DestVT, N)); // convert types.
2517   else
2518     setValue(&I, N);            // noop cast.
2519 }
2520
2521 void SelectionDAGBuilder::visitInsertElement(const User &I) {
2522   SDValue InVec = getValue(I.getOperand(0));
2523   SDValue InVal = getValue(I.getOperand(1));
2524   SDValue InIdx = DAG.getNode(ISD::ZERO_EXTEND, getCurDebugLoc(),
2525                               TLI.getPointerTy(),
2526                               getValue(I.getOperand(2)));
2527   setValue(&I, DAG.getNode(ISD::INSERT_VECTOR_ELT, getCurDebugLoc(),
2528                            TLI.getValueType(I.getType()),
2529                            InVec, InVal, InIdx));
2530 }
2531
2532 void SelectionDAGBuilder::visitExtractElement(const User &I) {
2533   SDValue InVec = getValue(I.getOperand(0));
2534   SDValue InIdx = DAG.getNode(ISD::ZERO_EXTEND, getCurDebugLoc(),
2535                               TLI.getPointerTy(),
2536                               getValue(I.getOperand(1)));
2537   setValue(&I, DAG.getNode(ISD::EXTRACT_VECTOR_ELT, getCurDebugLoc(),
2538                            TLI.getValueType(I.getType()), InVec, InIdx));
2539 }
2540
2541 // Utility for visitShuffleVector - Returns true if the mask is mask starting
2542 // from SIndx and increasing to the element length (undefs are allowed).
2543 static bool SequentialMask(SmallVectorImpl<int> &Mask, unsigned SIndx) {
2544   unsigned MaskNumElts = Mask.size();
2545   for (unsigned i = 0; i != MaskNumElts; ++i)
2546     if ((Mask[i] >= 0) && (Mask[i] != (int)(i + SIndx)))
2547       return false;
2548   return true;
2549 }
2550
2551 void SelectionDAGBuilder::visitShuffleVector(const User &I) {
2552   SmallVector<int, 8> Mask;
2553   SDValue Src1 = getValue(I.getOperand(0));
2554   SDValue Src2 = getValue(I.getOperand(1));
2555
2556   // Convert the ConstantVector mask operand into an array of ints, with -1
2557   // representing undef values.
2558   SmallVector<Constant*, 8> MaskElts;
2559   cast<Constant>(I.getOperand(2))->getVectorElements(MaskElts);
2560   unsigned MaskNumElts = MaskElts.size();
2561   for (unsigned i = 0; i != MaskNumElts; ++i) {
2562     if (isa<UndefValue>(MaskElts[i]))
2563       Mask.push_back(-1);
2564     else
2565       Mask.push_back(cast<ConstantInt>(MaskElts[i])->getSExtValue());
2566   }
2567
2568   EVT VT = TLI.getValueType(I.getType());
2569   EVT SrcVT = Src1.getValueType();
2570   unsigned SrcNumElts = SrcVT.getVectorNumElements();
2571
2572   if (SrcNumElts == MaskNumElts) {
2573     setValue(&I, DAG.getVectorShuffle(VT, getCurDebugLoc(), Src1, Src2,
2574                                       &Mask[0]));
2575     return;
2576   }
2577
2578   // Normalize the shuffle vector since mask and vector length don't match.
2579   if (SrcNumElts < MaskNumElts && MaskNumElts % SrcNumElts == 0) {
2580     // Mask is longer than the source vectors and is a multiple of the source
2581     // vectors.  We can use concatenate vector to make the mask and vectors
2582     // lengths match.
2583     if (SrcNumElts*2 == MaskNumElts && SequentialMask(Mask, 0)) {
2584       // The shuffle is concatenating two vectors together.
2585       setValue(&I, DAG.getNode(ISD::CONCAT_VECTORS, getCurDebugLoc(),
2586                                VT, Src1, Src2));
2587       return;
2588     }
2589
2590     // Pad both vectors with undefs to make them the same length as the mask.
2591     unsigned NumConcat = MaskNumElts / SrcNumElts;
2592     bool Src1U = Src1.getOpcode() == ISD::UNDEF;
2593     bool Src2U = Src2.getOpcode() == ISD::UNDEF;
2594     SDValue UndefVal = DAG.getUNDEF(SrcVT);
2595
2596     SmallVector<SDValue, 8> MOps1(NumConcat, UndefVal);
2597     SmallVector<SDValue, 8> MOps2(NumConcat, UndefVal);
2598     MOps1[0] = Src1;
2599     MOps2[0] = Src2;
2600
2601     Src1 = Src1U ? DAG.getUNDEF(VT) : DAG.getNode(ISD::CONCAT_VECTORS,
2602                                                   getCurDebugLoc(), VT,
2603                                                   &MOps1[0], NumConcat);
2604     Src2 = Src2U ? DAG.getUNDEF(VT) : DAG.getNode(ISD::CONCAT_VECTORS,
2605                                                   getCurDebugLoc(), VT,
2606                                                   &MOps2[0], NumConcat);
2607
2608     // Readjust mask for new input vector length.
2609     SmallVector<int, 8> MappedOps;
2610     for (unsigned i = 0; i != MaskNumElts; ++i) {
2611       int Idx = Mask[i];
2612       if (Idx < (int)SrcNumElts)
2613         MappedOps.push_back(Idx);
2614       else
2615         MappedOps.push_back(Idx + MaskNumElts - SrcNumElts);
2616     }
2617
2618     setValue(&I, DAG.getVectorShuffle(VT, getCurDebugLoc(), Src1, Src2,
2619                                       &MappedOps[0]));
2620     return;
2621   }
2622
2623   if (SrcNumElts > MaskNumElts) {
2624     // Analyze the access pattern of the vector to see if we can extract
2625     // two subvectors and do the shuffle. The analysis is done by calculating
2626     // the range of elements the mask access on both vectors.
2627     int MinRange[2] = { SrcNumElts+1, SrcNumElts+1};
2628     int MaxRange[2] = {-1, -1};
2629
2630     for (unsigned i = 0; i != MaskNumElts; ++i) {
2631       int Idx = Mask[i];
2632       int Input = 0;
2633       if (Idx < 0)
2634         continue;
2635
2636       if (Idx >= (int)SrcNumElts) {
2637         Input = 1;
2638         Idx -= SrcNumElts;
2639       }
2640       if (Idx > MaxRange[Input])
2641         MaxRange[Input] = Idx;
2642       if (Idx < MinRange[Input])
2643         MinRange[Input] = Idx;
2644     }
2645
2646     // Check if the access is smaller than the vector size and can we find
2647     // a reasonable extract index.
2648     int RangeUse[2] = { 2, 2 };  // 0 = Unused, 1 = Extract, 2 = Can not
2649                                  // Extract.
2650     int StartIdx[2];  // StartIdx to extract from
2651     for (int Input=0; Input < 2; ++Input) {
2652       if (MinRange[Input] == (int)(SrcNumElts+1) && MaxRange[Input] == -1) {
2653         RangeUse[Input] = 0; // Unused
2654         StartIdx[Input] = 0;
2655       } else if (MaxRange[Input] - MinRange[Input] < (int)MaskNumElts) {
2656         // Fits within range but we should see if we can find a good
2657         // start index that is a multiple of the mask length.
2658         if (MaxRange[Input] < (int)MaskNumElts) {
2659           RangeUse[Input] = 1; // Extract from beginning of the vector
2660           StartIdx[Input] = 0;
2661         } else {
2662           StartIdx[Input] = (MinRange[Input]/MaskNumElts)*MaskNumElts;
2663           if (MaxRange[Input] - StartIdx[Input] < (int)MaskNumElts &&
2664               StartIdx[Input] + MaskNumElts < SrcNumElts)
2665             RangeUse[Input] = 1; // Extract from a multiple of the mask length.
2666         }
2667       }
2668     }
2669
2670     if (RangeUse[0] == 0 && RangeUse[1] == 0) {
2671       setValue(&I, DAG.getUNDEF(VT)); // Vectors are not used.
2672       return;
2673     }
2674     else if (RangeUse[0] < 2 && RangeUse[1] < 2) {
2675       // Extract appropriate subvector and generate a vector shuffle
2676       for (int Input=0; Input < 2; ++Input) {
2677         SDValue &Src = Input == 0 ? Src1 : Src2;
2678         if (RangeUse[Input] == 0)
2679           Src = DAG.getUNDEF(VT);
2680         else
2681           Src = DAG.getNode(ISD::EXTRACT_SUBVECTOR, getCurDebugLoc(), VT,
2682                             Src, DAG.getIntPtrConstant(StartIdx[Input]));
2683       }
2684
2685       // Calculate new mask.
2686       SmallVector<int, 8> MappedOps;
2687       for (unsigned i = 0; i != MaskNumElts; ++i) {
2688         int Idx = Mask[i];
2689         if (Idx < 0)
2690           MappedOps.push_back(Idx);
2691         else if (Idx < (int)SrcNumElts)
2692           MappedOps.push_back(Idx - StartIdx[0]);
2693         else
2694           MappedOps.push_back(Idx - SrcNumElts - StartIdx[1] + MaskNumElts);
2695       }
2696
2697       setValue(&I, DAG.getVectorShuffle(VT, getCurDebugLoc(), Src1, Src2,
2698                                         &MappedOps[0]));
2699       return;
2700     }
2701   }
2702
2703   // We can't use either concat vectors or extract subvectors so fall back to
2704   // replacing the shuffle with extract and build vector.
2705   // to insert and build vector.
2706   EVT EltVT = VT.getVectorElementType();
2707   EVT PtrVT = TLI.getPointerTy();
2708   SmallVector<SDValue,8> Ops;
2709   for (unsigned i = 0; i != MaskNumElts; ++i) {
2710     if (Mask[i] < 0) {
2711       Ops.push_back(DAG.getUNDEF(EltVT));
2712     } else {
2713       int Idx = Mask[i];
2714       SDValue Res;
2715
2716       if (Idx < (int)SrcNumElts)
2717         Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, getCurDebugLoc(),
2718                           EltVT, Src1, DAG.getConstant(Idx, PtrVT));
2719       else
2720         Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, getCurDebugLoc(),
2721                           EltVT, Src2,
2722                           DAG.getConstant(Idx - SrcNumElts, PtrVT));
2723
2724       Ops.push_back(Res);
2725     }
2726   }
2727
2728   setValue(&I, DAG.getNode(ISD::BUILD_VECTOR, getCurDebugLoc(),
2729                            VT, &Ops[0], Ops.size()));
2730 }
2731
2732 void SelectionDAGBuilder::visitInsertValue(const InsertValueInst &I) {
2733   const Value *Op0 = I.getOperand(0);
2734   const Value *Op1 = I.getOperand(1);
2735   const Type *AggTy = I.getType();
2736   const Type *ValTy = Op1->getType();
2737   bool IntoUndef = isa<UndefValue>(Op0);
2738   bool FromUndef = isa<UndefValue>(Op1);
2739
2740   unsigned LinearIndex = ComputeLinearIndex(TLI, AggTy,
2741                                             I.idx_begin(), I.idx_end());
2742
2743   SmallVector<EVT, 4> AggValueVTs;
2744   ComputeValueVTs(TLI, AggTy, AggValueVTs);
2745   SmallVector<EVT, 4> ValValueVTs;
2746   ComputeValueVTs(TLI, ValTy, ValValueVTs);
2747
2748   unsigned NumAggValues = AggValueVTs.size();
2749   unsigned NumValValues = ValValueVTs.size();
2750   SmallVector<SDValue, 4> Values(NumAggValues);
2751
2752   SDValue Agg = getValue(Op0);
2753   SDValue Val = getValue(Op1);
2754   unsigned i = 0;
2755   // Copy the beginning value(s) from the original aggregate.
2756   for (; i != LinearIndex; ++i)
2757     Values[i] = IntoUndef ? DAG.getUNDEF(AggValueVTs[i]) :
2758                 SDValue(Agg.getNode(), Agg.getResNo() + i);
2759   // Copy values from the inserted value(s).
2760   for (; i != LinearIndex + NumValValues; ++i)
2761     Values[i] = FromUndef ? DAG.getUNDEF(AggValueVTs[i]) :
2762                 SDValue(Val.getNode(), Val.getResNo() + i - LinearIndex);
2763   // Copy remaining value(s) from the original aggregate.
2764   for (; i != NumAggValues; ++i)
2765     Values[i] = IntoUndef ? DAG.getUNDEF(AggValueVTs[i]) :
2766                 SDValue(Agg.getNode(), Agg.getResNo() + i);
2767
2768   setValue(&I, DAG.getNode(ISD::MERGE_VALUES, getCurDebugLoc(),
2769                            DAG.getVTList(&AggValueVTs[0], NumAggValues),
2770                            &Values[0], NumAggValues));
2771 }
2772
2773 void SelectionDAGBuilder::visitExtractValue(const ExtractValueInst &I) {
2774   const Value *Op0 = I.getOperand(0);
2775   const Type *AggTy = Op0->getType();
2776   const Type *ValTy = I.getType();
2777   bool OutOfUndef = isa<UndefValue>(Op0);
2778
2779   unsigned LinearIndex = ComputeLinearIndex(TLI, AggTy,
2780                                             I.idx_begin(), I.idx_end());
2781
2782   SmallVector<EVT, 4> ValValueVTs;
2783   ComputeValueVTs(TLI, ValTy, ValValueVTs);
2784
2785   unsigned NumValValues = ValValueVTs.size();
2786   SmallVector<SDValue, 4> Values(NumValValues);
2787
2788   SDValue Agg = getValue(Op0);
2789   // Copy out the selected value(s).
2790   for (unsigned i = LinearIndex; i != LinearIndex + NumValValues; ++i)
2791     Values[i - LinearIndex] =
2792       OutOfUndef ?
2793         DAG.getUNDEF(Agg.getNode()->getValueType(Agg.getResNo() + i)) :
2794         SDValue(Agg.getNode(), Agg.getResNo() + i);
2795
2796   setValue(&I, DAG.getNode(ISD::MERGE_VALUES, getCurDebugLoc(),
2797                            DAG.getVTList(&ValValueVTs[0], NumValValues),
2798                            &Values[0], NumValValues));
2799 }
2800
2801 void SelectionDAGBuilder::visitGetElementPtr(const User &I) {
2802   SDValue N = getValue(I.getOperand(0));
2803   const Type *Ty = I.getOperand(0)->getType();
2804
2805   for (GetElementPtrInst::const_op_iterator OI = I.op_begin()+1, E = I.op_end();
2806        OI != E; ++OI) {
2807     const Value *Idx = *OI;
2808     if (const StructType *StTy = dyn_cast<StructType>(Ty)) {
2809       unsigned Field = cast<ConstantInt>(Idx)->getZExtValue();
2810       if (Field) {
2811         // N = N + Offset
2812         uint64_t Offset = TD->getStructLayout(StTy)->getElementOffset(Field);
2813         N = DAG.getNode(ISD::ADD, getCurDebugLoc(), N.getValueType(), N,
2814                         DAG.getIntPtrConstant(Offset));
2815       }
2816
2817       Ty = StTy->getElementType(Field);
2818     } else if (const UnionType *UnTy = dyn_cast<UnionType>(Ty)) {
2819       unsigned Field = cast<ConstantInt>(Idx)->getZExtValue();
2820
2821       // Offset canonically 0 for unions, but type changes
2822       Ty = UnTy->getElementType(Field);
2823     } else {
2824       Ty = cast<SequentialType>(Ty)->getElementType();
2825
2826       // If this is a constant subscript, handle it quickly.
2827       if (const ConstantInt *CI = dyn_cast<ConstantInt>(Idx)) {
2828         if (CI->isZero()) continue;
2829         uint64_t Offs =
2830             TD->getTypeAllocSize(Ty)*cast<ConstantInt>(CI)->getSExtValue();
2831         SDValue OffsVal;
2832         EVT PTy = TLI.getPointerTy();
2833         unsigned PtrBits = PTy.getSizeInBits();
2834         if (PtrBits < 64)
2835           OffsVal = DAG.getNode(ISD::TRUNCATE, getCurDebugLoc(),
2836                                 TLI.getPointerTy(),
2837                                 DAG.getConstant(Offs, MVT::i64));
2838         else
2839           OffsVal = DAG.getIntPtrConstant(Offs);
2840
2841         N = DAG.getNode(ISD::ADD, getCurDebugLoc(), N.getValueType(), N,
2842                         OffsVal);
2843         continue;
2844       }
2845
2846       // N = N + Idx * ElementSize;
2847       APInt ElementSize = APInt(TLI.getPointerTy().getSizeInBits(),
2848                                 TD->getTypeAllocSize(Ty));
2849       SDValue IdxN = getValue(Idx);
2850
2851       // If the index is smaller or larger than intptr_t, truncate or extend
2852       // it.
2853       IdxN = DAG.getSExtOrTrunc(IdxN, getCurDebugLoc(), N.getValueType());
2854
2855       // If this is a multiply by a power of two, turn it into a shl
2856       // immediately.  This is a very common case.
2857       if (ElementSize != 1) {
2858         if (ElementSize.isPowerOf2()) {
2859           unsigned Amt = ElementSize.logBase2();
2860           IdxN = DAG.getNode(ISD::SHL, getCurDebugLoc(),
2861                              N.getValueType(), IdxN,
2862                              DAG.getConstant(Amt, TLI.getPointerTy()));
2863         } else {
2864           SDValue Scale = DAG.getConstant(ElementSize, TLI.getPointerTy());
2865           IdxN = DAG.getNode(ISD::MUL, getCurDebugLoc(),
2866                              N.getValueType(), IdxN, Scale);
2867         }
2868       }
2869
2870       N = DAG.getNode(ISD::ADD, getCurDebugLoc(),
2871                       N.getValueType(), N, IdxN);
2872     }
2873   }
2874
2875   setValue(&I, N);
2876 }
2877
2878 void SelectionDAGBuilder::visitAlloca(const AllocaInst &I) {
2879   // If this is a fixed sized alloca in the entry block of the function,
2880   // allocate it statically on the stack.
2881   if (FuncInfo.StaticAllocaMap.count(&I))
2882     return;   // getValue will auto-populate this.
2883
2884   const Type *Ty = I.getAllocatedType();
2885   uint64_t TySize = TLI.getTargetData()->getTypeAllocSize(Ty);
2886   unsigned Align =
2887     std::max((unsigned)TLI.getTargetData()->getPrefTypeAlignment(Ty),
2888              I.getAlignment());
2889
2890   SDValue AllocSize = getValue(I.getArraySize());
2891
2892   EVT IntPtr = TLI.getPointerTy();
2893   if (AllocSize.getValueType() != IntPtr)
2894     AllocSize = DAG.getZExtOrTrunc(AllocSize, getCurDebugLoc(), IntPtr);
2895
2896   AllocSize = DAG.getNode(ISD::MUL, getCurDebugLoc(), IntPtr,
2897                           AllocSize,
2898                           DAG.getConstant(TySize, IntPtr));
2899
2900   // Handle alignment.  If the requested alignment is less than or equal to
2901   // the stack alignment, ignore it.  If the size is greater than or equal to
2902   // the stack alignment, we note this in the DYNAMIC_STACKALLOC node.
2903   unsigned StackAlign = TM.getFrameInfo()->getStackAlignment();
2904   if (Align <= StackAlign)
2905     Align = 0;
2906
2907   // Round the size of the allocation up to the stack alignment size
2908   // by add SA-1 to the size.
2909   AllocSize = DAG.getNode(ISD::ADD, getCurDebugLoc(),
2910                           AllocSize.getValueType(), AllocSize,
2911                           DAG.getIntPtrConstant(StackAlign-1));
2912
2913   // Mask out the low bits for alignment purposes.
2914   AllocSize = DAG.getNode(ISD::AND, getCurDebugLoc(),
2915                           AllocSize.getValueType(), AllocSize,
2916                           DAG.getIntPtrConstant(~(uint64_t)(StackAlign-1)));
2917
2918   SDValue Ops[] = { getRoot(), AllocSize, DAG.getIntPtrConstant(Align) };
2919   SDVTList VTs = DAG.getVTList(AllocSize.getValueType(), MVT::Other);
2920   SDValue DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, getCurDebugLoc(),
2921                             VTs, Ops, 3);
2922   setValue(&I, DSA);
2923   DAG.setRoot(DSA.getValue(1));
2924
2925   // Inform the Frame Information that we have just allocated a variable-sized
2926   // object.
2927   FuncInfo.MF->getFrameInfo()->CreateVariableSizedObject(Align ? Align : 1);
2928 }
2929
2930 void SelectionDAGBuilder::visitLoad(const LoadInst &I) {
2931   const Value *SV = I.getOperand(0);
2932   SDValue Ptr = getValue(SV);
2933
2934   const Type *Ty = I.getType();
2935
2936   bool isVolatile = I.isVolatile();
2937   bool isNonTemporal = I.getMetadata("nontemporal") != 0;
2938   unsigned Alignment = I.getAlignment();
2939
2940   SmallVector<EVT, 4> ValueVTs;
2941   SmallVector<uint64_t, 4> Offsets;
2942   ComputeValueVTs(TLI, Ty, ValueVTs, &Offsets);
2943   unsigned NumValues = ValueVTs.size();
2944   if (NumValues == 0)
2945     return;
2946
2947   SDValue Root;
2948   bool ConstantMemory = false;
2949   if (I.isVolatile())
2950     // Serialize volatile loads with other side effects.
2951     Root = getRoot();
2952   else if (AA->pointsToConstantMemory(SV)) {
2953     // Do not serialize (non-volatile) loads of constant memory with anything.
2954     Root = DAG.getEntryNode();
2955     ConstantMemory = true;
2956   } else {
2957     // Do not serialize non-volatile loads against each other.
2958     Root = DAG.getRoot();
2959   }
2960
2961   SmallVector<SDValue, 4> Values(NumValues);
2962   SmallVector<SDValue, 4> Chains(NumValues);
2963   EVT PtrVT = Ptr.getValueType();
2964   for (unsigned i = 0; i != NumValues; ++i) {
2965     SDValue A = DAG.getNode(ISD::ADD, getCurDebugLoc(),
2966                             PtrVT, Ptr,
2967                             DAG.getConstant(Offsets[i], PtrVT));
2968     SDValue L = DAG.getLoad(ValueVTs[i], getCurDebugLoc(), Root,
2969                             A, SV, Offsets[i], isVolatile,
2970                             isNonTemporal, Alignment);
2971
2972     Values[i] = L;
2973     Chains[i] = L.getValue(1);
2974   }
2975
2976   if (!ConstantMemory) {
2977     SDValue Chain = DAG.getNode(ISD::TokenFactor, getCurDebugLoc(),
2978                                 MVT::Other, &Chains[0], NumValues);
2979     if (isVolatile)
2980       DAG.setRoot(Chain);
2981     else
2982       PendingLoads.push_back(Chain);
2983   }
2984
2985   setValue(&I, DAG.getNode(ISD::MERGE_VALUES, getCurDebugLoc(),
2986                            DAG.getVTList(&ValueVTs[0], NumValues),
2987                            &Values[0], NumValues));
2988 }
2989
2990 void SelectionDAGBuilder::visitStore(const StoreInst &I) {
2991   const Value *SrcV = I.getOperand(0);
2992   const Value *PtrV = I.getOperand(1);
2993
2994   SmallVector<EVT, 4> ValueVTs;
2995   SmallVector<uint64_t, 4> Offsets;
2996   ComputeValueVTs(TLI, SrcV->getType(), ValueVTs, &Offsets);
2997   unsigned NumValues = ValueVTs.size();
2998   if (NumValues == 0)
2999     return;
3000
3001   // Get the lowered operands. Note that we do this after
3002   // checking if NumResults is zero, because with zero results
3003   // the operands won't have values in the map.
3004   SDValue Src = getValue(SrcV);
3005   SDValue Ptr = getValue(PtrV);
3006
3007   SDValue Root = getRoot();
3008   SmallVector<SDValue, 4> Chains(NumValues);
3009   EVT PtrVT = Ptr.getValueType();
3010   bool isVolatile = I.isVolatile();
3011   bool isNonTemporal = I.getMetadata("nontemporal") != 0;
3012   unsigned Alignment = I.getAlignment();
3013
3014   for (unsigned i = 0; i != NumValues; ++i) {
3015     SDValue Add = DAG.getNode(ISD::ADD, getCurDebugLoc(), PtrVT, Ptr,
3016                               DAG.getConstant(Offsets[i], PtrVT));
3017     Chains[i] = DAG.getStore(Root, getCurDebugLoc(),
3018                              SDValue(Src.getNode(), Src.getResNo() + i),
3019                              Add, PtrV, Offsets[i], isVolatile,
3020                              isNonTemporal, Alignment);
3021   }
3022
3023   DAG.setRoot(DAG.getNode(ISD::TokenFactor, getCurDebugLoc(),
3024                           MVT::Other, &Chains[0], NumValues));
3025 }
3026
3027 /// visitTargetIntrinsic - Lower a call of a target intrinsic to an INTRINSIC
3028 /// node.
3029 void SelectionDAGBuilder::visitTargetIntrinsic(const CallInst &I,
3030                                                unsigned Intrinsic) {
3031   bool HasChain = !I.doesNotAccessMemory();
3032   bool OnlyLoad = HasChain && I.onlyReadsMemory();
3033
3034   // Build the operand list.
3035   SmallVector<SDValue, 8> Ops;
3036   if (HasChain) {  // If this intrinsic has side-effects, chainify it.
3037     if (OnlyLoad) {
3038       // We don't need to serialize loads against other loads.
3039       Ops.push_back(DAG.getRoot());
3040     } else {
3041       Ops.push_back(getRoot());
3042     }
3043   }
3044
3045   // Info is set by getTgtMemInstrinsic
3046   TargetLowering::IntrinsicInfo Info;
3047   bool IsTgtIntrinsic = TLI.getTgtMemIntrinsic(Info, I, Intrinsic);
3048
3049   // Add the intrinsic ID as an integer operand if it's not a target intrinsic.
3050   if (!IsTgtIntrinsic)
3051     Ops.push_back(DAG.getConstant(Intrinsic, TLI.getPointerTy()));
3052
3053   // Add all operands of the call to the operand list.
3054   for (unsigned i = 0, e = I.getNumArgOperands(); i != e; ++i) {
3055     SDValue Op = getValue(I.getArgOperand(i));
3056     assert(TLI.isTypeLegal(Op.getValueType()) &&
3057            "Intrinsic uses a non-legal type?");
3058     Ops.push_back(Op);
3059   }
3060
3061   SmallVector<EVT, 4> ValueVTs;
3062   ComputeValueVTs(TLI, I.getType(), ValueVTs);
3063 #ifndef NDEBUG
3064   for (unsigned Val = 0, E = ValueVTs.size(); Val != E; ++Val) {
3065     assert(TLI.isTypeLegal(ValueVTs[Val]) &&
3066            "Intrinsic uses a non-legal type?");
3067   }
3068 #endif // NDEBUG
3069
3070   if (HasChain)
3071     ValueVTs.push_back(MVT::Other);
3072
3073   SDVTList VTs = DAG.getVTList(ValueVTs.data(), ValueVTs.size());
3074
3075   // Create the node.
3076   SDValue Result;
3077   if (IsTgtIntrinsic) {
3078     // This is target intrinsic that touches memory
3079     Result = DAG.getMemIntrinsicNode(Info.opc, getCurDebugLoc(),
3080                                      VTs, &Ops[0], Ops.size(),
3081                                      Info.memVT, Info.ptrVal, Info.offset,
3082                                      Info.align, Info.vol,
3083                                      Info.readMem, Info.writeMem);
3084   } else if (!HasChain) {
3085     Result = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, getCurDebugLoc(),
3086                          VTs, &Ops[0], Ops.size());
3087   } else if (!I.getType()->isVoidTy()) {
3088     Result = DAG.getNode(ISD::INTRINSIC_W_CHAIN, getCurDebugLoc(),
3089                          VTs, &Ops[0], Ops.size());
3090   } else {
3091     Result = DAG.getNode(ISD::INTRINSIC_VOID, getCurDebugLoc(),
3092                          VTs, &Ops[0], Ops.size());
3093   }
3094
3095   if (HasChain) {
3096     SDValue Chain = Result.getValue(Result.getNode()->getNumValues()-1);
3097     if (OnlyLoad)
3098       PendingLoads.push_back(Chain);
3099     else
3100       DAG.setRoot(Chain);
3101   }
3102
3103   if (!I.getType()->isVoidTy()) {
3104     if (const VectorType *PTy = dyn_cast<VectorType>(I.getType())) {
3105       EVT VT = TLI.getValueType(PTy);
3106       Result = DAG.getNode(ISD::BIT_CONVERT, getCurDebugLoc(), VT, Result);
3107     }
3108
3109     setValue(&I, Result);
3110   }
3111 }
3112
3113 /// GetSignificand - Get the significand and build it into a floating-point
3114 /// number with exponent of 1:
3115 ///
3116 ///   Op = (Op & 0x007fffff) | 0x3f800000;
3117 ///
3118 /// where Op is the hexidecimal representation of floating point value.
3119 static SDValue
3120 GetSignificand(SelectionDAG &DAG, SDValue Op, DebugLoc dl) {
3121   SDValue t1 = DAG.getNode(ISD::AND, dl, MVT::i32, Op,
3122                            DAG.getConstant(0x007fffff, MVT::i32));
3123   SDValue t2 = DAG.getNode(ISD::OR, dl, MVT::i32, t1,
3124                            DAG.getConstant(0x3f800000, MVT::i32));
3125   return DAG.getNode(ISD::BIT_CONVERT, dl, MVT::f32, t2);
3126 }
3127
3128 /// GetExponent - Get the exponent:
3129 ///
3130 ///   (float)(int)(((Op & 0x7f800000) >> 23) - 127);
3131 ///
3132 /// where Op is the hexidecimal representation of floating point value.
3133 static SDValue
3134 GetExponent(SelectionDAG &DAG, SDValue Op, const TargetLowering &TLI,
3135             DebugLoc dl) {
3136   SDValue t0 = DAG.getNode(ISD::AND, dl, MVT::i32, Op,
3137                            DAG.getConstant(0x7f800000, MVT::i32));
3138   SDValue t1 = DAG.getNode(ISD::SRL, dl, MVT::i32, t0,
3139                            DAG.getConstant(23, TLI.getPointerTy()));
3140   SDValue t2 = DAG.getNode(ISD::SUB, dl, MVT::i32, t1,
3141                            DAG.getConstant(127, MVT::i32));
3142   return DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, t2);
3143 }
3144
3145 /// getF32Constant - Get 32-bit floating point constant.
3146 static SDValue
3147 getF32Constant(SelectionDAG &DAG, unsigned Flt) {
3148   return DAG.getConstantFP(APFloat(APInt(32, Flt)), MVT::f32);
3149 }
3150
3151 /// Inlined utility function to implement binary input atomic intrinsics for
3152 /// visitIntrinsicCall: I is a call instruction
3153 ///                     Op is the associated NodeType for I
3154 const char *
3155 SelectionDAGBuilder::implVisitBinaryAtomic(const CallInst& I,
3156                                            ISD::NodeType Op) {
3157   SDValue Root = getRoot();
3158   SDValue L =
3159     DAG.getAtomic(Op, getCurDebugLoc(),
3160                   getValue(I.getArgOperand(1)).getValueType().getSimpleVT(),
3161                   Root,
3162                   getValue(I.getArgOperand(0)),
3163                   getValue(I.getArgOperand(1)),
3164                   I.getArgOperand(0));
3165   setValue(&I, L);
3166   DAG.setRoot(L.getValue(1));
3167   return 0;
3168 }
3169
3170 // implVisitAluOverflow - Lower arithmetic overflow instrinsics.
3171 const char *
3172 SelectionDAGBuilder::implVisitAluOverflow(const CallInst &I, ISD::NodeType Op) {
3173   SDValue Op1 = getValue(I.getArgOperand(0));
3174   SDValue Op2 = getValue(I.getArgOperand(1));
3175
3176   SDVTList VTs = DAG.getVTList(Op1.getValueType(), MVT::i1);
3177   setValue(&I, DAG.getNode(Op, getCurDebugLoc(), VTs, Op1, Op2));
3178   return 0;
3179 }
3180
3181 /// visitExp - Lower an exp intrinsic. Handles the special sequences for
3182 /// limited-precision mode.
3183 void
3184 SelectionDAGBuilder::visitExp(const CallInst &I) {
3185   SDValue result;
3186   DebugLoc dl = getCurDebugLoc();
3187
3188   if (getValue(I.getArgOperand(0)).getValueType() == MVT::f32 &&
3189       LimitFloatPrecision > 0 && LimitFloatPrecision <= 18) {
3190     SDValue Op = getValue(I.getArgOperand(0));
3191
3192     // Put the exponent in the right bit position for later addition to the
3193     // final result:
3194     //
3195     //   #define LOG2OFe 1.4426950f
3196     //   IntegerPartOfX = ((int32_t)(X * LOG2OFe));
3197     SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, Op,
3198                              getF32Constant(DAG, 0x3fb8aa3b));
3199     SDValue IntegerPartOfX = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32, t0);
3200
3201     //   FractionalPartOfX = (X * LOG2OFe) - (float)IntegerPartOfX;
3202     SDValue t1 = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, IntegerPartOfX);
3203     SDValue X = DAG.getNode(ISD::FSUB, dl, MVT::f32, t0, t1);
3204
3205     //   IntegerPartOfX <<= 23;
3206     IntegerPartOfX = DAG.getNode(ISD::SHL, dl, MVT::i32, IntegerPartOfX,
3207                                  DAG.getConstant(23, TLI.getPointerTy()));
3208
3209     if (LimitFloatPrecision <= 6) {
3210       // For floating-point precision of 6:
3211       //
3212       //   TwoToFractionalPartOfX =
3213       //     0.997535578f +
3214       //       (0.735607626f + 0.252464424f * x) * x;
3215       //
3216       // error 0.0144103317, which is 6 bits
3217       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3218                                getF32Constant(DAG, 0x3e814304));
3219       SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
3220                                getF32Constant(DAG, 0x3f3c50c8));
3221       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3222       SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
3223                                getF32Constant(DAG, 0x3f7f5e7e));
3224       SDValue TwoToFracPartOfX = DAG.getNode(ISD::BIT_CONVERT, dl,MVT::i32, t5);
3225
3226       // Add the exponent into the result in integer domain.
3227       SDValue t6 = DAG.getNode(ISD::ADD, dl, MVT::i32,
3228                                TwoToFracPartOfX, IntegerPartOfX);
3229
3230       result = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::f32, t6);
3231     } else if (LimitFloatPrecision > 6 && LimitFloatPrecision <= 12) {
3232       // For floating-point precision of 12:
3233       //
3234       //   TwoToFractionalPartOfX =
3235       //     0.999892986f +
3236       //       (0.696457318f +
3237       //         (0.224338339f + 0.792043434e-1f * x) * x) * x;
3238       //
3239       // 0.000107046256 error, which is 13 to 14 bits
3240       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3241                                getF32Constant(DAG, 0x3da235e3));
3242       SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
3243                                getF32Constant(DAG, 0x3e65b8f3));
3244       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3245       SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
3246                                getF32Constant(DAG, 0x3f324b07));
3247       SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
3248       SDValue t7 = DAG.getNode(ISD::FADD, dl, MVT::f32, t6,
3249                                getF32Constant(DAG, 0x3f7ff8fd));
3250       SDValue TwoToFracPartOfX = DAG.getNode(ISD::BIT_CONVERT, dl,MVT::i32, t7);
3251
3252       // Add the exponent into the result in integer domain.
3253       SDValue t8 = DAG.getNode(ISD::ADD, dl, MVT::i32,
3254                                TwoToFracPartOfX, IntegerPartOfX);
3255
3256       result = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::f32, t8);
3257     } else { // LimitFloatPrecision > 12 && LimitFloatPrecision <= 18
3258       // For floating-point precision of 18:
3259       //
3260       //   TwoToFractionalPartOfX =
3261       //     0.999999982f +
3262       //       (0.693148872f +
3263       //         (0.240227044f +
3264       //           (0.554906021e-1f +
3265       //             (0.961591928e-2f +
3266       //               (0.136028312e-2f + 0.157059148e-3f *x)*x)*x)*x)*x)*x;
3267       //
3268       // error 2.47208000*10^(-7), which is better than 18 bits
3269       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3270                                getF32Constant(DAG, 0x3924b03e));
3271       SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
3272                                getF32Constant(DAG, 0x3ab24b87));
3273       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3274       SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
3275                                getF32Constant(DAG, 0x3c1d8c17));
3276       SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
3277       SDValue t7 = DAG.getNode(ISD::FADD, dl, MVT::f32, t6,
3278                                getF32Constant(DAG, 0x3d634a1d));
3279       SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
3280       SDValue t9 = DAG.getNode(ISD::FADD, dl, MVT::f32, t8,
3281                                getF32Constant(DAG, 0x3e75fe14));
3282       SDValue t10 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t9, X);
3283       SDValue t11 = DAG.getNode(ISD::FADD, dl, MVT::f32, t10,
3284                                 getF32Constant(DAG, 0x3f317234));
3285       SDValue t12 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t11, X);
3286       SDValue t13 = DAG.getNode(ISD::FADD, dl, MVT::f32, t12,
3287                                 getF32Constant(DAG, 0x3f800000));
3288       SDValue TwoToFracPartOfX = DAG.getNode(ISD::BIT_CONVERT, dl,
3289                                              MVT::i32, t13);
3290
3291       // Add the exponent into the result in integer domain.
3292       SDValue t14 = DAG.getNode(ISD::ADD, dl, MVT::i32,
3293                                 TwoToFracPartOfX, IntegerPartOfX);
3294
3295       result = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::f32, t14);
3296     }
3297   } else {
3298     // No special expansion.
3299     result = DAG.getNode(ISD::FEXP, dl,
3300                          getValue(I.getArgOperand(0)).getValueType(),
3301                          getValue(I.getArgOperand(0)));
3302   }
3303
3304   setValue(&I, result);
3305 }
3306
3307 /// visitLog - Lower a log intrinsic. Handles the special sequences for
3308 /// limited-precision mode.
3309 void
3310 SelectionDAGBuilder::visitLog(const CallInst &I) {
3311   SDValue result;
3312   DebugLoc dl = getCurDebugLoc();
3313
3314   if (getValue(I.getArgOperand(0)).getValueType() == MVT::f32 &&
3315       LimitFloatPrecision > 0 && LimitFloatPrecision <= 18) {
3316     SDValue Op = getValue(I.getArgOperand(0));
3317     SDValue Op1 = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::i32, Op);
3318
3319     // Scale the exponent by log(2) [0.69314718f].
3320     SDValue Exp = GetExponent(DAG, Op1, TLI, dl);
3321     SDValue LogOfExponent = DAG.getNode(ISD::FMUL, dl, MVT::f32, Exp,
3322                                         getF32Constant(DAG, 0x3f317218));
3323
3324     // Get the significand and build it into a floating-point number with
3325     // exponent of 1.
3326     SDValue X = GetSignificand(DAG, Op1, dl);
3327
3328     if (LimitFloatPrecision <= 6) {
3329       // For floating-point precision of 6:
3330       //
3331       //   LogofMantissa =
3332       //     -1.1609546f +
3333       //       (1.4034025f - 0.23903021f * x) * x;
3334       //
3335       // error 0.0034276066, which is better than 8 bits
3336       SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3337                                getF32Constant(DAG, 0xbe74c456));
3338       SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
3339                                getF32Constant(DAG, 0x3fb3a2b1));
3340       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
3341       SDValue LogOfMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
3342                                           getF32Constant(DAG, 0x3f949a29));
3343
3344       result = DAG.getNode(ISD::FADD, dl,
3345                            MVT::f32, LogOfExponent, LogOfMantissa);
3346     } else if (LimitFloatPrecision > 6 && LimitFloatPrecision <= 12) {
3347       // For floating-point precision of 12:
3348       //
3349       //   LogOfMantissa =
3350       //     -1.7417939f +
3351       //       (2.8212026f +
3352       //         (-1.4699568f +
3353       //           (0.44717955f - 0.56570851e-1f * x) * x) * x) * x;
3354       //
3355       // error 0.000061011436, which is 14 bits
3356       SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3357                                getF32Constant(DAG, 0xbd67b6d6));
3358       SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
3359                                getF32Constant(DAG, 0x3ee4f4b8));
3360       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
3361       SDValue t3 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
3362                                getF32Constant(DAG, 0x3fbc278b));
3363       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3364       SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
3365                                getF32Constant(DAG, 0x40348e95));
3366       SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
3367       SDValue LogOfMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t6,
3368                                           getF32Constant(DAG, 0x3fdef31a));
3369
3370       result = DAG.getNode(ISD::FADD, dl,
3371                            MVT::f32, LogOfExponent, LogOfMantissa);
3372     } else { // LimitFloatPrecision > 12 && LimitFloatPrecision <= 18
3373       // For floating-point precision of 18:
3374       //
3375       //   LogOfMantissa =
3376       //     -2.1072184f +
3377       //       (4.2372794f +
3378       //         (-3.7029485f +
3379       //           (2.2781945f +
3380       //             (-0.87823314f +
3381       //               (0.19073739f - 0.17809712e-1f * x) * x) * x) * x) * x)*x;
3382       //
3383       // error 0.0000023660568, which is better than 18 bits
3384       SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3385                                getF32Constant(DAG, 0xbc91e5ac));
3386       SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
3387                                getF32Constant(DAG, 0x3e4350aa));
3388       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
3389       SDValue t3 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
3390                                getF32Constant(DAG, 0x3f60d3e3));
3391       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3392       SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
3393                                getF32Constant(DAG, 0x4011cdf0));
3394       SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
3395       SDValue t7 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t6,
3396                                getF32Constant(DAG, 0x406cfd1c));
3397       SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
3398       SDValue t9 = DAG.getNode(ISD::FADD, dl, MVT::f32, t8,
3399                                getF32Constant(DAG, 0x408797cb));
3400       SDValue t10 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t9, X);
3401       SDValue LogOfMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t10,
3402                                           getF32Constant(DAG, 0x4006dcab));
3403
3404       result = DAG.getNode(ISD::FADD, dl,
3405                            MVT::f32, LogOfExponent, LogOfMantissa);
3406     }
3407   } else {
3408     // No special expansion.
3409     result = DAG.getNode(ISD::FLOG, dl,
3410                          getValue(I.getArgOperand(0)).getValueType(),
3411                          getValue(I.getArgOperand(0)));
3412   }
3413
3414   setValue(&I, result);
3415 }
3416
3417 /// visitLog2 - Lower a log2 intrinsic. Handles the special sequences for
3418 /// limited-precision mode.
3419 void
3420 SelectionDAGBuilder::visitLog2(const CallInst &I) {
3421   SDValue result;
3422   DebugLoc dl = getCurDebugLoc();
3423
3424   if (getValue(I.getArgOperand(0)).getValueType() == MVT::f32 &&
3425       LimitFloatPrecision > 0 && LimitFloatPrecision <= 18) {
3426     SDValue Op = getValue(I.getArgOperand(0));
3427     SDValue Op1 = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::i32, Op);
3428
3429     // Get the exponent.
3430     SDValue LogOfExponent = GetExponent(DAG, Op1, TLI, dl);
3431
3432     // Get the significand and build it into a floating-point number with
3433     // exponent of 1.
3434     SDValue X = GetSignificand(DAG, Op1, dl);
3435
3436     // Different possible minimax approximations of significand in
3437     // floating-point for various degrees of accuracy over [1,2].
3438     if (LimitFloatPrecision <= 6) {
3439       // For floating-point precision of 6:
3440       //
3441       //   Log2ofMantissa = -1.6749035f + (2.0246817f - .34484768f * x) * x;
3442       //
3443       // error 0.0049451742, which is more than 7 bits
3444       SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3445                                getF32Constant(DAG, 0xbeb08fe0));
3446       SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
3447                                getF32Constant(DAG, 0x40019463));
3448       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
3449       SDValue Log2ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
3450                                            getF32Constant(DAG, 0x3fd6633d));
3451
3452       result = DAG.getNode(ISD::FADD, dl,
3453                            MVT::f32, LogOfExponent, Log2ofMantissa);
3454     } else if (LimitFloatPrecision > 6 && LimitFloatPrecision <= 12) {
3455       // For floating-point precision of 12:
3456       //
3457       //   Log2ofMantissa =
3458       //     -2.51285454f +
3459       //       (4.07009056f +
3460       //         (-2.12067489f +
3461       //           (.645142248f - 0.816157886e-1f * x) * x) * x) * x;
3462       //
3463       // error 0.0000876136000, which is better than 13 bits
3464       SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3465                                getF32Constant(DAG, 0xbda7262e));
3466       SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
3467                                getF32Constant(DAG, 0x3f25280b));
3468       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
3469       SDValue t3 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
3470                                getF32Constant(DAG, 0x4007b923));
3471       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3472       SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
3473                                getF32Constant(DAG, 0x40823e2f));
3474       SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
3475       SDValue Log2ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t6,
3476                                            getF32Constant(DAG, 0x4020d29c));
3477
3478       result = DAG.getNode(ISD::FADD, dl,
3479                            MVT::f32, LogOfExponent, Log2ofMantissa);
3480     } else { // LimitFloatPrecision > 12 && LimitFloatPrecision <= 18
3481       // For floating-point precision of 18:
3482       //
3483       //   Log2ofMantissa =
3484       //     -3.0400495f +
3485       //       (6.1129976f +
3486       //         (-5.3420409f +
3487       //           (3.2865683f +
3488       //             (-1.2669343f +
3489       //               (0.27515199f -
3490       //                 0.25691327e-1f * x) * x) * x) * x) * x) * x;
3491       //
3492       // error 0.0000018516, which is better than 18 bits
3493       SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3494                                getF32Constant(DAG, 0xbcd2769e));
3495       SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
3496                                getF32Constant(DAG, 0x3e8ce0b9));
3497       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
3498       SDValue t3 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
3499                                getF32Constant(DAG, 0x3fa22ae7));
3500       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3501       SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
3502                                getF32Constant(DAG, 0x40525723));
3503       SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
3504       SDValue t7 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t6,
3505                                getF32Constant(DAG, 0x40aaf200));
3506       SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
3507       SDValue t9 = DAG.getNode(ISD::FADD, dl, MVT::f32, t8,
3508                                getF32Constant(DAG, 0x40c39dad));
3509       SDValue t10 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t9, X);
3510       SDValue Log2ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t10,
3511                                            getF32Constant(DAG, 0x4042902c));
3512
3513       result = DAG.getNode(ISD::FADD, dl,
3514                            MVT::f32, LogOfExponent, Log2ofMantissa);
3515     }
3516   } else {
3517     // No special expansion.
3518     result = DAG.getNode(ISD::FLOG2, dl,
3519                          getValue(I.getArgOperand(0)).getValueType(),
3520                          getValue(I.getArgOperand(0)));
3521   }
3522
3523   setValue(&I, result);
3524 }
3525
3526 /// visitLog10 - Lower a log10 intrinsic. Handles the special sequences for
3527 /// limited-precision mode.
3528 void
3529 SelectionDAGBuilder::visitLog10(const CallInst &I) {
3530   SDValue result;
3531   DebugLoc dl = getCurDebugLoc();
3532
3533   if (getValue(I.getArgOperand(0)).getValueType() == MVT::f32 &&
3534       LimitFloatPrecision > 0 && LimitFloatPrecision <= 18) {
3535     SDValue Op = getValue(I.getArgOperand(0));
3536     SDValue Op1 = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::i32, Op);
3537
3538     // Scale the exponent by log10(2) [0.30102999f].
3539     SDValue Exp = GetExponent(DAG, Op1, TLI, dl);
3540     SDValue LogOfExponent = DAG.getNode(ISD::FMUL, dl, MVT::f32, Exp,
3541                                         getF32Constant(DAG, 0x3e9a209a));
3542
3543     // Get the significand and build it into a floating-point number with
3544     // exponent of 1.
3545     SDValue X = GetSignificand(DAG, Op1, dl);
3546
3547     if (LimitFloatPrecision <= 6) {
3548       // For floating-point precision of 6:
3549       //
3550       //   Log10ofMantissa =
3551       //     -0.50419619f +
3552       //       (0.60948995f - 0.10380950f * x) * x;
3553       //
3554       // error 0.0014886165, which is 6 bits
3555       SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3556                                getF32Constant(DAG, 0xbdd49a13));
3557       SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
3558                                getF32Constant(DAG, 0x3f1c0789));
3559       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
3560       SDValue Log10ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
3561                                             getF32Constant(DAG, 0x3f011300));
3562
3563       result = DAG.getNode(ISD::FADD, dl,
3564                            MVT::f32, LogOfExponent, Log10ofMantissa);
3565     } else if (LimitFloatPrecision > 6 && LimitFloatPrecision <= 12) {
3566       // For floating-point precision of 12:
3567       //
3568       //   Log10ofMantissa =
3569       //     -0.64831180f +
3570       //       (0.91751397f +
3571       //         (-0.31664806f + 0.47637168e-1f * x) * x) * x;
3572       //
3573       // error 0.00019228036, which is better than 12 bits
3574       SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3575                                getF32Constant(DAG, 0x3d431f31));
3576       SDValue t1 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t0,
3577                                getF32Constant(DAG, 0x3ea21fb2));
3578       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
3579       SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
3580                                getF32Constant(DAG, 0x3f6ae232));
3581       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3582       SDValue Log10ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t4,
3583                                             getF32Constant(DAG, 0x3f25f7c3));
3584
3585       result = DAG.getNode(ISD::FADD, dl,
3586                            MVT::f32, LogOfExponent, Log10ofMantissa);
3587     } else { // LimitFloatPrecision > 12 && LimitFloatPrecision <= 18
3588       // For floating-point precision of 18:
3589       //
3590       //   Log10ofMantissa =
3591       //     -0.84299375f +
3592       //       (1.5327582f +
3593       //         (-1.0688956f +
3594       //           (0.49102474f +
3595       //             (-0.12539807f + 0.13508273e-1f * x) * x) * x) * x) * x;
3596       //
3597       // error 0.0000037995730, which is better than 18 bits
3598       SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3599                                getF32Constant(DAG, 0x3c5d51ce));
3600       SDValue t1 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t0,
3601                                getF32Constant(DAG, 0x3e00685a));
3602       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
3603       SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
3604                                getF32Constant(DAG, 0x3efb6798));
3605       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3606       SDValue t5 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t4,
3607                                getF32Constant(DAG, 0x3f88d192));
3608       SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
3609       SDValue t7 = DAG.getNode(ISD::FADD, dl, MVT::f32, t6,
3610                                getF32Constant(DAG, 0x3fc4316c));
3611       SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
3612       SDValue Log10ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t8,
3613                                             getF32Constant(DAG, 0x3f57ce70));
3614
3615       result = DAG.getNode(ISD::FADD, dl,
3616                            MVT::f32, LogOfExponent, Log10ofMantissa);
3617     }
3618   } else {
3619     // No special expansion.
3620     result = DAG.getNode(ISD::FLOG10, dl,
3621                          getValue(I.getArgOperand(0)).getValueType(),
3622                          getValue(I.getArgOperand(0)));
3623   }
3624
3625   setValue(&I, result);
3626 }
3627
3628 /// visitExp2 - Lower an exp2 intrinsic. Handles the special sequences for
3629 /// limited-precision mode.
3630 void
3631 SelectionDAGBuilder::visitExp2(const CallInst &I) {
3632   SDValue result;
3633   DebugLoc dl = getCurDebugLoc();
3634
3635   if (getValue(I.getArgOperand(0)).getValueType() == MVT::f32 &&
3636       LimitFloatPrecision > 0 && LimitFloatPrecision <= 18) {
3637     SDValue Op = getValue(I.getArgOperand(0));
3638
3639     SDValue IntegerPartOfX = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32, Op);
3640
3641     //   FractionalPartOfX = x - (float)IntegerPartOfX;
3642     SDValue t1 = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, IntegerPartOfX);
3643     SDValue X = DAG.getNode(ISD::FSUB, dl, MVT::f32, Op, t1);
3644
3645     //   IntegerPartOfX <<= 23;
3646     IntegerPartOfX = DAG.getNode(ISD::SHL, dl, MVT::i32, IntegerPartOfX,
3647                                  DAG.getConstant(23, TLI.getPointerTy()));
3648
3649     if (LimitFloatPrecision <= 6) {
3650       // For floating-point precision of 6:
3651       //
3652       //   TwoToFractionalPartOfX =
3653       //     0.997535578f +
3654       //       (0.735607626f + 0.252464424f * x) * x;
3655       //
3656       // error 0.0144103317, which is 6 bits
3657       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3658                                getF32Constant(DAG, 0x3e814304));
3659       SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
3660                                getF32Constant(DAG, 0x3f3c50c8));
3661       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3662       SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
3663                                getF32Constant(DAG, 0x3f7f5e7e));
3664       SDValue t6 = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::i32, t5);
3665       SDValue TwoToFractionalPartOfX =
3666         DAG.getNode(ISD::ADD, dl, MVT::i32, t6, IntegerPartOfX);
3667
3668       result = DAG.getNode(ISD::BIT_CONVERT, dl,
3669                            MVT::f32, TwoToFractionalPartOfX);
3670     } else if (LimitFloatPrecision > 6 && LimitFloatPrecision <= 12) {
3671       // For floating-point precision of 12:
3672       //
3673       //   TwoToFractionalPartOfX =
3674       //     0.999892986f +
3675       //       (0.696457318f +
3676       //         (0.224338339f + 0.792043434e-1f * x) * x) * x;
3677       //
3678       // error 0.000107046256, which is 13 to 14 bits
3679       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3680                                getF32Constant(DAG, 0x3da235e3));
3681       SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
3682                                getF32Constant(DAG, 0x3e65b8f3));
3683       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3684       SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
3685                                getF32Constant(DAG, 0x3f324b07));
3686       SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
3687       SDValue t7 = DAG.getNode(ISD::FADD, dl, MVT::f32, t6,
3688                                getF32Constant(DAG, 0x3f7ff8fd));
3689       SDValue t8 = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::i32, t7);
3690       SDValue TwoToFractionalPartOfX =
3691         DAG.getNode(ISD::ADD, dl, MVT::i32, t8, IntegerPartOfX);
3692
3693       result = DAG.getNode(ISD::BIT_CONVERT, dl,
3694                            MVT::f32, TwoToFractionalPartOfX);
3695     } else { // LimitFloatPrecision > 12 && LimitFloatPrecision <= 18
3696       // For floating-point precision of 18:
3697       //
3698       //   TwoToFractionalPartOfX =
3699       //     0.999999982f +
3700       //       (0.693148872f +
3701       //         (0.240227044f +
3702       //           (0.554906021e-1f +
3703       //             (0.961591928e-2f +
3704       //               (0.136028312e-2f + 0.157059148e-3f *x)*x)*x)*x)*x)*x;
3705       // error 2.47208000*10^(-7), which is better than 18 bits
3706       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3707                                getF32Constant(DAG, 0x3924b03e));
3708       SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
3709                                getF32Constant(DAG, 0x3ab24b87));
3710       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3711       SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
3712                                getF32Constant(DAG, 0x3c1d8c17));
3713       SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
3714       SDValue t7 = DAG.getNode(ISD::FADD, dl, MVT::f32, t6,
3715                                getF32Constant(DAG, 0x3d634a1d));
3716       SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
3717       SDValue t9 = DAG.getNode(ISD::FADD, dl, MVT::f32, t8,
3718                                getF32Constant(DAG, 0x3e75fe14));
3719       SDValue t10 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t9, X);
3720       SDValue t11 = DAG.getNode(ISD::FADD, dl, MVT::f32, t10,
3721                                 getF32Constant(DAG, 0x3f317234));
3722       SDValue t12 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t11, X);
3723       SDValue t13 = DAG.getNode(ISD::FADD, dl, MVT::f32, t12,
3724                                 getF32Constant(DAG, 0x3f800000));
3725       SDValue t14 = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::i32, t13);
3726       SDValue TwoToFractionalPartOfX =
3727         DAG.getNode(ISD::ADD, dl, MVT::i32, t14, IntegerPartOfX);
3728
3729       result = DAG.getNode(ISD::BIT_CONVERT, dl,
3730                            MVT::f32, TwoToFractionalPartOfX);
3731     }
3732   } else {
3733     // No special expansion.
3734     result = DAG.getNode(ISD::FEXP2, dl,
3735                          getValue(I.getArgOperand(0)).getValueType(),
3736                          getValue(I.getArgOperand(0)));
3737   }
3738
3739   setValue(&I, result);
3740 }
3741
3742 /// visitPow - Lower a pow intrinsic. Handles the special sequences for
3743 /// limited-precision mode with x == 10.0f.
3744 void
3745 SelectionDAGBuilder::visitPow(const CallInst &I) {
3746   SDValue result;
3747   const Value *Val = I.getArgOperand(0);
3748   DebugLoc dl = getCurDebugLoc();
3749   bool IsExp10 = false;
3750
3751   if (getValue(Val).getValueType() == MVT::f32 &&
3752       getValue(I.getArgOperand(1)).getValueType() == MVT::f32 &&
3753       LimitFloatPrecision > 0 && LimitFloatPrecision <= 18) {
3754     if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(Val))) {
3755       if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
3756         APFloat Ten(10.0f);
3757         IsExp10 = CFP->getValueAPF().bitwiseIsEqual(Ten);
3758       }
3759     }
3760   }
3761
3762   if (IsExp10 && LimitFloatPrecision > 0 && LimitFloatPrecision <= 18) {
3763     SDValue Op = getValue(I.getArgOperand(1));
3764
3765     // Put the exponent in the right bit position for later addition to the
3766     // final result:
3767     //
3768     //   #define LOG2OF10 3.3219281f
3769     //   IntegerPartOfX = (int32_t)(x * LOG2OF10);
3770     SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, Op,
3771                              getF32Constant(DAG, 0x40549a78));
3772     SDValue IntegerPartOfX = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32, t0);
3773
3774     //   FractionalPartOfX = x - (float)IntegerPartOfX;
3775     SDValue t1 = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, IntegerPartOfX);
3776     SDValue X = DAG.getNode(ISD::FSUB, dl, MVT::f32, t0, t1);
3777
3778     //   IntegerPartOfX <<= 23;
3779     IntegerPartOfX = DAG.getNode(ISD::SHL, dl, MVT::i32, IntegerPartOfX,
3780                                  DAG.getConstant(23, TLI.getPointerTy()));
3781
3782     if (LimitFloatPrecision <= 6) {
3783       // For floating-point precision of 6:
3784       //
3785       //   twoToFractionalPartOfX =
3786       //     0.997535578f +
3787       //       (0.735607626f + 0.252464424f * x) * x;
3788       //
3789       // error 0.0144103317, which is 6 bits
3790       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3791                                getF32Constant(DAG, 0x3e814304));
3792       SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
3793                                getF32Constant(DAG, 0x3f3c50c8));
3794       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3795       SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
3796                                getF32Constant(DAG, 0x3f7f5e7e));
3797       SDValue t6 = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::i32, t5);
3798       SDValue TwoToFractionalPartOfX =
3799         DAG.getNode(ISD::ADD, dl, MVT::i32, t6, IntegerPartOfX);
3800
3801       result = DAG.getNode(ISD::BIT_CONVERT, dl,
3802                            MVT::f32, TwoToFractionalPartOfX);
3803     } else if (LimitFloatPrecision > 6 && LimitFloatPrecision <= 12) {
3804       // For floating-point precision of 12:
3805       //
3806       //   TwoToFractionalPartOfX =
3807       //     0.999892986f +
3808       //       (0.696457318f +
3809       //         (0.224338339f + 0.792043434e-1f * x) * x) * x;
3810       //
3811       // error 0.000107046256, which is 13 to 14 bits
3812       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3813                                getF32Constant(DAG, 0x3da235e3));
3814       SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
3815                                getF32Constant(DAG, 0x3e65b8f3));
3816       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3817       SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
3818                                getF32Constant(DAG, 0x3f324b07));
3819       SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
3820       SDValue t7 = DAG.getNode(ISD::FADD, dl, MVT::f32, t6,
3821                                getF32Constant(DAG, 0x3f7ff8fd));
3822       SDValue t8 = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::i32, t7);
3823       SDValue TwoToFractionalPartOfX =
3824         DAG.getNode(ISD::ADD, dl, MVT::i32, t8, IntegerPartOfX);
3825
3826       result = DAG.getNode(ISD::BIT_CONVERT, dl,
3827                            MVT::f32, TwoToFractionalPartOfX);
3828     } else { // LimitFloatPrecision > 12 && LimitFloatPrecision <= 18
3829       // For floating-point precision of 18:
3830       //
3831       //   TwoToFractionalPartOfX =
3832       //     0.999999982f +
3833       //       (0.693148872f +
3834       //         (0.240227044f +
3835       //           (0.554906021e-1f +
3836       //             (0.961591928e-2f +
3837       //               (0.136028312e-2f + 0.157059148e-3f *x)*x)*x)*x)*x)*x;
3838       // error 2.47208000*10^(-7), which is better than 18 bits
3839       SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
3840                                getF32Constant(DAG, 0x3924b03e));
3841       SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
3842                                getF32Constant(DAG, 0x3ab24b87));
3843       SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
3844       SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
3845                                getF32Constant(DAG, 0x3c1d8c17));
3846       SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
3847       SDValue t7 = DAG.getNode(ISD::FADD, dl, MVT::f32, t6,
3848                                getF32Constant(DAG, 0x3d634a1d));
3849       SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
3850       SDValue t9 = DAG.getNode(ISD::FADD, dl, MVT::f32, t8,
3851                                getF32Constant(DAG, 0x3e75fe14));
3852       SDValue t10 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t9, X);
3853       SDValue t11 = DAG.getNode(ISD::FADD, dl, MVT::f32, t10,
3854                                 getF32Constant(DAG, 0x3f317234));
3855       SDValue t12 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t11, X);
3856       SDValue t13 = DAG.getNode(ISD::FADD, dl, MVT::f32, t12,
3857                                 getF32Constant(DAG, 0x3f800000));
3858       SDValue t14 = DAG.getNode(ISD::BIT_CONVERT, dl, MVT::i32, t13);
3859       SDValue TwoToFractionalPartOfX =
3860         DAG.getNode(ISD::ADD, dl, MVT::i32, t14, IntegerPartOfX);
3861
3862       result = DAG.getNode(ISD::BIT_CONVERT, dl,
3863                            MVT::f32, TwoToFractionalPartOfX);
3864     }
3865   } else {
3866     // No special expansion.
3867     result = DAG.getNode(ISD::FPOW, dl,
3868                          getValue(I.getArgOperand(0)).getValueType(),
3869                          getValue(I.getArgOperand(0)),
3870                          getValue(I.getArgOperand(1)));
3871   }
3872
3873   setValue(&I, result);
3874 }
3875
3876
3877 /// ExpandPowI - Expand a llvm.powi intrinsic.
3878 static SDValue ExpandPowI(DebugLoc DL, SDValue LHS, SDValue RHS,
3879                           SelectionDAG &DAG) {
3880   // If RHS is a constant, we can expand this out to a multiplication tree,
3881   // otherwise we end up lowering to a call to __powidf2 (for example).  When
3882   // optimizing for size, we only want to do this if the expansion would produce
3883   // a small number of multiplies, otherwise we do the full expansion.
3884   if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS)) {
3885     // Get the exponent as a positive value.
3886     unsigned Val = RHSC->getSExtValue();
3887     if ((int)Val < 0) Val = -Val;
3888
3889     // powi(x, 0) -> 1.0
3890     if (Val == 0)
3891       return DAG.getConstantFP(1.0, LHS.getValueType());
3892
3893     const Function *F = DAG.getMachineFunction().getFunction();
3894     if (!F->hasFnAttr(Attribute::OptimizeForSize) ||
3895         // If optimizing for size, don't insert too many multiplies.  This
3896         // inserts up to 5 multiplies.
3897         CountPopulation_32(Val)+Log2_32(Val) < 7) {
3898       // We use the simple binary decomposition method to generate the multiply
3899       // sequence.  There are more optimal ways to do this (for example,
3900       // powi(x,15) generates one more multiply than it should), but this has
3901       // the benefit of being both really simple and much better than a libcall.
3902       SDValue Res;  // Logically starts equal to 1.0
3903       SDValue CurSquare = LHS;
3904       while (Val) {
3905         if (Val & 1) {
3906           if (Res.getNode())
3907             Res = DAG.getNode(ISD::FMUL, DL,Res.getValueType(), Res, CurSquare);
3908           else
3909             Res = CurSquare;  // 1.0*CurSquare.
3910         }
3911
3912         CurSquare = DAG.getNode(ISD::FMUL, DL, CurSquare.getValueType(),
3913                                 CurSquare, CurSquare);
3914         Val >>= 1;
3915       }
3916
3917       // If the original was negative, invert the result, producing 1/(x*x*x).
3918       if (RHSC->getSExtValue() < 0)
3919         Res = DAG.getNode(ISD::FDIV, DL, LHS.getValueType(),
3920                           DAG.getConstantFP(1.0, LHS.getValueType()), Res);
3921       return Res;
3922     }
3923   }
3924
3925   // Otherwise, expand to a libcall.
3926   return DAG.getNode(ISD::FPOWI, DL, LHS.getValueType(), LHS, RHS);
3927 }
3928
3929 /// EmitFuncArgumentDbgValue - If the DbgValueInst is a dbg_value of a function
3930 /// argument, create the corresponding DBG_VALUE machine instruction for it now.
3931 /// At the end of instruction selection, they will be inserted to the entry BB.
3932 bool
3933 SelectionDAGBuilder::EmitFuncArgumentDbgValue(const Value *V, MDNode *Variable,
3934                                               uint64_t Offset,
3935                                               const SDValue &N) {
3936   if (!isa<Argument>(V))
3937     return false;
3938
3939   MachineFunction &MF = DAG.getMachineFunction();
3940   // Ignore inlined function arguments here.
3941   DIVariable DV(Variable);
3942   if (DV.isInlinedFnArgument(MF.getFunction()))
3943     return false;
3944
3945   MachineBasicBlock *MBB = FuncInfo.MBB;
3946   if (MBB != &MF.front())
3947     return false;
3948
3949   unsigned Reg = 0;
3950   if (N.getNode() && N.getOpcode() == ISD::CopyFromReg) {
3951     Reg = cast<RegisterSDNode>(N.getOperand(1))->getReg();
3952     if (Reg && TargetRegisterInfo::isVirtualRegister(Reg)) {
3953       MachineRegisterInfo &RegInfo = MF.getRegInfo();
3954       unsigned PR = RegInfo.getLiveInPhysReg(Reg);
3955       if (PR)
3956         Reg = PR;
3957     }
3958   }
3959
3960   if (!Reg) {
3961     DenseMap<const Value *, unsigned>::iterator VMI = FuncInfo.ValueMap.find(V);
3962     if (VMI == FuncInfo.ValueMap.end())
3963       return false;
3964     Reg = VMI->second;
3965   }
3966
3967   const TargetInstrInfo *TII = DAG.getTarget().getInstrInfo();
3968   MachineInstrBuilder MIB = BuildMI(MF, getCurDebugLoc(),
3969                                     TII->get(TargetOpcode::DBG_VALUE))
3970     .addReg(Reg, RegState::Debug).addImm(Offset).addMetadata(Variable);
3971   FuncInfo.ArgDbgValues.push_back(&*MIB);
3972   return true;
3973 }
3974
3975 // VisualStudio defines setjmp as _setjmp
3976 #if defined(_MSC_VER) && defined(setjmp)
3977 #define setjmp_undefined_for_visual_studio
3978 #undef setjmp
3979 #endif
3980
3981 /// visitIntrinsicCall - Lower the call to the specified intrinsic function.  If
3982 /// we want to emit this as a call to a named external function, return the name
3983 /// otherwise lower it and return null.
3984 const char *
3985 SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I, unsigned Intrinsic) {
3986   DebugLoc dl = getCurDebugLoc();
3987   SDValue Res;
3988
3989   switch (Intrinsic) {
3990   default:
3991     // By default, turn this into a target intrinsic node.
3992     visitTargetIntrinsic(I, Intrinsic);
3993     return 0;
3994   case Intrinsic::vastart:  visitVAStart(I); return 0;
3995   case Intrinsic::vaend:    visitVAEnd(I); return 0;
3996   case Intrinsic::vacopy:   visitVACopy(I); return 0;
3997   case Intrinsic::returnaddress:
3998     setValue(&I, DAG.getNode(ISD::RETURNADDR, dl, TLI.getPointerTy(),
3999                              getValue(I.getArgOperand(0))));
4000     return 0;
4001   case Intrinsic::frameaddress:
4002     setValue(&I, DAG.getNode(ISD::FRAMEADDR, dl, TLI.getPointerTy(),
4003                              getValue(I.getArgOperand(0))));
4004     return 0;
4005   case Intrinsic::setjmp:
4006     return "_setjmp"+!TLI.usesUnderscoreSetJmp();
4007   case Intrinsic::longjmp:
4008     return "_longjmp"+!TLI.usesUnderscoreLongJmp();
4009   case Intrinsic::memcpy: {
4010     // Assert for address < 256 since we support only user defined address
4011     // spaces.
4012     assert(cast<PointerType>(I.getArgOperand(0)->getType())->getAddressSpace()
4013            < 256 &&
4014            cast<PointerType>(I.getArgOperand(1)->getType())->getAddressSpace()
4015            < 256 &&
4016            "Unknown address space");
4017     SDValue Op1 = getValue(I.getArgOperand(0));
4018     SDValue Op2 = getValue(I.getArgOperand(1));
4019     SDValue Op3 = getValue(I.getArgOperand(2));
4020     unsigned Align = cast<ConstantInt>(I.getArgOperand(3))->getZExtValue();
4021     bool isVol = cast<ConstantInt>(I.getArgOperand(4))->getZExtValue();
4022     DAG.setRoot(DAG.getMemcpy(getRoot(), dl, Op1, Op2, Op3, Align, isVol, false,
4023                               I.getArgOperand(0), 0, I.getArgOperand(1), 0));
4024     return 0;
4025   }
4026   case Intrinsic::memset: {
4027     // Assert for address < 256 since we support only user defined address
4028     // spaces.
4029     assert(cast<PointerType>(I.getArgOperand(0)->getType())->getAddressSpace()
4030            < 256 &&
4031            "Unknown address space");
4032     SDValue Op1 = getValue(I.getArgOperand(0));
4033     SDValue Op2 = getValue(I.getArgOperand(1));
4034     SDValue Op3 = getValue(I.getArgOperand(2));
4035     unsigned Align = cast<ConstantInt>(I.getArgOperand(3))->getZExtValue();
4036     bool isVol = cast<ConstantInt>(I.getArgOperand(4))->getZExtValue();
4037     DAG.setRoot(DAG.getMemset(getRoot(), dl, Op1, Op2, Op3, Align, isVol,
4038                               I.getArgOperand(0), 0));
4039     return 0;
4040   }
4041   case Intrinsic::memmove: {
4042     // Assert for address < 256 since we support only user defined address
4043     // spaces.
4044     assert(cast<PointerType>(I.getArgOperand(0)->getType())->getAddressSpace()
4045            < 256 &&
4046            cast<PointerType>(I.getArgOperand(1)->getType())->getAddressSpace()
4047            < 256 &&
4048            "Unknown address space");
4049     SDValue Op1 = getValue(I.getArgOperand(0));
4050     SDValue Op2 = getValue(I.getArgOperand(1));
4051     SDValue Op3 = getValue(I.getArgOperand(2));
4052     unsigned Align = cast<ConstantInt>(I.getArgOperand(3))->getZExtValue();
4053     bool isVol = cast<ConstantInt>(I.getArgOperand(4))->getZExtValue();
4054
4055     // If the source and destination are known to not be aliases, we can
4056     // lower memmove as memcpy.
4057     uint64_t Size = -1ULL;
4058     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op3))
4059       Size = C->getZExtValue();
4060     if (AA->alias(I.getArgOperand(0), Size, I.getArgOperand(1), Size) ==
4061         AliasAnalysis::NoAlias) {
4062       DAG.setRoot(DAG.getMemcpy(getRoot(), dl, Op1, Op2, Op3, Align, isVol,
4063                                 false, I.getArgOperand(0), 0,
4064                                 I.getArgOperand(1), 0));
4065       return 0;
4066     }
4067
4068     DAG.setRoot(DAG.getMemmove(getRoot(), dl, Op1, Op2, Op3, Align, isVol,
4069                                I.getArgOperand(0), 0, I.getArgOperand(1), 0));
4070     return 0;
4071   }
4072   case Intrinsic::dbg_declare: {
4073     const DbgDeclareInst &DI = cast<DbgDeclareInst>(I);
4074     if (!DIVariable(DI.getVariable()).Verify())
4075       return 0;
4076
4077     MDNode *Variable = DI.getVariable();
4078     // Parameters are handled specially.
4079     bool isParameter =
4080       DIVariable(Variable).getTag() == dwarf::DW_TAG_arg_variable;
4081     const Value *Address = DI.getAddress();
4082     if (!Address)
4083       return 0;
4084     if (const BitCastInst *BCI = dyn_cast<BitCastInst>(Address))
4085       Address = BCI->getOperand(0);
4086     const AllocaInst *AI = dyn_cast<AllocaInst>(Address);
4087
4088     // Build an entry in DbgOrdering.  Debug info input nodes get an SDNodeOrder
4089     // but do not always have a corresponding SDNode built.  The SDNodeOrder
4090     // absolute, but not relative, values are different depending on whether
4091     // debug info exists.
4092     ++SDNodeOrder;
4093     SDValue &N = NodeMap[Address];
4094     SDDbgValue *SDV;
4095     if (N.getNode()) {
4096       if (isParameter && !AI) {
4097         FrameIndexSDNode *FINode = dyn_cast<FrameIndexSDNode>(N.getNode());
4098         if (FINode)
4099           // Byval parameter.  We have a frame index at this point.
4100           SDV = DAG.getDbgValue(Variable, FINode->getIndex(),
4101                                 0, dl, SDNodeOrder);
4102         else
4103           // Can't do anything with other non-AI cases yet.  This might be a
4104           // parameter of a callee function that got inlined, for example.
4105           return 0;
4106       } else if (AI)
4107         SDV = DAG.getDbgValue(Variable, N.getNode(), N.getResNo(),
4108                               0, dl, SDNodeOrder);
4109       else
4110         // Can't do anything with other non-AI cases yet.
4111         return 0;
4112       DAG.AddDbgValue(SDV, N.getNode(), isParameter);
4113     } else {
4114       // If Address is an arugment then try to emits its dbg value using
4115       // virtual register info from the FuncInfo.ValueMap. Otherwise add undef
4116       // to help track missing debug info.
4117       if (!EmitFuncArgumentDbgValue(Address, Variable, 0, N)) {
4118         SDV = DAG.getDbgValue(Variable, UndefValue::get(Address->getType()),
4119                               0, dl, SDNodeOrder);
4120         DAG.AddDbgValue(SDV, 0, isParameter);
4121       }
4122     }
4123     return 0;
4124   }
4125   case Intrinsic::dbg_value: {
4126     const DbgValueInst &DI = cast<DbgValueInst>(I);
4127     if (!DIVariable(DI.getVariable()).Verify())
4128       return 0;
4129
4130     MDNode *Variable = DI.getVariable();
4131     uint64_t Offset = DI.getOffset();
4132     const Value *V = DI.getValue();
4133     if (!V)
4134       return 0;
4135
4136     // Build an entry in DbgOrdering.  Debug info input nodes get an SDNodeOrder
4137     // but do not always have a corresponding SDNode built.  The SDNodeOrder
4138     // absolute, but not relative, values are different depending on whether
4139     // debug info exists.
4140     ++SDNodeOrder;
4141     SDDbgValue *SDV;
4142     if (isa<ConstantInt>(V) || isa<ConstantFP>(V)) {
4143       SDV = DAG.getDbgValue(Variable, V, Offset, dl, SDNodeOrder);
4144       DAG.AddDbgValue(SDV, 0, false);
4145     } else {
4146       bool createUndef = false;
4147       // Do not use getValue() in here; we don't want to generate code at
4148       // this point if it hasn't been done yet.
4149       SDValue N = NodeMap[V];
4150       if (!N.getNode() && isa<Argument>(V))
4151         // Check unused arguments map.
4152         N = UnusedArgNodeMap[V];
4153       if (N.getNode()) {
4154         if (!EmitFuncArgumentDbgValue(V, Variable, Offset, N)) {
4155           SDV = DAG.getDbgValue(Variable, N.getNode(),
4156                                 N.getResNo(), Offset, dl, SDNodeOrder);
4157           DAG.AddDbgValue(SDV, N.getNode(), false);
4158         }
4159       } else if (isa<PHINode>(V) && !V->use_empty() ) {
4160         // Do not call getValue(V) yet, as we don't want to generate code.
4161         // Remember it for later.
4162         DanglingDebugInfo DDI(&DI, dl, SDNodeOrder);
4163         DanglingDebugInfoMap[V] = DDI;
4164       } else
4165         createUndef = true;
4166       if (createUndef) {
4167         // We may expand this to cover more cases.  One case where we have no
4168         // data available is an unreferenced parameter; we need this fallback.
4169         SDV = DAG.getDbgValue(Variable, UndefValue::get(V->getType()),
4170                               Offset, dl, SDNodeOrder);
4171         DAG.AddDbgValue(SDV, 0, false);
4172       }
4173     }
4174
4175     // Build a debug info table entry.
4176     if (const BitCastInst *BCI = dyn_cast<BitCastInst>(V))
4177       V = BCI->getOperand(0);
4178     const AllocaInst *AI = dyn_cast<AllocaInst>(V);
4179     // Don't handle byval struct arguments or VLAs, for example.
4180     if (!AI)
4181       return 0;
4182     DenseMap<const AllocaInst*, int>::iterator SI =
4183       FuncInfo.StaticAllocaMap.find(AI);
4184     if (SI == FuncInfo.StaticAllocaMap.end())
4185       return 0; // VLAs.
4186     int FI = SI->second;
4187
4188     MachineModuleInfo &MMI = DAG.getMachineFunction().getMMI();
4189     if (!DI.getDebugLoc().isUnknown() && MMI.hasDebugInfo())
4190       MMI.setVariableDbgInfo(Variable, FI, DI.getDebugLoc());
4191     return 0;
4192   }
4193   case Intrinsic::eh_exception: {
4194     // Insert the EXCEPTIONADDR instruction.
4195     assert(FuncInfo.MBB->isLandingPad() &&
4196            "Call to eh.exception not in landing pad!");
4197     SDVTList VTs = DAG.getVTList(TLI.getPointerTy(), MVT::Other);
4198     SDValue Ops[1];
4199     Ops[0] = DAG.getRoot();
4200     SDValue Op = DAG.getNode(ISD::EXCEPTIONADDR, dl, VTs, Ops, 1);
4201     setValue(&I, Op);
4202     DAG.setRoot(Op.getValue(1));
4203     return 0;
4204   }
4205
4206   case Intrinsic::eh_selector: {
4207     MachineBasicBlock *CallMBB = FuncInfo.MBB;
4208     MachineModuleInfo &MMI = DAG.getMachineFunction().getMMI();
4209     if (CallMBB->isLandingPad())
4210       AddCatchInfo(I, &MMI, CallMBB);
4211     else {
4212 #ifndef NDEBUG
4213       FuncInfo.CatchInfoLost.insert(&I);
4214 #endif
4215       // FIXME: Mark exception selector register as live in.  Hack for PR1508.
4216       unsigned Reg = TLI.getExceptionSelectorRegister();
4217       if (Reg) FuncInfo.MBB->addLiveIn(Reg);
4218     }
4219
4220     // Insert the EHSELECTION instruction.
4221     SDVTList VTs = DAG.getVTList(TLI.getPointerTy(), MVT::Other);
4222     SDValue Ops[2];
4223     Ops[0] = getValue(I.getArgOperand(0));
4224     Ops[1] = getRoot();
4225     SDValue Op = DAG.getNode(ISD::EHSELECTION, dl, VTs, Ops, 2);
4226     DAG.setRoot(Op.getValue(1));
4227     setValue(&I, DAG.getSExtOrTrunc(Op, dl, MVT::i32));
4228     return 0;
4229   }
4230
4231   case Intrinsic::eh_typeid_for: {
4232     // Find the type id for the given typeinfo.
4233     GlobalVariable *GV = ExtractTypeInfo(I.getArgOperand(0));
4234     unsigned TypeID = DAG.getMachineFunction().getMMI().getTypeIDFor(GV);
4235     Res = DAG.getConstant(TypeID, MVT::i32);
4236     setValue(&I, Res);
4237     return 0;
4238   }
4239
4240   case Intrinsic::eh_return_i32:
4241   case Intrinsic::eh_return_i64:
4242     DAG.getMachineFunction().getMMI().setCallsEHReturn(true);
4243     DAG.setRoot(DAG.getNode(ISD::EH_RETURN, dl,
4244                             MVT::Other,
4245                             getControlRoot(),
4246                             getValue(I.getArgOperand(0)),
4247                             getValue(I.getArgOperand(1))));
4248     return 0;
4249   case Intrinsic::eh_unwind_init:
4250     DAG.getMachineFunction().getMMI().setCallsUnwindInit(true);
4251     return 0;
4252   case Intrinsic::eh_dwarf_cfa: {
4253     SDValue CfaArg = DAG.getSExtOrTrunc(getValue(I.getArgOperand(0)), dl,
4254                                         TLI.getPointerTy());
4255     SDValue Offset = DAG.getNode(ISD::ADD, dl,
4256                                  TLI.getPointerTy(),
4257                                  DAG.getNode(ISD::FRAME_TO_ARGS_OFFSET, dl,
4258                                              TLI.getPointerTy()),
4259                                  CfaArg);
4260     SDValue FA = DAG.getNode(ISD::FRAMEADDR, dl,
4261                              TLI.getPointerTy(),
4262                              DAG.getConstant(0, TLI.getPointerTy()));
4263     setValue(&I, DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(),
4264                              FA, Offset));
4265     return 0;
4266   }
4267   case Intrinsic::eh_sjlj_callsite: {
4268     MachineModuleInfo &MMI = DAG.getMachineFunction().getMMI();
4269     ConstantInt *CI = dyn_cast<ConstantInt>(I.getArgOperand(0));
4270     assert(CI && "Non-constant call site value in eh.sjlj.callsite!");
4271     assert(MMI.getCurrentCallSite() == 0 && "Overlapping call sites!");
4272
4273     MMI.setCurrentCallSite(CI->getZExtValue());
4274     return 0;
4275   }
4276   case Intrinsic::eh_sjlj_setjmp: {
4277     setValue(&I, DAG.getNode(ISD::EH_SJLJ_SETJMP, dl, MVT::i32, getRoot(),
4278                              getValue(I.getArgOperand(0))));
4279     return 0;
4280   }
4281   case Intrinsic::eh_sjlj_longjmp: {
4282     DAG.setRoot(DAG.getNode(ISD::EH_SJLJ_LONGJMP, dl, MVT::Other,
4283                             getRoot(),
4284                             getValue(I.getArgOperand(0))));
4285     return 0;
4286   }
4287
4288   case Intrinsic::convertff:
4289   case Intrinsic::convertfsi:
4290   case Intrinsic::convertfui:
4291   case Intrinsic::convertsif:
4292   case Intrinsic::convertuif:
4293   case Intrinsic::convertss:
4294   case Intrinsic::convertsu:
4295   case Intrinsic::convertus:
4296   case Intrinsic::convertuu: {
4297     ISD::CvtCode Code = ISD::CVT_INVALID;
4298     switch (Intrinsic) {
4299     case Intrinsic::convertff:  Code = ISD::CVT_FF; break;
4300     case Intrinsic::convertfsi: Code = ISD::CVT_FS; break;
4301     case Intrinsic::convertfui: Code = ISD::CVT_FU; break;
4302     case Intrinsic::convertsif: Code = ISD::CVT_SF; break;
4303     case Intrinsic::convertuif: Code = ISD::CVT_UF; break;
4304     case Intrinsic::convertss:  Code = ISD::CVT_SS; break;
4305     case Intrinsic::convertsu:  Code = ISD::CVT_SU; break;
4306     case Intrinsic::convertus:  Code = ISD::CVT_US; break;
4307     case Intrinsic::convertuu:  Code = ISD::CVT_UU; break;
4308     }
4309     EVT DestVT = TLI.getValueType(I.getType());
4310     const Value *Op1 = I.getArgOperand(0);
4311     Res = DAG.getConvertRndSat(DestVT, getCurDebugLoc(), getValue(Op1),
4312                                DAG.getValueType(DestVT),
4313                                DAG.getValueType(getValue(Op1).getValueType()),
4314                                getValue(I.getArgOperand(1)),
4315                                getValue(I.getArgOperand(2)),
4316                                Code);
4317     setValue(&I, Res);
4318     return 0;
4319   }
4320   case Intrinsic::sqrt:
4321     setValue(&I, DAG.getNode(ISD::FSQRT, dl,
4322                              getValue(I.getArgOperand(0)).getValueType(),
4323                              getValue(I.getArgOperand(0))));
4324     return 0;
4325   case Intrinsic::powi:
4326     setValue(&I, ExpandPowI(dl, getValue(I.getArgOperand(0)),
4327                             getValue(I.getArgOperand(1)), DAG));
4328     return 0;
4329   case Intrinsic::sin:
4330     setValue(&I, DAG.getNode(ISD::FSIN, dl,
4331                              getValue(I.getArgOperand(0)).getValueType(),
4332                              getValue(I.getArgOperand(0))));
4333     return 0;
4334   case Intrinsic::cos:
4335     setValue(&I, DAG.getNode(ISD::FCOS, dl,
4336                              getValue(I.getArgOperand(0)).getValueType(),
4337                              getValue(I.getArgOperand(0))));
4338     return 0;
4339   case Intrinsic::log:
4340     visitLog(I);
4341     return 0;
4342   case Intrinsic::log2:
4343     visitLog2(I);
4344     return 0;
4345   case Intrinsic::log10:
4346     visitLog10(I);
4347     return 0;
4348   case Intrinsic::exp:
4349     visitExp(I);
4350     return 0;
4351   case Intrinsic::exp2:
4352     visitExp2(I);
4353     return 0;
4354   case Intrinsic::pow:
4355     visitPow(I);
4356     return 0;
4357   case Intrinsic::convert_to_fp16:
4358     setValue(&I, DAG.getNode(ISD::FP32_TO_FP16, dl,
4359                              MVT::i16, getValue(I.getArgOperand(0))));
4360     return 0;
4361   case Intrinsic::convert_from_fp16:
4362     setValue(&I, DAG.getNode(ISD::FP16_TO_FP32, dl,
4363                              MVT::f32, getValue(I.getArgOperand(0))));
4364     return 0;
4365   case Intrinsic::pcmarker: {
4366     SDValue Tmp = getValue(I.getArgOperand(0));
4367     DAG.setRoot(DAG.getNode(ISD::PCMARKER, dl, MVT::Other, getRoot(), Tmp));
4368     return 0;
4369   }
4370   case Intrinsic::readcyclecounter: {
4371     SDValue Op = getRoot();
4372     Res = DAG.getNode(ISD::READCYCLECOUNTER, dl,
4373                       DAG.getVTList(MVT::i64, MVT::Other),
4374                       &Op, 1);
4375     setValue(&I, Res);
4376     DAG.setRoot(Res.getValue(1));
4377     return 0;
4378   }
4379   case Intrinsic::bswap:
4380     setValue(&I, DAG.getNode(ISD::BSWAP, dl,
4381                              getValue(I.getArgOperand(0)).getValueType(),
4382                              getValue(I.getArgOperand(0))));
4383     return 0;
4384   case Intrinsic::cttz: {
4385     SDValue Arg = getValue(I.getArgOperand(0));
4386     EVT Ty = Arg.getValueType();
4387     setValue(&I, DAG.getNode(ISD::CTTZ, dl, Ty, Arg));
4388     return 0;
4389   }
4390   case Intrinsic::ctlz: {
4391     SDValue Arg = getValue(I.getArgOperand(0));
4392     EVT Ty = Arg.getValueType();
4393     setValue(&I, DAG.getNode(ISD::CTLZ, dl, Ty, Arg));
4394     return 0;
4395   }
4396   case Intrinsic::ctpop: {
4397     SDValue Arg = getValue(I.getArgOperand(0));
4398     EVT Ty = Arg.getValueType();
4399     setValue(&I, DAG.getNode(ISD::CTPOP, dl, Ty, Arg));
4400     return 0;
4401   }
4402   case Intrinsic::stacksave: {
4403     SDValue Op = getRoot();
4404     Res = DAG.getNode(ISD::STACKSAVE, dl,
4405                       DAG.getVTList(TLI.getPointerTy(), MVT::Other), &Op, 1);
4406     setValue(&I, Res);
4407     DAG.setRoot(Res.getValue(1));
4408     return 0;
4409   }
4410   case Intrinsic::stackrestore: {
4411     Res = getValue(I.getArgOperand(0));
4412     DAG.setRoot(DAG.getNode(ISD::STACKRESTORE, dl, MVT::Other, getRoot(), Res));
4413     return 0;
4414   }
4415   case Intrinsic::stackprotector: {
4416     // Emit code into the DAG to store the stack guard onto the stack.
4417     MachineFunction &MF = DAG.getMachineFunction();
4418     MachineFrameInfo *MFI = MF.getFrameInfo();
4419     EVT PtrTy = TLI.getPointerTy();
4420
4421     SDValue Src = getValue(I.getArgOperand(0));   // The guard's value.
4422     AllocaInst *Slot = cast<AllocaInst>(I.getArgOperand(1));
4423
4424     int FI = FuncInfo.StaticAllocaMap[Slot];
4425     MFI->setStackProtectorIndex(FI);
4426
4427     SDValue FIN = DAG.getFrameIndex(FI, PtrTy);
4428
4429     // Store the stack protector onto the stack.
4430     Res = DAG.getStore(getRoot(), getCurDebugLoc(), Src, FIN,
4431                        PseudoSourceValue::getFixedStack(FI),
4432                        0, true, false, 0);
4433     setValue(&I, Res);
4434     DAG.setRoot(Res);
4435     return 0;
4436   }
4437   case Intrinsic::objectsize: {
4438     // If we don't know by now, we're never going to know.
4439     ConstantInt *CI = dyn_cast<ConstantInt>(I.getArgOperand(1));
4440
4441     assert(CI && "Non-constant type in __builtin_object_size?");
4442
4443     SDValue Arg = getValue(I.getCalledValue());
4444     EVT Ty = Arg.getValueType();
4445
4446     if (CI->isZero())
4447       Res = DAG.getConstant(-1ULL, Ty);
4448     else
4449       Res = DAG.getConstant(0, Ty);
4450
4451     setValue(&I, Res);
4452     return 0;
4453   }
4454   case Intrinsic::var_annotation:
4455     // Discard annotate attributes
4456     return 0;
4457
4458   case Intrinsic::init_trampoline: {
4459     const Function *F = cast<Function>(I.getArgOperand(1)->stripPointerCasts());
4460
4461     SDValue Ops[6];
4462     Ops[0] = getRoot();
4463     Ops[1] = getValue(I.getArgOperand(0));
4464     Ops[2] = getValue(I.getArgOperand(1));
4465     Ops[3] = getValue(I.getArgOperand(2));
4466     Ops[4] = DAG.getSrcValue(I.getArgOperand(0));
4467     Ops[5] = DAG.getSrcValue(F);
4468
4469     Res = DAG.getNode(ISD::TRAMPOLINE, dl,
4470                       DAG.getVTList(TLI.getPointerTy(), MVT::Other),
4471                       Ops, 6);
4472
4473     setValue(&I, Res);
4474     DAG.setRoot(Res.getValue(1));
4475     return 0;
4476   }
4477   case Intrinsic::gcroot:
4478     if (GFI) {
4479       const Value *Alloca = I.getArgOperand(0);
4480       const Constant *TypeMap = cast<Constant>(I.getArgOperand(1));
4481
4482       FrameIndexSDNode *FI = cast<FrameIndexSDNode>(getValue(Alloca).getNode());
4483       GFI->addStackRoot(FI->getIndex(), TypeMap);
4484     }
4485     return 0;
4486   case Intrinsic::gcread:
4487   case Intrinsic::gcwrite:
4488     llvm_unreachable("GC failed to lower gcread/gcwrite intrinsics!");
4489     return 0;
4490   case Intrinsic::flt_rounds:
4491     setValue(&I, DAG.getNode(ISD::FLT_ROUNDS_, dl, MVT::i32));
4492     return 0;
4493   case Intrinsic::trap:
4494     DAG.setRoot(DAG.getNode(ISD::TRAP, dl,MVT::Other, getRoot()));
4495     return 0;
4496   case Intrinsic::uadd_with_overflow:
4497     return implVisitAluOverflow(I, ISD::UADDO);
4498   case Intrinsic::sadd_with_overflow:
4499     return implVisitAluOverflow(I, ISD::SADDO);
4500   case Intrinsic::usub_with_overflow:
4501     return implVisitAluOverflow(I, ISD::USUBO);
4502   case Intrinsic::ssub_with_overflow:
4503     return implVisitAluOverflow(I, ISD::SSUBO);
4504   case Intrinsic::umul_with_overflow:
4505     return implVisitAluOverflow(I, ISD::UMULO);
4506   case Intrinsic::smul_with_overflow:
4507     return implVisitAluOverflow(I, ISD::SMULO);
4508
4509   case Intrinsic::prefetch: {
4510     SDValue Ops[4];
4511     Ops[0] = getRoot();
4512     Ops[1] = getValue(I.getArgOperand(0));
4513     Ops[2] = getValue(I.getArgOperand(1));
4514     Ops[3] = getValue(I.getArgOperand(2));
4515     DAG.setRoot(DAG.getNode(ISD::PREFETCH, dl, MVT::Other, &Ops[0], 4));
4516     return 0;
4517   }
4518
4519   case Intrinsic::memory_barrier: {
4520     SDValue Ops[6];
4521     Ops[0] = getRoot();
4522     for (int x = 1; x < 6; ++x)
4523       Ops[x] = getValue(I.getArgOperand(x - 1));
4524
4525     DAG.setRoot(DAG.getNode(ISD::MEMBARRIER, dl, MVT::Other, &Ops[0], 6));
4526     return 0;
4527   }
4528   case Intrinsic::atomic_cmp_swap: {
4529     SDValue Root = getRoot();
4530     SDValue L =
4531       DAG.getAtomic(ISD::ATOMIC_CMP_SWAP, getCurDebugLoc(),
4532                     getValue(I.getArgOperand(1)).getValueType().getSimpleVT(),
4533                     Root,
4534                     getValue(I.getArgOperand(0)),
4535                     getValue(I.getArgOperand(1)),
4536                     getValue(I.getArgOperand(2)),
4537                     I.getArgOperand(0));
4538     setValue(&I, L);
4539     DAG.setRoot(L.getValue(1));
4540     return 0;
4541   }
4542   case Intrinsic::atomic_load_add:
4543     return implVisitBinaryAtomic(I, ISD::ATOMIC_LOAD_ADD);
4544   case Intrinsic::atomic_load_sub:
4545     return implVisitBinaryAtomic(I, ISD::ATOMIC_LOAD_SUB);
4546   case Intrinsic::atomic_load_or:
4547     return implVisitBinaryAtomic(I, ISD::ATOMIC_LOAD_OR);
4548   case Intrinsic::atomic_load_xor:
4549     return implVisitBinaryAtomic(I, ISD::ATOMIC_LOAD_XOR);
4550   case Intrinsic::atomic_load_and:
4551     return implVisitBinaryAtomic(I, ISD::ATOMIC_LOAD_AND);
4552   case Intrinsic::atomic_load_nand:
4553     return implVisitBinaryAtomic(I, ISD::ATOMIC_LOAD_NAND);
4554   case Intrinsic::atomic_load_max:
4555     return implVisitBinaryAtomic(I, ISD::ATOMIC_LOAD_MAX);
4556   case Intrinsic::atomic_load_min:
4557     return implVisitBinaryAtomic(I, ISD::ATOMIC_LOAD_MIN);
4558   case Intrinsic::atomic_load_umin:
4559     return implVisitBinaryAtomic(I, ISD::ATOMIC_LOAD_UMIN);
4560   case Intrinsic::atomic_load_umax:
4561     return implVisitBinaryAtomic(I, ISD::ATOMIC_LOAD_UMAX);
4562   case Intrinsic::atomic_swap:
4563     return implVisitBinaryAtomic(I, ISD::ATOMIC_SWAP);
4564
4565   case Intrinsic::invariant_start:
4566   case Intrinsic::lifetime_start:
4567     // Discard region information.
4568     setValue(&I, DAG.getUNDEF(TLI.getPointerTy()));
4569     return 0;
4570   case Intrinsic::invariant_end:
4571   case Intrinsic::lifetime_end:
4572     // Discard region information.
4573     return 0;
4574   }
4575 }
4576
4577 void SelectionDAGBuilder::LowerCallTo(ImmutableCallSite CS, SDValue Callee,
4578                                       bool isTailCall,
4579                                       MachineBasicBlock *LandingPad) {
4580   const PointerType *PT = cast<PointerType>(CS.getCalledValue()->getType());
4581   const FunctionType *FTy = cast<FunctionType>(PT->getElementType());
4582   const Type *RetTy = FTy->getReturnType();
4583   MachineModuleInfo &MMI = DAG.getMachineFunction().getMMI();
4584   MCSymbol *BeginLabel = 0;
4585
4586   TargetLowering::ArgListTy Args;
4587   TargetLowering::ArgListEntry Entry;
4588   Args.reserve(CS.arg_size());
4589
4590   // Check whether the function can return without sret-demotion.
4591   SmallVector<ISD::OutputArg, 4> Outs;
4592   SmallVector<uint64_t, 4> Offsets;
4593   GetReturnInfo(RetTy, CS.getAttributes().getRetAttributes(),
4594                 Outs, TLI, &Offsets);
4595
4596   bool CanLowerReturn = TLI.CanLowerReturn(CS.getCallingConv(),
4597                         FTy->isVarArg(), Outs, FTy->getContext());
4598
4599   SDValue DemoteStackSlot;
4600
4601   if (!CanLowerReturn) {
4602     uint64_t TySize = TLI.getTargetData()->getTypeAllocSize(
4603                       FTy->getReturnType());
4604     unsigned Align  = TLI.getTargetData()->getPrefTypeAlignment(
4605                       FTy->getReturnType());
4606     MachineFunction &MF = DAG.getMachineFunction();
4607     int SSFI = MF.getFrameInfo()->CreateStackObject(TySize, Align, false);
4608     const Type *StackSlotPtrType = PointerType::getUnqual(FTy->getReturnType());
4609
4610     DemoteStackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy());
4611     Entry.Node = DemoteStackSlot;
4612     Entry.Ty = StackSlotPtrType;
4613     Entry.isSExt = false;
4614     Entry.isZExt = false;
4615     Entry.isInReg = false;
4616     Entry.isSRet = true;
4617     Entry.isNest = false;
4618     Entry.isByVal = false;
4619     Entry.Alignment = Align;
4620     Args.push_back(Entry);
4621     RetTy = Type::getVoidTy(FTy->getContext());
4622   }
4623
4624   for (ImmutableCallSite::arg_iterator i = CS.arg_begin(), e = CS.arg_end();
4625        i != e; ++i) {
4626     SDValue ArgNode = getValue(*i);
4627     Entry.Node = ArgNode; Entry.Ty = (*i)->getType();
4628
4629     unsigned attrInd = i - CS.arg_begin() + 1;
4630     Entry.isSExt  = CS.paramHasAttr(attrInd, Attribute::SExt);
4631     Entry.isZExt  = CS.paramHasAttr(attrInd, Attribute::ZExt);
4632     Entry.isInReg = CS.paramHasAttr(attrInd, Attribute::InReg);
4633     Entry.isSRet  = CS.paramHasAttr(attrInd, Attribute::StructRet);
4634     Entry.isNest  = CS.paramHasAttr(attrInd, Attribute::Nest);
4635     Entry.isByVal = CS.paramHasAttr(attrInd, Attribute::ByVal);
4636     Entry.Alignment = CS.getParamAlignment(attrInd);
4637     Args.push_back(Entry);
4638   }
4639
4640   if (LandingPad) {
4641     // Insert a label before the invoke call to mark the try range.  This can be
4642     // used to detect deletion of the invoke via the MachineModuleInfo.
4643     BeginLabel = MMI.getContext().CreateTempSymbol();
4644
4645     // For SjLj, keep track of which landing pads go with which invokes
4646     // so as to maintain the ordering of pads in the LSDA.
4647     unsigned CallSiteIndex = MMI.getCurrentCallSite();
4648     if (CallSiteIndex) {
4649       MMI.setCallSiteBeginLabel(BeginLabel, CallSiteIndex);
4650       // Now that the call site is handled, stop tracking it.
4651       MMI.setCurrentCallSite(0);
4652     }
4653
4654     // Both PendingLoads and PendingExports must be flushed here;
4655     // this call might not return.
4656     (void)getRoot();
4657     DAG.setRoot(DAG.getEHLabel(getCurDebugLoc(), getControlRoot(), BeginLabel));
4658   }
4659
4660   // Check if target-independent constraints permit a tail call here.
4661   // Target-dependent constraints are checked within TLI.LowerCallTo.
4662   if (isTailCall &&
4663       !isInTailCallPosition(CS, CS.getAttributes().getRetAttributes(), TLI))
4664     isTailCall = false;
4665
4666   std::pair<SDValue,SDValue> Result =
4667     TLI.LowerCallTo(getRoot(), RetTy,
4668                     CS.paramHasAttr(0, Attribute::SExt),
4669                     CS.paramHasAttr(0, Attribute::ZExt), FTy->isVarArg(),
4670                     CS.paramHasAttr(0, Attribute::InReg), FTy->getNumParams(),
4671                     CS.getCallingConv(),
4672                     isTailCall,
4673                     !CS.getInstruction()->use_empty(),
4674                     Callee, Args, DAG, getCurDebugLoc());
4675   assert((isTailCall || Result.second.getNode()) &&
4676          "Non-null chain expected with non-tail call!");
4677   assert((Result.second.getNode() || !Result.first.getNode()) &&
4678          "Null value expected with tail call!");
4679   if (Result.first.getNode()) {
4680     setValue(CS.getInstruction(), Result.first);
4681   } else if (!CanLowerReturn && Result.second.getNode()) {
4682     // The instruction result is the result of loading from the
4683     // hidden sret parameter.
4684     SmallVector<EVT, 1> PVTs;
4685     const Type *PtrRetTy = PointerType::getUnqual(FTy->getReturnType());
4686
4687     ComputeValueVTs(TLI, PtrRetTy, PVTs);
4688     assert(PVTs.size() == 1 && "Pointers should fit in one register");
4689     EVT PtrVT = PVTs[0];
4690     unsigned NumValues = Outs.size();
4691     SmallVector<SDValue, 4> Values(NumValues);
4692     SmallVector<SDValue, 4> Chains(NumValues);
4693
4694     for (unsigned i = 0; i < NumValues; ++i) {
4695       SDValue Add = DAG.getNode(ISD::ADD, getCurDebugLoc(), PtrVT,
4696                                 DemoteStackSlot,
4697                                 DAG.getConstant(Offsets[i], PtrVT));
4698       SDValue L = DAG.getLoad(Outs[i].VT, getCurDebugLoc(), Result.second,
4699                               Add, NULL, Offsets[i], false, false, 1);
4700       Values[i] = L;
4701       Chains[i] = L.getValue(1);
4702     }
4703
4704     SDValue Chain = DAG.getNode(ISD::TokenFactor, getCurDebugLoc(),
4705                                 MVT::Other, &Chains[0], NumValues);
4706     PendingLoads.push_back(Chain);
4707
4708     // Collect the legal value parts into potentially illegal values
4709     // that correspond to the original function's return values.
4710     SmallVector<EVT, 4> RetTys;
4711     RetTy = FTy->getReturnType();
4712     ComputeValueVTs(TLI, RetTy, RetTys);
4713     ISD::NodeType AssertOp = ISD::DELETED_NODE;
4714     SmallVector<SDValue, 4> ReturnValues;
4715     unsigned CurReg = 0;
4716     for (unsigned I = 0, E = RetTys.size(); I != E; ++I) {
4717       EVT VT = RetTys[I];
4718       EVT RegisterVT = TLI.getRegisterType(RetTy->getContext(), VT);
4719       unsigned NumRegs = TLI.getNumRegisters(RetTy->getContext(), VT);
4720
4721       SDValue ReturnValue =
4722         getCopyFromParts(DAG, getCurDebugLoc(), &Values[CurReg], NumRegs,
4723                          RegisterVT, VT, AssertOp);
4724       ReturnValues.push_back(ReturnValue);
4725       CurReg += NumRegs;
4726     }
4727
4728     setValue(CS.getInstruction(),
4729              DAG.getNode(ISD::MERGE_VALUES, getCurDebugLoc(),
4730                          DAG.getVTList(&RetTys[0], RetTys.size()),
4731                          &ReturnValues[0], ReturnValues.size()));
4732
4733   }
4734
4735   // As a special case, a null chain means that a tail call has been emitted and
4736   // the DAG root is already updated.
4737   if (Result.second.getNode())
4738     DAG.setRoot(Result.second);
4739   else
4740     HasTailCall = true;
4741
4742   if (LandingPad) {
4743     // Insert a label at the end of the invoke call to mark the try range.  This
4744     // can be used to detect deletion of the invoke via the MachineModuleInfo.
4745     MCSymbol *EndLabel = MMI.getContext().CreateTempSymbol();
4746     DAG.setRoot(DAG.getEHLabel(getCurDebugLoc(), getRoot(), EndLabel));
4747
4748     // Inform MachineModuleInfo of range.
4749     MMI.addInvoke(LandingPad, BeginLabel, EndLabel);
4750   }
4751 }
4752
4753 /// IsOnlyUsedInZeroEqualityComparison - Return true if it only matters that the
4754 /// value is equal or not-equal to zero.
4755 static bool IsOnlyUsedInZeroEqualityComparison(const Value *V) {
4756   for (Value::const_use_iterator UI = V->use_begin(), E = V->use_end();
4757        UI != E; ++UI) {
4758     if (const ICmpInst *IC = dyn_cast<ICmpInst>(*UI))
4759       if (IC->isEquality())
4760         if (const Constant *C = dyn_cast<Constant>(IC->getOperand(1)))
4761           if (C->isNullValue())
4762             continue;
4763     // Unknown instruction.
4764     return false;
4765   }
4766   return true;
4767 }
4768
4769 static SDValue getMemCmpLoad(const Value *PtrVal, MVT LoadVT,
4770                              const Type *LoadTy,
4771                              SelectionDAGBuilder &Builder) {
4772
4773   // Check to see if this load can be trivially constant folded, e.g. if the
4774   // input is from a string literal.
4775   if (const Constant *LoadInput = dyn_cast<Constant>(PtrVal)) {
4776     // Cast pointer to the type we really want to load.
4777     LoadInput = ConstantExpr::getBitCast(const_cast<Constant *>(LoadInput),
4778                                          PointerType::getUnqual(LoadTy));
4779
4780     if (const Constant *LoadCst =
4781           ConstantFoldLoadFromConstPtr(const_cast<Constant *>(LoadInput),
4782                                        Builder.TD))
4783       return Builder.getValue(LoadCst);
4784   }
4785
4786   // Otherwise, we have to emit the load.  If the pointer is to unfoldable but
4787   // still constant memory, the input chain can be the entry node.
4788   SDValue Root;
4789   bool ConstantMemory = false;
4790
4791   // Do not serialize (non-volatile) loads of constant memory with anything.
4792   if (Builder.AA->pointsToConstantMemory(PtrVal)) {
4793     Root = Builder.DAG.getEntryNode();
4794     ConstantMemory = true;
4795   } else {
4796     // Do not serialize non-volatile loads against each other.
4797     Root = Builder.DAG.getRoot();
4798   }
4799
4800   SDValue Ptr = Builder.getValue(PtrVal);
4801   SDValue LoadVal = Builder.DAG.getLoad(LoadVT, Builder.getCurDebugLoc(), Root,
4802                                         Ptr, PtrVal /*SrcValue*/, 0/*SVOffset*/,
4803                                         false /*volatile*/,
4804                                         false /*nontemporal*/, 1 /* align=1 */);
4805
4806   if (!ConstantMemory)
4807     Builder.PendingLoads.push_back(LoadVal.getValue(1));
4808   return LoadVal;
4809 }
4810
4811
4812 /// visitMemCmpCall - See if we can lower a call to memcmp in an optimized form.
4813 /// If so, return true and lower it, otherwise return false and it will be
4814 /// lowered like a normal call.
4815 bool SelectionDAGBuilder::visitMemCmpCall(const CallInst &I) {
4816   // Verify that the prototype makes sense.  int memcmp(void*,void*,size_t)
4817   if (I.getNumArgOperands() != 3)
4818     return false;
4819
4820   const Value *LHS = I.getArgOperand(0), *RHS = I.getArgOperand(1);
4821   if (!LHS->getType()->isPointerTy() || !RHS->getType()->isPointerTy() ||
4822       !I.getArgOperand(2)->getType()->isIntegerTy() ||
4823       !I.getType()->isIntegerTy())
4824     return false;
4825
4826   const ConstantInt *Size = dyn_cast<ConstantInt>(I.getArgOperand(2));
4827
4828   // memcmp(S1,S2,2) != 0 -> (*(short*)LHS != *(short*)RHS)  != 0
4829   // memcmp(S1,S2,4) != 0 -> (*(int*)LHS != *(int*)RHS)  != 0
4830   if (Size && IsOnlyUsedInZeroEqualityComparison(&I)) {
4831     bool ActuallyDoIt = true;
4832     MVT LoadVT;
4833     const Type *LoadTy;
4834     switch (Size->getZExtValue()) {
4835     default:
4836       LoadVT = MVT::Other;
4837       LoadTy = 0;
4838       ActuallyDoIt = false;
4839       break;
4840     case 2:
4841       LoadVT = MVT::i16;
4842       LoadTy = Type::getInt16Ty(Size->getContext());
4843       break;
4844     case 4:
4845       LoadVT = MVT::i32;
4846       LoadTy = Type::getInt32Ty(Size->getContext());
4847       break;
4848     case 8:
4849       LoadVT = MVT::i64;
4850       LoadTy = Type::getInt64Ty(Size->getContext());
4851       break;
4852         /*
4853     case 16:
4854       LoadVT = MVT::v4i32;
4855       LoadTy = Type::getInt32Ty(Size->getContext());
4856       LoadTy = VectorType::get(LoadTy, 4);
4857       break;
4858          */
4859     }
4860
4861     // This turns into unaligned loads.  We only do this if the target natively
4862     // supports the MVT we'll be loading or if it is small enough (<= 4) that
4863     // we'll only produce a small number of byte loads.
4864
4865     // Require that we can find a legal MVT, and only do this if the target
4866     // supports unaligned loads of that type.  Expanding into byte loads would
4867     // bloat the code.
4868     if (ActuallyDoIt && Size->getZExtValue() > 4) {
4869       // TODO: Handle 5 byte compare as 4-byte + 1 byte.
4870       // TODO: Handle 8 byte compare on x86-32 as two 32-bit loads.
4871       if (!TLI.isTypeLegal(LoadVT) ||!TLI.allowsUnalignedMemoryAccesses(LoadVT))
4872         ActuallyDoIt = false;
4873     }
4874
4875     if (ActuallyDoIt) {
4876       SDValue LHSVal = getMemCmpLoad(LHS, LoadVT, LoadTy, *this);
4877       SDValue RHSVal = getMemCmpLoad(RHS, LoadVT, LoadTy, *this);
4878
4879       SDValue Res = DAG.getSetCC(getCurDebugLoc(), MVT::i1, LHSVal, RHSVal,
4880                                  ISD::SETNE);
4881       EVT CallVT = TLI.getValueType(I.getType(), true);
4882       setValue(&I, DAG.getZExtOrTrunc(Res, getCurDebugLoc(), CallVT));
4883       return true;
4884     }
4885   }
4886
4887
4888   return false;
4889 }
4890
4891
4892 void SelectionDAGBuilder::visitCall(const CallInst &I) {
4893   // Handle inline assembly differently.
4894   if (isa<InlineAsm>(I.getCalledValue())) {
4895     visitInlineAsm(&I);
4896     return;
4897   }
4898
4899   const char *RenameFn = 0;
4900   if (Function *F = I.getCalledFunction()) {
4901     if (F->isDeclaration()) {
4902       if (const TargetIntrinsicInfo *II = TM.getIntrinsicInfo()) {
4903         if (unsigned IID = II->getIntrinsicID(F)) {
4904           RenameFn = visitIntrinsicCall(I, IID);
4905           if (!RenameFn)
4906             return;
4907         }
4908       }
4909       if (unsigned IID = F->getIntrinsicID()) {
4910         RenameFn = visitIntrinsicCall(I, IID);
4911         if (!RenameFn)
4912           return;
4913       }
4914     }
4915
4916     // Check for well-known libc/libm calls.  If the function is internal, it
4917     // can't be a library call.
4918     if (!F->hasLocalLinkage() && F->hasName()) {
4919       StringRef Name = F->getName();
4920       if (Name == "copysign" || Name == "copysignf" || Name == "copysignl") {
4921         if (I.getNumArgOperands() == 2 &&   // Basic sanity checks.
4922             I.getArgOperand(0)->getType()->isFloatingPointTy() &&
4923             I.getType() == I.getArgOperand(0)->getType() &&
4924             I.getType() == I.getArgOperand(1)->getType()) {
4925           SDValue LHS = getValue(I.getArgOperand(0));
4926           SDValue RHS = getValue(I.getArgOperand(1));
4927           setValue(&I, DAG.getNode(ISD::FCOPYSIGN, getCurDebugLoc(),
4928                                    LHS.getValueType(), LHS, RHS));
4929           return;
4930         }
4931       } else if (Name == "fabs" || Name == "fabsf" || Name == "fabsl") {
4932         if (I.getNumArgOperands() == 1 &&   // Basic sanity checks.
4933             I.getArgOperand(0)->getType()->isFloatingPointTy() &&
4934             I.getType() == I.getArgOperand(0)->getType()) {
4935           SDValue Tmp = getValue(I.getArgOperand(0));
4936           setValue(&I, DAG.getNode(ISD::FABS, getCurDebugLoc(),
4937                                    Tmp.getValueType(), Tmp));
4938           return;
4939         }
4940       } else if (Name == "sin" || Name == "sinf" || Name == "sinl") {
4941         if (I.getNumArgOperands() == 1 &&   // Basic sanity checks.
4942             I.getArgOperand(0)->getType()->isFloatingPointTy() &&
4943             I.getType() == I.getArgOperand(0)->getType() &&
4944             I.onlyReadsMemory()) {
4945           SDValue Tmp = getValue(I.getArgOperand(0));
4946           setValue(&I, DAG.getNode(ISD::FSIN, getCurDebugLoc(),
4947                                    Tmp.getValueType(), Tmp));
4948           return;
4949         }
4950       } else if (Name == "cos" || Name == "cosf" || Name == "cosl") {
4951         if (I.getNumArgOperands() == 1 &&   // Basic sanity checks.
4952             I.getArgOperand(0)->getType()->isFloatingPointTy() &&
4953             I.getType() == I.getArgOperand(0)->getType() &&
4954             I.onlyReadsMemory()) {
4955           SDValue Tmp = getValue(I.getArgOperand(0));
4956           setValue(&I, DAG.getNode(ISD::FCOS, getCurDebugLoc(),
4957                                    Tmp.getValueType(), Tmp));
4958           return;
4959         }
4960       } else if (Name == "sqrt" || Name == "sqrtf" || Name == "sqrtl") {
4961         if (I.getNumArgOperands() == 1 &&   // Basic sanity checks.
4962             I.getArgOperand(0)->getType()->isFloatingPointTy() &&
4963             I.getType() == I.getArgOperand(0)->getType() &&
4964             I.onlyReadsMemory()) {
4965           SDValue Tmp = getValue(I.getArgOperand(0));
4966           setValue(&I, DAG.getNode(ISD::FSQRT, getCurDebugLoc(),
4967                                    Tmp.getValueType(), Tmp));
4968           return;
4969         }
4970       } else if (Name == "memcmp") {
4971         if (visitMemCmpCall(I))
4972           return;
4973       }
4974     }
4975   }
4976
4977   SDValue Callee;
4978   if (!RenameFn)
4979     Callee = getValue(I.getCalledValue());
4980   else
4981     Callee = DAG.getExternalSymbol(RenameFn, TLI.getPointerTy());
4982
4983   // Check if we can potentially perform a tail call. More detailed checking is
4984   // be done within LowerCallTo, after more information about the call is known.
4985   LowerCallTo(&I, Callee, I.isTailCall());
4986 }
4987
4988 namespace llvm {
4989
4990 /// AsmOperandInfo - This contains information for each constraint that we are
4991 /// lowering.
4992 class LLVM_LIBRARY_VISIBILITY SDISelAsmOperandInfo :
4993     public TargetLowering::AsmOperandInfo {
4994 public:
4995   /// CallOperand - If this is the result output operand or a clobber
4996   /// this is null, otherwise it is the incoming operand to the CallInst.
4997   /// This gets modified as the asm is processed.
4998   SDValue CallOperand;
4999
5000   /// AssignedRegs - If this is a register or register class operand, this
5001   /// contains the set of register corresponding to the operand.
5002   RegsForValue AssignedRegs;
5003
5004   explicit SDISelAsmOperandInfo(const InlineAsm::ConstraintInfo &info)
5005     : TargetLowering::AsmOperandInfo(info), CallOperand(0,0) {
5006   }
5007
5008   /// MarkAllocatedRegs - Once AssignedRegs is set, mark the assigned registers
5009   /// busy in OutputRegs/InputRegs.
5010   void MarkAllocatedRegs(bool isOutReg, bool isInReg,
5011                          std::set<unsigned> &OutputRegs,
5012                          std::set<unsigned> &InputRegs,
5013                          const TargetRegisterInfo &TRI) const {
5014     if (isOutReg) {
5015       for (unsigned i = 0, e = AssignedRegs.Regs.size(); i != e; ++i)
5016         MarkRegAndAliases(AssignedRegs.Regs[i], OutputRegs, TRI);
5017     }
5018     if (isInReg) {
5019       for (unsigned i = 0, e = AssignedRegs.Regs.size(); i != e; ++i)
5020         MarkRegAndAliases(AssignedRegs.Regs[i], InputRegs, TRI);
5021     }
5022   }
5023
5024   /// getCallOperandValEVT - Return the EVT of the Value* that this operand
5025   /// corresponds to.  If there is no Value* for this operand, it returns
5026   /// MVT::Other.
5027   EVT getCallOperandValEVT(LLVMContext &Context,
5028                            const TargetLowering &TLI,
5029                            const TargetData *TD) const {
5030     if (CallOperandVal == 0) return MVT::Other;
5031
5032     if (isa<BasicBlock>(CallOperandVal))
5033       return TLI.getPointerTy();
5034
5035     const llvm::Type *OpTy = CallOperandVal->getType();
5036
5037     // If this is an indirect operand, the operand is a pointer to the
5038     // accessed type.
5039     if (isIndirect) {
5040       const llvm::PointerType *PtrTy = dyn_cast<PointerType>(OpTy);
5041       if (!PtrTy)
5042         report_fatal_error("Indirect operand for inline asm not a pointer!");
5043       OpTy = PtrTy->getElementType();
5044     }
5045
5046     // If OpTy is not a single value, it may be a struct/union that we
5047     // can tile with integers.
5048     if (!OpTy->isSingleValueType() && OpTy->isSized()) {
5049       unsigned BitSize = TD->getTypeSizeInBits(OpTy);
5050       switch (BitSize) {
5051       default: break;
5052       case 1:
5053       case 8:
5054       case 16:
5055       case 32:
5056       case 64:
5057       case 128:
5058         OpTy = IntegerType::get(Context, BitSize);
5059         break;
5060       }
5061     }
5062
5063     return TLI.getValueType(OpTy, true);
5064   }
5065
5066 private:
5067   /// MarkRegAndAliases - Mark the specified register and all aliases in the
5068   /// specified set.
5069   static void MarkRegAndAliases(unsigned Reg, std::set<unsigned> &Regs,
5070                                 const TargetRegisterInfo &TRI) {
5071     assert(TargetRegisterInfo::isPhysicalRegister(Reg) && "Isn't a physreg");
5072     Regs.insert(Reg);
5073     if (const unsigned *Aliases = TRI.getAliasSet(Reg))
5074       for (; *Aliases; ++Aliases)
5075         Regs.insert(*Aliases);
5076   }
5077 };
5078
5079 } // end llvm namespace.
5080
5081 /// isAllocatableRegister - If the specified register is safe to allocate,
5082 /// i.e. it isn't a stack pointer or some other special register, return the
5083 /// register class for the register.  Otherwise, return null.
5084 static const TargetRegisterClass *
5085 isAllocatableRegister(unsigned Reg, MachineFunction &MF,
5086                       const TargetLowering &TLI,
5087                       const TargetRegisterInfo *TRI) {
5088   EVT FoundVT = MVT::Other;
5089   const TargetRegisterClass *FoundRC = 0;
5090   for (TargetRegisterInfo::regclass_iterator RCI = TRI->regclass_begin(),
5091        E = TRI->regclass_end(); RCI != E; ++RCI) {
5092     EVT ThisVT = MVT::Other;
5093
5094     const TargetRegisterClass *RC = *RCI;
5095     // If none of the value types for this register class are valid, we
5096     // can't use it.  For example, 64-bit reg classes on 32-bit targets.
5097     for (TargetRegisterClass::vt_iterator I = RC->vt_begin(), E = RC->vt_end();
5098          I != E; ++I) {
5099       if (TLI.isTypeLegal(*I)) {
5100         // If we have already found this register in a different register class,
5101         // choose the one with the largest VT specified.  For example, on
5102         // PowerPC, we favor f64 register classes over f32.
5103         if (FoundVT == MVT::Other || FoundVT.bitsLT(*I)) {
5104           ThisVT = *I;
5105           break;
5106         }
5107       }
5108     }
5109
5110     if (ThisVT == MVT::Other) continue;
5111
5112     // NOTE: This isn't ideal.  In particular, this might allocate the
5113     // frame pointer in functions that need it (due to them not being taken
5114     // out of allocation, because a variable sized allocation hasn't been seen
5115     // yet).  This is a slight code pessimization, but should still work.
5116     for (TargetRegisterClass::iterator I = RC->allocation_order_begin(MF),
5117          E = RC->allocation_order_end(MF); I != E; ++I)
5118       if (*I == Reg) {
5119         // We found a matching register class.  Keep looking at others in case
5120         // we find one with larger registers that this physreg is also in.
5121         FoundRC = RC;
5122         FoundVT = ThisVT;
5123         break;
5124       }
5125   }
5126   return FoundRC;
5127 }
5128
5129 /// GetRegistersForValue - Assign registers (virtual or physical) for the
5130 /// specified operand.  We prefer to assign virtual registers, to allow the
5131 /// register allocator to handle the assignment process.  However, if the asm
5132 /// uses features that we can't model on machineinstrs, we have SDISel do the
5133 /// allocation.  This produces generally horrible, but correct, code.
5134 ///
5135 ///   OpInfo describes the operand.
5136 ///   Input and OutputRegs are the set of already allocated physical registers.
5137 ///
5138 void SelectionDAGBuilder::
5139 GetRegistersForValue(SDISelAsmOperandInfo &OpInfo,
5140                      std::set<unsigned> &OutputRegs,
5141                      std::set<unsigned> &InputRegs) {
5142   LLVMContext &Context = FuncInfo.Fn->getContext();
5143
5144   // Compute whether this value requires an input register, an output register,
5145   // or both.
5146   bool isOutReg = false;
5147   bool isInReg = false;
5148   switch (OpInfo.Type) {
5149   case InlineAsm::isOutput:
5150     isOutReg = true;
5151
5152     // If there is an input constraint that matches this, we need to reserve
5153     // the input register so no other inputs allocate to it.
5154     isInReg = OpInfo.hasMatchingInput();
5155     break;
5156   case InlineAsm::isInput:
5157     isInReg = true;
5158     isOutReg = false;
5159     break;
5160   case InlineAsm::isClobber:
5161     isOutReg = true;
5162     isInReg = true;
5163     break;
5164   }
5165
5166
5167   MachineFunction &MF = DAG.getMachineFunction();
5168   SmallVector<unsigned, 4> Regs;
5169
5170   // If this is a constraint for a single physreg, or a constraint for a
5171   // register class, find it.
5172   std::pair<unsigned, const TargetRegisterClass*> PhysReg =
5173     TLI.getRegForInlineAsmConstraint(OpInfo.ConstraintCode,
5174                                      OpInfo.ConstraintVT);
5175
5176   unsigned NumRegs = 1;
5177   if (OpInfo.ConstraintVT != MVT::Other) {
5178     // If this is a FP input in an integer register (or visa versa) insert a bit
5179     // cast of the input value.  More generally, handle any case where the input
5180     // value disagrees with the register class we plan to stick this in.
5181     if (OpInfo.Type == InlineAsm::isInput &&
5182         PhysReg.second && !PhysReg.second->hasType(OpInfo.ConstraintVT)) {
5183       // Try to convert to the first EVT that the reg class contains.  If the
5184       // types are identical size, use a bitcast to convert (e.g. two differing
5185       // vector types).
5186       EVT RegVT = *PhysReg.second->vt_begin();
5187       if (RegVT.getSizeInBits() == OpInfo.ConstraintVT.getSizeInBits()) {
5188         OpInfo.CallOperand = DAG.getNode(ISD::BIT_CONVERT, getCurDebugLoc(),
5189                                          RegVT, OpInfo.CallOperand);
5190         OpInfo.ConstraintVT = RegVT;
5191       } else if (RegVT.isInteger() && OpInfo.ConstraintVT.isFloatingPoint()) {
5192         // If the input is a FP value and we want it in FP registers, do a
5193         // bitcast to the corresponding integer type.  This turns an f64 value
5194         // into i64, which can be passed with two i32 values on a 32-bit
5195         // machine.
5196         RegVT = EVT::getIntegerVT(Context,
5197                                   OpInfo.ConstraintVT.getSizeInBits());
5198         OpInfo.CallOperand = DAG.getNode(ISD::BIT_CONVERT, getCurDebugLoc(),
5199                                          RegVT, OpInfo.CallOperand);
5200         OpInfo.ConstraintVT = RegVT;
5201       }
5202     }
5203
5204     NumRegs = TLI.getNumRegisters(Context, OpInfo.ConstraintVT);
5205   }
5206
5207   EVT RegVT;
5208   EVT ValueVT = OpInfo.ConstraintVT;
5209
5210   // If this is a constraint for a specific physical register, like {r17},
5211   // assign it now.
5212   if (unsigned AssignedReg = PhysReg.first) {
5213     const TargetRegisterClass *RC = PhysReg.second;
5214     if (OpInfo.ConstraintVT == MVT::Other)
5215       ValueVT = *RC->vt_begin();
5216
5217     // Get the actual register value type.  This is important, because the user
5218     // may have asked for (e.g.) the AX register in i32 type.  We need to
5219     // remember that AX is actually i16 to get the right extension.
5220     RegVT = *RC->vt_begin();
5221
5222     // This is a explicit reference to a physical register.
5223     Regs.push_back(AssignedReg);
5224
5225     // If this is an expanded reference, add the rest of the regs to Regs.
5226     if (NumRegs != 1) {
5227       TargetRegisterClass::iterator I = RC->begin();
5228       for (; *I != AssignedReg; ++I)
5229         assert(I != RC->end() && "Didn't find reg!");
5230
5231       // Already added the first reg.
5232       --NumRegs; ++I;
5233       for (; NumRegs; --NumRegs, ++I) {
5234         assert(I != RC->end() && "Ran out of registers to allocate!");
5235         Regs.push_back(*I);
5236       }
5237     }
5238
5239     OpInfo.AssignedRegs = RegsForValue(Regs, RegVT, ValueVT);
5240     const TargetRegisterInfo *TRI = DAG.getTarget().getRegisterInfo();
5241     OpInfo.MarkAllocatedRegs(isOutReg, isInReg, OutputRegs, InputRegs, *TRI);
5242     return;
5243   }
5244
5245   // Otherwise, if this was a reference to an LLVM register class, create vregs
5246   // for this reference.
5247   if (const TargetRegisterClass *RC = PhysReg.second) {
5248     RegVT = *RC->vt_begin();
5249     if (OpInfo.ConstraintVT == MVT::Other)
5250       ValueVT = RegVT;
5251
5252     // Create the appropriate number of virtual registers.
5253     MachineRegisterInfo &RegInfo = MF.getRegInfo();
5254     for (; NumRegs; --NumRegs)
5255       Regs.push_back(RegInfo.createVirtualRegister(RC));
5256
5257     OpInfo.AssignedRegs = RegsForValue(Regs, RegVT, ValueVT);
5258     return;
5259   }
5260
5261   // This is a reference to a register class that doesn't directly correspond
5262   // to an LLVM register class.  Allocate NumRegs consecutive, available,
5263   // registers from the class.
5264   std::vector<unsigned> RegClassRegs
5265     = TLI.getRegClassForInlineAsmConstraint(OpInfo.ConstraintCode,
5266                                             OpInfo.ConstraintVT);
5267
5268   const TargetRegisterInfo *TRI = DAG.getTarget().getRegisterInfo();
5269   unsigned NumAllocated = 0;
5270   for (unsigned i = 0, e = RegClassRegs.size(); i != e; ++i) {
5271     unsigned Reg = RegClassRegs[i];
5272     // See if this register is available.
5273     if ((isOutReg && OutputRegs.count(Reg)) ||   // Already used.
5274         (isInReg  && InputRegs.count(Reg))) {    // Already used.
5275       // Make sure we find consecutive registers.
5276       NumAllocated = 0;
5277       continue;
5278     }
5279
5280     // Check to see if this register is allocatable (i.e. don't give out the
5281     // stack pointer).
5282     const TargetRegisterClass *RC = isAllocatableRegister(Reg, MF, TLI, TRI);
5283     if (!RC) {        // Couldn't allocate this register.
5284       // Reset NumAllocated to make sure we return consecutive registers.
5285       NumAllocated = 0;
5286       continue;
5287     }
5288
5289     // Okay, this register is good, we can use it.
5290     ++NumAllocated;
5291
5292     // If we allocated enough consecutive registers, succeed.
5293     if (NumAllocated == NumRegs) {
5294       unsigned RegStart = (i-NumAllocated)+1;
5295       unsigned RegEnd   = i+1;
5296       // Mark all of the allocated registers used.
5297       for (unsigned i = RegStart; i != RegEnd; ++i)
5298         Regs.push_back(RegClassRegs[i]);
5299
5300       OpInfo.AssignedRegs = RegsForValue(Regs, *RC->vt_begin(),
5301                                          OpInfo.ConstraintVT);
5302       OpInfo.MarkAllocatedRegs(isOutReg, isInReg, OutputRegs, InputRegs, *TRI);
5303       return;
5304     }
5305   }
5306
5307   // Otherwise, we couldn't allocate enough registers for this.
5308 }
5309
5310 /// visitInlineAsm - Handle a call to an InlineAsm object.
5311 ///
5312 void SelectionDAGBuilder::visitInlineAsm(ImmutableCallSite CS) {
5313   const InlineAsm *IA = cast<InlineAsm>(CS.getCalledValue());
5314
5315   /// ConstraintOperands - Information about all of the constraints.
5316   std::vector<SDISelAsmOperandInfo> ConstraintOperands;
5317
5318   std::set<unsigned> OutputRegs, InputRegs;
5319
5320   // Do a prepass over the constraints, canonicalizing them, and building up the
5321   // ConstraintOperands list.
5322   std::vector<InlineAsm::ConstraintInfo>
5323     ConstraintInfos = IA->ParseConstraints();
5324
5325   bool hasMemory = hasInlineAsmMemConstraint(ConstraintInfos, TLI);
5326
5327   SDValue Chain, Flag;
5328
5329   // We won't need to flush pending loads if this asm doesn't touch
5330   // memory and is nonvolatile.
5331   if (hasMemory || IA->hasSideEffects())
5332     Chain = getRoot();
5333   else
5334     Chain = DAG.getRoot();
5335
5336   unsigned ArgNo = 0;   // ArgNo - The argument of the CallInst.
5337   unsigned ResNo = 0;   // ResNo - The result number of the next output.
5338   for (unsigned i = 0, e = ConstraintInfos.size(); i != e; ++i) {
5339     ConstraintOperands.push_back(SDISelAsmOperandInfo(ConstraintInfos[i]));
5340     SDISelAsmOperandInfo &OpInfo = ConstraintOperands.back();
5341
5342     EVT OpVT = MVT::Other;
5343
5344     // Compute the value type for each operand.
5345     switch (OpInfo.Type) {
5346     case InlineAsm::isOutput:
5347       // Indirect outputs just consume an argument.
5348       if (OpInfo.isIndirect) {
5349         OpInfo.CallOperandVal = const_cast<Value *>(CS.getArgument(ArgNo++));
5350         break;
5351       }
5352
5353       // The return value of the call is this value.  As such, there is no
5354       // corresponding argument.
5355       assert(!CS.getType()->isVoidTy() &&
5356              "Bad inline asm!");
5357       if (const StructType *STy = dyn_cast<StructType>(CS.getType())) {
5358         OpVT = TLI.getValueType(STy->getElementType(ResNo));
5359       } else {
5360         assert(ResNo == 0 && "Asm only has one result!");
5361         OpVT = TLI.getValueType(CS.getType());
5362       }
5363       ++ResNo;
5364       break;
5365     case InlineAsm::isInput:
5366       OpInfo.CallOperandVal = const_cast<Value *>(CS.getArgument(ArgNo++));
5367       break;
5368     case InlineAsm::isClobber:
5369       // Nothing to do.
5370       break;
5371     }
5372
5373     // If this is an input or an indirect output, process the call argument.
5374     // BasicBlocks are labels, currently appearing only in asm's.
5375     if (OpInfo.CallOperandVal) {
5376       // Strip bitcasts, if any.  This mostly comes up for functions.
5377       OpInfo.CallOperandVal = OpInfo.CallOperandVal->stripPointerCasts();
5378
5379       if (const BasicBlock *BB = dyn_cast<BasicBlock>(OpInfo.CallOperandVal)) {
5380         OpInfo.CallOperand = DAG.getBasicBlock(FuncInfo.MBBMap[BB]);
5381       } else {
5382         OpInfo.CallOperand = getValue(OpInfo.CallOperandVal);
5383       }
5384
5385       OpVT = OpInfo.getCallOperandValEVT(*DAG.getContext(), TLI, TD);
5386     }
5387
5388     OpInfo.ConstraintVT = OpVT;
5389   }
5390
5391   // Second pass over the constraints: compute which constraint option to use
5392   // and assign registers to constraints that want a specific physreg.
5393   for (unsigned i = 0, e = ConstraintInfos.size(); i != e; ++i) {
5394     SDISelAsmOperandInfo &OpInfo = ConstraintOperands[i];
5395
5396     // If this is an output operand with a matching input operand, look up the
5397     // matching input. If their types mismatch, e.g. one is an integer, the
5398     // other is floating point, or their sizes are different, flag it as an
5399     // error.
5400     if (OpInfo.hasMatchingInput()) {
5401       SDISelAsmOperandInfo &Input = ConstraintOperands[OpInfo.MatchingInput];
5402
5403       if (OpInfo.ConstraintVT != Input.ConstraintVT) {
5404         if ((OpInfo.ConstraintVT.isInteger() !=
5405              Input.ConstraintVT.isInteger()) ||
5406             (OpInfo.ConstraintVT.getSizeInBits() !=
5407              Input.ConstraintVT.getSizeInBits())) {
5408           report_fatal_error("Unsupported asm: input constraint"
5409                              " with a matching output constraint of"
5410                              " incompatible type!");
5411         }
5412         Input.ConstraintVT = OpInfo.ConstraintVT;
5413       }
5414     }
5415
5416     // Compute the constraint code and ConstraintType to use.
5417     TLI.ComputeConstraintToUse(OpInfo, OpInfo.CallOperand, &DAG);
5418
5419     // If this is a memory input, and if the operand is not indirect, do what we
5420     // need to to provide an address for the memory input.
5421     if (OpInfo.ConstraintType == TargetLowering::C_Memory &&
5422         !OpInfo.isIndirect) {
5423       assert(OpInfo.Type == InlineAsm::isInput &&
5424              "Can only indirectify direct input operands!");
5425
5426       // Memory operands really want the address of the value.  If we don't have
5427       // an indirect input, put it in the constpool if we can, otherwise spill
5428       // it to a stack slot.
5429
5430       // If the operand is a float, integer, or vector constant, spill to a
5431       // constant pool entry to get its address.
5432       const Value *OpVal = OpInfo.CallOperandVal;
5433       if (isa<ConstantFP>(OpVal) || isa<ConstantInt>(OpVal) ||
5434           isa<ConstantVector>(OpVal)) {
5435         OpInfo.CallOperand = DAG.getConstantPool(cast<Constant>(OpVal),
5436                                                  TLI.getPointerTy());
5437       } else {
5438         // Otherwise, create a stack slot and emit a store to it before the
5439         // asm.
5440         const Type *Ty = OpVal->getType();
5441         uint64_t TySize = TLI.getTargetData()->getTypeAllocSize(Ty);
5442         unsigned Align  = TLI.getTargetData()->getPrefTypeAlignment(Ty);
5443         MachineFunction &MF = DAG.getMachineFunction();
5444         int SSFI = MF.getFrameInfo()->CreateStackObject(TySize, Align, false);
5445         SDValue StackSlot = DAG.getFrameIndex(SSFI, TLI.getPointerTy());
5446         Chain = DAG.getStore(Chain, getCurDebugLoc(),
5447                              OpInfo.CallOperand, StackSlot, NULL, 0,
5448                              false, false, 0);
5449         OpInfo.CallOperand = StackSlot;
5450       }
5451
5452       // There is no longer a Value* corresponding to this operand.
5453       OpInfo.CallOperandVal = 0;
5454
5455       // It is now an indirect operand.
5456       OpInfo.isIndirect = true;
5457     }
5458
5459     // If this constraint is for a specific register, allocate it before
5460     // anything else.
5461     if (OpInfo.ConstraintType == TargetLowering::C_Register)
5462       GetRegistersForValue(OpInfo, OutputRegs, InputRegs);
5463   }
5464
5465   ConstraintInfos.clear();
5466
5467   // Second pass - Loop over all of the operands, assigning virtual or physregs
5468   // to register class operands.
5469   for (unsigned i = 0, e = ConstraintOperands.size(); i != e; ++i) {
5470     SDISelAsmOperandInfo &OpInfo = ConstraintOperands[i];
5471
5472     // C_Register operands have already been allocated, Other/Memory don't need
5473     // to be.
5474     if (OpInfo.ConstraintType == TargetLowering::C_RegisterClass)
5475       GetRegistersForValue(OpInfo, OutputRegs, InputRegs);
5476   }
5477
5478   // AsmNodeOperands - The operands for the ISD::INLINEASM node.
5479   std::vector<SDValue> AsmNodeOperands;
5480   AsmNodeOperands.push_back(SDValue());  // reserve space for input chain
5481   AsmNodeOperands.push_back(
5482           DAG.getTargetExternalSymbol(IA->getAsmString().c_str(),
5483                                       TLI.getPointerTy()));
5484
5485   // If we have a !srcloc metadata node associated with it, we want to attach
5486   // this to the ultimately generated inline asm machineinstr.  To do this, we
5487   // pass in the third operand as this (potentially null) inline asm MDNode.
5488   const MDNode *SrcLoc = CS.getInstruction()->getMetadata("srcloc");
5489   AsmNodeOperands.push_back(DAG.getMDNode(SrcLoc));
5490
5491   // Remember the AlignStack bit as operand 3.
5492   AsmNodeOperands.push_back(DAG.getTargetConstant(IA->isAlignStack() ? 1 : 0,
5493                                             MVT::i1));
5494
5495   // Loop over all of the inputs, copying the operand values into the
5496   // appropriate registers and processing the output regs.
5497   RegsForValue RetValRegs;
5498
5499   // IndirectStoresToEmit - The set of stores to emit after the inline asm node.
5500   std::vector<std::pair<RegsForValue, Value*> > IndirectStoresToEmit;
5501
5502   for (unsigned i = 0, e = ConstraintOperands.size(); i != e; ++i) {
5503     SDISelAsmOperandInfo &OpInfo = ConstraintOperands[i];
5504
5505     switch (OpInfo.Type) {
5506     case InlineAsm::isOutput: {
5507       if (OpInfo.ConstraintType != TargetLowering::C_RegisterClass &&
5508           OpInfo.ConstraintType != TargetLowering::C_Register) {
5509         // Memory output, or 'other' output (e.g. 'X' constraint).
5510         assert(OpInfo.isIndirect && "Memory output must be indirect operand");
5511
5512         // Add information to the INLINEASM node to know about this output.
5513         unsigned OpFlags = InlineAsm::getFlagWord(InlineAsm::Kind_Mem, 1);
5514         AsmNodeOperands.push_back(DAG.getTargetConstant(OpFlags,
5515                                                         TLI.getPointerTy()));
5516         AsmNodeOperands.push_back(OpInfo.CallOperand);
5517         break;
5518       }
5519
5520       // Otherwise, this is a register or register class output.
5521
5522       // Copy the output from the appropriate register.  Find a register that
5523       // we can use.
5524       if (OpInfo.AssignedRegs.Regs.empty())
5525         report_fatal_error("Couldn't allocate output reg for constraint '" +
5526                            Twine(OpInfo.ConstraintCode) + "'!");
5527
5528       // If this is an indirect operand, store through the pointer after the
5529       // asm.
5530       if (OpInfo.isIndirect) {
5531         IndirectStoresToEmit.push_back(std::make_pair(OpInfo.AssignedRegs,
5532                                                       OpInfo.CallOperandVal));
5533       } else {
5534         // This is the result value of the call.
5535         assert(!CS.getType()->isVoidTy() && "Bad inline asm!");
5536         // Concatenate this output onto the outputs list.
5537         RetValRegs.append(OpInfo.AssignedRegs);
5538       }
5539
5540       // Add information to the INLINEASM node to know that this register is
5541       // set.
5542       OpInfo.AssignedRegs.AddInlineAsmOperands(OpInfo.isEarlyClobber ?
5543                                            InlineAsm::Kind_RegDefEarlyClobber :
5544                                                InlineAsm::Kind_RegDef,
5545                                                false,
5546                                                0,
5547                                                DAG,
5548                                                AsmNodeOperands);
5549       break;
5550     }
5551     case InlineAsm::isInput: {
5552       SDValue InOperandVal = OpInfo.CallOperand;
5553
5554       if (OpInfo.isMatchingInputConstraint()) {   // Matching constraint?
5555         // If this is required to match an output register we have already set,
5556         // just use its register.
5557         unsigned OperandNo = OpInfo.getMatchedOperand();
5558
5559         // Scan until we find the definition we already emitted of this operand.
5560         // When we find it, create a RegsForValue operand.
5561         unsigned CurOp = InlineAsm::Op_FirstOperand;
5562         for (; OperandNo; --OperandNo) {
5563           // Advance to the next operand.
5564           unsigned OpFlag =
5565             cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getZExtValue();
5566           assert((InlineAsm::isRegDefKind(OpFlag) ||
5567                   InlineAsm::isRegDefEarlyClobberKind(OpFlag) ||
5568                   InlineAsm::isMemKind(OpFlag)) && "Skipped past definitions?");
5569           CurOp += InlineAsm::getNumOperandRegisters(OpFlag)+1;
5570         }
5571
5572         unsigned OpFlag =
5573           cast<ConstantSDNode>(AsmNodeOperands[CurOp])->getZExtValue();
5574         if (InlineAsm::isRegDefKind(OpFlag) ||
5575             InlineAsm::isRegDefEarlyClobberKind(OpFlag)) {
5576           // Add (OpFlag&0xffff)>>3 registers to MatchedRegs.
5577           if (OpInfo.isIndirect) {
5578             // This happens on gcc/testsuite/gcc.dg/pr8788-1.c
5579             LLVMContext &Ctx = *DAG.getContext();
5580             Ctx.emitError(CS.getInstruction(),  "inline asm not supported yet:"
5581                           " don't know how to handle tied "
5582                           "indirect register inputs");
5583           }
5584
5585           RegsForValue MatchedRegs;
5586           MatchedRegs.ValueVTs.push_back(InOperandVal.getValueType());
5587           EVT RegVT = AsmNodeOperands[CurOp+1].getValueType();
5588           MatchedRegs.RegVTs.push_back(RegVT);
5589           MachineRegisterInfo &RegInfo = DAG.getMachineFunction().getRegInfo();
5590           for (unsigned i = 0, e = InlineAsm::getNumOperandRegisters(OpFlag);
5591                i != e; ++i)
5592             MatchedRegs.Regs.push_back
5593               (RegInfo.createVirtualRegister(TLI.getRegClassFor(RegVT)));
5594
5595           // Use the produced MatchedRegs object to
5596           MatchedRegs.getCopyToRegs(InOperandVal, DAG, getCurDebugLoc(),
5597                                     Chain, &Flag);
5598           MatchedRegs.AddInlineAsmOperands(InlineAsm::Kind_RegUse,
5599                                            true, OpInfo.getMatchedOperand(),
5600                                            DAG, AsmNodeOperands);
5601           break;
5602         }
5603
5604         assert(InlineAsm::isMemKind(OpFlag) && "Unknown matching constraint!");
5605         assert(InlineAsm::getNumOperandRegisters(OpFlag) == 1 &&
5606                "Unexpected number of operands");
5607         // Add information to the INLINEASM node to know about this input.
5608         // See InlineAsm.h isUseOperandTiedToDef.
5609         OpFlag = InlineAsm::getFlagWordForMatchingOp(OpFlag,
5610                                                     OpInfo.getMatchedOperand());
5611         AsmNodeOperands.push_back(DAG.getTargetConstant(OpFlag,
5612                                                         TLI.getPointerTy()));
5613         AsmNodeOperands.push_back(AsmNodeOperands[CurOp+1]);
5614         break;
5615       }
5616
5617       // Treat indirect 'X' constraint as memory.
5618       if (OpInfo.ConstraintType == TargetLowering::C_Other &&
5619           OpInfo.isIndirect)
5620         OpInfo.ConstraintType = TargetLowering::C_Memory;
5621
5622       if (OpInfo.ConstraintType == TargetLowering::C_Other) {
5623         std::vector<SDValue> Ops;
5624         TLI.LowerAsmOperandForConstraint(InOperandVal, OpInfo.ConstraintCode[0],
5625                                          Ops, DAG);
5626         if (Ops.empty())
5627           report_fatal_error("Invalid operand for inline asm constraint '" +
5628                              Twine(OpInfo.ConstraintCode) + "'!");
5629
5630         // Add information to the INLINEASM node to know about this input.
5631         unsigned ResOpType =
5632           InlineAsm::getFlagWord(InlineAsm::Kind_Imm, Ops.size());
5633         AsmNodeOperands.push_back(DAG.getTargetConstant(ResOpType,
5634                                                         TLI.getPointerTy()));
5635         AsmNodeOperands.insert(AsmNodeOperands.end(), Ops.begin(), Ops.end());
5636         break;
5637       }
5638
5639       if (OpInfo.ConstraintType == TargetLowering::C_Memory) {
5640         assert(OpInfo.isIndirect && "Operand must be indirect to be a mem!");
5641         assert(InOperandVal.getValueType() == TLI.getPointerTy() &&
5642                "Memory operands expect pointer values");
5643
5644         // Add information to the INLINEASM node to know about this input.
5645         unsigned ResOpType = InlineAsm::getFlagWord(InlineAsm::Kind_Mem, 1);
5646         AsmNodeOperands.push_back(DAG.getTargetConstant(ResOpType,
5647                                                         TLI.getPointerTy()));
5648         AsmNodeOperands.push_back(InOperandVal);
5649         break;
5650       }
5651
5652       assert((OpInfo.ConstraintType == TargetLowering::C_RegisterClass ||
5653               OpInfo.ConstraintType == TargetLowering::C_Register) &&
5654              "Unknown constraint type!");
5655       assert(!OpInfo.isIndirect &&
5656              "Don't know how to handle indirect register inputs yet!");
5657
5658       // Copy the input into the appropriate registers.
5659       if (OpInfo.AssignedRegs.Regs.empty() ||
5660           !OpInfo.AssignedRegs.areValueTypesLegal(TLI))
5661         report_fatal_error("Couldn't allocate input reg for constraint '" +
5662                            Twine(OpInfo.ConstraintCode) + "'!");
5663
5664       OpInfo.AssignedRegs.getCopyToRegs(InOperandVal, DAG, getCurDebugLoc(),
5665                                         Chain, &Flag);
5666
5667       OpInfo.AssignedRegs.AddInlineAsmOperands(InlineAsm::Kind_RegUse, false, 0,
5668                                                DAG, AsmNodeOperands);
5669       break;
5670     }
5671     case InlineAsm::isClobber: {
5672       // Add the clobbered value to the operand list, so that the register
5673       // allocator is aware that the physreg got clobbered.
5674       if (!OpInfo.AssignedRegs.Regs.empty())
5675         OpInfo.AssignedRegs.AddInlineAsmOperands(
5676                                             InlineAsm::Kind_RegDefEarlyClobber,
5677                                                  false, 0, DAG,
5678                                                  AsmNodeOperands);
5679       break;
5680     }
5681     }
5682   }
5683
5684   // Finish up input operands.  Set the input chain and add the flag last.
5685   AsmNodeOperands[InlineAsm::Op_InputChain] = Chain;
5686   if (Flag.getNode()) AsmNodeOperands.push_back(Flag);
5687
5688   Chain = DAG.getNode(ISD::INLINEASM, getCurDebugLoc(),
5689                       DAG.getVTList(MVT::Other, MVT::Flag),
5690                       &AsmNodeOperands[0], AsmNodeOperands.size());
5691   Flag = Chain.getValue(1);
5692
5693   // If this asm returns a register value, copy the result from that register
5694   // and set it as the value of the call.
5695   if (!RetValRegs.Regs.empty()) {
5696     SDValue Val = RetValRegs.getCopyFromRegs(DAG, FuncInfo, getCurDebugLoc(),
5697                                              Chain, &Flag);
5698
5699     // FIXME: Why don't we do this for inline asms with MRVs?
5700     if (CS.getType()->isSingleValueType() && CS.getType()->isSized()) {
5701       EVT ResultType = TLI.getValueType(CS.getType());
5702
5703       // If any of the results of the inline asm is a vector, it may have the
5704       // wrong width/num elts.  This can happen for register classes that can
5705       // contain multiple different value types.  The preg or vreg allocated may
5706       // not have the same VT as was expected.  Convert it to the right type
5707       // with bit_convert.
5708       if (ResultType != Val.getValueType() && Val.getValueType().isVector()) {
5709         Val = DAG.getNode(ISD::BIT_CONVERT, getCurDebugLoc(),
5710                           ResultType, Val);
5711
5712       } else if (ResultType != Val.getValueType() &&
5713                  ResultType.isInteger() && Val.getValueType().isInteger()) {
5714         // If a result value was tied to an input value, the computed result may
5715         // have a wider width than the expected result.  Extract the relevant
5716         // portion.
5717         Val = DAG.getNode(ISD::TRUNCATE, getCurDebugLoc(), ResultType, Val);
5718       }
5719
5720       assert(ResultType == Val.getValueType() && "Asm result value mismatch!");
5721     }
5722
5723     setValue(CS.getInstruction(), Val);
5724     // Don't need to use this as a chain in this case.
5725     if (!IA->hasSideEffects() && !hasMemory && IndirectStoresToEmit.empty())
5726       return;
5727   }
5728
5729   std::vector<std::pair<SDValue, const Value *> > StoresToEmit;
5730
5731   // Process indirect outputs, first output all of the flagged copies out of
5732   // physregs.
5733   for (unsigned i = 0, e = IndirectStoresToEmit.size(); i != e; ++i) {
5734     RegsForValue &OutRegs = IndirectStoresToEmit[i].first;
5735     const Value *Ptr = IndirectStoresToEmit[i].second;
5736     SDValue OutVal = OutRegs.getCopyFromRegs(DAG, FuncInfo, getCurDebugLoc(),
5737                                              Chain, &Flag);
5738     StoresToEmit.push_back(std::make_pair(OutVal, Ptr));
5739   }
5740
5741   // Emit the non-flagged stores from the physregs.
5742   SmallVector<SDValue, 8> OutChains;
5743   for (unsigned i = 0, e = StoresToEmit.size(); i != e; ++i) {
5744     SDValue Val = DAG.getStore(Chain, getCurDebugLoc(),
5745                                StoresToEmit[i].first,
5746                                getValue(StoresToEmit[i].second),
5747                                StoresToEmit[i].second, 0,
5748                                false, false, 0);
5749     OutChains.push_back(Val);
5750   }
5751
5752   if (!OutChains.empty())
5753     Chain = DAG.getNode(ISD::TokenFactor, getCurDebugLoc(), MVT::Other,
5754                         &OutChains[0], OutChains.size());
5755
5756   DAG.setRoot(Chain);
5757 }
5758
5759 void SelectionDAGBuilder::visitVAStart(const CallInst &I) {
5760   DAG.setRoot(DAG.getNode(ISD::VASTART, getCurDebugLoc(),
5761                           MVT::Other, getRoot(),
5762                           getValue(I.getArgOperand(0)),
5763                           DAG.getSrcValue(I.getArgOperand(0))));
5764 }
5765
5766 void SelectionDAGBuilder::visitVAArg(const VAArgInst &I) {
5767   const TargetData &TD = *TLI.getTargetData();
5768   SDValue V = DAG.getVAArg(TLI.getValueType(I.getType()), getCurDebugLoc(),
5769                            getRoot(), getValue(I.getOperand(0)),
5770                            DAG.getSrcValue(I.getOperand(0)),
5771                            TD.getABITypeAlignment(I.getType()));
5772   setValue(&I, V);
5773   DAG.setRoot(V.getValue(1));
5774 }
5775
5776 void SelectionDAGBuilder::visitVAEnd(const CallInst &I) {
5777   DAG.setRoot(DAG.getNode(ISD::VAEND, getCurDebugLoc(),
5778                           MVT::Other, getRoot(),
5779                           getValue(I.getArgOperand(0)),
5780                           DAG.getSrcValue(I.getArgOperand(0))));
5781 }
5782
5783 void SelectionDAGBuilder::visitVACopy(const CallInst &I) {
5784   DAG.setRoot(DAG.getNode(ISD::VACOPY, getCurDebugLoc(),
5785                           MVT::Other, getRoot(),
5786                           getValue(I.getArgOperand(0)),
5787                           getValue(I.getArgOperand(1)),
5788                           DAG.getSrcValue(I.getArgOperand(0)),
5789                           DAG.getSrcValue(I.getArgOperand(1))));
5790 }
5791
5792 /// TargetLowering::LowerCallTo - This is the default LowerCallTo
5793 /// implementation, which just calls LowerCall.
5794 /// FIXME: When all targets are
5795 /// migrated to using LowerCall, this hook should be integrated into SDISel.
5796 std::pair<SDValue, SDValue>
5797 TargetLowering::LowerCallTo(SDValue Chain, const Type *RetTy,
5798                             bool RetSExt, bool RetZExt, bool isVarArg,
5799                             bool isInreg, unsigned NumFixedArgs,
5800                             CallingConv::ID CallConv, bool isTailCall,
5801                             bool isReturnValueUsed,
5802                             SDValue Callee,
5803                             ArgListTy &Args, SelectionDAG &DAG,
5804                             DebugLoc dl) const {
5805   // Handle all of the outgoing arguments.
5806   SmallVector<ISD::OutputArg, 32> Outs;
5807   SmallVector<SDValue, 32> OutVals;
5808   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
5809     SmallVector<EVT, 4> ValueVTs;
5810     ComputeValueVTs(*this, Args[i].Ty, ValueVTs);
5811     for (unsigned Value = 0, NumValues = ValueVTs.size();
5812          Value != NumValues; ++Value) {
5813       EVT VT = ValueVTs[Value];
5814       const Type *ArgTy = VT.getTypeForEVT(RetTy->getContext());
5815       SDValue Op = SDValue(Args[i].Node.getNode(),
5816                            Args[i].Node.getResNo() + Value);
5817       ISD::ArgFlagsTy Flags;
5818       unsigned OriginalAlignment =
5819         getTargetData()->getABITypeAlignment(ArgTy);
5820
5821       if (Args[i].isZExt)
5822         Flags.setZExt();
5823       if (Args[i].isSExt)
5824         Flags.setSExt();
5825       if (Args[i].isInReg)
5826         Flags.setInReg();
5827       if (Args[i].isSRet)
5828         Flags.setSRet();
5829       if (Args[i].isByVal) {
5830         Flags.setByVal();
5831         const PointerType *Ty = cast<PointerType>(Args[i].Ty);
5832         const Type *ElementTy = Ty->getElementType();
5833         unsigned FrameAlign = getByValTypeAlignment(ElementTy);
5834         unsigned FrameSize  = getTargetData()->getTypeAllocSize(ElementTy);
5835         // For ByVal, alignment should come from FE.  BE will guess if this
5836         // info is not there but there are cases it cannot get right.
5837         if (Args[i].Alignment)
5838           FrameAlign = Args[i].Alignment;
5839         Flags.setByValAlign(FrameAlign);
5840         Flags.setByValSize(FrameSize);
5841       }
5842       if (Args[i].isNest)
5843         Flags.setNest();
5844       Flags.setOrigAlign(OriginalAlignment);
5845
5846       EVT PartVT = getRegisterType(RetTy->getContext(), VT);
5847       unsigned NumParts = getNumRegisters(RetTy->getContext(), VT);
5848       SmallVector<SDValue, 4> Parts(NumParts);
5849       ISD::NodeType ExtendKind = ISD::ANY_EXTEND;
5850
5851       if (Args[i].isSExt)
5852         ExtendKind = ISD::SIGN_EXTEND;
5853       else if (Args[i].isZExt)
5854         ExtendKind = ISD::ZERO_EXTEND;
5855
5856       getCopyToParts(DAG, dl, Op, &Parts[0], NumParts,
5857                      PartVT, ExtendKind);
5858
5859       for (unsigned j = 0; j != NumParts; ++j) {
5860         // if it isn't first piece, alignment must be 1
5861         ISD::OutputArg MyFlags(Flags, Parts[j].getValueType(),
5862                                i < NumFixedArgs);
5863         if (NumParts > 1 && j == 0)
5864           MyFlags.Flags.setSplit();
5865         else if (j != 0)
5866           MyFlags.Flags.setOrigAlign(1);
5867
5868         Outs.push_back(MyFlags);
5869         OutVals.push_back(Parts[j]);
5870       }
5871     }
5872   }
5873
5874   // Handle the incoming return values from the call.
5875   SmallVector<ISD::InputArg, 32> Ins;
5876   SmallVector<EVT, 4> RetTys;
5877   ComputeValueVTs(*this, RetTy, RetTys);
5878   for (unsigned I = 0, E = RetTys.size(); I != E; ++I) {
5879     EVT VT = RetTys[I];
5880     EVT RegisterVT = getRegisterType(RetTy->getContext(), VT);
5881     unsigned NumRegs = getNumRegisters(RetTy->getContext(), VT);
5882     for (unsigned i = 0; i != NumRegs; ++i) {
5883       ISD::InputArg MyFlags;
5884       MyFlags.VT = RegisterVT;
5885       MyFlags.Used = isReturnValueUsed;
5886       if (RetSExt)
5887         MyFlags.Flags.setSExt();
5888       if (RetZExt)
5889         MyFlags.Flags.setZExt();
5890       if (isInreg)
5891         MyFlags.Flags.setInReg();
5892       Ins.push_back(MyFlags);
5893     }
5894   }
5895
5896   SmallVector<SDValue, 4> InVals;
5897   Chain = LowerCall(Chain, Callee, CallConv, isVarArg, isTailCall,
5898                     Outs, OutVals, Ins, dl, DAG, InVals);
5899
5900   // Verify that the target's LowerCall behaved as expected.
5901   assert(Chain.getNode() && Chain.getValueType() == MVT::Other &&
5902          "LowerCall didn't return a valid chain!");
5903   assert((!isTailCall || InVals.empty()) &&
5904          "LowerCall emitted a return value for a tail call!");
5905   assert((isTailCall || InVals.size() == Ins.size()) &&
5906          "LowerCall didn't emit the correct number of values!");
5907
5908   // For a tail call, the return value is merely live-out and there aren't
5909   // any nodes in the DAG representing it. Return a special value to
5910   // indicate that a tail call has been emitted and no more Instructions
5911   // should be processed in the current block.
5912   if (isTailCall) {
5913     DAG.setRoot(Chain);
5914     return std::make_pair(SDValue(), SDValue());
5915   }
5916
5917   DEBUG(for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
5918           assert(InVals[i].getNode() &&
5919                  "LowerCall emitted a null value!");
5920           assert(Ins[i].VT == InVals[i].getValueType() &&
5921                  "LowerCall emitted a value with the wrong type!");
5922         });
5923
5924   // Collect the legal value parts into potentially illegal values
5925   // that correspond to the original function's return values.
5926   ISD::NodeType AssertOp = ISD::DELETED_NODE;
5927   if (RetSExt)
5928     AssertOp = ISD::AssertSext;
5929   else if (RetZExt)
5930     AssertOp = ISD::AssertZext;
5931   SmallVector<SDValue, 4> ReturnValues;
5932   unsigned CurReg = 0;
5933   for (unsigned I = 0, E = RetTys.size(); I != E; ++I) {
5934     EVT VT = RetTys[I];
5935     EVT RegisterVT = getRegisterType(RetTy->getContext(), VT);
5936     unsigned NumRegs = getNumRegisters(RetTy->getContext(), VT);
5937
5938     ReturnValues.push_back(getCopyFromParts(DAG, dl, &InVals[CurReg],
5939                                             NumRegs, RegisterVT, VT,
5940                                             AssertOp));
5941     CurReg += NumRegs;
5942   }
5943
5944   // For a function returning void, there is no return value. We can't create
5945   // such a node, so we just return a null return value in that case. In
5946   // that case, nothing will actualy look at the value.
5947   if (ReturnValues.empty())
5948     return std::make_pair(SDValue(), Chain);
5949
5950   SDValue Res = DAG.getNode(ISD::MERGE_VALUES, dl,
5951                             DAG.getVTList(&RetTys[0], RetTys.size()),
5952                             &ReturnValues[0], ReturnValues.size());
5953   return std::make_pair(Res, Chain);
5954 }
5955
5956 void TargetLowering::LowerOperationWrapper(SDNode *N,
5957                                            SmallVectorImpl<SDValue> &Results,
5958                                            SelectionDAG &DAG) const {
5959   SDValue Res = LowerOperation(SDValue(N, 0), DAG);
5960   if (Res.getNode())
5961     Results.push_back(Res);
5962 }
5963
5964 SDValue TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
5965   llvm_unreachable("LowerOperation not implemented for this target!");
5966   return SDValue();
5967 }
5968
5969 void
5970 SelectionDAGBuilder::CopyValueToVirtualRegister(const Value *V, unsigned Reg) {
5971   SDValue Op = getNonRegisterValue(V);
5972   assert((Op.getOpcode() != ISD::CopyFromReg ||
5973           cast<RegisterSDNode>(Op.getOperand(1))->getReg() != Reg) &&
5974          "Copy from a reg to the same reg!");
5975   assert(!TargetRegisterInfo::isPhysicalRegister(Reg) && "Is a physreg");
5976
5977   RegsForValue RFV(V->getContext(), TLI, Reg, V->getType());
5978   SDValue Chain = DAG.getEntryNode();
5979   RFV.getCopyToRegs(Op, DAG, getCurDebugLoc(), Chain, 0);
5980   PendingExports.push_back(Chain);
5981 }
5982
5983 #include "llvm/CodeGen/SelectionDAGISel.h"
5984
5985 void SelectionDAGISel::LowerArguments(const BasicBlock *LLVMBB) {
5986   // If this is the entry block, emit arguments.
5987   const Function &F = *LLVMBB->getParent();
5988   SelectionDAG &DAG = SDB->DAG;
5989   DebugLoc dl = SDB->getCurDebugLoc();
5990   const TargetData *TD = TLI.getTargetData();
5991   SmallVector<ISD::InputArg, 16> Ins;
5992
5993   // Check whether the function can return without sret-demotion.
5994   SmallVector<ISD::OutputArg, 4> Outs;
5995   GetReturnInfo(F.getReturnType(), F.getAttributes().getRetAttributes(),
5996                 Outs, TLI);
5997
5998   if (!FuncInfo->CanLowerReturn) {
5999     // Put in an sret pointer parameter before all the other parameters.
6000     SmallVector<EVT, 1> ValueVTs;
6001     ComputeValueVTs(TLI, PointerType::getUnqual(F.getReturnType()), ValueVTs);
6002
6003     // NOTE: Assuming that a pointer will never break down to more than one VT
6004     // or one register.
6005     ISD::ArgFlagsTy Flags;
6006     Flags.setSRet();
6007     EVT RegisterVT = TLI.getRegisterType(*DAG.getContext(), ValueVTs[0]);
6008     ISD::InputArg RetArg(Flags, RegisterVT, true);
6009     Ins.push_back(RetArg);
6010   }
6011
6012   // Set up the incoming argument description vector.
6013   unsigned Idx = 1;
6014   for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end();
6015        I != E; ++I, ++Idx) {
6016     SmallVector<EVT, 4> ValueVTs;
6017     ComputeValueVTs(TLI, I->getType(), ValueVTs);
6018     bool isArgValueUsed = !I->use_empty();
6019     for (unsigned Value = 0, NumValues = ValueVTs.size();
6020          Value != NumValues; ++Value) {
6021       EVT VT = ValueVTs[Value];
6022       const Type *ArgTy = VT.getTypeForEVT(*DAG.getContext());
6023       ISD::ArgFlagsTy Flags;
6024       unsigned OriginalAlignment =
6025         TD->getABITypeAlignment(ArgTy);
6026
6027       if (F.paramHasAttr(Idx, Attribute::ZExt))
6028         Flags.setZExt();
6029       if (F.paramHasAttr(Idx, Attribute::SExt))
6030         Flags.setSExt();
6031       if (F.paramHasAttr(Idx, Attribute::InReg))
6032         Flags.setInReg();
6033       if (F.paramHasAttr(Idx, Attribute::StructRet))
6034         Flags.setSRet();
6035       if (F.paramHasAttr(Idx, Attribute::ByVal)) {
6036         Flags.setByVal();
6037         const PointerType *Ty = cast<PointerType>(I->getType());
6038         const Type *ElementTy = Ty->getElementType();
6039         unsigned FrameAlign = TLI.getByValTypeAlignment(ElementTy);
6040         unsigned FrameSize  = TD->getTypeAllocSize(ElementTy);
6041         // For ByVal, alignment should be passed from FE.  BE will guess if
6042         // this info is not there but there are cases it cannot get right.
6043         if (F.getParamAlignment(Idx))
6044           FrameAlign = F.getParamAlignment(Idx);
6045         Flags.setByValAlign(FrameAlign);
6046         Flags.setByValSize(FrameSize);
6047       }
6048       if (F.paramHasAttr(Idx, Attribute::Nest))
6049         Flags.setNest();
6050       Flags.setOrigAlign(OriginalAlignment);
6051
6052       EVT RegisterVT = TLI.getRegisterType(*CurDAG->getContext(), VT);
6053       unsigned NumRegs = TLI.getNumRegisters(*CurDAG->getContext(), VT);
6054       for (unsigned i = 0; i != NumRegs; ++i) {
6055         ISD::InputArg MyFlags(Flags, RegisterVT, isArgValueUsed);
6056         if (NumRegs > 1 && i == 0)
6057           MyFlags.Flags.setSplit();
6058         // if it isn't first piece, alignment must be 1
6059         else if (i > 0)
6060           MyFlags.Flags.setOrigAlign(1);
6061         Ins.push_back(MyFlags);
6062       }
6063     }
6064   }
6065
6066   // Call the target to set up the argument values.
6067   SmallVector<SDValue, 8> InVals;
6068   SDValue NewRoot = TLI.LowerFormalArguments(DAG.getRoot(), F.getCallingConv(),
6069                                              F.isVarArg(), Ins,
6070                                              dl, DAG, InVals);
6071
6072   // Verify that the target's LowerFormalArguments behaved as expected.
6073   assert(NewRoot.getNode() && NewRoot.getValueType() == MVT::Other &&
6074          "LowerFormalArguments didn't return a valid chain!");
6075   assert(InVals.size() == Ins.size() &&
6076          "LowerFormalArguments didn't emit the correct number of values!");
6077   DEBUG({
6078       for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
6079         assert(InVals[i].getNode() &&
6080                "LowerFormalArguments emitted a null value!");
6081         assert(Ins[i].VT == InVals[i].getValueType() &&
6082                "LowerFormalArguments emitted a value with the wrong type!");
6083       }
6084     });
6085
6086   // Update the DAG with the new chain value resulting from argument lowering.
6087   DAG.setRoot(NewRoot);
6088
6089   // Set up the argument values.
6090   unsigned i = 0;
6091   Idx = 1;
6092   if (!FuncInfo->CanLowerReturn) {
6093     // Create a virtual register for the sret pointer, and put in a copy
6094     // from the sret argument into it.
6095     SmallVector<EVT, 1> ValueVTs;
6096     ComputeValueVTs(TLI, PointerType::getUnqual(F.getReturnType()), ValueVTs);
6097     EVT VT = ValueVTs[0];
6098     EVT RegVT = TLI.getRegisterType(*CurDAG->getContext(), VT);
6099     ISD::NodeType AssertOp = ISD::DELETED_NODE;
6100     SDValue ArgValue = getCopyFromParts(DAG, dl, &InVals[0], 1,
6101                                         RegVT, VT, AssertOp);
6102
6103     MachineFunction& MF = SDB->DAG.getMachineFunction();
6104     MachineRegisterInfo& RegInfo = MF.getRegInfo();
6105     unsigned SRetReg = RegInfo.createVirtualRegister(TLI.getRegClassFor(RegVT));
6106     FuncInfo->DemoteRegister = SRetReg;
6107     NewRoot = SDB->DAG.getCopyToReg(NewRoot, SDB->getCurDebugLoc(),
6108                                     SRetReg, ArgValue);
6109     DAG.setRoot(NewRoot);
6110
6111     // i indexes lowered arguments.  Bump it past the hidden sret argument.
6112     // Idx indexes LLVM arguments.  Don't touch it.
6113     ++i;
6114   }
6115
6116   for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E;
6117       ++I, ++Idx) {
6118     SmallVector<SDValue, 4> ArgValues;
6119     SmallVector<EVT, 4> ValueVTs;
6120     ComputeValueVTs(TLI, I->getType(), ValueVTs);
6121     unsigned NumValues = ValueVTs.size();
6122
6123     // If this argument is unused then remember its value. It is used to generate
6124     // debugging information.
6125     if (I->use_empty() && NumValues)
6126       SDB->setUnusedArgValue(I, InVals[i]);
6127
6128     for (unsigned Value = 0; Value != NumValues; ++Value) {
6129       EVT VT = ValueVTs[Value];
6130       EVT PartVT = TLI.getRegisterType(*CurDAG->getContext(), VT);
6131       unsigned NumParts = TLI.getNumRegisters(*CurDAG->getContext(), VT);
6132
6133       if (!I->use_empty()) {
6134         ISD::NodeType AssertOp = ISD::DELETED_NODE;
6135         if (F.paramHasAttr(Idx, Attribute::SExt))
6136           AssertOp = ISD::AssertSext;
6137         else if (F.paramHasAttr(Idx, Attribute::ZExt))
6138           AssertOp = ISD::AssertZext;
6139
6140         ArgValues.push_back(getCopyFromParts(DAG, dl, &InVals[i],
6141                                              NumParts, PartVT, VT,
6142                                              AssertOp));
6143       }
6144
6145       i += NumParts;
6146     }
6147
6148     if (!I->use_empty()) {
6149       SDValue Res;
6150       if (!ArgValues.empty())
6151         Res = DAG.getMergeValues(&ArgValues[0], NumValues,
6152                                  SDB->getCurDebugLoc());
6153       SDB->setValue(I, Res);
6154
6155       // If this argument is live outside of the entry block, insert a copy from
6156       // whereever we got it to the vreg that other BB's will reference it as.
6157       SDB->CopyToExportRegsIfNeeded(I);
6158     }
6159   }
6160
6161   assert(i == InVals.size() && "Argument register count mismatch!");
6162
6163   // Finally, if the target has anything special to do, allow it to do so.
6164   // FIXME: this should insert code into the DAG!
6165   EmitFunctionEntryCode();
6166 }
6167
6168 /// Handle PHI nodes in successor blocks.  Emit code into the SelectionDAG to
6169 /// ensure constants are generated when needed.  Remember the virtual registers
6170 /// that need to be added to the Machine PHI nodes as input.  We cannot just
6171 /// directly add them, because expansion might result in multiple MBB's for one
6172 /// BB.  As such, the start of the BB might correspond to a different MBB than
6173 /// the end.
6174 ///
6175 void
6176 SelectionDAGBuilder::HandlePHINodesInSuccessorBlocks(const BasicBlock *LLVMBB) {
6177   const TerminatorInst *TI = LLVMBB->getTerminator();
6178
6179   SmallPtrSet<MachineBasicBlock *, 4> SuccsHandled;
6180
6181   // Check successor nodes' PHI nodes that expect a constant to be available
6182   // from this block.
6183   for (unsigned succ = 0, e = TI->getNumSuccessors(); succ != e; ++succ) {
6184     const BasicBlock *SuccBB = TI->getSuccessor(succ);
6185     if (!isa<PHINode>(SuccBB->begin())) continue;
6186     MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB];
6187
6188     // If this terminator has multiple identical successors (common for
6189     // switches), only handle each succ once.
6190     if (!SuccsHandled.insert(SuccMBB)) continue;
6191
6192     MachineBasicBlock::iterator MBBI = SuccMBB->begin();
6193
6194     // At this point we know that there is a 1-1 correspondence between LLVM PHI
6195     // nodes and Machine PHI nodes, but the incoming operands have not been
6196     // emitted yet.
6197     for (BasicBlock::const_iterator I = SuccBB->begin();
6198          const PHINode *PN = dyn_cast<PHINode>(I); ++I) {
6199       // Ignore dead phi's.
6200       if (PN->use_empty()) continue;
6201
6202       unsigned Reg;
6203       const Value *PHIOp = PN->getIncomingValueForBlock(LLVMBB);
6204
6205       if (const Constant *C = dyn_cast<Constant>(PHIOp)) {
6206         unsigned &RegOut = ConstantsOut[C];
6207         if (RegOut == 0) {
6208           RegOut = FuncInfo.CreateRegs(C->getType());
6209           CopyValueToVirtualRegister(C, RegOut);
6210         }
6211         Reg = RegOut;
6212       } else {
6213         DenseMap<const Value *, unsigned>::iterator I =
6214           FuncInfo.ValueMap.find(PHIOp);
6215         if (I != FuncInfo.ValueMap.end())
6216           Reg = I->second;
6217         else {
6218           assert(isa<AllocaInst>(PHIOp) &&
6219                  FuncInfo.StaticAllocaMap.count(cast<AllocaInst>(PHIOp)) &&
6220                  "Didn't codegen value into a register!??");
6221           Reg = FuncInfo.CreateRegs(PHIOp->getType());
6222           CopyValueToVirtualRegister(PHIOp, Reg);
6223         }
6224       }
6225
6226       // Remember that this register needs to added to the machine PHI node as
6227       // the input for this MBB.
6228       SmallVector<EVT, 4> ValueVTs;
6229       ComputeValueVTs(TLI, PN->getType(), ValueVTs);
6230       for (unsigned vti = 0, vte = ValueVTs.size(); vti != vte; ++vti) {
6231         EVT VT = ValueVTs[vti];
6232         unsigned NumRegisters = TLI.getNumRegisters(*DAG.getContext(), VT);
6233         for (unsigned i = 0, e = NumRegisters; i != e; ++i)
6234           FuncInfo.PHINodesToUpdate.push_back(std::make_pair(MBBI++, Reg+i));
6235         Reg += NumRegisters;
6236       }
6237     }
6238   }
6239   ConstantsOut.clear();
6240 }