1193323Sed//===-------- LegalizeTypesGeneric.cpp - Generic type legalization --------===// 2193323Sed// 3193323Sed// The LLVM Compiler Infrastructure 4193323Sed// 5193323Sed// This file is distributed under the University of Illinois Open Source 6193323Sed// License. See LICENSE.TXT for details. 7193323Sed// 8193323Sed//===----------------------------------------------------------------------===// 9193323Sed// 10193323Sed// This file implements generic type expansion and splitting for LegalizeTypes. 11193323Sed// The routines here perform legalization when the details of the type (such as 12193323Sed// whether it is an integer or a float) do not matter. 13193323Sed// Expansion is the act of changing a computation in an illegal type to be a 14198090Srdivacky// computation in two identical registers of a smaller type. The Lo/Hi part 15198090Srdivacky// is required to be stored first in memory on little/big-endian machines. 16193323Sed// Splitting is the act of changing a computation in an illegal type to be a 17193323Sed// computation in two not necessarily identical registers of a smaller type. 18198090Srdivacky// There are no requirements on how the type is represented in memory. 19193323Sed// 20193323Sed//===----------------------------------------------------------------------===// 21193323Sed 22193323Sed#include "LegalizeTypes.h" 23249423Sdim#include "llvm/IR/DataLayout.h" 24193323Sedusing namespace llvm; 25193323Sed 26193323Sed//===----------------------------------------------------------------------===// 27193323Sed// Generic Result Expansion. 28193323Sed//===----------------------------------------------------------------------===// 29193323Sed 30193323Sed// These routines assume that the Lo/Hi part is stored first in memory on 31193323Sed// little/big-endian machines, followed by the Hi/Lo part. This means that 32193323Sed// they cannot be used as is on vectors, for which Lo is always stored first. 33226633Sdimvoid DAGTypeLegalizer::ExpandRes_MERGE_VALUES(SDNode *N, unsigned ResNo, 34226633Sdim SDValue &Lo, SDValue &Hi) { 35226633Sdim SDValue Op = DisintegrateMERGE_VALUES(N, ResNo); 36226633Sdim GetExpandedOp(Op, Lo, Hi); 37226633Sdim} 38193323Sed 39218893Sdimvoid DAGTypeLegalizer::ExpandRes_BITCAST(SDNode *N, SDValue &Lo, SDValue &Hi) { 40198090Srdivacky EVT OutVT = N->getValueType(0); 41198090Srdivacky EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT); 42193323Sed SDValue InOp = N->getOperand(0); 43198090Srdivacky EVT InVT = InOp.getValueType(); 44263508Sdim SDLoc dl(N); 45193323Sed 46193323Sed // Handle some special cases efficiently. 47193323Sed switch (getTypeAction(InVT)) { 48223017Sdim case TargetLowering::TypeLegal: 49223017Sdim case TargetLowering::TypePromoteInteger: 50193323Sed break; 51223017Sdim case TargetLowering::TypeSoftenFloat: 52193323Sed // Convert the integer operand instead. 53193323Sed SplitInteger(GetSoftenedFloat(InOp), Lo, Hi); 54218893Sdim Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo); 55218893Sdim Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi); 56193323Sed return; 57223017Sdim case TargetLowering::TypeExpandInteger: 58223017Sdim case TargetLowering::TypeExpandFloat: 59193323Sed // Convert the expanded pieces of the input. 60193323Sed GetExpandedOp(InOp, Lo, Hi); 61218893Sdim Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo); 62218893Sdim Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi); 63193323Sed return; 64223017Sdim case TargetLowering::TypeSplitVector: 65193323Sed GetSplitVector(InOp, Lo, Hi); 66198090Srdivacky if (TLI.isBigEndian()) 67198090Srdivacky std::swap(Lo, Hi); 68218893Sdim Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo); 69218893Sdim Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi); 70198090Srdivacky return; 71223017Sdim case TargetLowering::TypeScalarizeVector: 72193323Sed // Convert the element instead. 73193323Sed SplitInteger(BitConvertToInteger(GetScalarizedVector(InOp)), Lo, Hi); 74218893Sdim Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo); 75218893Sdim Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi); 76193323Sed return; 77223017Sdim case TargetLowering::TypeWidenVector: { 78218893Sdim assert(!(InVT.getVectorNumElements() & 1) && "Unsupported BITCAST"); 79193323Sed InOp = GetWidenedVector(InOp); 80263508Sdim EVT LoVT, HiVT; 81263508Sdim llvm::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(InVT); 82263508Sdim llvm::tie(Lo, Hi) = DAG.SplitVector(InOp, dl, LoVT, HiVT); 83193323Sed if (TLI.isBigEndian()) 84193323Sed std::swap(Lo, Hi); 85218893Sdim Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo); 86218893Sdim Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi); 87193323Sed return; 88193323Sed } 89193323Sed } 90193323Sed 91193724Sed if (InVT.isVector() && OutVT.isInteger()) { 92218893Sdim // Handle cases like i64 = BITCAST v1i64 on x86, where the operand 93193724Sed // is legal but the result is not. 94243830Sdim unsigned NumElems = 2; 95243830Sdim EVT ElemVT = NOutVT; 96243830Sdim EVT NVT = EVT::getVectorVT(*DAG.getContext(), ElemVT, NumElems); 97193724Sed 98243830Sdim // If <ElemVT * N> is not a legal type, try <ElemVT/2 * (N*2)>. 99243830Sdim while (!isTypeLegal(NVT)) { 100243830Sdim unsigned NewSizeInBits = ElemVT.getSizeInBits() / 2; 101243830Sdim // If the element size is smaller than byte, bail. 102243830Sdim if (NewSizeInBits < 8) 103243830Sdim break; 104243830Sdim NumElems *= 2; 105243830Sdim ElemVT = EVT::getIntegerVT(*DAG.getContext(), NewSizeInBits); 106243830Sdim NVT = EVT::getVectorVT(*DAG.getContext(), ElemVT, NumElems); 107243830Sdim } 108243830Sdim 109193724Sed if (isTypeLegal(NVT)) { 110218893Sdim SDValue CastInOp = DAG.getNode(ISD::BITCAST, dl, NVT, InOp); 111193724Sed 112243830Sdim SmallVector<SDValue, 8> Vals; 113243830Sdim for (unsigned i = 0; i < NumElems; ++i) 114243830Sdim Vals.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ElemVT, 115263508Sdim CastInOp, DAG.getConstant(i, 116263508Sdim TLI.getVectorIdxTy()))); 117243830Sdim 118243830Sdim // Build Lo, Hi pair by pairing extracted elements if needed. 119243830Sdim unsigned Slot = 0; 120243830Sdim for (unsigned e = Vals.size(); e - Slot > 2; Slot += 2, e += 1) { 121243830Sdim // Each iteration will BUILD_PAIR two nodes and append the result until 122243830Sdim // there are only two nodes left, i.e. Lo and Hi. 123243830Sdim SDValue LHS = Vals[Slot]; 124243830Sdim SDValue RHS = Vals[Slot + 1]; 125243830Sdim 126243830Sdim if (TLI.isBigEndian()) 127243830Sdim std::swap(LHS, RHS); 128243830Sdim 129243830Sdim Vals.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, 130243830Sdim EVT::getIntegerVT( 131243830Sdim *DAG.getContext(), 132243830Sdim LHS.getValueType().getSizeInBits() << 1), 133243830Sdim LHS, RHS)); 134243830Sdim } 135243830Sdim Lo = Vals[Slot++]; 136243830Sdim Hi = Vals[Slot++]; 137243830Sdim 138193724Sed if (TLI.isBigEndian()) 139193724Sed std::swap(Lo, Hi); 140198090Srdivacky 141193724Sed return; 142193724Sed } 143193724Sed } 144193724Sed 145193323Sed // Lower the bit-convert to a store/load from the stack. 146193323Sed assert(NOutVT.isByteSized() && "Expanded type not byte sized!"); 147193323Sed 148193323Sed // Create the stack frame object. Make sure it is aligned for both 149193323Sed // the source and expanded destination types. 150193323Sed unsigned Alignment = 151243830Sdim TLI.getDataLayout()->getPrefTypeAlignment(NOutVT. 152198396Srdivacky getTypeForEVT(*DAG.getContext())); 153193323Sed SDValue StackPtr = DAG.CreateStackTemporary(InVT, Alignment); 154193323Sed int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex(); 155218893Sdim MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(SPFI); 156193323Sed 157193323Sed // Emit a store to the stack slot. 158218893Sdim SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, InOp, StackPtr, PtrInfo, 159203954Srdivacky false, false, 0); 160193323Sed 161193323Sed // Load the first half from the stack slot. 162263508Sdim Lo = DAG.getLoad(NOutVT, dl, Store, StackPtr, PtrInfo, 163234353Sdim false, false, false, 0); 164193323Sed 165193323Sed // Increment the pointer to the other half. 166193323Sed unsigned IncrementSize = NOutVT.getSizeInBits() / 8; 167193323Sed StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr, 168263508Sdim DAG.getConstant(IncrementSize, 169263508Sdim StackPtr.getValueType())); 170193323Sed 171193323Sed // Load the second half from the stack slot. 172218893Sdim Hi = DAG.getLoad(NOutVT, dl, Store, StackPtr, 173218893Sdim PtrInfo.getWithOffset(IncrementSize), false, 174234353Sdim false, false, MinAlign(Alignment, IncrementSize)); 175193323Sed 176193323Sed // Handle endianness of the load. 177193323Sed if (TLI.isBigEndian()) 178193323Sed std::swap(Lo, Hi); 179193323Sed} 180193323Sed 181193323Sedvoid DAGTypeLegalizer::ExpandRes_BUILD_PAIR(SDNode *N, SDValue &Lo, 182193323Sed SDValue &Hi) { 183193323Sed // Return the operands. 184193323Sed Lo = N->getOperand(0); 185193323Sed Hi = N->getOperand(1); 186193323Sed} 187193323Sed 188193323Sedvoid DAGTypeLegalizer::ExpandRes_EXTRACT_ELEMENT(SDNode *N, SDValue &Lo, 189193323Sed SDValue &Hi) { 190193323Sed GetExpandedOp(N->getOperand(0), Lo, Hi); 191193323Sed SDValue Part = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? 192193323Sed Hi : Lo; 193193323Sed 194193323Sed assert(Part.getValueType() == N->getValueType(0) && 195193323Sed "Type twice as big as expanded type not itself expanded!"); 196193323Sed 197193323Sed GetPairElements(Part, Lo, Hi); 198193323Sed} 199193323Sed 200193323Sedvoid DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo, 201193323Sed SDValue &Hi) { 202193323Sed SDValue OldVec = N->getOperand(0); 203193323Sed unsigned OldElts = OldVec.getValueType().getVectorNumElements(); 204239462Sdim EVT OldEltVT = OldVec.getValueType().getVectorElementType(); 205263508Sdim SDLoc dl(N); 206193323Sed 207193323Sed // Convert to a vector of the expanded element type, for example 208193323Sed // <3 x i64> -> <6 x i32>. 209198090Srdivacky EVT OldVT = N->getValueType(0); 210198090Srdivacky EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT); 211193323Sed 212239462Sdim if (OldVT != OldEltVT) { 213239462Sdim // The result of EXTRACT_VECTOR_ELT may be larger than the element type of 214239462Sdim // the input vector. If so, extend the elements of the input vector to the 215239462Sdim // same bitwidth as the result before expanding. 216239462Sdim assert(OldEltVT.bitsLT(OldVT) && "Result type smaller then element type!"); 217239462Sdim EVT NVecVT = EVT::getVectorVT(*DAG.getContext(), OldVT, OldElts); 218239462Sdim OldVec = DAG.getNode(ISD::ANY_EXTEND, dl, NVecVT, N->getOperand(0)); 219239462Sdim } 220239462Sdim 221218893Sdim SDValue NewVec = DAG.getNode(ISD::BITCAST, dl, 222207618Srdivacky EVT::getVectorVT(*DAG.getContext(), 223207618Srdivacky NewVT, 2*OldElts), 224207618Srdivacky OldVec); 225193323Sed 226193323Sed // Extract the elements at 2 * Idx and 2 * Idx + 1 from the new vector. 227193323Sed SDValue Idx = N->getOperand(1); 228193323Sed 229193323Sed Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx); 230193323Sed Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx); 231193323Sed 232193323Sed Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, 233193323Sed DAG.getConstant(1, Idx.getValueType())); 234193323Sed Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx); 235193323Sed 236193323Sed if (TLI.isBigEndian()) 237193323Sed std::swap(Lo, Hi); 238193323Sed} 239193323Sed 240193323Sedvoid DAGTypeLegalizer::ExpandRes_NormalLoad(SDNode *N, SDValue &Lo, 241193323Sed SDValue &Hi) { 242193323Sed assert(ISD::isNormalLoad(N) && "This routine only for normal loads!"); 243263508Sdim SDLoc dl(N); 244193323Sed 245193323Sed LoadSDNode *LD = cast<LoadSDNode>(N); 246198090Srdivacky EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), LD->getValueType(0)); 247193323Sed SDValue Chain = LD->getChain(); 248193323Sed SDValue Ptr = LD->getBasePtr(); 249193323Sed unsigned Alignment = LD->getAlignment(); 250193323Sed bool isVolatile = LD->isVolatile(); 251203954Srdivacky bool isNonTemporal = LD->isNonTemporal(); 252234353Sdim bool isInvariant = LD->isInvariant(); 253263508Sdim const MDNode *TBAAInfo = LD->getTBAAInfo(); 254193323Sed 255193323Sed assert(NVT.isByteSized() && "Expanded type not byte sized!"); 256193323Sed 257218893Sdim Lo = DAG.getLoad(NVT, dl, Chain, Ptr, LD->getPointerInfo(), 258263508Sdim isVolatile, isNonTemporal, isInvariant, Alignment, 259263508Sdim TBAAInfo); 260193323Sed 261193323Sed // Increment the pointer to the other half. 262193323Sed unsigned IncrementSize = NVT.getSizeInBits() / 8; 263193323Sed Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 264263508Sdim DAG.getConstant(IncrementSize, Ptr.getValueType())); 265218893Sdim Hi = DAG.getLoad(NVT, dl, Chain, Ptr, 266218893Sdim LD->getPointerInfo().getWithOffset(IncrementSize), 267234353Sdim isVolatile, isNonTemporal, isInvariant, 268263508Sdim MinAlign(Alignment, IncrementSize), TBAAInfo); 269193323Sed 270193323Sed // Build a factor node to remember that this load is independent of the 271193323Sed // other one. 272193323Sed Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1), 273193323Sed Hi.getValue(1)); 274193323Sed 275193323Sed // Handle endianness of the load. 276193323Sed if (TLI.isBigEndian()) 277193323Sed std::swap(Lo, Hi); 278193323Sed 279193323Sed // Modified the chain - switch anything that used the old chain to use 280193323Sed // the new one. 281193323Sed ReplaceValueWith(SDValue(N, 1), Chain); 282193323Sed} 283193323Sed 284193323Sedvoid DAGTypeLegalizer::ExpandRes_VAARG(SDNode *N, SDValue &Lo, SDValue &Hi) { 285210299Sed EVT OVT = N->getValueType(0); 286210299Sed EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), OVT); 287193323Sed SDValue Chain = N->getOperand(0); 288193323Sed SDValue Ptr = N->getOperand(1); 289263508Sdim SDLoc dl(N); 290210299Sed const unsigned Align = N->getConstantOperandVal(3); 291193323Sed 292210299Sed Lo = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2), Align); 293210299Sed Hi = DAG.getVAArg(NVT, dl, Lo.getValue(1), Ptr, N->getOperand(2), 0); 294193323Sed 295193323Sed // Handle endianness of the load. 296193323Sed if (TLI.isBigEndian()) 297193323Sed std::swap(Lo, Hi); 298193323Sed 299193323Sed // Modified the chain - switch anything that used the old chain to use 300193323Sed // the new one. 301193323Sed ReplaceValueWith(SDValue(N, 1), Hi.getValue(1)); 302193323Sed} 303193323Sed 304193323Sed 305193323Sed//===--------------------------------------------------------------------===// 306193323Sed// Generic Operand Expansion. 307193323Sed//===--------------------------------------------------------------------===// 308193323Sed 309263508Sdimvoid DAGTypeLegalizer::IntegerToVector(SDValue Op, unsigned NumElements, 310263508Sdim SmallVectorImpl<SDValue> &Ops, 311263508Sdim EVT EltVT) { 312263508Sdim assert(Op.getValueType().isInteger()); 313263508Sdim SDLoc DL(Op); 314263508Sdim SDValue Parts[2]; 315263508Sdim 316263508Sdim if (NumElements > 1) { 317263508Sdim NumElements >>= 1; 318263508Sdim SplitInteger(Op, Parts[0], Parts[1]); 319263508Sdim if (TLI.isBigEndian()) 320263508Sdim std::swap(Parts[0], Parts[1]); 321263508Sdim IntegerToVector(Parts[0], NumElements, Ops, EltVT); 322263508Sdim IntegerToVector(Parts[1], NumElements, Ops, EltVT); 323263508Sdim } else { 324263508Sdim Ops.push_back(DAG.getNode(ISD::BITCAST, DL, EltVT, Op)); 325263508Sdim } 326263508Sdim} 327263508Sdim 328218893SdimSDValue DAGTypeLegalizer::ExpandOp_BITCAST(SDNode *N) { 329263508Sdim SDLoc dl(N); 330193323Sed if (N->getValueType(0).isVector()) { 331193323Sed // An illegal expanding type is being converted to a legal vector type. 332193323Sed // Make a two element vector out of the expanded parts and convert that 333193323Sed // instead, but only if the new vector type is legal (otherwise there 334193323Sed // is no point, and it might create expansion loops). For example, on 335218893Sdim // x86 this turns v1i64 = BITCAST i64 into v1i64 = BITCAST v2i32. 336263508Sdim // 337263508Sdim // FIXME: I'm not sure why we are first trying to split the input into 338263508Sdim // a 2 element vector, so I'm leaving it here to maintain the current 339263508Sdim // behavior. 340263508Sdim unsigned NumElts = 2; 341198090Srdivacky EVT OVT = N->getOperand(0).getValueType(); 342207618Srdivacky EVT NVT = EVT::getVectorVT(*DAG.getContext(), 343207618Srdivacky TLI.getTypeToTransformTo(*DAG.getContext(), OVT), 344263508Sdim NumElts); 345263508Sdim if (!isTypeLegal(NVT)) { 346263508Sdim // If we can't find a legal type by splitting the integer in half, 347263508Sdim // then we can use the node's value type. 348263508Sdim NumElts = N->getValueType(0).getVectorNumElements(); 349263508Sdim NVT = N->getValueType(0); 350263508Sdim } 351193323Sed 352263508Sdim SmallVector<SDValue, 8> Ops; 353263508Sdim IntegerToVector(N->getOperand(0), NumElts, Ops, NVT.getVectorElementType()); 354193323Sed 355263508Sdim SDValue Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, &Ops[0], NumElts); 356263508Sdim return DAG.getNode(ISD::BITCAST, dl, N->getValueType(0), Vec); 357193323Sed } 358193323Sed 359193323Sed // Otherwise, store to a temporary and load out again as the new type. 360193323Sed return CreateStackStoreLoad(N->getOperand(0), N->getValueType(0)); 361193323Sed} 362193323Sed 363193323SedSDValue DAGTypeLegalizer::ExpandOp_BUILD_VECTOR(SDNode *N) { 364193323Sed // The vector type is legal but the element type needs expansion. 365198090Srdivacky EVT VecVT = N->getValueType(0); 366193323Sed unsigned NumElts = VecVT.getVectorNumElements(); 367198090Srdivacky EVT OldVT = N->getOperand(0).getValueType(); 368198090Srdivacky EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT); 369263508Sdim SDLoc dl(N); 370193323Sed 371193323Sed assert(OldVT == VecVT.getVectorElementType() && 372193323Sed "BUILD_VECTOR operand type doesn't match vector element type!"); 373193323Sed 374193323Sed // Build a vector of twice the length out of the expanded elements. 375193323Sed // For example <3 x i64> -> <6 x i32>. 376193323Sed std::vector<SDValue> NewElts; 377193323Sed NewElts.reserve(NumElts*2); 378193323Sed 379193323Sed for (unsigned i = 0; i < NumElts; ++i) { 380193323Sed SDValue Lo, Hi; 381193323Sed GetExpandedOp(N->getOperand(i), Lo, Hi); 382193323Sed if (TLI.isBigEndian()) 383193323Sed std::swap(Lo, Hi); 384193323Sed NewElts.push_back(Lo); 385193323Sed NewElts.push_back(Hi); 386193323Sed } 387193323Sed 388193323Sed SDValue NewVec = DAG.getNode(ISD::BUILD_VECTOR, dl, 389207618Srdivacky EVT::getVectorVT(*DAG.getContext(), 390207618Srdivacky NewVT, NewElts.size()), 391207618Srdivacky &NewElts[0], NewElts.size()); 392193323Sed 393193323Sed // Convert the new vector to the old vector type. 394218893Sdim return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec); 395193323Sed} 396193323Sed 397193323SedSDValue DAGTypeLegalizer::ExpandOp_EXTRACT_ELEMENT(SDNode *N) { 398193323Sed SDValue Lo, Hi; 399193323Sed GetExpandedOp(N->getOperand(0), Lo, Hi); 400193323Sed return cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? Hi : Lo; 401193323Sed} 402193323Sed 403193323SedSDValue DAGTypeLegalizer::ExpandOp_INSERT_VECTOR_ELT(SDNode *N) { 404193323Sed // The vector type is legal but the element type needs expansion. 405198090Srdivacky EVT VecVT = N->getValueType(0); 406193323Sed unsigned NumElts = VecVT.getVectorNumElements(); 407263508Sdim SDLoc dl(N); 408193323Sed 409193323Sed SDValue Val = N->getOperand(1); 410198090Srdivacky EVT OldEVT = Val.getValueType(); 411198090Srdivacky EVT NewEVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldEVT); 412193323Sed 413193323Sed assert(OldEVT == VecVT.getVectorElementType() && 414193323Sed "Inserted element type doesn't match vector element type!"); 415193323Sed 416193323Sed // Bitconvert to a vector of twice the length with elements of the expanded 417193323Sed // type, insert the expanded vector elements, and then convert back. 418198090Srdivacky EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewEVT, NumElts*2); 419218893Sdim SDValue NewVec = DAG.getNode(ISD::BITCAST, dl, 420193323Sed NewVecVT, N->getOperand(0)); 421193323Sed 422193323Sed SDValue Lo, Hi; 423193323Sed GetExpandedOp(Val, Lo, Hi); 424193323Sed if (TLI.isBigEndian()) 425193323Sed std::swap(Lo, Hi); 426193323Sed 427193323Sed SDValue Idx = N->getOperand(2); 428193323Sed Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx); 429193323Sed NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Lo, Idx); 430193323Sed Idx = DAG.getNode(ISD::ADD, dl, 431263508Sdim Idx.getValueType(), Idx, 432263508Sdim DAG.getConstant(1, Idx.getValueType())); 433193323Sed NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Hi, Idx); 434193323Sed 435193323Sed // Convert the new vector to the old vector type. 436218893Sdim return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec); 437193323Sed} 438193323Sed 439193323SedSDValue DAGTypeLegalizer::ExpandOp_SCALAR_TO_VECTOR(SDNode *N) { 440263508Sdim SDLoc dl(N); 441198090Srdivacky EVT VT = N->getValueType(0); 442193323Sed assert(VT.getVectorElementType() == N->getOperand(0).getValueType() && 443193323Sed "SCALAR_TO_VECTOR operand type doesn't match vector element type!"); 444193323Sed unsigned NumElts = VT.getVectorNumElements(); 445193323Sed SmallVector<SDValue, 16> Ops(NumElts); 446193323Sed Ops[0] = N->getOperand(0); 447193323Sed SDValue UndefVal = DAG.getUNDEF(Ops[0].getValueType()); 448193323Sed for (unsigned i = 1; i < NumElts; ++i) 449193323Sed Ops[i] = UndefVal; 450193323Sed return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Ops[0], NumElts); 451193323Sed} 452193323Sed 453193323SedSDValue DAGTypeLegalizer::ExpandOp_NormalStore(SDNode *N, unsigned OpNo) { 454193323Sed assert(ISD::isNormalStore(N) && "This routine only for normal stores!"); 455193323Sed assert(OpNo == 1 && "Can only expand the stored value so far"); 456263508Sdim SDLoc dl(N); 457193323Sed 458193323Sed StoreSDNode *St = cast<StoreSDNode>(N); 459207618Srdivacky EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), 460207618Srdivacky St->getValue().getValueType()); 461193323Sed SDValue Chain = St->getChain(); 462193323Sed SDValue Ptr = St->getBasePtr(); 463193323Sed unsigned Alignment = St->getAlignment(); 464193323Sed bool isVolatile = St->isVolatile(); 465203954Srdivacky bool isNonTemporal = St->isNonTemporal(); 466263508Sdim const MDNode *TBAAInfo = St->getTBAAInfo(); 467193323Sed 468193323Sed assert(NVT.isByteSized() && "Expanded type not byte sized!"); 469193323Sed unsigned IncrementSize = NVT.getSizeInBits() / 8; 470193323Sed 471193323Sed SDValue Lo, Hi; 472193323Sed GetExpandedOp(St->getValue(), Lo, Hi); 473193323Sed 474193323Sed if (TLI.isBigEndian()) 475193323Sed std::swap(Lo, Hi); 476193323Sed 477218893Sdim Lo = DAG.getStore(Chain, dl, Lo, Ptr, St->getPointerInfo(), 478263508Sdim isVolatile, isNonTemporal, Alignment, TBAAInfo); 479193323Sed 480193323Sed Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 481263508Sdim DAG.getConstant(IncrementSize, Ptr.getValueType())); 482218893Sdim Hi = DAG.getStore(Chain, dl, Hi, Ptr, 483218893Sdim St->getPointerInfo().getWithOffset(IncrementSize), 484203954Srdivacky isVolatile, isNonTemporal, 485263508Sdim MinAlign(Alignment, IncrementSize), TBAAInfo); 486193323Sed 487193323Sed return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi); 488193323Sed} 489193323Sed 490193323Sed 491193323Sed//===--------------------------------------------------------------------===// 492193323Sed// Generic Result Splitting. 493193323Sed//===--------------------------------------------------------------------===// 494193323Sed 495193323Sed// Be careful to make no assumptions about which of Lo/Hi is stored first in 496193323Sed// memory (for vectors it is always Lo first followed by Hi in the following 497193323Sed// bytes; for integers and floats it is Lo first if and only if the machine is 498193323Sed// little-endian). 499193323Sed 500226633Sdimvoid DAGTypeLegalizer::SplitRes_MERGE_VALUES(SDNode *N, unsigned ResNo, 501193323Sed SDValue &Lo, SDValue &Hi) { 502226633Sdim SDValue Op = DisintegrateMERGE_VALUES(N, ResNo); 503226633Sdim GetSplitOp(Op, Lo, Hi); 504193323Sed} 505193323Sed 506193323Sedvoid DAGTypeLegalizer::SplitRes_SELECT(SDNode *N, SDValue &Lo, 507193323Sed SDValue &Hi) { 508226633Sdim SDValue LL, LH, RL, RH, CL, CH; 509263508Sdim SDLoc dl(N); 510193323Sed GetSplitOp(N->getOperand(1), LL, LH); 511193323Sed GetSplitOp(N->getOperand(2), RL, RH); 512193323Sed 513193323Sed SDValue Cond = N->getOperand(0); 514226633Sdim CL = CH = Cond; 515226633Sdim if (Cond.getValueType().isVector()) { 516263508Sdim // Check if there are already splitted versions of the vector available and 517263508Sdim // use those instead of splitting the mask operand again. 518263508Sdim if (getTypeAction(Cond.getValueType()) == TargetLowering::TypeSplitVector) 519263508Sdim GetSplitVector(Cond, CL, CH); 520263508Sdim else 521263508Sdim llvm::tie(CL, CH) = DAG.SplitVector(Cond, dl); 522226633Sdim } 523226633Sdim 524226633Sdim Lo = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), CL, LL, RL); 525226633Sdim Hi = DAG.getNode(N->getOpcode(), dl, LH.getValueType(), CH, LH, RH); 526193323Sed} 527193323Sed 528193323Sedvoid DAGTypeLegalizer::SplitRes_SELECT_CC(SDNode *N, SDValue &Lo, 529193323Sed SDValue &Hi) { 530193323Sed SDValue LL, LH, RL, RH; 531263508Sdim SDLoc dl(N); 532193323Sed GetSplitOp(N->getOperand(2), LL, LH); 533193323Sed GetSplitOp(N->getOperand(3), RL, RH); 534193323Sed 535193323Sed Lo = DAG.getNode(ISD::SELECT_CC, dl, LL.getValueType(), N->getOperand(0), 536193323Sed N->getOperand(1), LL, RL, N->getOperand(4)); 537193323Sed Hi = DAG.getNode(ISD::SELECT_CC, dl, LH.getValueType(), N->getOperand(0), 538193323Sed N->getOperand(1), LH, RH, N->getOperand(4)); 539193323Sed} 540193323Sed 541193323Sedvoid DAGTypeLegalizer::SplitRes_UNDEF(SDNode *N, SDValue &Lo, SDValue &Hi) { 542198090Srdivacky EVT LoVT, HiVT; 543263508Sdim llvm::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0)); 544193323Sed Lo = DAG.getUNDEF(LoVT); 545193323Sed Hi = DAG.getUNDEF(HiVT); 546193323Sed} 547