LegalizeTypesGeneric.cpp revision c460ae90019ddb19d4c07b2cd2fbaecfa7adf67d
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. 15// Splitting is the act of changing a computation in an illegal type to be a 16// computation in two not necessarily identical registers of a smaller type. 17// 18//===----------------------------------------------------------------------===// 19 20#include "LegalizeTypes.h" 21#include "llvm/Target/TargetData.h" 22#include "llvm/CodeGen/PseudoSourceValue.h" 23using namespace llvm; 24 25//===----------------------------------------------------------------------===// 26// Generic Result Expansion. 27//===----------------------------------------------------------------------===// 28 29// These routines assume that the Lo/Hi part is stored first in memory on 30// little/big-endian machines, followed by the Hi/Lo part. This means that 31// they cannot be used as is on vectors, for which Lo is always stored first. 32 33void DAGTypeLegalizer::ExpandRes_BIT_CONVERT(SDNode *N, SDValue &Lo, 34 SDValue &Hi) { 35 MVT OutVT = N->getValueType(0); 36 MVT NOutVT = TLI.getTypeToTransformTo(OutVT); 37 SDValue InOp = N->getOperand(0); 38 MVT InVT = InOp.getValueType(); 39 DebugLoc dl = N->getDebugLoc(); 40 41 // Handle some special cases efficiently. 42 switch (getTypeAction(InVT)) { 43 default: 44 assert(false && "Unknown type action!"); 45 case Legal: 46 case PromoteInteger: 47 break; 48 case SoftenFloat: 49 // Convert the integer operand instead. 50 SplitInteger(GetSoftenedFloat(InOp), Lo, Hi); 51 Lo = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Lo); 52 Hi = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Hi); 53 return; 54 case ExpandInteger: 55 case ExpandFloat: 56 // Convert the expanded pieces of the input. 57 GetExpandedOp(InOp, Lo, Hi); 58 Lo = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Lo); 59 Hi = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Hi); 60 return; 61 case SplitVector: 62 // Convert the split parts of the input if it was split in two. 63 GetSplitVector(InOp, Lo, Hi); 64 if (Lo.getValueType() == Hi.getValueType()) { 65 if (TLI.isBigEndian()) 66 std::swap(Lo, Hi); 67 Lo = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Lo); 68 Hi = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Hi); 69 return; 70 } 71 break; 72 case ScalarizeVector: 73 // Convert the element instead. 74 SplitInteger(BitConvertToInteger(GetScalarizedVector(InOp)), Lo, Hi); 75 Lo = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Lo); 76 Hi = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Hi); 77 return; 78 } 79 80 // Lower the bit-convert to a store/load from the stack. 81 assert(NOutVT.isByteSized() && "Expanded type not byte sized!"); 82 83 // Create the stack frame object. Make sure it is aligned for both 84 // the source and expanded destination types. 85 unsigned Alignment = 86 TLI.getTargetData()->getPrefTypeAlignment(NOutVT.getTypeForMVT()); 87 SDValue StackPtr = DAG.CreateStackTemporary(InVT, Alignment); 88 int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex(); 89 const Value *SV = PseudoSourceValue::getFixedStack(SPFI); 90 91 // Emit a store to the stack slot. 92 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, InOp, StackPtr, SV, 0); 93 94 // Load the first half from the stack slot. 95 Lo = DAG.getLoad(NOutVT, dl, Store, StackPtr, SV, 0); 96 97 // Increment the pointer to the other half. 98 unsigned IncrementSize = NOutVT.getSizeInBits() / 8; 99 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr, 100 DAG.getIntPtrConstant(IncrementSize)); 101 102 // Load the second half from the stack slot. 103 Hi = DAG.getLoad(NOutVT, dl, Store, StackPtr, SV, IncrementSize, false, 104 MinAlign(Alignment, IncrementSize)); 105 106 // Handle endianness of the load. 107 if (TLI.isBigEndian()) 108 std::swap(Lo, Hi); 109} 110 111void DAGTypeLegalizer::ExpandRes_BUILD_PAIR(SDNode *N, SDValue &Lo, 112 SDValue &Hi) { 113 // Return the operands. 114 Lo = N->getOperand(0); 115 Hi = N->getOperand(1); 116} 117 118void DAGTypeLegalizer::ExpandRes_EXTRACT_ELEMENT(SDNode *N, SDValue &Lo, 119 SDValue &Hi) { 120 GetExpandedOp(N->getOperand(0), Lo, Hi); 121 SDValue Part = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? 122 Hi : Lo; 123 DebugLoc dl = N->getDebugLoc(); 124 125 assert(Part.getValueType() == N->getValueType(0) && 126 "Type twice as big as expanded type not itself expanded!"); 127 MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 128 129 Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, NVT, Part, 130 DAG.getConstant(0, TLI.getPointerTy())); 131 Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, NVT, Part, 132 DAG.getConstant(1, TLI.getPointerTy())); 133} 134 135void DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo, 136 SDValue &Hi) { 137 SDValue OldVec = N->getOperand(0); 138 unsigned OldElts = OldVec.getValueType().getVectorNumElements(); 139 DebugLoc dl = N->getDebugLoc(); 140 141 // Convert to a vector of the expanded element type, for example 142 // <3 x i64> -> <6 x i32>. 143 MVT OldVT = N->getValueType(0); 144 MVT NewVT = TLI.getTypeToTransformTo(OldVT); 145 146 SDValue NewVec = DAG.getNode(ISD::BIT_CONVERT, dl, 147 MVT::getVectorVT(NewVT, 2*OldElts), 148 OldVec); 149 150 // Extract the elements at 2 * Idx and 2 * Idx + 1 from the new vector. 151 SDValue Idx = N->getOperand(1); 152 153 // Make sure the type of Idx is big enough to hold the new values. 154 if (Idx.getValueType().bitsLT(TLI.getPointerTy())) 155 Idx = DAG.getNode(ISD::ZERO_EXTEND, dl, TLI.getPointerTy(), Idx); 156 157 Idx = DAG.getNode(ISD::ADD, Idx.getValueType(), Idx, Idx); 158 Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx); 159 160 Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, 161 DAG.getConstant(1, Idx.getValueType())); 162 Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx); 163 164 if (TLI.isBigEndian()) 165 std::swap(Lo, Hi); 166} 167 168void DAGTypeLegalizer::ExpandRes_NormalLoad(SDNode *N, SDValue &Lo, 169 SDValue &Hi) { 170 assert(ISD::isNormalLoad(N) && "This routine only for normal loads!"); 171 DebugLoc dl = N->getDebugLoc(); 172 173 LoadSDNode *LD = cast<LoadSDNode>(N); 174 MVT NVT = TLI.getTypeToTransformTo(LD->getValueType(0)); 175 SDValue Chain = LD->getChain(); 176 SDValue Ptr = LD->getBasePtr(); 177 int SVOffset = LD->getSrcValueOffset(); 178 unsigned Alignment = LD->getAlignment(); 179 bool isVolatile = LD->isVolatile(); 180 181 assert(NVT.isByteSized() && "Expanded type not byte sized!"); 182 183 Lo = DAG.getLoad(NVT, dl, Chain, Ptr, LD->getSrcValue(), SVOffset, 184 isVolatile, Alignment); 185 186 // Increment the pointer to the other half. 187 unsigned IncrementSize = NVT.getSizeInBits() / 8; 188 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 189 DAG.getIntPtrConstant(IncrementSize)); 190 Hi = DAG.getLoad(NVT, dl, Chain, Ptr, LD->getSrcValue(), 191 SVOffset+IncrementSize, 192 isVolatile, MinAlign(Alignment, IncrementSize)); 193 194 // Build a factor node to remember that this load is independent of the 195 // other one. 196 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1), 197 Hi.getValue(1)); 198 199 // Handle endianness of the load. 200 if (TLI.isBigEndian()) 201 std::swap(Lo, Hi); 202 203 // Modified the chain - switch anything that used the old chain to use 204 // the new one. 205 ReplaceValueWith(SDValue(N, 1), Chain); 206} 207 208void DAGTypeLegalizer::ExpandRes_VAARG(SDNode *N, SDValue &Lo, SDValue &Hi) { 209 MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 210 SDValue Chain = N->getOperand(0); 211 SDValue Ptr = N->getOperand(1); 212 DebugLoc dl = N->getDebugLoc(); 213 214 Lo = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2)); 215 Hi = DAG.getVAArg(NVT, dl, Lo.getValue(1), Ptr, N->getOperand(2)); 216 217 // Handle endianness of the load. 218 if (TLI.isBigEndian()) 219 std::swap(Lo, Hi); 220 221 // Modified the chain - switch anything that used the old chain to use 222 // the new one. 223 ReplaceValueWith(SDValue(N, 1), Hi.getValue(1)); 224} 225 226 227//===--------------------------------------------------------------------===// 228// Generic Operand Expansion. 229//===--------------------------------------------------------------------===// 230 231SDValue DAGTypeLegalizer::ExpandOp_BIT_CONVERT(SDNode *N) { 232 DebugLoc dl = N->getDebugLoc(); 233 if (N->getValueType(0).isVector()) { 234 // An illegal expanding type is being converted to a legal vector type. 235 // Make a two element vector out of the expanded parts and convert that 236 // instead, but only if the new vector type is legal (otherwise there 237 // is no point, and it might create expansion loops). For example, on 238 // x86 this turns v1i64 = BIT_CONVERT i64 into v1i64 = BIT_CONVERT v2i32. 239 MVT OVT = N->getOperand(0).getValueType(); 240 MVT NVT = MVT::getVectorVT(TLI.getTypeToTransformTo(OVT), 2); 241 242 if (isTypeLegal(NVT)) { 243 SDValue Parts[2]; 244 GetExpandedOp(N->getOperand(0), Parts[0], Parts[1]); 245 246 if (TLI.isBigEndian()) 247 std::swap(Parts[0], Parts[1]); 248 249 SDValue Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, Parts, 2); 250 return DAG.getNode(ISD::BIT_CONVERT, dl, N->getValueType(0), Vec); 251 } 252 } 253 254 // Otherwise, store to a temporary and load out again as the new type. 255 return CreateStackStoreLoad(N->getOperand(0), N->getValueType(0)); 256} 257 258SDValue DAGTypeLegalizer::ExpandOp_BUILD_VECTOR(SDNode *N) { 259 // The vector type is legal but the element type needs expansion. 260 MVT VecVT = N->getValueType(0); 261 unsigned NumElts = VecVT.getVectorNumElements(); 262 MVT OldVT = N->getOperand(0).getValueType(); 263 MVT NewVT = TLI.getTypeToTransformTo(OldVT); 264 DebugLoc dl = N->getDebugLoc(); 265 266 // Build a vector of twice the length out of the expanded elements. 267 // For example <3 x i64> -> <6 x i32>. 268 std::vector<SDValue> NewElts; 269 NewElts.reserve(NumElts*2); 270 271 for (unsigned i = 0; i < NumElts; ++i) { 272 SDValue Lo, Hi; 273 GetExpandedOp(N->getOperand(i), Lo, Hi); 274 if (TLI.isBigEndian()) 275 std::swap(Lo, Hi); 276 NewElts.push_back(Lo); 277 NewElts.push_back(Hi); 278 } 279 280 SDValue NewVec = DAG.getNode(ISD::BUILD_VECTOR, dl, 281 MVT::getVectorVT(NewVT, NewElts.size()), 282 &NewElts[0], NewElts.size()); 283 284 // Convert the new vector to the old vector type. 285 return DAG.getNode(ISD::BIT_CONVERT, dl, VecVT, NewVec); 286} 287 288SDValue DAGTypeLegalizer::ExpandOp_EXTRACT_ELEMENT(SDNode *N) { 289 SDValue Lo, Hi; 290 GetExpandedOp(N->getOperand(0), Lo, Hi); 291 return cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? Hi : Lo; 292} 293 294SDValue DAGTypeLegalizer::ExpandOp_INSERT_VECTOR_ELT(SDNode *N) { 295 // The vector type is legal but the element type needs expansion. 296 MVT VecVT = N->getValueType(0); 297 unsigned NumElts = VecVT.getVectorNumElements(); 298 DebugLoc dl = N->getDebugLoc(); 299 300 SDValue Val = N->getOperand(1); 301 MVT OldEVT = Val.getValueType(); 302 MVT NewEVT = TLI.getTypeToTransformTo(OldEVT); 303 304 assert(OldEVT == VecVT.getVectorElementType() && 305 "Inserted element type doesn't match vector element type!"); 306 307 // Bitconvert to a vector of twice the length with elements of the expanded 308 // type, insert the expanded vector elements, and then convert back. 309 MVT NewVecVT = MVT::getVectorVT(NewEVT, NumElts*2); 310 SDValue NewVec = DAG.getNode(ISD::BIT_CONVERT, dl, 311 NewVecVT, N->getOperand(0)); 312 313 SDValue Lo, Hi; 314 GetExpandedOp(Val, Lo, Hi); 315 if (TLI.isBigEndian()) 316 std::swap(Lo, Hi); 317 318 SDValue Idx = N->getOperand(2); 319 Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx); 320 NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Lo, Idx); 321 Idx = DAG.getNode(ISD::ADD, dl, 322 Idx.getValueType(), Idx, DAG.getIntPtrConstant(1)); 323 NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Hi, Idx); 324 325 // Convert the new vector to the old vector type. 326 return DAG.getNode(ISD::BIT_CONVERT, dl, VecVT, NewVec); 327} 328 329SDValue DAGTypeLegalizer::ExpandOp_SCALAR_TO_VECTOR(SDNode *N) { 330 DebugLoc dl = N->getDebugLoc(); 331 MVT VT = N->getValueType(0); 332 unsigned NumElts = VT.getVectorNumElements(); 333 SmallVector<SDValue, 16> Ops(NumElts); 334 Ops[0] = N->getOperand(0); 335 SDValue UndefVal = DAG.getNode(ISD::UNDEF, dl, Ops[0].getValueType()); 336 for (unsigned i = 1; i < NumElts; ++i) 337 Ops[i] = UndefVal; 338 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Ops[0], NumElts); 339} 340 341SDValue DAGTypeLegalizer::ExpandOp_NormalStore(SDNode *N, unsigned OpNo) { 342 assert(ISD::isNormalStore(N) && "This routine only for normal stores!"); 343 assert(OpNo == 1 && "Can only expand the stored value so far"); 344 DebugLoc dl = N->getDebugLoc(); 345 346 StoreSDNode *St = cast<StoreSDNode>(N); 347 MVT NVT = TLI.getTypeToTransformTo(St->getValue().getValueType()); 348 SDValue Chain = St->getChain(); 349 SDValue Ptr = St->getBasePtr(); 350 int SVOffset = St->getSrcValueOffset(); 351 unsigned Alignment = St->getAlignment(); 352 bool isVolatile = St->isVolatile(); 353 354 assert(NVT.isByteSized() && "Expanded type not byte sized!"); 355 unsigned IncrementSize = NVT.getSizeInBits() / 8; 356 357 SDValue Lo, Hi; 358 GetExpandedOp(St->getValue(), Lo, Hi); 359 360 if (TLI.isBigEndian()) 361 std::swap(Lo, Hi); 362 363 Lo = DAG.getStore(Chain, dl, Lo, Ptr, St->getSrcValue(), SVOffset, 364 isVolatile, Alignment); 365 366 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 367 DAG.getIntPtrConstant(IncrementSize)); 368 assert(isTypeLegal(Ptr.getValueType()) && "Pointers must be legal!"); 369 Hi = DAG.getStore(Chain, dl, Hi, Ptr, St->getSrcValue(), 370 SVOffset + IncrementSize, 371 isVolatile, MinAlign(Alignment, IncrementSize)); 372 373 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi); 374} 375 376 377//===--------------------------------------------------------------------===// 378// Generic Result Splitting. 379//===--------------------------------------------------------------------===// 380 381// Be careful to make no assumptions about which of Lo/Hi is stored first in 382// memory (for vectors it is always Lo first followed by Hi in the following 383// bytes; for integers and floats it is Lo first if and only if the machine is 384// little-endian). 385 386void DAGTypeLegalizer::SplitRes_MERGE_VALUES(SDNode *N, 387 SDValue &Lo, SDValue &Hi) { 388 // A MERGE_VALUES node can produce any number of values. We know that the 389 // first illegal one needs to be expanded into Lo/Hi. 390 unsigned i; 391 392 // The string of legal results gets turned into input operands, which have 393 // the same type. 394 for (i = 0; isTypeLegal(N->getValueType(i)); ++i) 395 ReplaceValueWith(SDValue(N, i), SDValue(N->getOperand(i))); 396 397 // The first illegal result must be the one that needs to be expanded. 398 GetSplitOp(N->getOperand(i), Lo, Hi); 399 400 // Legalize the rest of the results into the input operands whether they are 401 // legal or not. 402 unsigned e = N->getNumValues(); 403 for (++i; i != e; ++i) 404 ReplaceValueWith(SDValue(N, i), SDValue(N->getOperand(i))); 405} 406 407void DAGTypeLegalizer::SplitRes_SELECT(SDNode *N, SDValue &Lo, 408 SDValue &Hi) { 409 SDValue LL, LH, RL, RH; 410 DebugLoc dl = N->getDebugLoc(); 411 GetSplitOp(N->getOperand(1), LL, LH); 412 GetSplitOp(N->getOperand(2), RL, RH); 413 414 SDValue Cond = N->getOperand(0); 415 Lo = DAG.getNode(ISD::SELECT, dl, LL.getValueType(), Cond, LL, RL); 416 Hi = DAG.getNode(ISD::SELECT, dl, LH.getValueType(), Cond, LH, RH); 417} 418 419void DAGTypeLegalizer::SplitRes_SELECT_CC(SDNode *N, SDValue &Lo, 420 SDValue &Hi) { 421 SDValue LL, LH, RL, RH; 422 DebugLoc dl = N->getDebugLoc(); 423 GetSplitOp(N->getOperand(2), LL, LH); 424 GetSplitOp(N->getOperand(3), RL, RH); 425 426 Lo = DAG.getNode(ISD::SELECT_CC, dl, LL.getValueType(), N->getOperand(0), 427 N->getOperand(1), LL, RL, N->getOperand(4)); 428 Hi = DAG.getNode(ISD::SELECT_CC, dl, LH.getValueType(), N->getOperand(0), 429 N->getOperand(1), LH, RH, N->getOperand(4)); 430} 431 432void DAGTypeLegalizer::SplitRes_UNDEF(SDNode *N, SDValue &Lo, SDValue &Hi) { 433 MVT LoVT, HiVT; 434 DebugLoc dl = N->getDebugLoc(); 435 GetSplitDestVTs(N->getValueType(0), LoVT, HiVT); 436 Lo = DAG.getNode(ISD::UNDEF, dl, LoVT); 437 Hi = DAG.getNode(ISD::UNDEF, dl, HiVT); 438} 439