lib/CodeGen/SelectionDAG/SelectionDAG.cpp

   1 //===-- SelectionDAG.cpp - Implement the SelectionDAG data structures -----===//
   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 the SelectionDAG class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/CodeGen/SelectionDAG.h"
  15 #include "SDNodeDbgValue.h"
  16 #include "llvm/ADT/SetVector.h"
  17 #include "llvm/ADT/SmallPtrSet.h"
  18 #include "llvm/ADT/SmallSet.h"
  19 #include "llvm/ADT/SmallVector.h"
  20 #include "llvm/ADT/StringExtras.h"
  21 #include "llvm/Analysis/ValueTracking.h"
  22 #include "llvm/CodeGen/MachineBasicBlock.h"
  23 #include "llvm/CodeGen/MachineConstantPool.h"
  24 #include "llvm/CodeGen/MachineFrameInfo.h"
  25 #include "llvm/CodeGen/MachineModuleInfo.h"
  26 #include "llvm/IR/CallingConv.h"
  27 #include "llvm/IR/Constants.h"
  28 #include "llvm/IR/DataLayout.h"
  29 #include "llvm/IR/DebugInfo.h"
  30 #include "llvm/IR/DerivedTypes.h"
  31 #include "llvm/IR/Function.h"
  32 #include "llvm/IR/GlobalAlias.h"
  33 #include "llvm/IR/GlobalVariable.h"
  34 #include "llvm/IR/Intrinsics.h"
  35 #include "llvm/Support/CommandLine.h"
  36 #include "llvm/Support/Debug.h"
  37 #include "llvm/Support/ErrorHandling.h"
  38 #include "llvm/Support/ManagedStatic.h"
  39 #include "llvm/Support/MathExtras.h"
  40 #include "llvm/Support/Mutex.h"
  41 #include "llvm/Support/raw_ostream.h"
  42 #include "llvm/Target/TargetInstrInfo.h"
  43 #include "llvm/Target/TargetIntrinsicInfo.h"
  44 #include "llvm/Target/TargetLowering.h"
  45 #include "llvm/Target/TargetMachine.h"
  46 #include "llvm/Target/TargetOptions.h"
  47 #include "llvm/Target/TargetRegisterInfo.h"
  48 #include "llvm/Target/TargetSelectionDAGInfo.h"
  49 #include <algorithm>
  50 #include <cmath>
  51 using namespace llvm;
  52
  53 /// makeVTList - Return an instance of the SDVTList struct initialized with the
  54 /// specified members.
  55 static SDVTList makeVTList(const EVT *VTs, unsigned NumVTs) {
  56   SDVTList Res = {VTs, NumVTs};
  57   return Res;
  58 }
  59
  60 // Default null implementations of the callbacks.
  61 void SelectionDAG::DAGUpdateListener::NodeDeleted(SDNode*, SDNode*) {}
  62 void SelectionDAG::DAGUpdateListener::NodeUpdated(SDNode*) {}
  63
  64 //===----------------------------------------------------------------------===//
  65 //                              ConstantFPSDNode Class
  66 //===----------------------------------------------------------------------===//
  67
  68 /// isExactlyValue - We don't rely on operator== working on double values, as
  69 /// it returns true for things that are clearly not equal, like -0.0 and 0.0.
  70 /// As such, this method can be used to do an exact bit-for-bit comparison of
  71 /// two floating point values.
  72 bool ConstantFPSDNode::isExactlyValue(const APFloat& V) const {
  73   return getValueAPF().bitwiseIsEqual(V);
  74 }
  75
  76 bool ConstantFPSDNode::isValueValidForType(EVT VT,
  77                                            const APFloat& Val) {
  78   assert(VT.isFloatingPoint() && "Can only convert between FP types");
  79
  80   // convert modifies in place, so make a copy.
  81   APFloat Val2 = APFloat(Val);
  82   bool losesInfo;
  83   (void) Val2.convert(SelectionDAG::EVTToAPFloatSemantics(VT),
  84                       APFloat::rmNearestTiesToEven,
  85                       &losesInfo);
  86   return !losesInfo;
  87 }
  88
  89 //===----------------------------------------------------------------------===//
  90 //                              ISD Namespace
  91 //===----------------------------------------------------------------------===//
  92
  93 /// isBuildVectorAllOnes - Return true if the specified node is a
  94 /// BUILD_VECTOR where all of the elements are ~0 or undef.
  95 bool ISD::isBuildVectorAllOnes(const SDNode *N) {
  96   // Look through a bit convert.
  97   if (N->getOpcode() == ISD::BITCAST)
  98     N = N->getOperand(0).getNode();
  99
 100   if (N->getOpcode() != ISD::BUILD_VECTOR) return false;
 101
 102   unsigned i = 0, e = N->getNumOperands();
 103
 104   // Skip over all of the undef values.
 105   while (i != e && N->getOperand(i).getOpcode() == ISD::UNDEF)
 106     ++i;
 107
 108   // Do not accept an all-undef vector.
 109   if (i == e) return false;
 110
 111   // Do not accept build_vectors that aren't all constants or which have non-~0
 112   // elements. We have to be a bit careful here, as the type of the constant
 113   // may not be the same as the type of the vector elements due to type
 114   // legalization (the elements are promoted to a legal type for the target and
 115   // a vector of a type may be legal when the base element type is not).
 116   // We only want to check enough bits to cover the vector elements, because
 117   // we care if the resultant vector is all ones, not whether the individual
 118   // constants are.
 119   SDValue NotZero = N->getOperand(i);
 120   unsigned EltSize = N->getValueType(0).getVectorElementType().getSizeInBits();
 121   if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(NotZero)) {
 122     if (CN->getAPIntValue().countTrailingOnes() < EltSize)
 123       return false;
 124   } else if (ConstantFPSDNode *CFPN = dyn_cast<ConstantFPSDNode>(NotZero)) {
 125     if (CFPN->getValueAPF().bitcastToAPInt().countTrailingOnes() < EltSize)
 126       return false;
 127   } else
 128     return false;
 129
 130   // Okay, we have at least one ~0 value, check to see if the rest match or are
 131   // undefs. Even with the above element type twiddling, this should be OK, as
 132   // the same type legalization should have applied to all the elements.
 133   for (++i; i != e; ++i)
 134     if (N->getOperand(i) != NotZero &&
 135         N->getOperand(i).getOpcode() != ISD::UNDEF)
 136       return false;
 137   return true;
 138 }
 139
 140
 141 /// isBuildVectorAllZeros - Return true if the specified node is a
 142 /// BUILD_VECTOR where all of the elements are 0 or undef.
 143 bool ISD::isBuildVectorAllZeros(const SDNode *N) {
 144   // Look through a bit convert.
 145   if (N->getOpcode() == ISD::BITCAST)
 146     N = N->getOperand(0).getNode();
 147
 148   if (N->getOpcode() != ISD::BUILD_VECTOR) return false;
 149
 150   unsigned i = 0, e = N->getNumOperands();
 151
 152   // Skip over all of the undef values.
 153   while (i != e && N->getOperand(i).getOpcode() == ISD::UNDEF)
 154     ++i;
 155
 156   // Do not accept an all-undef vector.
 157   if (i == e) return false;
 158
 159   // Do not accept build_vectors that aren't all constants or which have non-0
 160   // elements.
 161   SDValue Zero = N->getOperand(i);
 162   if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Zero)) {
 163     if (!CN->isNullValue())
 164       return false;
 165   } else if (ConstantFPSDNode *CFPN = dyn_cast<ConstantFPSDNode>(Zero)) {
 166     if (!CFPN->getValueAPF().isPosZero())
 167       return false;
 168   } else
 169     return false;
 170
 171   // Okay, we have at least one 0 value, check to see if the rest match or are
 172   // undefs.
 173   for (++i; i != e; ++i)
 174     if (N->getOperand(i) != Zero &&
 175         N->getOperand(i).getOpcode() != ISD::UNDEF)
 176       return false;
 177   return true;
 178 }
 179
 180 /// \brief Return true if the specified node is a BUILD_VECTOR node of
 181 /// all ConstantSDNode or undef.
 182 bool ISD::isBuildVectorOfConstantSDNodes(const SDNode *N) {
 183   if (N->getOpcode() != ISD::BUILD_VECTOR)
 184     return false;
 185
 186   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
 187     SDValue Op = N->getOperand(i);
 188     if (Op.getOpcode() == ISD::UNDEF)
 189       continue;
 190     if (!isa<ConstantSDNode>(Op))
 191       return false;
 192   }
 193   return true;
 194 }
 195
 196 /// isScalarToVector - Return true if the specified node is a
 197 /// ISD::SCALAR_TO_VECTOR node or a BUILD_VECTOR node where only the low
 198 /// element is not an undef.
 199 bool ISD::isScalarToVector(const SDNode *N) {
 200   if (N->getOpcode() == ISD::SCALAR_TO_VECTOR)
 201     return true;
 202
 203   if (N->getOpcode() != ISD::BUILD_VECTOR)
 204     return false;
 205   if (N->getOperand(0).getOpcode() == ISD::UNDEF)
 206     return false;
 207   unsigned NumElems = N->getNumOperands();
 208   if (NumElems == 1)
 209     return false;
 210   for (unsigned i = 1; i < NumElems; ++i) {
 211     SDValue V = N->getOperand(i);
 212     if (V.getOpcode() != ISD::UNDEF)
 213       return false;
 214   }
 215   return true;
 216 }
 217
 218 /// allOperandsUndef - Return true if the node has at least one operand
 219 /// and all operands of the specified node are ISD::UNDEF.
 220 bool ISD::allOperandsUndef(const SDNode *N) {
 221   // Return false if the node has no operands.
 222   // This is "logically inconsistent" with the definition of "all" but
 223   // is probably the desired behavior.
 224   if (N->getNumOperands() == 0)
 225     return false;
 226
 227   for (unsigned i = 0, e = N->getNumOperands(); i != e ; ++i)
 228     if (N->getOperand(i).getOpcode() != ISD::UNDEF)
 229       return false;
 230
 231   return true;
 232 }
 233
 234 ISD::NodeType ISD::getExtForLoadExtType(ISD::LoadExtType ExtType) {
 235   switch (ExtType) {
 236   case ISD::EXTLOAD:
 237     return ISD::ANY_EXTEND;
 238   case ISD::SEXTLOAD:
 239     return ISD::SIGN_EXTEND;
 240   case ISD::ZEXTLOAD:
 241     return ISD::ZERO_EXTEND;
 242   default:
 243     break;
 244   }
 245
 246   llvm_unreachable("Invalid LoadExtType");
 247 }
 248
 249 /// getSetCCSwappedOperands - Return the operation corresponding to (Y op X)
 250 /// when given the operation for (X op Y).
 251 ISD::CondCode ISD::getSetCCSwappedOperands(ISD::CondCode Operation) {
 252   // To perform this operation, we just need to swap the L and G bits of the
 253   // operation.
 254   unsigned OldL = (Operation >> 2) & 1;
 255   unsigned OldG = (Operation >> 1) & 1;
 256   return ISD::CondCode((Operation & ~6) |  // Keep the N, U, E bits
 257                        (OldL << 1) |       // New G bit
 258                        (OldG << 2));       // New L bit.
 259 }
 260
 261 /// getSetCCInverse - Return the operation corresponding to !(X op Y), where
 262 /// 'op' is a valid SetCC operation.
 263 ISD::CondCode ISD::getSetCCInverse(ISD::CondCode Op, bool isInteger) {
 264   unsigned Operation = Op;
 265   if (isInteger)
 266     Operation ^= 7;   // Flip L, G, E bits, but not U.
 267   else
 268     Operation ^= 15;  // Flip all of the condition bits.
 269
 270   if (Operation > ISD::SETTRUE2)
 271     Operation &= ~8;  // Don't let N and U bits get set.
 272
 273   return ISD::CondCode(Operation);
 274 }
 275
 276
 277 /// isSignedOp - For an integer comparison, return 1 if the comparison is a
 278 /// signed operation and 2 if the result is an unsigned comparison.  Return zero
 279 /// if the operation does not depend on the sign of the input (setne and seteq).
 280 static int isSignedOp(ISD::CondCode Opcode) {
 281   switch (Opcode) {
 282   default: llvm_unreachable("Illegal integer setcc operation!");
 283   case ISD::SETEQ:
 284   case ISD::SETNE: return 0;
 285   case ISD::SETLT:
 286   case ISD::SETLE:
 287   case ISD::SETGT:
 288   case ISD::SETGE: return 1;
 289   case ISD::SETULT:
 290   case ISD::SETULE:
 291   case ISD::SETUGT:
 292   case ISD::SETUGE: return 2;
 293   }
 294 }
 295
 296 /// getSetCCOrOperation - Return the result of a logical OR between different
 297 /// comparisons of identical values: ((X op1 Y) | (X op2 Y)).  This function
 298 /// returns SETCC_INVALID if it is not possible to represent the resultant
 299 /// comparison.
 300 ISD::CondCode ISD::getSetCCOrOperation(ISD::CondCode Op1, ISD::CondCode Op2,
 301                                        bool isInteger) {
 302   if (isInteger && (isSignedOp(Op1) | isSignedOp(Op2)) == 3)
 303     // Cannot fold a signed integer setcc with an unsigned integer setcc.
 304     return ISD::SETCC_INVALID;
 305
 306   unsigned Op = Op1 | Op2;  // Combine all of the condition bits.
 307
 308   // If the N and U bits get set then the resultant comparison DOES suddenly
 309   // care about orderedness, and is true when ordered.
 310   if (Op > ISD::SETTRUE2)
 311     Op &= ~16;     // Clear the U bit if the N bit is set.
 312
 313   // Canonicalize illegal integer setcc's.
 314   if (isInteger && Op == ISD::SETUNE)  // e.g. SETUGT | SETULT
 315     Op = ISD::SETNE;
 316
 317   return ISD::CondCode(Op);
 318 }
 319
 320 /// getSetCCAndOperation - Return the result of a logical AND between different
 321 /// comparisons of identical values: ((X op1 Y) & (X op2 Y)).  This
 322 /// function returns zero if it is not possible to represent the resultant
 323 /// comparison.
 324 ISD::CondCode ISD::getSetCCAndOperation(ISD::CondCode Op1, ISD::CondCode Op2,
 325                                         bool isInteger) {
 326   if (isInteger && (isSignedOp(Op1) | isSignedOp(Op2)) == 3)
 327     // Cannot fold a signed setcc with an unsigned setcc.
 328     return ISD::SETCC_INVALID;
 329
 330   // Combine all of the condition bits.
 331   ISD::CondCode Result = ISD::CondCode(Op1 & Op2);
 332
 333   // Canonicalize illegal integer setcc's.
 334   if (isInteger) {
 335     switch (Result) {
 336     default: break;
 337     case ISD::SETUO : Result = ISD::SETFALSE; break;  // SETUGT & SETULT
 338     case ISD::SETOEQ:                                 // SETEQ  & SETU[LG]E
 339     case ISD::SETUEQ: Result = ISD::SETEQ   ; break;  // SETUGE & SETULE
 340     case ISD::SETOLT: Result = ISD::SETULT  ; break;  // SETULT & SETNE
 341     case ISD::SETOGT: Result = ISD::SETUGT  ; break;  // SETUGT & SETNE
 342     }
 343   }
 344
 345   return Result;
 346 }
 347
 348 //===----------------------------------------------------------------------===//
 349 //                           SDNode Profile Support
 350 //===----------------------------------------------------------------------===//
 351
 352 /// AddNodeIDOpcode - Add the node opcode to the NodeID data.
 353 ///
 354 static void AddNodeIDOpcode(FoldingSetNodeID &ID, unsigned OpC)  {
 355   ID.AddInteger(OpC);
 356 }
 357
 358 /// AddNodeIDValueTypes - Value type lists are intern'd so we can represent them
 359 /// solely with their pointer.
 360 static void AddNodeIDValueTypes(FoldingSetNodeID &ID, SDVTList VTList) {
 361   ID.AddPointer(VTList.VTs);
 362 }
 363
 364 /// AddNodeIDOperands - Various routines for adding operands to the NodeID data.
 365 ///
 366 static void AddNodeIDOperands(FoldingSetNodeID &ID,
 367                               const SDValue *Ops, unsigned NumOps) {
 368   for (; NumOps; --NumOps, ++Ops) {
 369     ID.AddPointer(Ops->getNode());
 370     ID.AddInteger(Ops->getResNo());
 371   }
 372 }
 373
 374 /// AddNodeIDOperands - Various routines for adding operands to the NodeID data.
 375 ///
 376 static void AddNodeIDOperands(FoldingSetNodeID &ID,
 377                               const SDUse *Ops, unsigned NumOps) {
 378   for (; NumOps; --NumOps, ++Ops) {
 379     ID.AddPointer(Ops->getNode());
 380     ID.AddInteger(Ops->getResNo());
 381   }
 382 }
 383
 384 static void AddNodeIDNode(FoldingSetNodeID &ID,
 385                           unsigned short OpC, SDVTList VTList,
 386                           const SDValue *OpList, unsigned N) {
 387   AddNodeIDOpcode(ID, OpC);
 388   AddNodeIDValueTypes(ID, VTList);
 389   AddNodeIDOperands(ID, OpList, N);
 390 }
 391
 392 /// AddNodeIDCustom - If this is an SDNode with special info, add this info to
 393 /// the NodeID data.
 394 static void AddNodeIDCustom(FoldingSetNodeID &ID, const SDNode *N) {
 395   switch (N->getOpcode()) {
 396   case ISD::TargetExternalSymbol:
 397   case ISD::ExternalSymbol:
 398     llvm_unreachable("Should only be used on nodes with operands");
 399   default: break;  // Normal nodes don't need extra info.
 400   case ISD::TargetConstant:
 401   case ISD::Constant: {
 402     const ConstantSDNode *C = cast<ConstantSDNode>(N);
 403     ID.AddPointer(C->getConstantIntValue());
 404     ID.AddBoolean(C->isOpaque());
 405     break;
 406   }
 407   case ISD::TargetConstantFP:
 408   case ISD::ConstantFP: {
 409     ID.AddPointer(cast<ConstantFPSDNode>(N)->getConstantFPValue());
 410     break;
 411   }
 412   case ISD::TargetGlobalAddress:
 413   case ISD::GlobalAddress:
 414   case ISD::TargetGlobalTLSAddress:
 415   case ISD::GlobalTLSAddress: {
 416     const GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(N);
 417     ID.AddPointer(GA->getGlobal());
 418     ID.AddInteger(GA->getOffset());
 419     ID.AddInteger(GA->getTargetFlags());
 420     ID.AddInteger(GA->getAddressSpace());
 421     break;
 422   }
 423   case ISD::BasicBlock:
 424     ID.AddPointer(cast<BasicBlockSDNode>(N)->getBasicBlock());
 425     break;
 426   case ISD::Register:
 427     ID.AddInteger(cast<RegisterSDNode>(N)->getReg());
 428     break;
 429   case ISD::RegisterMask:
 430     ID.AddPointer(cast<RegisterMaskSDNode>(N)->getRegMask());
 431     break;
 432   case ISD::SRCVALUE:
 433     ID.AddPointer(cast<SrcValueSDNode>(N)->getValue());
 434     break;
 435   case ISD::FrameIndex:
 436   case ISD::TargetFrameIndex:
 437     ID.AddInteger(cast<FrameIndexSDNode>(N)->getIndex());
 438     break;
 439   case ISD::JumpTable:
 440   case ISD::TargetJumpTable:
 441     ID.AddInteger(cast<JumpTableSDNode>(N)->getIndex());
 442     ID.AddInteger(cast<JumpTableSDNode>(N)->getTargetFlags());
 443     break;
 444   case ISD::ConstantPool:
 445   case ISD::TargetConstantPool: {
 446     const ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(N);
 447     ID.AddInteger(CP->getAlignment());
 448     ID.AddInteger(CP->getOffset());
 449     if (CP->isMachineConstantPoolEntry())
 450       CP->getMachineCPVal()->addSelectionDAGCSEId(ID);
 451     else
 452       ID.AddPointer(CP->getConstVal());
 453     ID.AddInteger(CP->getTargetFlags());
 454     break;
 455   }
 456   case ISD::TargetIndex: {
 457     const TargetIndexSDNode *TI = cast<TargetIndexSDNode>(N);
 458     ID.AddInteger(TI->getIndex());
 459     ID.AddInteger(TI->getOffset());
 460     ID.AddInteger(TI->getTargetFlags());
 461     break;
 462   }
 463   case ISD::LOAD: {
 464     const LoadSDNode *LD = cast<LoadSDNode>(N);
 465     ID.AddInteger(LD->getMemoryVT().getRawBits());
 466     ID.AddInteger(LD->getRawSubclassData());
 467     ID.AddInteger(LD->getPointerInfo().getAddrSpace());
 468     break;
 469   }
 470   case ISD::STORE: {
 471     const StoreSDNode *ST = cast<StoreSDNode>(N);
 472     ID.AddInteger(ST->getMemoryVT().getRawBits());
 473     ID.AddInteger(ST->getRawSubclassData());
 474     ID.AddInteger(ST->getPointerInfo().getAddrSpace());
 475     break;
 476   }
 477   case ISD::ATOMIC_CMP_SWAP:
 478   case ISD::ATOMIC_SWAP:
 479   case ISD::ATOMIC_LOAD_ADD:
 480   case ISD::ATOMIC_LOAD_SUB:
 481   case ISD::ATOMIC_LOAD_AND:
 482   case ISD::ATOMIC_LOAD_OR:
 483   case ISD::ATOMIC_LOAD_XOR:
 484   case ISD::ATOMIC_LOAD_NAND:
 485   case ISD::ATOMIC_LOAD_MIN:
 486   case ISD::ATOMIC_LOAD_MAX:
 487   case ISD::ATOMIC_LOAD_UMIN:
 488   case ISD::ATOMIC_LOAD_UMAX:
 489   case ISD::ATOMIC_LOAD:
 490   case ISD::ATOMIC_STORE: {
 491     const AtomicSDNode *AT = cast<AtomicSDNode>(N);
 492     ID.AddInteger(AT->getMemoryVT().getRawBits());
 493     ID.AddInteger(AT->getRawSubclassData());
 494     ID.AddInteger(AT->getPointerInfo().getAddrSpace());
 495     break;
 496   }
 497   case ISD::PREFETCH: {
 498     const MemSDNode *PF = cast<MemSDNode>(N);
 499     ID.AddInteger(PF->getPointerInfo().getAddrSpace());
 500     break;
 501   }
 502   case ISD::VECTOR_SHUFFLE: {
 503     const ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(N);
 504     for (unsigned i = 0, e = N->getValueType(0).getVectorNumElements();
 505          i != e; ++i)
 506       ID.AddInteger(SVN->getMaskElt(i));
 507     break;
 508   }
 509   case ISD::TargetBlockAddress:
 510   case ISD::BlockAddress: {
 511     const BlockAddressSDNode *BA = cast<BlockAddressSDNode>(N);
 512     ID.AddPointer(BA->getBlockAddress());
 513     ID.AddInteger(BA->getOffset());
 514     ID.AddInteger(BA->getTargetFlags());
 515     break;
 516   }
 517   } // end switch (N->getOpcode())
 518
 519   // Target specific memory nodes could also have address spaces to check.
 520   if (N->isTargetMemoryOpcode())
 521     ID.AddInteger(cast<MemSDNode>(N)->getPointerInfo().getAddrSpace());
 522 }
 523
 524 /// AddNodeIDNode - Generic routine for adding a nodes info to the NodeID
 525 /// data.
 526 static void AddNodeIDNode(FoldingSetNodeID &ID, const SDNode *N) {
 527   AddNodeIDOpcode(ID, N->getOpcode());
 528   // Add the return value info.
 529   AddNodeIDValueTypes(ID, N->getVTList());
 530   // Add the operand info.
 531   AddNodeIDOperands(ID, N->op_begin(), N->getNumOperands());
 532
 533   // Handle SDNode leafs with special info.
 534   AddNodeIDCustom(ID, N);
 535 }
 536
 537 /// encodeMemSDNodeFlags - Generic routine for computing a value for use in
 538 /// the CSE map that carries volatility, temporalness, indexing mode, and
 539 /// extension/truncation information.
 540 ///
 541 static inline unsigned
 542 encodeMemSDNodeFlags(int ConvType, ISD::MemIndexedMode AM, bool isVolatile,
 543                      bool isNonTemporal, bool isInvariant) {
 544   assert((ConvType & 3) == ConvType &&
 545          "ConvType may not require more than 2 bits!");
 546   assert((AM & 7) == AM &&
 547          "AM may not require more than 3 bits!");
 548   return ConvType |
 549          (AM << 2) |
 550          (isVolatile << 5) |
 551          (isNonTemporal << 6) |
 552          (isInvariant << 7);
 553 }
 554
 555 //===----------------------------------------------------------------------===//
 556 //                              SelectionDAG Class
 557 //===----------------------------------------------------------------------===//
 558
 559 /// doNotCSE - Return true if CSE should not be performed for this node.
 560 static bool doNotCSE(SDNode *N) {
 561   if (N->getValueType(0) == MVT::Glue)
 562     return true; // Never CSE anything that produces a flag.
 563
 564   switch (N->getOpcode()) {
 565   default: break;
 566   case ISD::HANDLENODE:
 567   case ISD::EH_LABEL:
 568     return true;   // Never CSE these nodes.
 569   }
 570
 571   // Check that remaining values produced are not flags.
 572   for (unsigned i = 1, e = N->getNumValues(); i != e; ++i)
 573     if (N->getValueType(i) == MVT::Glue)
 574       return true; // Never CSE anything that produces a flag.
 575
 576   return false;
 577 }
 578
 579 /// RemoveDeadNodes - This method deletes all unreachable nodes in the
 580 /// SelectionDAG.
 581 void SelectionDAG::RemoveDeadNodes() {
 582   // Create a dummy node (which is not added to allnodes), that adds a reference
 583   // to the root node, preventing it from being deleted.
 584   HandleSDNode Dummy(getRoot());
 585
 586   SmallVector<SDNode*, 128> DeadNodes;
 587
 588   // Add all obviously-dead nodes to the DeadNodes worklist.
 589   for (allnodes_iterator I = allnodes_begin(), E = allnodes_end(); I != E; ++I)
 590     if (I->use_empty())
 591       DeadNodes.push_back(I);
 592
 593   RemoveDeadNodes(DeadNodes);
 594
 595   // If the root changed (e.g. it was a dead load, update the root).
 596   setRoot(Dummy.getValue());
 597 }
 598
 599 /// RemoveDeadNodes - This method deletes the unreachable nodes in the
 600 /// given list, and any nodes that become unreachable as a result.
 601 void SelectionDAG::RemoveDeadNodes(SmallVectorImpl<SDNode *> &DeadNodes) {
 602
 603   // Process the worklist, deleting the nodes and adding their uses to the
 604   // worklist.
 605   while (!DeadNodes.empty()) {
 606     SDNode *N = DeadNodes.pop_back_val();
 607
 608     for (DAGUpdateListener *DUL = UpdateListeners; DUL; DUL = DUL->Next)
 609       DUL->NodeDeleted(N, 0);
 610
 611     // Take the node out of the appropriate CSE map.
 612     RemoveNodeFromCSEMaps(N);
 613
 614     // Next, brutally remove the operand list.  This is safe to do, as there are
 615     // no cycles in the graph.
 616     for (SDNode::op_iterator I = N->op_begin(), E = N->op_end(); I != E; ) {
 617       SDUse &Use = *I++;
 618       SDNode *Operand = Use.getNode();
 619       Use.set(SDValue());
 620
 621       // Now that we removed this operand, see if there are no uses of it left.
 622       if (Operand->use_empty())
 623         DeadNodes.push_back(Operand);
 624     }
 625
 626     DeallocateNode(N);
 627   }
 628 }
 629
 630 void SelectionDAG::RemoveDeadNode(SDNode *N){
 631   SmallVector<SDNode*, 16> DeadNodes(1, N);
 632
 633   // Create a dummy node that adds a reference to the root node, preventing
 634   // it from being deleted.  (This matters if the root is an operand of the
 635   // dead node.)
 636   HandleSDNode Dummy(getRoot());
 637
 638   RemoveDeadNodes(DeadNodes);
 639 }
 640
 641 void SelectionDAG::DeleteNode(SDNode *N) {
 642   // First take this out of the appropriate CSE map.
 643   RemoveNodeFromCSEMaps(N);
 644
 645   // Finally, remove uses due to operands of this node, remove from the
 646   // AllNodes list, and delete the node.
 647   DeleteNodeNotInCSEMaps(N);
 648 }
 649
 650 void SelectionDAG::DeleteNodeNotInCSEMaps(SDNode *N) {
 651   assert(N != AllNodes.begin() && "Cannot delete the entry node!");
 652   assert(N->use_empty() && "Cannot delete a node that is not dead!");
 653
 654   // Drop all of the operands and decrement used node's use counts.
 655   N->DropOperands();
 656
 657   DeallocateNode(N);
 658 }
 659
 660 void SelectionDAG::DeallocateNode(SDNode *N) {
 661   if (N->OperandsNeedDelete)
 662     delete[] N->OperandList;
 663
 664   // Set the opcode to DELETED_NODE to help catch bugs when node
 665   // memory is reallocated.
 666   N->NodeType = ISD::DELETED_NODE;
 667
 668   NodeAllocator.Deallocate(AllNodes.remove(N));
 669
 670   // If any of the SDDbgValue nodes refer to this SDNode, invalidate them.
 671   ArrayRef<SDDbgValue*> DbgVals = DbgInfo->getSDDbgValues(N);
 672   for (unsigned i = 0, e = DbgVals.size(); i != e; ++i)
 673     DbgVals[i]->setIsInvalidated();
 674 }
 675
 676 /// RemoveNodeFromCSEMaps - Take the specified node out of the CSE map that
 677 /// correspond to it.  This is useful when we're about to delete or repurpose
 678 /// the node.  We don't want future request for structurally identical nodes
 679 /// to return N anymore.
 680 bool SelectionDAG::RemoveNodeFromCSEMaps(SDNode *N) {
 681   bool Erased = false;
 682   switch (N->getOpcode()) {
 683   case ISD::HANDLENODE: return false;  // noop.
 684   case ISD::CONDCODE:
 685     assert(CondCodeNodes[cast<CondCodeSDNode>(N)->get()] &&
 686            "Cond code doesn't exist!");
 687     Erased = CondCodeNodes[cast<CondCodeSDNode>(N)->get()] != 0;
 688     CondCodeNodes[cast<CondCodeSDNode>(N)->get()] = 0;
 689     break;
 690   case ISD::ExternalSymbol:
 691     Erased = ExternalSymbols.erase(cast<ExternalSymbolSDNode>(N)->getSymbol());
 692     break;
 693   case ISD::TargetExternalSymbol: {
 694     ExternalSymbolSDNode *ESN = cast<ExternalSymbolSDNode>(N);
 695     Erased = TargetExternalSymbols.erase(
 696                std::pair<std::string,unsigned char>(ESN->getSymbol(),
 697                                                     ESN->getTargetFlags()));
 698     break;
 699   }
 700   case ISD::VALUETYPE: {
 701     EVT VT = cast<VTSDNode>(N)->getVT();
 702     if (VT.isExtended()) {
 703       Erased = ExtendedValueTypeNodes.erase(VT);
 704     } else {
 705       Erased = ValueTypeNodes[VT.getSimpleVT().SimpleTy] != 0;
 706       ValueTypeNodes[VT.getSimpleVT().SimpleTy] = 0;
 707     }
 708     break;
 709   }
 710   default:
 711     // Remove it from the CSE Map.
 712     assert(N->getOpcode() != ISD::DELETED_NODE && "DELETED_NODE in CSEMap!");
 713     assert(N->getOpcode() != ISD::EntryToken && "EntryToken in CSEMap!");
 714     Erased = CSEMap.RemoveNode(N);
 715     break;
 716   }
 717 #ifndef NDEBUG
 718   // Verify that the node was actually in one of the CSE maps, unless it has a
 719   // flag result (which cannot be CSE'd) or is one of the special cases that are
 720   // not subject to CSE.
 721   if (!Erased && N->getValueType(N->getNumValues()-1) != MVT::Glue &&
 722       !N->isMachineOpcode() && !doNotCSE(N)) {
 723     N->dump(this);
 724     dbgs() << "\n";
 725     llvm_unreachable("Node is not in map!");
 726   }
 727 #endif
 728   return Erased;
 729 }
 730
 731 /// AddModifiedNodeToCSEMaps - The specified node has been removed from the CSE
 732 /// maps and modified in place. Add it back to the CSE maps, unless an identical
 733 /// node already exists, in which case transfer all its users to the existing
 734 /// node. This transfer can potentially trigger recursive merging.
 735 ///
 736 void
 737 SelectionDAG::AddModifiedNodeToCSEMaps(SDNode *N) {
 738   // For node types that aren't CSE'd, just act as if no identical node
 739   // already exists.
 740   if (!doNotCSE(N)) {
 741     SDNode *Existing = CSEMap.GetOrInsertNode(N);
 742     if (Existing != N) {
 743       // If there was already an existing matching node, use ReplaceAllUsesWith
 744       // to replace the dead one with the existing one.  This can cause
 745       // recursive merging of other unrelated nodes down the line.
 746       ReplaceAllUsesWith(N, Existing);
 747
 748       // N is now dead. Inform the listeners and delete it.
 749       for (DAGUpdateListener *DUL = UpdateListeners; DUL; DUL = DUL->Next)
 750         DUL->NodeDeleted(N, Existing);
 751       DeleteNodeNotInCSEMaps(N);
 752       return;
 753     }
 754   }
 755
 756   // If the node doesn't already exist, we updated it.  Inform listeners.
 757   for (DAGUpdateListener *DUL = UpdateListeners; DUL; DUL = DUL->Next)
 758     DUL->NodeUpdated(N);
 759 }
 760
 761 /// FindModifiedNodeSlot - Find a slot for the specified node if its operands
 762 /// were replaced with those specified.  If this node is never memoized,
 763 /// return null, otherwise return a pointer to the slot it would take.  If a
 764 /// node already exists with these operands, the slot will be non-null.
 765 SDNode *SelectionDAG::FindModifiedNodeSlot(SDNode *N, SDValue Op,
 766                                            void *&InsertPos) {
 767   if (doNotCSE(N))
 768     return 0;
 769
 770   SDValue Ops[] = { Op };
 771   FoldingSetNodeID ID;
 772   AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops, 1);
 773   AddNodeIDCustom(ID, N);
 774   SDNode *Node = CSEMap.FindNodeOrInsertPos(ID, InsertPos);
 775   return Node;
 776 }
 777
 778 /// FindModifiedNodeSlot - Find a slot for the specified node if its operands
 779 /// were replaced with those specified.  If this node is never memoized,
 780 /// return null, otherwise return a pointer to the slot it would take.  If a
 781 /// node already exists with these operands, the slot will be non-null.
 782 SDNode *SelectionDAG::FindModifiedNodeSlot(SDNode *N,
 783                                            SDValue Op1, SDValue Op2,
 784                                            void *&InsertPos) {
 785   if (doNotCSE(N))
 786     return 0;
 787
 788   SDValue Ops[] = { Op1, Op2 };
 789   FoldingSetNodeID ID;
 790   AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops, 2);
 791   AddNodeIDCustom(ID, N);
 792   SDNode *Node = CSEMap.FindNodeOrInsertPos(ID, InsertPos);
 793   return Node;
 794 }
 795
 796
 797 /// FindModifiedNodeSlot - Find a slot for the specified node if its operands
 798 /// were replaced with those specified.  If this node is never memoized,
 799 /// return null, otherwise return a pointer to the slot it would take.  If a
 800 /// node already exists with these operands, the slot will be non-null.
 801 SDNode *SelectionDAG::FindModifiedNodeSlot(SDNode *N,
 802                                            const SDValue *Ops,unsigned NumOps,
 803                                            void *&InsertPos) {
 804   if (doNotCSE(N))
 805     return 0;
 806
 807   FoldingSetNodeID ID;
 808   AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops, NumOps);
 809   AddNodeIDCustom(ID, N);
 810   SDNode *Node = CSEMap.FindNodeOrInsertPos(ID, InsertPos);
 811   return Node;
 812 }
 813
 814 #ifndef NDEBUG
 815 /// VerifyNodeCommon - Sanity check the given node.  Aborts if it is invalid.
 816 static void VerifyNodeCommon(SDNode *N) {
 817   switch (N->getOpcode()) {
 818   default:
 819     break;
 820   case ISD::BUILD_PAIR: {
 821     EVT VT = N->getValueType(0);
 822     assert(N->getNumValues() == 1 && "Too many results!");
 823     assert(!VT.isVector() && (VT.isInteger() || VT.isFloatingPoint()) &&
 824            "Wrong return type!");
 825     assert(N->getNumOperands() == 2 && "Wrong number of operands!");
 826     assert(N->getOperand(0).getValueType() == N->getOperand(1).getValueType() &&
 827            "Mismatched operand types!");
 828     assert(N->getOperand(0).getValueType().isInteger() == VT.isInteger() &&
 829            "Wrong operand type!");
 830     assert(VT.getSizeInBits() == 2 * N->getOperand(0).getValueSizeInBits() &&
 831            "Wrong return type size");
 832     break;
 833   }
 834   case ISD::BUILD_VECTOR: {
 835     assert(N->getNumValues() == 1 && "Too many results!");
 836     assert(N->getValueType(0).isVector() && "Wrong return type!");
 837     assert(N->getNumOperands() == N->getValueType(0).getVectorNumElements() &&
 838            "Wrong number of operands!");
 839     EVT EltVT = N->getValueType(0).getVectorElementType();
 840     for (SDNode::op_iterator I = N->op_begin(), E = N->op_end(); I != E; ++I) {
 841       assert((I->getValueType() == EltVT ||
 842              (EltVT.isInteger() && I->getValueType().isInteger() &&
 843               EltVT.bitsLE(I->getValueType()))) &&
 844             "Wrong operand type!");
 845       assert(I->getValueType() == N->getOperand(0).getValueType() &&
 846              "Operands must all have the same type");
 847     }
 848     break;
 849   }
 850   }
 851 }
 852
 853 /// VerifySDNode - Sanity check the given SDNode.  Aborts if it is invalid.
 854 static void VerifySDNode(SDNode *N) {
 855   // The SDNode allocators cannot be used to allocate nodes with fields that are
 856   // not present in an SDNode!
 857   assert(!isa<MemSDNode>(N) && "Bad MemSDNode!");
 858   assert(!isa<ShuffleVectorSDNode>(N) && "Bad ShuffleVectorSDNode!");
 859   assert(!isa<ConstantSDNode>(N) && "Bad ConstantSDNode!");
 860   assert(!isa<ConstantFPSDNode>(N) && "Bad ConstantFPSDNode!");
 861   assert(!isa<GlobalAddressSDNode>(N) && "Bad GlobalAddressSDNode!");
 862   assert(!isa<FrameIndexSDNode>(N) && "Bad FrameIndexSDNode!");
 863   assert(!isa<JumpTableSDNode>(N) && "Bad JumpTableSDNode!");
 864   assert(!isa<ConstantPoolSDNode>(N) && "Bad ConstantPoolSDNode!");
 865   assert(!isa<BasicBlockSDNode>(N) && "Bad BasicBlockSDNode!");
 866   assert(!isa<SrcValueSDNode>(N) && "Bad SrcValueSDNode!");
 867   assert(!isa<MDNodeSDNode>(N) && "Bad MDNodeSDNode!");
 868   assert(!isa<RegisterSDNode>(N) && "Bad RegisterSDNode!");
 869   assert(!isa<BlockAddressSDNode>(N) && "Bad BlockAddressSDNode!");
 870   assert(!isa<EHLabelSDNode>(N) && "Bad EHLabelSDNode!");
 871   assert(!isa<ExternalSymbolSDNode>(N) && "Bad ExternalSymbolSDNode!");
 872   assert(!isa<CondCodeSDNode>(N) && "Bad CondCodeSDNode!");
 873   assert(!isa<CvtRndSatSDNode>(N) && "Bad CvtRndSatSDNode!");
 874   assert(!isa<VTSDNode>(N) && "Bad VTSDNode!");
 875   assert(!isa<MachineSDNode>(N) && "Bad MachineSDNode!");
 876
 877   VerifyNodeCommon(N);
 878 }
 879
 880 /// VerifyMachineNode - Sanity check the given MachineNode.  Aborts if it is
 881 /// invalid.
 882 static void VerifyMachineNode(SDNode *N) {
 883   // The MachineNode allocators cannot be used to allocate nodes with fields
 884   // that are not present in a MachineNode!
 885   // Currently there are no such nodes.
 886
 887   VerifyNodeCommon(N);
 888 }
 889 #endif // NDEBUG
 890
 891 /// getEVTAlignment - Compute the default alignment value for the
 892 /// given type.
 893 ///
 894 unsigned SelectionDAG::getEVTAlignment(EVT VT) const {
 895   Type *Ty = VT == MVT::iPTR ?
 896                    PointerType::get(Type::getInt8Ty(*getContext()), 0) :
 897                    VT.getTypeForEVT(*getContext());
 898
 899   return TM.getTargetLowering()->getDataLayout()->getABITypeAlignment(Ty);
 900 }
 901
 902 // EntryNode could meaningfully have debug info if we can find it...
 903 SelectionDAG::SelectionDAG(const TargetMachine &tm, CodeGenOpt::Level OL)
 904   : TM(tm), TSI(*tm.getSelectionDAGInfo()), TLI(0), OptLevel(OL),
 905     EntryNode(ISD::EntryToken, 0, DebugLoc(), getVTList(MVT::Other)),
 906     Root(getEntryNode()), NewNodesMustHaveLegalTypes(false),
 907     UpdateListeners(0) {
 908   AllNodes.push_back(&EntryNode);
 909   DbgInfo = new SDDbgInfo();
 910 }
 911
 912 void SelectionDAG::init(MachineFunction &mf, const TargetLowering *tli) {
 913   MF = &mf;
 914   TLI = tli;
 915   Context = &mf.getFunction()->getContext();
 916 }
 917
 918 SelectionDAG::~SelectionDAG() {
 919   assert(!UpdateListeners && "Dangling registered DAGUpdateListeners");
 920   allnodes_clear();
 921   delete DbgInfo;
 922 }
 923
 924 void SelectionDAG::allnodes_clear() {
 925   assert(&*AllNodes.begin() == &EntryNode);
 926   AllNodes.remove(AllNodes.begin());
 927   while (!AllNodes.empty())
 928     DeallocateNode(AllNodes.begin());
 929 }
 930
 931 void SelectionDAG::clear() {
 932   allnodes_clear();
 933   OperandAllocator.Reset();
 934   CSEMap.clear();
 935
 936   ExtendedValueTypeNodes.clear();
 937   ExternalSymbols.clear();
 938   TargetExternalSymbols.clear();
 939   std::fill(CondCodeNodes.begin(), CondCodeNodes.end(),
 940             static_cast<CondCodeSDNode*>(0));
 941   std::fill(ValueTypeNodes.begin(), ValueTypeNodes.end(),
 942             static_cast<SDNode*>(0));
 943
 944   EntryNode.UseList = 0;
 945   AllNodes.push_back(&EntryNode);
 946   Root = getEntryNode();
 947   DbgInfo->clear();
 948 }
 949
 950 SDValue SelectionDAG::getAnyExtOrTrunc(SDValue Op, SDLoc DL, EVT VT) {
 951   return VT.bitsGT(Op.getValueType()) ?
 952     getNode(ISD::ANY_EXTEND, DL, VT, Op) :
 953     getNode(ISD::TRUNCATE, DL, VT, Op);
 954 }
 955
 956 SDValue SelectionDAG::getSExtOrTrunc(SDValue Op, SDLoc DL, EVT VT) {
 957   return VT.bitsGT(Op.getValueType()) ?
 958     getNode(ISD::SIGN_EXTEND, DL, VT, Op) :
 959     getNode(ISD::TRUNCATE, DL, VT, Op);
 960 }
 961
 962 SDValue SelectionDAG::getZExtOrTrunc(SDValue Op, SDLoc DL, EVT VT) {
 963   return VT.bitsGT(Op.getValueType()) ?
 964     getNode(ISD::ZERO_EXTEND, DL, VT, Op) :
 965     getNode(ISD::TRUNCATE, DL, VT, Op);
 966 }
 967
 968 SDValue SelectionDAG::getZeroExtendInReg(SDValue Op, SDLoc DL, EVT VT) {
 969   assert(!VT.isVector() &&
 970          "getZeroExtendInReg should use the vector element type instead of "
 971          "the vector type!");
 972   if (Op.getValueType() == VT) return Op;
 973   unsigned BitWidth = Op.getValueType().getScalarType().getSizeInBits();
 974   APInt Imm = APInt::getLowBitsSet(BitWidth,
 975                                    VT.getSizeInBits());
 976   return getNode(ISD::AND, DL, Op.getValueType(), Op,
 977                  getConstant(Imm, Op.getValueType()));
 978 }
 979
 980 /// getNOT - Create a bitwise NOT operation as (XOR Val, -1).
 981 ///
 982 SDValue SelectionDAG::getNOT(SDLoc DL, SDValue Val, EVT VT) {
 983   EVT EltVT = VT.getScalarType();
 984   SDValue NegOne =
 985     getConstant(APInt::getAllOnesValue(EltVT.getSizeInBits()), VT);
 986   return getNode(ISD::XOR, DL, VT, Val, NegOne);
 987 }
 988
 989 SDValue SelectionDAG::getConstant(uint64_t Val, EVT VT, bool isT, bool isO) {
 990   EVT EltVT = VT.getScalarType();
 991   assert((EltVT.getSizeInBits() >= 64 ||
 992          (uint64_t)((int64_t)Val >> EltVT.getSizeInBits()) + 1 < 2) &&
 993          "getConstant with a uint64_t value that doesn't fit in the type!");
 994   return getConstant(APInt(EltVT.getSizeInBits(), Val), VT, isT, isO);
 995 }
 996
 997 SDValue SelectionDAG::getConstant(const APInt &Val, EVT VT, bool isT, bool isO)
 998 {
 999   return getConstant(*ConstantInt::get(*Context, Val), VT, isT, isO);
1000 }
1001
1002 SDValue SelectionDAG::getConstant(const ConstantInt &Val, EVT VT, bool isT,
1003                                   bool isO) {
1004   assert(VT.isInteger() && "Cannot create FP integer constant!");
1005
1006   EVT EltVT = VT.getScalarType();
1007   const ConstantInt *Elt = &Val;
1008
1009   const TargetLowering *TLI = TM.getTargetLowering();
1010
1011   // In some cases the vector type is legal but the element type is illegal and
1012   // needs to be promoted, for example v8i8 on ARM.  In this case, promote the
1013   // inserted value (the type does not need to match the vector element type).
1014   // Any extra bits introduced will be truncated away.
1015   if (VT.isVector() && TLI->getTypeAction(*getContext(), EltVT) ==
1016       TargetLowering::TypePromoteInteger) {
1017    EltVT = TLI->getTypeToTransformTo(*getContext(), EltVT);
1018    APInt NewVal = Elt->getValue().zext(EltVT.getSizeInBits());
1019    Elt = ConstantInt::get(*getContext(), NewVal);
1020   }
1021   // In other cases the element type is illegal and needs to be expanded, for
1022   // example v2i64 on MIPS32. In this case, find the nearest legal type, split
1023   // the value into n parts and use a vector type with n-times the elements.
1024   // Then bitcast to the type requested.
1025   // Legalizing constants too early makes the DAGCombiner's job harder so we
1026   // only legalize if the DAG tells us we must produce legal types.
1027   else if (NewNodesMustHaveLegalTypes && VT.isVector() &&
1028            TLI->getTypeAction(*getContext(), EltVT) ==
1029            TargetLowering::TypeExpandInteger) {
1030     APInt NewVal = Elt->getValue();
1031     EVT ViaEltVT = TLI->getTypeToTransformTo(*getContext(), EltVT);
1032     unsigned ViaEltSizeInBits = ViaEltVT.getSizeInBits();
1033     unsigned ViaVecNumElts = VT.getSizeInBits() / ViaEltSizeInBits;
1034     EVT ViaVecVT = EVT::getVectorVT(*getContext(), ViaEltVT, ViaVecNumElts);
1035
1036     // Check the temporary vector is the correct size. If this fails then
1037     // getTypeToTransformTo() probably returned a type whose size (in bits)
1038     // isn't a power-of-2 factor of the requested type size.
1039     assert(ViaVecVT.getSizeInBits() == VT.getSizeInBits());
1040
1041     SmallVector<SDValue, 2> EltParts;
1042     for (unsigned i = 0; i < ViaVecNumElts / VT.getVectorNumElements(); ++i) {
1043       EltParts.push_back(getConstant(NewVal.lshr(i * ViaEltSizeInBits)
1044                                            .trunc(ViaEltSizeInBits),
1045                                      ViaEltVT, isT, isO));
1046     }
1047
1048     // EltParts is currently in little endian order. If we actually want
1049     // big-endian order then reverse it now.
1050     if (TLI->isBigEndian())
1051       std::reverse(EltParts.begin(), EltParts.end());
1052
1053     // The elements must be reversed when the element order is different
1054     // to the endianness of the elements (because the BITCAST is itself a
1055     // vector shuffle in this situation). However, we do not need any code to
1056     // perform this reversal because getConstant() is producing a vector
1057     // splat.
1058     // This situation occurs in MIPS MSA.
1059
1060     SmallVector<SDValue, 8> Ops;
1061     for (unsigned i = 0; i < VT.getVectorNumElements(); ++i)
1062       Ops.insert(Ops.end(), EltParts.begin(), EltParts.end());
1063
1064     SDValue Result = getNode(ISD::BITCAST, SDLoc(), VT,
1065                              getNode(ISD::BUILD_VECTOR, SDLoc(), ViaVecVT,
1066                                      &Ops[0], Ops.size()));
1067     return Result;
1068   }
1069
1070   assert(Elt->getBitWidth() == EltVT.getSizeInBits() &&
1071          "APInt size does not match type size!");
1072   unsigned Opc = isT ? ISD::TargetConstant : ISD::Constant;
1073   FoldingSetNodeID ID;
1074   AddNodeIDNode(ID, Opc, getVTList(EltVT), 0, 0);
1075   ID.AddPointer(Elt);
1076   ID.AddBoolean(isO);
1077   void *IP = 0;
1078   SDNode *N = NULL;
1079   if ((N = CSEMap.FindNodeOrInsertPos(ID, IP)))
1080     if (!VT.isVector())
1081       return SDValue(N, 0);
1082
1083   if (!N) {
1084     N = new (NodeAllocator) ConstantSDNode(isT, isO, Elt, EltVT);
1085     CSEMap.InsertNode(N, IP);
1086     AllNodes.push_back(N);
1087   }
1088
1089   SDValue Result(N, 0);
1090   if (VT.isVector()) {
1091     SmallVector<SDValue, 8> Ops;
1092     Ops.assign(VT.getVectorNumElements(), Result);
1093     Result = getNode(ISD::BUILD_VECTOR, SDLoc(), VT, &Ops[0], Ops.size());
1094   }
1095   return Result;
1096 }
1097
1098 SDValue SelectionDAG::getIntPtrConstant(uint64_t Val, bool isTarget) {
1099   return getConstant(Val, TM.getTargetLowering()->getPointerTy(), isTarget);
1100 }
1101
1102
1103 SDValue SelectionDAG::getConstantFP(const APFloat& V, EVT VT, bool isTarget) {
1104   return getConstantFP(*ConstantFP::get(*getContext(), V), VT, isTarget);
1105 }
1106
1107 SDValue SelectionDAG::getConstantFP(const ConstantFP& V, EVT VT, bool isTarget){
1108   assert(VT.isFloatingPoint() && "Cannot create integer FP constant!");
1109
1110   EVT EltVT = VT.getScalarType();
1111
1112   // Do the map lookup using the actual bit pattern for the floating point
1113   // value, so that we don't have problems with 0.0 comparing equal to -0.0, and
1114   // we don't have issues with SNANs.
1115   unsigned Opc = isTarget ? ISD::TargetConstantFP : ISD::ConstantFP;
1116   FoldingSetNodeID ID;
1117   AddNodeIDNode(ID, Opc, getVTList(EltVT), 0, 0);
1118   ID.AddPointer(&V);
1119   void *IP = 0;
1120   SDNode *N = NULL;
1121   if ((N = CSEMap.FindNodeOrInsertPos(ID, IP)))
1122     if (!VT.isVector())
1123       return SDValue(N, 0);
1124
1125   if (!N) {
1126     N = new (NodeAllocator) ConstantFPSDNode(isTarget, &V, EltVT);
1127     CSEMap.InsertNode(N, IP);
1128     AllNodes.push_back(N);
1129   }
1130
1131   SDValue Result(N, 0);
1132   if (VT.isVector()) {
1133     SmallVector<SDValue, 8> Ops;
1134     Ops.assign(VT.getVectorNumElements(), Result);
1135     // FIXME SDLoc info might be appropriate here
1136     Result = getNode(ISD::BUILD_VECTOR, SDLoc(), VT, &Ops[0], Ops.size());
1137   }
1138   return Result;
1139 }
1140
1141 SDValue SelectionDAG::getConstantFP(double Val, EVT VT, bool isTarget) {
1142   EVT EltVT = VT.getScalarType();
1143   if (EltVT==MVT::f32)
1144     return getConstantFP(APFloat((float)Val), VT, isTarget);
1145   else if (EltVT==MVT::f64)
1146     return getConstantFP(APFloat(Val), VT, isTarget);
1147   else if (EltVT==MVT::f80 || EltVT==MVT::f128 || EltVT==MVT::ppcf128 ||
1148            EltVT==MVT::f16) {
1149     bool ignored;
1150     APFloat apf = APFloat(Val);
1151     apf.convert(EVTToAPFloatSemantics(EltVT), APFloat::rmNearestTiesToEven,
1152                 &ignored);
1153     return getConstantFP(apf, VT, isTarget);
1154   } else
1155     llvm_unreachable("Unsupported type in getConstantFP");
1156 }
1157
1158 SDValue SelectionDAG::getGlobalAddress(const GlobalValue *GV, SDLoc DL,
1159                                        EVT VT, int64_t Offset,
1160                                        bool isTargetGA,
1161                                        unsigned char TargetFlags) {
1162   assert((TargetFlags == 0 || isTargetGA) &&
1163          "Cannot set target flags on target-independent globals");
1164   const TargetLowering *TLI = TM.getTargetLowering();
1165
1166   // Truncate (with sign-extension) the offset value to the pointer size.
1167   unsigned BitWidth = TLI->getPointerTypeSizeInBits(GV->getType());
1168   if (BitWidth < 64)
1169     Offset = SignExtend64(Offset, BitWidth);
1170
1171   const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
1172   if (!GVar) {
1173     // If GV is an alias then use the aliasee for determining thread-localness.
1174     if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(GV))
1175       GVar = dyn_cast_or_null<GlobalVariable>(GA->resolveAliasedGlobal(false));
1176   }
1177
1178   unsigned Opc;
1179   if (GVar && GVar->isThreadLocal())
1180     Opc = isTargetGA ? ISD::TargetGlobalTLSAddress : ISD::GlobalTLSAddress;
1181   else
1182     Opc = isTargetGA ? ISD::TargetGlobalAddress : ISD::GlobalAddress;
1183
1184   FoldingSetNodeID ID;
1185   AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
1186   ID.AddPointer(GV);
1187   ID.AddInteger(Offset);
1188   ID.AddInteger(TargetFlags);
1189   ID.AddInteger(GV->getType()->getAddressSpace());
1190   void *IP = 0;
1191   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1192     return SDValue(E, 0);
1193
1194   SDNode *N = new (NodeAllocator) GlobalAddressSDNode(Opc, DL.getIROrder(),
1195                                                       DL.getDebugLoc(), GV, VT,
1196                                                       Offset, TargetFlags);
1197   CSEMap.InsertNode(N, IP);
1198   AllNodes.push_back(N);
1199   return SDValue(N, 0);
1200 }
1201
1202 SDValue SelectionDAG::getFrameIndex(int FI, EVT VT, bool isTarget) {
1203   unsigned Opc = isTarget ? ISD::TargetFrameIndex : ISD::FrameIndex;
1204   FoldingSetNodeID ID;
1205   AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
1206   ID.AddInteger(FI);
1207   void *IP = 0;
1208   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1209     return SDValue(E, 0);
1210
1211   SDNode *N = new (NodeAllocator) FrameIndexSDNode(FI, VT, isTarget);
1212   CSEMap.InsertNode(N, IP);
1213   AllNodes.push_back(N);
1214   return SDValue(N, 0);
1215 }
1216
1217 SDValue SelectionDAG::getJumpTable(int JTI, EVT VT, bool isTarget,
1218                                    unsigned char TargetFlags) {
1219   assert((TargetFlags == 0 || isTarget) &&
1220          "Cannot set target flags on target-independent jump tables");
1221   unsigned Opc = isTarget ? ISD::TargetJumpTable : ISD::JumpTable;
1222   FoldingSetNodeID ID;
1223   AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
1224   ID.AddInteger(JTI);
1225   ID.AddInteger(TargetFlags);
1226   void *IP = 0;
1227   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1228     return SDValue(E, 0);
1229
1230   SDNode *N = new (NodeAllocator) JumpTableSDNode(JTI, VT, isTarget,
1231                                                   TargetFlags);
1232   CSEMap.InsertNode(N, IP);
1233   AllNodes.push_back(N);
1234   return SDValue(N, 0);
1235 }
1236
1237 SDValue SelectionDAG::getConstantPool(const Constant *C, EVT VT,
1238                                       unsigned Alignment, int Offset,
1239                                       bool isTarget,
1240                                       unsigned char TargetFlags) {
1241   assert((TargetFlags == 0 || isTarget) &&
1242          "Cannot set target flags on target-independent globals");
1243   if (Alignment == 0)
1244     Alignment =
1245     TM.getTargetLowering()->getDataLayout()->getPrefTypeAlignment(C->getType());
1246   unsigned Opc = isTarget ? ISD::TargetConstantPool : ISD::ConstantPool;
1247   FoldingSetNodeID ID;
1248   AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
1249   ID.AddInteger(Alignment);
1250   ID.AddInteger(Offset);
1251   ID.AddPointer(C);
1252   ID.AddInteger(TargetFlags);
1253   void *IP = 0;
1254   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1255     return SDValue(E, 0);
1256
1257   SDNode *N = new (NodeAllocator) ConstantPoolSDNode(isTarget, C, VT, Offset,
1258                                                      Alignment, TargetFlags);
1259   CSEMap.InsertNode(N, IP);
1260   AllNodes.push_back(N);
1261   return SDValue(N, 0);
1262 }
1263
1264
1265 SDValue SelectionDAG::getConstantPool(MachineConstantPoolValue *C, EVT VT,
1266                                       unsigned Alignment, int Offset,
1267                                       bool isTarget,
1268                                       unsigned char TargetFlags) {
1269   assert((TargetFlags == 0 || isTarget) &&
1270          "Cannot set target flags on target-independent globals");
1271   if (Alignment == 0)
1272     Alignment =
1273     TM.getTargetLowering()->getDataLayout()->getPrefTypeAlignment(C->getType());
1274   unsigned Opc = isTarget ? ISD::TargetConstantPool : ISD::ConstantPool;
1275   FoldingSetNodeID ID;
1276   AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
1277   ID.AddInteger(Alignment);
1278   ID.AddInteger(Offset);
1279   C->addSelectionDAGCSEId(ID);
1280   ID.AddInteger(TargetFlags);
1281   void *IP = 0;
1282   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1283     return SDValue(E, 0);
1284
1285   SDNode *N = new (NodeAllocator) ConstantPoolSDNode(isTarget, C, VT, Offset,
1286                                                      Alignment, TargetFlags);
1287   CSEMap.InsertNode(N, IP);
1288   AllNodes.push_back(N);
1289   return SDValue(N, 0);
1290 }
1291
1292 SDValue SelectionDAG::getTargetIndex(int Index, EVT VT, int64_t Offset,
1293                                      unsigned char TargetFlags) {
1294   FoldingSetNodeID ID;
1295   AddNodeIDNode(ID, ISD::TargetIndex, getVTList(VT), 0, 0);
1296   ID.AddInteger(Index);
1297   ID.AddInteger(Offset);
1298   ID.AddInteger(TargetFlags);
1299   void *IP = 0;
1300   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1301     return SDValue(E, 0);
1302
1303   SDNode *N = new (NodeAllocator) TargetIndexSDNode(Index, VT, Offset,
1304                                                     TargetFlags);
1305   CSEMap.InsertNode(N, IP);
1306   AllNodes.push_back(N);
1307   return SDValue(N, 0);
1308 }
1309
1310 SDValue SelectionDAG::getBasicBlock(MachineBasicBlock *MBB) {
1311   FoldingSetNodeID ID;
1312   AddNodeIDNode(ID, ISD::BasicBlock, getVTList(MVT::Other), 0, 0);
1313   ID.AddPointer(MBB);
1314   void *IP = 0;
1315   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1316     return SDValue(E, 0);
1317
1318   SDNode *N = new (NodeAllocator) BasicBlockSDNode(MBB);
1319   CSEMap.InsertNode(N, IP);
1320   AllNodes.push_back(N);
1321   return SDValue(N, 0);
1322 }
1323
1324 SDValue SelectionDAG::getValueType(EVT VT) {
1325   if (VT.isSimple() && (unsigned)VT.getSimpleVT().SimpleTy >=
1326       ValueTypeNodes.size())
1327     ValueTypeNodes.resize(VT.getSimpleVT().SimpleTy+1);
1328
1329   SDNode *&N = VT.isExtended() ?
1330     ExtendedValueTypeNodes[VT] : ValueTypeNodes[VT.getSimpleVT().SimpleTy];
1331
1332   if (N) return SDValue(N, 0);
1333   N = new (NodeAllocator) VTSDNode(VT);
1334   AllNodes.push_back(N);
1335   return SDValue(N, 0);
1336 }
1337
1338 SDValue SelectionDAG::getExternalSymbol(const char *Sym, EVT VT) {
1339   SDNode *&N = ExternalSymbols[Sym];
1340   if (N) return SDValue(N, 0);
1341   N = new (NodeAllocator) ExternalSymbolSDNode(false, Sym, 0, VT);
1342   AllNodes.push_back(N);
1343   return SDValue(N, 0);
1344 }
1345
1346 SDValue SelectionDAG::getTargetExternalSymbol(const char *Sym, EVT VT,
1347                                               unsigned char TargetFlags) {
1348   SDNode *&N =
1349     TargetExternalSymbols[std::pair<std::string,unsigned char>(Sym,
1350                                                                TargetFlags)];
1351   if (N) return SDValue(N, 0);
1352   N = new (NodeAllocator) ExternalSymbolSDNode(true, Sym, TargetFlags, VT);
1353   AllNodes.push_back(N);
1354   return SDValue(N, 0);
1355 }
1356
1357 SDValue SelectionDAG::getCondCode(ISD::CondCode Cond) {
1358   if ((unsigned)Cond >= CondCodeNodes.size())
1359     CondCodeNodes.resize(Cond+1);
1360
1361   if (CondCodeNodes[Cond] == 0) {
1362     CondCodeSDNode *N = new (NodeAllocator) CondCodeSDNode(Cond);
1363     CondCodeNodes[Cond] = N;
1364     AllNodes.push_back(N);
1365   }
1366
1367   return SDValue(CondCodeNodes[Cond], 0);
1368 }
1369
1370 // commuteShuffle - swaps the values of N1 and N2, and swaps all indices in
1371 // the shuffle mask M that point at N1 to point at N2, and indices that point
1372 // N2 to point at N1.
1373 static void commuteShuffle(SDValue &N1, SDValue &N2, SmallVectorImpl<int> &M) {
1374   std::swap(N1, N2);
1375   int NElts = M.size();
1376   for (int i = 0; i != NElts; ++i) {
1377     if (M[i] >= NElts)
1378       M[i] -= NElts;
1379     else if (M[i] >= 0)
1380       M[i] += NElts;
1381   }
1382 }
1383
1384 SDValue SelectionDAG::getVectorShuffle(EVT VT, SDLoc dl, SDValue N1,
1385                                        SDValue N2, const int *Mask) {
1386   assert(VT == N1.getValueType() && VT == N2.getValueType() &&
1387          "Invalid VECTOR_SHUFFLE");
1388
1389   // Canonicalize shuffle undef, undef -> undef
1390   if (N1.getOpcode() == ISD::UNDEF && N2.getOpcode() == ISD::UNDEF)
1391     return getUNDEF(VT);
1392
1393   // Validate that all indices in Mask are within the range of the elements
1394   // input to the shuffle.
1395   unsigned NElts = VT.getVectorNumElements();
1396   SmallVector<int, 8> MaskVec;
1397   for (unsigned i = 0; i != NElts; ++i) {
1398     assert(Mask[i] < (int)(NElts * 2) && "Index out of range");
1399     MaskVec.push_back(Mask[i]);
1400   }
1401
1402   // Canonicalize shuffle v, v -> v, undef
1403   if (N1 == N2) {
1404     N2 = getUNDEF(VT);
1405     for (unsigned i = 0; i != NElts; ++i)
1406       if (MaskVec[i] >= (int)NElts) MaskVec[i] -= NElts;
1407   }
1408
1409   // Canonicalize shuffle undef, v -> v, undef.  Commute the shuffle mask.
1410   if (N1.getOpcode() == ISD::UNDEF)
1411     commuteShuffle(N1, N2, MaskVec);
1412
1413   // Canonicalize all index into lhs, -> shuffle lhs, undef
1414   // Canonicalize all index into rhs, -> shuffle rhs, undef
1415   bool AllLHS = true, AllRHS = true;
1416   bool N2Undef = N2.getOpcode() == ISD::UNDEF;
1417   for (unsigned i = 0; i != NElts; ++i) {
1418     if (MaskVec[i] >= (int)NElts) {
1419       if (N2Undef)
1420         MaskVec[i] = -1;
1421       else
1422         AllLHS = false;
1423     } else if (MaskVec[i] >= 0) {
1424       AllRHS = false;
1425     }
1426   }
1427   if (AllLHS && AllRHS)
1428     return getUNDEF(VT);
1429   if (AllLHS && !N2Undef)
1430     N2 = getUNDEF(VT);
1431   if (AllRHS) {
1432     N1 = getUNDEF(VT);
1433     commuteShuffle(N1, N2, MaskVec);
1434   }
1435
1436   // If Identity shuffle return that node.
1437   bool Identity = true;
1438   for (unsigned i = 0; i != NElts; ++i) {
1439     if (MaskVec[i] >= 0 && MaskVec[i] != (int)i) Identity = false;
1440   }
1441   if (Identity && NElts)
1442     return N1;
1443
1444   FoldingSetNodeID ID;
1445   SDValue Ops[2] = { N1, N2 };
1446   AddNodeIDNode(ID, ISD::VECTOR_SHUFFLE, getVTList(VT), Ops, 2);
1447   for (unsigned i = 0; i != NElts; ++i)
1448     ID.AddInteger(MaskVec[i]);
1449
1450   void* IP = 0;
1451   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1452     return SDValue(E, 0);
1453
1454   // Allocate the mask array for the node out of the BumpPtrAllocator, since
1455   // SDNode doesn't have access to it.  This memory will be "leaked" when
1456   // the node is deallocated, but recovered when the NodeAllocator is released.
1457   int *MaskAlloc = OperandAllocator.Allocate<int>(NElts);
1458   memcpy(MaskAlloc, &MaskVec[0], NElts * sizeof(int));
1459
1460   ShuffleVectorSDNode *N =
1461     new (NodeAllocator) ShuffleVectorSDNode(VT, dl.getIROrder(),
1462                                             dl.getDebugLoc(), N1, N2,
1463                                             MaskAlloc);
1464   CSEMap.InsertNode(N, IP);
1465   AllNodes.push_back(N);
1466   return SDValue(N, 0);
1467 }
1468
1469 SDValue SelectionDAG::getConvertRndSat(EVT VT, SDLoc dl,
1470                                        SDValue Val, SDValue DTy,
1471                                        SDValue STy, SDValue Rnd, SDValue Sat,
1472                                        ISD::CvtCode Code) {
1473   // If the src and dest types are the same and the conversion is between
1474   // integer types of the same sign or two floats, no conversion is necessary.
1475   if (DTy == STy &&
1476       (Code == ISD::CVT_UU || Code == ISD::CVT_SS || Code == ISD::CVT_FF))
1477     return Val;
1478
1479   FoldingSetNodeID ID;
1480   SDValue Ops[] = { Val, DTy, STy, Rnd, Sat };
1481   AddNodeIDNode(ID, ISD::CONVERT_RNDSAT, getVTList(VT), &Ops[0], 5);
1482   void* IP = 0;
1483   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1484     return SDValue(E, 0);
1485
1486   CvtRndSatSDNode *N = new (NodeAllocator) CvtRndSatSDNode(VT, dl.getIROrder(),
1487                                                            dl.getDebugLoc(),
1488                                                            Ops, 5, Code);
1489   CSEMap.InsertNode(N, IP);
1490   AllNodes.push_back(N);
1491   return SDValue(N, 0);
1492 }
1493
1494 SDValue SelectionDAG::getRegister(unsigned RegNo, EVT VT) {
1495   FoldingSetNodeID ID;
1496   AddNodeIDNode(ID, ISD::Register, getVTList(VT), 0, 0);
1497   ID.AddInteger(RegNo);
1498   void *IP = 0;
1499   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1500     return SDValue(E, 0);
1501
1502   SDNode *N = new (NodeAllocator) RegisterSDNode(RegNo, VT);
1503   CSEMap.InsertNode(N, IP);
1504   AllNodes.push_back(N);
1505   return SDValue(N, 0);
1506 }
1507
1508 SDValue SelectionDAG::getRegisterMask(const uint32_t *RegMask) {
1509   FoldingSetNodeID ID;
1510   AddNodeIDNode(ID, ISD::RegisterMask, getVTList(MVT::Untyped), 0, 0);
1511   ID.AddPointer(RegMask);
1512   void *IP = 0;
1513   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1514     return SDValue(E, 0);
1515
1516   SDNode *N = new (NodeAllocator) RegisterMaskSDNode(RegMask);
1517   CSEMap.InsertNode(N, IP);
1518   AllNodes.push_back(N);
1519   return SDValue(N, 0);
1520 }
1521
1522 SDValue SelectionDAG::getEHLabel(SDLoc dl, SDValue Root, MCSymbol *Label) {
1523   FoldingSetNodeID ID;
1524   SDValue Ops[] = { Root };
1525   AddNodeIDNode(ID, ISD::EH_LABEL, getVTList(MVT::Other), &Ops[0], 1);
1526   ID.AddPointer(Label);
1527   void *IP = 0;
1528   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1529     return SDValue(E, 0);
1530
1531   SDNode *N = new (NodeAllocator) EHLabelSDNode(dl.getIROrder(),
1532                                                 dl.getDebugLoc(), Root, Label);
1533   CSEMap.InsertNode(N, IP);
1534   AllNodes.push_back(N);
1535   return SDValue(N, 0);
1536 }
1537
1538
1539 SDValue SelectionDAG::getBlockAddress(const BlockAddress *BA, EVT VT,
1540                                       int64_t Offset,
1541                                       bool isTarget,
1542                                       unsigned char TargetFlags) {
1543   unsigned Opc = isTarget ? ISD::TargetBlockAddress : ISD::BlockAddress;
1544
1545   FoldingSetNodeID ID;
1546   AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
1547   ID.AddPointer(BA);
1548   ID.AddInteger(Offset);
1549   ID.AddInteger(TargetFlags);
1550   void *IP = 0;
1551   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1552     return SDValue(E, 0);
1553
1554   SDNode *N = new (NodeAllocator) BlockAddressSDNode(Opc, VT, BA, Offset,
1555                                                      TargetFlags);
1556   CSEMap.InsertNode(N, IP);
1557   AllNodes.push_back(N);
1558   return SDValue(N, 0);
1559 }
1560
1561 SDValue SelectionDAG::getSrcValue(const Value *V) {
1562   assert((!V || V->getType()->isPointerTy()) &&
1563          "SrcValue is not a pointer?");
1564
1565   FoldingSetNodeID ID;
1566   AddNodeIDNode(ID, ISD::SRCVALUE, getVTList(MVT::Other), 0, 0);
1567   ID.AddPointer(V);
1568
1569   void *IP = 0;
1570   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1571     return SDValue(E, 0);
1572
1573   SDNode *N = new (NodeAllocator) SrcValueSDNode(V);
1574   CSEMap.InsertNode(N, IP);
1575   AllNodes.push_back(N);
1576   return SDValue(N, 0);
1577 }
1578
1579 /// getMDNode - Return an MDNodeSDNode which holds an MDNode.
1580 SDValue SelectionDAG::getMDNode(const MDNode *MD) {
1581   FoldingSetNodeID ID;
1582   AddNodeIDNode(ID, ISD::MDNODE_SDNODE, getVTList(MVT::Other), 0, 0);
1583   ID.AddPointer(MD);
1584
1585   void *IP = 0;
1586   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1587     return SDValue(E, 0);
1588
1589   SDNode *N = new (NodeAllocator) MDNodeSDNode(MD);
1590   CSEMap.InsertNode(N, IP);
1591   AllNodes.push_back(N);
1592   return SDValue(N, 0);
1593 }
1594
1595 /// getAddrSpaceCast - Return an AddrSpaceCastSDNode.
1596 SDValue SelectionDAG::getAddrSpaceCast(SDLoc dl, EVT VT, SDValue Ptr,
1597                                        unsigned SrcAS, unsigned DestAS) {
1598   SDValue Ops[] = {Ptr};
1599   FoldingSetNodeID ID;
1600   AddNodeIDNode(ID, ISD::ADDRSPACECAST, getVTList(VT), &Ops[0], 1);
1601   ID.AddInteger(SrcAS);
1602   ID.AddInteger(DestAS);
1603
1604   void *IP = 0;
1605   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
1606     return SDValue(E, 0);
1607
1608   SDNode *N = new (NodeAllocator) AddrSpaceCastSDNode(dl.getIROrder(),
1609                                                       dl.getDebugLoc(),
1610                                                       VT, Ptr, SrcAS, DestAS);
1611   CSEMap.InsertNode(N, IP);
1612   AllNodes.push_back(N);
1613   return SDValue(N, 0);
1614 }
1615
1616 /// getShiftAmountOperand - Return the specified value casted to
1617 /// the target's desired shift amount type.
1618 SDValue SelectionDAG::getShiftAmountOperand(EVT LHSTy, SDValue Op) {
1619   EVT OpTy = Op.getValueType();
1620   EVT ShTy = TM.getTargetLowering()->getShiftAmountTy(LHSTy);
1621   if (OpTy == ShTy || OpTy.isVector()) return Op;
1622
1623   ISD::NodeType Opcode = OpTy.bitsGT(ShTy) ?  ISD::TRUNCATE : ISD::ZERO_EXTEND;
1624   return getNode(Opcode, SDLoc(Op), ShTy, Op);
1625 }
1626
1627 /// CreateStackTemporary - Create a stack temporary, suitable for holding the
1628 /// specified value type.
1629 SDValue SelectionDAG::CreateStackTemporary(EVT VT, unsigned minAlign) {
1630   MachineFrameInfo *FrameInfo = getMachineFunction().getFrameInfo();
1631   unsigned ByteSize = VT.getStoreSize();
1632   Type *Ty = VT.getTypeForEVT(*getContext());
1633   const TargetLowering *TLI = TM.getTargetLowering();
1634   unsigned StackAlign =
1635   std::max((unsigned)TLI->getDataLayout()->getPrefTypeAlignment(Ty), minAlign);
1636
1637   int FrameIdx = FrameInfo->CreateStackObject(ByteSize, StackAlign, false);
1638   return getFrameIndex(FrameIdx, TLI->getPointerTy());
1639 }
1640
1641 /// CreateStackTemporary - Create a stack temporary suitable for holding
1642 /// either of the specified value types.
1643 SDValue SelectionDAG::CreateStackTemporary(EVT VT1, EVT VT2) {
1644   unsigned Bytes = std::max(VT1.getStoreSizeInBits(),
1645                             VT2.getStoreSizeInBits())/8;
1646   Type *Ty1 = VT1.getTypeForEVT(*getContext());
1647   Type *Ty2 = VT2.getTypeForEVT(*getContext());
1648   const TargetLowering *TLI = TM.getTargetLowering();
1649   const DataLayout *TD = TLI->getDataLayout();
1650   unsigned Align = std::max(TD->getPrefTypeAlignment(Ty1),
1651                             TD->getPrefTypeAlignment(Ty2));
1652
1653   MachineFrameInfo *FrameInfo = getMachineFunction().getFrameInfo();
1654   int FrameIdx = FrameInfo->CreateStackObject(Bytes, Align, false);
1655   return getFrameIndex(FrameIdx, TLI->getPointerTy());
1656 }
1657
1658 SDValue SelectionDAG::FoldSetCC(EVT VT, SDValue N1,
1659                                 SDValue N2, ISD::CondCode Cond, SDLoc dl) {
1660   // These setcc operations always fold.
1661   switch (Cond) {
1662   default: break;
1663   case ISD::SETFALSE:
1664   case ISD::SETFALSE2: return getConstant(0, VT);
1665   case ISD::SETTRUE:
1666   case ISD::SETTRUE2: {
1667     const TargetLowering *TLI = TM.getTargetLowering();
1668     TargetLowering::BooleanContent Cnt = TLI->getBooleanContents(VT.isVector());
1669     return getConstant(
1670         Cnt == TargetLowering::ZeroOrNegativeOneBooleanContent ? -1ULL : 1, VT);
1671   }
1672
1673   case ISD::SETOEQ:
1674   case ISD::SETOGT:
1675   case ISD::SETOGE:
1676   case ISD::SETOLT:
1677   case ISD::SETOLE:
1678   case ISD::SETONE:
1679   case ISD::SETO:
1680   case ISD::SETUO:
1681   case ISD::SETUEQ:
1682   case ISD::SETUNE:
1683     assert(!N1.getValueType().isInteger() && "Illegal setcc for integer!");
1684     break;
1685   }
1686
1687   if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.getNode())) {
1688     const APInt &C2 = N2C->getAPIntValue();
1689     if (ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode())) {
1690       const APInt &C1 = N1C->getAPIntValue();
1691
1692       switch (Cond) {
1693       default: llvm_unreachable("Unknown integer setcc!");
1694       case ISD::SETEQ:  return getConstant(C1 == C2, VT);
1695       case ISD::SETNE:  return getConstant(C1 != C2, VT);
1696       case ISD::SETULT: return getConstant(C1.ult(C2), VT);
1697       case ISD::SETUGT: return getConstant(C1.ugt(C2), VT);
1698       case ISD::SETULE: return getConstant(C1.ule(C2), VT);
1699       case ISD::SETUGE: return getConstant(C1.uge(C2), VT);
1700       case ISD::SETLT:  return getConstant(C1.slt(C2), VT);
1701       case ISD::SETGT:  return getConstant(C1.sgt(C2), VT);
1702       case ISD::SETLE:  return getConstant(C1.sle(C2), VT);
1703       case ISD::SETGE:  return getConstant(C1.sge(C2), VT);
1704       }
1705     }
1706   }
1707   if (ConstantFPSDNode *N1C = dyn_cast<ConstantFPSDNode>(N1.getNode())) {
1708     if (ConstantFPSDNode *N2C = dyn_cast<ConstantFPSDNode>(N2.getNode())) {
1709       APFloat::cmpResult R = N1C->getValueAPF().compare(N2C->getValueAPF());
1710       switch (Cond) {
1711       default: break;
1712       case ISD::SETEQ:  if (R==APFloat::cmpUnordered)
1713                           return getUNDEF(VT);
1714                         // fall through
1715       case ISD::SETOEQ: return getConstant(R==APFloat::cmpEqual, VT);
1716       case ISD::SETNE:  if (R==APFloat::cmpUnordered)
1717                           return getUNDEF(VT);
1718                         // fall through
1719       case ISD::SETONE: return getConstant(R==APFloat::cmpGreaterThan ||
1720                                            R==APFloat::cmpLessThan, VT);
1721       case ISD::SETLT:  if (R==APFloat::cmpUnordered)
1722                           return getUNDEF(VT);
1723                         // fall through
1724       case ISD::SETOLT: return getConstant(R==APFloat::cmpLessThan, VT);
1725       case ISD::SETGT:  if (R==APFloat::cmpUnordered)
1726                           return getUNDEF(VT);
1727                         // fall through
1728       case ISD::SETOGT: return getConstant(R==APFloat::cmpGreaterThan, VT);
1729       case ISD::SETLE:  if (R==APFloat::cmpUnordered)
1730                           return getUNDEF(VT);
1731                         // fall through
1732       case ISD::SETOLE: return getConstant(R==APFloat::cmpLessThan ||
1733                                            R==APFloat::cmpEqual, VT);
1734       case ISD::SETGE:  if (R==APFloat::cmpUnordered)
1735                           return getUNDEF(VT);
1736                         // fall through
1737       case ISD::SETOGE: return getConstant(R==APFloat::cmpGreaterThan ||
1738                                            R==APFloat::cmpEqual, VT);
1739       case ISD::SETO:   return getConstant(R!=APFloat::cmpUnordered, VT);
1740       case ISD::SETUO:  return getConstant(R==APFloat::cmpUnordered, VT);
1741       case ISD::SETUEQ: return getConstant(R==APFloat::cmpUnordered ||
1742                                            R==APFloat::cmpEqual, VT);
1743       case ISD::SETUNE: return getConstant(R!=APFloat::cmpEqual, VT);
1744       case ISD::SETULT: return getConstant(R==APFloat::cmpUnordered ||
1745                                            R==APFloat::cmpLessThan, VT);
1746       case ISD::SETUGT: return getConstant(R==APFloat::cmpGreaterThan ||
1747                                            R==APFloat::cmpUnordered, VT);
1748       case ISD::SETULE: return getConstant(R!=APFloat::cmpGreaterThan, VT);
1749       case ISD::SETUGE: return getConstant(R!=APFloat::cmpLessThan, VT);
1750       }
1751     } else {
1752       // Ensure that the constant occurs on the RHS.
1753       ISD::CondCode SwappedCond = ISD::getSetCCSwappedOperands(Cond);
1754       MVT CompVT = N1.getValueType().getSimpleVT();
1755       if (!TM.getTargetLowering()->isCondCodeLegal(SwappedCond, CompVT))
1756         return SDValue();
1757
1758       return getSetCC(dl, VT, N2, N1, SwappedCond);
1759     }
1760   }
1761
1762   // Could not fold it.
1763   return SDValue();
1764 }
1765
1766 /// SignBitIsZero - Return true if the sign bit of Op is known to be zero.  We
1767 /// use this predicate to simplify operations downstream.
1768 bool SelectionDAG::SignBitIsZero(SDValue Op, unsigned Depth) const {
1769   // This predicate is not safe for vector operations.
1770   if (Op.getValueType().isVector())
1771     return false;
1772
1773   unsigned BitWidth = Op.getValueType().getScalarType().getSizeInBits();
1774   return MaskedValueIsZero(Op, APInt::getSignBit(BitWidth), Depth);
1775 }
1776
1777 /// MaskedValueIsZero - Return true if 'V & Mask' is known to be zero.  We use
1778 /// this predicate to simplify operations downstream.  Mask is known to be zero
1779 /// for bits that V cannot have.
1780 bool SelectionDAG::MaskedValueIsZero(SDValue Op, const APInt &Mask,
1781                                      unsigned Depth) const {
1782   APInt KnownZero, KnownOne;
1783   ComputeMaskedBits(Op, KnownZero, KnownOne, Depth);
1784   assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1785   return (KnownZero & Mask) == Mask;
1786 }
1787
1788 /// ComputeMaskedBits - Determine which of the bits specified in Mask are
1789 /// known to be either zero or one and return them in the KnownZero/KnownOne
1790 /// bitsets.  This code only analyzes bits in Mask, in order to short-circuit
1791 /// processing.
1792 void SelectionDAG::ComputeMaskedBits(SDValue Op, APInt &KnownZero,
1793                                      APInt &KnownOne, unsigned Depth) const {
1794   const TargetLowering *TLI = TM.getTargetLowering();
1795   unsigned BitWidth = Op.getValueType().getScalarType().getSizeInBits();
1796
1797   KnownZero = KnownOne = APInt(BitWidth, 0);   // Don't know anything.
1798   if (Depth == 6)
1799     return;  // Limit search depth.
1800
1801   APInt KnownZero2, KnownOne2;
1802
1803   switch (Op.getOpcode()) {
1804   case ISD::Constant:
1805     // We know all of the bits for a constant!
1806     KnownOne = cast<ConstantSDNode>(Op)->getAPIntValue();
1807     KnownZero = ~KnownOne;
1808     return;
1809   case ISD::AND:
1810     // If either the LHS or the RHS are Zero, the result is zero.
1811     ComputeMaskedBits(Op.getOperand(1), KnownZero, KnownOne, Depth+1);
1812     ComputeMaskedBits(Op.getOperand(0), KnownZero2, KnownOne2, Depth+1);
1813     assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1814     assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
1815
1816     // Output known-1 bits are only known if set in both the LHS & RHS.
1817     KnownOne &= KnownOne2;
1818     // Output known-0 are known to be clear if zero in either the LHS | RHS.
1819     KnownZero |= KnownZero2;
1820     return;
1821   case ISD::OR:
1822     ComputeMaskedBits(Op.getOperand(1), KnownZero, KnownOne, Depth+1);
1823     ComputeMaskedBits(Op.getOperand(0), KnownZero2, KnownOne2, Depth+1);
1824     assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1825     assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
1826
1827     // Output known-0 bits are only known if clear in both the LHS & RHS.
1828     KnownZero &= KnownZero2;
1829     // Output known-1 are known to be set if set in either the LHS | RHS.
1830     KnownOne |= KnownOne2;
1831     return;
1832   case ISD::XOR: {
1833     ComputeMaskedBits(Op.getOperand(1), KnownZero, KnownOne, Depth+1);
1834     ComputeMaskedBits(Op.getOperand(0), KnownZero2, KnownOne2, Depth+1);
1835     assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1836     assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
1837
1838     // Output known-0 bits are known if clear or set in both the LHS & RHS.
1839     APInt KnownZeroOut = (KnownZero & KnownZero2) | (KnownOne & KnownOne2);
1840     // Output known-1 are known to be set if set in only one of the LHS, RHS.
1841     KnownOne = (KnownZero & KnownOne2) | (KnownOne & KnownZero2);
1842     KnownZero = KnownZeroOut;
1843     return;
1844   }
1845   case ISD::MUL: {
1846     ComputeMaskedBits(Op.getOperand(1), KnownZero, KnownOne, Depth+1);
1847     ComputeMaskedBits(Op.getOperand(0), KnownZero2, KnownOne2, Depth+1);
1848     assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1849     assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
1850
1851     // If low bits are zero in either operand, output low known-0 bits.
1852     // Also compute a conserative estimate for high known-0 bits.
1853     // More trickiness is possible, but this is sufficient for the
1854     // interesting case of alignment computation.
1855     KnownOne.clearAllBits();
1856     unsigned TrailZ = KnownZero.countTrailingOnes() +
1857                       KnownZero2.countTrailingOnes();
1858     unsigned LeadZ =  std::max(KnownZero.countLeadingOnes() +
1859                                KnownZero2.countLeadingOnes(),
1860                                BitWidth) - BitWidth;
1861
1862     TrailZ = std::min(TrailZ, BitWidth);
1863     LeadZ = std::min(LeadZ, BitWidth);
1864     KnownZero = APInt::getLowBitsSet(BitWidth, TrailZ) |
1865                 APInt::getHighBitsSet(BitWidth, LeadZ);
1866     return;
1867   }
1868   case ISD::UDIV: {
1869     // For the purposes of computing leading zeros we can conservatively
1870     // treat a udiv as a logical right shift by the power of 2 known to
1871     // be less than the denominator.
1872     ComputeMaskedBits(Op.getOperand(0), KnownZero2, KnownOne2, Depth+1);
1873     unsigned LeadZ = KnownZero2.countLeadingOnes();
1874
1875     KnownOne2.clearAllBits();
1876     KnownZero2.clearAllBits();
1877     ComputeMaskedBits(Op.getOperand(1), KnownZero2, KnownOne2, Depth+1);
1878     unsigned RHSUnknownLeadingOnes = KnownOne2.countLeadingZeros();
1879     if (RHSUnknownLeadingOnes != BitWidth)
1880       LeadZ = std::min(BitWidth,
1881                        LeadZ + BitWidth - RHSUnknownLeadingOnes - 1);
1882
1883     KnownZero = APInt::getHighBitsSet(BitWidth, LeadZ);
1884     return;
1885   }
1886   case ISD::SELECT:
1887     ComputeMaskedBits(Op.getOperand(2), KnownZero, KnownOne, Depth+1);
1888     ComputeMaskedBits(Op.getOperand(1), KnownZero2, KnownOne2, Depth+1);
1889     assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1890     assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
1891
1892     // Only known if known in both the LHS and RHS.
1893     KnownOne &= KnownOne2;
1894     KnownZero &= KnownZero2;
1895     return;
1896   case ISD::SELECT_CC:
1897     ComputeMaskedBits(Op.getOperand(3), KnownZero, KnownOne, Depth+1);
1898     ComputeMaskedBits(Op.getOperand(2), KnownZero2, KnownOne2, Depth+1);
1899     assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1900     assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
1901
1902     // Only known if known in both the LHS and RHS.
1903     KnownOne &= KnownOne2;
1904     KnownZero &= KnownZero2;
1905     return;
1906   case ISD::SADDO:
1907   case ISD::UADDO:
1908   case ISD::SSUBO:
1909   case ISD::USUBO:
1910   case ISD::SMULO:
1911   case ISD::UMULO:
1912     if (Op.getResNo() != 1)
1913       return;
1914     // The boolean result conforms to getBooleanContents.  Fall through.
1915   case ISD::SETCC:
1916     // If we know the result of a setcc has the top bits zero, use this info.
1917     if (TLI->getBooleanContents(Op.getValueType().isVector()) ==
1918         TargetLowering::ZeroOrOneBooleanContent && BitWidth > 1)
1919       KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - 1);
1920     return;
1921   case ISD::SHL:
1922     // (shl X, C1) & C2 == 0   iff   (X & C2 >>u C1) == 0
1923     if (ConstantSDNode *SA = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
1924       unsigned ShAmt = SA->getZExtValue();
1925
1926       // If the shift count is an invalid immediate, don't do anything.
1927       if (ShAmt >= BitWidth)
1928         return;
1929
1930       ComputeMaskedBits(Op.getOperand(0), KnownZero, KnownOne, Depth+1);
1931       assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1932       KnownZero <<= ShAmt;
1933       KnownOne  <<= ShAmt;
1934       // low bits known zero.
1935       KnownZero |= APInt::getLowBitsSet(BitWidth, ShAmt);
1936     }
1937     return;
1938   case ISD::SRL:
1939     // (ushr X, C1) & C2 == 0   iff  (-1 >> C1) & C2 == 0
1940     if (ConstantSDNode *SA = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
1941       unsigned ShAmt = SA->getZExtValue();
1942
1943       // If the shift count is an invalid immediate, don't do anything.
1944       if (ShAmt >= BitWidth)
1945         return;
1946
1947       ComputeMaskedBits(Op.getOperand(0), KnownZero, KnownOne, Depth+1);
1948       assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1949       KnownZero = KnownZero.lshr(ShAmt);
1950       KnownOne  = KnownOne.lshr(ShAmt);
1951
1952       APInt HighBits = APInt::getHighBitsSet(BitWidth, ShAmt);
1953       KnownZero |= HighBits;  // High bits known zero.
1954     }
1955     return;
1956   case ISD::SRA:
1957     if (ConstantSDNode *SA = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
1958       unsigned ShAmt = SA->getZExtValue();
1959
1960       // If the shift count is an invalid immediate, don't do anything.
1961       if (ShAmt >= BitWidth)
1962         return;
1963
1964       // If any of the demanded bits are produced by the sign extension, we also
1965       // demand the input sign bit.
1966       APInt HighBits = APInt::getHighBitsSet(BitWidth, ShAmt);
1967
1968       ComputeMaskedBits(Op.getOperand(0), KnownZero, KnownOne, Depth+1);
1969       assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1970       KnownZero = KnownZero.lshr(ShAmt);
1971       KnownOne  = KnownOne.lshr(ShAmt);
1972
1973       // Handle the sign bits.
1974       APInt SignBit = APInt::getSignBit(BitWidth);
1975       SignBit = SignBit.lshr(ShAmt);  // Adjust to where it is now in the mask.
1976
1977       if (KnownZero.intersects(SignBit)) {
1978         KnownZero |= HighBits;  // New bits are known zero.
1979       } else if (KnownOne.intersects(SignBit)) {
1980         KnownOne  |= HighBits;  // New bits are known one.
1981       }
1982     }
1983     return;
1984   case ISD::SIGN_EXTEND_INREG: {
1985     EVT EVT = cast<VTSDNode>(Op.getOperand(1))->getVT();
1986     unsigned EBits = EVT.getScalarType().getSizeInBits();
1987
1988     // Sign extension.  Compute the demanded bits in the result that are not
1989     // present in the input.
1990     APInt NewBits = APInt::getHighBitsSet(BitWidth, BitWidth - EBits);
1991
1992     APInt InSignBit = APInt::getSignBit(EBits);
1993     APInt InputDemandedBits = APInt::getLowBitsSet(BitWidth, EBits);
1994
1995     // If the sign extended bits are demanded, we know that the sign
1996     // bit is demanded.
1997     InSignBit = InSignBit.zext(BitWidth);
1998     if (NewBits.getBoolValue())
1999       InputDemandedBits |= InSignBit;
2000
2001     ComputeMaskedBits(Op.getOperand(0), KnownZero, KnownOne, Depth+1);
2002     KnownOne &= InputDemandedBits;
2003     KnownZero &= InputDemandedBits;
2004     assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
2005
2006     // If the sign bit of the input is known set or clear, then we know the
2007     // top bits of the result.
2008     if (KnownZero.intersects(InSignBit)) {         // Input sign bit known clear
2009       KnownZero |= NewBits;
2010       KnownOne  &= ~NewBits;
2011     } else if (KnownOne.intersects(InSignBit)) {   // Input sign bit known set
2012       KnownOne  |= NewBits;
2013       KnownZero &= ~NewBits;
2014     } else {                              // Input sign bit unknown
2015       KnownZero &= ~NewBits;
2016       KnownOne  &= ~NewBits;
2017     }
2018     return;
2019   }
2020   case ISD::CTTZ:
2021   case ISD::CTTZ_ZERO_UNDEF:
2022   case ISD::CTLZ:
2023   case ISD::CTLZ_ZERO_UNDEF:
2024   case ISD::CTPOP: {
2025     unsigned LowBits = Log2_32(BitWidth)+1;
2026     KnownZero = APInt::getHighBitsSet(BitWidth, BitWidth - LowBits);
2027     KnownOne.clearAllBits();
2028     return;
2029   }
2030   case ISD::LOAD: {
2031     LoadSDNode *LD = cast<LoadSDNode>(Op);
2032     // If this is a ZEXTLoad and we are looking at the loaded value.
2033     if (ISD::isZEXTLoad(Op.getNode()) && Op.getResNo() == 0) {
2034       EVT VT = LD->getMemoryVT();
2035       unsigned MemBits = VT.getScalarType().getSizeInBits();
2036       KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - MemBits);
2037     } else if (const MDNode *Ranges = LD->getRanges()) {
2038       computeMaskedBitsLoad(*Ranges, KnownZero);
2039     }
2040     return;
2041   }
2042   case ISD::ZERO_EXTEND: {
2043     EVT InVT = Op.getOperand(0).getValueType();
2044     unsigned InBits = InVT.getScalarType().getSizeInBits();
2045     APInt NewBits   = APInt::getHighBitsSet(BitWidth, BitWidth - InBits);
2046     KnownZero = KnownZero.trunc(InBits);
2047     KnownOne = KnownOne.trunc(InBits);
2048     ComputeMaskedBits(Op.getOperand(0), KnownZero, KnownOne, Depth+1);
2049     KnownZero = KnownZero.zext(BitWidth);
2050     KnownOne = KnownOne.zext(BitWidth);
2051     KnownZero |= NewBits;
2052     return;
2053   }
2054   case ISD::SIGN_EXTEND: {
2055     EVT InVT = Op.getOperand(0).getValueType();
2056     unsigned InBits = InVT.getScalarType().getSizeInBits();
2057     APInt NewBits   = APInt::getHighBitsSet(BitWidth, BitWidth - InBits);
2058
2059     KnownZero = KnownZero.trunc(InBits);
2060     KnownOne = KnownOne.trunc(InBits);
2061     ComputeMaskedBits(Op.getOperand(0), KnownZero, KnownOne, Depth+1);
2062
2063     // Note if the sign bit is known to be zero or one.
2064     bool SignBitKnownZero = KnownZero.isNegative();
2065     bool SignBitKnownOne  = KnownOne.isNegative();
2066     assert(!(SignBitKnownZero && SignBitKnownOne) &&
2067            "Sign bit can't be known to be both zero and one!");
2068
2069     KnownZero = KnownZero.zext(BitWidth);
2070     KnownOne = KnownOne.zext(BitWidth);
2071
2072     // If the sign bit is known zero or one, the top bits match.
2073     if (SignBitKnownZero)
2074       KnownZero |= NewBits;
2075     else if (SignBitKnownOne)
2076       KnownOne  |= NewBits;
2077     return;
2078   }
2079   case ISD::ANY_EXTEND: {
2080     EVT InVT = Op.getOperand(0).getValueType();
2081     unsigned InBits = InVT.getScalarType().getSizeInBits();
2082     KnownZero = KnownZero.trunc(InBits);
2083     KnownOne = KnownOne.trunc(InBits);
2084     ComputeMaskedBits(Op.getOperand(0), KnownZero, KnownOne, Depth+1);
2085     KnownZero = KnownZero.zext(BitWidth);
2086     KnownOne = KnownOne.zext(BitWidth);
2087     return;
2088   }
2089   case ISD::TRUNCATE: {
2090     EVT InVT = Op.getOperand(0).getValueType();
2091     unsigned InBits = InVT.getScalarType().getSizeInBits();
2092     KnownZero = KnownZero.zext(InBits);
2093     KnownOne = KnownOne.zext(InBits);
2094     ComputeMaskedBits(Op.getOperand(0), KnownZero, KnownOne, Depth+1);
2095     assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
2096     KnownZero = KnownZero.trunc(BitWidth);
2097     KnownOne = KnownOne.trunc(BitWidth);
2098     break;
2099   }
2100   case ISD::AssertZext: {
2101     EVT VT = cast<VTSDNode>(Op.getOperand(1))->getVT();
2102     APInt InMask = APInt::getLowBitsSet(BitWidth, VT.getSizeInBits());
2103     ComputeMaskedBits(Op.getOperand(0), KnownZero, KnownOne, Depth+1);
2104     KnownZero |= (~InMask);
2105     KnownOne  &= (~KnownZero);
2106     return;
2107   }
2108   case ISD::FGETSIGN:
2109     // All bits are zero except the low bit.
2110     KnownZero = APInt::getHighBitsSet(BitWidth, BitWidth - 1);
2111     return;
2112
2113   case ISD::SUB: {
2114     if (ConstantSDNode *CLHS = dyn_cast<ConstantSDNode>(Op.getOperand(0))) {
2115       // We know that the top bits of C-X are clear if X contains less bits
2116       // than C (i.e. no wrap-around can happen).  For example, 20-X is
2117       // positive if we can prove that X is >= 0 and < 16.
2118       if (CLHS->getAPIntValue().isNonNegative()) {
2119         unsigned NLZ = (CLHS->getAPIntValue()+1).countLeadingZeros();
2120         // NLZ can't be BitWidth with no sign bit
2121         APInt MaskV = APInt::getHighBitsSet(BitWidth, NLZ+1);
2122         ComputeMaskedBits(Op.getOperand(1), KnownZero2, KnownOne2, Depth+1);
2123
2124         // If all of the MaskV bits are known to be zero, then we know the
2125         // output top bits are zero, because we now know that the output is
2126         // from [0-C].
2127         if ((KnownZero2 & MaskV) == MaskV) {
2128           unsigned NLZ2 = CLHS->getAPIntValue().countLeadingZeros();
2129           // Top bits known zero.
2130           KnownZero = APInt::getHighBitsSet(BitWidth, NLZ2);
2131         }
2132       }
2133     }
2134   }
2135   // fall through
2136   case ISD::ADD:
2137   case ISD::ADDE: {
2138     // Output known-0 bits are known if clear or set in both the low clear bits
2139     // common to both LHS & RHS.  For example, 8+(X<<3) is known to have the
2140     // low 3 bits clear.
2141     ComputeMaskedBits(Op.getOperand(0), KnownZero2, KnownOne2, Depth+1);
2142     assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
2143     unsigned KnownZeroOut = KnownZero2.countTrailingOnes();
2144
2145     ComputeMaskedBits(Op.getOperand(1), KnownZero2, KnownOne2, Depth+1);
2146     assert((KnownZero2 & KnownOne2) == 0 && "Bits known to be one AND zero?");
2147     KnownZeroOut = std::min(KnownZeroOut,
2148                             KnownZero2.countTrailingOnes());
2149
2150     if (Op.getOpcode() == ISD::ADD) {
2151       KnownZero |= APInt::getLowBitsSet(BitWidth, KnownZeroOut);
2152       return;
2153     }
2154
2155     // With ADDE, a carry bit may be added in, so we can only use this
2156     // information if we know (at least) that the low two bits are clear.  We
2157     // then return to the caller that the low bit is unknown but that other bits
2158     // are known zero.
2159     if (KnownZeroOut >= 2) // ADDE
2160       KnownZero |= APInt::getBitsSet(BitWidth, 1, KnownZeroOut);
2161     return;
2162   }
2163   case ISD::SREM:
2164     if (ConstantSDNode *Rem = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
2165       const APInt &RA = Rem->getAPIntValue().abs();
2166       if (RA.isPowerOf2()) {
2167         APInt LowBits = RA - 1;
2168         ComputeMaskedBits(Op.getOperand(0), KnownZero2,KnownOne2,Depth+1);
2169
2170         // The low bits of the first operand are unchanged by the srem.
2171         KnownZero = KnownZero2 & LowBits;
2172         KnownOne = KnownOne2 & LowBits;
2173
2174         // If the first operand is non-negative or has all low bits zero, then
2175         // the upper bits are all zero.
2176         if (KnownZero2[BitWidth-1] || ((KnownZero2 & LowBits) == LowBits))
2177           KnownZero |= ~LowBits;
2178
2179         // If the first operand is negative and not all low bits are zero, then
2180         // the upper bits are all one.
2181         if (KnownOne2[BitWidth-1] && ((KnownOne2 & LowBits) != 0))
2182           KnownOne |= ~LowBits;
2183         assert((KnownZero & KnownOne) == 0&&"Bits known to be one AND zero?");
2184       }
2185     }
2186     return;
2187   case ISD::UREM: {
2188     if (ConstantSDNode *Rem = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
2189       const APInt &RA = Rem->getAPIntValue();
2190       if (RA.isPowerOf2()) {
2191         APInt LowBits = (RA - 1);
2192         KnownZero |= ~LowBits;
2193         ComputeMaskedBits(Op.getOperand(0), KnownZero, KnownOne,Depth+1);
2194         assert((KnownZero & KnownOne) == 0&&"Bits known to be one AND zero?");
2195         break;
2196       }
2197     }
2198
2199     // Since the result is less than or equal to either operand, any leading
2200     // zero bits in either operand must also exist in the result.
2201     ComputeMaskedBits(Op.getOperand(0), KnownZero, KnownOne, Depth+1);
2202     ComputeMaskedBits(Op.getOperand(1), KnownZero2, KnownOne2, Depth+1);
2203
2204     uint32_t Leaders = std::max(KnownZero.countLeadingOnes(),
2205                                 KnownZero2.countLeadingOnes());
2206     KnownOne.clearAllBits();
2207     KnownZero = APInt::getHighBitsSet(BitWidth, Leaders);
2208     return;
2209   }
2210   case ISD::FrameIndex:
2211   case ISD::TargetFrameIndex:
2212     if (unsigned Align = InferPtrAlignment(Op)) {
2213       // The low bits are known zero if the pointer is aligned.
2214       KnownZero = APInt::getLowBitsSet(BitWidth, Log2_32(Align));
2215       return;
2216     }
2217     break;
2218
2219   default:
2220     if (Op.getOpcode() < ISD::BUILTIN_OP_END)
2221       break;
2222     // Fallthrough
2223   case ISD::INTRINSIC_WO_CHAIN:
2224   case ISD::INTRINSIC_W_CHAIN:
2225   case ISD::INTRINSIC_VOID:
2226     // Allow the target to implement this method for its nodes.
2227     TLI->computeMaskedBitsForTargetNode(Op, KnownZero, KnownOne, *this, Depth);
2228     return;
2229   }
2230 }
2231
2232 /// ComputeNumSignBits - Return the number of times the sign bit of the
2233 /// register is replicated into the other bits.  We know that at least 1 bit
2234 /// is always equal to the sign bit (itself), but other cases can give us
2235 /// information.  For example, immediately after an "SRA X, 2", we know that
2236 /// the top 3 bits are all equal to each other, so we return 3.
2237 unsigned SelectionDAG::ComputeNumSignBits(SDValue Op, unsigned Depth) const{
2238   const TargetLowering *TLI = TM.getTargetLowering();
2239   EVT VT = Op.getValueType();
2240   assert(VT.isInteger() && "Invalid VT!");
2241   unsigned VTBits = VT.getScalarType().getSizeInBits();
2242   unsigned Tmp, Tmp2;
2243   unsigned FirstAnswer = 1;
2244
2245   if (Depth == 6)
2246     return 1;  // Limit search depth.
2247
2248   switch (Op.getOpcode()) {
2249   default: break;
2250   case ISD::AssertSext:
2251     Tmp = cast<VTSDNode>(Op.getOperand(1))->getVT().getSizeInBits();
2252     return VTBits-Tmp+1;
2253   case ISD::AssertZext:
2254     Tmp = cast<VTSDNode>(Op.getOperand(1))->getVT().getSizeInBits();
2255     return VTBits-Tmp;
2256
2257   case ISD::Constant: {
2258     const APInt &Val = cast<ConstantSDNode>(Op)->getAPIntValue();
2259     return Val.getNumSignBits();
2260   }
2261
2262   case ISD::SIGN_EXTEND:
2263     Tmp =
2264         VTBits-Op.getOperand(0).getValueType().getScalarType().getSizeInBits();
2265     return ComputeNumSignBits(Op.getOperand(0), Depth+1) + Tmp;
2266
2267   case ISD::SIGN_EXTEND_INREG:
2268     // Max of the input and what this extends.
2269     Tmp =
2270       cast<VTSDNode>(Op.getOperand(1))->getVT().getScalarType().getSizeInBits();
2271     Tmp = VTBits-Tmp+1;
2272
2273     Tmp2 = ComputeNumSignBits(Op.getOperand(0), Depth+1);
2274     return std::max(Tmp, Tmp2);
2275
2276   case ISD::SRA:
2277     Tmp = ComputeNumSignBits(Op.getOperand(0), Depth+1);
2278     // SRA X, C   -> adds C sign bits.
2279     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
2280       Tmp += C->getZExtValue();
2281       if (Tmp > VTBits) Tmp = VTBits;
2282     }
2283     return Tmp;
2284   case ISD::SHL:
2285     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
2286       // shl destroys sign bits.
2287       Tmp = ComputeNumSignBits(Op.getOperand(0), Depth+1);
2288       if (C->getZExtValue() >= VTBits ||      // Bad shift.
2289           C->getZExtValue() >= Tmp) break;    // Shifted all sign bits out.
2290       return Tmp - C->getZExtValue();
2291     }
2292     break;
2293   case ISD::AND:
2294   case ISD::OR:
2295   case ISD::XOR:    // NOT is handled here.
2296     // Logical binary ops preserve the number of sign bits at the worst.
2297     Tmp = ComputeNumSignBits(Op.getOperand(0), Depth+1);
2298     if (Tmp != 1) {
2299       Tmp2 = ComputeNumSignBits(Op.getOperand(1), Depth+1);
2300       FirstAnswer = std::min(Tmp, Tmp2);
2301       // We computed what we know about the sign bits as our first
2302       // answer. Now proceed to the generic code that uses
2303       // ComputeMaskedBits, and pick whichever answer is better.
2304     }
2305     break;
2306
2307   case ISD::SELECT:
2308     Tmp = ComputeNumSignBits(Op.getOperand(1), Depth+1);
2309     if (Tmp == 1) return 1;  // Early out.
2310     Tmp2 = ComputeNumSignBits(Op.getOperand(2), Depth+1);
2311     return std::min(Tmp, Tmp2);
2312
2313   case ISD::SADDO:
2314   case ISD::UADDO:
2315   case ISD::SSUBO:
2316   case ISD::USUBO:
2317   case ISD::SMULO:
2318   case ISD::UMULO:
2319     if (Op.getResNo() != 1)
2320       break;
2321     // The boolean result conforms to getBooleanContents.  Fall through.
2322   case ISD::SETCC:
2323     // If setcc returns 0/-1, all bits are sign bits.
2324     if (TLI->getBooleanContents(Op.getValueType().isVector()) ==
2325         TargetLowering::ZeroOrNegativeOneBooleanContent)
2326       return VTBits;
2327     break;
2328   case ISD::ROTL:
2329   case ISD::ROTR:
2330     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1))) {
2331       unsigned RotAmt = C->getZExtValue() & (VTBits-1);
2332
2333       // Handle rotate right by N like a rotate left by 32-N.
2334       if (Op.getOpcode() == ISD::ROTR)
2335         RotAmt = (VTBits-RotAmt) & (VTBits-1);
2336
2337       // If we aren't rotating out all of the known-in sign bits, return the
2338       // number that are left.  This handles rotl(sext(x), 1) for example.
2339       Tmp = ComputeNumSignBits(Op.getOperand(0), Depth+1);
2340       if (Tmp > RotAmt+1) return Tmp-RotAmt;
2341     }
2342     break;
2343   case ISD::ADD:
2344     // Add can have at most one carry bit.  Thus we know that the output
2345     // is, at worst, one more bit than the inputs.
2346     Tmp = ComputeNumSignBits(Op.getOperand(0), Depth+1);
2347     if (Tmp == 1) return 1;  // Early out.
2348
2349     // Special case decrementing a value (ADD X, -1):
2350     if (ConstantSDNode *CRHS = dyn_cast<ConstantSDNode>(Op.getOperand(1)))
2351       if (CRHS->isAllOnesValue()) {
2352         APInt KnownZero, KnownOne;
2353         ComputeMaskedBits(Op.getOperand(0), KnownZero, KnownOne, Depth+1);
2354
2355         // If the input is known to be 0 or 1, the output is 0/-1, which is all
2356         // sign bits set.
2357         if ((KnownZero | APInt(VTBits, 1)).isAllOnesValue())
2358           return VTBits;
2359
2360         // If we are subtracting one from a positive number, there is no carry
2361         // out of the result.
2362         if (KnownZero.isNegative())
2363           return Tmp;
2364       }
2365
2366     Tmp2 = ComputeNumSignBits(Op.getOperand(1), Depth+1);
2367     if (Tmp2 == 1) return 1;
2368     return std::min(Tmp, Tmp2)-1;
2369
2370   case ISD::SUB:
2371     Tmp2 = ComputeNumSignBits(Op.getOperand(1), Depth+1);
2372     if (Tmp2 == 1) return 1;
2373
2374     // Handle NEG.
2375     if (ConstantSDNode *CLHS = dyn_cast<ConstantSDNode>(Op.getOperand(0)))
2376       if (CLHS->isNullValue()) {
2377         APInt KnownZero, KnownOne;
2378         ComputeMaskedBits(Op.getOperand(1), KnownZero, KnownOne, Depth+1);
2379         // If the input is known to be 0 or 1, the output is 0/-1, which is all
2380         // sign bits set.
2381         if ((KnownZero | APInt(VTBits, 1)).isAllOnesValue())
2382           return VTBits;
2383
2384         // If the input is known to be positive (the sign bit is known clear),
2385         // the output of the NEG has the same number of sign bits as the input.
2386         if (KnownZero.isNegative())
2387           return Tmp2;
2388
2389         // Otherwise, we treat this like a SUB.
2390       }
2391
2392     // Sub can have at most one carry bit.  Thus we know that the output
2393     // is, at worst, one more bit than the inputs.
2394     Tmp = ComputeNumSignBits(Op.getOperand(0), Depth+1);
2395     if (Tmp == 1) return 1;  // Early out.
2396     return std::min(Tmp, Tmp2)-1;
2397   case ISD::TRUNCATE:
2398     // FIXME: it's tricky to do anything useful for this, but it is an important
2399     // case for targets like X86.
2400     break;
2401   }
2402
2403   // If we are looking at the loaded value of the SDNode.
2404   if (Op.getResNo() == 0) {
2405     // Handle LOADX separately here. EXTLOAD case will fallthrough.
2406     if (LoadSDNode *LD = dyn_cast<LoadSDNode>(Op)) {
2407       unsigned ExtType = LD->getExtensionType();
2408       switch (ExtType) {
2409         default: break;
2410         case ISD::SEXTLOAD:    // '17' bits known
2411           Tmp = LD->getMemoryVT().getScalarType().getSizeInBits();
2412           return VTBits-Tmp+1;
2413         case ISD::ZEXTLOAD:    // '16' bits known
2414           Tmp = LD->getMemoryVT().getScalarType().getSizeInBits();
2415           return VTBits-Tmp;
2416       }
2417     }
2418   }
2419
2420   // Allow the target to implement this method for its nodes.
2421   if (Op.getOpcode() >= ISD::BUILTIN_OP_END ||
2422       Op.getOpcode() == ISD::INTRINSIC_WO_CHAIN ||
2423       Op.getOpcode() == ISD::INTRINSIC_W_CHAIN ||
2424       Op.getOpcode() == ISD::INTRINSIC_VOID) {
2425     unsigned NumBits = TLI->ComputeNumSignBitsForTargetNode(Op, Depth);
2426     if (NumBits > 1) FirstAnswer = std::max(FirstAnswer, NumBits);
2427   }
2428
2429   // Finally, if we can prove that the top bits of the result are 0's or 1's,
2430   // use this information.
2431   APInt KnownZero, KnownOne;
2432   ComputeMaskedBits(Op, KnownZero, KnownOne, Depth);
2433
2434   APInt Mask;
2435   if (KnownZero.isNegative()) {        // sign bit is 0
2436     Mask = KnownZero;
2437   } else if (KnownOne.isNegative()) {  // sign bit is 1;
2438     Mask = KnownOne;
2439   } else {
2440     // Nothing known.
2441     return FirstAnswer;
2442   }
2443
2444   // Okay, we know that the sign bit in Mask is set.  Use CLZ to determine
2445   // the number of identical bits in the top of the input value.
2446   Mask = ~Mask;
2447   Mask <<= Mask.getBitWidth()-VTBits;
2448   // Return # leading zeros.  We use 'min' here in case Val was zero before
2449   // shifting.  We don't want to return '64' as for an i32 "0".
2450   return std::max(FirstAnswer, std::min(VTBits, Mask.countLeadingZeros()));
2451 }
2452
2453 /// isBaseWithConstantOffset - Return true if the specified operand is an
2454 /// ISD::ADD with a ConstantSDNode on the right-hand side, or if it is an
2455 /// ISD::OR with a ConstantSDNode that is guaranteed to have the same
2456 /// semantics as an ADD.  This handles the equivalence:
2457 ///     X|Cst == X+Cst iff X&Cst = 0.
2458 bool SelectionDAG::isBaseWithConstantOffset(SDValue Op) const {
2459   if ((Op.getOpcode() != ISD::ADD && Op.getOpcode() != ISD::OR) ||
2460       !isa<ConstantSDNode>(Op.getOperand(1)))
2461     return false;
2462
2463   if (Op.getOpcode() == ISD::OR &&
2464       !MaskedValueIsZero(Op.getOperand(0),
2465                      cast<ConstantSDNode>(Op.getOperand(1))->getAPIntValue()))
2466     return false;
2467
2468   return true;
2469 }
2470
2471
2472 bool SelectionDAG::isKnownNeverNaN(SDValue Op) const {
2473   // If we're told that NaNs won't happen, assume they won't.
2474   if (getTarget().Options.NoNaNsFPMath)
2475     return true;
2476
2477   // If the value is a constant, we can obviously see if it is a NaN or not.
2478   if (const ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(Op))
2479     return !C->getValueAPF().isNaN();
2480
2481   // TODO: Recognize more cases here.
2482
2483   return false;
2484 }
2485
2486 bool SelectionDAG::isKnownNeverZero(SDValue Op) const {
2487   // If the value is a constant, we can obviously see if it is a zero or not.
2488   if (const ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(Op))
2489     return !C->isZero();
2490
2491   // TODO: Recognize more cases here.
2492   switch (Op.getOpcode()) {
2493   default: break;
2494   case ISD::OR:
2495     if (const ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op.getOperand(1)))
2496       return !C->isNullValue();
2497     break;
2498   }
2499
2500   return false;
2501 }
2502
2503 bool SelectionDAG::isEqualTo(SDValue A, SDValue B) const {
2504   // Check the obvious case.
2505   if (A == B) return true;
2506
2507   // For for negative and positive zero.
2508   if (const ConstantFPSDNode *CA = dyn_cast<ConstantFPSDNode>(A))
2509     if (const ConstantFPSDNode *CB = dyn_cast<ConstantFPSDNode>(B))
2510       if (CA->isZero() && CB->isZero()) return true;
2511
2512   // Otherwise they may not be equal.
2513   return false;
2514 }
2515
2516 /// getNode - Gets or creates the specified node.
2517 ///
2518 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT) {
2519   FoldingSetNodeID ID;
2520   AddNodeIDNode(ID, Opcode, getVTList(VT), 0, 0);
2521   void *IP = 0;
2522   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
2523     return SDValue(E, 0);
2524
2525   SDNode *N = new (NodeAllocator) SDNode(Opcode, DL.getIROrder(),
2526                                          DL.getDebugLoc(), getVTList(VT));
2527   CSEMap.InsertNode(N, IP);
2528
2529   AllNodes.push_back(N);
2530 #ifndef NDEBUG
2531   VerifySDNode(N);
2532 #endif
2533   return SDValue(N, 0);
2534 }
2535
2536 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL,
2537                               EVT VT, SDValue Operand) {
2538   // Constant fold unary operations with an integer constant operand.
2539   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Operand.getNode())) {
2540     const APInt &Val = C->getAPIntValue();
2541     switch (Opcode) {
2542     default: break;
2543     case ISD::SIGN_EXTEND:
2544       return getConstant(Val.sextOrTrunc(VT.getSizeInBits()), VT,
2545                          C->isTargetOpcode(), C->isOpaque());
2546     case ISD::ANY_EXTEND:
2547     case ISD::ZERO_EXTEND:
2548     case ISD::TRUNCATE:
2549       return getConstant(Val.zextOrTrunc(VT.getSizeInBits()), VT,
2550                          C->isTargetOpcode(), C->isOpaque());
2551     case ISD::UINT_TO_FP:
2552     case ISD::SINT_TO_FP: {
2553       APFloat apf(EVTToAPFloatSemantics(VT),
2554                   APInt::getNullValue(VT.getSizeInBits()));
2555       (void)apf.convertFromAPInt(Val,
2556                                  Opcode==ISD::SINT_TO_FP,
2557                                  APFloat::rmNearestTiesToEven);
2558       return getConstantFP(apf, VT);
2559     }
2560     case ISD::BITCAST:
2561       if (VT == MVT::f32 && C->getValueType(0) == MVT::i32)
2562         return getConstantFP(APFloat(APFloat::IEEEsingle, Val), VT);
2563       else if (VT == MVT::f64 && C->getValueType(0) == MVT::i64)
2564         return getConstantFP(APFloat(APFloat::IEEEdouble, Val), VT);
2565       break;
2566     case ISD::BSWAP:
2567       return getConstant(Val.byteSwap(), VT, C->isTargetOpcode(),
2568                          C->isOpaque());
2569     case ISD::CTPOP:
2570       return getConstant(Val.countPopulation(), VT, C->isTargetOpcode(),
2571                          C->isOpaque());
2572     case ISD::CTLZ:
2573     case ISD::CTLZ_ZERO_UNDEF:
2574       return getConstant(Val.countLeadingZeros(), VT, C->isTargetOpcode(),
2575                          C->isOpaque());
2576     case ISD::CTTZ:
2577     case ISD::CTTZ_ZERO_UNDEF:
2578       return getConstant(Val.countTrailingZeros(), VT, C->isTargetOpcode(),
2579                          C->isOpaque());
2580     }
2581   }
2582
2583   // Constant fold unary operations with a floating point constant operand.
2584   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(Operand.getNode())) {
2585     APFloat V = C->getValueAPF();    // make copy
2586     switch (Opcode) {
2587     case ISD::FNEG:
2588       V.changeSign();
2589       return getConstantFP(V, VT);
2590     case ISD::FABS:
2591       V.clearSign();
2592       return getConstantFP(V, VT);
2593     case ISD::FCEIL: {
2594       APFloat::opStatus fs = V.roundToIntegral(APFloat::rmTowardPositive);
2595       if (fs == APFloat::opOK || fs == APFloat::opInexact)
2596         return getConstantFP(V, VT);
2597       break;
2598     }
2599     case ISD::FTRUNC: {
2600       APFloat::opStatus fs = V.roundToIntegral(APFloat::rmTowardZero);
2601       if (fs == APFloat::opOK || fs == APFloat::opInexact)
2602         return getConstantFP(V, VT);
2603       break;
2604     }
2605     case ISD::FFLOOR: {
2606       APFloat::opStatus fs = V.roundToIntegral(APFloat::rmTowardNegative);
2607       if (fs == APFloat::opOK || fs == APFloat::opInexact)
2608         return getConstantFP(V, VT);
2609       break;
2610     }
2611     case ISD::FP_EXTEND: {
2612       bool ignored;
2613       // This can return overflow, underflow, or inexact; we don't care.
2614       // FIXME need to be more flexible about rounding mode.
2615       (void)V.convert(EVTToAPFloatSemantics(VT),
2616                       APFloat::rmNearestTiesToEven, &ignored);
2617       return getConstantFP(V, VT);
2618     }
2619     case ISD::FP_TO_SINT:
2620     case ISD::FP_TO_UINT: {
2621       integerPart x[2];
2622       bool ignored;
2623       assert(integerPartWidth >= 64);
2624       // FIXME need to be more flexible about rounding mode.
2625       APFloat::opStatus s = V.convertToInteger(x, VT.getSizeInBits(),
2626                             Opcode==ISD::FP_TO_SINT,
2627                             APFloat::rmTowardZero, &ignored);
2628       if (s==APFloat::opInvalidOp)     // inexact is OK, in fact usual
2629         break;
2630       APInt api(VT.getSizeInBits(), x);
2631       return getConstant(api, VT);
2632     }
2633     case ISD::BITCAST:
2634       if (VT == MVT::i32 && C->getValueType(0) == MVT::f32)
2635         return getConstant((uint32_t)V.bitcastToAPInt().getZExtValue(), VT);
2636       else if (VT == MVT::i64 && C->getValueType(0) == MVT::f64)
2637         return getConstant(V.bitcastToAPInt().getZExtValue(), VT);
2638       break;
2639     }
2640   }
2641
2642   unsigned OpOpcode = Operand.getNode()->getOpcode();
2643   switch (Opcode) {
2644   case ISD::TokenFactor:
2645   case ISD::MERGE_VALUES:
2646   case ISD::CONCAT_VECTORS:
2647     return Operand;         // Factor, merge or concat of one node?  No need.
2648   case ISD::FP_ROUND: llvm_unreachable("Invalid method to make FP_ROUND node");
2649   case ISD::FP_EXTEND:
2650     assert(VT.isFloatingPoint() &&
2651            Operand.getValueType().isFloatingPoint() && "Invalid FP cast!");
2652     if (Operand.getValueType() == VT) return Operand;  // noop conversion.
2653     assert((!VT.isVector() ||
2654             VT.getVectorNumElements() ==
2655             Operand.getValueType().getVectorNumElements()) &&
2656            "Vector element count mismatch!");
2657     if (Operand.getOpcode() == ISD::UNDEF)
2658       return getUNDEF(VT);
2659     break;
2660   case ISD::SIGN_EXTEND:
2661     assert(VT.isInteger() && Operand.getValueType().isInteger() &&
2662            "Invalid SIGN_EXTEND!");
2663     if (Operand.getValueType() == VT) return Operand;   // noop extension
2664     assert(Operand.getValueType().getScalarType().bitsLT(VT.getScalarType()) &&
2665            "Invalid sext node, dst < src!");
2666     assert((!VT.isVector() ||
2667             VT.getVectorNumElements() ==
2668             Operand.getValueType().getVectorNumElements()) &&
2669            "Vector element count mismatch!");
2670     if (OpOpcode == ISD::SIGN_EXTEND || OpOpcode == ISD::ZERO_EXTEND)
2671       return getNode(OpOpcode, DL, VT, Operand.getNode()->getOperand(0));
2672     else if (OpOpcode == ISD::UNDEF)
2673       // sext(undef) = 0, because the top bits will all be the same.
2674       return getConstant(0, VT);
2675     break;
2676   case ISD::ZERO_EXTEND:
2677     assert(VT.isInteger() && Operand.getValueType().isInteger() &&
2678            "Invalid ZERO_EXTEND!");
2679     if (Operand.getValueType() == VT) return Operand;   // noop extension
2680     assert(Operand.getValueType().getScalarType().bitsLT(VT.getScalarType()) &&
2681            "Invalid zext node, dst < src!");
2682     assert((!VT.isVector() ||
2683             VT.getVectorNumElements() ==
2684             Operand.getValueType().getVectorNumElements()) &&
2685            "Vector element count mismatch!");
2686     if (OpOpcode == ISD::ZERO_EXTEND)   // (zext (zext x)) -> (zext x)
2687       return getNode(ISD::ZERO_EXTEND, DL, VT,
2688                      Operand.getNode()->getOperand(0));
2689     else if (OpOpcode == ISD::UNDEF)
2690       // zext(undef) = 0, because the top bits will be zero.
2691       return getConstant(0, VT);
2692     break;
2693   case ISD::ANY_EXTEND:
2694     assert(VT.isInteger() && Operand.getValueType().isInteger() &&
2695            "Invalid ANY_EXTEND!");
2696     if (Operand.getValueType() == VT) return Operand;   // noop extension
2697     assert(Operand.getValueType().getScalarType().bitsLT(VT.getScalarType()) &&
2698            "Invalid anyext node, dst < src!");
2699     assert((!VT.isVector() ||
2700             VT.getVectorNumElements() ==
2701             Operand.getValueType().getVectorNumElements()) &&
2702            "Vector element count mismatch!");
2703
2704     if (OpOpcode == ISD::ZERO_EXTEND || OpOpcode == ISD::SIGN_EXTEND ||
2705         OpOpcode == ISD::ANY_EXTEND)
2706       // (ext (zext x)) -> (zext x)  and  (ext (sext x)) -> (sext x)
2707       return getNode(OpOpcode, DL, VT, Operand.getNode()->getOperand(0));
2708     else if (OpOpcode == ISD::UNDEF)
2709       return getUNDEF(VT);
2710
2711     // (ext (trunx x)) -> x
2712     if (OpOpcode == ISD::TRUNCATE) {
2713       SDValue OpOp = Operand.getNode()->getOperand(0);
2714       if (OpOp.getValueType() == VT)
2715         return OpOp;
2716     }
2717     break;
2718   case ISD::TRUNCATE:
2719     assert(VT.isInteger() && Operand.getValueType().isInteger() &&
2720            "Invalid TRUNCATE!");
2721     if (Operand.getValueType() == VT) return Operand;   // noop truncate
2722     assert(Operand.getValueType().getScalarType().bitsGT(VT.getScalarType()) &&
2723            "Invalid truncate node, src < dst!");
2724     assert((!VT.isVector() ||
2725             VT.getVectorNumElements() ==
2726             Operand.getValueType().getVectorNumElements()) &&
2727            "Vector element count mismatch!");
2728     if (OpOpcode == ISD::TRUNCATE)
2729       return getNode(ISD::TRUNCATE, DL, VT, Operand.getNode()->getOperand(0));
2730     if (OpOpcode == ISD::ZERO_EXTEND || OpOpcode == ISD::SIGN_EXTEND ||
2731         OpOpcode == ISD::ANY_EXTEND) {
2732       // If the source is smaller than the dest, we still need an extend.
2733       if (Operand.getNode()->getOperand(0).getValueType().getScalarType()
2734             .bitsLT(VT.getScalarType()))
2735         return getNode(OpOpcode, DL, VT, Operand.getNode()->getOperand(0));
2736       if (Operand.getNode()->getOperand(0).getValueType().bitsGT(VT))
2737         return getNode(ISD::TRUNCATE, DL, VT, Operand.getNode()->getOperand(0));
2738       return Operand.getNode()->getOperand(0);
2739     }
2740     if (OpOpcode == ISD::UNDEF)
2741       return getUNDEF(VT);
2742     break;
2743   case ISD::BITCAST:
2744     // Basic sanity checking.
2745     assert(VT.getSizeInBits() == Operand.getValueType().getSizeInBits()
2746            && "Cannot BITCAST between types of different sizes!");
2747     if (VT == Operand.getValueType()) return Operand;  // noop conversion.
2748     if (OpOpcode == ISD::BITCAST)  // bitconv(bitconv(x)) -> bitconv(x)
2749       return getNode(ISD::BITCAST, DL, VT, Operand.getOperand(0));
2750     if (OpOpcode == ISD::UNDEF)
2751       return getUNDEF(VT);
2752     break;
2753   case ISD::SCALAR_TO_VECTOR:
2754     assert(VT.isVector() && !Operand.getValueType().isVector() &&
2755            (VT.getVectorElementType() == Operand.getValueType() ||
2756             (VT.getVectorElementType().isInteger() &&
2757              Operand.getValueType().isInteger() &&
2758              VT.getVectorElementType().bitsLE(Operand.getValueType()))) &&
2759            "Illegal SCALAR_TO_VECTOR node!");
2760     if (OpOpcode == ISD::UNDEF)
2761       return getUNDEF(VT);
2762     // scalar_to_vector(extract_vector_elt V, 0) -> V, top bits are undefined.
2763     if (OpOpcode == ISD::EXTRACT_VECTOR_ELT &&
2764         isa<ConstantSDNode>(Operand.getOperand(1)) &&
2765         Operand.getConstantOperandVal(1) == 0 &&
2766         Operand.getOperand(0).getValueType() == VT)
2767       return Operand.getOperand(0);
2768     break;
2769   case ISD::FNEG:
2770     // -(X-Y) -> (Y-X) is unsafe because when X==Y, -0.0 != +0.0
2771     if (getTarget().Options.UnsafeFPMath && OpOpcode == ISD::FSUB)
2772       return getNode(ISD::FSUB, DL, VT, Operand.getNode()->getOperand(1),
2773                      Operand.getNode()->getOperand(0));
2774     if (OpOpcode == ISD::FNEG)  // --X -> X
2775       return Operand.getNode()->getOperand(0);
2776     break;
2777   case ISD::FABS:
2778     if (OpOpcode == ISD::FNEG)  // abs(-X) -> abs(X)
2779       return getNode(ISD::FABS, DL, VT, Operand.getNode()->getOperand(0));
2780     break;
2781   }
2782
2783   SDNode *N;
2784   SDVTList VTs = getVTList(VT);
2785   if (VT != MVT::Glue) { // Don't CSE flag producing nodes
2786     FoldingSetNodeID ID;
2787     SDValue Ops[1] = { Operand };
2788     AddNodeIDNode(ID, Opcode, VTs, Ops, 1);
2789     void *IP = 0;
2790     if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
2791       return SDValue(E, 0);
2792
2793     N = new (NodeAllocator) UnarySDNode(Opcode, DL.getIROrder(),
2794                                         DL.getDebugLoc(), VTs, Operand);
2795     CSEMap.InsertNode(N, IP);
2796   } else {
2797     N = new (NodeAllocator) UnarySDNode(Opcode, DL.getIROrder(),
2798                                         DL.getDebugLoc(), VTs, Operand);
2799   }
2800
2801   AllNodes.push_back(N);
2802 #ifndef NDEBUG
2803   VerifySDNode(N);
2804 #endif
2805   return SDValue(N, 0);
2806 }
2807
2808 SDValue SelectionDAG::FoldConstantArithmetic(unsigned Opcode, EVT VT,
2809                                              SDNode *Cst1, SDNode *Cst2) {
2810   SmallVector<std::pair<ConstantSDNode *, ConstantSDNode *>, 4> Inputs;
2811   SmallVector<SDValue, 4> Outputs;
2812   EVT SVT = VT.getScalarType();
2813
2814   ConstantSDNode *Scalar1 = dyn_cast<ConstantSDNode>(Cst1);
2815   ConstantSDNode *Scalar2 = dyn_cast<ConstantSDNode>(Cst2);
2816   if (Scalar1 && Scalar2 && (Scalar1->isOpaque() || Scalar2->isOpaque()))
2817     return SDValue();
2818
2819   if (Scalar1 && Scalar2)
2820     // Scalar instruction.
2821     Inputs.push_back(std::make_pair(Scalar1, Scalar2));
2822   else {
2823     // For vectors extract each constant element into Inputs so we can constant
2824     // fold them individually.
2825     BuildVectorSDNode *BV1 = dyn_cast<BuildVectorSDNode>(Cst1);
2826     BuildVectorSDNode *BV2 = dyn_cast<BuildVectorSDNode>(Cst2);
2827     if (!BV1 || !BV2)
2828       return SDValue();
2829
2830     assert(BV1->getNumOperands() == BV2->getNumOperands() && "Out of sync!");
2831
2832     for (unsigned I = 0, E = BV1->getNumOperands(); I != E; ++I) {
2833       ConstantSDNode *V1 = dyn_cast<ConstantSDNode>(BV1->getOperand(I));
2834       ConstantSDNode *V2 = dyn_cast<ConstantSDNode>(BV2->getOperand(I));
2835       if (!V1 || !V2) // Not a constant, bail.
2836         return SDValue();
2837
2838       if (V1->isOpaque() || V2->isOpaque())
2839         return SDValue();
2840
2841       // Avoid BUILD_VECTOR nodes that perform implicit truncation.
2842       // FIXME: This is valid and could be handled by truncating the APInts.
2843       if (V1->getValueType(0) != SVT || V2->getValueType(0) != SVT)
2844         return SDValue();
2845
2846       Inputs.push_back(std::make_pair(V1, V2));
2847     }
2848   }
2849
2850   // We have a number of constant values, constant fold them element by element.
2851   for (unsigned I = 0, E = Inputs.size(); I != E; ++I) {
2852     const APInt &C1 = Inputs[I].first->getAPIntValue();
2853     const APInt &C2 = Inputs[I].second->getAPIntValue();
2854
2855     switch (Opcode) {
2856     case ISD::ADD:
2857       Outputs.push_back(getConstant(C1 + C2, SVT));
2858       break;
2859     case ISD::SUB:
2860       Outputs.push_back(getConstant(C1 - C2, SVT));
2861       break;
2862     case ISD::MUL:
2863       Outputs.push_back(getConstant(C1 * C2, SVT));
2864       break;
2865     case ISD::UDIV:
2866       if (!C2.getBoolValue())
2867         return SDValue();
2868       Outputs.push_back(getConstant(C1.udiv(C2), SVT));
2869       break;
2870     case ISD::UREM:
2871       if (!C2.getBoolValue())
2872         return SDValue();
2873       Outputs.push_back(getConstant(C1.urem(C2), SVT));
2874       break;
2875     case ISD::SDIV:
2876       if (!C2.getBoolValue())
2877         return SDValue();
2878       Outputs.push_back(getConstant(C1.sdiv(C2), SVT));
2879       break;
2880     case ISD::SREM:
2881       if (!C2.getBoolValue())
2882         return SDValue();
2883       Outputs.push_back(getConstant(C1.srem(C2), SVT));
2884       break;
2885     case ISD::AND:
2886       Outputs.push_back(getConstant(C1 & C2, SVT));
2887       break;
2888     case ISD::OR:
2889       Outputs.push_back(getConstant(C1 | C2, SVT));
2890       break;
2891     case ISD::XOR:
2892       Outputs.push_back(getConstant(C1 ^ C2, SVT));
2893       break;
2894     case ISD::SHL:
2895       Outputs.push_back(getConstant(C1 << C2, SVT));
2896       break;
2897     case ISD::SRL:
2898       Outputs.push_back(getConstant(C1.lshr(C2), SVT));
2899       break;
2900     case ISD::SRA:
2901       Outputs.push_back(getConstant(C1.ashr(C2), SVT));
2902       break;
2903     case ISD::ROTL:
2904       Outputs.push_back(getConstant(C1.rotl(C2), SVT));
2905       break;
2906     case ISD::ROTR:
2907       Outputs.push_back(getConstant(C1.rotr(C2), SVT));
2908       break;
2909     default:
2910       return SDValue();
2911     }
2912   }
2913
2914   // Handle the scalar case first.
2915   if (Scalar1 && Scalar2)
2916     return Outputs.back();
2917
2918   // Otherwise build a big vector out of the scalar elements we generated.
2919   return getNode(ISD::BUILD_VECTOR, SDLoc(), VT, Outputs.data(),
2920                  Outputs.size());
2921 }
2922
2923 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT, SDValue N1,
2924                               SDValue N2) {
2925   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
2926   ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.getNode());
2927   switch (Opcode) {
2928   default: break;
2929   case ISD::TokenFactor:
2930     assert(VT == MVT::Other && N1.getValueType() == MVT::Other &&
2931            N2.getValueType() == MVT::Other && "Invalid token factor!");
2932     // Fold trivial token factors.
2933     if (N1.getOpcode() == ISD::EntryToken) return N2;
2934     if (N2.getOpcode() == ISD::EntryToken) return N1;
2935     if (N1 == N2) return N1;
2936     break;
2937   case ISD::CONCAT_VECTORS:
2938     // Concat of UNDEFs is UNDEF.
2939     if (N1.getOpcode() == ISD::UNDEF &&
2940         N2.getOpcode() == ISD::UNDEF)
2941       return getUNDEF(VT);
2942
2943     // A CONCAT_VECTOR with all operands BUILD_VECTOR can be simplified to
2944     // one big BUILD_VECTOR.
2945     if (N1.getOpcode() == ISD::BUILD_VECTOR &&
2946         N2.getOpcode() == ISD::BUILD_VECTOR) {
2947       SmallVector<SDValue, 16> Elts(N1.getNode()->op_begin(),
2948                                     N1.getNode()->op_end());
2949       Elts.append(N2.getNode()->op_begin(), N2.getNode()->op_end());
2950       return getNode(ISD::BUILD_VECTOR, DL, VT, &Elts[0], Elts.size());
2951     }
2952     break;
2953   case ISD::AND:
2954     assert(VT.isInteger() && "This operator does not apply to FP types!");
2955     assert(N1.getValueType() == N2.getValueType() &&
2956            N1.getValueType() == VT && "Binary operator types must match!");
2957     // (X & 0) -> 0.  This commonly occurs when legalizing i64 values, so it's
2958     // worth handling here.
2959     if (N2C && N2C->isNullValue())
2960       return N2;
2961     if (N2C && N2C->isAllOnesValue())  // X & -1 -> X
2962       return N1;
2963     break;
2964   case ISD::OR:
2965   case ISD::XOR:
2966   case ISD::ADD:
2967   case ISD::SUB:
2968     assert(VT.isInteger() && "This operator does not apply to FP types!");
2969     assert(N1.getValueType() == N2.getValueType() &&
2970            N1.getValueType() == VT && "Binary operator types must match!");
2971     // (X ^|+- 0) -> X.  This commonly occurs when legalizing i64 values, so
2972     // it's worth handling here.
2973     if (N2C && N2C->isNullValue())
2974       return N1;
2975     break;
2976   case ISD::UDIV:
2977   case ISD::UREM:
2978   case ISD::MULHU:
2979   case ISD::MULHS:
2980   case ISD::MUL:
2981   case ISD::SDIV:
2982   case ISD::SREM:
2983     assert(VT.isInteger() && "This operator does not apply to FP types!");
2984     assert(N1.getValueType() == N2.getValueType() &&
2985            N1.getValueType() == VT && "Binary operator types must match!");
2986     break;
2987   case ISD::FADD:
2988   case ISD::FSUB:
2989   case ISD::FMUL:
2990   case ISD::FDIV:
2991   case ISD::FREM:
2992     if (getTarget().Options.UnsafeFPMath) {
2993       if (Opcode == ISD::FADD) {
2994         // 0+x --> x
2995         if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(N1))
2996           if (CFP->getValueAPF().isZero())
2997             return N2;
2998         // x+0 --> x
2999         if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(N2))
3000           if (CFP->getValueAPF().isZero())
3001             return N1;
3002       } else if (Opcode == ISD::FSUB) {
3003         // x-0 --> x
3004         if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(N2))
3005           if (CFP->getValueAPF().isZero())
3006             return N1;
3007       } else if (Opcode == ISD::FMUL) {
3008         ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(N1);
3009         SDValue V = N2;
3010
3011         // If the first operand isn't the constant, try the second
3012         if (!CFP) {
3013           CFP = dyn_cast<ConstantFPSDNode>(N2);
3014           V = N1;
3015         }
3016
3017         if (CFP) {
3018           // 0*x --> 0
3019           if (CFP->isZero())
3020             return SDValue(CFP,0);
3021           // 1*x --> x
3022           if (CFP->isExactlyValue(1.0))
3023             return V;
3024         }
3025       }
3026     }
3027     assert(VT.isFloatingPoint() && "This operator only applies to FP types!");
3028     assert(N1.getValueType() == N2.getValueType() &&
3029            N1.getValueType() == VT && "Binary operator types must match!");
3030     break;
3031   case ISD::FCOPYSIGN:   // N1 and result must match.  N1/N2 need not match.
3032     assert(N1.getValueType() == VT &&
3033            N1.getValueType().isFloatingPoint() &&
3034            N2.getValueType().isFloatingPoint() &&
3035            "Invalid FCOPYSIGN!");
3036     break;
3037   case ISD::SHL:
3038   case ISD::SRA:
3039   case ISD::SRL:
3040   case ISD::ROTL:
3041   case ISD::ROTR:
3042     assert(VT == N1.getValueType() &&
3043            "Shift operators return type must be the same as their first arg");
3044     assert(VT.isInteger() && N2.getValueType().isInteger() &&
3045            "Shifts only work on integers");
3046     assert((!VT.isVector() || VT == N2.getValueType()) &&
3047            "Vector shift amounts must be in the same as their first arg");
3048     // Verify that the shift amount VT is bit enough to hold valid shift
3049     // amounts.  This catches things like trying to shift an i1024 value by an
3050     // i8, which is easy to fall into in generic code that uses
3051     // TLI.getShiftAmount().
3052     assert(N2.getValueType().getSizeInBits() >=
3053                    Log2_32_Ceil(N1.getValueType().getSizeInBits()) &&
3054            "Invalid use of small shift amount with oversized value!");
3055
3056     // Always fold shifts of i1 values so the code generator doesn't need to
3057     // handle them.  Since we know the size of the shift has to be less than the
3058     // size of the value, the shift/rotate count is guaranteed to be zero.
3059     if (VT == MVT::i1)
3060       return N1;
3061     if (N2C && N2C->isNullValue())
3062       return N1;
3063     break;
3064   case ISD::FP_ROUND_INREG: {
3065     EVT EVT = cast<VTSDNode>(N2)->getVT();
3066     assert(VT == N1.getValueType() && "Not an inreg round!");
3067     assert(VT.isFloatingPoint() && EVT.isFloatingPoint() &&
3068            "Cannot FP_ROUND_INREG integer types");
3069     assert(EVT.isVector() == VT.isVector() &&
3070            "FP_ROUND_INREG type should be vector iff the operand "
3071            "type is vector!");
3072     assert((!EVT.isVector() ||
3073             EVT.getVectorNumElements() == VT.getVectorNumElements()) &&
3074            "Vector element counts must match in FP_ROUND_INREG");
3075     assert(EVT.bitsLE(VT) && "Not rounding down!");
3076     (void)EVT;
3077     if (cast<VTSDNode>(N2)->getVT() == VT) return N1;  // Not actually rounding.
3078     break;
3079   }
3080   case ISD::FP_ROUND:
3081     assert(VT.isFloatingPoint() &&
3082            N1.getValueType().isFloatingPoint() &&
3083            VT.bitsLE(N1.getValueType()) &&
3084            isa<ConstantSDNode>(N2) && "Invalid FP_ROUND!");
3085     if (N1.getValueType() == VT) return N1;  // noop conversion.
3086     break;
3087   case ISD::AssertSext:
3088   case ISD::AssertZext: {
3089     EVT EVT = cast<VTSDNode>(N2)->getVT();
3090     assert(VT == N1.getValueType() && "Not an inreg extend!");
3091     assert(VT.isInteger() && EVT.isInteger() &&
3092            "Cannot *_EXTEND_INREG FP types");
3093     assert(!EVT.isVector() &&
3094            "AssertSExt/AssertZExt type should be the vector element type "
3095            "rather than the vector type!");
3096     assert(EVT.bitsLE(VT) && "Not extending!");
3097     if (VT == EVT) return N1; // noop assertion.
3098     break;
3099   }
3100   case ISD::SIGN_EXTEND_INREG: {
3101     EVT EVT = cast<VTSDNode>(N2)->getVT();
3102     assert(VT == N1.getValueType() && "Not an inreg extend!");
3103     assert(VT.isInteger() && EVT.isInteger() &&
3104            "Cannot *_EXTEND_INREG FP types");
3105     assert(EVT.isVector() == VT.isVector() &&
3106            "SIGN_EXTEND_INREG type should be vector iff the operand "
3107            "type is vector!");
3108     assert((!EVT.isVector() ||
3109             EVT.getVectorNumElements() == VT.getVectorNumElements()) &&
3110            "Vector element counts must match in SIGN_EXTEND_INREG");
3111     assert(EVT.bitsLE(VT) && "Not extending!");
3112     if (EVT == VT) return N1;  // Not actually extending
3113
3114     if (N1C) {
3115       APInt Val = N1C->getAPIntValue();
3116       unsigned FromBits = EVT.getScalarType().getSizeInBits();
3117       Val <<= Val.getBitWidth()-FromBits;
3118       Val = Val.ashr(Val.getBitWidth()-FromBits);
3119       return getConstant(Val, VT);
3120     }
3121     break;
3122   }
3123   case ISD::EXTRACT_VECTOR_ELT:
3124     // EXTRACT_VECTOR_ELT of an UNDEF is an UNDEF.
3125     if (N1.getOpcode() == ISD::UNDEF)
3126       return getUNDEF(VT);
3127
3128     // EXTRACT_VECTOR_ELT of CONCAT_VECTORS is often formed while lowering is
3129     // expanding copies of large vectors from registers.
3130     if (N2C &&
3131         N1.getOpcode() == ISD::CONCAT_VECTORS &&
3132         N1.getNumOperands() > 0) {
3133       unsigned Factor =
3134         N1.getOperand(0).getValueType().getVectorNumElements();
3135       return getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT,
3136                      N1.getOperand(N2C->getZExtValue() / Factor),
3137                      getConstant(N2C->getZExtValue() % Factor,
3138                                  N2.getValueType()));
3139     }
3140
3141     // EXTRACT_VECTOR_ELT of BUILD_VECTOR is often formed while lowering is
3142     // expanding large vector constants.
3143     if (N2C && N1.getOpcode() == ISD::BUILD_VECTOR) {
3144       SDValue Elt = N1.getOperand(N2C->getZExtValue());
3145
3146       if (VT != Elt.getValueType())
3147         // If the vector element type is not legal, the BUILD_VECTOR operands
3148         // are promoted and implicitly truncated, and the result implicitly
3149         // extended. Make that explicit here.
3150         Elt = getAnyExtOrTrunc(Elt, DL, VT);
3151
3152       return Elt;
3153     }
3154
3155     // EXTRACT_VECTOR_ELT of INSERT_VECTOR_ELT is often formed when vector
3156     // operations are lowered to scalars.
3157     if (N1.getOpcode() == ISD::INSERT_VECTOR_ELT) {
3158       // If the indices are the same, return the inserted element else
3159       // if the indices are known different, extract the element from
3160       // the original vector.
3161       SDValue N1Op2 = N1.getOperand(2);
3162       ConstantSDNode *N1Op2C = dyn_cast<ConstantSDNode>(N1Op2.getNode());
3163
3164       if (N1Op2C && N2C) {
3165         if (N1Op2C->getZExtValue() == N2C->getZExtValue()) {
3166           if (VT == N1.getOperand(1).getValueType())
3167             return N1.getOperand(1);
3168           else
3169             return getSExtOrTrunc(N1.getOperand(1), DL, VT);
3170         }
3171
3172         return getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, N1.getOperand(0), N2);
3173       }
3174     }
3175     break;
3176   case ISD::EXTRACT_ELEMENT:
3177     assert(N2C && (unsigned)N2C->getZExtValue() < 2 && "Bad EXTRACT_ELEMENT!");
3178     assert(!N1.getValueType().isVector() && !VT.isVector() &&
3179            (N1.getValueType().isInteger() == VT.isInteger()) &&
3180            N1.getValueType() != VT &&
3181            "Wrong types for EXTRACT_ELEMENT!");
3182
3183     // EXTRACT_ELEMENT of BUILD_PAIR is often formed while legalize is expanding
3184     // 64-bit integers into 32-bit parts.  Instead of building the extract of
3185     // the BUILD_PAIR, only to have legalize rip it apart, just do it now.
3186     if (N1.getOpcode() == ISD::BUILD_PAIR)
3187       return N1.getOperand(N2C->getZExtValue());
3188
3189     // EXTRACT_ELEMENT of a constant int is also very common.
3190     if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(N1)) {
3191       unsigned ElementSize = VT.getSizeInBits();
3192       unsigned Shift = ElementSize * N2C->getZExtValue();
3193       APInt ShiftedVal = C->getAPIntValue().lshr(Shift);
3194       return getConstant(ShiftedVal.trunc(ElementSize), VT);
3195     }
3196     break;
3197   case ISD::EXTRACT_SUBVECTOR: {
3198     SDValue Index = N2;
3199     if (VT.isSimple() && N1.getValueType().isSimple()) {
3200       assert(VT.isVector() && N1.getValueType().isVector() &&
3201              "Extract subvector VTs must be a vectors!");
3202       assert(VT.getVectorElementType() ==
3203              N1.getValueType().getVectorElementType() &&
3204              "Extract subvector VTs must have the same element type!");
3205       assert(VT.getSimpleVT() <= N1.getSimpleValueType() &&
3206              "Extract subvector must be from larger vector to smaller vector!");
3207
3208       if (isa<ConstantSDNode>(Index.getNode())) {
3209         assert((VT.getVectorNumElements() +
3210                 cast<ConstantSDNode>(Index.getNode())->getZExtValue()
3211                 <= N1.getValueType().getVectorNumElements())
3212                && "Extract subvector overflow!");
3213       }
3214
3215       // Trivial extraction.
3216       if (VT.getSimpleVT() == N1.getSimpleValueType())
3217         return N1;
3218     }
3219     break;
3220   }
3221   }
3222
3223   // Perform trivial constant folding.
3224   SDValue SV = FoldConstantArithmetic(Opcode, VT, N1.getNode(), N2.getNode());
3225   if (SV.getNode()) return SV;
3226
3227   // Canonicalize constant to RHS if commutative.
3228   if (N1C && !N2C && isCommutativeBinOp(Opcode)) {
3229     std::swap(N1C, N2C);
3230     std::swap(N1, N2);
3231   }
3232
3233   // Constant fold FP operations.
3234   ConstantFPSDNode *N1CFP = dyn_cast<ConstantFPSDNode>(N1.getNode());
3235   ConstantFPSDNode *N2CFP = dyn_cast<ConstantFPSDNode>(N2.getNode());
3236   if (N1CFP) {
3237     if (!N2CFP && isCommutativeBinOp(Opcode)) {
3238       // Canonicalize constant to RHS if commutative.
3239       std::swap(N1CFP, N2CFP);
3240       std::swap(N1, N2);
3241     } else if (N2CFP) {
3242       APFloat V1 = N1CFP->getValueAPF(), V2 = N2CFP->getValueAPF();
3243       APFloat::opStatus s;
3244       switch (Opcode) {
3245       case ISD::FADD:
3246         s = V1.add(V2, APFloat::rmNearestTiesToEven);
3247         if (s != APFloat::opInvalidOp)
3248           return getConstantFP(V1, VT);
3249         break;
3250       case ISD::FSUB:
3251         s = V1.subtract(V2, APFloat::rmNearestTiesToEven);
3252         if (s!=APFloat::opInvalidOp)
3253           return getConstantFP(V1, VT);
3254         break;
3255       case ISD::FMUL:
3256         s = V1.multiply(V2, APFloat::rmNearestTiesToEven);
3257         if (s!=APFloat::opInvalidOp)
3258           return getConstantFP(V1, VT);
3259         break;
3260       case ISD::FDIV:
3261         s = V1.divide(V2, APFloat::rmNearestTiesToEven);
3262         if (s!=APFloat::opInvalidOp && s!=APFloat::opDivByZero)
3263           return getConstantFP(V1, VT);
3264         break;
3265       case ISD::FREM :
3266         s = V1.mod(V2, APFloat::rmNearestTiesToEven);
3267         if (s!=APFloat::opInvalidOp && s!=APFloat::opDivByZero)
3268           return getConstantFP(V1, VT);
3269         break;
3270       case ISD::FCOPYSIGN:
3271         V1.copySign(V2);
3272         return getConstantFP(V1, VT);
3273       default: break;
3274       }
3275     }
3276
3277     if (Opcode == ISD::FP_ROUND) {
3278       APFloat V = N1CFP->getValueAPF();    // make copy
3279       bool ignored;
3280       // This can return overflow, underflow, or inexact; we don't care.
3281       // FIXME need to be more flexible about rounding mode.
3282       (void)V.convert(EVTToAPFloatSemantics(VT),
3283                       APFloat::rmNearestTiesToEven, &ignored);
3284       return getConstantFP(V, VT);
3285     }
3286   }
3287
3288   // Canonicalize an UNDEF to the RHS, even over a constant.
3289   if (N1.getOpcode() == ISD::UNDEF) {
3290     if (isCommutativeBinOp(Opcode)) {
3291       std::swap(N1, N2);
3292     } else {
3293       switch (Opcode) {
3294       case ISD::FP_ROUND_INREG:
3295       case ISD::SIGN_EXTEND_INREG:
3296       case ISD::SUB:
3297       case ISD::FSUB:
3298       case ISD::FDIV:
3299       case ISD::FREM:
3300       case ISD::SRA:
3301         return N1;     // fold op(undef, arg2) -> undef
3302       case ISD::UDIV:
3303       case ISD::SDIV:
3304       case ISD::UREM:
3305       case ISD::SREM:
3306       case ISD::SRL:
3307       case ISD::SHL:
3308         if (!VT.isVector())
3309           return getConstant(0, VT);    // fold op(undef, arg2) -> 0
3310         // For vectors, we can't easily build an all zero vector, just return
3311         // the LHS.
3312         return N2;
3313       }
3314     }
3315   }
3316
3317   // Fold a bunch of operators when the RHS is undef.
3318   if (N2.getOpcode() == ISD::UNDEF) {
3319     switch (Opcode) {
3320     case ISD::XOR:
3321       if (N1.getOpcode() == ISD::UNDEF)
3322         // Handle undef ^ undef -> 0 special case. This is a common
3323         // idiom (misuse).
3324         return getConstant(0, VT);
3325       // fallthrough
3326     case ISD::ADD:
3327     case ISD::ADDC:
3328     case ISD::ADDE:
3329     case ISD::SUB:
3330     case ISD::UDIV:
3331     case ISD::SDIV:
3332     case ISD::UREM:
3333     case ISD::SREM:
3334       return N2;       // fold op(arg1, undef) -> undef
3335     case ISD::FADD:
3336     case ISD::FSUB:
3337     case ISD::FMUL:
3338     case ISD::FDIV:
3339     case ISD::FREM:
3340       if (getTarget().Options.UnsafeFPMath)
3341         return N2;
3342       break;
3343     case ISD::MUL:
3344     case ISD::AND:
3345     case ISD::SRL:
3346     case ISD::SHL:
3347       if (!VT.isVector())
3348         return getConstant(0, VT);  // fold op(arg1, undef) -> 0
3349       // For vectors, we can't easily build an all zero vector, just return
3350       // the LHS.
3351       return N1;
3352     case ISD::OR:
3353       if (!VT.isVector())
3354         return getConstant(APInt::getAllOnesValue(VT.getSizeInBits()), VT);
3355       // For vectors, we can't easily build an all one vector, just return
3356       // the LHS.
3357       return N1;
3358     case ISD::SRA:
3359       return N1;
3360     }
3361   }
3362
3363   // Memoize this node if possible.
3364   SDNode *N;
3365   SDVTList VTs = getVTList(VT);
3366   if (VT != MVT::Glue) {
3367     SDValue Ops[] = { N1, N2 };
3368     FoldingSetNodeID ID;
3369     AddNodeIDNode(ID, Opcode, VTs, Ops, 2);
3370     void *IP = 0;
3371     if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
3372       return SDValue(E, 0);
3373
3374     N = new (NodeAllocator) BinarySDNode(Opcode, DL.getIROrder(),
3375                                          DL.getDebugLoc(), VTs, N1, N2);
3376     CSEMap.InsertNode(N, IP);
3377   } else {
3378     N = new (NodeAllocator) BinarySDNode(Opcode, DL.getIROrder(),
3379                                          DL.getDebugLoc(), VTs, N1, N2);
3380   }
3381
3382   AllNodes.push_back(N);
3383 #ifndef NDEBUG
3384   VerifySDNode(N);
3385 #endif
3386   return SDValue(N, 0);
3387 }
3388
3389 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT,
3390                               SDValue N1, SDValue N2, SDValue N3) {
3391   // Perform various simplifications.
3392   ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
3393   switch (Opcode) {
3394   case ISD::FMA: {
3395     ConstantFPSDNode *N1CFP = dyn_cast<ConstantFPSDNode>(N1);
3396     ConstantFPSDNode *N2CFP = dyn_cast<ConstantFPSDNode>(N2);
3397     ConstantFPSDNode *N3CFP = dyn_cast<ConstantFPSDNode>(N3);
3398     if (N1CFP && N2CFP && N3CFP) {
3399       APFloat  V1 = N1CFP->getValueAPF();
3400       const APFloat &V2 = N2CFP->getValueAPF();
3401       const APFloat &V3 = N3CFP->getValueAPF();
3402       APFloat::opStatus s =
3403         V1.fusedMultiplyAdd(V2, V3, APFloat::rmNearestTiesToEven);
3404       if (s != APFloat::opInvalidOp)
3405         return getConstantFP(V1, VT);
3406     }
3407     break;
3408   }
3409   case ISD::CONCAT_VECTORS:
3410     // A CONCAT_VECTOR with all operands BUILD_VECTOR can be simplified to
3411     // one big BUILD_VECTOR.
3412     if (N1.getOpcode() == ISD::BUILD_VECTOR &&
3413         N2.getOpcode() == ISD::BUILD_VECTOR &&
3414         N3.getOpcode() == ISD::BUILD_VECTOR) {
3415       SmallVector<SDValue, 16> Elts(N1.getNode()->op_begin(),
3416                                     N1.getNode()->op_end());
3417       Elts.append(N2.getNode()->op_begin(), N2.getNode()->op_end());
3418       Elts.append(N3.getNode()->op_begin(), N3.getNode()->op_end());
3419       return getNode(ISD::BUILD_VECTOR, DL, VT, &Elts[0], Elts.size());
3420     }
3421     break;
3422   case ISD::SETCC: {
3423     // Use FoldSetCC to simplify SETCC's.
3424     SDValue Simp = FoldSetCC(VT, N1, N2, cast<CondCodeSDNode>(N3)->get(), DL);
3425     if (Simp.getNode()) return Simp;
3426     break;
3427   }
3428   case ISD::SELECT:
3429     if (N1C) {
3430      if (N1C->getZExtValue())
3431        return N2;             // select true, X, Y -> X
3432      return N3;             // select false, X, Y -> Y
3433     }
3434
3435     if (N2 == N3) return N2;   // select C, X, X -> X
3436     break;
3437   case ISD::VECTOR_SHUFFLE:
3438     llvm_unreachable("should use getVectorShuffle constructor!");
3439   case ISD::INSERT_SUBVECTOR: {
3440     SDValue Index = N3;
3441     if (VT.isSimple() && N1.getValueType().isSimple()
3442         && N2.getValueType().isSimple()) {
3443       assert(VT.isVector() && N1.getValueType().isVector() &&
3444              N2.getValueType().isVector() &&
3445              "Insert subvector VTs must be a vectors");
3446       assert(VT == N1.getValueType() &&
3447              "Dest and insert subvector source types must match!");
3448       assert(N2.getSimpleValueType() <= N1.getSimpleValueType() &&
3449              "Insert subvector must be from smaller vector to larger vector!");
3450       if (isa<ConstantSDNode>(Index.getNode())) {
3451         assert((N2.getValueType().getVectorNumElements() +
3452                 cast<ConstantSDNode>(Index.getNode())->getZExtValue()
3453                 <= VT.getVectorNumElements())
3454                && "Insert subvector overflow!");
3455       }
3456
3457       // Trivial insertion.
3458       if (VT.getSimpleVT() == N2.getSimpleValueType())
3459         return N2;
3460     }
3461     break;
3462   }
3463   case ISD::BITCAST:
3464     // Fold bit_convert nodes from a type to themselves.
3465     if (N1.getValueType() == VT)
3466       return N1;
3467     break;
3468   }
3469
3470   // Memoize node if it doesn't produce a flag.
3471   SDNode *N;
3472   SDVTList VTs = getVTList(VT);
3473   if (VT != MVT::Glue) {
3474     SDValue Ops[] = { N1, N2, N3 };
3475     FoldingSetNodeID ID;
3476     AddNodeIDNode(ID, Opcode, VTs, Ops, 3);
3477     void *IP = 0;
3478     if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
3479       return SDValue(E, 0);
3480
3481     N = new (NodeAllocator) TernarySDNode(Opcode, DL.getIROrder(),
3482                                           DL.getDebugLoc(), VTs, N1, N2, N3);
3483     CSEMap.InsertNode(N, IP);
3484   } else {
3485     N = new (NodeAllocator) TernarySDNode(Opcode, DL.getIROrder(),
3486                                           DL.getDebugLoc(), VTs, N1, N2, N3);
3487   }
3488
3489   AllNodes.push_back(N);
3490 #ifndef NDEBUG
3491   VerifySDNode(N);
3492 #endif
3493   return SDValue(N, 0);
3494 }
3495
3496 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT,
3497                               SDValue N1, SDValue N2, SDValue N3,
3498                               SDValue N4) {
3499   SDValue Ops[] = { N1, N2, N3, N4 };
3500   return getNode(Opcode, DL, VT, Ops, 4);
3501 }
3502
3503 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT,
3504                               SDValue N1, SDValue N2, SDValue N3,
3505                               SDValue N4, SDValue N5) {
3506   SDValue Ops[] = { N1, N2, N3, N4, N5 };
3507   return getNode(Opcode, DL, VT, Ops, 5);
3508 }
3509
3510 /// getStackArgumentTokenFactor - Compute a TokenFactor to force all
3511 /// the incoming stack arguments to be loaded from the stack.
3512 SDValue SelectionDAG::getStackArgumentTokenFactor(SDValue Chain) {
3513   SmallVector<SDValue, 8> ArgChains;
3514
3515   // Include the original chain at the beginning of the list. When this is
3516   // used by target LowerCall hooks, this helps legalize find the
3517   // CALLSEQ_BEGIN node.
3518   ArgChains.push_back(Chain);
3519
3520   // Add a chain value for each stack argument.
3521   for (SDNode::use_iterator U = getEntryNode().getNode()->use_begin(),
3522        UE = getEntryNode().getNode()->use_end(); U != UE; ++U)
3523     if (LoadSDNode *L = dyn_cast<LoadSDNode>(*U))
3524       if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(L->getBasePtr()))
3525         if (FI->getIndex() < 0)
3526           ArgChains.push_back(SDValue(L, 1));
3527
3528   // Build a tokenfactor for all the chains.
3529   return getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other,
3530                  &ArgChains[0], ArgChains.size());
3531 }
3532
3533 /// getMemsetValue - Vectorized representation of the memset value
3534 /// operand.
3535 static SDValue getMemsetValue(SDValue Value, EVT VT, SelectionDAG &DAG,
3536                               SDLoc dl) {
3537   assert(Value.getOpcode() != ISD::UNDEF);
3538
3539   unsigned NumBits = VT.getScalarType().getSizeInBits();
3540   if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Value)) {
3541     assert(C->getAPIntValue().getBitWidth() == 8);
3542     APInt Val = APInt::getSplat(NumBits, C->getAPIntValue());
3543     if (VT.isInteger())
3544       return DAG.getConstant(Val, VT);
3545     return DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(VT), Val), VT);
3546   }
3547
3548   Value = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Value);
3549   if (NumBits > 8) {
3550     // Use a multiplication with 0x010101... to extend the input to the
3551     // required length.
3552     APInt Magic = APInt::getSplat(NumBits, APInt(8, 0x01));
3553     Value = DAG.getNode(ISD::MUL, dl, VT, Value, DAG.getConstant(Magic, VT));
3554   }
3555
3556   return Value;
3557 }
3558
3559 /// getMemsetStringVal - Similar to getMemsetValue. Except this is only
3560 /// used when a memcpy is turned into a memset when the source is a constant
3561 /// string ptr.
3562 static SDValue getMemsetStringVal(EVT VT, SDLoc dl, SelectionDAG &DAG,
3563                                   const TargetLowering &TLI, StringRef Str) {
3564   // Handle vector with all elements zero.
3565   if (Str.empty()) {
3566     if (VT.isInteger())
3567       return DAG.getConstant(0, VT);
3568     else if (VT == MVT::f32 || VT == MVT::f64)
3569       return DAG.getConstantFP(0.0, VT);
3570     else if (VT.isVector()) {
3571       unsigned NumElts = VT.getVectorNumElements();
3572       MVT EltVT = (VT.getVectorElementType() == MVT::f32) ? MVT::i32 : MVT::i64;
3573       return DAG.getNode(ISD::BITCAST, dl, VT,
3574                          DAG.getConstant(0, EVT::getVectorVT(*DAG.getContext(),
3575                                                              EltVT, NumElts)));
3576     } else
3577       llvm_unreachable("Expected type!");
3578   }
3579
3580   assert(!VT.isVector() && "Can't handle vector type here!");
3581   unsigned NumVTBits = VT.getSizeInBits();
3582   unsigned NumVTBytes = NumVTBits / 8;
3583   unsigned NumBytes = std::min(NumVTBytes, unsigned(Str.size()));
3584
3585   APInt Val(NumVTBits, 0);
3586   if (TLI.isLittleEndian()) {
3587     for (unsigned i = 0; i != NumBytes; ++i)
3588       Val |= (uint64_t)(unsigned char)Str[i] << i*8;
3589   } else {
3590     for (unsigned i = 0; i != NumBytes; ++i)
3591       Val |= (uint64_t)(unsigned char)Str[i] << (NumVTBytes-i-1)*8;
3592   }
3593
3594   // If the "cost" of materializing the integer immediate is less than the cost
3595   // of a load, then it is cost effective to turn the load into the immediate.
3596   Type *Ty = VT.getTypeForEVT(*DAG.getContext());
3597   if (TLI.shouldConvertConstantLoadToIntImm(Val, Ty))
3598     return DAG.getConstant(Val, VT);
3599   return SDValue(0, 0);
3600 }
3601
3602 /// getMemBasePlusOffset - Returns base and offset node for the
3603 ///
3604 static SDValue getMemBasePlusOffset(SDValue Base, unsigned Offset, SDLoc dl,
3605                                       SelectionDAG &DAG) {
3606   EVT VT = Base.getValueType();
3607   return DAG.getNode(ISD::ADD, dl,
3608                      VT, Base, DAG.getConstant(Offset, VT));
3609 }
3610
3611 /// isMemSrcFromString - Returns true if memcpy source is a string constant.
3612 ///
3613 static bool isMemSrcFromString(SDValue Src, StringRef &Str) {
3614   unsigned SrcDelta = 0;
3615   GlobalAddressSDNode *G = NULL;
3616   if (Src.getOpcode() == ISD::GlobalAddress)
3617     G = cast<GlobalAddressSDNode>(Src);
3618   else if (Src.getOpcode() == ISD::ADD &&
3619            Src.getOperand(0).getOpcode() == ISD::GlobalAddress &&
3620            Src.getOperand(1).getOpcode() == ISD::Constant) {
3621     G = cast<GlobalAddressSDNode>(Src.getOperand(0));
3622     SrcDelta = cast<ConstantSDNode>(Src.getOperand(1))->getZExtValue();
3623   }
3624   if (!G)
3625     return false;
3626
3627   return getConstantStringInfo(G->getGlobal(), Str, SrcDelta, false);
3628 }
3629
3630 /// FindOptimalMemOpLowering - Determines the optimial series memory ops
3631 /// to replace the memset / memcpy. Return true if the number of memory ops
3632 /// is below the threshold. It returns the types of the sequence of
3633 /// memory ops to perform memset / memcpy by reference.
3634 static bool FindOptimalMemOpLowering(std::vector<EVT> &MemOps,
3635                                      unsigned Limit, uint64_t Size,
3636                                      unsigned DstAlign, unsigned SrcAlign,
3637                                      bool IsMemset,
3638                                      bool ZeroMemset,
3639                                      bool MemcpyStrSrc,
3640                                      bool AllowOverlap,
3641                                      SelectionDAG &DAG,
3642                                      const TargetLowering &TLI) {
3643   assert((SrcAlign == 0 || SrcAlign >= DstAlign) &&
3644          "Expecting memcpy / memset source to meet alignment requirement!");
3645   // If 'SrcAlign' is zero, that means the memory operation does not need to
3646   // load the value, i.e. memset or memcpy from constant string. Otherwise,
3647   // it's the inferred alignment of the source. 'DstAlign', on the other hand,
3648   // is the specified alignment of the memory operation. If it is zero, that
3649   // means it's possible to change the alignment of the destination.
3650   // 'MemcpyStrSrc' indicates whether the memcpy source is constant so it does
3651   // not need to be loaded.
3652   EVT VT = TLI.getOptimalMemOpType(Size, DstAlign, SrcAlign,
3653                                    IsMemset, ZeroMemset, MemcpyStrSrc,
3654                                    DAG.getMachineFunction());
3655
3656   if (VT == MVT::Other) {
3657     unsigned AS = 0;
3658     if (DstAlign >= TLI.getDataLayout()->getPointerPrefAlignment(AS) ||
3659         TLI.allowsUnalignedMemoryAccesses(VT, AS)) {
3660       VT = TLI.getPointerTy();
3661     } else {
3662       switch (DstAlign & 7) {
3663       case 0:  VT = MVT::i64; break;
3664       case 4:  VT = MVT::i32; break;
3665       case 2:  VT = MVT::i16; break;
3666       default: VT = MVT::i8;  break;
3667       }
3668     }
3669
3670     MVT LVT = MVT::i64;
3671     while (!TLI.isTypeLegal(LVT))
3672       LVT = (MVT::SimpleValueType)(LVT.SimpleTy - 1);
3673     assert(LVT.isInteger());
3674
3675     if (VT.bitsGT(LVT))
3676       VT = LVT;
3677   }
3678
3679   unsigned NumMemOps = 0;
3680   while (Size != 0) {
3681     unsigned VTSize = VT.getSizeInBits() / 8;
3682     while (VTSize > Size) {
3683       // For now, only use non-vector load / store's for the left-over pieces.
3684       EVT NewVT = VT;
3685       unsigned NewVTSize;
3686
3687       bool Found = false;
3688       if (VT.isVector() || VT.isFloatingPoint()) {
3689         NewVT = (VT.getSizeInBits() > 64) ? MVT::i64 : MVT::i32;
3690         if (TLI.isOperationLegalOrCustom(ISD::STORE, NewVT) &&
3691             TLI.isSafeMemOpType(NewVT.getSimpleVT()))
3692           Found = true;
3693         else if (NewVT == MVT::i64 &&
3694                  TLI.isOperationLegalOrCustom(ISD::STORE, MVT::f64) &&
3695                  TLI.isSafeMemOpType(MVT::f64)) {
3696           // i64 is usually not legal on 32-bit targets, but f64 may be.
3697           NewVT = MVT::f64;
3698           Found = true;
3699         }
3700       }
3701
3702       if (!Found) {
3703         do {
3704           NewVT = (MVT::SimpleValueType)(NewVT.getSimpleVT().SimpleTy - 1);
3705           if (NewVT == MVT::i8)
3706             break;
3707         } while (!TLI.isSafeMemOpType(NewVT.getSimpleVT()));
3708       }
3709       NewVTSize = NewVT.getSizeInBits() / 8;
3710
3711       // If the new VT cannot cover all of the remaining bits, then consider
3712       // issuing a (or a pair of) unaligned and overlapping load / store.
3713       // FIXME: Only does this for 64-bit or more since we don't have proper
3714       // cost model for unaligned load / store.
3715       bool Fast;
3716       unsigned AS = 0;
3717       if (NumMemOps && AllowOverlap &&
3718           VTSize >= 8 && NewVTSize < Size &&
3719           TLI.allowsUnalignedMemoryAccesses(VT, AS, &Fast) && Fast)
3720         VTSize = Size;
3721       else {
3722         VT = NewVT;
3723         VTSize = NewVTSize;
3724       }
3725     }
3726
3727     if (++NumMemOps > Limit)
3728       return false;
3729
3730     MemOps.push_back(VT);
3731     Size -= VTSize;
3732   }
3733
3734   return true;
3735 }
3736
3737 static SDValue getMemcpyLoadsAndStores(SelectionDAG &DAG, SDLoc dl,
3738                                        SDValue Chain, SDValue Dst,
3739                                        SDValue Src, uint64_t Size,
3740                                        unsigned Align, bool isVol,
3741                                        bool AlwaysInline,
3742                                        MachinePointerInfo DstPtrInfo,
3743                                        MachinePointerInfo SrcPtrInfo) {
3744   // Turn a memcpy of undef to nop.
3745   if (Src.getOpcode() == ISD::UNDEF)
3746     return Chain;
3747
3748   // Expand memcpy to a series of load and store ops if the size operand falls
3749   // below a certain threshold.
3750   // TODO: In the AlwaysInline case, if the size is big then generate a loop
3751   // rather than maybe a humongous number of loads and stores.
3752   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
3753   std::vector<EVT> MemOps;
3754   bool DstAlignCanChange = false;
3755   MachineFunction &MF = DAG.getMachineFunction();
3756   MachineFrameInfo *MFI = MF.getFrameInfo();
3757   bool OptSize =
3758     MF.getFunction()->getAttributes().
3759       hasAttribute(AttributeSet::FunctionIndex, Attribute::OptimizeForSize);
3760   FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Dst);
3761   if (FI && !MFI->isFixedObjectIndex(FI->getIndex()))
3762     DstAlignCanChange = true;
3763   unsigned SrcAlign = DAG.InferPtrAlignment(Src);
3764   if (Align > SrcAlign)
3765     SrcAlign = Align;
3766   StringRef Str;
3767   bool CopyFromStr = isMemSrcFromString(Src, Str);
3768   bool isZeroStr = CopyFromStr && Str.empty();
3769   unsigned Limit = AlwaysInline ? ~0U : TLI.getMaxStoresPerMemcpy(OptSize);
3770
3771   if (!FindOptimalMemOpLowering(MemOps, Limit, Size,
3772                                 (DstAlignCanChange ? 0 : Align),
3773                                 (isZeroStr ? 0 : SrcAlign),
3774                                 false, false, CopyFromStr, true, DAG, TLI))
3775     return SDValue();
3776
3777   if (DstAlignCanChange) {
3778     Type *Ty = MemOps[0].getTypeForEVT(*DAG.getContext());
3779     unsigned NewAlign = (unsigned) TLI.getDataLayout()->getABITypeAlignment(Ty);
3780
3781     // Don't promote to an alignment that would require dynamic stack
3782     // realignment.
3783     const TargetRegisterInfo *TRI = MF.getTarget().getRegisterInfo();
3784     if (!TRI->needsStackRealignment(MF))
3785        while (NewAlign > Align &&
3786              TLI.getDataLayout()->exceedsNaturalStackAlignment(NewAlign))
3787           NewAlign /= 2;
3788
3789     if (NewAlign > Align) {
3790       // Give the stack frame object a larger alignment if needed.
3791       if (MFI->getObjectAlignment(FI->getIndex()) < NewAlign)
3792         MFI->setObjectAlignment(FI->getIndex(), NewAlign);
3793       Align = NewAlign;
3794     }
3795   }
3796
3797   SmallVector<SDValue, 8> OutChains;
3798   unsigned NumMemOps = MemOps.size();
3799   uint64_t SrcOff = 0, DstOff = 0;
3800   for (unsigned i = 0; i != NumMemOps; ++i) {
3801     EVT VT = MemOps[i];
3802     unsigned VTSize = VT.getSizeInBits() / 8;
3803     SDValue Value, Store;
3804
3805     if (VTSize > Size) {
3806       // Issuing an unaligned load / store pair  that overlaps with the previous
3807       // pair. Adjust the offset accordingly.
3808       assert(i == NumMemOps-1 && i != 0);
3809       SrcOff -= VTSize - Size;
3810       DstOff -= VTSize - Size;
3811     }
3812
3813     if (CopyFromStr &&
3814         (isZeroStr || (VT.isInteger() && !VT.isVector()))) {
3815       // It's unlikely a store of a vector immediate can be done in a single
3816       // instruction. It would require a load from a constantpool first.
3817       // We only handle zero vectors here.
3818       // FIXME: Handle other cases where store of vector immediate is done in
3819       // a single instruction.
3820       Value = getMemsetStringVal(VT, dl, DAG, TLI, Str.substr(SrcOff));
3821       if (Value.getNode())
3822         Store = DAG.getStore(Chain, dl, Value,
3823                              getMemBasePlusOffset(Dst, DstOff, dl, DAG),
3824                              DstPtrInfo.getWithOffset(DstOff), isVol,
3825                              false, Align);
3826     }
3827
3828     if (!Store.getNode()) {
3829       // The type might not be legal for the target.  This should only happen
3830       // if the type is smaller than a legal type, as on PPC, so the right
3831       // thing to do is generate a LoadExt/StoreTrunc pair.  These simplify
3832       // to Load/Store if NVT==VT.
3833       // FIXME does the case above also need this?
3834       EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
3835       assert(NVT.bitsGE(VT));
3836       Value = DAG.getExtLoad(ISD::EXTLOAD, dl, NVT, Chain,
3837                              getMemBasePlusOffset(Src, SrcOff, dl, DAG),
3838                              SrcPtrInfo.getWithOffset(SrcOff), VT, isVol, false,
3839                              MinAlign(SrcAlign, SrcOff));
3840       Store = DAG.getTruncStore(Chain, dl, Value,
3841                                 getMemBasePlusOffset(Dst, DstOff, dl, DAG),
3842                                 DstPtrInfo.getWithOffset(DstOff), VT, isVol,
3843                                 false, Align);
3844     }
3845     OutChains.push_back(Store);
3846     SrcOff += VTSize;
3847     DstOff += VTSize;
3848     Size -= VTSize;
3849   }
3850
3851   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
3852                      &OutChains[0], OutChains.size());
3853 }
3854
3855 static SDValue getMemmoveLoadsAndStores(SelectionDAG &DAG, SDLoc dl,
3856                                         SDValue Chain, SDValue Dst,
3857                                         SDValue Src, uint64_t Size,
3858                                         unsigned Align,  bool isVol,
3859                                         bool AlwaysInline,
3860                                         MachinePointerInfo DstPtrInfo,
3861                                         MachinePointerInfo SrcPtrInfo) {
3862   // Turn a memmove of undef to nop.
3863   if (Src.getOpcode() == ISD::UNDEF)
3864     return Chain;
3865
3866   // Expand memmove to a series of load and store ops if the size operand falls
3867   // below a certain threshold.
3868   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
3869   std::vector<EVT> MemOps;
3870   bool DstAlignCanChange = false;
3871   MachineFunction &MF = DAG.getMachineFunction();
3872   MachineFrameInfo *MFI = MF.getFrameInfo();
3873   bool OptSize = MF.getFunction()->getAttributes().
3874     hasAttribute(AttributeSet::FunctionIndex, Attribute::OptimizeForSize);
3875   FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Dst);
3876   if (FI && !MFI->isFixedObjectIndex(FI->getIndex()))
3877     DstAlignCanChange = true;
3878   unsigned SrcAlign = DAG.InferPtrAlignment(Src);
3879   if (Align > SrcAlign)
3880     SrcAlign = Align;
3881   unsigned Limit = AlwaysInline ? ~0U : TLI.getMaxStoresPerMemmove(OptSize);
3882
3883   if (!FindOptimalMemOpLowering(MemOps, Limit, Size,
3884                                 (DstAlignCanChange ? 0 : Align), SrcAlign,
3885                                 false, false, false, false, DAG, TLI))
3886     return SDValue();
3887
3888   if (DstAlignCanChange) {
3889     Type *Ty = MemOps[0].getTypeForEVT(*DAG.getContext());
3890     unsigned NewAlign = (unsigned) TLI.getDataLayout()->getABITypeAlignment(Ty);
3891     if (NewAlign > Align) {
3892       // Give the stack frame object a larger alignment if needed.
3893       if (MFI->getObjectAlignment(FI->getIndex()) < NewAlign)
3894         MFI->setObjectAlignment(FI->getIndex(), NewAlign);
3895       Align = NewAlign;
3896     }
3897   }
3898
3899   uint64_t SrcOff = 0, DstOff = 0;
3900   SmallVector<SDValue, 8> LoadValues;
3901   SmallVector<SDValue, 8> LoadChains;
3902   SmallVector<SDValue, 8> OutChains;
3903   unsigned NumMemOps = MemOps.size();
3904   for (unsigned i = 0; i < NumMemOps; i++) {
3905     EVT VT = MemOps[i];
3906     unsigned VTSize = VT.getSizeInBits() / 8;
3907     SDValue Value;
3908
3909     Value = DAG.getLoad(VT, dl, Chain,
3910                         getMemBasePlusOffset(Src, SrcOff, dl, DAG),
3911                         SrcPtrInfo.getWithOffset(SrcOff), isVol,
3912                         false, false, SrcAlign);
3913     LoadValues.push_back(Value);
3914     LoadChains.push_back(Value.getValue(1));
3915     SrcOff += VTSize;
3916   }
3917   Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
3918                       &LoadChains[0], LoadChains.size());
3919   OutChains.clear();
3920   for (unsigned i = 0; i < NumMemOps; i++) {
3921     EVT VT = MemOps[i];
3922     unsigned VTSize = VT.getSizeInBits() / 8;
3923     SDValue Store;
3924
3925     Store = DAG.getStore(Chain, dl, LoadValues[i],
3926                          getMemBasePlusOffset(Dst, DstOff, dl, DAG),
3927                          DstPtrInfo.getWithOffset(DstOff), isVol, false, Align);
3928     OutChains.push_back(Store);
3929     DstOff += VTSize;
3930   }
3931
3932   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
3933                      &OutChains[0], OutChains.size());
3934 }
3935
3936 /// \brief Lower the call to 'memset' intrinsic function into a series of store
3937 /// operations.
3938 ///
3939 /// \param DAG Selection DAG where lowered code is placed.
3940 /// \param dl Link to corresponding IR location.
3941 /// \param Chain Control flow dependency.
3942 /// \param Dst Pointer to destination memory location.
3943 /// \param Src Value of byte to write into the memory.
3944 /// \param Size Number of bytes to write.
3945 /// \param Align Alignment of the destination in bytes.
3946 /// \param isVol True if destination is volatile.
3947 /// \param DstPtrInfo IR information on the memory pointer.
3948 /// \returns New head in the control flow, if lowering was successful, empty
3949 /// SDValue otherwise.
3950 ///
3951 /// The function tries to replace 'llvm.memset' intrinsic with several store
3952 /// operations and value calculation code. This is usually profitable for small
3953 /// memory size.
3954 static SDValue getMemsetStores(SelectionDAG &DAG, SDLoc dl,
3955                                SDValue Chain, SDValue Dst,
3956                                SDValue Src, uint64_t Size,
3957                                unsigned Align, bool isVol,
3958                                MachinePointerInfo DstPtrInfo) {
3959   // Turn a memset of undef to nop.
3960   if (Src.getOpcode() == ISD::UNDEF)
3961     return Chain;
3962
3963   // Expand memset to a series of load/store ops if the size operand
3964   // falls below a certain threshold.
3965   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
3966   std::vector<EVT> MemOps;
3967   bool DstAlignCanChange = false;
3968   MachineFunction &MF = DAG.getMachineFunction();
3969   MachineFrameInfo *MFI = MF.getFrameInfo();
3970   bool OptSize = MF.getFunction()->getAttributes().
3971     hasAttribute(AttributeSet::FunctionIndex, Attribute::OptimizeForSize);
3972   FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Dst);
3973   if (FI && !MFI->isFixedObjectIndex(FI->getIndex()))
3974     DstAlignCanChange = true;
3975   bool IsZeroVal =
3976     isa<ConstantSDNode>(Src) && cast<ConstantSDNode>(Src)->isNullValue();
3977   if (!FindOptimalMemOpLowering(MemOps, TLI.getMaxStoresPerMemset(OptSize),
3978                                 Size, (DstAlignCanChange ? 0 : Align), 0,
3979                                 true, IsZeroVal, false, true, DAG, TLI))
3980     return SDValue();
3981
3982   if (DstAlignCanChange) {
3983     Type *Ty = MemOps[0].getTypeForEVT(*DAG.getContext());
3984     unsigned NewAlign = (unsigned) TLI.getDataLayout()->getABITypeAlignment(Ty);
3985     if (NewAlign > Align) {
3986       // Give the stack frame object a larger alignment if needed.
3987       if (MFI->getObjectAlignment(FI->getIndex()) < NewAlign)
3988         MFI->setObjectAlignment(FI->getIndex(), NewAlign);
3989       Align = NewAlign;
3990     }
3991   }
3992
3993   SmallVector<SDValue, 8> OutChains;
3994   uint64_t DstOff = 0;
3995   unsigned NumMemOps = MemOps.size();
3996
3997   // Find the largest store and generate the bit pattern for it.
3998   EVT LargestVT = MemOps[0];
3999   for (unsigned i = 1; i < NumMemOps; i++)
4000     if (MemOps[i].bitsGT(LargestVT))
4001       LargestVT = MemOps[i];
4002   SDValue MemSetValue = getMemsetValue(Src, LargestVT, DAG, dl);
4003
4004   for (unsigned i = 0; i < NumMemOps; i++) {
4005     EVT VT = MemOps[i];
4006     unsigned VTSize = VT.getSizeInBits() / 8;
4007     if (VTSize > Size) {
4008       // Issuing an unaligned load / store pair  that overlaps with the previous
4009       // pair. Adjust the offset accordingly.
4010       assert(i == NumMemOps-1 && i != 0);
4011       DstOff -= VTSize - Size;
4012     }
4013
4014     // If this store is smaller than the largest store see whether we can get
4015     // the smaller value for free with a truncate.
4016     SDValue Value = MemSetValue;
4017     if (VT.bitsLT(LargestVT)) {
4018       if (!LargestVT.isVector() && !VT.isVector() &&
4019           TLI.isTruncateFree(LargestVT, VT))
4020         Value = DAG.getNode(ISD::TRUNCATE, dl, VT, MemSetValue);
4021       else
4022         Value = getMemsetValue(Src, VT, DAG, dl);
4023     }
4024     assert(Value.getValueType() == VT && "Value with wrong type.");
4025     SDValue Store = DAG.getStore(Chain, dl, Value,
4026                                  getMemBasePlusOffset(Dst, DstOff, dl, DAG),
4027                                  DstPtrInfo.getWithOffset(DstOff),
4028                                  isVol, false, Align);
4029     OutChains.push_back(Store);
4030     DstOff += VT.getSizeInBits() / 8;
4031     Size -= VTSize;
4032   }
4033
4034   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
4035                      &OutChains[0], OutChains.size());
4036 }
4037
4038 SDValue SelectionDAG::getMemcpy(SDValue Chain, SDLoc dl, SDValue Dst,
4039                                 SDValue Src, SDValue Size,
4040                                 unsigned Align, bool isVol, bool AlwaysInline,
4041                                 MachinePointerInfo DstPtrInfo,
4042                                 MachinePointerInfo SrcPtrInfo) {
4043   assert(Align && "The SDAG layer expects explicit alignment and reserves 0");
4044
4045   // Check to see if we should lower the memcpy to loads and stores first.
4046   // For cases within the target-specified limits, this is the best choice.
4047   ConstantSDNode *ConstantSize = dyn_cast<ConstantSDNode>(Size);
4048   if (ConstantSize) {
4049     // Memcpy with size zero? Just return the original chain.
4050     if (ConstantSize->isNullValue())
4051       return Chain;
4052
4053     SDValue Result = getMemcpyLoadsAndStores(*this, dl, Chain, Dst, Src,
4054                                              ConstantSize->getZExtValue(),Align,
4055                                 isVol, false, DstPtrInfo, SrcPtrInfo);
4056     if (Result.getNode())
4057       return Result;
4058   }
4059
4060   // Then check to see if we should lower the memcpy with target-specific
4061   // code. If the target chooses to do this, this is the next best.
4062   SDValue Result =
4063     TSI.EmitTargetCodeForMemcpy(*this, dl, Chain, Dst, Src, Size, Align,
4064                                 isVol, AlwaysInline,
4065                                 DstPtrInfo, SrcPtrInfo);
4066   if (Result.getNode())
4067     return Result;
4068
4069   // If we really need inline code and the target declined to provide it,
4070   // use a (potentially long) sequence of loads and stores.
4071   if (AlwaysInline) {
4072     assert(ConstantSize && "AlwaysInline requires a constant size!");
4073     return getMemcpyLoadsAndStores(*this, dl, Chain, Dst, Src,
4074                                    ConstantSize->getZExtValue(), Align, isVol,
4075                                    true, DstPtrInfo, SrcPtrInfo);
4076   }
4077
4078   // FIXME: If the memcpy is volatile (isVol), lowering it to a plain libc
4079   // memcpy is not guaranteed to be safe. libc memcpys aren't required to
4080   // respect volatile, so they may do things like read or write memory
4081   // beyond the given memory regions. But fixing this isn't easy, and most
4082   // people don't care.
4083
4084   const TargetLowering *TLI = TM.getTargetLowering();
4085
4086   // Emit a library call.
4087   TargetLowering::ArgListTy Args;
4088   TargetLowering::ArgListEntry Entry;
4089   Entry.Ty = TLI->getDataLayout()->getIntPtrType(*getContext());
4090   Entry.Node = Dst; Args.push_back(Entry);
4091   Entry.Node = Src; Args.push_back(Entry);
4092   Entry.Node = Size; Args.push_back(Entry);
4093   // FIXME: pass in SDLoc
4094   TargetLowering::
4095   CallLoweringInfo CLI(Chain, Type::getVoidTy(*getContext()),
4096                     false, false, false, false, 0,
4097                     TLI->getLibcallCallingConv(RTLIB::MEMCPY),
4098                     /*isTailCall=*/false,
4099                     /*doesNotReturn=*/false, /*isReturnValueUsed=*/false,
4100                     getExternalSymbol(TLI->getLibcallName(RTLIB::MEMCPY),
4101                                       TLI->getPointerTy()),
4102                     Args, *this, dl);
4103   std::pair<SDValue,SDValue> CallResult = TLI->LowerCallTo(CLI);
4104
4105   return CallResult.second;
4106 }
4107
4108 SDValue SelectionDAG::getMemmove(SDValue Chain, SDLoc dl, SDValue Dst,
4109                                  SDValue Src, SDValue Size,
4110                                  unsigned Align, bool isVol,
4111                                  MachinePointerInfo DstPtrInfo,
4112                                  MachinePointerInfo SrcPtrInfo) {
4113   assert(Align && "The SDAG layer expects explicit alignment and reserves 0");
4114
4115   // Check to see if we should lower the memmove to loads and stores first.
4116   // For cases within the target-specified limits, this is the best choice.
4117   ConstantSDNode *ConstantSize = dyn_cast<ConstantSDNode>(Size);
4118   if (ConstantSize) {
4119     // Memmove with size zero? Just return the original chain.
4120     if (ConstantSize->isNullValue())
4121       return Chain;
4122
4123     SDValue Result =
4124       getMemmoveLoadsAndStores(*this, dl, Chain, Dst, Src,
4125                                ConstantSize->getZExtValue(), Align, isVol,
4126                                false, DstPtrInfo, SrcPtrInfo);
4127     if (Result.getNode())
4128       return Result;
4129   }
4130
4131   // Then check to see if we should lower the memmove with target-specific
4132   // code. If the target chooses to do this, this is the next best.
4133   SDValue Result =
4134     TSI.EmitTargetCodeForMemmove(*this, dl, Chain, Dst, Src, Size, Align, isVol,
4135                                  DstPtrInfo, SrcPtrInfo);
4136   if (Result.getNode())
4137     return Result;
4138
4139   // FIXME: If the memmove is volatile, lowering it to plain libc memmove may
4140   // not be safe.  See memcpy above for more details.
4141
4142   const TargetLowering *TLI = TM.getTargetLowering();
4143
4144   // Emit a library call.
4145   TargetLowering::ArgListTy Args;
4146   TargetLowering::ArgListEntry Entry;
4147   Entry.Ty = TLI->getDataLayout()->getIntPtrType(*getContext());
4148   Entry.Node = Dst; Args.push_back(Entry);
4149   Entry.Node = Src; Args.push_back(Entry);
4150   Entry.Node = Size; Args.push_back(Entry);
4151   // FIXME:  pass in SDLoc
4152   TargetLowering::
4153   CallLoweringInfo CLI(Chain, Type::getVoidTy(*getContext()),
4154                     false, false, false, false, 0,
4155                     TLI->getLibcallCallingConv(RTLIB::MEMMOVE),
4156                     /*isTailCall=*/false,
4157                     /*doesNotReturn=*/false, /*isReturnValueUsed=*/false,
4158                     getExternalSymbol(TLI->getLibcallName(RTLIB::MEMMOVE),
4159                                       TLI->getPointerTy()),
4160                     Args, *this, dl);
4161   std::pair<SDValue,SDValue> CallResult = TLI->LowerCallTo(CLI);
4162
4163   return CallResult.second;
4164 }
4165
4166 SDValue SelectionDAG::getMemset(SDValue Chain, SDLoc dl, SDValue Dst,
4167                                 SDValue Src, SDValue Size,
4168                                 unsigned Align, bool isVol,
4169                                 MachinePointerInfo DstPtrInfo) {
4170   assert(Align && "The SDAG layer expects explicit alignment and reserves 0");
4171
4172   // Check to see if we should lower the memset to stores first.
4173   // For cases within the target-specified limits, this is the best choice.
4174   ConstantSDNode *ConstantSize = dyn_cast<ConstantSDNode>(Size);
4175   if (ConstantSize) {
4176     // Memset with size zero? Just return the original chain.
4177     if (ConstantSize->isNullValue())
4178       return Chain;
4179
4180     SDValue Result =
4181       getMemsetStores(*this, dl, Chain, Dst, Src, ConstantSize->getZExtValue(),
4182                       Align, isVol, DstPtrInfo);
4183
4184     if (Result.getNode())
4185       return Result;
4186   }
4187
4188   // Then check to see if we should lower the memset with target-specific
4189   // code. If the target chooses to do this, this is the next best.
4190   SDValue Result =
4191     TSI.EmitTargetCodeForMemset(*this, dl, Chain, Dst, Src, Size, Align, isVol,
4192                                 DstPtrInfo);
4193   if (Result.getNode())
4194     return Result;
4195
4196   // Emit a library call.
4197   const TargetLowering *TLI = TM.getTargetLowering();
4198   Type *IntPtrTy = TLI->getDataLayout()->getIntPtrType(*getContext());
4199   TargetLowering::ArgListTy Args;
4200   TargetLowering::ArgListEntry Entry;
4201   Entry.Node = Dst; Entry.Ty = IntPtrTy;
4202   Args.push_back(Entry);
4203   // Extend or truncate the argument to be an i32 value for the call.
4204   if (Src.getValueType().bitsGT(MVT::i32))
4205     Src = getNode(ISD::TRUNCATE, dl, MVT::i32, Src);
4206   else
4207     Src = getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Src);
4208   Entry.Node = Src;
4209   Entry.Ty = Type::getInt32Ty(*getContext());
4210   Entry.isSExt = true;
4211   Args.push_back(Entry);
4212   Entry.Node = Size;
4213   Entry.Ty = IntPtrTy;
4214   Entry.isSExt = false;
4215   Args.push_back(Entry);
4216   // FIXME: pass in SDLoc
4217   TargetLowering::
4218   CallLoweringInfo CLI(Chain, Type::getVoidTy(*getContext()),
4219                     false, false, false, false, 0,
4220                     TLI->getLibcallCallingConv(RTLIB::MEMSET),
4221                     /*isTailCall=*/false,
4222                     /*doesNotReturn*/false, /*isReturnValueUsed=*/false,
4223                     getExternalSymbol(TLI->getLibcallName(RTLIB::MEMSET),
4224                                       TLI->getPointerTy()),
4225                     Args, *this, dl);
4226   std::pair<SDValue,SDValue> CallResult = TLI->LowerCallTo(CLI);
4227
4228   return CallResult.second;
4229 }
4230
4231 SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
4232                                 SDVTList VTList, SDValue *Ops, unsigned NumOps,
4233                                 MachineMemOperand *MMO,
4234                                 AtomicOrdering SuccessOrdering,
4235                                 AtomicOrdering FailureOrdering,
4236                                 SynchronizationScope SynchScope) {
4237   FoldingSetNodeID ID;
4238   ID.AddInteger(MemVT.getRawBits());
4239   AddNodeIDNode(ID, Opcode, VTList, Ops, NumOps);
4240   ID.AddInteger(MMO->getPointerInfo().getAddrSpace());
4241   void* IP = 0;
4242   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
4243     cast<AtomicSDNode>(E)->refineAlignment(MMO);
4244     return SDValue(E, 0);
4245   }
4246
4247   // Allocate the operands array for the node out of the BumpPtrAllocator, since
4248   // SDNode doesn't have access to it.  This memory will be "leaked" when
4249   // the node is deallocated, but recovered when the allocator is released.
4250   // If the number of operands is less than 5 we use AtomicSDNode's internal
4251   // storage.
4252   SDUse *DynOps = NumOps > 4 ? OperandAllocator.Allocate<SDUse>(NumOps) : 0;
4253
4254   SDNode *N = new (NodeAllocator) AtomicSDNode(Opcode, dl.getIROrder(),
4255                                                dl.getDebugLoc(), VTList, MemVT,
4256                                                Ops, DynOps, NumOps, MMO,
4257                                                SuccessOrdering, FailureOrdering,
4258                                                SynchScope);
4259   CSEMap.InsertNode(N, IP);
4260   AllNodes.push_back(N);
4261   return SDValue(N, 0);
4262 }
4263
4264 SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
4265                                 SDVTList VTList, SDValue *Ops, unsigned NumOps,
4266                                 MachineMemOperand *MMO,
4267                                 AtomicOrdering Ordering,
4268                                 SynchronizationScope SynchScope) {
4269   return getAtomic(Opcode, dl, MemVT, VTList, Ops, NumOps, MMO, Ordering,
4270                    Ordering, SynchScope);
4271 }
4272
4273 SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
4274                                 SDValue Chain, SDValue Ptr, SDValue Cmp,
4275                                 SDValue Swp, MachinePointerInfo PtrInfo,
4276                                 unsigned Alignment,
4277                                 AtomicOrdering SuccessOrdering,
4278                                 AtomicOrdering FailureOrdering,
4279                                 SynchronizationScope SynchScope) {
4280   if (Alignment == 0)  // Ensure that codegen never sees alignment 0
4281     Alignment = getEVTAlignment(MemVT);
4282
4283   MachineFunction &MF = getMachineFunction();
4284
4285   // All atomics are load and store, except for ATMOIC_LOAD and ATOMIC_STORE.
4286   // For now, atomics are considered to be volatile always.
4287   // FIXME: Volatile isn't really correct; we should keep track of atomic
4288   // orderings in the memoperand.
4289   unsigned Flags = MachineMemOperand::MOVolatile;
4290   if (Opcode != ISD::ATOMIC_STORE)
4291     Flags |= MachineMemOperand::MOLoad;
4292   if (Opcode != ISD::ATOMIC_LOAD)
4293     Flags |= MachineMemOperand::MOStore;
4294
4295   MachineMemOperand *MMO =
4296     MF.getMachineMemOperand(PtrInfo, Flags, MemVT.getStoreSize(), Alignment);
4297
4298   return getAtomic(Opcode, dl, MemVT, Chain, Ptr, Cmp, Swp, MMO,
4299                    SuccessOrdering, FailureOrdering, SynchScope);
4300 }
4301
4302 SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
4303                                 SDValue Chain,
4304                                 SDValue Ptr, SDValue Cmp,
4305                                 SDValue Swp, MachineMemOperand *MMO,
4306                                 AtomicOrdering SuccessOrdering,
4307                                 AtomicOrdering FailureOrdering,
4308                                 SynchronizationScope SynchScope) {
4309   assert(Opcode == ISD::ATOMIC_CMP_SWAP && "Invalid Atomic Op");
4310   assert(Cmp.getValueType() == Swp.getValueType() && "Invalid Atomic Op Types");
4311
4312   EVT VT = Cmp.getValueType();
4313
4314   SDVTList VTs = getVTList(VT, MVT::Other);
4315   SDValue Ops[] = {Chain, Ptr, Cmp, Swp};
4316   return getAtomic(Opcode, dl, MemVT, VTs, Ops, 4, MMO, SuccessOrdering,
4317                    FailureOrdering, SynchScope);
4318 }
4319
4320 SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
4321                                 SDValue Chain,
4322                                 SDValue Ptr, SDValue Val,
4323                                 const Value* PtrVal,
4324                                 unsigned Alignment,
4325                                 AtomicOrdering Ordering,
4326                                 SynchronizationScope SynchScope) {
4327   if (Alignment == 0)  // Ensure that codegen never sees alignment 0
4328     Alignment = getEVTAlignment(MemVT);
4329
4330   MachineFunction &MF = getMachineFunction();
4331   // An atomic store does not load. An atomic load does not store.
4332   // (An atomicrmw obviously both loads and stores.)
4333   // For now, atomics are considered to be volatile always, and they are
4334   // chained as such.
4335   // FIXME: Volatile isn't really correct; we should keep track of atomic
4336   // orderings in the memoperand.
4337   unsigned Flags = MachineMemOperand::MOVolatile;
4338   if (Opcode != ISD::ATOMIC_STORE)
4339     Flags |= MachineMemOperand::MOLoad;
4340   if (Opcode != ISD::ATOMIC_LOAD)
4341     Flags |= MachineMemOperand::MOStore;
4342
4343   MachineMemOperand *MMO =
4344     MF.getMachineMemOperand(MachinePointerInfo(PtrVal), Flags,
4345                             MemVT.getStoreSize(), Alignment);
4346
4347   return getAtomic(Opcode, dl, MemVT, Chain, Ptr, Val, MMO,
4348                    Ordering, SynchScope);
4349 }
4350
4351 SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
4352                                 SDValue Chain,
4353                                 SDValue Ptr, SDValue Val,
4354                                 MachineMemOperand *MMO,
4355                                 AtomicOrdering Ordering,
4356                                 SynchronizationScope SynchScope) {
4357   assert((Opcode == ISD::ATOMIC_LOAD_ADD ||
4358           Opcode == ISD::ATOMIC_LOAD_SUB ||
4359           Opcode == ISD::ATOMIC_LOAD_AND ||
4360           Opcode == ISD::ATOMIC_LOAD_OR ||
4361           Opcode == ISD::ATOMIC_LOAD_XOR ||
4362           Opcode == ISD::ATOMIC_LOAD_NAND ||
4363           Opcode == ISD::ATOMIC_LOAD_MIN ||
4364           Opcode == ISD::ATOMIC_LOAD_MAX ||
4365           Opcode == ISD::ATOMIC_LOAD_UMIN ||
4366           Opcode == ISD::ATOMIC_LOAD_UMAX ||
4367           Opcode == ISD::ATOMIC_SWAP ||
4368           Opcode == ISD::ATOMIC_STORE) &&
4369          "Invalid Atomic Op");
4370
4371   EVT VT = Val.getValueType();
4372
4373   SDVTList VTs = Opcode == ISD::ATOMIC_STORE ? getVTList(MVT::Other) :
4374                                                getVTList(VT, MVT::Other);
4375   SDValue Ops[] = {Chain, Ptr, Val};
4376   return getAtomic(Opcode, dl, MemVT, VTs, Ops, 3, MMO, Ordering, SynchScope);
4377 }
4378
4379 SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
4380                                 EVT VT, SDValue Chain,
4381                                 SDValue Ptr,
4382                                 const Value* PtrVal,
4383                                 unsigned Alignment,
4384                                 AtomicOrdering Ordering,
4385                                 SynchronizationScope SynchScope) {
4386   if (Alignment == 0)  // Ensure that codegen never sees alignment 0
4387     Alignment = getEVTAlignment(MemVT);
4388
4389   MachineFunction &MF = getMachineFunction();
4390   // An atomic store does not load. An atomic load does not store.
4391   // (An atomicrmw obviously both loads and stores.)
4392   // For now, atomics are considered to be volatile always, and they are
4393   // chained as such.
4394   // FIXME: Volatile isn't really correct; we should keep track of atomic
4395   // orderings in the memoperand.
4396   unsigned Flags = MachineMemOperand::MOVolatile;
4397   if (Opcode != ISD::ATOMIC_STORE)
4398     Flags |= MachineMemOperand::MOLoad;
4399   if (Opcode != ISD::ATOMIC_LOAD)
4400     Flags |= MachineMemOperand::MOStore;
4401
4402   MachineMemOperand *MMO =
4403     MF.getMachineMemOperand(MachinePointerInfo(PtrVal), Flags,
4404                             MemVT.getStoreSize(), Alignment);
4405
4406   return getAtomic(Opcode, dl, MemVT, VT, Chain, Ptr, MMO,
4407                    Ordering, SynchScope);
4408 }
4409
4410 SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
4411                                 EVT VT, SDValue Chain,
4412                                 SDValue Ptr,
4413                                 MachineMemOperand *MMO,
4414                                 AtomicOrdering Ordering,
4415                                 SynchronizationScope SynchScope) {
4416   assert(Opcode == ISD::ATOMIC_LOAD && "Invalid Atomic Op");
4417
4418   SDVTList VTs = getVTList(VT, MVT::Other);
4419   SDValue Ops[] = {Chain, Ptr};
4420   return getAtomic(Opcode, dl, MemVT, VTs, Ops, 2, MMO, Ordering, SynchScope);
4421 }
4422
4423 /// getMergeValues - Create a MERGE_VALUES node from the given operands.
4424 SDValue SelectionDAG::getMergeValues(const SDValue *Ops, unsigned NumOps,
4425                                      SDLoc dl) {
4426   if (NumOps == 1)
4427     return Ops[0];
4428
4429   SmallVector<EVT, 4> VTs;
4430   VTs.reserve(NumOps);
4431   for (unsigned i = 0; i < NumOps; ++i)
4432     VTs.push_back(Ops[i].getValueType());
4433   return getNode(ISD::MERGE_VALUES, dl, getVTList(&VTs[0], NumOps),
4434                  Ops, NumOps);
4435 }
4436
4437 SDValue
4438 SelectionDAG::getMemIntrinsicNode(unsigned Opcode, SDLoc dl,
4439                                   const EVT *VTs, unsigned NumVTs,
4440                                   const SDValue *Ops, unsigned NumOps,
4441                                   EVT MemVT, MachinePointerInfo PtrInfo,
4442                                   unsigned Align, bool Vol,
4443                                   bool ReadMem, bool WriteMem) {
4444   return getMemIntrinsicNode(Opcode, dl, makeVTList(VTs, NumVTs), Ops, NumOps,
4445                              MemVT, PtrInfo, Align, Vol,
4446                              ReadMem, WriteMem);
4447 }
4448
4449 SDValue
4450 SelectionDAG::getMemIntrinsicNode(unsigned Opcode, SDLoc dl, SDVTList VTList,
4451                                   const SDValue *Ops, unsigned NumOps,
4452                                   EVT MemVT, MachinePointerInfo PtrInfo,
4453                                   unsigned Align, bool Vol,
4454                                   bool ReadMem, bool WriteMem) {
4455   if (Align == 0)  // Ensure that codegen never sees alignment 0
4456     Align = getEVTAlignment(MemVT);
4457
4458   MachineFunction &MF = getMachineFunction();
4459   unsigned Flags = 0;
4460   if (WriteMem)
4461     Flags |= MachineMemOperand::MOStore;
4462   if (ReadMem)
4463     Flags |= MachineMemOperand::MOLoad;
4464   if (Vol)
4465     Flags |= MachineMemOperand::MOVolatile;
4466   MachineMemOperand *MMO =
4467     MF.getMachineMemOperand(PtrInfo, Flags, MemVT.getStoreSize(), Align);
4468
4469   return getMemIntrinsicNode(Opcode, dl, VTList, Ops, NumOps, MemVT, MMO);
4470 }
4471
4472 SDValue
4473 SelectionDAG::getMemIntrinsicNode(unsigned Opcode, SDLoc dl, SDVTList VTList,
4474                                   const SDValue *Ops, unsigned NumOps,
4475                                   EVT MemVT, MachineMemOperand *MMO) {
4476   assert((Opcode == ISD::INTRINSIC_VOID ||
4477           Opcode == ISD::INTRINSIC_W_CHAIN ||
4478           Opcode == ISD::PREFETCH ||
4479           Opcode == ISD::LIFETIME_START ||
4480           Opcode == ISD::LIFETIME_END ||
4481           (Opcode <= INT_MAX &&
4482            (int)Opcode >= ISD::FIRST_TARGET_MEMORY_OPCODE)) &&
4483          "Opcode is not a memory-accessing opcode!");
4484
4485   // Memoize the node unless it returns a flag.
4486   MemIntrinsicSDNode *N;
4487   if (VTList.VTs[VTList.NumVTs-1] != MVT::Glue) {
4488     FoldingSetNodeID ID;
4489     AddNodeIDNode(ID, Opcode, VTList, Ops, NumOps);
4490     ID.AddInteger(MMO->getPointerInfo().getAddrSpace());
4491     void *IP = 0;
4492     if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
4493       cast<MemIntrinsicSDNode>(E)->refineAlignment(MMO);
4494       return SDValue(E, 0);
4495     }
4496
4497     N = new (NodeAllocator) MemIntrinsicSDNode(Opcode, dl.getIROrder(),
4498                                                dl.getDebugLoc(), VTList, Ops,
4499                                                NumOps, MemVT, MMO);
4500     CSEMap.InsertNode(N, IP);
4501   } else {
4502     N = new (NodeAllocator) MemIntrinsicSDNode(Opcode, dl.getIROrder(),
4503                                                dl.getDebugLoc(), VTList, Ops,
4504                                                NumOps, MemVT, MMO);
4505   }
4506   AllNodes.push_back(N);
4507   return SDValue(N, 0);
4508 }
4509
4510 /// InferPointerInfo - If the specified ptr/offset is a frame index, infer a
4511 /// MachinePointerInfo record from it.  This is particularly useful because the
4512 /// code generator has many cases where it doesn't bother passing in a
4513 /// MachinePointerInfo to getLoad or getStore when it has "FI+Cst".
4514 static MachinePointerInfo InferPointerInfo(SDValue Ptr, int64_t Offset = 0) {
4515   // If this is FI+Offset, we can model it.
4516   if (const FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Ptr))
4517     return MachinePointerInfo::getFixedStack(FI->getIndex(), Offset);
4518
4519   // If this is (FI+Offset1)+Offset2, we can model it.
4520   if (Ptr.getOpcode() != ISD::ADD ||
4521       !isa<ConstantSDNode>(Ptr.getOperand(1)) ||
4522       !isa<FrameIndexSDNode>(Ptr.getOperand(0)))
4523     return MachinePointerInfo();
4524
4525   int FI = cast<FrameIndexSDNode>(Ptr.getOperand(0))->getIndex();
4526   return MachinePointerInfo::getFixedStack(FI, Offset+
4527                        cast<ConstantSDNode>(Ptr.getOperand(1))->getSExtValue());
4528 }
4529
4530 /// InferPointerInfo - If the specified ptr/offset is a frame index, infer a
4531 /// MachinePointerInfo record from it.  This is particularly useful because the
4532 /// code generator has many cases where it doesn't bother passing in a
4533 /// MachinePointerInfo to getLoad or getStore when it has "FI+Cst".
4534 static MachinePointerInfo InferPointerInfo(SDValue Ptr, SDValue OffsetOp) {
4535   // If the 'Offset' value isn't a constant, we can't handle this.
4536   if (ConstantSDNode *OffsetNode = dyn_cast<ConstantSDNode>(OffsetOp))
4537     return InferPointerInfo(Ptr, OffsetNode->getSExtValue());
4538   if (OffsetOp.getOpcode() == ISD::UNDEF)
4539     return InferPointerInfo(Ptr);
4540   return MachinePointerInfo();
4541 }
4542
4543
4544 SDValue
4545 SelectionDAG::getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType,
4546                       EVT VT, SDLoc dl, SDValue Chain,
4547                       SDValue Ptr, SDValue Offset,
4548                       MachinePointerInfo PtrInfo, EVT MemVT,
4549                       bool isVolatile, bool isNonTemporal, bool isInvariant,
4550                       unsigned Alignment, const MDNode *TBAAInfo,
4551                       const MDNode *Ranges) {
4552   assert(Chain.getValueType() == MVT::Other &&
4553         "Invalid chain type");
4554   if (Alignment == 0)  // Ensure that codegen never sees alignment 0
4555     Alignment = getEVTAlignment(VT);
4556
4557   unsigned Flags = MachineMemOperand::MOLoad;
4558   if (isVolatile)
4559     Flags |= MachineMemOperand::MOVolatile;
4560   if (isNonTemporal)
4561     Flags |= MachineMemOperand::MONonTemporal;
4562   if (isInvariant)
4563     Flags |= MachineMemOperand::MOInvariant;
4564
4565   // If we don't have a PtrInfo, infer the trivial frame index case to simplify
4566   // clients.
4567   if (PtrInfo.V == 0)
4568     PtrInfo = InferPointerInfo(Ptr, Offset);
4569
4570   MachineFunction &MF = getMachineFunction();
4571   MachineMemOperand *MMO =
4572     MF.getMachineMemOperand(PtrInfo, Flags, MemVT.getStoreSize(), Alignment,
4573                             TBAAInfo, Ranges);
4574   return getLoad(AM, ExtType, VT, dl, Chain, Ptr, Offset, MemVT, MMO);
4575 }
4576
4577 SDValue
4578 SelectionDAG::getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType,
4579                       EVT VT, SDLoc dl, SDValue Chain,
4580                       SDValue Ptr, SDValue Offset, EVT MemVT,
4581                       MachineMemOperand *MMO) {
4582   if (VT == MemVT) {
4583     ExtType = ISD::NON_EXTLOAD;
4584   } else if (ExtType == ISD::NON_EXTLOAD) {
4585     assert(VT == MemVT && "Non-extending load from different memory type!");
4586   } else {
4587     // Extending load.
4588     assert(MemVT.getScalarType().bitsLT(VT.getScalarType()) &&
4589            "Should only be an extending load, not truncating!");
4590     assert(VT.isInteger() == MemVT.isInteger() &&
4591            "Cannot convert from FP to Int or Int -> FP!");
4592     assert(VT.isVector() == MemVT.isVector() &&
4593            "Cannot use trunc store to convert to or from a vector!");
4594     assert((!VT.isVector() ||
4595             VT.getVectorNumElements() == MemVT.getVectorNumElements()) &&
4596            "Cannot use trunc store to change the number of vector elements!");
4597   }
4598
4599   bool Indexed = AM != ISD::UNINDEXED;
4600   assert((Indexed || Offset.getOpcode() == ISD::UNDEF) &&
4601          "Unindexed load with an offset!");
4602
4603   SDVTList VTs = Indexed ?
4604     getVTList(VT, Ptr.getValueType(), MVT::Other) : getVTList(VT, MVT::Other);
4605   SDValue Ops[] = { Chain, Ptr, Offset };
4606   FoldingSetNodeID ID;
4607   AddNodeIDNode(ID, ISD::LOAD, VTs, Ops, 3);
4608   ID.AddInteger(MemVT.getRawBits());
4609   ID.AddInteger(encodeMemSDNodeFlags(ExtType, AM, MMO->isVolatile(),
4610                                      MMO->isNonTemporal(),
4611                                      MMO->isInvariant()));
4612   ID.AddInteger(MMO->getPointerInfo().getAddrSpace());
4613   void *IP = 0;
4614   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
4615     cast<LoadSDNode>(E)->refineAlignment(MMO);
4616     return SDValue(E, 0);
4617   }
4618   SDNode *N = new (NodeAllocator) LoadSDNode(Ops, dl.getIROrder(),
4619                                              dl.getDebugLoc(), VTs, AM, ExtType,
4620                                              MemVT, MMO);
4621   CSEMap.InsertNode(N, IP);
4622   AllNodes.push_back(N);
4623   return SDValue(N, 0);
4624 }
4625
4626 SDValue SelectionDAG::getLoad(EVT VT, SDLoc dl,
4627                               SDValue Chain, SDValue Ptr,
4628                               MachinePointerInfo PtrInfo,
4629                               bool isVolatile, bool isNonTemporal,
4630                               bool isInvariant, unsigned Alignment,
4631                               const MDNode *TBAAInfo,
4632                               const MDNode *Ranges) {
4633   SDValue Undef = getUNDEF(Ptr.getValueType());
4634   return getLoad(ISD::UNINDEXED, ISD::NON_EXTLOAD, VT, dl, Chain, Ptr, Undef,
4635                  PtrInfo, VT, isVolatile, isNonTemporal, isInvariant, Alignment,
4636                  TBAAInfo, Ranges);
4637 }
4638
4639 SDValue SelectionDAG::getLoad(EVT VT, SDLoc dl,
4640                               SDValue Chain, SDValue Ptr,
4641                               MachineMemOperand *MMO) {
4642   SDValue Undef = getUNDEF(Ptr.getValueType());
4643   return getLoad(ISD::UNINDEXED, ISD::NON_EXTLOAD, VT, dl, Chain, Ptr, Undef,
4644                  VT, MMO);
4645 }
4646
4647 SDValue SelectionDAG::getExtLoad(ISD::LoadExtType ExtType, SDLoc dl, EVT VT,
4648                                  SDValue Chain, SDValue Ptr,
4649                                  MachinePointerInfo PtrInfo, EVT MemVT,
4650                                  bool isVolatile, bool isNonTemporal,
4651                                  unsigned Alignment, const MDNode *TBAAInfo) {
4652   SDValue Undef = getUNDEF(Ptr.getValueType());
4653   return getLoad(ISD::UNINDEXED, ExtType, VT, dl, Chain, Ptr, Undef,
4654                  PtrInfo, MemVT, isVolatile, isNonTemporal, false, Alignment,
4655                  TBAAInfo);
4656 }
4657
4658
4659 SDValue SelectionDAG::getExtLoad(ISD::LoadExtType ExtType, SDLoc dl, EVT VT,
4660                                  SDValue Chain, SDValue Ptr, EVT MemVT,
4661                                  MachineMemOperand *MMO) {
4662   SDValue Undef = getUNDEF(Ptr.getValueType());
4663   return getLoad(ISD::UNINDEXED, ExtType, VT, dl, Chain, Ptr, Undef,
4664                  MemVT, MMO);
4665 }
4666
4667 SDValue
4668 SelectionDAG::getIndexedLoad(SDValue OrigLoad, SDLoc dl, SDValue Base,
4669                              SDValue Offset, ISD::MemIndexedMode AM) {
4670   LoadSDNode *LD = cast<LoadSDNode>(OrigLoad);
4671   assert(LD->getOffset().getOpcode() == ISD::UNDEF &&
4672          "Load is already a indexed load!");
4673   return getLoad(AM, LD->getExtensionType(), OrigLoad.getValueType(), dl,
4674                  LD->getChain(), Base, Offset, LD->getPointerInfo(),
4675                  LD->getMemoryVT(), LD->isVolatile(), LD->isNonTemporal(),
4676                  false, LD->getAlignment());
4677 }
4678
4679 SDValue SelectionDAG::getStore(SDValue Chain, SDLoc dl, SDValue Val,
4680                                SDValue Ptr, MachinePointerInfo PtrInfo,
4681                                bool isVolatile, bool isNonTemporal,
4682                                unsigned Alignment, const MDNode *TBAAInfo) {
4683   assert(Chain.getValueType() == MVT::Other &&
4684         "Invalid chain type");
4685   if (Alignment == 0)  // Ensure that codegen never sees alignment 0
4686     Alignment = getEVTAlignment(Val.getValueType());
4687
4688   unsigned Flags = MachineMemOperand::MOStore;
4689   if (isVolatile)
4690     Flags |= MachineMemOperand::MOVolatile;
4691   if (isNonTemporal)
4692     Flags |= MachineMemOperand::MONonTemporal;
4693
4694   if (PtrInfo.V == 0)
4695     PtrInfo = InferPointerInfo(Ptr);
4696
4697   MachineFunction &MF = getMachineFunction();
4698   MachineMemOperand *MMO =
4699     MF.getMachineMemOperand(PtrInfo, Flags,
4700                             Val.getValueType().getStoreSize(), Alignment,
4701                             TBAAInfo);
4702
4703   return getStore(Chain, dl, Val, Ptr, MMO);
4704 }
4705
4706 SDValue SelectionDAG::getStore(SDValue Chain, SDLoc dl, SDValue Val,
4707                                SDValue Ptr, MachineMemOperand *MMO) {
4708   assert(Chain.getValueType() == MVT::Other &&
4709         "Invalid chain type");
4710   EVT VT = Val.getValueType();
4711   SDVTList VTs = getVTList(MVT::Other);
4712   SDValue Undef = getUNDEF(Ptr.getValueType());
4713   SDValue Ops[] = { Chain, Val, Ptr, Undef };
4714   FoldingSetNodeID ID;
4715   AddNodeIDNode(ID, ISD::STORE, VTs, Ops, 4);
4716   ID.AddInteger(VT.getRawBits());
4717   ID.AddInteger(encodeMemSDNodeFlags(false, ISD::UNINDEXED, MMO->isVolatile(),
4718                                      MMO->isNonTemporal(), MMO->isInvariant()));
4719   ID.AddInteger(MMO->getPointerInfo().getAddrSpace());
4720   void *IP = 0;
4721   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
4722     cast<StoreSDNode>(E)->refineAlignment(MMO);
4723     return SDValue(E, 0);
4724   }
4725   SDNode *N = new (NodeAllocator) StoreSDNode(Ops, dl.getIROrder(),
4726                                               dl.getDebugLoc(), VTs,
4727                                               ISD::UNINDEXED, false, VT, MMO);
4728   CSEMap.InsertNode(N, IP);
4729   AllNodes.push_back(N);
4730   return SDValue(N, 0);
4731 }
4732
4733 SDValue SelectionDAG::getTruncStore(SDValue Chain, SDLoc dl, SDValue Val,
4734                                     SDValue Ptr, MachinePointerInfo PtrInfo,
4735                                     EVT SVT,bool isVolatile, bool isNonTemporal,
4736                                     unsigned Alignment,
4737                                     const MDNode *TBAAInfo) {
4738   assert(Chain.getValueType() == MVT::Other &&
4739         "Invalid chain type");
4740   if (Alignment == 0)  // Ensure that codegen never sees alignment 0
4741     Alignment = getEVTAlignment(SVT);
4742
4743   unsigned Flags = MachineMemOperand::MOStore;
4744   if (isVolatile)
4745     Flags |= MachineMemOperand::MOVolatile;
4746   if (isNonTemporal)
4747     Flags |= MachineMemOperand::MONonTemporal;
4748
4749   if (PtrInfo.V == 0)
4750     PtrInfo = InferPointerInfo(Ptr);
4751
4752   MachineFunction &MF = getMachineFunction();
4753   MachineMemOperand *MMO =
4754     MF.getMachineMemOperand(PtrInfo, Flags, SVT.getStoreSize(), Alignment,
4755                             TBAAInfo);
4756
4757   return getTruncStore(Chain, dl, Val, Ptr, SVT, MMO);
4758 }
4759
4760 SDValue SelectionDAG::getTruncStore(SDValue Chain, SDLoc dl, SDValue Val,
4761                                     SDValue Ptr, EVT SVT,
4762                                     MachineMemOperand *MMO) {
4763   EVT VT = Val.getValueType();
4764
4765   assert(Chain.getValueType() == MVT::Other &&
4766         "Invalid chain type");
4767   if (VT == SVT)
4768     return getStore(Chain, dl, Val, Ptr, MMO);
4769
4770   assert(SVT.getScalarType().bitsLT(VT.getScalarType()) &&
4771          "Should only be a truncating store, not extending!");
4772   assert(VT.isInteger() == SVT.isInteger() &&
4773          "Can't do FP-INT conversion!");
4774   assert(VT.isVector() == SVT.isVector() &&
4775          "Cannot use trunc store to convert to or from a vector!");
4776   assert((!VT.isVector() ||
4777           VT.getVectorNumElements() == SVT.getVectorNumElements()) &&
4778          "Cannot use trunc store to change the number of vector elements!");
4779
4780   SDVTList VTs = getVTList(MVT::Other);
4781   SDValue Undef = getUNDEF(Ptr.getValueType());
4782   SDValue Ops[] = { Chain, Val, Ptr, Undef };
4783   FoldingSetNodeID ID;
4784   AddNodeIDNode(ID, ISD::STORE, VTs, Ops, 4);
4785   ID.AddInteger(SVT.getRawBits());
4786   ID.AddInteger(encodeMemSDNodeFlags(true, ISD::UNINDEXED, MMO->isVolatile(),
4787                                      MMO->isNonTemporal(), MMO->isInvariant()));
4788   ID.AddInteger(MMO->getPointerInfo().getAddrSpace());
4789   void *IP = 0;
4790   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
4791     cast<StoreSDNode>(E)->refineAlignment(MMO);
4792     return SDValue(E, 0);
4793   }
4794   SDNode *N = new (NodeAllocator) StoreSDNode(Ops, dl.getIROrder(),
4795                                               dl.getDebugLoc(), VTs,
4796                                               ISD::UNINDEXED, true, SVT, MMO);
4797   CSEMap.InsertNode(N, IP);
4798   AllNodes.push_back(N);
4799   return SDValue(N, 0);
4800 }
4801
4802 SDValue
4803 SelectionDAG::getIndexedStore(SDValue OrigStore, SDLoc dl, SDValue Base,
4804                               SDValue Offset, ISD::MemIndexedMode AM) {
4805   StoreSDNode *ST = cast<StoreSDNode>(OrigStore);
4806   assert(ST->getOffset().getOpcode() == ISD::UNDEF &&
4807          "Store is already a indexed store!");
4808   SDVTList VTs = getVTList(Base.getValueType(), MVT::Other);
4809   SDValue Ops[] = { ST->getChain(), ST->getValue(), Base, Offset };
4810   FoldingSetNodeID ID;
4811   AddNodeIDNode(ID, ISD::STORE, VTs, Ops, 4);
4812   ID.AddInteger(ST->getMemoryVT().getRawBits());
4813   ID.AddInteger(ST->getRawSubclassData());
4814   ID.AddInteger(ST->getPointerInfo().getAddrSpace());
4815   void *IP = 0;
4816   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
4817     return SDValue(E, 0);
4818
4819   SDNode *N = new (NodeAllocator) StoreSDNode(Ops, dl.getIROrder(),
4820                                               dl.getDebugLoc(), VTs, AM,
4821                                               ST->isTruncatingStore(),
4822                                               ST->getMemoryVT(),
4823                                               ST->getMemOperand());
4824   CSEMap.InsertNode(N, IP);
4825   AllNodes.push_back(N);
4826   return SDValue(N, 0);
4827 }
4828
4829 SDValue SelectionDAG::getVAArg(EVT VT, SDLoc dl,
4830                                SDValue Chain, SDValue Ptr,
4831                                SDValue SV,
4832                                unsigned Align) {
4833   SDValue Ops[] = { Chain, Ptr, SV, getTargetConstant(Align, MVT::i32) };
4834   return getNode(ISD::VAARG, dl, getVTList(VT, MVT::Other), Ops, 4);
4835 }
4836
4837 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT,
4838                               const SDUse *Ops, unsigned NumOps) {
4839   switch (NumOps) {
4840   case 0: return getNode(Opcode, DL, VT);
4841   case 1: return getNode(Opcode, DL, VT, Ops[0]);
4842   case 2: return getNode(Opcode, DL, VT, Ops[0], Ops[1]);
4843   case 3: return getNode(Opcode, DL, VT, Ops[0], Ops[1], Ops[2]);
4844   default: break;
4845   }
4846
4847   // Copy from an SDUse array into an SDValue array for use with
4848   // the regular getNode logic.
4849   SmallVector<SDValue, 8> NewOps(Ops, Ops + NumOps);
4850   return getNode(Opcode, DL, VT, &NewOps[0], NumOps);
4851 }
4852
4853 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT,
4854                               const SDValue *Ops, unsigned NumOps) {
4855   switch (NumOps) {
4856   case 0: return getNode(Opcode, DL, VT);
4857   case 1: return getNode(Opcode, DL, VT, Ops[0]);
4858   case 2: return getNode(Opcode, DL, VT, Ops[0], Ops[1]);
4859   case 3: return getNode(Opcode, DL, VT, Ops[0], Ops[1], Ops[2]);
4860   default: break;
4861   }
4862
4863   switch (Opcode) {
4864   default: break;
4865   case ISD::SELECT_CC: {
4866     assert(NumOps == 5 && "SELECT_CC takes 5 operands!");
4867     assert(Ops[0].getValueType() == Ops[1].getValueType() &&
4868            "LHS and RHS of condition must have same type!");
4869     assert(Ops[2].getValueType() == Ops[3].getValueType() &&
4870            "True and False arms of SelectCC must have same type!");
4871     assert(Ops[2].getValueType() == VT &&
4872            "select_cc node must be of same type as true and false value!");
4873     break;
4874   }
4875   case ISD::BR_CC: {
4876     assert(NumOps == 5 && "BR_CC takes 5 operands!");
4877     assert(Ops[2].getValueType() == Ops[3].getValueType() &&
4878            "LHS/RHS of comparison should match types!");
4879     break;
4880   }
4881   }
4882
4883   // Memoize nodes.
4884   SDNode *N;
4885   SDVTList VTs = getVTList(VT);
4886
4887   if (VT != MVT::Glue) {
4888     FoldingSetNodeID ID;
4889     AddNodeIDNode(ID, Opcode, VTs, Ops, NumOps);
4890     void *IP = 0;
4891
4892     if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
4893       return SDValue(E, 0);
4894
4895     N = new (NodeAllocator) SDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(),
4896                                    VTs, Ops, NumOps);
4897     CSEMap.InsertNode(N, IP);
4898   } else {
4899     N = new (NodeAllocator) SDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(),
4900                                    VTs, Ops, NumOps);
4901   }
4902
4903   AllNodes.push_back(N);
4904 #ifndef NDEBUG
4905   VerifySDNode(N);
4906 #endif
4907   return SDValue(N, 0);
4908 }
4909
4910 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL,
4911                               ArrayRef<EVT> ResultTys,
4912                               const SDValue *Ops, unsigned NumOps) {
4913   return getNode(Opcode, DL, getVTList(&ResultTys[0], ResultTys.size()),
4914                  Ops, NumOps);
4915 }
4916
4917 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL,
4918                               const EVT *VTs, unsigned NumVTs,
4919                               const SDValue *Ops, unsigned NumOps) {
4920   if (NumVTs == 1)
4921     return getNode(Opcode, DL, VTs[0], Ops, NumOps);
4922   return getNode(Opcode, DL, makeVTList(VTs, NumVTs), Ops, NumOps);
4923 }
4924
4925 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList,
4926                               const SDValue *Ops, unsigned NumOps) {
4927   if (VTList.NumVTs == 1)
4928     return getNode(Opcode, DL, VTList.VTs[0], Ops, NumOps);
4929
4930 #if 0
4931   switch (Opcode) {
4932   // FIXME: figure out how to safely handle things like
4933   // int foo(int x) { return 1 << (x & 255); }
4934   // int bar() { return foo(256); }
4935   case ISD::SRA_PARTS:
4936   case ISD::SRL_PARTS:
4937   case ISD::SHL_PARTS:
4938     if (N3.getOpcode() == ISD::SIGN_EXTEND_INREG &&
4939         cast<VTSDNode>(N3.getOperand(1))->getVT() != MVT::i1)
4940       return getNode(Opcode, DL, VT, N1, N2, N3.getOperand(0));
4941     else if (N3.getOpcode() == ISD::AND)
4942       if (ConstantSDNode *AndRHS = dyn_cast<ConstantSDNode>(N3.getOperand(1))) {
4943         // If the and is only masking out bits that cannot effect the shift,
4944         // eliminate the and.
4945         unsigned NumBits = VT.getScalarType().getSizeInBits()*2;
4946         if ((AndRHS->getValue() & (NumBits-1)) == NumBits-1)
4947           return getNode(Opcode, DL, VT, N1, N2, N3.getOperand(0));
4948       }
4949     break;
4950   }
4951 #endif
4952
4953   // Memoize the node unless it returns a flag.
4954   SDNode *N;
4955   if (VTList.VTs[VTList.NumVTs-1] != MVT::Glue) {
4956     FoldingSetNodeID ID;
4957     AddNodeIDNode(ID, Opcode, VTList, Ops, NumOps);
4958     void *IP = 0;
4959     if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
4960       return SDValue(E, 0);
4961
4962     if (NumOps == 1) {
4963       N = new (NodeAllocator) UnarySDNode(Opcode, DL.getIROrder(),
4964                                           DL.getDebugLoc(), VTList, Ops[0]);
4965     } else if (NumOps == 2) {
4966       N = new (NodeAllocator) BinarySDNode(Opcode, DL.getIROrder(),
4967                                            DL.getDebugLoc(), VTList, Ops[0],
4968                                            Ops[1]);
4969     } else if (NumOps == 3) {
4970       N = new (NodeAllocator) TernarySDNode(Opcode, DL.getIROrder(),
4971                                             DL.getDebugLoc(), VTList, Ops[0],
4972                                             Ops[1], Ops[2]);
4973     } else {
4974       N = new (NodeAllocator) SDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(),
4975                                      VTList, Ops, NumOps);
4976     }
4977     CSEMap.InsertNode(N, IP);
4978   } else {
4979     if (NumOps == 1) {
4980       N = new (NodeAllocator) UnarySDNode(Opcode, DL.getIROrder(),
4981                                           DL.getDebugLoc(), VTList, Ops[0]);
4982     } else if (NumOps == 2) {
4983       N = new (NodeAllocator) BinarySDNode(Opcode, DL.getIROrder(),
4984                                            DL.getDebugLoc(), VTList, Ops[0],
4985                                            Ops[1]);
4986     } else if (NumOps == 3) {
4987       N = new (NodeAllocator) TernarySDNode(Opcode, DL.getIROrder(),
4988                                             DL.getDebugLoc(), VTList, Ops[0],
4989                                             Ops[1], Ops[2]);
4990     } else {
4991       N = new (NodeAllocator) SDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(),
4992                                      VTList, Ops, NumOps);
4993     }
4994   }
4995   AllNodes.push_back(N);
4996 #ifndef NDEBUG
4997   VerifySDNode(N);
4998 #endif
4999   return SDValue(N, 0);
5000 }
5001
5002 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList) {
5003   return getNode(Opcode, DL, VTList, 0, 0);
5004 }
5005
5006 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList,
5007                               SDValue N1) {
5008   SDValue Ops[] = { N1 };
5009   return getNode(Opcode, DL, VTList, Ops, 1);
5010 }
5011
5012 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList,
5013                               SDValue N1, SDValue N2) {
5014   SDValue Ops[] = { N1, N2 };
5015   return getNode(Opcode, DL, VTList, Ops, 2);
5016 }
5017
5018 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList,
5019                               SDValue N1, SDValue N2, SDValue N3) {
5020   SDValue Ops[] = { N1, N2, N3 };
5021   return getNode(Opcode, DL, VTList, Ops, 3);
5022 }
5023
5024 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList,
5025                               SDValue N1, SDValue N2, SDValue N3,
5026                               SDValue N4) {
5027   SDValue Ops[] = { N1, N2, N3, N4 };
5028   return getNode(Opcode, DL, VTList, Ops, 4);
5029 }
5030
5031 SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList,
5032                               SDValue N1, SDValue N2, SDValue N3,
5033                               SDValue N4, SDValue N5) {
5034   SDValue Ops[] = { N1, N2, N3, N4, N5 };
5035   return getNode(Opcode, DL, VTList, Ops, 5);
5036 }
5037
5038 SDVTList SelectionDAG::getVTList(EVT VT) {
5039   return makeVTList(SDNode::getValueTypeList(VT), 1);
5040 }
5041
5042 SDVTList SelectionDAG::getVTList(EVT VT1, EVT VT2) {
5043   FoldingSetNodeID ID;
5044   ID.AddInteger(2U);
5045   ID.AddInteger(VT1.getRawBits());
5046   ID.AddInteger(VT2.getRawBits());
5047
5048   void *IP = 0;
5049   SDVTListNode *Result = VTListMap.FindNodeOrInsertPos(ID, IP);
5050   if (Result == NULL) {
5051     EVT *Array = Allocator.Allocate<EVT>(2);
5052     Array[0] = VT1;
5053     Array[1] = VT2;
5054     Result = new (Allocator) SDVTListNode(ID.Intern(Allocator), Array, 2);
5055     VTListMap.InsertNode(Result, IP);
5056   }
5057   return Result->getSDVTList();
5058 }
5059
5060 SDVTList SelectionDAG::getVTList(EVT VT1, EVT VT2, EVT VT3) {
5061   FoldingSetNodeID ID;
5062   ID.AddInteger(3U);
5063   ID.AddInteger(VT1.getRawBits());
5064   ID.AddInteger(VT2.getRawBits());
5065   ID.AddInteger(VT3.getRawBits());
5066
5067   void *IP = 0;
5068   SDVTListNode *Result = VTListMap.FindNodeOrInsertPos(ID, IP);
5069   if (Result == NULL) {
5070     EVT *Array = Allocator.Allocate<EVT>(3);
5071     Array[0] = VT1;
5072     Array[1] = VT2;
5073     Array[2] = VT3;
5074     Result = new (Allocator) SDVTListNode(ID.Intern(Allocator), Array, 3);
5075     VTListMap.InsertNode(Result, IP);
5076   }
5077   return Result->getSDVTList();
5078 }
5079
5080 SDVTList SelectionDAG::getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4) {
5081   FoldingSetNodeID ID;
5082   ID.AddInteger(4U);
5083   ID.AddInteger(VT1.getRawBits());
5084   ID.AddInteger(VT2.getRawBits());
5085   ID.AddInteger(VT3.getRawBits());
5086   ID.AddInteger(VT4.getRawBits());
5087
5088   void *IP = 0;
5089   SDVTListNode *Result = VTListMap.FindNodeOrInsertPos(ID, IP);
5090   if (Result == NULL) {
5091     EVT *Array = Allocator.Allocate<EVT>(4);
5092     Array[0] = VT1;
5093     Array[1] = VT2;
5094     Array[2] = VT3;
5095     Array[3] = VT4;
5096     Result = new (Allocator) SDVTListNode(ID.Intern(Allocator), Array, 4);
5097     VTListMap.InsertNode(Result, IP);
5098   }
5099   return Result->getSDVTList();
5100 }
5101
5102 SDVTList SelectionDAG::getVTList(const EVT *VTs, unsigned NumVTs) {
5103   FoldingSetNodeID ID;
5104   ID.AddInteger(NumVTs);
5105   for (unsigned index = 0; index < NumVTs; index++) {
5106     ID.AddInteger(VTs[index].getRawBits());
5107   }
5108
5109   void *IP = 0;
5110   SDVTListNode *Result = VTListMap.FindNodeOrInsertPos(ID, IP);
5111   if (Result == NULL) {
5112     EVT *Array = Allocator.Allocate<EVT>(NumVTs);
5113     std::copy(VTs, VTs + NumVTs, Array);
5114     Result = new (Allocator) SDVTListNode(ID.Intern(Allocator), Array, NumVTs);
5115     VTListMap.InsertNode(Result, IP);
5116   }
5117   return Result->getSDVTList();
5118 }
5119
5120
5121 /// UpdateNodeOperands - *Mutate* the specified node in-place to have the
5122 /// specified operands.  If the resultant node already exists in the DAG,
5123 /// this does not modify the specified node, instead it returns the node that
5124 /// already exists.  If the resultant node does not exist in the DAG, the
5125 /// input node is returned.  As a degenerate case, if you specify the same
5126 /// input operands as the node already has, the input node is returned.
5127 SDNode *SelectionDAG::UpdateNodeOperands(SDNode *N, SDValue Op) {
5128   assert(N->getNumOperands() == 1 && "Update with wrong number of operands");
5129
5130   // Check to see if there is no change.
5131   if (Op == N->getOperand(0)) return N;
5132
5133   // See if the modified node already exists.
5134   void *InsertPos = 0;
5135   if (SDNode *Existing = FindModifiedNodeSlot(N, Op, InsertPos))
5136     return Existing;
5137
5138   // Nope it doesn't.  Remove the node from its current place in the maps.
5139   if (InsertPos)
5140     if (!RemoveNodeFromCSEMaps(N))
5141       InsertPos = 0;
5142
5143   // Now we update the operands.
5144   N->OperandList[0].set(Op);
5145
5146   // If this gets put into a CSE map, add it.
5147   if (InsertPos) CSEMap.InsertNode(N, InsertPos);
5148   return N;
5149 }
5150
5151 SDNode *SelectionDAG::UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2) {
5152   assert(N->getNumOperands() == 2 && "Update with wrong number of operands");
5153
5154   // Check to see if there is no change.
5155   if (Op1 == N->getOperand(0) && Op2 == N->getOperand(1))
5156     return N;   // No operands changed, just return the input node.
5157
5158   // See if the modified node already exists.
5159   void *InsertPos = 0;
5160   if (SDNode *Existing = FindModifiedNodeSlot(N, Op1, Op2, InsertPos))
5161     return Existing;
5162
5163   // Nope it doesn't.  Remove the node from its current place in the maps.
5164   if (InsertPos)
5165     if (!RemoveNodeFromCSEMaps(N))
5166       InsertPos = 0;
5167
5168   // Now we update the operands.
5169   if (N->OperandList[0] != Op1)
5170     N->OperandList[0].set(Op1);
5171   if (N->OperandList[1] != Op2)
5172     N->OperandList[1].set(Op2);
5173
5174   // If this gets put into a CSE map, add it.
5175   if (InsertPos) CSEMap.InsertNode(N, InsertPos);
5176   return N;
5177 }
5178
5179 SDNode *SelectionDAG::
5180 UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2, SDValue Op3) {
5181   SDValue Ops[] = { Op1, Op2, Op3 };
5182   return UpdateNodeOperands(N, Ops, 3);
5183 }
5184
5185 SDNode *SelectionDAG::
5186 UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2,
5187                    SDValue Op3, SDValue Op4) {
5188   SDValue Ops[] = { Op1, Op2, Op3, Op4 };
5189   return UpdateNodeOperands(N, Ops, 4);
5190 }
5191
5192 SDNode *SelectionDAG::
5193 UpdateNodeOperands(SDNode *N, SDValue Op1, SDValue Op2,
5194                    SDValue Op3, SDValue Op4, SDValue Op5) {
5195   SDValue Ops[] = { Op1, Op2, Op3, Op4, Op5 };
5196   return UpdateNodeOperands(N, Ops, 5);
5197 }
5198
5199 SDNode *SelectionDAG::
5200 UpdateNodeOperands(SDNode *N, const SDValue *Ops, unsigned NumOps) {
5201   assert(N->getNumOperands() == NumOps &&
5202          "Update with wrong number of operands");
5203
5204   // Check to see if there is no change.
5205   bool AnyChange = false;
5206   for (unsigned i = 0; i != NumOps; ++i) {
5207     if (Ops[i] != N->getOperand(i)) {
5208       AnyChange = true;
5209       break;
5210     }
5211   }
5212
5213   // No operands changed, just return the input node.
5214   if (!AnyChange) return N;
5215
5216   // See if the modified node already exists.
5217   void *InsertPos = 0;
5218   if (SDNode *Existing = FindModifiedNodeSlot(N, Ops, NumOps, InsertPos))
5219     return Existing;
5220
5221   // Nope it doesn't.  Remove the node from its current place in the maps.
5222   if (InsertPos)
5223     if (!RemoveNodeFromCSEMaps(N))
5224       InsertPos = 0;
5225
5226   // Now we update the operands.
5227   for (unsigned i = 0; i != NumOps; ++i)
5228     if (N->OperandList[i] != Ops[i])
5229       N->OperandList[i].set(Ops[i]);
5230
5231   // If this gets put into a CSE map, add it.
5232   if (InsertPos) CSEMap.InsertNode(N, InsertPos);
5233   return N;
5234 }
5235
5236 /// DropOperands - Release the operands and set this node to have
5237 /// zero operands.
5238 void SDNode::DropOperands() {
5239   // Unlike the code in MorphNodeTo that does this, we don't need to
5240   // watch for dead nodes here.
5241   for (op_iterator I = op_begin(), E = op_end(); I != E; ) {
5242     SDUse &Use = *I++;
5243     Use.set(SDValue());
5244   }
5245 }
5246
5247 /// SelectNodeTo - These are wrappers around MorphNodeTo that accept a
5248 /// machine opcode.
5249 ///
5250 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5251                                    EVT VT) {
5252   SDVTList VTs = getVTList(VT);
5253   return SelectNodeTo(N, MachineOpc, VTs, 0, 0);
5254 }
5255
5256 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5257                                    EVT VT, SDValue Op1) {
5258   SDVTList VTs = getVTList(VT);
5259   SDValue Ops[] = { Op1 };
5260   return SelectNodeTo(N, MachineOpc, VTs, Ops, 1);
5261 }
5262
5263 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5264                                    EVT VT, SDValue Op1,
5265                                    SDValue Op2) {
5266   SDVTList VTs = getVTList(VT);
5267   SDValue Ops[] = { Op1, Op2 };
5268   return SelectNodeTo(N, MachineOpc, VTs, Ops, 2);
5269 }
5270
5271 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5272                                    EVT VT, SDValue Op1,
5273                                    SDValue Op2, SDValue Op3) {
5274   SDVTList VTs = getVTList(VT);
5275   SDValue Ops[] = { Op1, Op2, Op3 };
5276   return SelectNodeTo(N, MachineOpc, VTs, Ops, 3);
5277 }
5278
5279 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5280                                    EVT VT, const SDValue *Ops,
5281                                    unsigned NumOps) {
5282   SDVTList VTs = getVTList(VT);
5283   return SelectNodeTo(N, MachineOpc, VTs, Ops, NumOps);
5284 }
5285
5286 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5287                                    EVT VT1, EVT VT2, const SDValue *Ops,
5288                                    unsigned NumOps) {
5289   SDVTList VTs = getVTList(VT1, VT2);
5290   return SelectNodeTo(N, MachineOpc, VTs, Ops, NumOps);
5291 }
5292
5293 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5294                                    EVT VT1, EVT VT2) {
5295   SDVTList VTs = getVTList(VT1, VT2);
5296   return SelectNodeTo(N, MachineOpc, VTs, (SDValue *)0, 0);
5297 }
5298
5299 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5300                                    EVT VT1, EVT VT2, EVT VT3,
5301                                    const SDValue *Ops, unsigned NumOps) {
5302   SDVTList VTs = getVTList(VT1, VT2, VT3);
5303   return SelectNodeTo(N, MachineOpc, VTs, Ops, NumOps);
5304 }
5305
5306 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5307                                    EVT VT1, EVT VT2, EVT VT3, EVT VT4,
5308                                    const SDValue *Ops, unsigned NumOps) {
5309   SDVTList VTs = getVTList(VT1, VT2, VT3, VT4);
5310   return SelectNodeTo(N, MachineOpc, VTs, Ops, NumOps);
5311 }
5312
5313 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5314                                    EVT VT1, EVT VT2,
5315                                    SDValue Op1) {
5316   SDVTList VTs = getVTList(VT1, VT2);
5317   SDValue Ops[] = { Op1 };
5318   return SelectNodeTo(N, MachineOpc, VTs, Ops, 1);
5319 }
5320
5321 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5322                                    EVT VT1, EVT VT2,
5323                                    SDValue Op1, SDValue Op2) {
5324   SDVTList VTs = getVTList(VT1, VT2);
5325   SDValue Ops[] = { Op1, Op2 };
5326   return SelectNodeTo(N, MachineOpc, VTs, Ops, 2);
5327 }
5328
5329 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5330                                    EVT VT1, EVT VT2,
5331                                    SDValue Op1, SDValue Op2,
5332                                    SDValue Op3) {
5333   SDVTList VTs = getVTList(VT1, VT2);
5334   SDValue Ops[] = { Op1, Op2, Op3 };
5335   return SelectNodeTo(N, MachineOpc, VTs, Ops, 3);
5336 }
5337
5338 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5339                                    EVT VT1, EVT VT2, EVT VT3,
5340                                    SDValue Op1, SDValue Op2,
5341                                    SDValue Op3) {
5342   SDVTList VTs = getVTList(VT1, VT2, VT3);
5343   SDValue Ops[] = { Op1, Op2, Op3 };
5344   return SelectNodeTo(N, MachineOpc, VTs, Ops, 3);
5345 }
5346
5347 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
5348                                    SDVTList VTs, const SDValue *Ops,
5349                                    unsigned NumOps) {
5350   N = MorphNodeTo(N, ~MachineOpc, VTs, Ops, NumOps);
5351   // Reset the NodeID to -1.
5352   N->setNodeId(-1);
5353   return N;
5354 }
5355
5356 /// UpdadeSDLocOnMergedSDNode - If the opt level is -O0 then it throws away
5357 /// the line number information on the merged node since it is not possible to
5358 /// preserve the information that operation is associated with multiple lines.
5359 /// This will make the debugger working better at -O0, were there is a higher
5360 /// probability having other instructions associated with that line.
5361 ///
5362 /// For IROrder, we keep the smaller of the two
5363 SDNode *SelectionDAG::UpdadeSDLocOnMergedSDNode(SDNode *N, SDLoc OLoc) {
5364   DebugLoc NLoc = N->getDebugLoc();
5365   if (!(NLoc.isUnknown()) && (OptLevel == CodeGenOpt::None) &&
5366     (OLoc.getDebugLoc() != NLoc)) {
5367     N->setDebugLoc(DebugLoc());
5368   }
5369   unsigned Order = std::min(N->getIROrder(), OLoc.getIROrder());
5370   N->setIROrder(Order);
5371   return N;
5372 }
5373
5374 /// MorphNodeTo - This *mutates* the specified node to have the specified
5375 /// return type, opcode, and operands.
5376 ///
5377 /// Note that MorphNodeTo returns the resultant node.  If there is already a
5378 /// node of the specified opcode and operands, it returns that node instead of
5379 /// the current one.  Note that the SDLoc need not be the same.
5380 ///
5381 /// Using MorphNodeTo is faster than creating a new node and swapping it in
5382 /// with ReplaceAllUsesWith both because it often avoids allocating a new
5383 /// node, and because it doesn't require CSE recalculation for any of
5384 /// the node's users.
5385 ///
5386 SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
5387                                   SDVTList VTs, const SDValue *Ops,
5388                                   unsigned NumOps) {
5389   // If an identical node already exists, use it.
5390   void *IP = 0;
5391   if (VTs.VTs[VTs.NumVTs-1] != MVT::Glue) {
5392     FoldingSetNodeID ID;
5393     AddNodeIDNode(ID, Opc, VTs, Ops, NumOps);
5394     if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP))
5395       return UpdadeSDLocOnMergedSDNode(ON, SDLoc(N));
5396   }
5397
5398   if (!RemoveNodeFromCSEMaps(N))
5399     IP = 0;
5400
5401   // Start the morphing.
5402   N->NodeType = Opc;
5403   N->ValueList = VTs.VTs;
5404   N->NumValues = VTs.NumVTs;
5405
5406   // Clear the operands list, updating used nodes to remove this from their
5407   // use list.  Keep track of any operands that become dead as a result.
5408   SmallPtrSet<SDNode*, 16> DeadNodeSet;
5409   for (SDNode::op_iterator I = N->op_begin(), E = N->op_end(); I != E; ) {
5410     SDUse &Use = *I++;
5411     SDNode *Used = Use.getNode();
5412     Use.set(SDValue());
5413     if (Used->use_empty())
5414       DeadNodeSet.insert(Used);
5415   }
5416
5417   if (MachineSDNode *MN = dyn_cast<MachineSDNode>(N)) {
5418     // Initialize the memory references information.
5419     MN->setMemRefs(0, 0);
5420     // If NumOps is larger than the # of operands we can have in a
5421     // MachineSDNode, reallocate the operand list.
5422     if (NumOps > MN->NumOperands || !MN->OperandsNeedDelete) {
5423       if (MN->OperandsNeedDelete)
5424         delete[] MN->OperandList;
5425       if (NumOps > array_lengthof(MN->LocalOperands))
5426         // We're creating a final node that will live unmorphed for the
5427         // remainder of the current SelectionDAG iteration, so we can allocate
5428         // the operands directly out of a pool with no recycling metadata.
5429         MN->InitOperands(OperandAllocator.Allocate<SDUse>(NumOps),
5430                          Ops, NumOps);
5431       else
5432         MN->InitOperands(MN->LocalOperands, Ops, NumOps);
5433       MN->OperandsNeedDelete = false;
5434     } else
5435       MN->InitOperands(MN->OperandList, Ops, NumOps);
5436   } else {
5437     // If NumOps is larger than the # of operands we currently have, reallocate
5438     // the operand list.
5439     if (NumOps > N->NumOperands) {
5440       if (N->OperandsNeedDelete)
5441         delete[] N->OperandList;
5442       N->InitOperands(new SDUse[NumOps], Ops, NumOps);
5443       N->OperandsNeedDelete = true;
5444     } else
5445       N->InitOperands(N->OperandList, Ops, NumOps);
5446   }
5447
5448   // Delete any nodes that are still dead after adding the uses for the
5449   // new operands.
5450   if (!DeadNodeSet.empty()) {
5451     SmallVector<SDNode *, 16> DeadNodes;
5452     for (SmallPtrSet<SDNode *, 16>::iterator I = DeadNodeSet.begin(),
5453          E = DeadNodeSet.end(); I != E; ++I)
5454       if ((*I)->use_empty())
5455         DeadNodes.push_back(*I);
5456     RemoveDeadNodes(DeadNodes);
5457   }
5458
5459   if (IP)
5460     CSEMap.InsertNode(N, IP);   // Memoize the new node.
5461   return N;
5462 }
5463
5464
5465 /// getMachineNode - These are used for target selectors to create a new node
5466 /// with specified return type(s), MachineInstr opcode, and operands.
5467 ///
5468 /// Note that getMachineNode returns the resultant node.  If there is already a
5469 /// node of the specified opcode and operands, it returns that node instead of
5470 /// the current one.
5471 MachineSDNode *
5472 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT) {
5473   SDVTList VTs = getVTList(VT);
5474   return getMachineNode(Opcode, dl, VTs, None);
5475 }
5476
5477 MachineSDNode *
5478 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT, SDValue Op1) {
5479   SDVTList VTs = getVTList(VT);
5480   SDValue Ops[] = { Op1 };
5481   return getMachineNode(Opcode, dl, VTs, Ops);
5482 }
5483
5484 MachineSDNode *
5485 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT,
5486                              SDValue Op1, SDValue Op2) {
5487   SDVTList VTs = getVTList(VT);
5488   SDValue Ops[] = { Op1, Op2 };
5489   return getMachineNode(Opcode, dl, VTs, Ops);
5490 }
5491
5492 MachineSDNode *
5493 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT,
5494                              SDValue Op1, SDValue Op2, SDValue Op3) {
5495   SDVTList VTs = getVTList(VT);
5496   SDValue Ops[] = { Op1, Op2, Op3 };
5497   return getMachineNode(Opcode, dl, VTs, Ops);
5498 }
5499
5500 MachineSDNode *
5501 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT,
5502                              ArrayRef<SDValue> Ops) {
5503   SDVTList VTs = getVTList(VT);
5504   return getMachineNode(Opcode, dl, VTs, Ops);
5505 }
5506
5507 MachineSDNode *
5508 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2) {
5509   SDVTList VTs = getVTList(VT1, VT2);
5510   return getMachineNode(Opcode, dl, VTs, None);
5511 }
5512
5513 MachineSDNode *
5514 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
5515                              EVT VT1, EVT VT2, SDValue Op1) {
5516   SDVTList VTs = getVTList(VT1, VT2);
5517   SDValue Ops[] = { Op1 };
5518   return getMachineNode(Opcode, dl, VTs, Ops);
5519 }
5520
5521 MachineSDNode *
5522 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
5523                              EVT VT1, EVT VT2, SDValue Op1, SDValue Op2) {
5524   SDVTList VTs = getVTList(VT1, VT2);
5525   SDValue Ops[] = { Op1, Op2 };
5526   return getMachineNode(Opcode, dl, VTs, Ops);
5527 }
5528
5529 MachineSDNode *
5530 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
5531                              EVT VT1, EVT VT2, SDValue Op1,
5532                              SDValue Op2, SDValue Op3) {
5533   SDVTList VTs = getVTList(VT1, VT2);
5534   SDValue Ops[] = { Op1, Op2, Op3 };
5535   return getMachineNode(Opcode, dl, VTs, Ops);
5536 }
5537
5538 MachineSDNode *
5539 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
5540                              EVT VT1, EVT VT2,
5541                              ArrayRef<SDValue> Ops) {
5542   SDVTList VTs = getVTList(VT1, VT2);
5543   return getMachineNode(Opcode, dl, VTs, Ops);
5544 }
5545
5546 MachineSDNode *
5547 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
5548                              EVT VT1, EVT VT2, EVT VT3,
5549                              SDValue Op1, SDValue Op2) {
5550   SDVTList VTs = getVTList(VT1, VT2, VT3);
5551   SDValue Ops[] = { Op1, Op2 };
5552   return getMachineNode(Opcode, dl, VTs, Ops);
5553 }
5554
5555 MachineSDNode *
5556 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
5557                              EVT VT1, EVT VT2, EVT VT3,
5558                              SDValue Op1, SDValue Op2, SDValue Op3) {
5559   SDVTList VTs = getVTList(VT1, VT2, VT3);
5560   SDValue Ops[] = { Op1, Op2, Op3 };
5561   return getMachineNode(Opcode, dl, VTs, Ops);
5562 }
5563
5564 MachineSDNode *
5565 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
5566                              EVT VT1, EVT VT2, EVT VT3,
5567                              ArrayRef<SDValue> Ops) {
5568   SDVTList VTs = getVTList(VT1, VT2, VT3);
5569   return getMachineNode(Opcode, dl, VTs, Ops);
5570 }
5571
5572 MachineSDNode *
5573 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1,
5574                              EVT VT2, EVT VT3, EVT VT4,
5575                              ArrayRef<SDValue> Ops) {
5576   SDVTList VTs = getVTList(VT1, VT2, VT3, VT4);
5577   return getMachineNode(Opcode, dl, VTs, Ops);
5578 }
5579
5580 MachineSDNode *
5581 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
5582                              ArrayRef<EVT> ResultTys,
5583                              ArrayRef<SDValue> Ops) {
5584   SDVTList VTs = getVTList(&ResultTys[0], ResultTys.size());
5585   return getMachineNode(Opcode, dl, VTs, Ops);
5586 }
5587
5588 MachineSDNode *
5589 SelectionDAG::getMachineNode(unsigned Opcode, SDLoc DL, SDVTList VTs,
5590                              ArrayRef<SDValue> OpsArray) {
5591   bool DoCSE = VTs.VTs[VTs.NumVTs-1] != MVT::Glue;
5592   MachineSDNode *N;
5593   void *IP = 0;
5594   const SDValue *Ops = OpsArray.data();
5595   unsigned NumOps = OpsArray.size();
5596
5597   if (DoCSE) {
5598     FoldingSetNodeID ID;
5599     AddNodeIDNode(ID, ~Opcode, VTs, Ops, NumOps);
5600     IP = 0;
5601     if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
5602       return cast<MachineSDNode>(UpdadeSDLocOnMergedSDNode(E, DL));
5603     }
5604   }
5605
5606   // Allocate a new MachineSDNode.
5607   N = new (NodeAllocator) MachineSDNode(~Opcode, DL.getIROrder(),
5608                                         DL.getDebugLoc(), VTs);
5609
5610   // Initialize the operands list.
5611   if (NumOps > array_lengthof(N->LocalOperands))
5612     // We're creating a final node that will live unmorphed for the
5613     // remainder of the current SelectionDAG iteration, so we can allocate
5614     // the operands directly out of a pool with no recycling metadata.
5615     N->InitOperands(OperandAllocator.Allocate<SDUse>(NumOps),
5616                     Ops, NumOps);
5617   else
5618     N->InitOperands(N->LocalOperands, Ops, NumOps);
5619   N->OperandsNeedDelete = false;
5620
5621   if (DoCSE)
5622     CSEMap.InsertNode(N, IP);
5623
5624   AllNodes.push_back(N);
5625 #ifndef NDEBUG
5626   VerifyMachineNode(N);
5627 #endif
5628   return N;
5629 }
5630
5631 /// getTargetExtractSubreg - A convenience function for creating
5632 /// TargetOpcode::EXTRACT_SUBREG nodes.
5633 SDValue
5634 SelectionDAG::getTargetExtractSubreg(int SRIdx, SDLoc DL, EVT VT,
5635                                      SDValue Operand) {
5636   SDValue SRIdxVal = getTargetConstant(SRIdx, MVT::i32);
5637   SDNode *Subreg = getMachineNode(TargetOpcode::EXTRACT_SUBREG, DL,
5638                                   VT, Operand, SRIdxVal);
5639   return SDValue(Subreg, 0);
5640 }
5641
5642 /// getTargetInsertSubreg - A convenience function for creating
5643 /// TargetOpcode::INSERT_SUBREG nodes.
5644 SDValue
5645 SelectionDAG::getTargetInsertSubreg(int SRIdx, SDLoc DL, EVT VT,
5646                                     SDValue Operand, SDValue Subreg) {
5647   SDValue SRIdxVal = getTargetConstant(SRIdx, MVT::i32);
5648   SDNode *Result = getMachineNode(TargetOpcode::INSERT_SUBREG, DL,
5649                                   VT, Operand, Subreg, SRIdxVal);
5650   return SDValue(Result, 0);
5651 }
5652
5653 /// getNodeIfExists - Get the specified node if it's already available, or
5654 /// else return NULL.
5655 SDNode *SelectionDAG::getNodeIfExists(unsigned Opcode, SDVTList VTList,
5656                                       const SDValue *Ops, unsigned NumOps) {
5657   if (VTList.VTs[VTList.NumVTs-1] != MVT::Glue) {
5658     FoldingSetNodeID ID;
5659     AddNodeIDNode(ID, Opcode, VTList, Ops, NumOps);
5660     void *IP = 0;
5661     if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
5662       return E;
5663   }
5664   return NULL;
5665 }
5666
5667 /// getDbgValue - Creates a SDDbgValue node.
5668 ///
5669 SDDbgValue *
5670 SelectionDAG::getDbgValue(MDNode *MDPtr, SDNode *N, unsigned R, uint64_t Off,
5671                           DebugLoc DL, unsigned O) {
5672   return new (Allocator) SDDbgValue(MDPtr, N, R, Off, DL, O);
5673 }
5674
5675 SDDbgValue *
5676 SelectionDAG::getDbgValue(MDNode *MDPtr, const Value *C, uint64_t Off,
5677                           DebugLoc DL, unsigned O) {
5678   return new (Allocator) SDDbgValue(MDPtr, C, Off, DL, O);
5679 }
5680
5681 SDDbgValue *
5682 SelectionDAG::getDbgValue(MDNode *MDPtr, unsigned FI, uint64_t Off,
5683                           DebugLoc DL, unsigned O) {
5684   return new (Allocator) SDDbgValue(MDPtr, FI, Off, DL, O);
5685 }
5686
5687 namespace {
5688
5689 /// RAUWUpdateListener - Helper for ReplaceAllUsesWith - When the node
5690 /// pointed to by a use iterator is deleted, increment the use iterator
5691 /// so that it doesn't dangle.
5692 ///
5693 class RAUWUpdateListener : public SelectionDAG::DAGUpdateListener {
5694   SDNode::use_iterator &UI;
5695   SDNode::use_iterator &UE;
5696
5697   void NodeDeleted(SDNode *N, SDNode *E) override {
5698     // Increment the iterator as needed.
5699     while (UI != UE && N == *UI)
5700       ++UI;
5701   }
5702
5703 public:
5704   RAUWUpdateListener(SelectionDAG &d,
5705                      SDNode::use_iterator &ui,
5706                      SDNode::use_iterator &ue)
5707     : SelectionDAG::DAGUpdateListener(d), UI(ui), UE(ue) {}
5708 };
5709
5710 }
5711
5712 /// ReplaceAllUsesWith - Modify anything using 'From' to use 'To' instead.
5713 /// This can cause recursive merging of nodes in the DAG.
5714 ///
5715 /// This version assumes From has a single result value.
5716 ///
5717 void SelectionDAG::ReplaceAllUsesWith(SDValue FromN, SDValue To) {
5718   SDNode *From = FromN.getNode();
5719   assert(From->getNumValues() == 1 && FromN.getResNo() == 0 &&
5720          "Cannot replace with this method!");
5721   assert(From != To.getNode() && "Cannot replace uses of with self");
5722
5723   // Iterate over all the existing uses of From. New uses will be added
5724   // to the beginning of the use list, which we avoid visiting.
5725   // This specifically avoids visiting uses of From that arise while the
5726   // replacement is happening, because any such uses would be the result
5727   // of CSE: If an existing node looks like From after one of its operands
5728   // is replaced by To, we don't want to replace of all its users with To
5729   // too. See PR3018 for more info.
5730   SDNode::use_iterator UI = From->use_begin(), UE = From->use_end();
5731   RAUWUpdateListener Listener(*this, UI, UE);
5732   while (UI != UE) {
5733     SDNode *User = *UI;
5734
5735     // This node is about to morph, remove its old self from the CSE maps.
5736     RemoveNodeFromCSEMaps(User);
5737
5738     // A user can appear in a use list multiple times, and when this
5739     // happens the uses are usually next to each other in the list.
5740     // To help reduce the number of CSE recomputations, process all
5741     // the uses of this user that we can find this way.
5742     do {
5743       SDUse &Use = UI.getUse();
5744       ++UI;
5745       Use.set(To);
5746     } while (UI != UE && *UI == User);
5747
5748     // Now that we have modified User, add it back to the CSE maps.  If it
5749     // already exists there, recursively merge the results together.
5750     AddModifiedNodeToCSEMaps(User);
5751   }
5752
5753   // If we just RAUW'd the root, take note.
5754   if (FromN == getRoot())
5755     setRoot(To);
5756 }
5757
5758 /// ReplaceAllUsesWith - Modify anything using 'From' to use 'To' instead.
5759 /// This can cause recursive merging of nodes in the DAG.
5760 ///
5761 /// This version assumes that for each value of From, there is a
5762 /// corresponding value in To in the same position with the same type.
5763 ///
5764 void SelectionDAG::ReplaceAllUsesWith(SDNode *From, SDNode *To) {
5765 #ifndef NDEBUG
5766   for (unsigned i = 0, e = From->getNumValues(); i != e; ++i)
5767     assert((!From->hasAnyUseOfValue(i) ||
5768             From->getValueType(i) == To->getValueType(i)) &&
5769            "Cannot use this version of ReplaceAllUsesWith!");
5770 #endif
5771
5772   // Handle the trivial case.
5773   if (From == To)
5774     return;
5775
5776   // Iterate over just the existing users of From. See the comments in
5777   // the ReplaceAllUsesWith above.
5778   SDNode::use_iterator UI = From->use_begin(), UE = From->use_end();
5779   RAUWUpdateListener Listener(*this, UI, UE);
5780   while (UI != UE) {
5781     SDNode *User = *UI;
5782
5783     // This node is about to morph, remove its old self from the CSE maps.
5784     RemoveNodeFromCSEMaps(User);
5785
5786     // A user can appear in a use list multiple times, and when this
5787     // happens the uses are usually next to each other in the list.
5788     // To help reduce the number of CSE recomputations, process all
5789     // the uses of this user that we can find this way.
5790     do {
5791       SDUse &Use = UI.getUse();
5792       ++UI;
5793       Use.setNode(To);
5794     } while (UI != UE && *UI == User);
5795
5796     // Now that we have modified User, add it back to the CSE maps.  If it
5797     // already exists there, recursively merge the results together.
5798     AddModifiedNodeToCSEMaps(User);
5799   }
5800
5801   // If we just RAUW'd the root, take note.
5802   if (From == getRoot().getNode())
5803     setRoot(SDValue(To, getRoot().getResNo()));
5804 }
5805
5806 /// ReplaceAllUsesWith - Modify anything using 'From' to use 'To' instead.
5807 /// This can cause recursive merging of nodes in the DAG.
5808 ///
5809 /// This version can replace From with any result values.  To must match the
5810 /// number and types of values returned by From.
5811 void SelectionDAG::ReplaceAllUsesWith(SDNode *From, const SDValue *To) {
5812   if (From->getNumValues() == 1)  // Handle the simple case efficiently.
5813     return ReplaceAllUsesWith(SDValue(From, 0), To[0]);
5814
5815   // Iterate over just the existing users of From. See the comments in
5816   // the ReplaceAllUsesWith above.
5817   SDNode::use_iterator UI = From->use_begin(), UE = From->use_end();
5818   RAUWUpdateListener Listener(*this, UI, UE);
5819   while (UI != UE) {
5820     SDNode *User = *UI;
5821
5822     // This node is about to morph, remove its old self from the CSE maps.
5823     RemoveNodeFromCSEMaps(User);
5824
5825     // A user can appear in a use list multiple times, and when this
5826     // happens the uses are usually next to each other in the list.
5827     // To help reduce the number of CSE recomputations, process all
5828     // the uses of this user that we can find this way.
5829     do {
5830       SDUse &Use = UI.getUse();
5831       const SDValue &ToOp = To[Use.getResNo()];
5832       ++UI;
5833       Use.set(ToOp);
5834     } while (UI != UE && *UI == User);
5835
5836     // Now that we have modified User, add it back to the CSE maps.  If it
5837     // already exists there, recursively merge the results together.
5838     AddModifiedNodeToCSEMaps(User);
5839   }
5840
5841   // If we just RAUW'd the root, take note.
5842   if (From == getRoot().getNode())
5843     setRoot(SDValue(To[getRoot().getResNo()]));
5844 }
5845
5846 /// ReplaceAllUsesOfValueWith - Replace any uses of From with To, leaving
5847 /// uses of other values produced by From.getNode() alone.  The Deleted
5848 /// vector is handled the same way as for ReplaceAllUsesWith.
5849 void SelectionDAG::ReplaceAllUsesOfValueWith(SDValue From, SDValue To){
5850   // Handle the really simple, really trivial case efficiently.
5851   if (From == To) return;
5852
5853   // Handle the simple, trivial, case efficiently.
5854   if (From.getNode()->getNumValues() == 1) {
5855     ReplaceAllUsesWith(From, To);
5856     return;
5857   }
5858
5859   // Iterate over just the existing users of From. See the comments in
5860   // the ReplaceAllUsesWith above.
5861   SDNode::use_iterator UI = From.getNode()->use_begin(),
5862                        UE = From.getNode()->use_end();
5863   RAUWUpdateListener Listener(*this, UI, UE);
5864   while (UI != UE) {
5865     SDNode *User = *UI;
5866     bool UserRemovedFromCSEMaps = false;
5867
5868     // A user can appear in a use list multiple times, and when this
5869     // happens the uses are usually next to each other in the list.
5870     // To help reduce the number of CSE recomputations, process all
5871     // the uses of this user that we can find this way.
5872     do {
5873       SDUse &Use = UI.getUse();
5874
5875       // Skip uses of different values from the same node.
5876       if (Use.getResNo() != From.getResNo()) {
5877         ++UI;
5878         continue;
5879       }
5880
5881       // If this node hasn't been modified yet, it's still in the CSE maps,
5882       // so remove its old self from the CSE maps.
5883       if (!UserRemovedFromCSEMaps) {
5884         RemoveNodeFromCSEMaps(User);
5885         UserRemovedFromCSEMaps = true;
5886       }
5887
5888       ++UI;
5889       Use.set(To);
5890     } while (UI != UE && *UI == User);
5891
5892     // We are iterating over all uses of the From node, so if a use
5893     // doesn't use the specific value, no changes are made.
5894     if (!UserRemovedFromCSEMaps)
5895       continue;
5896
5897     // Now that we have modified User, add it back to the CSE maps.  If it
5898     // already exists there, recursively merge the results together.
5899     AddModifiedNodeToCSEMaps(User);
5900   }
5901
5902   // If we just RAUW'd the root, take note.
5903   if (From == getRoot())
5904     setRoot(To);
5905 }
5906
5907 namespace {
5908   /// UseMemo - This class is used by SelectionDAG::ReplaceAllUsesOfValuesWith
5909   /// to record information about a use.
5910   struct UseMemo {
5911     SDNode *User;
5912     unsigned Index;
5913     SDUse *Use;
5914   };
5915
5916   /// operator< - Sort Memos by User.
5917   bool operator<(const UseMemo &L, const UseMemo &R) {
5918     return (intptr_t)L.User < (intptr_t)R.User;
5919   }
5920 }
5921
5922 /// ReplaceAllUsesOfValuesWith - Replace any uses of From with To, leaving
5923 /// uses of other values produced by From.getNode() alone.  The same value
5924 /// may appear in both the From and To list.  The Deleted vector is
5925 /// handled the same way as for ReplaceAllUsesWith.
5926 void SelectionDAG::ReplaceAllUsesOfValuesWith(const SDValue *From,
5927                                               const SDValue *To,
5928                                               unsigned Num){
5929   // Handle the simple, trivial case efficiently.
5930   if (Num == 1)
5931     return ReplaceAllUsesOfValueWith(*From, *To);
5932
5933   // Read up all the uses and make records of them. This helps
5934   // processing new uses that are introduced during the
5935   // replacement process.
5936   SmallVector<UseMemo, 4> Uses;
5937   for (unsigned i = 0; i != Num; ++i) {
5938     unsigned FromResNo = From[i].getResNo();
5939     SDNode *FromNode = From[i].getNode();
5940     for (SDNode::use_iterator UI = FromNode->use_begin(),
5941          E = FromNode->use_end(); UI != E; ++UI) {
5942       SDUse &Use = UI.getUse();
5943       if (Use.getResNo() == FromResNo) {
5944         UseMemo Memo = { *UI, i, &Use };
5945         Uses.push_back(Memo);
5946       }
5947     }
5948   }
5949
5950   // Sort the uses, so that all the uses from a given User are together.
5951   std::sort(Uses.begin(), Uses.end());
5952
5953   for (unsigned UseIndex = 0, UseIndexEnd = Uses.size();
5954        UseIndex != UseIndexEnd; ) {
5955     // We know that this user uses some value of From.  If it is the right
5956     // value, update it.
5957     SDNode *User = Uses[UseIndex].User;
5958
5959     // This node is about to morph, remove its old self from the CSE maps.
5960     RemoveNodeFromCSEMaps(User);
5961
5962     // The Uses array is sorted, so all the uses for a given User
5963     // are next to each other in the list.
5964     // To help reduce the number of CSE recomputations, process all
5965     // the uses of this user that we can find this way.
5966     do {
5967       unsigned i = Uses[UseIndex].Index;
5968       SDUse &Use = *Uses[UseIndex].Use;
5969       ++UseIndex;
5970
5971       Use.set(To[i]);
5972     } while (UseIndex != UseIndexEnd && Uses[UseIndex].User == User);
5973
5974     // Now that we have modified User, add it back to the CSE maps.  If it
5975     // already exists there, recursively merge the results together.
5976     AddModifiedNodeToCSEMaps(User);
5977   }
5978 }
5979
5980 /// AssignTopologicalOrder - Assign a unique node id for each node in the DAG
5981 /// based on their topological order. It returns the maximum id and a vector
5982 /// of the SDNodes* in assigned order by reference.
5983 unsigned SelectionDAG::AssignTopologicalOrder() {
5984
5985   unsigned DAGSize = 0;
5986
5987   // SortedPos tracks the progress of the algorithm. Nodes before it are
5988   // sorted, nodes after it are unsorted. When the algorithm completes
5989   // it is at the end of the list.
5990   allnodes_iterator SortedPos = allnodes_begin();
5991
5992   // Visit all the nodes. Move nodes with no operands to the front of
5993   // the list immediately. Annotate nodes that do have operands with their
5994   // operand count. Before we do this, the Node Id fields of the nodes
5995   // may contain arbitrary values. After, the Node Id fields for nodes
5996   // before SortedPos will contain the topological sort index, and the
5997   // Node Id fields for nodes At SortedPos and after will contain the
5998   // count of outstanding operands.
5999   for (allnodes_iterator I = allnodes_begin(),E = allnodes_end(); I != E; ) {
6000     SDNode *N = I++;
6001     checkForCycles(N);
6002     unsigned Degree = N->getNumOperands();
6003     if (Degree == 0) {
6004       // A node with no uses, add it to the result array immediately.
6005       N->setNodeId(DAGSize++);
6006       allnodes_iterator Q = N;
6007       if (Q != SortedPos)
6008         SortedPos = AllNodes.insert(SortedPos, AllNodes.remove(Q));
6009       assert(SortedPos != AllNodes.end() && "Overran node list");
6010       ++SortedPos;
6011     } else {
6012       // Temporarily use the Node Id as scratch space for the degree count.
6013       N->setNodeId(Degree);
6014     }
6015   }
6016
6017   // Visit all the nodes. As we iterate, move nodes into sorted order,
6018   // such that by the time the end is reached all nodes will be sorted.
6019   for (allnodes_iterator I = allnodes_begin(),E = allnodes_end(); I != E; ++I) {
6020     SDNode *N = I;
6021     checkForCycles(N);
6022     // N is in sorted position, so all its uses have one less operand
6023     // that needs to be sorted.
6024     for (SDNode::use_iterator UI = N->use_begin(), UE = N->use_end();
6025          UI != UE; ++UI) {
6026       SDNode *P = *UI;
6027       unsigned Degree = P->getNodeId();
6028       assert(Degree != 0 && "Invalid node degree");
6029       --Degree;
6030       if (Degree == 0) {
6031         // All of P's operands are sorted, so P may sorted now.
6032         P->setNodeId(DAGSize++);
6033         if (P != SortedPos)
6034           SortedPos = AllNodes.insert(SortedPos, AllNodes.remove(P));
6035         assert(SortedPos != AllNodes.end() && "Overran node list");
6036         ++SortedPos;
6037       } else {
6038         // Update P's outstanding operand count.
6039         P->setNodeId(Degree);
6040       }
6041     }
6042     if (I == SortedPos) {
6043 #ifndef NDEBUG
6044       SDNode *S = ++I;
6045       dbgs() << "Overran sorted position:\n";
6046       S->dumprFull();
6047 #endif
6048       llvm_unreachable(0);
6049     }
6050   }
6051
6052   assert(SortedPos == AllNodes.end() &&
6053          "Topological sort incomplete!");
6054   assert(AllNodes.front().getOpcode() == ISD::EntryToken &&
6055          "First node in topological sort is not the entry token!");
6056   assert(AllNodes.front().getNodeId() == 0 &&
6057          "First node in topological sort has non-zero id!");
6058   assert(AllNodes.front().getNumOperands() == 0 &&
6059          "First node in topological sort has operands!");
6060   assert(AllNodes.back().getNodeId() == (int)DAGSize-1 &&
6061          "Last node in topologic sort has unexpected id!");
6062   assert(AllNodes.back().use_empty() &&
6063          "Last node in topologic sort has users!");
6064   assert(DAGSize == allnodes_size() && "Node count mismatch!");
6065   return DAGSize;
6066 }
6067
6068 /// AddDbgValue - Add a dbg_value SDNode. If SD is non-null that means the
6069 /// value is produced by SD.
6070 void SelectionDAG::AddDbgValue(SDDbgValue *DB, SDNode *SD, bool isParameter) {
6071   DbgInfo->add(DB, SD, isParameter);
6072   if (SD)
6073     SD->setHasDebugValue(true);
6074 }
6075
6076 /// TransferDbgValues - Transfer SDDbgValues.
6077 void SelectionDAG::TransferDbgValues(SDValue From, SDValue To) {
6078   if (From == To || !From.getNode()->getHasDebugValue())
6079     return;
6080   SDNode *FromNode = From.getNode();
6081   SDNode *ToNode = To.getNode();
6082   ArrayRef<SDDbgValue *> DVs = GetDbgValues(FromNode);
6083   SmallVector<SDDbgValue *, 2> ClonedDVs;
6084   for (ArrayRef<SDDbgValue *>::iterator I = DVs.begin(), E = DVs.end();
6085        I != E; ++I) {
6086     SDDbgValue *Dbg = *I;
6087     if (Dbg->getKind() == SDDbgValue::SDNODE) {
6088       SDDbgValue *Clone = getDbgValue(Dbg->getMDPtr(), ToNode, To.getResNo(),
6089                                       Dbg->getOffset(), Dbg->getDebugLoc(),
6090                                       Dbg->getOrder());
6091       ClonedDVs.push_back(Clone);
6092     }
6093   }
6094   for (SmallVectorImpl<SDDbgValue *>::iterator I = ClonedDVs.begin(),
6095          E = ClonedDVs.end(); I != E; ++I)
6096     AddDbgValue(*I, ToNode, false);
6097 }
6098
6099 //===----------------------------------------------------------------------===//
6100 //                              SDNode Class
6101 //===----------------------------------------------------------------------===//
6102
6103 HandleSDNode::~HandleSDNode() {
6104   DropOperands();
6105 }
6106
6107 GlobalAddressSDNode::GlobalAddressSDNode(unsigned Opc, unsigned Order,
6108                                          DebugLoc DL, const GlobalValue *GA,
6109                                          EVT VT, int64_t o, unsigned char TF)
6110   : SDNode(Opc, Order, DL, getSDVTList(VT)), Offset(o), TargetFlags(TF) {
6111   TheGlobal = GA;
6112 }
6113
6114 AddrSpaceCastSDNode::AddrSpaceCastSDNode(unsigned Order, DebugLoc dl, EVT VT,
6115                                          SDValue X, unsigned SrcAS,
6116                                          unsigned DestAS)
6117  : UnarySDNode(ISD::ADDRSPACECAST, Order, dl, getSDVTList(VT), X),
6118    SrcAddrSpace(SrcAS), DestAddrSpace(DestAS) {}
6119
6120 MemSDNode::MemSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs,
6121                      EVT memvt, MachineMemOperand *mmo)
6122  : SDNode(Opc, Order, dl, VTs), MemoryVT(memvt), MMO(mmo) {
6123   SubclassData = encodeMemSDNodeFlags(0, ISD::UNINDEXED, MMO->isVolatile(),
6124                                       MMO->isNonTemporal(), MMO->isInvariant());
6125   assert(isVolatile() == MMO->isVolatile() && "Volatile encoding error!");
6126   assert(isNonTemporal() == MMO->isNonTemporal() &&
6127          "Non-temporal encoding error!");
6128   assert(memvt.getStoreSize() == MMO->getSize() && "Size mismatch!");
6129 }
6130
6131 MemSDNode::MemSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs,
6132                      const SDValue *Ops, unsigned NumOps, EVT memvt,
6133                      MachineMemOperand *mmo)
6134    : SDNode(Opc, Order, dl, VTs, Ops, NumOps),
6135      MemoryVT(memvt), MMO(mmo) {
6136   SubclassData = encodeMemSDNodeFlags(0, ISD::UNINDEXED, MMO->isVolatile(),
6137                                       MMO->isNonTemporal(), MMO->isInvariant());
6138   assert(isVolatile() == MMO->isVolatile() && "Volatile encoding error!");
6139   assert(memvt.getStoreSize() == MMO->getSize() && "Size mismatch!");
6140 }
6141
6142 /// Profile - Gather unique data for the node.
6143 ///
6144 void SDNode::Profile(FoldingSetNodeID &ID) const {
6145   AddNodeIDNode(ID, this);
6146 }
6147
6148 namespace {
6149   struct EVTArray {
6150     std::vector<EVT> VTs;
6151
6152     EVTArray() {
6153       VTs.reserve(MVT::LAST_VALUETYPE);
6154       for (unsigned i = 0; i < MVT::LAST_VALUETYPE; ++i)
6155         VTs.push_back(MVT((MVT::SimpleValueType)i));
6156     }
6157   };
6158 }
6159
6160 static ManagedStatic<std::set<EVT, EVT::compareRawBits> > EVTs;
6161 static ManagedStatic<EVTArray> SimpleVTArray;
6162 static ManagedStatic<sys::SmartMutex<true> > VTMutex;
6163
6164 /// getValueTypeList - Return a pointer to the specified value type.
6165 ///
6166 const EVT *SDNode::getValueTypeList(EVT VT) {
6167   if (VT.isExtended()) {
6168     sys::SmartScopedLock<true> Lock(*VTMutex);
6169     return &(*EVTs->insert(VT).first);
6170   } else {
6171     assert(VT.getSimpleVT() < MVT::LAST_VALUETYPE &&
6172            "Value type out of range!");
6173     return &SimpleVTArray->VTs[VT.getSimpleVT().SimpleTy];
6174   }
6175 }
6176
6177 /// hasNUsesOfValue - Return true if there are exactly NUSES uses of the
6178 /// indicated value.  This method ignores uses of other values defined by this
6179 /// operation.
6180 bool SDNode::hasNUsesOfValue(unsigned NUses, unsigned Value) const {
6181   assert(Value < getNumValues() && "Bad value!");
6182
6183   // TODO: Only iterate over uses of a given value of the node
6184   for (SDNode::use_iterator UI = use_begin(), E = use_end(); UI != E; ++UI) {
6185     if (UI.getUse().getResNo() == Value) {
6186       if (NUses == 0)
6187         return false;
6188       --NUses;
6189     }
6190   }
6191
6192   // Found exactly the right number of uses?
6193   return NUses == 0;
6194 }
6195
6196
6197 /// hasAnyUseOfValue - Return true if there are any use of the indicated
6198 /// value. This method ignores uses of other values defined by this operation.
6199 bool SDNode::hasAnyUseOfValue(unsigned Value) const {
6200   assert(Value < getNumValues() && "Bad value!");
6201
6202   for (SDNode::use_iterator UI = use_begin(), E = use_end(); UI != E; ++UI)
6203     if (UI.getUse().getResNo() == Value)
6204       return true;
6205
6206   return false;
6207 }
6208
6209
6210 /// isOnlyUserOf - Return true if this node is the only use of N.
6211 ///
6212 bool SDNode::isOnlyUserOf(SDNode *N) const {
6213   bool Seen = false;
6214   for (SDNode::use_iterator I = N->use_begin(), E = N->use_end(); I != E; ++I) {
6215     SDNode *User = *I;
6216     if (User == this)
6217       Seen = true;
6218     else
6219       return false;
6220   }
6221
6222   return Seen;
6223 }
6224
6225 /// isOperand - Return true if this node is an operand of N.
6226 ///
6227 bool SDValue::isOperandOf(SDNode *N) const {
6228   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
6229     if (*this == N->getOperand(i))
6230       return true;
6231   return false;
6232 }
6233
6234 bool SDNode::isOperandOf(SDNode *N) const {
6235   for (unsigned i = 0, e = N->NumOperands; i != e; ++i)
6236     if (this == N->OperandList[i].getNode())
6237       return true;
6238   return false;
6239 }
6240
6241 /// reachesChainWithoutSideEffects - Return true if this operand (which must
6242 /// be a chain) reaches the specified operand without crossing any
6243 /// side-effecting instructions on any chain path.  In practice, this looks
6244 /// through token factors and non-volatile loads.  In order to remain efficient,
6245 /// this only looks a couple of nodes in, it does not do an exhaustive search.
6246 bool SDValue::reachesChainWithoutSideEffects(SDValue Dest,
6247                                                unsigned Depth) const {
6248   if (*this == Dest) return true;
6249
6250   // Don't search too deeply, we just want to be able to see through
6251   // TokenFactor's etc.
6252   if (Depth == 0) return false;
6253
6254   // If this is a token factor, all inputs to the TF happen in parallel.  If any
6255   // of the operands of the TF does not reach dest, then we cannot do the xform.
6256   if (getOpcode() == ISD::TokenFactor) {
6257     for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
6258       if (!getOperand(i).reachesChainWithoutSideEffects(Dest, Depth-1))
6259         return false;
6260     return true;
6261   }
6262
6263   // Loads don't have side effects, look through them.
6264   if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(*this)) {
6265     if (!Ld->isVolatile())
6266       return Ld->getChain().reachesChainWithoutSideEffects(Dest, Depth-1);
6267   }
6268   return false;
6269 }
6270
6271 /// hasPredecessor - Return true if N is a predecessor of this node.
6272 /// N is either an operand of this node, or can be reached by recursively
6273 /// traversing up the operands.
6274 /// NOTE: This is an expensive method. Use it carefully.
6275 bool SDNode::hasPredecessor(const SDNode *N) const {
6276   SmallPtrSet<const SDNode *, 32> Visited;
6277   SmallVector<const SDNode *, 16> Worklist;
6278   return hasPredecessorHelper(N, Visited, Worklist);
6279 }
6280
6281 bool
6282 SDNode::hasPredecessorHelper(const SDNode *N,
6283                              SmallPtrSet<const SDNode *, 32> &Visited,
6284                              SmallVectorImpl<const SDNode *> &Worklist) const {
6285   if (Visited.empty()) {
6286     Worklist.push_back(this);
6287   } else {
6288     // Take a look in the visited set. If we've already encountered this node
6289     // we needn't search further.
6290     if (Visited.count(N))
6291       return true;
6292   }
6293
6294   // Haven't visited N yet. Continue the search.
6295   while (!Worklist.empty()) {
6296     const SDNode *M = Worklist.pop_back_val();
6297     for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i) {
6298       SDNode *Op = M->getOperand(i).getNode();
6299       if (Visited.insert(Op))
6300         Worklist.push_back(Op);
6301       if (Op == N)
6302         return true;
6303     }
6304   }
6305
6306   return false;
6307 }
6308
6309 uint64_t SDNode::getConstantOperandVal(unsigned Num) const {
6310   assert(Num < NumOperands && "Invalid child # of SDNode!");
6311   return cast<ConstantSDNode>(OperandList[Num])->getZExtValue();
6312 }
6313
6314 SDValue SelectionDAG::UnrollVectorOp(SDNode *N, unsigned ResNE) {
6315   assert(N->getNumValues() == 1 &&
6316          "Can't unroll a vector with multiple results!");
6317
6318   EVT VT = N->getValueType(0);
6319   unsigned NE = VT.getVectorNumElements();
6320   EVT EltVT = VT.getVectorElementType();
6321   SDLoc dl(N);
6322
6323   SmallVector<SDValue, 8> Scalars;
6324   SmallVector<SDValue, 4> Operands(N->getNumOperands());
6325
6326   // If ResNE is 0, fully unroll the vector op.
6327   if (ResNE == 0)
6328     ResNE = NE;
6329   else if (NE > ResNE)
6330     NE = ResNE;
6331
6332   unsigned i;
6333   for (i= 0; i != NE; ++i) {
6334     for (unsigned j = 0, e = N->getNumOperands(); j != e; ++j) {
6335       SDValue Operand = N->getOperand(j);
6336       EVT OperandVT = Operand.getValueType();
6337       if (OperandVT.isVector()) {
6338         // A vector operand; extract a single element.
6339         const TargetLowering *TLI = TM.getTargetLowering();
6340         EVT OperandEltVT = OperandVT.getVectorElementType();
6341         Operands[j] = getNode(ISD::EXTRACT_VECTOR_ELT, dl,
6342                               OperandEltVT,
6343                               Operand,
6344                               getConstant(i, TLI->getVectorIdxTy()));
6345       } else {
6346         // A scalar operand; just use it as is.
6347         Operands[j] = Operand;
6348       }
6349     }
6350
6351     switch (N->getOpcode()) {
6352     default:
6353       Scalars.push_back(getNode(N->getOpcode(), dl, EltVT,
6354                                 &Operands[0], Operands.size()));
6355       break;
6356     case ISD::VSELECT:
6357       Scalars.push_back(getNode(ISD::SELECT, dl, EltVT,
6358                                 &Operands[0], Operands.size()));
6359       break;
6360     case ISD::SHL:
6361     case ISD::SRA:
6362     case ISD::SRL:
6363     case ISD::ROTL:
6364     case ISD::ROTR:
6365       Scalars.push_back(getNode(N->getOpcode(), dl, EltVT, Operands[0],
6366                                getShiftAmountOperand(Operands[0].getValueType(),
6367                                                      Operands[1])));
6368       break;
6369     case ISD::SIGN_EXTEND_INREG:
6370     case ISD::FP_ROUND_INREG: {
6371       EVT ExtVT = cast<VTSDNode>(Operands[1])->getVT().getVectorElementType();
6372       Scalars.push_back(getNode(N->getOpcode(), dl, EltVT,
6373                                 Operands[0],
6374                                 getValueType(ExtVT)));
6375     }
6376     }
6377   }
6378
6379   for (; i < ResNE; ++i)
6380     Scalars.push_back(getUNDEF(EltVT));
6381
6382   return getNode(ISD::BUILD_VECTOR, dl,
6383                  EVT::getVectorVT(*getContext(), EltVT, ResNE),
6384                  &Scalars[0], Scalars.size());
6385 }
6386
6387
6388 /// isConsecutiveLoad - Return true if LD is loading 'Bytes' bytes from a
6389 /// location that is 'Dist' units away from the location that the 'Base' load
6390 /// is loading from.
6391 bool SelectionDAG::isConsecutiveLoad(LoadSDNode *LD, LoadSDNode *Base,
6392                                      unsigned Bytes, int Dist) const {
6393   if (LD->getChain() != Base->getChain())
6394     return false;
6395   EVT VT = LD->getValueType(0);
6396   if (VT.getSizeInBits() / 8 != Bytes)
6397     return false;
6398
6399   SDValue Loc = LD->getOperand(1);
6400   SDValue BaseLoc = Base->getOperand(1);
6401   if (Loc.getOpcode() == ISD::FrameIndex) {
6402     if (BaseLoc.getOpcode() != ISD::FrameIndex)
6403       return false;
6404     const MachineFrameInfo *MFI = getMachineFunction().getFrameInfo();
6405     int FI  = cast<FrameIndexSDNode>(Loc)->getIndex();
6406     int BFI = cast<FrameIndexSDNode>(BaseLoc)->getIndex();
6407     int FS  = MFI->getObjectSize(FI);
6408     int BFS = MFI->getObjectSize(BFI);
6409     if (FS != BFS || FS != (int)Bytes) return false;
6410     return MFI->getObjectOffset(FI) == (MFI->getObjectOffset(BFI) + Dist*Bytes);
6411   }
6412
6413   // Handle X+C
6414   if (isBaseWithConstantOffset(Loc) && Loc.getOperand(0) == BaseLoc &&
6415       cast<ConstantSDNode>(Loc.getOperand(1))->getSExtValue() == Dist*Bytes)
6416     return true;
6417
6418   const GlobalValue *GV1 = NULL;
6419   const GlobalValue *GV2 = NULL;
6420   int64_t Offset1 = 0;
6421   int64_t Offset2 = 0;
6422   const TargetLowering *TLI = TM.getTargetLowering();
6423   bool isGA1 = TLI->isGAPlusOffset(Loc.getNode(), GV1, Offset1);
6424   bool isGA2 = TLI->isGAPlusOffset(BaseLoc.getNode(), GV2, Offset2);
6425   if (isGA1 && isGA2 && GV1 == GV2)
6426     return Offset1 == (Offset2 + Dist*Bytes);
6427   return false;
6428 }
6429
6430
6431 /// InferPtrAlignment - Infer alignment of a load / store address. Return 0 if
6432 /// it cannot be inferred.
6433 unsigned SelectionDAG::InferPtrAlignment(SDValue Ptr) const {
6434   // If this is a GlobalAddress + cst, return the alignment.
6435   const GlobalValue *GV;
6436   int64_t GVOffset = 0;
6437   const TargetLowering *TLI = TM.getTargetLowering();
6438   if (TLI->isGAPlusOffset(Ptr.getNode(), GV, GVOffset)) {
6439     unsigned PtrWidth = TLI->getPointerTypeSizeInBits(GV->getType());
6440     APInt KnownZero(PtrWidth, 0), KnownOne(PtrWidth, 0);
6441     llvm::ComputeMaskedBits(const_cast<GlobalValue*>(GV), KnownZero, KnownOne,
6442                             TLI->getDataLayout());
6443     unsigned AlignBits = KnownZero.countTrailingOnes();
6444     unsigned Align = AlignBits ? 1 << std::min(31U, AlignBits) : 0;
6445     if (Align)
6446       return MinAlign(Align, GVOffset);
6447   }
6448
6449   // If this is a direct reference to a stack slot, use information about the
6450   // stack slot's alignment.
6451   int FrameIdx = 1 << 31;
6452   int64_t FrameOffset = 0;
6453   if (FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Ptr)) {
6454     FrameIdx = FI->getIndex();
6455   } else if (isBaseWithConstantOffset(Ptr) &&
6456              isa<FrameIndexSDNode>(Ptr.getOperand(0))) {
6457     // Handle FI+Cst
6458     FrameIdx = cast<FrameIndexSDNode>(Ptr.getOperand(0))->getIndex();
6459     FrameOffset = Ptr.getConstantOperandVal(1);
6460   }
6461
6462   if (FrameIdx != (1 << 31)) {
6463     const MachineFrameInfo &MFI = *getMachineFunction().getFrameInfo();
6464     unsigned FIInfoAlign = MinAlign(MFI.getObjectAlignment(FrameIdx),
6465                                     FrameOffset);
6466     return FIInfoAlign;
6467   }
6468
6469   return 0;
6470 }
6471
6472 /// GetSplitDestVTs - Compute the VTs needed for the low/hi parts of a type
6473 /// which is split (or expanded) into two not necessarily identical pieces.
6474 std::pair<EVT, EVT> SelectionDAG::GetSplitDestVTs(const EVT &VT) const {
6475   // Currently all types are split in half.
6476   EVT LoVT, HiVT;
6477   if (!VT.isVector()) {
6478     LoVT = HiVT = TLI->getTypeToTransformTo(*getContext(), VT);
6479   } else {
6480     unsigned NumElements = VT.getVectorNumElements();
6481     assert(!(NumElements & 1) && "Splitting vector, but not in half!");
6482     LoVT = HiVT = EVT::getVectorVT(*getContext(), VT.getVectorElementType(),
6483                                    NumElements/2);
6484   }
6485   return std::make_pair(LoVT, HiVT);
6486 }
6487
6488 /// SplitVector - Split the vector with EXTRACT_SUBVECTOR and return the
6489 /// low/high part.
6490 std::pair<SDValue, SDValue>
6491 SelectionDAG::SplitVector(const SDValue &N, const SDLoc &DL, const EVT &LoVT,
6492                           const EVT &HiVT) {
6493   assert(LoVT.getVectorNumElements() + HiVT.getVectorNumElements() <=
6494          N.getValueType().getVectorNumElements() &&
6495          "More vector elements requested than available!");
6496   SDValue Lo, Hi;
6497   Lo = getNode(ISD::EXTRACT_SUBVECTOR, DL, LoVT, N,
6498                getConstant(0, TLI->getVectorIdxTy()));
6499   Hi = getNode(ISD::EXTRACT_SUBVECTOR, DL, HiVT, N,
6500                getConstant(LoVT.getVectorNumElements(), TLI->getVectorIdxTy()));
6501   return std::make_pair(Lo, Hi);
6502 }
6503
6504 // getAddressSpace - Return the address space this GlobalAddress belongs to.
6505 unsigned GlobalAddressSDNode::getAddressSpace() const {
6506   return getGlobal()->getType()->getAddressSpace();
6507 }
6508
6509
6510 Type *ConstantPoolSDNode::getType() const {
6511   if (isMachineConstantPoolEntry())
6512     return Val.MachineCPVal->getType();
6513   return Val.ConstVal->getType();
6514 }
6515
6516 bool BuildVectorSDNode::isConstantSplat(APInt &SplatValue,
6517                                         APInt &SplatUndef,
6518                                         unsigned &SplatBitSize,
6519                                         bool &HasAnyUndefs,
6520                                         unsigned MinSplatBits,
6521                                         bool isBigEndian) const {
6522   EVT VT = getValueType(0);
6523   assert(VT.isVector() && "Expected a vector type");
6524   unsigned sz = VT.getSizeInBits();
6525   if (MinSplatBits > sz)
6526     return false;
6527
6528   SplatValue = APInt(sz, 0);
6529   SplatUndef = APInt(sz, 0);
6530
6531   // Get the bits.  Bits with undefined values (when the corresponding element
6532   // of the vector is an ISD::UNDEF value) are set in SplatUndef and cleared
6533   // in SplatValue.  If any of the values are not constant, give up and return
6534   // false.
6535   unsigned int nOps = getNumOperands();
6536   assert(nOps > 0 && "isConstantSplat has 0-size build vector");
6537   unsigned EltBitSize = VT.getVectorElementType().getSizeInBits();
6538
6539   for (unsigned j = 0; j < nOps; ++j) {
6540     unsigned i = isBigEndian ? nOps-1-j : j;
6541     SDValue OpVal = getOperand(i);
6542     unsigned BitPos = j * EltBitSize;
6543
6544     if (OpVal.getOpcode() == ISD::UNDEF)
6545       SplatUndef |= APInt::getBitsSet(sz, BitPos, BitPos + EltBitSize);
6546     else if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(OpVal))
6547       SplatValue |= CN->getAPIntValue().zextOrTrunc(EltBitSize).
6548                     zextOrTrunc(sz) << BitPos;
6549     else if (ConstantFPSDNode *CN = dyn_cast<ConstantFPSDNode>(OpVal))
6550       SplatValue |= CN->getValueAPF().bitcastToAPInt().zextOrTrunc(sz) <<BitPos;
6551      else
6552       return false;
6553   }
6554
6555   // The build_vector is all constants or undefs.  Find the smallest element
6556   // size that splats the vector.
6557
6558   HasAnyUndefs = (SplatUndef != 0);
6559   while (sz > 8) {
6560
6561     unsigned HalfSize = sz / 2;
6562     APInt HighValue = SplatValue.lshr(HalfSize).trunc(HalfSize);
6563     APInt LowValue = SplatValue.trunc(HalfSize);
6564     APInt HighUndef = SplatUndef.lshr(HalfSize).trunc(HalfSize);
6565     APInt LowUndef = SplatUndef.trunc(HalfSize);
6566
6567     // If the two halves do not match (ignoring undef bits), stop here.
6568     if ((HighValue & ~LowUndef) != (LowValue & ~HighUndef) ||
6569         MinSplatBits > HalfSize)
6570       break;
6571
6572     SplatValue = HighValue | LowValue;
6573     SplatUndef = HighUndef & LowUndef;
6574
6575     sz = HalfSize;
6576   }
6577
6578   SplatBitSize = sz;
6579   return true;
6580 }
6581
6582 ConstantSDNode *BuildVectorSDNode::getConstantSplatValue() const {
6583   SDValue Op0 = getOperand(0);
6584   if (Op0.getOpcode() != ISD::Constant)
6585     return nullptr;
6586
6587   for (unsigned i = 1, e = getNumOperands(); i != e; ++i)
6588     if (getOperand(i) != Op0)
6589       return nullptr;
6590
6591   return cast<ConstantSDNode>(Op0);
6592 }
6593
6594 bool BuildVectorSDNode::isConstant() const {
6595   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
6596     unsigned Opc = getOperand(i).getOpcode();
6597     if (Opc != ISD::UNDEF && Opc != ISD::Constant && Opc != ISD::ConstantFP)
6598       return false;
6599   }
6600   return true;
6601 }
6602
6603 bool ShuffleVectorSDNode::isSplatMask(const int *Mask, EVT VT) {
6604   // Find the first non-undef value in the shuffle mask.
6605   unsigned i, e;
6606   for (i = 0, e = VT.getVectorNumElements(); i != e && Mask[i] < 0; ++i)
6607     /* search */;
6608
6609   assert(i != e && "VECTOR_SHUFFLE node with all undef indices!");
6610
6611   // Make sure all remaining elements are either undef or the same as the first
6612   // non-undef value.
6613   for (int Idx = Mask[i]; i != e; ++i)
6614     if (Mask[i] >= 0 && Mask[i] != Idx)
6615       return false;
6616   return true;
6617 }
6618
6619 #ifdef XDEBUG
6620 static void checkForCyclesHelper(const SDNode *N,
6621                                  SmallPtrSet<const SDNode*, 32> &Visited,
6622                                  SmallPtrSet<const SDNode*, 32> &Checked) {
6623   // If this node has already been checked, don't check it again.
6624   if (Checked.count(N))
6625     return;
6626
6627   // If a node has already been visited on this depth-first walk, reject it as
6628   // a cycle.
6629   if (!Visited.insert(N)) {
6630     dbgs() << "Offending node:\n";
6631     N->dumprFull();
6632     errs() << "Detected cycle in SelectionDAG\n";
6633     abort();
6634   }
6635
6636   for(unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
6637     checkForCyclesHelper(N->getOperand(i).getNode(), Visited, Checked);
6638
6639   Checked.insert(N);
6640   Visited.erase(N);
6641 }
6642 #endif
6643
6644 void llvm::checkForCycles(const llvm::SDNode *N) {
6645 #ifdef XDEBUG
6646   assert(N && "Checking nonexistent SDNode");
6647   SmallPtrSet<const SDNode*, 32> visited;
6648   SmallPtrSet<const SDNode*, 32> checked;
6649   checkForCyclesHelper(N, visited, checked);
6650 #endif
6651 }
6652
6653 void llvm::checkForCycles(const llvm::SelectionDAG *DAG) {
6654   checkForCycles(DAG->getRoot().getNode());
6655 }