RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-02-01 05:01:59 +01:00
Code Issues Projects Releases Wiki Activity

teach libanalysis to simplify vector loads with bitcast sources. This

Browse Source 
implements something out of Target/README.txt producing:

_foo:                                                       ## @foo
	movl	4(%esp), %eax
	movapd	LCPI1_0, %xmm0
	movapd	%xmm0, (%eax)
	ret	$4

instead of:

_foo:                                                       ## @foo
	movl	4(%esp), %eax
	movapd	_b, %xmm0
	mulpd	LCPI1_0, %xmm0
	addpd	_a, %xmm0
	movapd	%xmm0, (%eax)
	ret	$4

llvm-svn: 84942
This commit is contained in:
Chris Lattner 2009-10-23 06:57:37 +00:00
parent 2ee1f0f0b5
commit 4874f5bce5
2 changed files with 23 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
lib/Analysis/ConstantFolding.cpp
View File

@ -210,24 +210,30 @@ static bool ReadDataFromGlobal(Constant *C, uint64_t ByteOffset,
static Constant *FoldReinterpretLoadFromConstPtr(Constant *C,
const TargetData &TD) {
const Type *InitializerTy = cast<PointerType>(C->getType())->getElementType();
const IntegerType *IntType = dyn_cast<IntegerType>(InitializerTy);
const Type *LoadTy = cast<PointerType>(C->getType())->getElementType();
const IntegerType *IntType = dyn_cast<IntegerType>(LoadTy);
// If this isn't an integer load we can't fold it directly.
if (!IntType) {
// If this is a float/double load, we can try folding it as an int32/64 load
// and then bitcast the result. This can be useful for union cases.
// and then bitcast the result. This can be useful for union cases. Note
// that address spaces don't matter here since we're not going to result in
// an actual new load.
const Type *MapTy;
if (InitializerTy->isFloatTy())
if (LoadTy->isFloatTy())
MapTy = Type::getInt32PtrTy(C->getContext());
else if (InitializerTy->isDoubleTy())
else if (LoadTy->isDoubleTy())
MapTy = Type::getInt64PtrTy(C->getContext());
else
else if (isa<VectorType>(LoadTy)) {
MapTy = IntegerType::get(C->getContext(),
TD.getTypeAllocSizeInBits(LoadTy));
MapTy = PointerType::getUnqual(MapTy);
} else
return 0;
C = ConstantExpr::getBitCast(C, MapTy);
if (Constant *Res = FoldReinterpretLoadFromConstPtr(C, TD))
return ConstantExpr::getBitCast(Res, InitializerTy);
return ConstantExpr::getBitCast(Res, LoadTy);
return 0;
}

10
test/Transforms/ConstProp/loads.ll
View File

@ -77,3 +77,13 @@ define i128 @test9() {
; @test9
; CHECK: ret i128 112312312
}
; vector load.
define <2 x i64> @test10() {
%r = load <2 x i64>* bitcast({i64, i64}* @test3 to <2 x i64>*)
ret <2 x i64> %r
; @test10
; CHECK: ret <2 x i64> <i64 112312312, i64 0>
}