lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp

   1 //===-------- LegalizeTypesGeneric.cpp - Generic type legalization --------===//
   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 file implements generic type expansion and splitting for LegalizeTypes.
  11 // The routines here perform legalization when the details of the type (such as
  12 // whether it is an integer or a float) do not matter.
  13 // Expansion is the act of changing a computation in an illegal type to be a
  14 // computation in two identical registers of a smaller type.  The Lo/Hi part
  15 // is required to be stored first in memory on little/big-endian machines.
  16 // Splitting is the act of changing a computation in an illegal type to be a
  17 // computation in two not necessarily identical registers of a smaller type.
  18 // There are no requirements on how the type is represented in memory.
  19 //
  20 //===----------------------------------------------------------------------===//
  21
  22 #include "LegalizeTypes.h"
  23 #include "llvm/IR/DataLayout.h"
  24 using namespace llvm;
  25
  26 #define DEBUG_TYPE "legalize-types"
  27
  28 //===----------------------------------------------------------------------===//
  29 // Generic Result Expansion.
  30 //===----------------------------------------------------------------------===//
  31
  32 // These routines assume that the Lo/Hi part is stored first in memory on
  33 // little/big-endian machines, followed by the Hi/Lo part.  This means that
  34 // they cannot be used as is on vectors, for which Lo is always stored first.
  35 void DAGTypeLegalizer::ExpandRes_MERGE_VALUES(SDNode *N, unsigned ResNo,
  36                                               SDValue &Lo, SDValue &Hi) {
  37   SDValue Op = DisintegrateMERGE_VALUES(N, ResNo);
  38   GetExpandedOp(Op, Lo, Hi);
  39 }
  40
  41 void DAGTypeLegalizer::ExpandRes_BITCAST(SDNode *N, SDValue &Lo, SDValue &Hi) {
  42   EVT OutVT = N->getValueType(0);
  43   EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
  44   SDValue InOp = N->getOperand(0);
  45   EVT InVT = InOp.getValueType();
  46   SDLoc dl(N);
  47
  48   // Handle some special cases efficiently.
  49   switch (getTypeAction(InVT)) {
  50     case TargetLowering::TypeLegal:
  51     case TargetLowering::TypePromoteInteger:
  52       break;
  53     case TargetLowering::TypePromoteFloat:
  54       llvm_unreachable("Bitcast of a promotion-needing float should never need"
  55                        "expansion");
  56     case TargetLowering::TypeSoftenFloat:
  57       // Convert the integer operand instead.
  58       SplitInteger(GetSoftenedFloat(InOp), Lo, Hi);
  59       Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
  60       Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
  61       return;
  62     case TargetLowering::TypeExpandInteger:
  63     case TargetLowering::TypeExpandFloat: {
  64       auto &DL = DAG.getDataLayout();
  65       // Convert the expanded pieces of the input.
  66       GetExpandedOp(InOp, Lo, Hi);
  67       if (TLI.hasBigEndianPartOrdering(InVT, DL) !=
  68           TLI.hasBigEndianPartOrdering(OutVT, DL))
  69         std::swap(Lo, Hi);
  70       Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
  71       Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
  72       return;
  73     }
  74     case TargetLowering::TypeSplitVector:
  75       GetSplitVector(InOp, Lo, Hi);
  76       if (TLI.hasBigEndianPartOrdering(OutVT, DAG.getDataLayout()))
  77         std::swap(Lo, Hi);
  78       Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
  79       Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
  80       return;
  81     case TargetLowering::TypeScalarizeVector:
  82       // Convert the element instead.
  83       SplitInteger(BitConvertToInteger(GetScalarizedVector(InOp)), Lo, Hi);
  84       Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
  85       Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
  86       return;
  87     case TargetLowering::TypeWidenVector: {
  88       assert(!(InVT.getVectorNumElements() & 1) && "Unsupported BITCAST");
  89       InOp = GetWidenedVector(InOp);
  90       EVT LoVT, HiVT;
  91       std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(InVT);
  92       std::tie(Lo, Hi) = DAG.SplitVector(InOp, dl, LoVT, HiVT);
  93       if (TLI.hasBigEndianPartOrdering(OutVT, DAG.getDataLayout()))
  94         std::swap(Lo, Hi);
  95       Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
  96       Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
  97       return;
  98     }
  99   }
 100
 101   if (InVT.isVector() && OutVT.isInteger()) {
 102     // Handle cases like i64 = BITCAST v1i64 on x86, where the operand
 103     // is legal but the result is not.
 104     unsigned NumElems = 2;
 105     EVT ElemVT = NOutVT;
 106     EVT NVT = EVT::getVectorVT(*DAG.getContext(), ElemVT, NumElems);
 107
 108     // If <ElemVT * N> is not a legal type, try <ElemVT/2 * (N*2)>.
 109     while (!isTypeLegal(NVT)) {
 110       unsigned NewSizeInBits = ElemVT.getSizeInBits() / 2;
 111       // If the element size is smaller than byte, bail.
 112       if (NewSizeInBits < 8)
 113         break;
 114       NumElems *= 2;
 115       ElemVT = EVT::getIntegerVT(*DAG.getContext(), NewSizeInBits);
 116       NVT = EVT::getVectorVT(*DAG.getContext(), ElemVT, NumElems);
 117     }
 118
 119     if (isTypeLegal(NVT)) {
 120       SDValue CastInOp = DAG.getNode(ISD::BITCAST, dl, NVT, InOp);
 121
 122       SmallVector<SDValue, 8> Vals;
 123       for (unsigned i = 0; i < NumElems; ++i)
 124         Vals.push_back(DAG.getNode(
 125             ISD::EXTRACT_VECTOR_ELT, dl, ElemVT, CastInOp,
 126             DAG.getConstant(i, dl, TLI.getVectorIdxTy(DAG.getDataLayout()))));
 127
 128       // Build Lo, Hi pair by pairing extracted elements if needed.
 129       unsigned Slot = 0;
 130       for (unsigned e = Vals.size(); e - Slot > 2; Slot += 2, e += 1) {
 131         // Each iteration will BUILD_PAIR two nodes and append the result until
 132         // there are only two nodes left, i.e. Lo and Hi.
 133         SDValue LHS = Vals[Slot];
 134         SDValue RHS = Vals[Slot + 1];
 135
 136         if (DAG.getDataLayout().isBigEndian())
 137           std::swap(LHS, RHS);
 138
 139         Vals.push_back(DAG.getNode(ISD::BUILD_PAIR, dl,
 140                                    EVT::getIntegerVT(
 141                                      *DAG.getContext(),
 142                                      LHS.getValueType().getSizeInBits() << 1),
 143                                    LHS, RHS));
 144       }
 145       Lo = Vals[Slot++];
 146       Hi = Vals[Slot++];
 147
 148       if (DAG.getDataLayout().isBigEndian())
 149         std::swap(Lo, Hi);
 150
 151       return;
 152     }
 153   }
 154
 155   // Lower the bit-convert to a store/load from the stack.
 156   assert(NOutVT.isByteSized() && "Expanded type not byte sized!");
 157
 158   // Create the stack frame object.  Make sure it is aligned for both
 159   // the source and expanded destination types.
 160   unsigned Alignment = DAG.getDataLayout().getPrefTypeAlignment(
 161       NOutVT.getTypeForEVT(*DAG.getContext()));
 162   SDValue StackPtr = DAG.CreateStackTemporary(InVT, Alignment);
 163   int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
 164   MachinePointerInfo PtrInfo =
 165       MachinePointerInfo::getFixedStack(DAG.getMachineFunction(), SPFI);
 166
 167   // Emit a store to the stack slot.
 168   SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, InOp, StackPtr, PtrInfo,
 169                                false, false, 0);
 170
 171   // Load the first half from the stack slot.
 172   Lo = DAG.getLoad(NOutVT, dl, Store, StackPtr, PtrInfo,
 173                    false, false, false, 0);
 174
 175   // Increment the pointer to the other half.
 176   unsigned IncrementSize = NOutVT.getSizeInBits() / 8;
 177   StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
 178                          DAG.getConstant(IncrementSize, dl,
 179                                          StackPtr.getValueType()));
 180
 181   // Load the second half from the stack slot.
 182   Hi = DAG.getLoad(NOutVT, dl, Store, StackPtr,
 183                    PtrInfo.getWithOffset(IncrementSize), false,
 184                    false, false, MinAlign(Alignment, IncrementSize));
 185
 186   // Handle endianness of the load.
 187   if (TLI.hasBigEndianPartOrdering(OutVT, DAG.getDataLayout()))
 188     std::swap(Lo, Hi);
 189 }
 190
 191 void DAGTypeLegalizer::ExpandRes_BUILD_PAIR(SDNode *N, SDValue &Lo,
 192                                             SDValue &Hi) {
 193   // Return the operands.
 194   Lo = N->getOperand(0);
 195   Hi = N->getOperand(1);
 196 }
 197
 198 void DAGTypeLegalizer::ExpandRes_EXTRACT_ELEMENT(SDNode *N, SDValue &Lo,
 199                                                  SDValue &Hi) {
 200   GetExpandedOp(N->getOperand(0), Lo, Hi);
 201   SDValue Part = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ?
 202                    Hi : Lo;
 203
 204   assert(Part.getValueType() == N->getValueType(0) &&
 205          "Type twice as big as expanded type not itself expanded!");
 206
 207   GetPairElements(Part, Lo, Hi);
 208 }
 209
 210 void DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo,
 211                                                     SDValue &Hi) {
 212   SDValue OldVec = N->getOperand(0);
 213   unsigned OldElts = OldVec.getValueType().getVectorNumElements();
 214   EVT OldEltVT = OldVec.getValueType().getVectorElementType();
 215   SDLoc dl(N);
 216
 217   // Convert to a vector of the expanded element type, for example
 218   // <3 x i64> -> <6 x i32>.
 219   EVT OldVT = N->getValueType(0);
 220   EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT);
 221
 222   if (OldVT != OldEltVT) {
 223     // The result of EXTRACT_VECTOR_ELT may be larger than the element type of
 224     // the input vector.  If so, extend the elements of the input vector to the
 225     // same bitwidth as the result before expanding.
 226     assert(OldEltVT.bitsLT(OldVT) && "Result type smaller then element type!");
 227     EVT NVecVT = EVT::getVectorVT(*DAG.getContext(), OldVT, OldElts);
 228     OldVec = DAG.getNode(ISD::ANY_EXTEND, dl, NVecVT, N->getOperand(0));
 229   }
 230
 231   SDValue NewVec = DAG.getNode(ISD::BITCAST, dl,
 232                                EVT::getVectorVT(*DAG.getContext(),
 233                                                 NewVT, 2*OldElts),
 234                                OldVec);
 235
 236   // Extract the elements at 2 * Idx and 2 * Idx + 1 from the new vector.
 237   SDValue Idx = N->getOperand(1);
 238
 239   Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx);
 240   Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx);
 241
 242   Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx,
 243                     DAG.getConstant(1, dl, Idx.getValueType()));
 244   Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx);
 245
 246   if (DAG.getDataLayout().isBigEndian())
 247     std::swap(Lo, Hi);
 248 }
 249
 250 void DAGTypeLegalizer::ExpandRes_NormalLoad(SDNode *N, SDValue &Lo,
 251                                             SDValue &Hi) {
 252   assert(ISD::isNormalLoad(N) && "This routine only for normal loads!");
 253   SDLoc dl(N);
 254
 255   LoadSDNode *LD = cast<LoadSDNode>(N);
 256   EVT ValueVT = LD->getValueType(0);
 257   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), ValueVT);
 258   SDValue Chain = LD->getChain();
 259   SDValue Ptr = LD->getBasePtr();
 260   unsigned Alignment = LD->getAlignment();
 261   bool isVolatile = LD->isVolatile();
 262   bool isNonTemporal = LD->isNonTemporal();
 263   bool isInvariant = LD->isInvariant();
 264   AAMDNodes AAInfo = LD->getAAInfo();
 265
 266   assert(NVT.isByteSized() && "Expanded type not byte sized!");
 267
 268   Lo = DAG.getLoad(NVT, dl, Chain, Ptr, LD->getPointerInfo(),
 269                    isVolatile, isNonTemporal, isInvariant, Alignment,
 270                    AAInfo);
 271
 272   // Increment the pointer to the other half.
 273   unsigned IncrementSize = NVT.getSizeInBits() / 8;
 274   Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
 275                     DAG.getConstant(IncrementSize, dl, Ptr.getValueType()));
 276   Hi = DAG.getLoad(NVT, dl, Chain, Ptr,
 277                    LD->getPointerInfo().getWithOffset(IncrementSize),
 278                    isVolatile, isNonTemporal, isInvariant,
 279                    MinAlign(Alignment, IncrementSize), AAInfo);
 280
 281   // Build a factor node to remember that this load is independent of the
 282   // other one.
 283   Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
 284                       Hi.getValue(1));
 285
 286   // Handle endianness of the load.
 287   if (TLI.hasBigEndianPartOrdering(ValueVT, DAG.getDataLayout()))
 288     std::swap(Lo, Hi);
 289
 290   // Modified the chain - switch anything that used the old chain to use
 291   // the new one.
 292   ReplaceValueWith(SDValue(N, 1), Chain);
 293 }
 294
 295 void DAGTypeLegalizer::ExpandRes_VAARG(SDNode *N, SDValue &Lo, SDValue &Hi) {
 296   EVT OVT = N->getValueType(0);
 297   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), OVT);
 298   SDValue Chain = N->getOperand(0);
 299   SDValue Ptr = N->getOperand(1);
 300   SDLoc dl(N);
 301   const unsigned Align = N->getConstantOperandVal(3);
 302
 303   Lo = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2), Align);
 304   Hi = DAG.getVAArg(NVT, dl, Lo.getValue(1), Ptr, N->getOperand(2), 0);
 305
 306   // Handle endianness of the load.
 307   if (TLI.hasBigEndianPartOrdering(OVT, DAG.getDataLayout()))
 308     std::swap(Lo, Hi);
 309
 310   // Modified the chain - switch anything that used the old chain to use
 311   // the new one.
 312   ReplaceValueWith(SDValue(N, 1), Hi.getValue(1));
 313 }
 314
 315
 316 //===--------------------------------------------------------------------===//
 317 // Generic Operand Expansion.
 318 //===--------------------------------------------------------------------===//
 319
 320 void DAGTypeLegalizer::IntegerToVector(SDValue Op, unsigned NumElements,
 321                                        SmallVectorImpl<SDValue> &Ops,
 322                                        EVT EltVT) {
 323   assert(Op.getValueType().isInteger());
 324   SDLoc DL(Op);
 325   SDValue Parts[2];
 326
 327   if (NumElements > 1) {
 328     NumElements >>= 1;
 329     SplitInteger(Op, Parts[0], Parts[1]);
 330     if (DAG.getDataLayout().isBigEndian())
 331         std::swap(Parts[0], Parts[1]);
 332     IntegerToVector(Parts[0], NumElements, Ops, EltVT);
 333     IntegerToVector(Parts[1], NumElements, Ops, EltVT);
 334   } else {
 335     Ops.push_back(DAG.getNode(ISD::BITCAST, DL, EltVT, Op));
 336   }
 337 }
 338
 339 SDValue DAGTypeLegalizer::ExpandOp_BITCAST(SDNode *N) {
 340   SDLoc dl(N);
 341   if (N->getValueType(0).isVector()) {
 342     // An illegal expanding type is being converted to a legal vector type.
 343     // Make a two element vector out of the expanded parts and convert that
 344     // instead, but only if the new vector type is legal (otherwise there
 345     // is no point, and it might create expansion loops).  For example, on
 346     // x86 this turns v1i64 = BITCAST i64 into v1i64 = BITCAST v2i32.
 347     //
 348     // FIXME: I'm not sure why we are first trying to split the input into
 349     // a 2 element vector, so I'm leaving it here to maintain the current
 350     // behavior.
 351     unsigned NumElts = 2;
 352     EVT OVT = N->getOperand(0).getValueType();
 353     EVT NVT = EVT::getVectorVT(*DAG.getContext(),
 354                                TLI.getTypeToTransformTo(*DAG.getContext(), OVT),
 355                                NumElts);
 356     if (!isTypeLegal(NVT)) {
 357       // If we can't find a legal type by splitting the integer in half,
 358       // then we can use the node's value type.
 359       NumElts = N->getValueType(0).getVectorNumElements();
 360       NVT = N->getValueType(0);
 361     }
 362
 363     SmallVector<SDValue, 8> Ops;
 364     IntegerToVector(N->getOperand(0), NumElts, Ops, NVT.getVectorElementType());
 365
 366     SDValue Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT,
 367                               makeArrayRef(Ops.data(), NumElts));
 368     return DAG.getNode(ISD::BITCAST, dl, N->getValueType(0), Vec);
 369   }
 370
 371   // Otherwise, store to a temporary and load out again as the new type.
 372   return CreateStackStoreLoad(N->getOperand(0), N->getValueType(0));
 373 }
 374
 375 SDValue DAGTypeLegalizer::ExpandOp_BUILD_VECTOR(SDNode *N) {
 376   // The vector type is legal but the element type needs expansion.
 377   EVT VecVT = N->getValueType(0);
 378   unsigned NumElts = VecVT.getVectorNumElements();
 379   EVT OldVT = N->getOperand(0).getValueType();
 380   EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT);
 381   SDLoc dl(N);
 382
 383   assert(OldVT == VecVT.getVectorElementType() &&
 384          "BUILD_VECTOR operand type doesn't match vector element type!");
 385
 386   // Build a vector of twice the length out of the expanded elements.
 387   // For example <3 x i64> -> <6 x i32>.
 388   std::vector<SDValue> NewElts;
 389   NewElts.reserve(NumElts*2);
 390
 391   for (unsigned i = 0; i < NumElts; ++i) {
 392     SDValue Lo, Hi;
 393     GetExpandedOp(N->getOperand(i), Lo, Hi);
 394     if (DAG.getDataLayout().isBigEndian())
 395       std::swap(Lo, Hi);
 396     NewElts.push_back(Lo);
 397     NewElts.push_back(Hi);
 398   }
 399
 400   SDValue NewVec = DAG.getNode(ISD::BUILD_VECTOR, dl,
 401                                EVT::getVectorVT(*DAG.getContext(),
 402                                                 NewVT, NewElts.size()),
 403                                NewElts);
 404
 405   // Convert the new vector to the old vector type.
 406   return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec);
 407 }
 408
 409 SDValue DAGTypeLegalizer::ExpandOp_EXTRACT_ELEMENT(SDNode *N) {
 410   SDValue Lo, Hi;
 411   GetExpandedOp(N->getOperand(0), Lo, Hi);
 412   return cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? Hi : Lo;
 413 }
 414
 415 SDValue DAGTypeLegalizer::ExpandOp_INSERT_VECTOR_ELT(SDNode *N) {
 416   // The vector type is legal but the element type needs expansion.
 417   EVT VecVT = N->getValueType(0);
 418   unsigned NumElts = VecVT.getVectorNumElements();
 419   SDLoc dl(N);
 420
 421   SDValue Val = N->getOperand(1);
 422   EVT OldEVT = Val.getValueType();
 423   EVT NewEVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldEVT);
 424
 425   assert(OldEVT == VecVT.getVectorElementType() &&
 426          "Inserted element type doesn't match vector element type!");
 427
 428   // Bitconvert to a vector of twice the length with elements of the expanded
 429   // type, insert the expanded vector elements, and then convert back.
 430   EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewEVT, NumElts*2);
 431   SDValue NewVec = DAG.getNode(ISD::BITCAST, dl,
 432                                NewVecVT, N->getOperand(0));
 433
 434   SDValue Lo, Hi;
 435   GetExpandedOp(Val, Lo, Hi);
 436   if (DAG.getDataLayout().isBigEndian())
 437     std::swap(Lo, Hi);
 438
 439   SDValue Idx = N->getOperand(2);
 440   Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx);
 441   NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Lo, Idx);
 442   Idx = DAG.getNode(ISD::ADD, dl,
 443                     Idx.getValueType(), Idx,
 444                     DAG.getConstant(1, dl, Idx.getValueType()));
 445   NewVec =  DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Hi, Idx);
 446
 447   // Convert the new vector to the old vector type.
 448   return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec);
 449 }
 450
 451 SDValue DAGTypeLegalizer::ExpandOp_SCALAR_TO_VECTOR(SDNode *N) {
 452   SDLoc dl(N);
 453   EVT VT = N->getValueType(0);
 454   assert(VT.getVectorElementType() == N->getOperand(0).getValueType() &&
 455          "SCALAR_TO_VECTOR operand type doesn't match vector element type!");
 456   unsigned NumElts = VT.getVectorNumElements();
 457   SmallVector<SDValue, 16> Ops(NumElts);
 458   Ops[0] = N->getOperand(0);
 459   SDValue UndefVal = DAG.getUNDEF(Ops[0].getValueType());
 460   for (unsigned i = 1; i < NumElts; ++i)
 461     Ops[i] = UndefVal;
 462   return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
 463 }
 464
 465 SDValue DAGTypeLegalizer::ExpandOp_NormalStore(SDNode *N, unsigned OpNo) {
 466   assert(ISD::isNormalStore(N) && "This routine only for normal stores!");
 467   assert(OpNo == 1 && "Can only expand the stored value so far");
 468   SDLoc dl(N);
 469
 470   StoreSDNode *St = cast<StoreSDNode>(N);
 471   EVT ValueVT = St->getValue().getValueType();
 472   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), ValueVT);
 473   SDValue Chain = St->getChain();
 474   SDValue Ptr = St->getBasePtr();
 475   unsigned Alignment = St->getAlignment();
 476   bool isVolatile = St->isVolatile();
 477   bool isNonTemporal = St->isNonTemporal();
 478   AAMDNodes AAInfo = St->getAAInfo();
 479
 480   assert(NVT.isByteSized() && "Expanded type not byte sized!");
 481   unsigned IncrementSize = NVT.getSizeInBits() / 8;
 482
 483   SDValue Lo, Hi;
 484   GetExpandedOp(St->getValue(), Lo, Hi);
 485
 486   if (TLI.hasBigEndianPartOrdering(ValueVT, DAG.getDataLayout()))
 487     std::swap(Lo, Hi);
 488
 489   Lo = DAG.getStore(Chain, dl, Lo, Ptr, St->getPointerInfo(),
 490                     isVolatile, isNonTemporal, Alignment, AAInfo);
 491
 492   Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
 493                     DAG.getConstant(IncrementSize, dl, Ptr.getValueType()));
 494   Hi = DAG.getStore(Chain, dl, Hi, Ptr,
 495                     St->getPointerInfo().getWithOffset(IncrementSize),
 496                     isVolatile, isNonTemporal,
 497                     MinAlign(Alignment, IncrementSize), AAInfo);
 498
 499   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
 500 }
 501
 502
 503 //===--------------------------------------------------------------------===//
 504 // Generic Result Splitting.
 505 //===--------------------------------------------------------------------===//
 506
 507 // Be careful to make no assumptions about which of Lo/Hi is stored first in
 508 // memory (for vectors it is always Lo first followed by Hi in the following
 509 // bytes; for integers and floats it is Lo first if and only if the machine is
 510 // little-endian).
 511
 512 void DAGTypeLegalizer::SplitRes_MERGE_VALUES(SDNode *N, unsigned ResNo,
 513                                              SDValue &Lo, SDValue &Hi) {
 514   SDValue Op = DisintegrateMERGE_VALUES(N, ResNo);
 515   GetSplitOp(Op, Lo, Hi);
 516 }
 517
 518 void DAGTypeLegalizer::SplitRes_SELECT(SDNode *N, SDValue &Lo,
 519                                        SDValue &Hi) {
 520   SDValue LL, LH, RL, RH, CL, CH;
 521   SDLoc dl(N);
 522   GetSplitOp(N->getOperand(1), LL, LH);
 523   GetSplitOp(N->getOperand(2), RL, RH);
 524
 525   SDValue Cond = N->getOperand(0);
 526   CL = CH = Cond;
 527   if (Cond.getValueType().isVector()) {
 528     // Check if there are already splitted versions of the vector available and
 529     // use those instead of splitting the mask operand again.
 530     if (getTypeAction(Cond.getValueType()) == TargetLowering::TypeSplitVector)
 531       GetSplitVector(Cond, CL, CH);
 532     else
 533       std::tie(CL, CH) = DAG.SplitVector(Cond, dl);
 534   }
 535
 536   Lo = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), CL, LL, RL);
 537   Hi = DAG.getNode(N->getOpcode(), dl, LH.getValueType(), CH, LH, RH);
 538 }
 539
 540 void DAGTypeLegalizer::SplitRes_SELECT_CC(SDNode *N, SDValue &Lo,
 541                                           SDValue &Hi) {
 542   SDValue LL, LH, RL, RH;
 543   SDLoc dl(N);
 544   GetSplitOp(N->getOperand(2), LL, LH);
 545   GetSplitOp(N->getOperand(3), RL, RH);
 546
 547   Lo = DAG.getNode(ISD::SELECT_CC, dl, LL.getValueType(), N->getOperand(0),
 548                    N->getOperand(1), LL, RL, N->getOperand(4));
 549   Hi = DAG.getNode(ISD::SELECT_CC, dl, LH.getValueType(), N->getOperand(0),
 550                    N->getOperand(1), LH, RH, N->getOperand(4));
 551 }
 552
 553 void DAGTypeLegalizer::SplitRes_UNDEF(SDNode *N, SDValue &Lo, SDValue &Hi) {
 554   EVT LoVT, HiVT;
 555   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
 556   Lo = DAG.getUNDEF(LoVT);
 557   Hi = DAG.getUNDEF(HiVT);
 558 }