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