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