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/Target/TargetData.h" 24 using 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. 33 void 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 39 void 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 DebugLoc dl = N->getDebugLoc(); 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 InNVT = EVT::getVectorVT(*DAG.getContext(), InVT.getVectorElementType(), 81 InVT.getVectorNumElements()/2); 82 Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, InNVT, InOp, 83 DAG.getIntPtrConstant(0)); 84 Hi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, InNVT, InOp, 85 DAG.getIntPtrConstant(InNVT.getVectorNumElements())); 86 if (TLI.isBigEndian()) 87 std::swap(Lo, Hi); 88 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo); 89 Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi); 90 return; 91 } 92 } 93 94 if (InVT.isVector() && OutVT.isInteger()) { 95 // Handle cases like i64 = BITCAST v1i64 on x86, where the operand 96 // is legal but the result is not. 97 EVT NVT = EVT::getVectorVT(*DAG.getContext(), NOutVT, 2); 98 99 if (isTypeLegal(NVT)) { 100 SDValue CastInOp = DAG.getNode(ISD::BITCAST, dl, NVT, InOp); 101 Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NOutVT, CastInOp, 102 DAG.getIntPtrConstant(0)); 103 Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NOutVT, CastInOp, 104 DAG.getIntPtrConstant(1)); 105 106 if (TLI.isBigEndian()) 107 std::swap(Lo, Hi); 108 109 return; 110 } 111 } 112 113 // Lower the bit-convert to a store/load from the stack. 114 assert(NOutVT.isByteSized() && "Expanded type not byte sized!"); 115 116 // Create the stack frame object. Make sure it is aligned for both 117 // the source and expanded destination types. 118 unsigned Alignment = 119 TLI.getTargetData()->getPrefTypeAlignment(NOutVT. 120 getTypeForEVT(*DAG.getContext())); 121 SDValue StackPtr = DAG.CreateStackTemporary(InVT, Alignment); 122 int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex(); 123 MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(SPFI); 124 125 // Emit a store to the stack slot. 126 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, InOp, StackPtr, PtrInfo, 127 false, false, 0); 128 129 // Load the first half from the stack slot. 130 Lo = DAG.getLoad(NOutVT, dl, Store, StackPtr, PtrInfo, 131 false, false, false, 0); 132 133 // Increment the pointer to the other half. 134 unsigned IncrementSize = NOutVT.getSizeInBits() / 8; 135 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr, 136 DAG.getIntPtrConstant(IncrementSize)); 137 138 // Load the second half from the stack slot. 139 Hi = DAG.getLoad(NOutVT, dl, Store, StackPtr, 140 PtrInfo.getWithOffset(IncrementSize), false, 141 false, false, MinAlign(Alignment, IncrementSize)); 142 143 // Handle endianness of the load. 144 if (TLI.isBigEndian()) 145 std::swap(Lo, Hi); 146 } 147 148 void DAGTypeLegalizer::ExpandRes_BUILD_PAIR(SDNode *N, SDValue &Lo, 149 SDValue &Hi) { 150 // Return the operands. 151 Lo = N->getOperand(0); 152 Hi = N->getOperand(1); 153 } 154 155 void DAGTypeLegalizer::ExpandRes_EXTRACT_ELEMENT(SDNode *N, SDValue &Lo, 156 SDValue &Hi) { 157 GetExpandedOp(N->getOperand(0), Lo, Hi); 158 SDValue Part = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? 159 Hi : Lo; 160 161 assert(Part.getValueType() == N->getValueType(0) && 162 "Type twice as big as expanded type not itself expanded!"); 163 164 GetPairElements(Part, Lo, Hi); 165 } 166 167 void DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo, 168 SDValue &Hi) { 169 SDValue OldVec = N->getOperand(0); 170 unsigned OldElts = OldVec.getValueType().getVectorNumElements(); 171 DebugLoc dl = N->getDebugLoc(); 172 173 // Convert to a vector of the expanded element type, for example 174 // <3 x i64> -> <6 x i32>. 175 EVT OldVT = N->getValueType(0); 176 EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT); 177 178 SDValue NewVec = DAG.getNode(ISD::BITCAST, dl, 179 EVT::getVectorVT(*DAG.getContext(), 180 NewVT, 2*OldElts), 181 OldVec); 182 183 // Extract the elements at 2 * Idx and 2 * Idx + 1 from the new vector. 184 SDValue Idx = N->getOperand(1); 185 186 // Make sure the type of Idx is big enough to hold the new values. 187 if (Idx.getValueType().bitsLT(TLI.getPointerTy())) 188 Idx = DAG.getNode(ISD::ZERO_EXTEND, dl, TLI.getPointerTy(), Idx); 189 190 Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx); 191 Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx); 192 193 Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, 194 DAG.getConstant(1, Idx.getValueType())); 195 Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx); 196 197 if (TLI.isBigEndian()) 198 std::swap(Lo, Hi); 199 } 200 201 void DAGTypeLegalizer::ExpandRes_NormalLoad(SDNode *N, SDValue &Lo, 202 SDValue &Hi) { 203 assert(ISD::isNormalLoad(N) && "This routine only for normal loads!"); 204 DebugLoc dl = N->getDebugLoc(); 205 206 LoadSDNode *LD = cast<LoadSDNode>(N); 207 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), LD->getValueType(0)); 208 SDValue Chain = LD->getChain(); 209 SDValue Ptr = LD->getBasePtr(); 210 unsigned Alignment = LD->getAlignment(); 211 bool isVolatile = LD->isVolatile(); 212 bool isNonTemporal = LD->isNonTemporal(); 213 bool isInvariant = LD->isInvariant(); 214 215 assert(NVT.isByteSized() && "Expanded type not byte sized!"); 216 217 Lo = DAG.getLoad(NVT, dl, Chain, Ptr, LD->getPointerInfo(), 218 isVolatile, isNonTemporal, isInvariant, Alignment); 219 220 // Increment the pointer to the other half. 221 unsigned IncrementSize = NVT.getSizeInBits() / 8; 222 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 223 DAG.getIntPtrConstant(IncrementSize)); 224 Hi = DAG.getLoad(NVT, dl, Chain, Ptr, 225 LD->getPointerInfo().getWithOffset(IncrementSize), 226 isVolatile, isNonTemporal, isInvariant, 227 MinAlign(Alignment, IncrementSize)); 228 229 // Build a factor node to remember that this load is independent of the 230 // other one. 231 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1), 232 Hi.getValue(1)); 233 234 // Handle endianness of the load. 235 if (TLI.isBigEndian()) 236 std::swap(Lo, Hi); 237 238 // Modified the chain - switch anything that used the old chain to use 239 // the new one. 240 ReplaceValueWith(SDValue(N, 1), Chain); 241 } 242 243 void DAGTypeLegalizer::ExpandRes_VAARG(SDNode *N, SDValue &Lo, SDValue &Hi) { 244 EVT OVT = N->getValueType(0); 245 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), OVT); 246 SDValue Chain = N->getOperand(0); 247 SDValue Ptr = N->getOperand(1); 248 DebugLoc dl = N->getDebugLoc(); 249 const unsigned Align = N->getConstantOperandVal(3); 250 251 Lo = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2), Align); 252 Hi = DAG.getVAArg(NVT, dl, Lo.getValue(1), Ptr, N->getOperand(2), 0); 253 254 // Handle endianness of the load. 255 if (TLI.isBigEndian()) 256 std::swap(Lo, Hi); 257 258 // Modified the chain - switch anything that used the old chain to use 259 // the new one. 260 ReplaceValueWith(SDValue(N, 1), Hi.getValue(1)); 261 } 262 263 264 //===--------------------------------------------------------------------===// 265 // Generic Operand Expansion. 266 //===--------------------------------------------------------------------===// 267 268 SDValue DAGTypeLegalizer::ExpandOp_BITCAST(SDNode *N) { 269 DebugLoc dl = N->getDebugLoc(); 270 if (N->getValueType(0).isVector()) { 271 // An illegal expanding type is being converted to a legal vector type. 272 // Make a two element vector out of the expanded parts and convert that 273 // instead, but only if the new vector type is legal (otherwise there 274 // is no point, and it might create expansion loops). For example, on 275 // x86 this turns v1i64 = BITCAST i64 into v1i64 = BITCAST v2i32. 276 EVT OVT = N->getOperand(0).getValueType(); 277 EVT NVT = EVT::getVectorVT(*DAG.getContext(), 278 TLI.getTypeToTransformTo(*DAG.getContext(), OVT), 279 2); 280 281 if (isTypeLegal(NVT)) { 282 SDValue Parts[2]; 283 GetExpandedOp(N->getOperand(0), Parts[0], Parts[1]); 284 285 if (TLI.isBigEndian()) 286 std::swap(Parts[0], Parts[1]); 287 288 SDValue Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, Parts, 2); 289 return DAG.getNode(ISD::BITCAST, dl, N->getValueType(0), Vec); 290 } 291 } 292 293 // Otherwise, store to a temporary and load out again as the new type. 294 return CreateStackStoreLoad(N->getOperand(0), N->getValueType(0)); 295 } 296 297 SDValue DAGTypeLegalizer::ExpandOp_BUILD_VECTOR(SDNode *N) { 298 // The vector type is legal but the element type needs expansion. 299 EVT VecVT = N->getValueType(0); 300 unsigned NumElts = VecVT.getVectorNumElements(); 301 EVT OldVT = N->getOperand(0).getValueType(); 302 EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT); 303 DebugLoc dl = N->getDebugLoc(); 304 305 assert(OldVT == VecVT.getVectorElementType() && 306 "BUILD_VECTOR operand type doesn't match vector element type!"); 307 308 // Build a vector of twice the length out of the expanded elements. 309 // For example <3 x i64> -> <6 x i32>. 310 std::vector<SDValue> NewElts; 311 NewElts.reserve(NumElts*2); 312 313 for (unsigned i = 0; i < NumElts; ++i) { 314 SDValue Lo, Hi; 315 GetExpandedOp(N->getOperand(i), Lo, Hi); 316 if (TLI.isBigEndian()) 317 std::swap(Lo, Hi); 318 NewElts.push_back(Lo); 319 NewElts.push_back(Hi); 320 } 321 322 SDValue NewVec = DAG.getNode(ISD::BUILD_VECTOR, dl, 323 EVT::getVectorVT(*DAG.getContext(), 324 NewVT, NewElts.size()), 325 &NewElts[0], NewElts.size()); 326 327 // Convert the new vector to the old vector type. 328 return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec); 329 } 330 331 SDValue DAGTypeLegalizer::ExpandOp_EXTRACT_ELEMENT(SDNode *N) { 332 SDValue Lo, Hi; 333 GetExpandedOp(N->getOperand(0), Lo, Hi); 334 return cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? Hi : Lo; 335 } 336 337 SDValue DAGTypeLegalizer::ExpandOp_INSERT_VECTOR_ELT(SDNode *N) { 338 // The vector type is legal but the element type needs expansion. 339 EVT VecVT = N->getValueType(0); 340 unsigned NumElts = VecVT.getVectorNumElements(); 341 DebugLoc dl = N->getDebugLoc(); 342 343 SDValue Val = N->getOperand(1); 344 EVT OldEVT = Val.getValueType(); 345 EVT NewEVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldEVT); 346 347 assert(OldEVT == VecVT.getVectorElementType() && 348 "Inserted element type doesn't match vector element type!"); 349 350 // Bitconvert to a vector of twice the length with elements of the expanded 351 // type, insert the expanded vector elements, and then convert back. 352 EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewEVT, NumElts*2); 353 SDValue NewVec = DAG.getNode(ISD::BITCAST, dl, 354 NewVecVT, N->getOperand(0)); 355 356 SDValue Lo, Hi; 357 GetExpandedOp(Val, Lo, Hi); 358 if (TLI.isBigEndian()) 359 std::swap(Lo, Hi); 360 361 SDValue Idx = N->getOperand(2); 362 Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx); 363 NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Lo, Idx); 364 Idx = DAG.getNode(ISD::ADD, dl, 365 Idx.getValueType(), Idx, DAG.getIntPtrConstant(1)); 366 NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Hi, Idx); 367 368 // Convert the new vector to the old vector type. 369 return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec); 370 } 371 372 SDValue DAGTypeLegalizer::ExpandOp_SCALAR_TO_VECTOR(SDNode *N) { 373 DebugLoc dl = N->getDebugLoc(); 374 EVT VT = N->getValueType(0); 375 assert(VT.getVectorElementType() == N->getOperand(0).getValueType() && 376 "SCALAR_TO_VECTOR operand type doesn't match vector element type!"); 377 unsigned NumElts = VT.getVectorNumElements(); 378 SmallVector<SDValue, 16> Ops(NumElts); 379 Ops[0] = N->getOperand(0); 380 SDValue UndefVal = DAG.getUNDEF(Ops[0].getValueType()); 381 for (unsigned i = 1; i < NumElts; ++i) 382 Ops[i] = UndefVal; 383 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Ops[0], NumElts); 384 } 385 386 SDValue DAGTypeLegalizer::ExpandOp_NormalStore(SDNode *N, unsigned OpNo) { 387 assert(ISD::isNormalStore(N) && "This routine only for normal stores!"); 388 assert(OpNo == 1 && "Can only expand the stored value so far"); 389 DebugLoc dl = N->getDebugLoc(); 390 391 StoreSDNode *St = cast<StoreSDNode>(N); 392 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), 393 St->getValue().getValueType()); 394 SDValue Chain = St->getChain(); 395 SDValue Ptr = St->getBasePtr(); 396 unsigned Alignment = St->getAlignment(); 397 bool isVolatile = St->isVolatile(); 398 bool isNonTemporal = St->isNonTemporal(); 399 400 assert(NVT.isByteSized() && "Expanded type not byte sized!"); 401 unsigned IncrementSize = NVT.getSizeInBits() / 8; 402 403 SDValue Lo, Hi; 404 GetExpandedOp(St->getValue(), Lo, Hi); 405 406 if (TLI.isBigEndian()) 407 std::swap(Lo, Hi); 408 409 Lo = DAG.getStore(Chain, dl, Lo, Ptr, St->getPointerInfo(), 410 isVolatile, isNonTemporal, Alignment); 411 412 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 413 DAG.getIntPtrConstant(IncrementSize)); 414 assert(isTypeLegal(Ptr.getValueType()) && "Pointers must be legal!"); 415 Hi = DAG.getStore(Chain, dl, Hi, Ptr, 416 St->getPointerInfo().getWithOffset(IncrementSize), 417 isVolatile, isNonTemporal, 418 MinAlign(Alignment, IncrementSize)); 419 420 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi); 421 } 422 423 424 //===--------------------------------------------------------------------===// 425 // Generic Result Splitting. 426 //===--------------------------------------------------------------------===// 427 428 // Be careful to make no assumptions about which of Lo/Hi is stored first in 429 // memory (for vectors it is always Lo first followed by Hi in the following 430 // bytes; for integers and floats it is Lo first if and only if the machine is 431 // little-endian). 432 433 void DAGTypeLegalizer::SplitRes_MERGE_VALUES(SDNode *N, unsigned ResNo, 434 SDValue &Lo, SDValue &Hi) { 435 SDValue Op = DisintegrateMERGE_VALUES(N, ResNo); 436 GetSplitOp(Op, Lo, Hi); 437 } 438 439 void DAGTypeLegalizer::SplitRes_SELECT(SDNode *N, SDValue &Lo, 440 SDValue &Hi) { 441 SDValue LL, LH, RL, RH, CL, CH; 442 DebugLoc dl = N->getDebugLoc(); 443 GetSplitOp(N->getOperand(1), LL, LH); 444 GetSplitOp(N->getOperand(2), RL, RH); 445 446 SDValue Cond = N->getOperand(0); 447 CL = CH = Cond; 448 if (Cond.getValueType().isVector()) { 449 assert(Cond.getValueType().getVectorElementType() == MVT::i1 && 450 "Condition legalized before result?"); 451 unsigned NumElements = Cond.getValueType().getVectorNumElements(); 452 EVT VCondTy = EVT::getVectorVT(*DAG.getContext(), MVT::i1, NumElements / 2); 453 CL = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VCondTy, Cond, 454 DAG.getIntPtrConstant(0)); 455 CH = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VCondTy, Cond, 456 DAG.getIntPtrConstant(NumElements / 2)); 457 } 458 459 Lo = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), CL, LL, RL); 460 Hi = DAG.getNode(N->getOpcode(), dl, LH.getValueType(), CH, LH, RH); 461 } 462 463 void DAGTypeLegalizer::SplitRes_SELECT_CC(SDNode *N, SDValue &Lo, 464 SDValue &Hi) { 465 SDValue LL, LH, RL, RH; 466 DebugLoc dl = N->getDebugLoc(); 467 GetSplitOp(N->getOperand(2), LL, LH); 468 GetSplitOp(N->getOperand(3), RL, RH); 469 470 Lo = DAG.getNode(ISD::SELECT_CC, dl, LL.getValueType(), N->getOperand(0), 471 N->getOperand(1), LL, RL, N->getOperand(4)); 472 Hi = DAG.getNode(ISD::SELECT_CC, dl, LH.getValueType(), N->getOperand(0), 473 N->getOperand(1), LH, RH, N->getOperand(4)); 474 } 475 476 void DAGTypeLegalizer::SplitRes_UNDEF(SDNode *N, SDValue &Lo, SDValue &Hi) { 477 EVT LoVT, HiVT; 478 GetSplitDestVTs(N->getValueType(0), LoVT, HiVT); 479 Lo = DAG.getUNDEF(LoVT); 480 Hi = DAG.getUNDEF(HiVT); 481 } 482
