6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-14 14:24:05 +00:00
Code Issues Projects Releases Wiki Activity

prefer to generate constant pool loads over splats. This prevents us from

Browse Source 
using a splat for {1.0,1.0,1.0,1.0}


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@27055 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2006-03-24 07:29:17 +00:00
parent b3e7afd9ee
commit 2eb8653157
1 changed files with 35 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
View File

@ -3113,6 +3113,11 @@ SDOperand SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) {
SDOperand SplatValue = Node->getOperand(0); SDOperand SplatValue = Node->getOperand(0);
std::map<SDOperand, std::vector<unsigned> > Values; std::map<SDOperand, std::vector<unsigned> > Values;
Values[SplatValue].push_back(0); Values[SplatValue].push_back(0);
bool isConstant = true;
if (!isa<ConstantFPSDNode>(SplatValue) && !isa<ConstantSDNode>(SplatValue) &&
SplatValue.getOpcode() != ISD::UNDEF)
isConstant = false;
for (unsigned i = 1; i < NumElems; ++i) { for (unsigned i = 1; i < NumElems; ++i) {
SDOperand V = Node->getOperand(i); SDOperand V = Node->getOperand(i);
std::map<SDOperand, std::vector<unsigned> >::iterator I = Values.find(V); std::map<SDOperand, std::vector<unsigned> >::iterator I = Values.find(V);
@ -3124,6 +3129,12 @@ SDOperand SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) {
isOnlyLowElement = false; isOnlyLowElement = false;
if (SplatValue != V) if (SplatValue != V)
SplatValue = SDOperand(0,0); SplatValue = SDOperand(0,0);
// If this isn't a constant element or an undef, we can't use a constant
// pool load.
if (!isa<ConstantFPSDNode>(V) && !isa<ConstantSDNode>(V) &&
V.getOpcode() != ISD::UNDEF)
isConstant = false;
} }
if (isOnlyLowElement) { if (isOnlyLowElement) {
@ -3135,40 +3146,7 @@ SDOperand SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) {
Node->getOperand(0)); Node->getOperand(0));
} }
if (SplatValue.Val) { // Splat of one value? // If all elements are constants, create a load from the constant pool.
// Build the shuffle constant vector: <0, 0, 0, 0>
MVT::ValueType MaskVT =
MVT::getIntVectorWithNumElements(NumElems);
SDOperand Zero = DAG.getConstant(0, MVT::getVectorBaseType(MaskVT));
std::vector<SDOperand> ZeroVec(NumElems, Zero);
SDOperand SplatMask = DAG.getNode(ISD::BUILD_VECTOR, MaskVT, ZeroVec);
// If the target supports VECTOR_SHUFFLE and this shuffle mask, use it.
if (TLI.isShuffleLegal(Node->getValueType(0), SplatMask)) {
// Get the splatted value into the low element of a vector register.
SDOperand LowValVec =
DAG.getNode(ISD::SCALAR_TO_VECTOR, Node->getValueType(0), SplatValue);
// Return shuffle(LowValVec, undef, <0,0,0,0>)
return DAG.getNode(ISD::VECTOR_SHUFFLE, Node->getValueType(0), LowValVec,
DAG.getNode(ISD::UNDEF, Node->getValueType(0)),
SplatMask);
}
}
// If the elements are all constants, turn this into a load from the constant
// pool.
bool isConstant = true;
for (SDNode::op_iterator I = Node->op_begin(), E = Node->op_end();
I != E; ++I) {
if (!isa<ConstantFPSDNode>(I) && !isa<ConstantSDNode>(I) &&
I->getOpcode() != ISD::UNDEF) {
isConstant = false;
break;
}
}
// Create a ConstantPacked, and put it in the constant pool.
if (isConstant) { if (isConstant) {
MVT::ValueType VT = Node->getValueType(0); MVT::ValueType VT = Node->getValueType(0);
const Type *OpNTy = const Type *OpNTy =
@ -3192,6 +3170,27 @@ SDOperand SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) {
DAG.getSrcValue(NULL)); DAG.getSrcValue(NULL));
} }
if (SplatValue.Val) { // Splat of one value?
// Build the shuffle constant vector: <0, 0, 0, 0>
MVT::ValueType MaskVT =
MVT::getIntVectorWithNumElements(NumElems);
SDOperand Zero = DAG.getConstant(0, MVT::getVectorBaseType(MaskVT));
std::vector<SDOperand> ZeroVec(NumElems, Zero);
SDOperand SplatMask = DAG.getNode(ISD::BUILD_VECTOR, MaskVT, ZeroVec);
// If the target supports VECTOR_SHUFFLE and this shuffle mask, use it.
if (TLI.isShuffleLegal(Node->getValueType(0), SplatMask)) {
// Get the splatted value into the low element of a vector register.
SDOperand LowValVec =
DAG.getNode(ISD::SCALAR_TO_VECTOR, Node->getValueType(0), SplatValue);
// Return shuffle(LowValVec, undef, <0,0,0,0>)
return DAG.getNode(ISD::VECTOR_SHUFFLE, Node->getValueType(0), LowValVec,
DAG.getNode(ISD::UNDEF, Node->getValueType(0)),
SplatMask);
}
}
// If there are only two unique elements, we may be able to turn this into a // If there are only two unique elements, we may be able to turn this into a
// vector shuffle. // vector shuffle.
if (Values.size() == 2) { if (Values.size() == 2) {