LegalizeTypesGeneric.cpp revision f4e4629ee8c218f892ad8ae3e182fe40bc160895
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 1478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// computation in two identical registers of a smaller type. 1578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// Splitting is the act of changing a computation in an illegal type to be a 1678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// computation in two not necessarily identical registers of a smaller type. 1778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// 1878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===----------------------------------------------------------------------===// 1978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 2078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands#include "LegalizeTypes.h" 2178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sandsusing namespace llvm; 2278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 2378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===----------------------------------------------------------------------===// 2478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// Generic Result Expansion. 2578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===----------------------------------------------------------------------===// 2678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 2778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// These routines assume that the Lo/Hi part is stored first in memory on 2878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// little/big-endian machines, followed by the Hi/Lo part. This means that 2978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// they cannot be used as is on vectors, for which Lo is always stored first. 3078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 314a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sandsvoid DAGTypeLegalizer::ExpandRes_BIT_CONVERT(SDNode *N, SDOperand &Lo, 324a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands SDOperand &Hi) { 3378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 3478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand InOp = N->getOperand(0); 3578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT InVT = InOp.getValueType(); 3678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 3778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Handle some special cases efficiently. 3878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands switch (getTypeAction(InVT)) { 3978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands default: 4078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(false && "Unknown type action!"); 4178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case Legal: 4278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case PromoteInteger: 4378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands break; 4478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case SoftenFloat: 4578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Convert the integer operand instead. 4678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SplitInteger(GetSoftenedFloat(InOp), Lo, Hi); 4778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Lo = DAG.getNode(ISD::BIT_CONVERT, NVT, Lo); 4878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi = DAG.getNode(ISD::BIT_CONVERT, NVT, Hi); 4978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return; 5078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ExpandInteger: 5178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands case ExpandFloat: 5278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Convert the expanded pieces of the input. 5378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetExpandedOp(InOp, Lo, Hi); 5478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Lo = DAG.getNode(ISD::BIT_CONVERT, NVT, Lo); 5578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi = DAG.getNode(ISD::BIT_CONVERT, NVT, Hi); 5678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return; 57f4e4629ee8c218f892ad8ae3e182fe40bc160895Duncan Sands case SplitVector: 5878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Convert the split parts of the input if it was split in two. 5978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitVector(InOp, Lo, Hi); 6078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (Lo.getValueType() == Hi.getValueType()) { 6178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (TLI.isBigEndian()) 6278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands std::swap(Lo, Hi); 6378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Lo = DAG.getNode(ISD::BIT_CONVERT, NVT, Lo); 6478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi = DAG.getNode(ISD::BIT_CONVERT, NVT, Hi); 6578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return; 6678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands } 6778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands break; 68f4e4629ee8c218f892ad8ae3e182fe40bc160895Duncan Sands case ScalarizeVector: 6978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Convert the element instead. 7078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SplitInteger(BitConvertToInteger(GetScalarizedVector(InOp)), Lo, Hi); 7178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Lo = DAG.getNode(ISD::BIT_CONVERT, NVT, Lo); 7278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi = DAG.getNode(ISD::BIT_CONVERT, NVT, Hi); 7378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return; 7478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands } 7578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 7678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Lower the bit-convert to a store/load from the stack, then expand the load. 7778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand Op = CreateStackStoreLoad(InOp, N->getValueType(0)); 78ab09b7e8f34075c1759127a113f41bdf921f4034Duncan Sands ExpandRes_NormalLoad(Op.Val, Lo, Hi); 7978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 8078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 814a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sandsvoid DAGTypeLegalizer::ExpandRes_BUILD_PAIR(SDNode *N, SDOperand &Lo, 824a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands SDOperand &Hi) { 8378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Return the operands. 8478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Lo = N->getOperand(0); 8578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi = N->getOperand(1); 8678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 8778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 884a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sandsvoid DAGTypeLegalizer::ExpandRes_EXTRACT_ELEMENT(SDNode *N, SDOperand &Lo, 894a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands SDOperand &Hi) { 904a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands GetExpandedOp(N->getOperand(0), Lo, Hi); 914a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands SDOperand Part = cast<ConstantSDNode>(N->getOperand(1))->getValue() ? Hi : Lo; 924a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands 934a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands assert(Part.getValueType() == N->getValueType(0) && 944a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands "Type twice as big as expanded type not itself expanded!"); 954a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0)); 964a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands 974a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, NVT, Part, 984a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands DAG.getConstant(0, TLI.getPointerTy())); 994a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, NVT, Part, 1004a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands DAG.getConstant(1, TLI.getPointerTy())); 1014a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands} 1024a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sands 1034a307ecce68f90e0eebf1ded52b947816cdc2304Duncan Sandsvoid DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDOperand &Lo, 10478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand &Hi) { 10578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand OldVec = N->getOperand(0); 10678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned OldElts = OldVec.getValueType().getVectorNumElements(); 10778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 10878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Convert to a vector of the expanded element type, for example 10978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // <3 x i64> -> <6 x i32>. 11078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT OldVT = N->getValueType(0); 11178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT NewVT = TLI.getTypeToTransformTo(OldVT); 11278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 11378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand NewVec = DAG.getNode(ISD::BIT_CONVERT, 11478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT::getVectorVT(NewVT, 2*OldElts), 11578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands OldVec); 11678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 11778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Extract the elements at 2 * Idx and 2 * Idx + 1 from the new vector. 11878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand Idx = N->getOperand(1); 11978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 12078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Make sure the type of Idx is big enough to hold the new values. 12178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (Idx.getValueType().bitsLT(TLI.getPointerTy())) 12278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Idx = DAG.getNode(ISD::ZERO_EXTEND, TLI.getPointerTy(), Idx); 12378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 12478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Idx = DAG.getNode(ISD::ADD, Idx.getValueType(), Idx, Idx); 12578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, NewVT, NewVec, Idx); 12678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 12778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Idx = DAG.getNode(ISD::ADD, Idx.getValueType(), Idx, 12878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands DAG.getConstant(1, Idx.getValueType())); 12978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, NewVT, NewVec, Idx); 13078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 13178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (TLI.isBigEndian()) 13278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands std::swap(Lo, Hi); 13378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 13478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 135ab09b7e8f34075c1759127a113f41bdf921f4034Duncan Sandsvoid DAGTypeLegalizer::ExpandRes_NormalLoad(SDNode *N, SDOperand &Lo, 136ab09b7e8f34075c1759127a113f41bdf921f4034Duncan Sands SDOperand &Hi) { 137ab09b7e8f34075c1759127a113f41bdf921f4034Duncan Sands assert(ISD::isNormalLoad(N) && "This routine only for normal loads!"); 13878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 13978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands LoadSDNode *LD = cast<LoadSDNode>(N); 14078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT NVT = TLI.getTypeToTransformTo(LD->getValueType(0)); 14178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand Chain = LD->getChain(); 14278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand Ptr = LD->getBasePtr(); 14378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands int SVOffset = LD->getSrcValueOffset(); 14478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned Alignment = LD->getAlignment(); 14578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands bool isVolatile = LD->isVolatile(); 14678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 14778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(NVT.isByteSized() && "Expanded type not byte sized!"); 14878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 14978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Lo = DAG.getLoad(NVT, Chain, Ptr, LD->getSrcValue(), SVOffset, 15078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands isVolatile, Alignment); 15178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 15278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Increment the pointer to the other half. 15378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned IncrementSize = NVT.getSizeInBits() / 8; 15478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 15578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands DAG.getIntPtrConstant(IncrementSize)); 15678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi = DAG.getLoad(NVT, Chain, Ptr, LD->getSrcValue(), SVOffset+IncrementSize, 15778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands isVolatile, MinAlign(Alignment, IncrementSize)); 15878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 15978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Build a factor node to remember that this load is independent of the 16078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // other one. 16178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Chain = DAG.getNode(ISD::TokenFactor, MVT::Other, Lo.getValue(1), 16278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi.getValue(1)); 16378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 16478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Handle endianness of the load. 16578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (TLI.isBigEndian()) 16678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands std::swap(Lo, Hi); 16778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 16878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Modified the chain - switch anything that used the old chain to use 16978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // the new one. 17078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands ReplaceValueWith(SDOperand(N, 1), Chain); 17178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 17278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 17378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===--------------------------------------------------------------------===// 17478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// Generic Operand Expansion. 17578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===--------------------------------------------------------------------===// 17678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 17778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan SandsSDOperand DAGTypeLegalizer::ExpandOp_BIT_CONVERT(SDNode *N) { 17878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (N->getValueType(0).isVector()) { 17978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // An illegal expanding type is being converted to a legal vector type. 18078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Make a two element vector out of the expanded parts and convert that 18178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // instead, but only if the new vector type is legal (otherwise there 18278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // is no point, and it might create expansion loops). For example, on 18378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // x86 this turns v1i64 = BIT_CONVERT i64 into v1i64 = BIT_CONVERT v2i32. 18478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT OVT = N->getOperand(0).getValueType(); 18578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT NVT = MVT::getVectorVT(TLI.getTypeToTransformTo(OVT), 2); 18678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 18778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (isTypeLegal(NVT)) { 18878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand Parts[2]; 18978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetExpandedOp(N->getOperand(0), Parts[0], Parts[1]); 19078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 19178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (TLI.isBigEndian()) 19278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands std::swap(Parts[0], Parts[1]); 19378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 19478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand Vec = DAG.getNode(ISD::BUILD_VECTOR, NVT, Parts, 2); 19578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return DAG.getNode(ISD::BIT_CONVERT, N->getValueType(0), Vec); 19678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands } 19778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands } 19878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 19978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Otherwise, store to a temporary and load out again as the new type. 20078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return CreateStackStoreLoad(N->getOperand(0), N->getValueType(0)); 20178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 20278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 20378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan SandsSDOperand DAGTypeLegalizer::ExpandOp_BUILD_VECTOR(SDNode *N) { 20478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // The vector type is legal but the element type needs expansion. 20578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT VecVT = N->getValueType(0); 20678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned NumElts = VecVT.getVectorNumElements(); 20778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT OldVT = N->getOperand(0).getValueType(); 20878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT NewVT = TLI.getTypeToTransformTo(OldVT); 20978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 21078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Build a vector of twice the length out of the expanded elements. 21178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // For example <3 x i64> -> <6 x i32>. 21278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands std::vector<SDOperand> NewElts; 21378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands NewElts.reserve(NumElts*2); 21478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 21578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands for (unsigned i = 0; i < NumElts; ++i) { 21678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand Lo, Hi; 21778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetExpandedOp(N->getOperand(i), Lo, Hi); 21878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (TLI.isBigEndian()) 21978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands std::swap(Lo, Hi); 22078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands NewElts.push_back(Lo); 22178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands NewElts.push_back(Hi); 22278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands } 22378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 22478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand NewVec = DAG.getNode(ISD::BUILD_VECTOR, 22578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT::getVectorVT(NewVT, NewElts.size()), 22678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands &NewElts[0], NewElts.size()); 22778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 22878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Convert the new vector to the old vector type. 22978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return DAG.getNode(ISD::BIT_CONVERT, VecVT, NewVec); 23078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 23178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 23278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan SandsSDOperand DAGTypeLegalizer::ExpandOp_EXTRACT_ELEMENT(SDNode *N) { 23378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand Lo, Hi; 23478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetExpandedOp(N->getOperand(0), Lo, Hi); 23578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return cast<ConstantSDNode>(N->getOperand(1))->getValue() ? Hi : Lo; 23678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 23778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 238ab09b7e8f34075c1759127a113f41bdf921f4034Duncan SandsSDOperand DAGTypeLegalizer::ExpandOp_NormalStore(SDNode *N, unsigned OpNo) { 239ab09b7e8f34075c1759127a113f41bdf921f4034Duncan Sands assert(ISD::isNormalStore(N) && "This routine only for normal stores!"); 24078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(OpNo == 1 && "Can only expand the stored value so far"); 24178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 24278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands StoreSDNode *St = cast<StoreSDNode>(N); 24378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT NVT = TLI.getTypeToTransformTo(St->getValue().getValueType()); 24478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand Chain = St->getChain(); 24578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand Ptr = St->getBasePtr(); 24678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands int SVOffset = St->getSrcValueOffset(); 24778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned Alignment = St->getAlignment(); 24878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands bool isVolatile = St->isVolatile(); 24978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 25078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(NVT.isByteSized() && "Expanded type not byte sized!"); 25178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned IncrementSize = NVT.getSizeInBits() / 8; 25278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 25378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand Lo, Hi; 25478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetExpandedOp(St->getValue(), Lo, Hi); 25578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 25678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands if (TLI.isBigEndian()) 25778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands std::swap(Lo, Hi); 25878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 25978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Lo = DAG.getStore(Chain, Lo, Ptr, St->getSrcValue(), SVOffset, 26078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands isVolatile, Alignment); 26178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 26278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Ptr = DAG.getNode(ISD::ADD, Ptr.getValueType(), Ptr, 26378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands DAG.getIntPtrConstant(IncrementSize)); 26478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands assert(isTypeLegal(Ptr.getValueType()) && "Pointers must be legal!"); 26578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi = DAG.getStore(Chain, Hi, Ptr, St->getSrcValue(), SVOffset + IncrementSize, 26678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands isVolatile, MinAlign(Alignment, IncrementSize)); 26778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 26878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands return DAG.getNode(ISD::TokenFactor, MVT::Other, Lo, Hi); 26978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 27078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 27178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 27278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===--------------------------------------------------------------------===// 27378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// Generic Result Splitting. 27478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands//===--------------------------------------------------------------------===// 27578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 27678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// Be careful to make no assumptions about which of Lo/Hi is stored first in 27778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// memory (for vectors it is always Lo first followed by Hi in the following 27878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// bytes; for integers and floats it is Lo first if and only if the machine is 27978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands// little-endian). 28078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 28178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sandsvoid DAGTypeLegalizer::SplitRes_MERGE_VALUES(SDNode *N, 28278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand &Lo, SDOperand &Hi) { 28378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // A MERGE_VALUES node can produce any number of values. We know that the 28478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // first illegal one needs to be expanded into Lo/Hi. 28578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned i; 28678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 28778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // The string of legal results gets turns into the input operands, which have 28878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // the same type. 28978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands for (i = 0; isTypeLegal(N->getValueType(i)); ++i) 29078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands ReplaceValueWith(SDOperand(N, i), SDOperand(N->getOperand(i))); 29178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 29278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // The first illegal result must be the one that needs to be expanded. 29378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitOp(N->getOperand(i), Lo, Hi); 29478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 29578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // Legalize the rest of the results into the input operands whether they are 29678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands // legal or not. 29778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands unsigned e = N->getNumValues(); 29878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands for (++i; i != e; ++i) 29978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands ReplaceValueWith(SDOperand(N, i), SDOperand(N->getOperand(i))); 30078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 30178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 30278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sandsvoid DAGTypeLegalizer::SplitRes_SELECT(SDNode *N, SDOperand &Lo, 30378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand &Hi) { 30478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand LL, LH, RL, RH; 30578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitOp(N->getOperand(1), LL, LH); 30678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitOp(N->getOperand(2), RL, RH); 30778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 30878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand Cond = N->getOperand(0); 30978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Lo = DAG.getNode(ISD::SELECT, LL.getValueType(), Cond, LL, RL); 31078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi = DAG.getNode(ISD::SELECT, LH.getValueType(), Cond, LH, RH); 31178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 31278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 31378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sandsvoid DAGTypeLegalizer::SplitRes_SELECT_CC(SDNode *N, SDOperand &Lo, 31478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand &Hi) { 31578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands SDOperand LL, LH, RL, RH; 31678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitOp(N->getOperand(2), LL, LH); 31778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitOp(N->getOperand(3), RL, RH); 31878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 31978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Lo = DAG.getNode(ISD::SELECT_CC, LL.getValueType(), N->getOperand(0), 32078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands N->getOperand(1), LL, RL, N->getOperand(4)); 32178cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi = DAG.getNode(ISD::SELECT_CC, LH.getValueType(), N->getOperand(0), 32278cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands N->getOperand(1), LH, RH, N->getOperand(4)); 32378cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 32478cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands 32578cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sandsvoid DAGTypeLegalizer::SplitRes_UNDEF(SDNode *N, SDOperand &Lo, SDOperand &Hi) { 32678cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands MVT LoVT, HiVT; 32778cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands GetSplitDestVTs(N->getValueType(0), LoVT, HiVT); 32878cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Lo = DAG.getNode(ISD::UNDEF, LoVT); 32978cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands Hi = DAG.getNode(ISD::UNDEF, HiVT); 33078cd649ad326f79a1f8424ca2b63cea3239a9a52Duncan Sands} 331