6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-08-09 11:25:55 +00:00
Code Issues Projects Releases Wiki Activity

Rewrite the vector part of getExtendedTypeAction to make it more

Browse Source 
understandable (at least I find it easier to understand like this).
No intended functionality change.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@126382 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan Sands
2011-02-24 11:54:18 +00:00
parent f26be1e965
commit f7e9ad7172
1 changed files with 34 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
include/llvm/Target/TargetLowering.h
View File

@@ -221,27 +221,41 @@ public:
return Promote; return Promote;
return Expand; return Expand;
} }
// If this is a type smaller than a legal vector type, promote to that // Vectors with only one element are always scalarized.
// type, e.g. <2 x float> -> <4 x float>. if (VT.getVectorNumElements() == 1)
if (VT.getVectorElementType().isSimple() && return Expand;
VT.getVectorNumElements() != 1) {
MVT EltType = VT.getVectorElementType().getSimpleVT(); // Vectors with a number of elements that is not a power of two are always
unsigned NumElts = VT.getVectorNumElements(); // widened, for example <3 x float> -> <4 x float>.
while (1) { if (!VT.isPow2VectorType())
// Round up to the nearest power of 2. return Promote;
NumElts = (unsigned)NextPowerOf2(NumElts);
// Vectors with a crazy element type are always expanded, for example
MVT LargerVector = MVT::getVectorVT(EltType, NumElts); // <4 x i2> is expanded into two vectors of type <2 x i2>.
if (LargerVector == MVT()) break; if (!VT.getVectorElementType().isSimple())
return Expand;
// If this the larger type is legal, promote to it.
if (getTypeAction(LargerVector) == Legal) return Promote; // If this type is smaller than a legal vector type then widen it,
} // otherwise expand it. E.g. <2 x float> -> <4 x float>.
MVT EltType = VT.getVectorElementType().getSimpleVT();
unsigned NumElts = VT.getVectorNumElements();
while (1) {
// Round up to the next power of 2.
NumElts = (unsigned)NextPowerOf2(NumElts);
// If there is no simple vector type with this many elements then there
// cannot be a larger legal vector type. Note that this assumes that
// there are no skipped intermediate vector types in the simple types.
MVT LargerVector = MVT::getVectorVT(EltType, NumElts);
if (LargerVector == MVT())
return Expand;
// If this type is legal then widen the vector.
if (getTypeAction(LargerVector) == Legal)
return Promote;
} }
}
return VT.isPow2VectorType() ? Expand : Promote;
}
public: public:
ValueTypeActionImpl() { ValueTypeActionImpl() {
std::fill(ValueTypeActions, array_endof(ValueTypeActions), 0); std::fill(ValueTypeActions, array_endof(ValueTypeActions), 0);