LegalizeTypesGeneric.cpp revision 6229d0acb8f395552131a7015a5d1e7b2bae2111
178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===-------- LegalizeTypesGeneric.cpp - Generic type legalization --------===// 278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// 378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// The LLVM Compiler Infrastructure 478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// 578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// This file is distributed under the University of Illinois Open Source 678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// License. See LICENSE.TXT for details. 778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// 878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===----------------------------------------------------------------------===// 978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// 1078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// This file implements generic type expansion and splitting for LegalizeTypes. 1178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// The routines here perform legalization when the details of the type (such as 1278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// whether it is an integer or a float) do not matter. 1378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// Expansion is the act of changing a computation in an illegal type to be a 14f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands// computation in two identical registers of a smaller type. The Lo/Hi part 15f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands// is required to be stored first in memory on little/big-endian machines. 1678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// Splitting is the act of changing a computation in an illegal type to be a 1778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// computation in two not necessarily identical registers of a smaller type. 18f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands// There are no requirements on how the type is represented in memory. 1978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// 2078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===----------------------------------------------------------------------===// 2178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 2278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands#include "LegalizeTypes.h" 2347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands#include "llvm/Target/TargetData.h" 24905ff1ebc4f383088e6af6fc37504cd06ba62b57Dan Gohman#include "llvm/CodeGen/PseudoSourceValue.h" 2578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sandsusing namespace llvm; 2678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 2778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===----------------------------------------------------------------------===// 2878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// Generic Result Expansion. 2978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===----------------------------------------------------------------------===// 3078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 3178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// These routines assume that the Lo/Hi part is stored first in memory on 3278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// little/big-endian machines, followed by the Hi/Lo part. This means that 3378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// they cannot be used as is on vectors, for which Lo is always stored first. 3478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 35475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::ExpandRes_BIT_CONVERT(SDNode *N, SDValue &Lo, 36475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Hi) { 37e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT OutVT = N->getValueType(0); 3823b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT); 39475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue InOp = N->getOperand(0); 40e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT InVT = InOp.getValueType(); 4135ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen DebugLoc dl = N->getDebugLoc(); 4278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 4378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Handle some special cases efficiently. 4478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands switch (getTypeAction(InVT)) { 4578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands default: 4678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(false && "Unknown type action!"); 4778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case Legal: 4878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case PromoteInteger: 4978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands break; 5078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case SoftenFloat: 5178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Convert the integer operand instead. 5278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SplitInteger(GetSoftenedFloat(InOp), Lo, Hi); 5335ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Lo = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Lo); 5435ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Hi = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Hi); 5578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return; 5678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ExpandInteger: 5778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ExpandFloat: 5878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Convert the expanded pieces of the input. 5978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetExpandedOp(InOp, Lo, Hi); 6035ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Lo = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Lo); 6135ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Hi = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Hi); 6278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return; 63f4e4629ee8c218f892ad8ae3e182fe40bc160895Duncan Sands case SplitVector: 6478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitVector(InOp, Lo, Hi); 65f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands if (TLI.isBigEndian()) 66f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands std::swap(Lo, Hi); 67f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands Lo = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Lo); 68f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands Hi = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Hi); 69f2d754bb382cba0bad2774144ddac84be5354d16Duncan Sands return; 70f4e4629ee8c218f892ad8ae3e182fe40bc160895Duncan Sands case ScalarizeVector: 7178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Convert the element instead. 7278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SplitInteger(BitConvertToInteger(GetScalarizedVector(InOp)), Lo, Hi); 7335ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Lo = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Lo); 7435ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Hi = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Hi); 7578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return; 76aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang case WidenVector: { 77aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang assert(!(InVT.getVectorNumElements() & 1) && "Unsupported BIT_CONVERT"); 78aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang InOp = GetWidenedVector(InOp); 7923b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT InNVT = EVT::getVectorVT(*DAG.getContext(), InVT.getVectorElementType(), 80aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang InVT.getVectorNumElements()/2); 81aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, InNVT, InOp, 82aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang DAG.getIntPtrConstant(0)); 83aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang Hi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, InNVT, InOp, 84aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang DAG.getIntPtrConstant(InNVT.getVectorNumElements())); 85aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang if (TLI.isBigEndian()) 86aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang std::swap(Lo, Hi); 87aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang Lo = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Lo); 88aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang Hi = DAG.getNode(ISD::BIT_CONVERT, dl, NOutVT, Hi); 89aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang return; 90aa9df0b0c3cef33514095bde2eedead986677955Mon P Wang } 9178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands } 9278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 93f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman if (InVT.isVector() && OutVT.isInteger()) { 94f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman // Handle cases like i64 = BIT_CONVERT v1i64 on x86, where the operand 95f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman // is legal but the result is not. 9623b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT NVT = EVT::getVectorVT(*DAG.getContext(), NOutVT, 2); 97f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman 98f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman if (isTypeLegal(NVT)) { 99f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman SDValue CastInOp = DAG.getNode(ISD::BIT_CONVERT, dl, NVT, InOp); 1002fb070bf5a34f3fae89beb8609c92abc1b1a2551Eli Friedman Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NOutVT, CastInOp, 101f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman DAG.getIntPtrConstant(0)); 1022fb070bf5a34f3fae89beb8609c92abc1b1a2551Eli Friedman Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NOutVT, CastInOp, 103f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman DAG.getIntPtrConstant(1)); 104f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman 105f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman if (TLI.isBigEndian()) 106f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman std::swap(Lo, Hi); 1078c899ee031481dbece5f111379a274c848cb5902Duncan Sands 108f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman return; 109f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman } 110f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman } 111f10d3a7bcda97d28f9d325cb58cec7e17d7ed101Eli Friedman 11247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Lower the bit-convert to a store/load from the stack. 11347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands assert(NOutVT.isByteSized() && "Expanded type not byte sized!"); 11447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 11547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Create the stack frame object. Make sure it is aligned for both 11647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // the source and expanded destination types. 11747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands unsigned Alignment = 118cac25a9452c75b24e33fffe3390de8b2b8983e92Evan Cheng TLI.getTargetData()->getPrefTypeAlignment(NOutVT. 119cac25a9452c75b24e33fffe3390de8b2b8983e92Evan Cheng getTypeForEVT(*DAG.getContext())); 12047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands SDValue StackPtr = DAG.CreateStackTemporary(InVT, Alignment); 121ff89dcb06fbd103373436e2d0ae85f252fae2254Evan Cheng int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex(); 122ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(SPFI); 12347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 12447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Emit a store to the stack slot. 125ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, InOp, StackPtr, PtrInfo, 1261e559443a17d1b335f697551c6263ba60d5dd827David Greene false, false, 0); 12747d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 12847d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Load the first half from the stack slot. 129ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Lo = DAG.getLoad(NOutVT, dl, Store, StackPtr, PtrInfo, false, false, 0); 13047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 13147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Increment the pointer to the other half. 13247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands unsigned IncrementSize = NOutVT.getSizeInBits() / 8; 13335ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr, 13447d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands DAG.getIntPtrConstant(IncrementSize)); 13547d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 13647d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Load the second half from the stack slot. 137ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Hi = DAG.getLoad(NOutVT, dl, Store, StackPtr, 138ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner PtrInfo.getWithOffset(IncrementSize), false, 1391e559443a17d1b335f697551c6263ba60d5dd827David Greene false, MinAlign(Alignment, IncrementSize)); 14047d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands 14147d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands // Handle endianness of the load. 14247d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands if (TLI.isBigEndian()) 14347d9dcc584cdb7fd645ca1d5c2a0ce363570aeb7Duncan Sands std::swap(Lo, Hi); 14478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 14578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 146475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::ExpandRes_BUILD_PAIR(SDNode *N, SDValue &Lo, 147475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Hi) { 14878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Return the operands. 14978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Lo = N->getOperand(0); 15078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi = N->getOperand(1); 15178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 15278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 153475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::ExpandRes_EXTRACT_ELEMENT(SDNode *N, SDValue &Lo, 154475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Hi) { 1554a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands GetExpandedOp(N->getOperand(0), Lo, Hi); 156f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman SDValue Part = cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? 157f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman Hi : Lo; 1584a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands 1594a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands assert(Part.getValueType() == N->getValueType(0) && 1604a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands "Type twice as big as expanded type not itself expanded!"); 1614a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands 1622bee0afb7d023e029975abf7d3157759fa797d37Dan Gohman GetPairElements(Part, Lo, Hi); 1634a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands} 1644a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands 165475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo, 166475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Hi) { 167475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue OldVec = N->getOperand(0); 16878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned OldElts = OldVec.getValueType().getVectorNumElements(); 16935ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen DebugLoc dl = N->getDebugLoc(); 17078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 17178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Convert to a vector of the expanded element type, for example 17278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // <3 x i64> -> <6 x i32>. 173e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT OldVT = N->getValueType(0); 17423b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT); 17578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 17635ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen SDValue NewVec = DAG.getNode(ISD::BIT_CONVERT, dl, 177adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng EVT::getVectorVT(*DAG.getContext(), 178adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng NewVT, 2*OldElts), 179adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng OldVec); 18078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 18178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Extract the elements at 2 * Idx and 2 * Idx + 1 from the new vector. 182475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Idx = N->getOperand(1); 18378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 18478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Make sure the type of Idx is big enough to hold the new values. 18578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (Idx.getValueType().bitsLT(TLI.getPointerTy())) 18635ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Idx = DAG.getNode(ISD::ZERO_EXTEND, dl, TLI.getPointerTy(), Idx); 18778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 188de06470330260f5937e7ca558f5f5b3e171f2ee5Dale Johannesen Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx); 18935ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx); 19078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 19135ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, 19278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands DAG.getConstant(1, Idx.getValueType())); 19335ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx); 19478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 19578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (TLI.isBigEndian()) 19678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands std::swap(Lo, Hi); 19778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 19878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 199475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::ExpandRes_NormalLoad(SDNode *N, SDValue &Lo, 200475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Hi) { 201ab09b7e8f34075c1759127a113f41bdf921f4034Duncan Sands assert(ISD::isNormalLoad(N) && "This routine only for normal loads!"); 20235ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen DebugLoc dl = N->getDebugLoc(); 20378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 20478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands LoadSDNode *LD = cast<LoadSDNode>(N); 20523b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), LD->getValueType(0)); 206475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = LD->getChain(); 207475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ptr = LD->getBasePtr(); 20878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned Alignment = LD->getAlignment(); 20978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands bool isVolatile = LD->isVolatile(); 2101e559443a17d1b335f697551c6263ba60d5dd827David Greene bool isNonTemporal = LD->isNonTemporal(); 21178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 21278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(NVT.isByteSized() && "Expanded type not byte sized!"); 21378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 214ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Lo = DAG.getLoad(NVT, dl, Chain, Ptr, LD->getPointerInfo(), 2151e559443a17d1b335f697551c6263ba60d5dd827David Greene isVolatile, isNonTemporal, Alignment); 21678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 21778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Increment the pointer to the other half. 21878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned IncrementSize = NVT.getSizeInBits() / 8; 21935ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 22078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands DAG.getIntPtrConstant(IncrementSize)); 221ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner Hi = DAG.getLoad(NVT, dl, Chain, Ptr, 222ecf42c4720aba6ee315d0166045c54187ac2de4dChris Lattner LD->getPointerInfo().getWithOffset(IncrementSize), 2231e559443a17d1b335f697551c6263ba60d5dd827David Greene isVolatile, isNonTemporal, 2241e559443a17d1b335f697551c6263ba60d5dd827David Greene MinAlign(Alignment, IncrementSize)); 22578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 22678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Build a factor node to remember that this load is independent of the 22778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // other one. 228825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1), 22978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi.getValue(1)); 23078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 23178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Handle endianness of the load. 23278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (TLI.isBigEndian()) 23378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands std::swap(Lo, Hi); 23478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 23578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Modified the chain - switch anything that used the old chain to use 23678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // the new one. 237475871a144eb604ddaf37503397ba0941442e5fbDan Gohman ReplaceValueWith(SDValue(N, 1), Chain); 23878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 23978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 24021c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sandsvoid DAGTypeLegalizer::ExpandRes_VAARG(SDNode *N, SDValue &Lo, SDValue &Hi) { 24172d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola EVT OVT = N->getValueType(0); 24272d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), OVT); 24321c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sands SDValue Chain = N->getOperand(0); 24421c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sands SDValue Ptr = N->getOperand(1); 245c460ae90019ddb19d4c07b2cd2fbaecfa7adf67dDale Johannesen DebugLoc dl = N->getDebugLoc(); 246cbeeae23c31d32b833c9c7c3e8984e4cbcf22f45Rafael Espindola const unsigned Align = N->getConstantOperandVal(3); 24721c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sands 24872d13ff755fe8484c89468252f945ba23fe98f71Rafael Espindola Lo = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2), Align); 249cbeeae23c31d32b833c9c7c3e8984e4cbcf22f45Rafael Espindola Hi = DAG.getVAArg(NVT, dl, Lo.getValue(1), Ptr, N->getOperand(2), 0); 25021c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sands 25121c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sands // Handle endianness of the load. 25221c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sands if (TLI.isBigEndian()) 25321c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sands std::swap(Lo, Hi); 25421c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sands 25521c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sands // Modified the chain - switch anything that used the old chain to use 25621c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sands // the new one. 25721c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sands ReplaceValueWith(SDValue(N, 1), Hi.getValue(1)); 25821c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sands} 25921c2972f7d24680f6475877a3398b7f8cf515b33Duncan Sands 260ae099d54428f4113f8a71c53314975fb8a8e8bbcDuncan Sands 26178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===--------------------------------------------------------------------===// 26278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// Generic Operand Expansion. 26378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===--------------------------------------------------------------------===// 26478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 265475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue DAGTypeLegalizer::ExpandOp_BIT_CONVERT(SDNode *N) { 26635ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen DebugLoc dl = N->getDebugLoc(); 26778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (N->getValueType(0).isVector()) { 26878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // An illegal expanding type is being converted to a legal vector type. 26978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Make a two element vector out of the expanded parts and convert that 27078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // instead, but only if the new vector type is legal (otherwise there 27178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // is no point, and it might create expansion loops). For example, on 27278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // x86 this turns v1i64 = BIT_CONVERT i64 into v1i64 = BIT_CONVERT v2i32. 273e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT OVT = N->getOperand(0).getValueType(); 274adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng EVT NVT = EVT::getVectorVT(*DAG.getContext(), 275adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng TLI.getTypeToTransformTo(*DAG.getContext(), OVT), 276adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng 2); 27778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 27878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (isTypeLegal(NVT)) { 279475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Parts[2]; 28078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetExpandedOp(N->getOperand(0), Parts[0], Parts[1]); 28178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 28278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (TLI.isBigEndian()) 28378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands std::swap(Parts[0], Parts[1]); 28478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 285a87008d90b7d894cfca53d407642acfd7be2af3cEvan Cheng SDValue Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, Parts, 2); 28635ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen return DAG.getNode(ISD::BIT_CONVERT, dl, N->getValueType(0), Vec); 28778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands } 28878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands } 28978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 29078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Otherwise, store to a temporary and load out again as the new type. 29178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return CreateStackStoreLoad(N->getOperand(0), N->getValueType(0)); 29278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 29378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 294475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue DAGTypeLegalizer::ExpandOp_BUILD_VECTOR(SDNode *N) { 29578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // The vector type is legal but the element type needs expansion. 296e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VecVT = N->getValueType(0); 29778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned NumElts = VecVT.getVectorNumElements(); 298e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT OldVT = N->getOperand(0).getValueType(); 29923b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT); 30035ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen DebugLoc dl = N->getDebugLoc(); 30178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 302b1303d05a89972195de023fda432cc621375a27cBob Wilson assert(OldVT == VecVT.getVectorElementType() && 303b1303d05a89972195de023fda432cc621375a27cBob Wilson "BUILD_VECTOR operand type doesn't match vector element type!"); 304b1303d05a89972195de023fda432cc621375a27cBob Wilson 30578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Build a vector of twice the length out of the expanded elements. 30678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // For example <3 x i64> -> <6 x i32>. 307475871a144eb604ddaf37503397ba0941442e5fbDan Gohman std::vector<SDValue> NewElts; 30878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands NewElts.reserve(NumElts*2); 30978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 31078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands for (unsigned i = 0; i < NumElts; ++i) { 311475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo, Hi; 31278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetExpandedOp(N->getOperand(i), Lo, Hi); 31378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (TLI.isBigEndian()) 31478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands std::swap(Lo, Hi); 31578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands NewElts.push_back(Lo); 31678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands NewElts.push_back(Hi); 31778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands } 31878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 319a87008d90b7d894cfca53d407642acfd7be2af3cEvan Cheng SDValue NewVec = DAG.getNode(ISD::BUILD_VECTOR, dl, 320adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng EVT::getVectorVT(*DAG.getContext(), 321adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng NewVT, NewElts.size()), 322adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng &NewElts[0], NewElts.size()); 32378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 32478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Convert the new vector to the old vector type. 32535ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen return DAG.getNode(ISD::BIT_CONVERT, dl, VecVT, NewVec); 32678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 32778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 328475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue DAGTypeLegalizer::ExpandOp_EXTRACT_ELEMENT(SDNode *N) { 329475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo, Hi; 33078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetExpandedOp(N->getOperand(0), Lo, Hi); 331f5aeb1a8e4cf272c7348376d185ef8d8267653e0Dan Gohman return cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() ? Hi : Lo; 33278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 33378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 334d17c0302763cfd0b3f6657d2493147552762ac07Mon P WangSDValue DAGTypeLegalizer::ExpandOp_INSERT_VECTOR_ELT(SDNode *N) { 335d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang // The vector type is legal but the element type needs expansion. 336e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VecVT = N->getValueType(0); 337d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang unsigned NumElts = VecVT.getVectorNumElements(); 33835ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen DebugLoc dl = N->getDebugLoc(); 339d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang 340d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang SDValue Val = N->getOperand(1); 341e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT OldEVT = Val.getValueType(); 34223b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT NewEVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldEVT); 343d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang 344d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang assert(OldEVT == VecVT.getVectorElementType() && 345d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang "Inserted element type doesn't match vector element type!"); 346d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang 347d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang // Bitconvert to a vector of twice the length with elements of the expanded 348d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang // type, insert the expanded vector elements, and then convert back. 34923b9b19b1a5a00faa9fce0788155c7dbfd00bfb1Owen Anderson EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewEVT, NumElts*2); 3507fb085871857134f8cbeb17499d4ab771ba8da42Duncan Sands SDValue NewVec = DAG.getNode(ISD::BIT_CONVERT, dl, 35135ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen NewVecVT, N->getOperand(0)); 352d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang 353d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang SDValue Lo, Hi; 354d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang GetExpandedOp(Val, Lo, Hi); 355d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang if (TLI.isBigEndian()) 356d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang std::swap(Lo, Hi); 357d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang 358d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang SDValue Idx = N->getOperand(2); 35935ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx); 36035ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Lo, Idx); 36135ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Idx = DAG.getNode(ISD::ADD, dl, 36235ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Idx.getValueType(), Idx, DAG.getIntPtrConstant(1)); 36335ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen NewVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, NewVec, Hi, Idx); 364d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang 365d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang // Convert the new vector to the old vector type. 36635ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen return DAG.getNode(ISD::BIT_CONVERT, dl, VecVT, NewVec); 367d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang} 368d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang 369d17c0302763cfd0b3f6657d2493147552762ac07Mon P WangSDValue DAGTypeLegalizer::ExpandOp_SCALAR_TO_VECTOR(SDNode *N) { 37035ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen DebugLoc dl = N->getDebugLoc(); 371e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT VT = N->getValueType(0); 372b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands assert(VT.getVectorElementType() == N->getOperand(0).getValueType() && 373b10b5ac8d9da43ca2db61401a20af6b676c98438Duncan Sands "SCALAR_TO_VECTOR operand type doesn't match vector element type!"); 374d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang unsigned NumElts = VT.getVectorNumElements(); 375d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang SmallVector<SDValue, 16> Ops(NumElts); 376d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang Ops[0] = N->getOperand(0); 377e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen SDValue UndefVal = DAG.getUNDEF(Ops[0].getValueType()); 378d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang for (unsigned i = 1; i < NumElts; ++i) 379d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang Ops[i] = UndefVal; 380a87008d90b7d894cfca53d407642acfd7be2af3cEvan Cheng return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Ops[0], NumElts); 381d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang} 382d17c0302763cfd0b3f6657d2493147552762ac07Mon P Wang 383475871a144eb604ddaf37503397ba0941442e5fbDan GohmanSDValue DAGTypeLegalizer::ExpandOp_NormalStore(SDNode *N, unsigned OpNo) { 384ab09b7e8f34075c1759127a113f41bdf921f4034Duncan Sands assert(ISD::isNormalStore(N) && "This routine only for normal stores!"); 38578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(OpNo == 1 && "Can only expand the stored value so far"); 38635ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen DebugLoc dl = N->getDebugLoc(); 38778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 38878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands StoreSDNode *St = cast<StoreSDNode>(N); 389adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), 390adf979900c84d00e1fe0872a68d2819c654b6f29Evan Cheng St->getValue().getValueType()); 391475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Chain = St->getChain(); 392475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Ptr = St->getBasePtr(); 39378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned Alignment = St->getAlignment(); 39478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands bool isVolatile = St->isVolatile(); 3951e559443a17d1b335f697551c6263ba60d5dd827David Greene bool isNonTemporal = St->isNonTemporal(); 39678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 39778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(NVT.isByteSized() && "Expanded type not byte sized!"); 39878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned IncrementSize = NVT.getSizeInBits() / 8; 39978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 400475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Lo, Hi; 40178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetExpandedOp(St->getValue(), Lo, Hi); 40278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 40378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (TLI.isBigEndian()) 40478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands std::swap(Lo, Hi); 40578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 4066229d0acb8f395552131a7015a5d1e7b2bae2111Chris Lattner Lo = DAG.getStore(Chain, dl, Lo, Ptr, St->getPointerInfo(), 4071e559443a17d1b335f697551c6263ba60d5dd827David Greene isVolatile, isNonTemporal, Alignment); 40878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 40935ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, 41078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands DAG.getIntPtrConstant(IncrementSize)); 41178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(isTypeLegal(Ptr.getValueType()) && "Pointers must be legal!"); 4126229d0acb8f395552131a7015a5d1e7b2bae2111Chris Lattner Hi = DAG.getStore(Chain, dl, Hi, Ptr, 4136229d0acb8f395552131a7015a5d1e7b2bae2111Chris Lattner St->getPointerInfo().getWithOffset(IncrementSize), 4141e559443a17d1b335f697551c6263ba60d5dd827David Greene isVolatile, isNonTemporal, 4151e559443a17d1b335f697551c6263ba60d5dd827David Greene MinAlign(Alignment, IncrementSize)); 41678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 417825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi); 41878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 41978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 42078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 42178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===--------------------------------------------------------------------===// 42278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// Generic Result Splitting. 42378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===--------------------------------------------------------------------===// 42478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 42578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// Be careful to make no assumptions about which of Lo/Hi is stored first in 42678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// memory (for vectors it is always Lo first followed by Hi in the following 42778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// bytes; for integers and floats it is Lo first if and only if the machine is 42878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// little-endian). 42978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 43078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sandsvoid DAGTypeLegalizer::SplitRes_MERGE_VALUES(SDNode *N, 431475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Lo, SDValue &Hi) { 43278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // A MERGE_VALUES node can produce any number of values. We know that the 43378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // first illegal one needs to be expanded into Lo/Hi. 43478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned i; 43578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 436cff50d9e20d7bbc3acf4845fe826bfb3095126c4Duncan Sands // The string of legal results gets turned into input operands, which have 43778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // the same type. 43878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands for (i = 0; isTypeLegal(N->getValueType(i)); ++i) 439475871a144eb604ddaf37503397ba0941442e5fbDan Gohman ReplaceValueWith(SDValue(N, i), SDValue(N->getOperand(i))); 44078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 44178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // The first illegal result must be the one that needs to be expanded. 44278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitOp(N->getOperand(i), Lo, Hi); 44378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 44478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Legalize the rest of the results into the input operands whether they are 44578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // legal or not. 44678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned e = N->getNumValues(); 44778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands for (++i; i != e; ++i) 448475871a144eb604ddaf37503397ba0941442e5fbDan Gohman ReplaceValueWith(SDValue(N, i), SDValue(N->getOperand(i))); 44978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 45078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 451475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::SplitRes_SELECT(SDNode *N, SDValue &Lo, 452475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Hi) { 453475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue LL, LH, RL, RH; 45435ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen DebugLoc dl = N->getDebugLoc(); 45578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitOp(N->getOperand(1), LL, LH); 45678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitOp(N->getOperand(2), RL, RH); 45778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 458475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue Cond = N->getOperand(0); 45935ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Lo = DAG.getNode(ISD::SELECT, dl, LL.getValueType(), Cond, LL, RL); 46035ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Hi = DAG.getNode(ISD::SELECT, dl, LH.getValueType(), Cond, LH, RH); 46178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 46278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 463475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::SplitRes_SELECT_CC(SDNode *N, SDValue &Lo, 464475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue &Hi) { 465475871a144eb604ddaf37503397ba0941442e5fbDan Gohman SDValue LL, LH, RL, RH; 46635ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen DebugLoc dl = N->getDebugLoc(); 46778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitOp(N->getOperand(2), LL, LH); 46878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitOp(N->getOperand(3), RL, RH); 46978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 47035ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Lo = DAG.getNode(ISD::SELECT_CC, dl, LL.getValueType(), N->getOperand(0), 47178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands N->getOperand(1), LL, RL, N->getOperand(4)); 47235ba3d463834f83e2bf8e8ad631ffc4d73a0203cDale Johannesen Hi = DAG.getNode(ISD::SELECT_CC, dl, LH.getValueType(), N->getOperand(0), 47378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands N->getOperand(1), LH, RH, N->getOperand(4)); 47478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 47578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 476475871a144eb604ddaf37503397ba0941442e5fbDan Gohmanvoid DAGTypeLegalizer::SplitRes_UNDEF(SDNode *N, SDValue &Lo, SDValue &Hi) { 477e50ed30282bb5b4a9ed952580523f2dda16215acOwen Anderson EVT LoVT, HiVT; 47878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitDestVTs(N->getValueType(0), LoVT, HiVT); 479e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen Lo = DAG.getUNDEF(LoVT); 480e8d7230f480654cdb8ff1c3d0a38e1e9ab0bd55fDale Johannesen Hi = DAG.getUNDEF(HiVT); 48178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 482