maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[InstCombine] canonicalize (bitcast (extractelement X)) --> (extractelement(bitcast X)) 

This change was discussed in D15392. It allows us to remove the fold that was added
in:
http://reviews.llvm.org/r255261

...and it will allow us to generalize this fold:
http://reviews.llvm.org/rL112232

while preserving the order of bitcast + extract that it produces and testing shows
is better handled by the backend.

Note that the existing check for "isVectorTy()" wasn't strong enough in general
and specifically because: x86_mmx. It's not a vector, but it's not vectorizable
either. So here we check VectorType::isValidElementType() directly before 
proceeding with the transform.

llvm-svn: 255433
This commit is contained in:
Sanjay Patel 2015-12-12 16:44:48 +00:00
parent a2d1591876
commit 1d49fc9b27
2 changed files with 19 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp
View File

@ -1715,40 +1715,29 @@ static Value *optimizeIntegerToVectorInsertions(BitCastInst &CI,
return Result;
}
/// Given a bitcasted source operand fed into an extract element instruction and
/// then bitcasted again to a scalar type, eliminate at least one bitcast by
/// changing the vector type of the extractelement instruction.
/// Example:
/// bitcast (extractelement (bitcast <2 x float> %X to <2 x i32>), 1) to float
/// --->
/// extractelement <2 x float> %X, i32 1
static Instruction *foldBitCastExtElt(BitCastInst &BitCast, InstCombiner &IC,
const DataLayout &DL) {
Type *DestType = BitCast.getType();
if (DestType->isVectorTy())
return nullptr;
/// Canonicalize scalar bitcasts of extracted elements into a bitcast of the
/// vector followed by extract element. The backend tends to handle bitcasts of
/// vectors better than bitcasts of scalars because vector registers are
/// usually not type-specific like scalar integer or scalar floating-point.
static Instruction *canonicalizeBitCastExtElt(BitCastInst &BitCast,
InstCombiner &IC,
const DataLayout &DL) {
// TODO: Create and use a pattern matcher for ExtractElementInst.
auto *ExtElt = dyn_cast<ExtractElementInst>(BitCast.getOperand(0));
if (!ExtElt || !ExtElt->hasOneUse())
return nullptr;
Value *InnerBitCast = nullptr;
if (!match(ExtElt->getOperand(0), m_BitCast(m_Value(InnerBitCast))))
// The bitcast must be to a vectorizable type, otherwise we can't make a new
// type to extract from.
Type *DestType = BitCast.getType();
if (!VectorType::isValidElementType(DestType))
return nullptr;
// If the source is not a vector or its element type doesn't match the result
// type, bitcast it to a vector type that we can extract from.
Type *SourceType = InnerBitCast->getType();
if (SourceType->getScalarType() != DestType) {
unsigned VecWidth = SourceType->getPrimitiveSizeInBits();
unsigned DestWidth = DestType->getPrimitiveSizeInBits();
unsigned NumElts = VecWidth / DestWidth;
SourceType = VectorType::get(DestType, NumElts);
InnerBitCast = IC.Builder->CreateBitCast(InnerBitCast, SourceType, "bc");
}
return ExtractElementInst::Create(InnerBitCast, ExtElt->getOperand(1));
unsigned NumElts = ExtElt->getVectorOperandType()->getNumElements();
auto *NewVecType = VectorType::get(DestType, NumElts);
auto *NewBC = IC.Builder->CreateBitCast(ExtElt->getVectorOperand(),
NewVecType, "bc");
return ExtractElementInst::Create(NewBC, ExtElt->getIndexOperand());
}
static Instruction *foldVecTruncToExtElt(Value *VecInput, Type *DestTy,
@ -1922,7 +1911,7 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) {
}
}
if (Instruction *I = foldBitCastExtElt(CI, *this, DL))
if (Instruction *I = canonicalizeBitCastExtElt(CI, *this, DL))
return I;
if (SrcTy->isPointerTy())

4
llvm/test/Transforms/InstCombine/bitcast-vec-canon.ll
View File

@ -5,8 +5,8 @@ define double @a(<1 x i64> %y) {
ret double %c
; CHECK-LABEL: @a(
; CHECK-NEXT: extractelement <1 x i64> %y, i32 0
; CHECK-NEXT: bitcast i64 {{.*}} to double
; CHECK-NEXT: bitcast <1 x i64> %y to <1 x double>
; CHECK-NEXT: extractelement <1 x double> {{.*}}, i32 0
; CHECK-NEXT: ret double
}