6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-05-13 01:15:32 +00: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



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@84942 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2009-10-23 06:57:37 +00:00
parent 739208a790
commit 17f0cd3cc1
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, static Constant *FoldReinterpretLoadFromConstPtr(Constant *C,
const TargetData &TD) { const TargetData &TD) {
const Type *InitializerTy = cast<PointerType>(C->getType())->getElementType(); const Type *LoadTy = cast<PointerType>(C->getType())->getElementType();
const IntegerType *IntType = dyn_cast<IntegerType>(InitializerTy); const IntegerType *IntType = dyn_cast<IntegerType>(LoadTy);
// If this isn't an integer load we can't fold it directly. // If this isn't an integer load we can't fold it directly.
if (!IntType) { if (!IntType) {
// If this is a float/double load, we can try folding it as an int32/64 load // 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; const Type *MapTy;
if (InitializerTy->isFloatTy()) if (LoadTy->isFloatTy())
MapTy = Type::getInt32PtrTy(C->getContext()); MapTy = Type::getInt32PtrTy(C->getContext());
else if (InitializerTy->isDoubleTy()) else if (LoadTy->isDoubleTy())
MapTy = Type::getInt64PtrTy(C->getContext()); 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; return 0;
C = ConstantExpr::getBitCast(C, MapTy); C = ConstantExpr::getBitCast(C, MapTy);
if (Constant *Res = FoldReinterpretLoadFromConstPtr(C, TD)) if (Constant *Res = FoldReinterpretLoadFromConstPtr(C, TD))
return ConstantExpr::getBitCast(Res, InitializerTy); return ConstantExpr::getBitCast(Res, LoadTy);
return 0; return 0;
} }

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

@ -77,3 +77,13 @@ define i128 @test9() {
; @test9 ; @test9
; CHECK: ret i128 112312312 ; 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>
}