RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 03:02:36 +01:00
Code Issues Projects Releases Wiki Activity

Update InstCombine to transform aggregate loads into scalar loads.

Browse Source 
Summary:
One step further getting aggregate loads and store being optimized
properly. This will only handle struct with one element at this point.

Test Plan: Added unit tests for the new supported cases.

Reviewers: chandlerc, joker-eph, joker.eph, majnemer

Reviewed By: majnemer

Subscribers: pete, llvm-commits

Differential Revision: http://reviews.llvm.org/D8339

Patch by Amaury Sechet.

From: Amaury Sechet <amaury@fb.com>
llvm-svn: 236695
This commit is contained in:
Mehdi Amini 2015-05-07 05:52:40 +00:00
parent e9638888f3
commit 7da0eff84e
2 changed files with 72 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
View File

@ -314,7 +314,8 @@ Instruction *InstCombiner::visitAllocaInst(AllocaInst &AI) {
///
/// Note that this will create all of the instructions with whatever insert
/// point the \c InstCombiner currently is using.
static LoadInst *combineLoadToNewType(InstCombiner &IC, LoadInst &LI, Type *NewTy) {
static LoadInst *combineLoadToNewType(InstCombiner &IC, LoadInst &LI, Type *NewTy,
const Twine &Suffix = "") {
Value *Ptr = LI.getPointerOperand();
unsigned AS = LI.getPointerAddressSpace();
SmallVector<std::pair<unsigned, MDNode *>, 8> MD;
@ -322,7 +323,7 @@ static LoadInst *combineLoadToNewType(InstCombiner &IC, LoadInst &LI, Type *NewT
LoadInst *NewLoad = IC.Builder->CreateAlignedLoad(
IC.Builder->CreateBitCast(Ptr, NewTy->getPointerTo(AS)),
LI.getAlignment(), LI.getName());
LI.getAlignment(), LI.getName() + Suffix);
MDBuilder MDB(NewLoad->getContext());
for (const auto &MDPair : MD) {
unsigned ID = MDPair.first;
@ -495,6 +496,31 @@ static Instruction *combineLoadToOperationType(InstCombiner &IC, LoadInst &LI) {
return nullptr;
}
static Instruction *unpackLoadToAggregate(InstCombiner &IC, LoadInst &LI) {
// FIXME: We could probably with some care handle both volatile and atomic
// stores here but it isn't clear that this is important.
if (!LI.isSimple())
return nullptr;
Type *T = LI.getType();
if (!T->isAggregateType())
return nullptr;
assert(LI.getAlignment() && "Alignement must be set at this point");
if (auto *ST = dyn_cast<StructType>(T)) {
// If the struct only have one element, we unpack.
if (ST->getNumElements() == 1) {
LoadInst *NewLoad = combineLoadToNewType(IC, LI, ST->getTypeAtIndex(0U),
".unpack");
return IC.ReplaceInstUsesWith(LI, IC.Builder->CreateInsertValue(
UndefValue::get(T), NewLoad, 0, LI.getName()));
}
}
return nullptr;
}
// If we can determine that all possible objects pointed to by the provided
// pointer value are, not only dereferenceable, but also definitively less than
// or equal to the provided maximum size, then return true. Otherwise, return
@ -701,6 +727,9 @@ Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
// FIXME: Some of it is okay for atomic loads; needs refactoring.
if (!LI.isSimple()) return nullptr;
if (Instruction *Res = unpackLoadToAggregate(*this, LI))
return Res;
// Do really simple store-to-load forwarding and load CSE, to catch cases
// where there are several consecutive memory accesses to the same location,
// separated by a few arithmetic operations.
@ -832,7 +861,7 @@ static bool unpackStoreToAggregate(InstCombiner &IC, StoreInst &SI) {
if (!T->isAggregateType())
return false;
if (StructType *ST = dyn_cast<StructType>(T)) {
if (auto *ST = dyn_cast<StructType>(T)) {
// If the struct only have one element, we unpack.
if (ST->getNumElements() == 1) {
V = IC.Builder->CreateExtractValue(V, 0);

42
test/Transforms/InstCombine/unpack-fca.ll
View File

@ -12,20 +12,58 @@ declare i32 @A.foo(%A* nocapture %this)
declare i8* @allocmemory(i64)
define void @structA() {
define void @storeA() {
body:
%0 = tail call i8* @allocmemory(i64 32)
%1 = bitcast i8* %0 to %A*
; CHECK-LABEL: storeA
; CHECK: store %A__vtbl* @A__vtblZ
store %A { %A__vtbl* @A__vtblZ }, %A* %1, align 8
ret void
}
define void @structOfA() {
define void @storeStructOfA() {
body:
%0 = tail call i8* @allocmemory(i64 32)
%1 = bitcast i8* %0 to { %A }*
; CHECK-LABEL: storeStructOfA
; CHECK: store %A__vtbl* @A__vtblZ
store { %A } { %A { %A__vtbl* @A__vtblZ } }, { %A }* %1, align 8
ret void
}
define %A @loadA() {
body:
%0 = tail call i8* @allocmemory(i64 32)
%1 = bitcast i8* %0 to %A*
; CHECK-LABEL: loadA
; CHECK: load %A__vtbl*,
; CHECK: insertvalue %A undef, %A__vtbl* {{.*}}, 0
%2 = load %A, %A* %1, align 8
ret %A %2
}
define { %A } @loadStructOfA() {
body:
%0 = tail call i8* @allocmemory(i64 32)
%1 = bitcast i8* %0 to { %A }*
; CHECK-LABEL: loadStructOfA
; CHECK: load %A__vtbl*,
; CHECK: insertvalue %A undef, %A__vtbl* {{.*}}, 0
; CHECK: insertvalue { %A } undef, %A {{.*}}, 0
%2 = load { %A }, { %A }* %1, align 8
ret { %A } %2
}
define { %A } @structOfA() {
body:
%0 = tail call i8* @allocmemory(i64 32)
%1 = bitcast i8* %0 to { %A }*
; CHECK-LABEL: structOfA
; CHECK: store %A__vtbl* @A__vtblZ
store { %A } { %A { %A__vtbl* @A__vtblZ } }, { %A }* %1, align 8
%2 = load { %A }, { %A }* %1, align 8
; CHECK-NOT: load
; CHECK: ret { %A } { %A { %A__vtbl* @A__vtblZ } }
ret { %A } %2
}