LegalizeTypesGeneric.cpp revision ee287ca22abcce9f769618c107ff3f46aa2d0cba
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 309SDValue DAGTypeLegalizer::ExpandOp_BITCAST(SDNode *N) { 310 SDLoc dl(N); 311 if (N->getValueType(0).isVector()) { 312 // An illegal expanding type is being converted to a legal vector type. 313 // Make a two element vector out of the expanded parts and convert that 314 // instead, but only if the new vector type is legal (otherwise there 315 // is no point, and it might create expansion loops). For example, on 316 // x86 this turns v1i64 = BITCAST i64 into v1i64 = BITCAST v2i32. 317 EVT OVT = N->getOperand(0).getValueType(); 318 EVT NVT = EVT::getVectorVT(*DAG.getContext(), 319 TLI.getTypeToTransformTo(*DAG.getContext(), OVT), 320 2); 321 322 if (isTypeLegal(NVT)) { 323 SDValue Parts[2]; 324 GetExpandedOp(N->getOperand(0), Parts[0], Parts[1]); 325 326 if (TLI.isBigEndian()) 327 std::swap(Parts[0], Parts[1]); 328 329 SDValue Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, Parts, 2); 330 return DAG.getNode(ISD::BITCAST, dl, N->getValueType(0), Vec); 331 } 332 } 333 334 // Otherwise, store to a temporary and load out again as the new type. 335 return CreateStackStoreLoad(N->getOperand(0), N->getValueType(0)); 336} 337 338SDValue DAGTypeLegalizer::ExpandOp_BUILD_VECTOR(SDNode *N) { 339 // The vector type is legal but the element type needs expansion. 340 EVT VecVT = N->getValueType(0); 341 unsigned NumElts = VecVT.getVectorNumElements(); 342 EVT OldVT = N->getOperand(0).getValueType(); 343 EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT); 344 SDLoc dl(N); 345 346 assert(OldVT == VecVT.getVectorElementType() && 347 "BUILD_VECTOR operand type doesn't match vector element type!"); 348 349 // Build a vector of twice the length out of the expanded elements. 350 // For example <3 x i64> -> <6 x i32>. 351 std::vector<SDValue> NewElts; 352 NewElts.reserve(NumElts*2); 353 354 for (unsigned i = 0; i < NumElts; ++i) { 355 SDValue Lo, Hi; 356 GetExpandedOp(N->getOperand(i), Lo, Hi); 357 if (TLI.isBigEndian()) 358 std::swap(Lo, Hi); 359 NewElts.push_back(Lo); 360 NewElts.push_back(Hi); 361 } 362 363 SDValue NewVec = DAG.getNode(ISD::BUILD_VECTOR, dl, 364 EVT::getVectorVT(*DAG.getContext(), 365 NewVT, NewElts.size()), 366 &NewElts[0], NewElts.size()); 367 368 // Convert the new vector to the old vector type. 369 return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec); 370} 371 372SDValue DAGTypeLegalizer::ExpandOp_EXTRACT_ELEMENT(SDNode *N) { 373 SDValue Lo, Hi; 374 GetExpandedOp(N->getOperand(0), Lo, Hi); 375 return cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? Hi : Lo; 376} 377 378SDValue DAGTypeLegalizer::ExpandOp_INSERT_VECTOR_ELT(SDNode *N) { 379 // The vector type is legal but the element type needs expansion. 380 EVT VecVT = N->getValueType(0); 381 unsigned NumElts = VecVT.getVectorNumElements(); 382 SDLoc dl(N); 383 384 SDValue Val = N->getOperand(1); 385 EVT OldEVT = Val.getValueType(); 386 EVT NewEVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldEVT); 387 388 assert(OldEVT == VecVT.getVectorElementType() && 389 "Inserted element type doesn't match vector element type!"); 390 391 // Bitconvert to a vector of twice the length with elements of the expanded 392 // type, insert the expanded vector elements, and then convert back. 393 EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewEVT, NumElts*2); 394 SDValue NewVec = DAG.getNode(ISD::BITCAST, dl, 395 NewVecVT, N->getOperand(0)); 396 397 SDValue Lo, Hi; 398 GetExpandedOp(Val, Lo, Hi); 399 if (TLI.isBigEndian()) 400 std::swap(Lo, Hi); 401 402 SDValue Idx = N->getOperand(2); 403 Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx); 404 NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Lo, Idx); 405 Idx = DAG.getNode(ISD::ADD, dl, 406 Idx.getValueType(), Idx, 407 DAG.getConstant(1, Idx.getValueType())); 408 NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Hi, Idx); 409 410 // Convert the new vector to the old vector type. 411 return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec); 412} 413 414SDValue DAGTypeLegalizer::ExpandOp_SCALAR_TO_VECTOR(SDNode *N) { 415 SDLoc dl(N); 416 EVT VT = N->getValueType(0); 417 assert(VT.getVectorElementType() == N->getOperand(0).getValueType() && 418 "SCALAR_TO_VECTOR operand type doesn't match vector element type!"); 419 unsigned NumElts = VT.getVectorNumElements(); 420 SmallVector<SDValue, 16> Ops(NumElts); 421 Ops[0] = N->getOperand(0); 422 SDValue UndefVal = DAG.getUNDEF(Ops[0].getValueType()); 423 for (unsigned i = 1; i < NumElts; ++i) 424 Ops[i] = UndefVal; 425 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Ops[0], NumElts); 426} 427 428SDValue DAGTypeLegalizer::ExpandOp_NormalStore(SDNode *N, unsigned OpNo) { 429 assert(ISD::isNormalStore(N) && "This routine only for normal stores!"); 430 assert(OpNo == 1 && "Can only expand the stored value so far"); 431 SDLoc dl(N); 432 433 StoreSDNode *St = cast<StoreSDNode>(N); 434 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), 435 St->getValue().getValueType()); 436 SDValue Chain = St->getChain(); 437 SDValue Ptr = St->getBasePtr(); 438 unsigned Alignment = St->getAlignment(); 439 bool isVolatile = St->isVolatile(); 440 bool isNonTemporal = St->isNonTemporal(); 441 const MDNode *TBAAInfo = St->getTBAAInfo(); 442 443 assert(NVT.isByteSized() && "Expanded type not byte sized!"); 444 unsigned IncrementSize = NVT.getSizeInBits() / 8; 445 446 SDValue Lo, Hi; 447 GetExpandedOp(St->getValue(), Lo, Hi); 448 449 if (TLI.isBigEndian()) 450 std::swap(Lo, Hi); 451 452 Lo = DAG.getStore(Chain, dl, Lo, Ptr, St->getPointerInfo(), 453 isVolatile, isNonTemporal, Alignment, TBAAInfo); 454 455 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 456 DAG.getConstant(IncrementSize, Ptr.getValueType())); 457 Hi = DAG.getStore(Chain, dl, Hi, Ptr, 458 St->getPointerInfo().getWithOffset(IncrementSize), 459 isVolatile, isNonTemporal, 460 MinAlign(Alignment, IncrementSize), TBAAInfo); 461 462 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi); 463} 464 465 466//===--------------------------------------------------------------------===// 467// Generic Result Splitting. 468//===--------------------------------------------------------------------===// 469 470// Be careful to make no assumptions about which of Lo/Hi is stored first in 471// memory (for vectors it is always Lo first followed by Hi in the following 472// bytes; for integers and floats it is Lo first if and only if the machine is 473// little-endian). 474 475void DAGTypeLegalizer::SplitRes_MERGE_VALUES(SDNode *N, unsigned ResNo, 476 SDValue &Lo, SDValue &Hi) { 477 SDValue Op = DisintegrateMERGE_VALUES(N, ResNo); 478 GetSplitOp(Op, Lo, Hi); 479} 480 481void DAGTypeLegalizer::SplitRes_SELECT(SDNode *N, SDValue &Lo, 482 SDValue &Hi) { 483 SDValue LL, LH, RL, RH, CL, CH; 484 SDLoc dl(N); 485 GetSplitOp(N->getOperand(1), LL, LH); 486 GetSplitOp(N->getOperand(2), RL, RH); 487 488 SDValue Cond = N->getOperand(0); 489 CL = CH = Cond; 490 if (Cond.getValueType().isVector()) { 491 if (Cond.getOpcode() == ISD::SETCC) { 492 assert(Cond.getValueType() == getSetCCResultType(N->getValueType(0)) && 493 "Condition has not been prepared for split!"); 494 GetSplitVector(Cond, CL, CH); 495 } else 496 llvm::tie(CL, CH) = DAG.SplitVector(Cond, dl); 497 } 498 499 Lo = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), CL, LL, RL); 500 Hi = DAG.getNode(N->getOpcode(), dl, LH.getValueType(), CH, LH, RH); 501} 502 503void DAGTypeLegalizer::SplitRes_SELECT_CC(SDNode *N, SDValue &Lo, 504 SDValue &Hi) { 505 SDValue LL, LH, RL, RH; 506 SDLoc dl(N); 507 GetSplitOp(N->getOperand(2), LL, LH); 508 GetSplitOp(N->getOperand(3), RL, RH); 509 510 Lo = DAG.getNode(ISD::SELECT_CC, dl, LL.getValueType(), N->getOperand(0), 511 N->getOperand(1), LL, RL, N->getOperand(4)); 512 Hi = DAG.getNode(ISD::SELECT_CC, dl, LH.getValueType(), N->getOperand(0), 513 N->getOperand(1), LH, RH, N->getOperand(4)); 514} 515 516void DAGTypeLegalizer::SplitRes_UNDEF(SDNode *N, SDValue &Lo, SDValue &Hi) { 517 EVT LoVT, HiVT; 518 llvm::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0)); 519 Lo = DAG.getUNDEF(LoVT); 520 Hi = DAG.getUNDEF(HiVT); 521} 522