2003-05-27 15:45:27 +00:00
|
|
|
//===- ScalarReplAggregates.cpp - Scalar Replacement of Aggregates --------===//
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2003-05-27 15:45:27 +00:00
|
|
|
//
|
|
|
|
// This transformation implements the well known scalar replacement of
|
|
|
|
// aggregates transformation. This xform breaks up alloca instructions of
|
|
|
|
// aggregate type (structure or array) into individual alloca instructions for
|
2003-09-11 16:45:55 +00:00
|
|
|
// each member (if possible). Then, if possible, it transforms the individual
|
|
|
|
// alloca instructions into nice clean scalar SSA form.
|
|
|
|
//
|
|
|
|
// This combines a simple SRoA algorithm with the Mem2Reg algorithm because
|
|
|
|
// often interact, especially for C++ programs. As such, iterating between
|
|
|
|
// SRoA, then Mem2Reg until we run out of things to promote works well.
|
2003-05-27 15:45:27 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-12-19 21:40:18 +00:00
|
|
|
#define DEBUG_TYPE "scalarrepl"
|
2003-05-27 15:45:27 +00:00
|
|
|
#include "llvm/Transforms/Scalar.h"
|
2003-09-11 16:45:55 +00:00
|
|
|
#include "llvm/Constants.h"
|
|
|
|
#include "llvm/DerivedTypes.h"
|
2003-05-27 15:45:27 +00:00
|
|
|
#include "llvm/Function.h"
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
#include "llvm/GlobalVariable.h"
|
2004-07-29 17:05:13 +00:00
|
|
|
#include "llvm/Instructions.h"
|
2007-03-05 07:52:57 +00:00
|
|
|
#include "llvm/IntrinsicInst.h"
|
2009-07-03 19:42:02 +00:00
|
|
|
#include "llvm/LLVMContext.h"
|
2010-09-01 23:09:27 +00:00
|
|
|
#include "llvm/Module.h"
|
2007-03-05 07:52:57 +00:00
|
|
|
#include "llvm/Pass.h"
|
2011-07-06 22:06:11 +00:00
|
|
|
#include "llvm/Analysis/DebugInfo.h"
|
2011-05-24 03:10:43 +00:00
|
|
|
#include "llvm/Analysis/DIBuilder.h"
|
2011-01-18 03:53:26 +00:00
|
|
|
#include "llvm/Analysis/Dominators.h"
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
#include "llvm/Analysis/Loads.h"
|
2010-12-15 20:02:24 +00:00
|
|
|
#include "llvm/Analysis/ValueTracking.h"
|
2003-09-11 16:45:55 +00:00
|
|
|
#include "llvm/Target/TargetData.h"
|
|
|
|
#include "llvm/Transforms/Utils/PromoteMemToReg.h"
|
2009-02-10 07:00:59 +00:00
|
|
|
#include "llvm/Transforms/Utils/Local.h"
|
2011-01-14 07:50:47 +00:00
|
|
|
#include "llvm/Transforms/Utils/SSAUpdater.h"
|
2010-11-18 06:26:49 +00:00
|
|
|
#include "llvm/Support/CallSite.h"
|
2006-06-28 23:17:24 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2009-07-11 13:10:19 +00:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2005-12-12 07:19:13 +00:00
|
|
|
#include "llvm/Support/GetElementPtrTypeIterator.h"
|
2009-02-03 19:41:50 +00:00
|
|
|
#include "llvm/Support/IRBuilder.h"
|
2005-12-12 07:19:13 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2009-08-23 04:37:46 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
#include "llvm/ADT/SetVector.h"
|
2007-02-12 22:56:41 +00:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
2003-12-02 17:43:55 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2006-12-19 21:40:18 +00:00
|
|
|
STATISTIC(NumReplaced, "Number of allocas broken up");
|
|
|
|
STATISTIC(NumPromoted, "Number of allocas promoted");
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
STATISTIC(NumAdjusted, "Number of scalar allocas adjusted to allow promotion");
|
2006-12-19 21:40:18 +00:00
|
|
|
STATISTIC(NumConverted, "Number of aggregates converted to scalar");
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
STATISTIC(NumGlobals, "Number of allocas copied from constant global");
|
2003-05-27 15:45:27 +00:00
|
|
|
|
2006-12-19 21:40:18 +00:00
|
|
|
namespace {
|
2009-09-02 06:11:42 +00:00
|
|
|
struct SROA : public FunctionPass {
|
2011-01-18 03:53:26 +00:00
|
|
|
SROA(int T, bool hasDT, char &ID)
|
|
|
|
: FunctionPass(ID), HasDomTree(hasDT) {
|
2007-07-09 21:19:23 +00:00
|
|
|
if (T == -1)
|
2007-08-02 21:33:36 +00:00
|
|
|
SRThreshold = 128;
|
2007-07-09 21:19:23 +00:00
|
|
|
else
|
|
|
|
SRThreshold = T;
|
|
|
|
}
|
2007-05-01 21:15:47 +00:00
|
|
|
|
2003-05-27 15:45:27 +00:00
|
|
|
bool runOnFunction(Function &F);
|
|
|
|
|
2003-09-11 16:45:55 +00:00
|
|
|
bool performScalarRepl(Function &F);
|
|
|
|
bool performPromotion(Function &F);
|
|
|
|
|
2003-05-27 15:45:27 +00:00
|
|
|
private:
|
2011-01-18 03:53:26 +00:00
|
|
|
bool HasDomTree;
|
2009-01-07 06:34:28 +00:00
|
|
|
TargetData *TD;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2009-12-18 20:14:40 +00:00
|
|
|
/// DeadInsts - Keep track of instructions we have made dead, so that
|
|
|
|
/// we can remove them after we are done working.
|
|
|
|
SmallVector<Value*, 32> DeadInsts;
|
|
|
|
|
2007-05-30 06:11:23 +00:00
|
|
|
/// AllocaInfo - When analyzing uses of an alloca instruction, this captures
|
|
|
|
/// information about the uses. All these fields are initialized to false
|
|
|
|
/// and set to true when something is learned.
|
|
|
|
struct AllocaInfo {
|
2011-01-23 07:29:29 +00:00
|
|
|
/// The alloca to promote.
|
|
|
|
AllocaInst *AI;
|
|
|
|
|
2011-01-23 08:27:54 +00:00
|
|
|
/// CheckedPHIs - This is a set of verified PHI nodes, to prevent infinite
|
|
|
|
/// looping and avoid redundant work.
|
|
|
|
SmallPtrSet<PHINode*, 8> CheckedPHIs;
|
|
|
|
|
2007-05-30 06:11:23 +00:00
|
|
|
/// isUnsafe - This is set to true if the alloca cannot be SROA'd.
|
|
|
|
bool isUnsafe : 1;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2007-05-30 06:11:23 +00:00
|
|
|
/// isMemCpySrc - This is true if this aggregate is memcpy'd from.
|
|
|
|
bool isMemCpySrc : 1;
|
|
|
|
|
2007-07-06 06:01:16 +00:00
|
|
|
/// isMemCpyDst - This is true if this aggregate is memcpy'd into.
|
2007-05-30 06:11:23 +00:00
|
|
|
bool isMemCpyDst : 1;
|
|
|
|
|
if an alloca is only ever accessed as a unit, and is accessed with load/store instructions,
then don't try to decimate it into its individual pieces. This will just make a mess of the
IR and is pointless if none of the elements are individually accessed. This was generating
really terrible code for std::bitset (PR8980) because it happens to be lowered by clang
as an {[8 x i8]} structure instead of {i64}.
The testcase now is optimized to:
define i64 @test2(i64 %X) {
br label %L2
L2: ; preds = %0
ret i64 %X
}
before we generated:
define i64 @test2(i64 %X) {
%sroa.store.elt = lshr i64 %X, 56
%1 = trunc i64 %sroa.store.elt to i8
%sroa.store.elt8 = lshr i64 %X, 48
%2 = trunc i64 %sroa.store.elt8 to i8
%sroa.store.elt9 = lshr i64 %X, 40
%3 = trunc i64 %sroa.store.elt9 to i8
%sroa.store.elt10 = lshr i64 %X, 32
%4 = trunc i64 %sroa.store.elt10 to i8
%sroa.store.elt11 = lshr i64 %X, 24
%5 = trunc i64 %sroa.store.elt11 to i8
%sroa.store.elt12 = lshr i64 %X, 16
%6 = trunc i64 %sroa.store.elt12 to i8
%sroa.store.elt13 = lshr i64 %X, 8
%7 = trunc i64 %sroa.store.elt13 to i8
%8 = trunc i64 %X to i8
br label %L2
L2: ; preds = %0
%9 = zext i8 %1 to i64
%10 = shl i64 %9, 56
%11 = zext i8 %2 to i64
%12 = shl i64 %11, 48
%13 = or i64 %12, %10
%14 = zext i8 %3 to i64
%15 = shl i64 %14, 40
%16 = or i64 %15, %13
%17 = zext i8 %4 to i64
%18 = shl i64 %17, 32
%19 = or i64 %18, %16
%20 = zext i8 %5 to i64
%21 = shl i64 %20, 24
%22 = or i64 %21, %19
%23 = zext i8 %6 to i64
%24 = shl i64 %23, 16
%25 = or i64 %24, %22
%26 = zext i8 %7 to i64
%27 = shl i64 %26, 8
%28 = or i64 %27, %25
%29 = zext i8 %8 to i64
%30 = or i64 %29, %28
ret i64 %30
}
In this case, instcombine was able to eliminate the nonsense, but in PR8980 enough
PHIs are in play that instcombine backs off. It's better to not generate this stuff
in the first place.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@123571 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-16 06:18:28 +00:00
|
|
|
/// hasSubelementAccess - This is true if a subelement of the alloca is
|
|
|
|
/// ever accessed, or false if the alloca is only accessed with mem
|
|
|
|
/// intrinsics or load/store that only access the entire alloca at once.
|
|
|
|
bool hasSubelementAccess : 1;
|
|
|
|
|
|
|
|
/// hasALoadOrStore - This is true if there are any loads or stores to it.
|
|
|
|
/// The alloca may just be accessed with memcpy, for example, which would
|
|
|
|
/// not set this.
|
|
|
|
bool hasALoadOrStore : 1;
|
|
|
|
|
2011-01-23 07:29:29 +00:00
|
|
|
explicit AllocaInfo(AllocaInst *ai)
|
|
|
|
: AI(ai), isUnsafe(false), isMemCpySrc(false), isMemCpyDst(false),
|
if an alloca is only ever accessed as a unit, and is accessed with load/store instructions,
then don't try to decimate it into its individual pieces. This will just make a mess of the
IR and is pointless if none of the elements are individually accessed. This was generating
really terrible code for std::bitset (PR8980) because it happens to be lowered by clang
as an {[8 x i8]} structure instead of {i64}.
The testcase now is optimized to:
define i64 @test2(i64 %X) {
br label %L2
L2: ; preds = %0
ret i64 %X
}
before we generated:
define i64 @test2(i64 %X) {
%sroa.store.elt = lshr i64 %X, 56
%1 = trunc i64 %sroa.store.elt to i8
%sroa.store.elt8 = lshr i64 %X, 48
%2 = trunc i64 %sroa.store.elt8 to i8
%sroa.store.elt9 = lshr i64 %X, 40
%3 = trunc i64 %sroa.store.elt9 to i8
%sroa.store.elt10 = lshr i64 %X, 32
%4 = trunc i64 %sroa.store.elt10 to i8
%sroa.store.elt11 = lshr i64 %X, 24
%5 = trunc i64 %sroa.store.elt11 to i8
%sroa.store.elt12 = lshr i64 %X, 16
%6 = trunc i64 %sroa.store.elt12 to i8
%sroa.store.elt13 = lshr i64 %X, 8
%7 = trunc i64 %sroa.store.elt13 to i8
%8 = trunc i64 %X to i8
br label %L2
L2: ; preds = %0
%9 = zext i8 %1 to i64
%10 = shl i64 %9, 56
%11 = zext i8 %2 to i64
%12 = shl i64 %11, 48
%13 = or i64 %12, %10
%14 = zext i8 %3 to i64
%15 = shl i64 %14, 40
%16 = or i64 %15, %13
%17 = zext i8 %4 to i64
%18 = shl i64 %17, 32
%19 = or i64 %18, %16
%20 = zext i8 %5 to i64
%21 = shl i64 %20, 24
%22 = or i64 %21, %19
%23 = zext i8 %6 to i64
%24 = shl i64 %23, 16
%25 = or i64 %24, %22
%26 = zext i8 %7 to i64
%27 = shl i64 %26, 8
%28 = or i64 %27, %25
%29 = zext i8 %8 to i64
%30 = or i64 %29, %28
ret i64 %30
}
In this case, instcombine was able to eliminate the nonsense, but in PR8980 enough
PHIs are in play that instcombine backs off. It's better to not generate this stuff
in the first place.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@123571 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-16 06:18:28 +00:00
|
|
|
hasSubelementAccess(false), hasALoadOrStore(false) {}
|
2007-05-30 06:11:23 +00:00
|
|
|
};
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2007-07-09 21:19:23 +00:00
|
|
|
unsigned SRThreshold;
|
|
|
|
|
2011-01-23 07:05:44 +00:00
|
|
|
void MarkUnsafe(AllocaInfo &I, Instruction *User) {
|
|
|
|
I.isUnsafe = true;
|
|
|
|
DEBUG(dbgs() << " Transformation preventing inst: " << *User << '\n');
|
|
|
|
}
|
2007-05-30 06:11:23 +00:00
|
|
|
|
2010-01-21 23:05:53 +00:00
|
|
|
bool isSafeAllocaToScalarRepl(AllocaInst *AI);
|
2007-05-30 06:11:23 +00:00
|
|
|
|
2011-01-23 07:29:29 +00:00
|
|
|
void isSafeForScalarRepl(Instruction *I, uint64_t Offset, AllocaInfo &Info);
|
2011-01-23 08:27:54 +00:00
|
|
|
void isSafePHISelectUseForScalarRepl(Instruction *User, uint64_t Offset,
|
|
|
|
AllocaInfo &Info);
|
2011-01-23 07:29:29 +00:00
|
|
|
void isSafeGEP(GetElementPtrInst *GEPI, uint64_t &Offset, AllocaInfo &Info);
|
|
|
|
void isSafeMemAccess(uint64_t Offset, uint64_t MemSize,
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *MemOpType, bool isStore, AllocaInfo &Info,
|
2011-01-23 08:27:54 +00:00
|
|
|
Instruction *TheAccess, bool AllowWholeAccess);
|
2011-07-18 04:54:35 +00:00
|
|
|
bool TypeHasComponent(Type *T, uint64_t Offset, uint64_t Size);
|
|
|
|
uint64_t FindElementAndOffset(Type *&T, uint64_t &Offset,
|
|
|
|
Type *&IdxTy);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
|
|
|
void DoScalarReplacement(AllocaInst *AI,
|
2009-10-23 21:09:37 +00:00
|
|
|
std::vector<AllocaInst*> &WorkList);
|
2009-12-18 20:14:40 +00:00
|
|
|
void DeleteDeadInstructions();
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2009-12-18 20:14:40 +00:00
|
|
|
void RewriteForScalarRepl(Instruction *I, AllocaInst *AI, uint64_t Offset,
|
|
|
|
SmallVector<AllocaInst*, 32> &NewElts);
|
|
|
|
void RewriteBitCast(BitCastInst *BC, AllocaInst *AI, uint64_t Offset,
|
|
|
|
SmallVector<AllocaInst*, 32> &NewElts);
|
|
|
|
void RewriteGEP(GetElementPtrInst *GEPI, AllocaInst *AI, uint64_t Offset,
|
|
|
|
SmallVector<AllocaInst*, 32> &NewElts);
|
2011-07-25 23:14:22 +00:00
|
|
|
void RewriteLifetimeIntrinsic(IntrinsicInst *II, AllocaInst *AI,
|
|
|
|
uint64_t Offset,
|
|
|
|
SmallVector<AllocaInst*, 32> &NewElts);
|
2009-12-18 20:14:40 +00:00
|
|
|
void RewriteMemIntrinUserOfAlloca(MemIntrinsic *MI, Instruction *Inst,
|
2009-10-23 21:09:37 +00:00
|
|
|
AllocaInst *AI,
|
2009-01-07 07:18:45 +00:00
|
|
|
SmallVector<AllocaInst*, 32> &NewElts);
|
2009-10-23 21:09:37 +00:00
|
|
|
void RewriteStoreUserOfWholeAlloca(StoreInst *SI, AllocaInst *AI,
|
Implement the first half of PR3290: if there is a store of an
integer to a (transitive) bitcast the alloca and if that integer
has the full size of the alloca, then it clobbers the whole thing.
Handle this by extracting pieces out of the stored integer and
filing them away in the SROA'd elements.
This triggers fairly frequently because the CFE uses integers to
pass small structs by value and the inliner exposes these. For
example, in kimwitu++, I see a bunch of these with i64 stores to
"%struct.std::pair<std::_Rb_tree_const_iterator<kc::impl_abstract_phylum*>,bool>"
In 176.gcc I see a few i32 stores to "%struct..0anon".
In the testcase, this is a difference between compiling test1 to:
_test1:
subl $12, %esp
movl 20(%esp), %eax
movl %eax, 4(%esp)
movl 16(%esp), %eax
movl %eax, (%esp)
movl (%esp), %eax
addl 4(%esp), %eax
addl $12, %esp
ret
vs:
_test1:
movl 8(%esp), %eax
addl 4(%esp), %eax
ret
The second half of this will be to handle loads of the same form.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61853 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-07 08:11:13 +00:00
|
|
|
SmallVector<AllocaInst*, 32> &NewElts);
|
2009-10-23 21:09:37 +00:00
|
|
|
void RewriteLoadUserOfWholeAlloca(LoadInst *LI, AllocaInst *AI,
|
2009-01-28 20:16:43 +00:00
|
|
|
SmallVector<AllocaInst*, 32> &NewElts);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-06-27 05:40:02 +00:00
|
|
|
static MemTransferInst *isOnlyCopiedFromConstantGlobal(
|
|
|
|
AllocaInst *AI, SmallVector<Instruction*, 4> &ToDelete);
|
2003-05-27 15:45:27 +00:00
|
|
|
};
|
2011-01-14 08:13:00 +00:00
|
|
|
|
2011-01-18 03:53:26 +00:00
|
|
|
// SROA_DT - SROA that uses DominatorTree.
|
|
|
|
struct SROA_DT : public SROA {
|
2011-01-14 08:13:00 +00:00
|
|
|
static char ID;
|
|
|
|
public:
|
2011-01-18 03:53:26 +00:00
|
|
|
SROA_DT(int T = -1) : SROA(T, true, ID) {
|
|
|
|
initializeSROA_DTPass(*PassRegistry::getPassRegistry());
|
2011-01-14 08:13:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// getAnalysisUsage - This pass does not require any passes, but we know it
|
|
|
|
// will not alter the CFG, so say so.
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.addRequired<DominatorTree>();
|
|
|
|
AU.setPreservesCFG();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// SROA_SSAUp - SROA that uses SSAUpdater.
|
|
|
|
struct SROA_SSAUp : public SROA {
|
|
|
|
static char ID;
|
|
|
|
public:
|
|
|
|
SROA_SSAUp(int T = -1) : SROA(T, false, ID) {
|
|
|
|
initializeSROA_SSAUpPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
|
|
|
|
|
|
|
// getAnalysisUsage - This pass does not require any passes, but we know it
|
|
|
|
// will not alter the CFG, so say so.
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.setPreservesCFG();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2003-05-27 15:45:27 +00:00
|
|
|
}
|
|
|
|
|
2011-01-18 03:53:26 +00:00
|
|
|
char SROA_DT::ID = 0;
|
2011-01-14 08:13:00 +00:00
|
|
|
char SROA_SSAUp::ID = 0;
|
|
|
|
|
2011-01-18 03:53:26 +00:00
|
|
|
INITIALIZE_PASS_BEGIN(SROA_DT, "scalarrepl",
|
|
|
|
"Scalar Replacement of Aggregates (DT)", false, false)
|
2010-10-12 19:48:12 +00:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(DominatorTree)
|
2011-01-18 03:53:26 +00:00
|
|
|
INITIALIZE_PASS_END(SROA_DT, "scalarrepl",
|
|
|
|
"Scalar Replacement of Aggregates (DT)", false, false)
|
2011-01-14 08:13:00 +00:00
|
|
|
|
|
|
|
INITIALIZE_PASS_BEGIN(SROA_SSAUp, "scalarrepl-ssa",
|
|
|
|
"Scalar Replacement of Aggregates (SSAUp)", false, false)
|
|
|
|
INITIALIZE_PASS_END(SROA_SSAUp, "scalarrepl-ssa",
|
|
|
|
"Scalar Replacement of Aggregates (SSAUp)", false, false)
|
2008-05-13 00:00:25 +00:00
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
// Public interface to the ScalarReplAggregates pass
|
2011-01-14 08:13:00 +00:00
|
|
|
FunctionPass *llvm::createScalarReplAggregatesPass(int Threshold,
|
2011-01-18 03:53:26 +00:00
|
|
|
bool UseDomTree) {
|
|
|
|
if (UseDomTree)
|
|
|
|
return new SROA_DT(Threshold);
|
2011-01-14 08:13:00 +00:00
|
|
|
return new SROA_SSAUp(Threshold);
|
2007-07-09 21:19:23 +00:00
|
|
|
}
|
2003-05-27 15:45:27 +00:00
|
|
|
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Convert To Scalar Optimization.
|
|
|
|
//===----------------------------------------------------------------------===//
|
2008-06-22 17:46:21 +00:00
|
|
|
|
2010-04-15 23:50:26 +00:00
|
|
|
namespace {
|
2010-04-16 00:38:19 +00:00
|
|
|
/// ConvertToScalarInfo - This class implements the "Convert To Scalar"
|
|
|
|
/// optimization, which scans the uses of an alloca and determines if it can
|
|
|
|
/// rewrite it in terms of a single new alloca that can be mem2reg'd.
|
2010-04-16 00:24:57 +00:00
|
|
|
class ConvertToScalarInfo {
|
2011-03-16 00:13:35 +00:00
|
|
|
/// AllocaSize - The size of the alloca being considered in bytes.
|
2010-04-15 23:50:26 +00:00
|
|
|
unsigned AllocaSize;
|
2010-04-16 00:20:00 +00:00
|
|
|
const TargetData &TD;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 02:32:17 +00:00
|
|
|
/// IsNotTrivial - This is set to true if there is some access to the object
|
2010-04-16 00:38:19 +00:00
|
|
|
/// which means that mem2reg can't promote it.
|
2010-04-15 23:50:26 +00:00
|
|
|
bool IsNotTrivial;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-06-13 21:44:35 +00:00
|
|
|
/// ScalarKind - Tracks the kind of alloca being considered for promotion,
|
|
|
|
/// computed based on the uses of the alloca rather than the LLVM type system.
|
|
|
|
enum {
|
|
|
|
Unknown,
|
2011-06-13 21:44:40 +00:00
|
|
|
|
2011-06-13 23:39:23 +00:00
|
|
|
// Accesses via GEPs that are consistent with element access of a vector
|
2011-06-13 21:44:40 +00:00
|
|
|
// type. This will not be converted into a vector unless there is a later
|
|
|
|
// access using an actual vector type.
|
|
|
|
ImplicitVector,
|
|
|
|
|
2011-06-13 23:39:23 +00:00
|
|
|
// Accesses via vector operations and GEPs that are consistent with the
|
|
|
|
// layout of a vector type.
|
2011-06-13 21:44:35 +00:00
|
|
|
Vector,
|
2011-06-13 21:44:40 +00:00
|
|
|
|
|
|
|
// An integer bag-of-bits with bitwise operations for insertion and
|
|
|
|
// extraction. Any combination of types can be converted into this kind
|
|
|
|
// of scalar.
|
2011-06-13 21:44:35 +00:00
|
|
|
Integer
|
|
|
|
} ScalarKind;
|
|
|
|
|
2010-04-16 00:38:19 +00:00
|
|
|
/// VectorTy - This tracks the type that we should promote the vector to if
|
|
|
|
/// it is possible to turn it into a vector. This starts out null, and if it
|
|
|
|
/// isn't possible to turn into a vector type, it gets set to VoidTy.
|
2011-07-18 04:54:35 +00:00
|
|
|
VectorType *VectorTy;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-03-16 08:13:42 +00:00
|
|
|
/// HadNonMemTransferAccess - True if there is at least one access to the
|
|
|
|
/// alloca that is not a MemTransferInst. We don't want to turn structs into
|
|
|
|
/// large integers unless there is some potential for optimization.
|
2011-03-16 00:13:44 +00:00
|
|
|
bool HadNonMemTransferAccess;
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
public:
|
2010-04-16 00:20:00 +00:00
|
|
|
explicit ConvertToScalarInfo(unsigned Size, const TargetData &td)
|
2011-06-13 21:44:35 +00:00
|
|
|
: AllocaSize(Size), TD(td), IsNotTrivial(false), ScalarKind(Unknown),
|
2011-06-13 21:44:40 +00:00
|
|
|
VectorTy(0), HadNonMemTransferAccess(false) { }
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:38:19 +00:00
|
|
|
AllocaInst *TryConvert(AllocaInst *AI);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
private:
|
2010-04-16 00:20:00 +00:00
|
|
|
bool CanConvertToScalar(Value *V, uint64_t Offset);
|
2011-07-18 04:54:35 +00:00
|
|
|
void MergeInTypeForLoadOrStore(Type *In, uint64_t Offset);
|
|
|
|
bool MergeInVectorType(VectorType *VInTy, uint64_t Offset);
|
2010-04-16 00:20:00 +00:00
|
|
|
void ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, uint64_t Offset);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Value *ConvertScalar_ExtractValue(Value *NV, Type *ToType,
|
2010-04-16 00:20:00 +00:00
|
|
|
uint64_t Offset, IRBuilder<> &Builder);
|
|
|
|
Value *ConvertScalar_InsertValue(Value *StoredVal, Value *ExistingVal,
|
|
|
|
uint64_t Offset, IRBuilder<> &Builder);
|
2010-04-15 23:50:26 +00:00
|
|
|
};
|
|
|
|
} // end anonymous namespace.
|
|
|
|
|
2010-09-01 05:14:33 +00:00
|
|
|
|
2010-04-16 00:38:19 +00:00
|
|
|
/// TryConvert - Analyze the specified alloca, and if it is safe to do so,
|
|
|
|
/// rewrite it to be a new alloca which is mem2reg'able. This returns the new
|
|
|
|
/// alloca if possible or null if not.
|
|
|
|
AllocaInst *ConvertToScalarInfo::TryConvert(AllocaInst *AI) {
|
|
|
|
// If we can't convert this scalar, or if mem2reg can trivially do it, bail
|
|
|
|
// out.
|
|
|
|
if (!CanConvertToScalar(AI, 0) || !IsNotTrivial)
|
|
|
|
return 0;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-06-13 21:44:40 +00:00
|
|
|
// If an alloca has only memset / memcpy uses, it may still have an Unknown
|
|
|
|
// ScalarKind. Treat it as an Integer below.
|
|
|
|
if (ScalarKind == Unknown)
|
|
|
|
ScalarKind = Integer;
|
|
|
|
|
2011-06-18 06:17:51 +00:00
|
|
|
if (ScalarKind == Vector && VectorTy->getBitWidth() != AllocaSize * 8)
|
|
|
|
ScalarKind = Integer;
|
|
|
|
|
2010-04-16 00:38:19 +00:00
|
|
|
// If we were able to find a vector type that can handle this with
|
|
|
|
// insert/extract elements, and if there was at least one use that had
|
|
|
|
// a vector type, promote this to a vector. We don't want to promote
|
|
|
|
// random stuff that doesn't use vectors (e.g. <9 x double>) because then
|
|
|
|
// we just get a lot of insert/extracts. If at least one vector is
|
|
|
|
// involved, then we probably really do have a union of vector/array.
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *NewTy;
|
2011-06-14 06:33:51 +00:00
|
|
|
if (ScalarKind == Vector) {
|
|
|
|
assert(VectorTy && "Missing type for vector scalar.");
|
2010-04-16 00:38:19 +00:00
|
|
|
DEBUG(dbgs() << "CONVERT TO VECTOR: " << *AI << "\n TYPE = "
|
|
|
|
<< *VectorTy << '\n');
|
|
|
|
NewTy = VectorTy; // Use the vector type.
|
|
|
|
} else {
|
2011-03-16 00:13:44 +00:00
|
|
|
unsigned BitWidth = AllocaSize * 8;
|
2011-06-13 21:44:40 +00:00
|
|
|
if ((ScalarKind == ImplicitVector || ScalarKind == Integer) &&
|
|
|
|
!HadNonMemTransferAccess && !TD.fitsInLegalInteger(BitWidth))
|
2011-03-16 00:13:44 +00:00
|
|
|
return 0;
|
|
|
|
|
2010-04-16 00:38:19 +00:00
|
|
|
DEBUG(dbgs() << "CONVERT TO SCALAR INTEGER: " << *AI << "\n");
|
|
|
|
// Create and insert the integer alloca.
|
2011-03-16 00:13:44 +00:00
|
|
|
NewTy = IntegerType::get(AI->getContext(), BitWidth);
|
2010-04-16 00:38:19 +00:00
|
|
|
}
|
|
|
|
AllocaInst *NewAI = new AllocaInst(NewTy, 0, "", AI->getParent()->begin());
|
|
|
|
ConvertUsesToScalar(AI, NewAI, 0);
|
|
|
|
return NewAI;
|
|
|
|
}
|
|
|
|
|
2011-06-13 21:44:43 +00:00
|
|
|
/// MergeInTypeForLoadOrStore - Add the 'In' type to the accumulated vector type
|
|
|
|
/// (VectorTy) so far at the offset specified by Offset (which is specified in
|
|
|
|
/// bytes).
|
2010-04-16 00:24:57 +00:00
|
|
|
///
|
2011-10-11 06:10:30 +00:00
|
|
|
/// There are two cases we handle here:
|
2010-04-16 00:24:57 +00:00
|
|
|
/// 1) A union of vector types of the same size and potentially its elements.
|
|
|
|
/// Here we turn element accesses into insert/extract element operations.
|
|
|
|
/// This promotes a <4 x float> with a store of float to the third element
|
|
|
|
/// into a <4 x float> that uses insert element.
|
2011-10-11 06:10:30 +00:00
|
|
|
/// 2) A fully general blob of memory, which we turn into some (potentially
|
2010-04-16 00:24:57 +00:00
|
|
|
/// large) integer type with extract and insert operations where the loads
|
2010-04-16 00:38:19 +00:00
|
|
|
/// and stores would mutate the memory. We mark this by setting VectorTy
|
|
|
|
/// to VoidTy.
|
2011-07-18 04:54:35 +00:00
|
|
|
void ConvertToScalarInfo::MergeInTypeForLoadOrStore(Type *In,
|
2011-06-13 21:44:43 +00:00
|
|
|
uint64_t Offset) {
|
2010-04-16 00:38:19 +00:00
|
|
|
// If we already decided to turn this into a blob of integer memory, there is
|
|
|
|
// nothing to be done.
|
2011-06-13 21:44:35 +00:00
|
|
|
if (ScalarKind == Integer)
|
2010-04-16 00:24:57 +00:00
|
|
|
return;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If this could be contributing to a vector, analyze it.
|
2010-04-15 23:50:26 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If the In type is a vector that is the same size as the alloca, see if it
|
|
|
|
// matches the existing VecTy.
|
2011-07-18 04:54:35 +00:00
|
|
|
if (VectorType *VInTy = dyn_cast<VectorType>(In)) {
|
2011-03-09 05:43:01 +00:00
|
|
|
if (MergeInVectorType(VInTy, Offset))
|
2010-04-16 00:24:57 +00:00
|
|
|
return;
|
|
|
|
} else if (In->isFloatTy() || In->isDoubleTy() ||
|
|
|
|
(In->isIntegerTy() && In->getPrimitiveSizeInBits() >= 8 &&
|
|
|
|
isPowerOf2_32(In->getPrimitiveSizeInBits()))) {
|
2011-03-29 05:19:52 +00:00
|
|
|
// Full width accesses can be ignored, because they can always be turned
|
|
|
|
// into bitcasts.
|
|
|
|
unsigned EltSize = In->getPrimitiveSizeInBits()/8;
|
2011-06-13 21:44:31 +00:00
|
|
|
if (EltSize == AllocaSize)
|
2011-03-29 05:19:52 +00:00
|
|
|
return;
|
2011-04-20 21:48:16 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If we're accessing something that could be an element of a vector, see
|
|
|
|
// if the implied vector agrees with what we already have and if Offset is
|
|
|
|
// compatible with it.
|
2011-06-09 01:45:33 +00:00
|
|
|
if (Offset % EltSize == 0 && AllocaSize % EltSize == 0 &&
|
2011-10-11 06:10:30 +00:00
|
|
|
(!VectorTy || EltSize == VectorTy->getElementType()
|
|
|
|
->getPrimitiveSizeInBits()/8)) {
|
2011-04-20 21:48:16 +00:00
|
|
|
if (!VectorTy) {
|
2011-06-13 21:44:40 +00:00
|
|
|
ScalarKind = ImplicitVector;
|
2010-04-16 00:24:57 +00:00
|
|
|
VectorTy = VectorType::get(In, AllocaSize/EltSize);
|
2011-04-20 21:48:16 +00:00
|
|
|
}
|
2011-10-11 06:10:30 +00:00
|
|
|
return;
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Otherwise, we have a case that we can't handle with an optimized vector
|
|
|
|
// form. We can still turn this into a large integer.
|
2011-06-13 21:44:35 +00:00
|
|
|
ScalarKind = Integer;
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
2010-04-15 23:50:26 +00:00
|
|
|
|
2011-06-13 21:44:43 +00:00
|
|
|
/// MergeInVectorType - Handles the vector case of MergeInTypeForLoadOrStore,
|
|
|
|
/// returning true if the type was successfully merged and false otherwise.
|
2011-07-18 04:54:35 +00:00
|
|
|
bool ConvertToScalarInfo::MergeInVectorType(VectorType *VInTy,
|
2011-03-09 05:43:01 +00:00
|
|
|
uint64_t Offset) {
|
2011-10-11 06:10:30 +00:00
|
|
|
if (VInTy->getBitWidth()/8 == AllocaSize && Offset == 0) {
|
|
|
|
// If we're storing/loading a vector of the right size, allow it as a
|
|
|
|
// vector. If this the first vector we see, remember the type so that
|
|
|
|
// we know the element size. If this is a subsequent access, ignore it
|
|
|
|
// even if it is a differing type but the same size. Worst case we can
|
|
|
|
// bitcast the resultant vectors.
|
|
|
|
if (!VectorTy)
|
|
|
|
VectorTy = VInTy;
|
2011-06-13 21:44:40 +00:00
|
|
|
ScalarKind = Vector;
|
2011-03-09 05:43:05 +00:00
|
|
|
return true;
|
2011-06-13 21:44:40 +00:00
|
|
|
}
|
2011-03-09 05:43:05 +00:00
|
|
|
|
2011-10-11 06:10:30 +00:00
|
|
|
return false;
|
2011-03-09 05:43:01 +00:00
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// CanConvertToScalar - V is a pointer. If we can convert the pointee and all
|
|
|
|
/// its accesses to a single vector type, return true and set VecTy to
|
|
|
|
/// the new type. If we could convert the alloca into a single promotable
|
|
|
|
/// integer, return true but set VecTy to VoidTy. Further, if the use is not a
|
|
|
|
/// completely trivial use that mem2reg could promote, set IsNotTrivial. Offset
|
|
|
|
/// is the current offset from the base of the alloca being analyzed.
|
|
|
|
///
|
|
|
|
/// If we see at least one access to the value that is as a vector type, set the
|
|
|
|
/// SawVec flag.
|
|
|
|
bool ConvertToScalarInfo::CanConvertToScalar(Value *V, uint64_t Offset) {
|
|
|
|
for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI!=E; ++UI) {
|
|
|
|
Instruction *User = cast<Instruction>(*UI);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(User)) {
|
|
|
|
// Don't break volatile loads.
|
2011-09-12 20:23:13 +00:00
|
|
|
if (!LI->isSimple())
|
2010-04-16 00:24:57 +00:00
|
|
|
return false;
|
2010-09-30 23:57:10 +00:00
|
|
|
// Don't touch MMX operations.
|
|
|
|
if (LI->getType()->isX86_MMXTy())
|
|
|
|
return false;
|
2011-03-16 00:13:44 +00:00
|
|
|
HadNonMemTransferAccess = true;
|
2011-06-13 21:44:43 +00:00
|
|
|
MergeInTypeForLoadOrStore(LI->getType(), Offset);
|
2006-12-22 23:14:42 +00:00
|
|
|
continue;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (StoreInst *SI = dyn_cast<StoreInst>(User)) {
|
|
|
|
// Storing the pointer, not into the value?
|
2011-09-12 20:23:13 +00:00
|
|
|
if (SI->getOperand(0) == V || !SI->isSimple()) return false;
|
2010-09-30 23:57:10 +00:00
|
|
|
// Don't touch MMX operations.
|
|
|
|
if (SI->getOperand(0)->getType()->isX86_MMXTy())
|
|
|
|
return false;
|
2011-03-16 00:13:44 +00:00
|
|
|
HadNonMemTransferAccess = true;
|
2011-06-13 21:44:43 +00:00
|
|
|
MergeInTypeForLoadOrStore(SI->getOperand(0)->getType(), Offset);
|
2009-02-03 01:30:09 +00:00
|
|
|
continue;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (BitCastInst *BCI = dyn_cast<BitCastInst>(User)) {
|
2011-07-25 23:14:22 +00:00
|
|
|
if (!onlyUsedByLifetimeMarkers(BCI))
|
|
|
|
IsNotTrivial = true; // Can't be mem2reg'd.
|
2010-04-16 00:24:57 +00:00
|
|
|
if (!CanConvertToScalar(BCI, Offset))
|
|
|
|
return false;
|
2010-02-03 17:23:56 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(User)) {
|
|
|
|
// If this is a GEP with a variable indices, we can't handle it.
|
|
|
|
if (!GEP->hasAllConstantIndices())
|
|
|
|
return false;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Compute the offset that this GEP adds to the pointer.
|
|
|
|
SmallVector<Value*, 8> Indices(GEP->op_begin()+1, GEP->op_end());
|
2011-12-05 06:29:09 +00:00
|
|
|
if (!GEP->getPointerOperandType()->isPointerTy())
|
|
|
|
return false;
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t GEPOffset = TD.getIndexedOffset(GEP->getPointerOperandType(),
|
2011-07-19 14:01:37 +00:00
|
|
|
Indices);
|
2010-04-16 00:24:57 +00:00
|
|
|
// See if all uses can be converted.
|
|
|
|
if (!CanConvertToScalar(GEP, Offset+GEPOffset))
|
|
|
|
return false;
|
2010-04-16 00:38:19 +00:00
|
|
|
IsNotTrivial = true; // Can't be mem2reg'd.
|
2011-03-16 00:13:44 +00:00
|
|
|
HadNonMemTransferAccess = true;
|
2009-02-03 01:30:09 +00:00
|
|
|
continue;
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
2003-05-27 15:45:27 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If this is a constant sized memset of a constant value (e.g. 0) we can
|
|
|
|
// handle it.
|
|
|
|
if (MemSetInst *MSI = dyn_cast<MemSetInst>(User)) {
|
2011-06-18 05:47:49 +00:00
|
|
|
// Store of constant value.
|
|
|
|
if (!isa<ConstantInt>(MSI->getValue()))
|
2010-04-16 00:38:19 +00:00
|
|
|
return false;
|
2011-06-18 05:47:49 +00:00
|
|
|
|
|
|
|
// Store of constant size.
|
|
|
|
ConstantInt *Len = dyn_cast<ConstantInt>(MSI->getLength());
|
|
|
|
if (!Len)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// If the size differs from the alloca, we can only convert the alloca to
|
|
|
|
// an integer bag-of-bits.
|
|
|
|
// FIXME: This should handle all of the cases that are currently accepted
|
|
|
|
// as vector element insertions.
|
|
|
|
if (Len->getZExtValue() != AllocaSize || Offset != 0)
|
|
|
|
ScalarKind = Integer;
|
|
|
|
|
2010-04-16 00:38:19 +00:00
|
|
|
IsNotTrivial = true; // Can't be mem2reg'd.
|
2011-03-16 00:13:44 +00:00
|
|
|
HadNonMemTransferAccess = true;
|
2010-04-16 00:38:19 +00:00
|
|
|
continue;
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If this is a memcpy or memmove into or out of the whole allocation, we
|
|
|
|
// can handle it like a load or store of the scalar type.
|
|
|
|
if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(User)) {
|
2010-04-16 00:38:19 +00:00
|
|
|
ConstantInt *Len = dyn_cast<ConstantInt>(MTI->getLength());
|
|
|
|
if (Len == 0 || Len->getZExtValue() != AllocaSize || Offset != 0)
|
|
|
|
return false;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:38:19 +00:00
|
|
|
IsNotTrivial = true; // Can't be mem2reg'd.
|
|
|
|
continue;
|
2003-05-27 15:45:27 +00:00
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-07-25 23:14:22 +00:00
|
|
|
// If this is a lifetime intrinsic, we can handle it.
|
|
|
|
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(User)) {
|
|
|
|
if (II->getIntrinsicID() == Intrinsic::lifetime_start ||
|
|
|
|
II->getIntrinsicID() == Intrinsic::lifetime_end) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Otherwise, we cannot handle this!
|
|
|
|
return false;
|
2007-04-25 05:02:56 +00:00
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
return true;
|
2003-05-27 15:45:27 +00:00
|
|
|
}
|
2009-12-14 05:11:02 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// ConvertUsesToScalar - Convert all of the users of Ptr to use the new alloca
|
|
|
|
/// directly. This happens when we are converting an "integer union" to a
|
|
|
|
/// single integer scalar, or when we are converting a "vector union" to a
|
|
|
|
/// vector with insert/extractelement instructions.
|
|
|
|
///
|
|
|
|
/// Offset is an offset from the original alloca, in bits that need to be
|
|
|
|
/// shifted to the right. By the end of this, there should be no uses of Ptr.
|
|
|
|
void ConvertToScalarInfo::ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI,
|
|
|
|
uint64_t Offset) {
|
|
|
|
while (!Ptr->use_empty()) {
|
|
|
|
Instruction *User = cast<Instruction>(Ptr->use_back());
|
2009-12-18 20:14:40 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (BitCastInst *CI = dyn_cast<BitCastInst>(User)) {
|
|
|
|
ConvertUsesToScalar(CI, NewAI, Offset);
|
|
|
|
CI->eraseFromParent();
|
|
|
|
continue;
|
|
|
|
}
|
2009-12-18 20:14:40 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(User)) {
|
|
|
|
// Compute the offset that this GEP adds to the pointer.
|
|
|
|
SmallVector<Value*, 8> Indices(GEP->op_begin()+1, GEP->op_end());
|
|
|
|
uint64_t GEPOffset = TD.getIndexedOffset(GEP->getPointerOperandType(),
|
2011-07-19 14:01:37 +00:00
|
|
|
Indices);
|
2010-04-16 00:24:57 +00:00
|
|
|
ConvertUsesToScalar(GEP, NewAI, Offset+GEPOffset*8);
|
|
|
|
GEP->eraseFromParent();
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-12-26 22:57:41 +00:00
|
|
|
IRBuilder<> Builder(User);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(User)) {
|
|
|
|
// The load is a bit extract from NewAI shifted right by Offset bits.
|
2011-09-27 20:39:19 +00:00
|
|
|
Value *LoadedVal = Builder.CreateLoad(NewAI);
|
2010-04-16 00:24:57 +00:00
|
|
|
Value *NewLoadVal
|
|
|
|
= ConvertScalar_ExtractValue(LoadedVal, LI->getType(), Offset, Builder);
|
|
|
|
LI->replaceAllUsesWith(NewLoadVal);
|
|
|
|
LI->eraseFromParent();
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (StoreInst *SI = dyn_cast<StoreInst>(User)) {
|
|
|
|
assert(SI->getOperand(0) != Ptr && "Consistency error!");
|
|
|
|
Instruction *Old = Builder.CreateLoad(NewAI, NewAI->getName()+".in");
|
|
|
|
Value *New = ConvertScalar_InsertValue(SI->getOperand(0), Old, Offset,
|
|
|
|
Builder);
|
|
|
|
Builder.CreateStore(New, NewAI);
|
|
|
|
SI->eraseFromParent();
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If the load we just inserted is now dead, then the inserted store
|
|
|
|
// overwrote the entire thing.
|
|
|
|
if (Old->use_empty())
|
|
|
|
Old->eraseFromParent();
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If this is a constant sized memset of a constant value (e.g. 0) we can
|
|
|
|
// transform it into a store of the expanded constant value.
|
|
|
|
if (MemSetInst *MSI = dyn_cast<MemSetInst>(User)) {
|
|
|
|
assert(MSI->getRawDest() == Ptr && "Consistency error!");
|
2012-03-23 08:29:04 +00:00
|
|
|
int64_t SNumBytes = cast<ConstantInt>(MSI->getLength())->getSExtValue();
|
2012-03-22 03:46:58 +00:00
|
|
|
if (SNumBytes > 0 && (SNumBytes >> 32) == 0) {
|
2012-03-15 00:05:31 +00:00
|
|
|
unsigned NumBytes = static_cast<unsigned>(SNumBytes);
|
2010-04-16 00:24:57 +00:00
|
|
|
unsigned Val = cast<ConstantInt>(MSI->getValue())->getZExtValue();
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Compute the value replicated the right number of times.
|
|
|
|
APInt APVal(NumBytes*8, Val);
|
2009-12-16 20:09:53 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Splat the value if non-zero.
|
|
|
|
if (Val)
|
|
|
|
for (unsigned i = 1; i != NumBytes; ++i)
|
|
|
|
APVal |= APVal << 8;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
Instruction *Old = Builder.CreateLoad(NewAI, NewAI->getName()+".in");
|
|
|
|
Value *New = ConvertScalar_InsertValue(
|
|
|
|
ConstantInt::get(User->getContext(), APVal),
|
|
|
|
Old, Offset, Builder);
|
|
|
|
Builder.CreateStore(New, NewAI);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If the load we just inserted is now dead, then the memset overwrote
|
|
|
|
// the entire thing.
|
|
|
|
if (Old->use_empty())
|
2011-01-13 20:59:44 +00:00
|
|
|
Old->eraseFromParent();
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
|
|
|
MSI->eraseFromParent();
|
|
|
|
continue;
|
2009-12-18 20:14:40 +00:00
|
|
|
}
|
2009-12-16 10:56:17 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If this is a memcpy or memmove into or out of the whole allocation, we
|
|
|
|
// can handle it like a load or store of the scalar type.
|
|
|
|
if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(User)) {
|
|
|
|
assert(Offset == 0 && "must be store to start of alloca");
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If the source and destination are both to the same alloca, then this is
|
|
|
|
// a noop copy-to-self, just delete it. Otherwise, emit a load and store
|
|
|
|
// as appropriate.
|
2011-01-24 18:53:32 +00:00
|
|
|
AllocaInst *OrigAI = cast<AllocaInst>(GetUnderlyingObject(Ptr, &TD, 0));
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-01-24 18:53:32 +00:00
|
|
|
if (GetUnderlyingObject(MTI->getSource(), &TD, 0) != OrigAI) {
|
2010-04-16 00:24:57 +00:00
|
|
|
// Dest must be OrigAI, change this to be a load from the original
|
|
|
|
// pointer (bitcasted), then a store to our new alloca.
|
|
|
|
assert(MTI->getRawDest() == Ptr && "Neither use is of pointer?");
|
|
|
|
Value *SrcPtr = MTI->getSource();
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType* SPTy = cast<PointerType>(SrcPtr->getType());
|
|
|
|
PointerType* AIPTy = cast<PointerType>(NewAI->getType());
|
2010-12-23 01:41:32 +00:00
|
|
|
if (SPTy->getAddressSpace() != AIPTy->getAddressSpace()) {
|
|
|
|
AIPTy = PointerType::get(AIPTy->getElementType(),
|
|
|
|
SPTy->getAddressSpace());
|
|
|
|
}
|
|
|
|
SrcPtr = Builder.CreateBitCast(SrcPtr, AIPTy);
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
LoadInst *SrcVal = Builder.CreateLoad(SrcPtr, "srcval");
|
|
|
|
SrcVal->setAlignment(MTI->getAlignment());
|
|
|
|
Builder.CreateStore(SrcVal, NewAI);
|
2011-01-24 18:53:32 +00:00
|
|
|
} else if (GetUnderlyingObject(MTI->getDest(), &TD, 0) != OrigAI) {
|
2010-04-16 00:24:57 +00:00
|
|
|
// Src must be OrigAI, change this to be a load from NewAI then a store
|
|
|
|
// through the original dest pointer (bitcasted).
|
|
|
|
assert(MTI->getRawSource() == Ptr && "Neither use is of pointer?");
|
|
|
|
LoadInst *SrcVal = Builder.CreateLoad(NewAI, "srcval");
|
2009-12-18 20:14:40 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType* DPTy = cast<PointerType>(MTI->getDest()->getType());
|
|
|
|
PointerType* AIPTy = cast<PointerType>(NewAI->getType());
|
2010-12-23 01:41:32 +00:00
|
|
|
if (DPTy->getAddressSpace() != AIPTy->getAddressSpace()) {
|
|
|
|
AIPTy = PointerType::get(AIPTy->getElementType(),
|
|
|
|
DPTy->getAddressSpace());
|
|
|
|
}
|
|
|
|
Value *DstPtr = Builder.CreateBitCast(MTI->getDest(), AIPTy);
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
StoreInst *NewStore = Builder.CreateStore(SrcVal, DstPtr);
|
|
|
|
NewStore->setAlignment(MTI->getAlignment());
|
|
|
|
} else {
|
|
|
|
// Noop transfer. Src == Dst
|
|
|
|
}
|
2008-10-06 16:23:31 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
MTI->eraseFromParent();
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-07-25 23:14:22 +00:00
|
|
|
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(User)) {
|
|
|
|
if (II->getIntrinsicID() == Intrinsic::lifetime_start ||
|
|
|
|
II->getIntrinsicID() == Intrinsic::lifetime_end) {
|
|
|
|
// There's no need to preserve these, as the resulting alloca will be
|
|
|
|
// converted to a register anyways.
|
|
|
|
II->eraseFromParent();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
llvm_unreachable("Unsupported operation!");
|
2008-08-23 05:21:06 +00:00
|
|
|
}
|
2009-12-16 20:09:53 +00:00
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// ConvertScalar_ExtractValue - Extract a value of type ToType from an integer
|
|
|
|
/// or vector value FromVal, extracting the bits from the offset specified by
|
|
|
|
/// Offset. This returns the value, which is of type ToType.
|
|
|
|
///
|
|
|
|
/// This happens when we are converting an "integer union" to a single
|
|
|
|
/// integer scalar, or when we are converting a "vector union" to a vector with
|
|
|
|
/// insert/extractelement instructions.
|
|
|
|
///
|
|
|
|
/// Offset is an offset from the original alloca, in bits that need to be
|
|
|
|
/// shifted to the right.
|
|
|
|
Value *ConvertToScalarInfo::
|
2011-07-18 04:54:35 +00:00
|
|
|
ConvertScalar_ExtractValue(Value *FromVal, Type *ToType,
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t Offset, IRBuilder<> &Builder) {
|
|
|
|
// If the load is of the whole new alloca, no conversion is needed.
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *FromType = FromVal->getType();
|
2011-04-13 21:40:02 +00:00
|
|
|
if (FromType == ToType && Offset == 0)
|
2010-04-16 00:24:57 +00:00
|
|
|
return FromVal;
|
|
|
|
|
|
|
|
// If the result alloca is a vector type, this is either an element
|
|
|
|
// access or a bitcast to another vector type of the same size.
|
2011-07-18 04:54:35 +00:00
|
|
|
if (VectorType *VTy = dyn_cast<VectorType>(FromType)) {
|
2011-06-08 22:08:31 +00:00
|
|
|
unsigned FromTypeSize = TD.getTypeAllocSize(FromType);
|
2011-03-29 05:19:52 +00:00
|
|
|
unsigned ToTypeSize = TD.getTypeAllocSize(ToType);
|
2011-10-11 06:10:30 +00:00
|
|
|
if (FromTypeSize == ToTypeSize)
|
2011-09-27 20:39:19 +00:00
|
|
|
return Builder.CreateBitCast(FromVal, ToType);
|
2010-04-16 00:24:57 +00:00
|
|
|
|
|
|
|
// Otherwise it must be an element access.
|
|
|
|
unsigned Elt = 0;
|
|
|
|
if (Offset) {
|
|
|
|
unsigned EltSize = TD.getTypeAllocSizeInBits(VTy->getElementType());
|
|
|
|
Elt = Offset/EltSize;
|
|
|
|
assert(EltSize*Elt == Offset && "Invalid modulus in validity checking");
|
2009-12-18 20:14:40 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
// Return the element extracted out of it.
|
2011-09-27 20:39:19 +00:00
|
|
|
Value *V = Builder.CreateExtractElement(FromVal, Builder.getInt32(Elt));
|
2010-04-16 00:24:57 +00:00
|
|
|
if (V->getType() != ToType)
|
2011-09-27 20:39:19 +00:00
|
|
|
V = Builder.CreateBitCast(V, ToType);
|
2010-04-16 00:24:57 +00:00
|
|
|
return V;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If ToType is a first class aggregate, extract out each of the pieces and
|
|
|
|
// use insertvalue's to form the FCA.
|
2011-07-18 04:54:35 +00:00
|
|
|
if (StructType *ST = dyn_cast<StructType>(ToType)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
const StructLayout &Layout = *TD.getStructLayout(ST);
|
|
|
|
Value *Res = UndefValue::get(ST);
|
|
|
|
for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) {
|
|
|
|
Value *Elt = ConvertScalar_ExtractValue(FromVal, ST->getElementType(i),
|
|
|
|
Offset+Layout.getElementOffsetInBits(i),
|
|
|
|
Builder);
|
2011-09-27 20:39:19 +00:00
|
|
|
Res = Builder.CreateInsertValue(Res, Elt, i);
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
|
|
|
return Res;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
if (ArrayType *AT = dyn_cast<ArrayType>(ToType)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t EltSize = TD.getTypeAllocSizeInBits(AT->getElementType());
|
|
|
|
Value *Res = UndefValue::get(AT);
|
|
|
|
for (unsigned i = 0, e = AT->getNumElements(); i != e; ++i) {
|
|
|
|
Value *Elt = ConvertScalar_ExtractValue(FromVal, AT->getElementType(),
|
|
|
|
Offset+i*EltSize, Builder);
|
2011-09-27 20:39:19 +00:00
|
|
|
Res = Builder.CreateInsertValue(Res, Elt, i);
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
|
|
|
return Res;
|
2009-12-18 20:14:40 +00:00
|
|
|
}
|
2009-12-16 20:09:53 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Otherwise, this must be a union that was converted to an integer value.
|
2011-07-18 04:54:35 +00:00
|
|
|
IntegerType *NTy = cast<IntegerType>(FromVal->getType());
|
2009-12-18 20:14:40 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If this is a big-endian system and the load is narrower than the
|
|
|
|
// full alloca type, we need to do a shift to get the right bits.
|
|
|
|
int ShAmt = 0;
|
|
|
|
if (TD.isBigEndian()) {
|
|
|
|
// On big-endian machines, the lowest bit is stored at the bit offset
|
|
|
|
// from the pointer given by getTypeStoreSizeInBits. This matters for
|
|
|
|
// integers with a bitwidth that is not a multiple of 8.
|
|
|
|
ShAmt = TD.getTypeStoreSizeInBits(NTy) -
|
|
|
|
TD.getTypeStoreSizeInBits(ToType) - Offset;
|
2009-12-18 20:14:40 +00:00
|
|
|
} else {
|
2010-04-16 00:24:57 +00:00
|
|
|
ShAmt = Offset;
|
2009-12-18 20:14:40 +00:00
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Note: we support negative bitwidths (with shl) which are not defined.
|
|
|
|
// We do this to support (f.e.) loads off the end of a structure where
|
|
|
|
// only some bits are used.
|
|
|
|
if (ShAmt > 0 && (unsigned)ShAmt < NTy->getBitWidth())
|
|
|
|
FromVal = Builder.CreateLShr(FromVal,
|
2011-09-27 20:39:19 +00:00
|
|
|
ConstantInt::get(FromVal->getType(), ShAmt));
|
2010-04-16 00:24:57 +00:00
|
|
|
else if (ShAmt < 0 && (unsigned)-ShAmt < NTy->getBitWidth())
|
2011-01-13 20:59:44 +00:00
|
|
|
FromVal = Builder.CreateShl(FromVal,
|
2011-09-27 20:39:19 +00:00
|
|
|
ConstantInt::get(FromVal->getType(), -ShAmt));
|
2009-12-18 20:14:40 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Finally, unconditionally truncate the integer to the right width.
|
|
|
|
unsigned LIBitWidth = TD.getTypeSizeInBits(ToType);
|
|
|
|
if (LIBitWidth < NTy->getBitWidth())
|
|
|
|
FromVal =
|
2011-01-13 20:59:44 +00:00
|
|
|
Builder.CreateTrunc(FromVal, IntegerType::get(FromVal->getContext(),
|
2011-09-27 20:39:19 +00:00
|
|
|
LIBitWidth));
|
2010-04-16 00:24:57 +00:00
|
|
|
else if (LIBitWidth > NTy->getBitWidth())
|
|
|
|
FromVal =
|
2011-01-13 20:59:44 +00:00
|
|
|
Builder.CreateZExt(FromVal, IntegerType::get(FromVal->getContext(),
|
2011-09-27 20:39:19 +00:00
|
|
|
LIBitWidth));
|
2010-04-16 00:24:57 +00:00
|
|
|
|
|
|
|
// If the result is an integer, this is a trunc or bitcast.
|
|
|
|
if (ToType->isIntegerTy()) {
|
|
|
|
// Should be done.
|
|
|
|
} else if (ToType->isFloatingPointTy() || ToType->isVectorTy()) {
|
|
|
|
// Just do a bitcast, we know the sizes match up.
|
2011-09-27 20:39:19 +00:00
|
|
|
FromVal = Builder.CreateBitCast(FromVal, ToType);
|
2010-04-16 00:24:57 +00:00
|
|
|
} else {
|
|
|
|
// Otherwise must be a pointer.
|
2011-09-27 20:39:19 +00:00
|
|
|
FromVal = Builder.CreateIntToPtr(FromVal, ToType);
|
2007-03-05 07:52:57 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
assert(FromVal->getType() == ToType && "Didn't convert right?");
|
|
|
|
return FromVal;
|
2007-03-05 07:52:57 +00:00
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// ConvertScalar_InsertValue - Insert the value "SV" into the existing integer
|
|
|
|
/// or vector value "Old" at the offset specified by Offset.
|
|
|
|
///
|
|
|
|
/// This happens when we are converting an "integer union" to a
|
|
|
|
/// single integer scalar, or when we are converting a "vector union" to a
|
|
|
|
/// vector with insert/extractelement instructions.
|
|
|
|
///
|
|
|
|
/// Offset is an offset from the original alloca, in bits that need to be
|
|
|
|
/// shifted to the right.
|
|
|
|
Value *ConvertToScalarInfo::
|
|
|
|
ConvertScalar_InsertValue(Value *SV, Value *Old,
|
|
|
|
uint64_t Offset, IRBuilder<> &Builder) {
|
|
|
|
// Convert the stored type to the actual type, shift it left to insert
|
|
|
|
// then 'or' into place.
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *AllocaType = Old->getType();
|
2010-04-16 00:24:57 +00:00
|
|
|
LLVMContext &Context = Old->getContext();
|
2009-12-16 20:09:53 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
if (VectorType *VTy = dyn_cast<VectorType>(AllocaType)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t VecSize = TD.getTypeAllocSizeInBits(VTy);
|
|
|
|
uint64_t ValSize = TD.getTypeAllocSizeInBits(SV->getType());
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Changing the whole vector with memset or with an access of a different
|
|
|
|
// vector type?
|
2011-10-11 06:10:30 +00:00
|
|
|
if (ValSize == VecSize)
|
2011-09-27 20:39:19 +00:00
|
|
|
return Builder.CreateBitCast(SV, AllocaType);
|
2011-03-09 05:43:05 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Must be an element insertion.
|
2011-10-23 07:02:10 +00:00
|
|
|
Type *EltTy = VTy->getElementType();
|
|
|
|
if (SV->getType() != EltTy)
|
|
|
|
SV = Builder.CreateBitCast(SV, EltTy);
|
|
|
|
uint64_t EltSize = TD.getTypeAllocSizeInBits(EltTy);
|
2010-04-16 00:24:57 +00:00
|
|
|
unsigned Elt = Offset/EltSize;
|
2011-09-27 20:39:19 +00:00
|
|
|
return Builder.CreateInsertElement(Old, SV, Builder.getInt32(Elt));
|
2009-12-18 20:14:40 +00:00
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If SV is a first-class aggregate value, insert each value recursively.
|
2011-07-18 04:54:35 +00:00
|
|
|
if (StructType *ST = dyn_cast<StructType>(SV->getType())) {
|
2010-04-16 00:24:57 +00:00
|
|
|
const StructLayout &Layout = *TD.getStructLayout(ST);
|
|
|
|
for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) {
|
2011-09-27 20:39:19 +00:00
|
|
|
Value *Elt = Builder.CreateExtractValue(SV, i);
|
2011-01-13 20:59:44 +00:00
|
|
|
Old = ConvertScalar_InsertValue(Elt, Old,
|
2010-04-16 00:24:57 +00:00
|
|
|
Offset+Layout.getElementOffsetInBits(i),
|
|
|
|
Builder);
|
|
|
|
}
|
|
|
|
return Old;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
if (ArrayType *AT = dyn_cast<ArrayType>(SV->getType())) {
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t EltSize = TD.getTypeAllocSizeInBits(AT->getElementType());
|
|
|
|
for (unsigned i = 0, e = AT->getNumElements(); i != e; ++i) {
|
2011-09-27 20:39:19 +00:00
|
|
|
Value *Elt = Builder.CreateExtractValue(SV, i);
|
2010-04-16 00:24:57 +00:00
|
|
|
Old = ConvertScalar_InsertValue(Elt, Old, Offset+i*EltSize, Builder);
|
|
|
|
}
|
|
|
|
return Old;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If SV is a float, convert it to the appropriate integer type.
|
|
|
|
// If it is a pointer, do the same.
|
|
|
|
unsigned SrcWidth = TD.getTypeSizeInBits(SV->getType());
|
|
|
|
unsigned DestWidth = TD.getTypeSizeInBits(AllocaType);
|
|
|
|
unsigned SrcStoreWidth = TD.getTypeStoreSizeInBits(SV->getType());
|
|
|
|
unsigned DestStoreWidth = TD.getTypeStoreSizeInBits(AllocaType);
|
|
|
|
if (SV->getType()->isFloatingPointTy() || SV->getType()->isVectorTy())
|
2011-09-27 20:39:19 +00:00
|
|
|
SV = Builder.CreateBitCast(SV, IntegerType::get(SV->getContext(),SrcWidth));
|
2010-04-16 00:24:57 +00:00
|
|
|
else if (SV->getType()->isPointerTy())
|
2011-09-27 20:39:19 +00:00
|
|
|
SV = Builder.CreatePtrToInt(SV, TD.getIntPtrType(SV->getContext()));
|
2010-04-16 00:24:57 +00:00
|
|
|
|
|
|
|
// Zero extend or truncate the value if needed.
|
|
|
|
if (SV->getType() != AllocaType) {
|
|
|
|
if (SV->getType()->getPrimitiveSizeInBits() <
|
|
|
|
AllocaType->getPrimitiveSizeInBits())
|
2011-09-27 20:39:19 +00:00
|
|
|
SV = Builder.CreateZExt(SV, AllocaType);
|
2010-04-16 00:24:57 +00:00
|
|
|
else {
|
|
|
|
// Truncation may be needed if storing more than the alloca can hold
|
|
|
|
// (undefined behavior).
|
2011-09-27 20:39:19 +00:00
|
|
|
SV = Builder.CreateTrunc(SV, AllocaType);
|
2010-04-16 00:24:57 +00:00
|
|
|
SrcWidth = DestWidth;
|
|
|
|
SrcStoreWidth = DestStoreWidth;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this is a big-endian system and the store is narrower than the
|
|
|
|
// full alloca type, we need to do a shift to get the right bits.
|
|
|
|
int ShAmt = 0;
|
|
|
|
if (TD.isBigEndian()) {
|
|
|
|
// On big-endian machines, the lowest bit is stored at the bit offset
|
|
|
|
// from the pointer given by getTypeStoreSizeInBits. This matters for
|
|
|
|
// integers with a bitwidth that is not a multiple of 8.
|
|
|
|
ShAmt = DestStoreWidth - SrcStoreWidth - Offset;
|
|
|
|
} else {
|
|
|
|
ShAmt = Offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Note: we support negative bitwidths (with shr) which are not defined.
|
|
|
|
// We do this to support (f.e.) stores off the end of a structure where
|
|
|
|
// only some bits in the structure are set.
|
|
|
|
APInt Mask(APInt::getLowBitsSet(DestWidth, SrcWidth));
|
|
|
|
if (ShAmt > 0 && (unsigned)ShAmt < DestWidth) {
|
2011-09-27 20:39:19 +00:00
|
|
|
SV = Builder.CreateShl(SV, ConstantInt::get(SV->getType(), ShAmt));
|
2010-04-16 00:24:57 +00:00
|
|
|
Mask <<= ShAmt;
|
|
|
|
} else if (ShAmt < 0 && (unsigned)-ShAmt < DestWidth) {
|
2011-09-27 20:39:19 +00:00
|
|
|
SV = Builder.CreateLShr(SV, ConstantInt::get(SV->getType(), -ShAmt));
|
2010-04-16 00:24:57 +00:00
|
|
|
Mask = Mask.lshr(-ShAmt);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Mask out the bits we are about to insert from the old value, and or
|
|
|
|
// in the new bits.
|
|
|
|
if (SrcWidth != DestWidth) {
|
|
|
|
assert(DestWidth > SrcWidth);
|
|
|
|
Old = Builder.CreateAnd(Old, ConstantInt::get(Context, ~Mask), "mask");
|
|
|
|
SV = Builder.CreateOr(Old, SV, "ins");
|
|
|
|
}
|
|
|
|
return SV;
|
2009-12-18 20:14:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SRoA Driver
|
|
|
|
//===----------------------------------------------------------------------===//
|
2009-12-18 20:14:40 +00:00
|
|
|
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
bool SROA::runOnFunction(Function &F) {
|
|
|
|
TD = getAnalysisIfAvailable<TargetData>();
|
2009-12-18 20:14:40 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
bool Changed = performPromotion(F);
|
2009-12-18 20:14:40 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// FIXME: ScalarRepl currently depends on TargetData more than it
|
|
|
|
// theoretically needs to. It should be refactored in order to support
|
|
|
|
// target-independent IR. Until this is done, just skip the actual
|
|
|
|
// scalar-replacement portion of this pass.
|
|
|
|
if (!TD) return Changed;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
bool LocalChange = performScalarRepl(F);
|
|
|
|
if (!LocalChange) break; // No need to repromote if no scalarrepl
|
|
|
|
Changed = true;
|
|
|
|
LocalChange = performPromotion(F);
|
|
|
|
if (!LocalChange) break; // No need to re-scalarrepl if no promotion
|
2009-12-16 20:09:53 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
|
|
|
|
return Changed;
|
2009-01-07 07:18:45 +00:00
|
|
|
}
|
|
|
|
|
2011-01-14 19:50:47 +00:00
|
|
|
namespace {
|
|
|
|
class AllocaPromoter : public LoadAndStorePromoter {
|
|
|
|
AllocaInst *AI;
|
2011-07-06 21:09:55 +00:00
|
|
|
DIBuilder *DIB;
|
2011-07-06 22:06:11 +00:00
|
|
|
SmallVector<DbgDeclareInst *, 4> DDIs;
|
|
|
|
SmallVector<DbgValueInst *, 4> DVIs;
|
2011-01-14 19:50:47 +00:00
|
|
|
public:
|
2011-05-24 03:10:43 +00:00
|
|
|
AllocaPromoter(const SmallVectorImpl<Instruction*> &Insts, SSAUpdater &S,
|
2011-07-06 21:09:55 +00:00
|
|
|
DIBuilder *DB)
|
2011-07-06 22:06:11 +00:00
|
|
|
: LoadAndStorePromoter(Insts, S), AI(0), DIB(DB) {}
|
2011-01-14 07:50:47 +00:00
|
|
|
|
2011-01-15 00:12:35 +00:00
|
|
|
void run(AllocaInst *AI, const SmallVectorImpl<Instruction*> &Insts) {
|
2011-01-14 19:50:47 +00:00
|
|
|
// Remember which alloca we're promoting (for isInstInList).
|
|
|
|
this->AI = AI;
|
2011-12-26 23:12:42 +00:00
|
|
|
if (MDNode *DebugNode = MDNode::getIfExists(AI->getContext(), AI)) {
|
2011-07-06 22:06:11 +00:00
|
|
|
for (Value::use_iterator UI = DebugNode->use_begin(),
|
|
|
|
E = DebugNode->use_end(); UI != E; ++UI)
|
|
|
|
if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(*UI))
|
|
|
|
DDIs.push_back(DDI);
|
|
|
|
else if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(*UI))
|
|
|
|
DVIs.push_back(DVI);
|
2011-12-26 23:12:42 +00:00
|
|
|
}
|
2011-07-06 22:06:11 +00:00
|
|
|
|
2011-01-15 00:12:35 +00:00
|
|
|
LoadAndStorePromoter::run(Insts);
|
2011-01-14 19:50:47 +00:00
|
|
|
AI->eraseFromParent();
|
2011-07-06 22:06:11 +00:00
|
|
|
for (SmallVector<DbgDeclareInst *, 4>::iterator I = DDIs.begin(),
|
|
|
|
E = DDIs.end(); I != E; ++I) {
|
|
|
|
DbgDeclareInst *DDI = *I;
|
2011-07-06 21:09:55 +00:00
|
|
|
DDI->eraseFromParent();
|
2011-07-06 22:06:11 +00:00
|
|
|
}
|
|
|
|
for (SmallVector<DbgValueInst *, 4>::iterator I = DVIs.begin(),
|
|
|
|
E = DVIs.end(); I != E; ++I) {
|
|
|
|
DbgValueInst *DVI = *I;
|
|
|
|
DVI->eraseFromParent();
|
|
|
|
}
|
2011-01-14 07:50:47 +00:00
|
|
|
}
|
|
|
|
|
2011-01-14 19:50:47 +00:00
|
|
|
virtual bool isInstInList(Instruction *I,
|
|
|
|
const SmallVectorImpl<Instruction*> &Insts) const {
|
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(I))
|
|
|
|
return LI->getOperand(0) == AI;
|
|
|
|
return cast<StoreInst>(I)->getPointerOperand() == AI;
|
2011-01-14 07:50:47 +00:00
|
|
|
}
|
2011-07-06 21:09:55 +00:00
|
|
|
|
2011-07-06 22:06:11 +00:00
|
|
|
virtual void updateDebugInfo(Instruction *Inst) const {
|
|
|
|
for (SmallVector<DbgDeclareInst *, 4>::const_iterator I = DDIs.begin(),
|
|
|
|
E = DDIs.end(); I != E; ++I) {
|
|
|
|
DbgDeclareInst *DDI = *I;
|
|
|
|
if (StoreInst *SI = dyn_cast<StoreInst>(Inst))
|
|
|
|
ConvertDebugDeclareToDebugValue(DDI, SI, *DIB);
|
|
|
|
else if (LoadInst *LI = dyn_cast<LoadInst>(Inst))
|
|
|
|
ConvertDebugDeclareToDebugValue(DDI, LI, *DIB);
|
|
|
|
}
|
|
|
|
for (SmallVector<DbgValueInst *, 4>::const_iterator I = DVIs.begin(),
|
|
|
|
E = DVIs.end(); I != E; ++I) {
|
|
|
|
DbgValueInst *DVI = *I;
|
2012-02-23 17:42:19 +00:00
|
|
|
Value *Arg = NULL;
|
2011-07-06 22:06:11 +00:00
|
|
|
if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
|
|
|
|
// If an argument is zero extended then use argument directly. The ZExt
|
|
|
|
// may be zapped by an optimization pass in future.
|
|
|
|
if (ZExtInst *ZExt = dyn_cast<ZExtInst>(SI->getOperand(0)))
|
2012-02-23 17:42:19 +00:00
|
|
|
Arg = dyn_cast<Argument>(ZExt->getOperand(0));
|
2011-07-06 22:06:11 +00:00
|
|
|
if (SExtInst *SExt = dyn_cast<SExtInst>(SI->getOperand(0)))
|
2012-02-23 17:42:19 +00:00
|
|
|
Arg = dyn_cast<Argument>(SExt->getOperand(0));
|
|
|
|
if (!Arg)
|
|
|
|
Arg = SI->getOperand(0);
|
2011-07-06 22:06:11 +00:00
|
|
|
} else if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
|
2012-02-23 17:42:19 +00:00
|
|
|
Arg = LI->getOperand(0);
|
|
|
|
} else {
|
|
|
|
continue;
|
2011-07-06 22:06:11 +00:00
|
|
|
}
|
2012-02-23 17:42:19 +00:00
|
|
|
Instruction *DbgVal =
|
|
|
|
DIB->insertDbgValueIntrinsic(Arg, 0, DIVariable(DVI->getVariable()),
|
|
|
|
Inst);
|
|
|
|
DbgVal->setDebugLoc(DVI->getDebugLoc());
|
2011-07-06 22:06:11 +00:00
|
|
|
}
|
2011-07-06 21:09:55 +00:00
|
|
|
}
|
2011-01-14 19:50:47 +00:00
|
|
|
};
|
|
|
|
} // end anon namespace
|
2009-12-08 18:22:03 +00:00
|
|
|
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
/// isSafeSelectToSpeculate - Select instructions that use an alloca and are
|
|
|
|
/// subsequently loaded can be rewritten to load both input pointers and then
|
|
|
|
/// select between the result, allowing the load of the alloca to be promoted.
|
|
|
|
/// From this:
|
|
|
|
/// %P2 = select i1 %cond, i32* %Alloca, i32* %Other
|
|
|
|
/// %V = load i32* %P2
|
|
|
|
/// to:
|
|
|
|
/// %V1 = load i32* %Alloca -> will be mem2reg'd
|
|
|
|
/// %V2 = load i32* %Other
|
2011-01-24 01:07:11 +00:00
|
|
|
/// %V = select i1 %cond, i32 %V1, i32 %V2
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
///
|
|
|
|
/// We can do this to a select if its only uses are loads and if the operand to
|
|
|
|
/// the select can be loaded unconditionally.
|
|
|
|
static bool isSafeSelectToSpeculate(SelectInst *SI, const TargetData *TD) {
|
|
|
|
bool TDerefable = SI->getTrueValue()->isDereferenceablePointer();
|
|
|
|
bool FDerefable = SI->getFalseValue()->isDereferenceablePointer();
|
|
|
|
|
|
|
|
for (Value::use_iterator UI = SI->use_begin(), UE = SI->use_end();
|
|
|
|
UI != UE; ++UI) {
|
|
|
|
LoadInst *LI = dyn_cast<LoadInst>(*UI);
|
2011-09-12 20:23:13 +00:00
|
|
|
if (LI == 0 || !LI->isSimple()) return false;
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
|
2011-01-24 01:07:11 +00:00
|
|
|
// Both operands to the select need to be dereferencable, either absolutely
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
// (e.g. allocas) or at this point because we can see other accesses to it.
|
|
|
|
if (!TDerefable && !isSafeToLoadUnconditionally(SI->getTrueValue(), LI,
|
|
|
|
LI->getAlignment(), TD))
|
|
|
|
return false;
|
|
|
|
if (!FDerefable && !isSafeToLoadUnconditionally(SI->getFalseValue(), LI,
|
|
|
|
LI->getAlignment(), TD))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-01-24 01:07:11 +00:00
|
|
|
/// isSafePHIToSpeculate - PHI instructions that use an alloca and are
|
|
|
|
/// subsequently loaded can be rewritten to load both input pointers in the pred
|
|
|
|
/// blocks and then PHI the results, allowing the load of the alloca to be
|
|
|
|
/// promoted.
|
|
|
|
/// From this:
|
|
|
|
/// %P2 = phi [i32* %Alloca, i32* %Other]
|
|
|
|
/// %V = load i32* %P2
|
|
|
|
/// to:
|
|
|
|
/// %V1 = load i32* %Alloca -> will be mem2reg'd
|
|
|
|
/// ...
|
|
|
|
/// %V2 = load i32* %Other
|
|
|
|
/// ...
|
|
|
|
/// %V = phi [i32 %V1, i32 %V2]
|
|
|
|
///
|
|
|
|
/// We can do this to a select if its only uses are loads and if the operand to
|
|
|
|
/// the select can be loaded unconditionally.
|
|
|
|
static bool isSafePHIToSpeculate(PHINode *PN, const TargetData *TD) {
|
|
|
|
// For now, we can only do this promotion if the load is in the same block as
|
|
|
|
// the PHI, and if there are no stores between the phi and load.
|
|
|
|
// TODO: Allow recursive phi users.
|
|
|
|
// TODO: Allow stores.
|
|
|
|
BasicBlock *BB = PN->getParent();
|
|
|
|
unsigned MaxAlign = 0;
|
|
|
|
for (Value::use_iterator UI = PN->use_begin(), UE = PN->use_end();
|
|
|
|
UI != UE; ++UI) {
|
|
|
|
LoadInst *LI = dyn_cast<LoadInst>(*UI);
|
2011-09-12 20:23:13 +00:00
|
|
|
if (LI == 0 || !LI->isSimple()) return false;
|
2011-01-24 01:07:11 +00:00
|
|
|
|
|
|
|
// For now we only allow loads in the same block as the PHI. This is a
|
|
|
|
// common case that happens when instcombine merges two loads through a PHI.
|
|
|
|
if (LI->getParent() != BB) return false;
|
|
|
|
|
|
|
|
// Ensure that there are no instructions between the PHI and the load that
|
|
|
|
// could store.
|
|
|
|
for (BasicBlock::iterator BBI = PN; &*BBI != LI; ++BBI)
|
|
|
|
if (BBI->mayWriteToMemory())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
MaxAlign = std::max(MaxAlign, LI->getAlignment());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, we know that we have one or more loads in the same block as the PHI.
|
|
|
|
// We can transform this if it is safe to push the loads into the predecessor
|
|
|
|
// blocks. The only thing to watch out for is that we can't put a possibly
|
|
|
|
// trapping load in the predecessor if it is a critical edge.
|
|
|
|
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
|
|
|
|
BasicBlock *Pred = PN->getIncomingBlock(i);
|
2011-09-22 18:56:30 +00:00
|
|
|
Value *InVal = PN->getIncomingValue(i);
|
|
|
|
|
|
|
|
// If the terminator of the predecessor has side-effects (an invoke),
|
|
|
|
// there is no safe place to put a load in the predecessor.
|
|
|
|
if (Pred->getTerminator()->mayHaveSideEffects())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// If the value is produced by the terminator of the predecessor
|
|
|
|
// (an invoke), there is no valid place to put a load in the predecessor.
|
|
|
|
if (Pred->getTerminator() == InVal)
|
|
|
|
return false;
|
2011-01-24 01:07:11 +00:00
|
|
|
|
|
|
|
// If the predecessor has a single successor, then the edge isn't critical.
|
|
|
|
if (Pred->getTerminator()->getNumSuccessors() == 1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// If this pointer is always safe to load, or if we can prove that there is
|
|
|
|
// already a load in the block, then we can move the load to the pred block.
|
|
|
|
if (InVal->isDereferenceablePointer() ||
|
|
|
|
isSafeToLoadUnconditionally(InVal, Pred->getTerminator(), MaxAlign, TD))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
|
|
|
|
/// tryToMakeAllocaBePromotable - This returns true if the alloca only has
|
|
|
|
/// direct (non-volatile) loads and stores to it. If the alloca is close but
|
|
|
|
/// not quite there, this will transform the code to allow promotion. As such,
|
|
|
|
/// it is a non-pure predicate.
|
|
|
|
static bool tryToMakeAllocaBePromotable(AllocaInst *AI, const TargetData *TD) {
|
|
|
|
SetVector<Instruction*, SmallVector<Instruction*, 4>,
|
|
|
|
SmallPtrSet<Instruction*, 4> > InstsToRewrite;
|
|
|
|
|
|
|
|
for (Value::use_iterator UI = AI->use_begin(), UE = AI->use_end();
|
|
|
|
UI != UE; ++UI) {
|
|
|
|
User *U = *UI;
|
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
|
2011-09-12 20:23:13 +00:00
|
|
|
if (!LI->isSimple())
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
return false;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
|
2011-09-12 20:23:13 +00:00
|
|
|
if (SI->getOperand(0) == AI || !SI->isSimple())
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
return false; // Don't allow a store OF the AI, only INTO the AI.
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (SelectInst *SI = dyn_cast<SelectInst>(U)) {
|
|
|
|
// If the condition being selected on is a constant, fold the select, yes
|
|
|
|
// this does (rarely) happen early on.
|
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(SI->getCondition())) {
|
|
|
|
Value *Result = SI->getOperand(1+CI->isZero());
|
|
|
|
SI->replaceAllUsesWith(Result);
|
|
|
|
SI->eraseFromParent();
|
|
|
|
|
|
|
|
// This is very rare and we just scrambled the use list of AI, start
|
|
|
|
// over completely.
|
|
|
|
return tryToMakeAllocaBePromotable(AI, TD);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If it is safe to turn "load (select c, AI, ptr)" into a select of two
|
|
|
|
// loads, then we can transform this by rewriting the select.
|
|
|
|
if (!isSafeSelectToSpeculate(SI, TD))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
InstsToRewrite.insert(SI);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-01-24 01:07:11 +00:00
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(U)) {
|
|
|
|
if (PN->use_empty()) { // Dead PHIs can be stripped.
|
|
|
|
InstsToRewrite.insert(PN);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If it is safe to turn "load (phi [AI, ptr, ...])" into a PHI of loads
|
|
|
|
// in the pred blocks, then we can transform this by rewriting the PHI.
|
|
|
|
if (!isSafePHIToSpeculate(PN, TD))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
InstsToRewrite.insert(PN);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-07-25 23:14:22 +00:00
|
|
|
if (BitCastInst *BCI = dyn_cast<BitCastInst>(U)) {
|
|
|
|
if (onlyUsedByLifetimeMarkers(BCI)) {
|
|
|
|
InstsToRewrite.insert(BCI);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there are no instructions to rewrite, then all uses are load/stores and
|
|
|
|
// we're done!
|
|
|
|
if (InstsToRewrite.empty())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// If we have instructions that need to be rewritten for this to be promotable
|
|
|
|
// take care of it now.
|
|
|
|
for (unsigned i = 0, e = InstsToRewrite.size(); i != e; ++i) {
|
2011-07-25 23:14:22 +00:00
|
|
|
if (BitCastInst *BCI = dyn_cast<BitCastInst>(InstsToRewrite[i])) {
|
|
|
|
// This could only be a bitcast used by nothing but lifetime intrinsics.
|
|
|
|
for (BitCastInst::use_iterator I = BCI->use_begin(), E = BCI->use_end();
|
|
|
|
I != E;) {
|
|
|
|
Use &U = I.getUse();
|
|
|
|
++I;
|
|
|
|
cast<Instruction>(U.getUser())->eraseFromParent();
|
|
|
|
}
|
|
|
|
BCI->eraseFromParent();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-01-24 01:07:11 +00:00
|
|
|
if (SelectInst *SI = dyn_cast<SelectInst>(InstsToRewrite[i])) {
|
|
|
|
// Selects in InstsToRewrite only have load uses. Rewrite each as two
|
|
|
|
// loads with a new select.
|
|
|
|
while (!SI->use_empty()) {
|
|
|
|
LoadInst *LI = cast<LoadInst>(SI->use_back());
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
|
2011-01-24 01:07:11 +00:00
|
|
|
IRBuilder<> Builder(LI);
|
|
|
|
LoadInst *TrueLoad =
|
|
|
|
Builder.CreateLoad(SI->getTrueValue(), LI->getName()+".t");
|
|
|
|
LoadInst *FalseLoad =
|
2011-07-01 06:27:03 +00:00
|
|
|
Builder.CreateLoad(SI->getFalseValue(), LI->getName()+".f");
|
2011-01-24 01:07:11 +00:00
|
|
|
|
|
|
|
// Transfer alignment and TBAA info if present.
|
|
|
|
TrueLoad->setAlignment(LI->getAlignment());
|
|
|
|
FalseLoad->setAlignment(LI->getAlignment());
|
|
|
|
if (MDNode *Tag = LI->getMetadata(LLVMContext::MD_tbaa)) {
|
|
|
|
TrueLoad->setMetadata(LLVMContext::MD_tbaa, Tag);
|
|
|
|
FalseLoad->setMetadata(LLVMContext::MD_tbaa, Tag);
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *V = Builder.CreateSelect(SI->getCondition(), TrueLoad, FalseLoad);
|
|
|
|
V->takeName(LI);
|
|
|
|
LI->replaceAllUsesWith(V);
|
|
|
|
LI->eraseFromParent();
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
}
|
2011-01-24 01:07:11 +00:00
|
|
|
|
|
|
|
// Now that all the loads are gone, the select is gone too.
|
|
|
|
SI->eraseFromParent();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, we have a PHI node which allows us to push the loads into the
|
|
|
|
// predecessors.
|
|
|
|
PHINode *PN = cast<PHINode>(InstsToRewrite[i]);
|
|
|
|
if (PN->use_empty()) {
|
|
|
|
PN->eraseFromParent();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *LoadTy = cast<PointerType>(PN->getType())->getElementType();
|
2011-03-30 11:28:46 +00:00
|
|
|
PHINode *NewPN = PHINode::Create(LoadTy, PN->getNumIncomingValues(),
|
|
|
|
PN->getName()+".ld", PN);
|
2011-01-24 01:07:11 +00:00
|
|
|
|
|
|
|
// Get the TBAA tag and alignment to use from one of the loads. It doesn't
|
|
|
|
// matter which one we get and if any differ, it doesn't matter.
|
|
|
|
LoadInst *SomeLoad = cast<LoadInst>(PN->use_back());
|
|
|
|
MDNode *TBAATag = SomeLoad->getMetadata(LLVMContext::MD_tbaa);
|
|
|
|
unsigned Align = SomeLoad->getAlignment();
|
|
|
|
|
|
|
|
// Rewrite all loads of the PN to use the new PHI.
|
|
|
|
while (!PN->use_empty()) {
|
|
|
|
LoadInst *LI = cast<LoadInst>(PN->use_back());
|
|
|
|
LI->replaceAllUsesWith(NewPN);
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
LI->eraseFromParent();
|
|
|
|
}
|
|
|
|
|
2011-01-24 01:07:11 +00:00
|
|
|
// Inject loads into all of the pred blocks. Keep track of which blocks we
|
|
|
|
// insert them into in case we have multiple edges from the same block.
|
|
|
|
DenseMap<BasicBlock*, LoadInst*> InsertedLoads;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
|
|
|
|
BasicBlock *Pred = PN->getIncomingBlock(i);
|
|
|
|
LoadInst *&Load = InsertedLoads[Pred];
|
|
|
|
if (Load == 0) {
|
|
|
|
Load = new LoadInst(PN->getIncomingValue(i),
|
|
|
|
PN->getName() + "." + Pred->getName(),
|
|
|
|
Pred->getTerminator());
|
|
|
|
Load->setAlignment(Align);
|
|
|
|
if (TBAATag) Load->setMetadata(LLVMContext::MD_tbaa, TBAATag);
|
|
|
|
}
|
|
|
|
|
|
|
|
NewPN->addIncoming(Load, Pred);
|
|
|
|
}
|
|
|
|
|
|
|
|
PN->eraseFromParent();
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
++NumAdjusted;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
bool SROA::performPromotion(Function &F) {
|
|
|
|
std::vector<AllocaInst*> Allocas;
|
2011-01-14 07:50:47 +00:00
|
|
|
DominatorTree *DT = 0;
|
2011-01-18 03:53:26 +00:00
|
|
|
if (HasDomTree)
|
2011-01-14 07:50:47 +00:00
|
|
|
DT = &getAnalysis<DominatorTree>();
|
2009-12-18 20:14:40 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
BasicBlock &BB = F.getEntryBlock(); // Get the entry node for the function
|
2011-07-06 21:09:55 +00:00
|
|
|
DIBuilder DIB(*F.getParent());
|
2010-04-16 00:24:57 +00:00
|
|
|
bool Changed = false;
|
2011-01-15 00:12:35 +00:00
|
|
|
SmallVector<Instruction*, 64> Insts;
|
2010-04-16 00:24:57 +00:00
|
|
|
while (1) {
|
|
|
|
Allocas.clear();
|
|
|
|
|
|
|
|
// Find allocas that are safe to promote, by looking at all instructions in
|
|
|
|
// the entry node
|
|
|
|
for (BasicBlock::iterator I = BB.begin(), E = --BB.end(); I != E; ++I)
|
|
|
|
if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) // Is it an alloca?
|
Enhance SRoA to promote allocas that are used by selects in some
common cases. This triggers a surprising number of times in SPEC2K6
because min/max idioms end up doing this. For example, code from the
STL ends up looking like this to SRoA:
%202 = load i64* %__old_size, align 8, !tbaa !3
%203 = load i64* %__old_size, align 8, !tbaa !3
%204 = load i64* %__n, align 8, !tbaa !3
%205 = icmp ult i64 %203, %204
%storemerge.i = select i1 %205, i64* %__n, i64* %__old_size
%206 = load i64* %storemerge.i, align 8, !tbaa !3
We can now promote both the __n and the __old_size allocas.
This addresses another chunk of rdar://7339113, poor codegen on
stringswitch.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124088 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-23 22:04:55 +00:00
|
|
|
if (tryToMakeAllocaBePromotable(AI, TD))
|
2010-04-16 00:24:57 +00:00
|
|
|
Allocas.push_back(AI);
|
|
|
|
|
|
|
|
if (Allocas.empty()) break;
|
|
|
|
|
2011-01-18 03:53:26 +00:00
|
|
|
if (HasDomTree)
|
2011-01-17 17:38:41 +00:00
|
|
|
PromoteMemToReg(Allocas, *DT);
|
2011-01-14 07:50:47 +00:00
|
|
|
else {
|
|
|
|
SSAUpdater SSA;
|
2011-01-15 00:12:35 +00:00
|
|
|
for (unsigned i = 0, e = Allocas.size(); i != e; ++i) {
|
|
|
|
AllocaInst *AI = Allocas[i];
|
|
|
|
|
|
|
|
// Build list of instructions to promote.
|
|
|
|
for (Value::use_iterator UI = AI->use_begin(), E = AI->use_end();
|
|
|
|
UI != E; ++UI)
|
|
|
|
Insts.push_back(cast<Instruction>(*UI));
|
2011-07-06 21:09:55 +00:00
|
|
|
AllocaPromoter(Insts, SSA, &DIB).run(AI, Insts);
|
2011-01-15 00:12:35 +00:00
|
|
|
Insts.clear();
|
|
|
|
}
|
2011-01-14 07:50:47 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
NumPromoted += Allocas.size();
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// ShouldAttemptScalarRepl - Decide if an alloca is a good candidate for
|
|
|
|
/// SROA. It must be a struct or array type with a small number of elements.
|
|
|
|
static bool ShouldAttemptScalarRepl(AllocaInst *AI) {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *T = AI->getAllocatedType();
|
2010-04-16 00:24:57 +00:00
|
|
|
// Do not promote any struct into more than 32 separate vars.
|
2011-07-18 04:54:35 +00:00
|
|
|
if (StructType *ST = dyn_cast<StructType>(T))
|
2010-04-16 00:24:57 +00:00
|
|
|
return ST->getNumElements() <= 32;
|
|
|
|
// Arrays are much less likely to be safe for SROA; only consider
|
|
|
|
// them if they are very small.
|
2011-07-18 04:54:35 +00:00
|
|
|
if (ArrayType *AT = dyn_cast<ArrayType>(T))
|
2010-04-16 00:24:57 +00:00
|
|
|
return AT->getNumElements() <= 8;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// performScalarRepl - This algorithm is a simple worklist driven algorithm,
|
2011-06-27 05:40:02 +00:00
|
|
|
// which runs on all of the alloca instructions in the function, removing them
|
|
|
|
// if they are only used by getelementptr instructions.
|
2010-04-16 00:24:57 +00:00
|
|
|
//
|
|
|
|
bool SROA::performScalarRepl(Function &F) {
|
|
|
|
std::vector<AllocaInst*> WorkList;
|
|
|
|
|
|
|
|
// Scan the entry basic block, adding allocas to the worklist.
|
|
|
|
BasicBlock &BB = F.getEntryBlock();
|
|
|
|
for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I)
|
|
|
|
if (AllocaInst *A = dyn_cast<AllocaInst>(I))
|
|
|
|
WorkList.push_back(A);
|
|
|
|
|
|
|
|
// Process the worklist
|
|
|
|
bool Changed = false;
|
|
|
|
while (!WorkList.empty()) {
|
|
|
|
AllocaInst *AI = WorkList.back();
|
|
|
|
WorkList.pop_back();
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Handle dead allocas trivially. These can be formed by SROA'ing arrays
|
|
|
|
// with unused elements.
|
|
|
|
if (AI->use_empty()) {
|
|
|
|
AI->eraseFromParent();
|
|
|
|
Changed = true;
|
|
|
|
continue;
|
2009-01-07 07:18:45 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
|
|
|
|
// If this alloca is impossible for us to promote, reject it early.
|
|
|
|
if (AI->isArrayAllocation() || !AI->getAllocatedType()->isSized())
|
|
|
|
continue;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Check to see if this allocation is only modified by a memcpy/memmove from
|
|
|
|
// a constant global. If this is the case, we can change all users to use
|
|
|
|
// the constant global instead. This is commonly produced by the CFE by
|
|
|
|
// constructs like "void foo() { int A[] = {1,2,3,4,5,6,7,8,9...}; }" if 'A'
|
|
|
|
// is only subsequently read.
|
2011-06-27 05:40:02 +00:00
|
|
|
SmallVector<Instruction *, 4> ToDelete;
|
|
|
|
if (MemTransferInst *Copy = isOnlyCopiedFromConstantGlobal(AI, ToDelete)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
DEBUG(dbgs() << "Found alloca equal to global: " << *AI << '\n');
|
2011-06-27 05:40:02 +00:00
|
|
|
DEBUG(dbgs() << " memcpy = " << *Copy << '\n');
|
|
|
|
for (unsigned i = 0, e = ToDelete.size(); i != e; ++i)
|
|
|
|
ToDelete[i]->eraseFromParent();
|
|
|
|
Constant *TheSrc = cast<Constant>(Copy->getSource());
|
2010-04-16 00:24:57 +00:00
|
|
|
AI->replaceAllUsesWith(ConstantExpr::getBitCast(TheSrc, AI->getType()));
|
2011-06-27 05:40:02 +00:00
|
|
|
Copy->eraseFromParent(); // Don't mutate the global.
|
2010-04-16 00:24:57 +00:00
|
|
|
AI->eraseFromParent();
|
|
|
|
++NumGlobals;
|
|
|
|
Changed = true;
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Check to see if we can perform the core SROA transformation. We cannot
|
|
|
|
// transform the allocation instruction if it is an array allocation
|
|
|
|
// (allocations OF arrays are ok though), and an allocation of a scalar
|
|
|
|
// value cannot be decomposed at all.
|
|
|
|
uint64_t AllocaSize = TD->getTypeAllocSize(AI->getAllocatedType());
|
2009-06-16 00:20:26 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Do not promote [0 x %struct].
|
|
|
|
if (AllocaSize == 0) continue;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Do not promote any struct whose size is too big.
|
|
|
|
if (AllocaSize > SRThreshold) continue;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If the alloca looks like a good candidate for scalar replacement, and if
|
|
|
|
// all its users can be transformed, then split up the aggregate into its
|
|
|
|
// separate elements.
|
|
|
|
if (ShouldAttemptScalarRepl(AI) && isSafeAllocaToScalarRepl(AI)) {
|
|
|
|
DoScalarReplacement(AI, WorkList);
|
|
|
|
Changed = true;
|
|
|
|
continue;
|
Reapply address space patch after fixing an issue in MemCopyOptimizer.
Added support for address spaces and added a isVolatile field to memcpy, memmove, and memset,
e.g., llvm.memcpy.i32(i8*, i8*, i32, i32) -> llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@100304 91177308-0d34-0410-b5e6-96231b3b80d8
2010-04-04 03:10:48 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
|
|
|
|
// If we can turn this aggregate value (potentially with casts) into a
|
|
|
|
// simple scalar value that can be mem2reg'd into a register value.
|
|
|
|
// IsNotTrivial tracks whether this is something that mem2reg could have
|
|
|
|
// promoted itself. If so, we don't want to transform it needlessly. Note
|
|
|
|
// that we can't just check based on the type: the alloca may be of an i32
|
|
|
|
// but that has pointer arithmetic to set byte 3 of it or something.
|
|
|
|
if (AllocaInst *NewAI =
|
|
|
|
ConvertToScalarInfo((unsigned)AllocaSize, *TD).TryConvert(AI)) {
|
|
|
|
NewAI->takeName(AI);
|
|
|
|
AI->eraseFromParent();
|
|
|
|
++NumConverted;
|
|
|
|
Changed = true;
|
|
|
|
continue;
|
2011-01-13 20:59:44 +00:00
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Otherwise, couldn't process this alloca.
|
2007-03-05 07:52:57 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
|
|
|
|
return Changed;
|
2007-03-05 07:52:57 +00:00
|
|
|
}
|
Implement the first half of PR3290: if there is a store of an
integer to a (transitive) bitcast the alloca and if that integer
has the full size of the alloca, then it clobbers the whole thing.
Handle this by extracting pieces out of the stored integer and
filing them away in the SROA'd elements.
This triggers fairly frequently because the CFE uses integers to
pass small structs by value and the inliner exposes these. For
example, in kimwitu++, I see a bunch of these with i64 stores to
"%struct.std::pair<std::_Rb_tree_const_iterator<kc::impl_abstract_phylum*>,bool>"
In 176.gcc I see a few i32 stores to "%struct..0anon".
In the testcase, this is a difference between compiling test1 to:
_test1:
subl $12, %esp
movl 20(%esp), %eax
movl %eax, 4(%esp)
movl 16(%esp), %eax
movl %eax, (%esp)
movl (%esp), %eax
addl 4(%esp), %eax
addl $12, %esp
ret
vs:
_test1:
movl 8(%esp), %eax
addl 4(%esp), %eax
ret
The second half of this will be to handle loads of the same form.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61853 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-07 08:11:13 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// DoScalarReplacement - This alloca satisfied the isSafeAllocaToScalarRepl
|
|
|
|
/// predicate, do SROA now.
|
2011-01-13 20:59:44 +00:00
|
|
|
void SROA::DoScalarReplacement(AllocaInst *AI,
|
2010-04-16 00:24:57 +00:00
|
|
|
std::vector<AllocaInst*> &WorkList) {
|
|
|
|
DEBUG(dbgs() << "Found inst to SROA: " << *AI << '\n');
|
|
|
|
SmallVector<AllocaInst*, 32> ElementAllocas;
|
2011-07-18 04:54:35 +00:00
|
|
|
if (StructType *ST = dyn_cast<StructType>(AI->getAllocatedType())) {
|
2010-04-16 00:24:57 +00:00
|
|
|
ElementAllocas.reserve(ST->getNumContainedTypes());
|
|
|
|
for (unsigned i = 0, e = ST->getNumContainedTypes(); i != e; ++i) {
|
2011-01-13 20:59:44 +00:00
|
|
|
AllocaInst *NA = new AllocaInst(ST->getContainedType(i), 0,
|
2010-04-16 00:24:57 +00:00
|
|
|
AI->getAlignment(),
|
|
|
|
AI->getName() + "." + Twine(i), AI);
|
|
|
|
ElementAllocas.push_back(NA);
|
|
|
|
WorkList.push_back(NA); // Add to worklist for recursive processing
|
|
|
|
}
|
|
|
|
} else {
|
2011-07-18 04:54:35 +00:00
|
|
|
ArrayType *AT = cast<ArrayType>(AI->getAllocatedType());
|
2010-04-16 00:24:57 +00:00
|
|
|
ElementAllocas.reserve(AT->getNumElements());
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ElTy = AT->getElementType();
|
2010-04-16 00:24:57 +00:00
|
|
|
for (unsigned i = 0, e = AT->getNumElements(); i != e; ++i) {
|
|
|
|
AllocaInst *NA = new AllocaInst(ElTy, 0, AI->getAlignment(),
|
|
|
|
AI->getName() + "." + Twine(i), AI);
|
|
|
|
ElementAllocas.push_back(NA);
|
|
|
|
WorkList.push_back(NA); // Add to worklist for recursive processing
|
|
|
|
}
|
|
|
|
}
|
Implement the first half of PR3290: if there is a store of an
integer to a (transitive) bitcast the alloca and if that integer
has the full size of the alloca, then it clobbers the whole thing.
Handle this by extracting pieces out of the stored integer and
filing them away in the SROA'd elements.
This triggers fairly frequently because the CFE uses integers to
pass small structs by value and the inliner exposes these. For
example, in kimwitu++, I see a bunch of these with i64 stores to
"%struct.std::pair<std::_Rb_tree_const_iterator<kc::impl_abstract_phylum*>,bool>"
In 176.gcc I see a few i32 stores to "%struct..0anon".
In the testcase, this is a difference between compiling test1 to:
_test1:
subl $12, %esp
movl 20(%esp), %eax
movl %eax, 4(%esp)
movl 16(%esp), %eax
movl %eax, (%esp)
movl (%esp), %eax
addl 4(%esp), %eax
addl $12, %esp
ret
vs:
_test1:
movl 8(%esp), %eax
addl 4(%esp), %eax
ret
The second half of this will be to handle loads of the same form.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61853 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-07 08:11:13 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Now that we have created the new alloca instructions, rewrite all the
|
|
|
|
// uses of the old alloca.
|
|
|
|
RewriteForScalarRepl(AI, AI, 0, ElementAllocas);
|
Implement the first half of PR3290: if there is a store of an
integer to a (transitive) bitcast the alloca and if that integer
has the full size of the alloca, then it clobbers the whole thing.
Handle this by extracting pieces out of the stored integer and
filing them away in the SROA'd elements.
This triggers fairly frequently because the CFE uses integers to
pass small structs by value and the inliner exposes these. For
example, in kimwitu++, I see a bunch of these with i64 stores to
"%struct.std::pair<std::_Rb_tree_const_iterator<kc::impl_abstract_phylum*>,bool>"
In 176.gcc I see a few i32 stores to "%struct..0anon".
In the testcase, this is a difference between compiling test1 to:
_test1:
subl $12, %esp
movl 20(%esp), %eax
movl %eax, 4(%esp)
movl 16(%esp), %eax
movl %eax, (%esp)
movl (%esp), %eax
addl 4(%esp), %eax
addl $12, %esp
ret
vs:
_test1:
movl 8(%esp), %eax
addl 4(%esp), %eax
ret
The second half of this will be to handle loads of the same form.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61853 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-07 08:11:13 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Now erase any instructions that were made dead while rewriting the alloca.
|
|
|
|
DeleteDeadInstructions();
|
|
|
|
AI->eraseFromParent();
|
|
|
|
|
2010-06-22 15:08:57 +00:00
|
|
|
++NumReplaced;
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// DeleteDeadInstructions - Erase instructions on the DeadInstrs list,
|
|
|
|
/// recursively including all their operands that become trivially dead.
|
|
|
|
void SROA::DeleteDeadInstructions() {
|
|
|
|
while (!DeadInsts.empty()) {
|
|
|
|
Instruction *I = cast<Instruction>(DeadInsts.pop_back_val());
|
|
|
|
|
|
|
|
for (User::op_iterator OI = I->op_begin(), E = I->op_end(); OI != E; ++OI)
|
|
|
|
if (Instruction *U = dyn_cast<Instruction>(*OI)) {
|
|
|
|
// Zero out the operand and see if it becomes trivially dead.
|
|
|
|
// (But, don't add allocas to the dead instruction list -- they are
|
|
|
|
// already on the worklist and will be deleted separately.)
|
|
|
|
*OI = 0;
|
|
|
|
if (isInstructionTriviallyDead(U) && !isa<AllocaInst>(U))
|
|
|
|
DeadInsts.push_back(U);
|
Implement the first half of PR3290: if there is a store of an
integer to a (transitive) bitcast the alloca and if that integer
has the full size of the alloca, then it clobbers the whole thing.
Handle this by extracting pieces out of the stored integer and
filing them away in the SROA'd elements.
This triggers fairly frequently because the CFE uses integers to
pass small structs by value and the inliner exposes these. For
example, in kimwitu++, I see a bunch of these with i64 stores to
"%struct.std::pair<std::_Rb_tree_const_iterator<kc::impl_abstract_phylum*>,bool>"
In 176.gcc I see a few i32 stores to "%struct..0anon".
In the testcase, this is a difference between compiling test1 to:
_test1:
subl $12, %esp
movl 20(%esp), %eax
movl %eax, 4(%esp)
movl 16(%esp), %eax
movl %eax, (%esp)
movl (%esp), %eax
addl 4(%esp), %eax
addl $12, %esp
ret
vs:
_test1:
movl 8(%esp), %eax
addl 4(%esp), %eax
ret
The second half of this will be to handle loads of the same form.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61853 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-07 08:11:13 +00:00
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
I->eraseFromParent();
|
|
|
|
}
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// isSafeForScalarRepl - Check if instruction I is a safe use with regard to
|
|
|
|
/// performing scalar replacement of alloca AI. The results are flagged in
|
|
|
|
/// the Info parameter. Offset indicates the position within AI that is
|
|
|
|
/// referenced by this instruction.
|
2011-01-23 07:29:29 +00:00
|
|
|
void SROA::isSafeForScalarRepl(Instruction *I, uint64_t Offset,
|
2010-04-16 00:24:57 +00:00
|
|
|
AllocaInfo &Info) {
|
|
|
|
for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI!=E; ++UI) {
|
|
|
|
Instruction *User = cast<Instruction>(*UI);
|
|
|
|
|
|
|
|
if (BitCastInst *BC = dyn_cast<BitCastInst>(User)) {
|
2011-01-23 07:29:29 +00:00
|
|
|
isSafeForScalarRepl(BC, Offset, Info);
|
2010-04-16 00:24:57 +00:00
|
|
|
} else if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(User)) {
|
|
|
|
uint64_t GEPOffset = Offset;
|
2011-01-23 07:29:29 +00:00
|
|
|
isSafeGEP(GEPI, GEPOffset, Info);
|
2010-04-16 00:24:57 +00:00
|
|
|
if (!Info.isUnsafe)
|
2011-01-23 07:29:29 +00:00
|
|
|
isSafeForScalarRepl(GEPI, GEPOffset, Info);
|
2010-06-28 11:20:42 +00:00
|
|
|
} else if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(User)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
ConstantInt *Length = dyn_cast<ConstantInt>(MI->getLength());
|
2011-01-23 07:05:44 +00:00
|
|
|
if (Length == 0)
|
|
|
|
return MarkUnsafe(Info, User);
|
2012-03-15 00:05:31 +00:00
|
|
|
if (Length->isNegative())
|
|
|
|
return MarkUnsafe(Info, User);
|
|
|
|
|
2011-01-23 07:29:29 +00:00
|
|
|
isSafeMemAccess(Offset, Length->getZExtValue(), 0,
|
2011-01-23 08:27:54 +00:00
|
|
|
UI.getOperandNo() == 0, Info, MI,
|
|
|
|
true /*AllowWholeAccess*/);
|
2010-04-16 00:24:57 +00:00
|
|
|
} else if (LoadInst *LI = dyn_cast<LoadInst>(User)) {
|
2011-09-12 20:23:13 +00:00
|
|
|
if (!LI->isSimple())
|
2011-01-23 07:05:44 +00:00
|
|
|
return MarkUnsafe(Info, User);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *LIType = LI->getType();
|
2011-01-23 07:29:29 +00:00
|
|
|
isSafeMemAccess(Offset, TD->getTypeAllocSize(LIType),
|
2011-01-23 08:27:54 +00:00
|
|
|
LIType, false, Info, LI, true /*AllowWholeAccess*/);
|
2011-01-23 07:05:44 +00:00
|
|
|
Info.hasALoadOrStore = true;
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
} else if (StoreInst *SI = dyn_cast<StoreInst>(User)) {
|
|
|
|
// Store is ok if storing INTO the pointer, not storing the pointer
|
2011-09-12 20:23:13 +00:00
|
|
|
if (!SI->isSimple() || SI->getOperand(0) == I)
|
2011-01-23 07:05:44 +00:00
|
|
|
return MarkUnsafe(Info, User);
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SIType = SI->getOperand(0)->getType();
|
2011-01-23 07:29:29 +00:00
|
|
|
isSafeMemAccess(Offset, TD->getTypeAllocSize(SIType),
|
2011-01-23 08:27:54 +00:00
|
|
|
SIType, true, Info, SI, true /*AllowWholeAccess*/);
|
|
|
|
Info.hasALoadOrStore = true;
|
2011-07-25 23:14:22 +00:00
|
|
|
} else if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(User)) {
|
|
|
|
if (II->getIntrinsicID() != Intrinsic::lifetime_start &&
|
|
|
|
II->getIntrinsicID() != Intrinsic::lifetime_end)
|
|
|
|
return MarkUnsafe(Info, User);
|
2011-01-23 08:27:54 +00:00
|
|
|
} else if (isa<PHINode>(User) || isa<SelectInst>(User)) {
|
|
|
|
isSafePHISelectUseForScalarRepl(User, Offset, Info);
|
|
|
|
} else {
|
|
|
|
return MarkUnsafe(Info, User);
|
|
|
|
}
|
|
|
|
if (Info.isUnsafe) return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// isSafePHIUseForScalarRepl - If we see a PHI node or select using a pointer
|
|
|
|
/// derived from the alloca, we can often still split the alloca into elements.
|
|
|
|
/// This is useful if we have a large alloca where one element is phi'd
|
|
|
|
/// together somewhere: we can SRoA and promote all the other elements even if
|
|
|
|
/// we end up not being able to promote this one.
|
|
|
|
///
|
|
|
|
/// All we require is that the uses of the PHI do not index into other parts of
|
|
|
|
/// the alloca. The most important use case for this is single load and stores
|
|
|
|
/// that are PHI'd together, which can happen due to code sinking.
|
|
|
|
void SROA::isSafePHISelectUseForScalarRepl(Instruction *I, uint64_t Offset,
|
|
|
|
AllocaInfo &Info) {
|
|
|
|
// If we've already checked this PHI, don't do it again.
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(I))
|
|
|
|
if (!Info.CheckedPHIs.insert(PN))
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI!=E; ++UI) {
|
|
|
|
Instruction *User = cast<Instruction>(*UI);
|
|
|
|
|
|
|
|
if (BitCastInst *BC = dyn_cast<BitCastInst>(User)) {
|
|
|
|
isSafePHISelectUseForScalarRepl(BC, Offset, Info);
|
|
|
|
} else if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(User)) {
|
|
|
|
// Only allow "bitcast" GEPs for simplicity. We could generalize this,
|
|
|
|
// but would have to prove that we're staying inside of an element being
|
|
|
|
// promoted.
|
|
|
|
if (!GEPI->hasAllZeroIndices())
|
|
|
|
return MarkUnsafe(Info, User);
|
|
|
|
isSafePHISelectUseForScalarRepl(GEPI, Offset, Info);
|
|
|
|
} else if (LoadInst *LI = dyn_cast<LoadInst>(User)) {
|
2011-09-12 20:23:13 +00:00
|
|
|
if (!LI->isSimple())
|
2011-01-23 08:27:54 +00:00
|
|
|
return MarkUnsafe(Info, User);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *LIType = LI->getType();
|
2011-01-23 08:27:54 +00:00
|
|
|
isSafeMemAccess(Offset, TD->getTypeAllocSize(LIType),
|
|
|
|
LIType, false, Info, LI, false /*AllowWholeAccess*/);
|
|
|
|
Info.hasALoadOrStore = true;
|
|
|
|
|
|
|
|
} else if (StoreInst *SI = dyn_cast<StoreInst>(User)) {
|
|
|
|
// Store is ok if storing INTO the pointer, not storing the pointer
|
2011-09-12 20:23:13 +00:00
|
|
|
if (!SI->isSimple() || SI->getOperand(0) == I)
|
2011-01-23 08:27:54 +00:00
|
|
|
return MarkUnsafe(Info, User);
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SIType = SI->getOperand(0)->getType();
|
2011-01-23 08:27:54 +00:00
|
|
|
isSafeMemAccess(Offset, TD->getTypeAllocSize(SIType),
|
|
|
|
SIType, true, Info, SI, false /*AllowWholeAccess*/);
|
2011-01-23 07:05:44 +00:00
|
|
|
Info.hasALoadOrStore = true;
|
2011-01-23 08:27:54 +00:00
|
|
|
} else if (isa<PHINode>(User) || isa<SelectInst>(User)) {
|
|
|
|
isSafePHISelectUseForScalarRepl(User, Offset, Info);
|
2010-04-16 00:24:57 +00:00
|
|
|
} else {
|
2011-01-23 07:05:44 +00:00
|
|
|
return MarkUnsafe(Info, User);
|
Implement the first half of PR3290: if there is a store of an
integer to a (transitive) bitcast the alloca and if that integer
has the full size of the alloca, then it clobbers the whole thing.
Handle this by extracting pieces out of the stored integer and
filing them away in the SROA'd elements.
This triggers fairly frequently because the CFE uses integers to
pass small structs by value and the inliner exposes these. For
example, in kimwitu++, I see a bunch of these with i64 stores to
"%struct.std::pair<std::_Rb_tree_const_iterator<kc::impl_abstract_phylum*>,bool>"
In 176.gcc I see a few i32 stores to "%struct..0anon".
In the testcase, this is a difference between compiling test1 to:
_test1:
subl $12, %esp
movl 20(%esp), %eax
movl %eax, 4(%esp)
movl 16(%esp), %eax
movl %eax, (%esp)
movl (%esp), %eax
addl 4(%esp), %eax
addl $12, %esp
ret
vs:
_test1:
movl 8(%esp), %eax
addl 4(%esp), %eax
ret
The second half of this will be to handle loads of the same form.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61853 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-07 08:11:13 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
if (Info.isUnsafe) return;
|
Implement the first half of PR3290: if there is a store of an
integer to a (transitive) bitcast the alloca and if that integer
has the full size of the alloca, then it clobbers the whole thing.
Handle this by extracting pieces out of the stored integer and
filing them away in the SROA'd elements.
This triggers fairly frequently because the CFE uses integers to
pass small structs by value and the inliner exposes these. For
example, in kimwitu++, I see a bunch of these with i64 stores to
"%struct.std::pair<std::_Rb_tree_const_iterator<kc::impl_abstract_phylum*>,bool>"
In 176.gcc I see a few i32 stores to "%struct..0anon".
In the testcase, this is a difference between compiling test1 to:
_test1:
subl $12, %esp
movl 20(%esp), %eax
movl %eax, 4(%esp)
movl 16(%esp), %eax
movl %eax, (%esp)
movl (%esp), %eax
addl 4(%esp), %eax
addl $12, %esp
ret
vs:
_test1:
movl 8(%esp), %eax
addl 4(%esp), %eax
ret
The second half of this will be to handle loads of the same form.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61853 91177308-0d34-0410-b5e6-96231b3b80d8
2009-01-07 08:11:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// isSafeGEP - Check if a GEP instruction can be handled for scalar
|
|
|
|
/// replacement. It is safe when all the indices are constant, in-bounds
|
|
|
|
/// references, and when the resulting offset corresponds to an element within
|
|
|
|
/// the alloca type. The results are flagged in the Info parameter. Upon
|
|
|
|
/// return, Offset is adjusted as specified by the GEP indices.
|
2011-01-23 07:29:29 +00:00
|
|
|
void SROA::isSafeGEP(GetElementPtrInst *GEPI,
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t &Offset, AllocaInfo &Info) {
|
|
|
|
gep_type_iterator GEPIt = gep_type_begin(GEPI), E = gep_type_end(GEPI);
|
|
|
|
if (GEPIt == E)
|
|
|
|
return;
|
2009-01-08 05:42:05 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Walk through the GEP type indices, checking the types that this indexes
|
|
|
|
// into.
|
|
|
|
for (; GEPIt != E; ++GEPIt) {
|
|
|
|
// Ignore struct elements, no extra checking needed for these.
|
|
|
|
if ((*GEPIt)->isStructTy())
|
|
|
|
continue;
|
2009-01-08 05:42:05 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
ConstantInt *IdxVal = dyn_cast<ConstantInt>(GEPIt.getOperand());
|
|
|
|
if (!IdxVal)
|
2011-01-23 07:05:44 +00:00
|
|
|
return MarkUnsafe(Info, GEPI);
|
2009-01-08 05:42:05 +00:00
|
|
|
}
|
2009-06-01 09:14:32 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Compute the offset due to this GEP and check if the alloca has a
|
|
|
|
// component element at that offset.
|
|
|
|
SmallVector<Value*, 8> Indices(GEPI->op_begin() + 1, GEPI->op_end());
|
2011-07-19 14:01:37 +00:00
|
|
|
Offset += TD->getIndexedOffset(GEPI->getPointerOperandType(), Indices);
|
2011-01-23 07:29:29 +00:00
|
|
|
if (!TypeHasComponent(Info.AI->getAllocatedType(), Offset, 0))
|
2011-01-23 07:05:44 +00:00
|
|
|
MarkUnsafe(Info, GEPI);
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
2009-06-01 09:14:32 +00:00
|
|
|
|
2011-01-13 17:45:11 +00:00
|
|
|
/// isHomogeneousAggregate - Check if type T is a struct or array containing
|
|
|
|
/// elements of the same type (which is always true for arrays). If so,
|
|
|
|
/// return true with NumElts and EltTy set to the number of elements and the
|
|
|
|
/// element type, respectively.
|
2011-07-18 04:54:35 +00:00
|
|
|
static bool isHomogeneousAggregate(Type *T, unsigned &NumElts,
|
|
|
|
Type *&EltTy) {
|
|
|
|
if (ArrayType *AT = dyn_cast<ArrayType>(T)) {
|
2011-01-13 17:45:11 +00:00
|
|
|
NumElts = AT->getNumElements();
|
2011-01-13 18:26:59 +00:00
|
|
|
EltTy = (NumElts == 0 ? 0 : AT->getElementType());
|
2011-01-13 17:45:11 +00:00
|
|
|
return true;
|
|
|
|
}
|
2011-07-18 04:54:35 +00:00
|
|
|
if (StructType *ST = dyn_cast<StructType>(T)) {
|
2011-01-13 17:45:11 +00:00
|
|
|
NumElts = ST->getNumContainedTypes();
|
2011-01-13 18:26:59 +00:00
|
|
|
EltTy = (NumElts == 0 ? 0 : ST->getContainedType(0));
|
2011-01-13 17:45:11 +00:00
|
|
|
for (unsigned n = 1; n < NumElts; ++n) {
|
|
|
|
if (ST->getContainedType(n) != EltTy)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isCompatibleAggregate - Check if T1 and T2 are either the same type or are
|
|
|
|
/// "homogeneous" aggregates with the same element type and number of elements.
|
2011-07-18 04:54:35 +00:00
|
|
|
static bool isCompatibleAggregate(Type *T1, Type *T2) {
|
2011-01-13 17:45:11 +00:00
|
|
|
if (T1 == T2)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
unsigned NumElts1, NumElts2;
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *EltTy1, *EltTy2;
|
2011-01-13 17:45:11 +00:00
|
|
|
if (isHomogeneousAggregate(T1, NumElts1, EltTy1) &&
|
|
|
|
isHomogeneousAggregate(T2, NumElts2, EltTy2) &&
|
|
|
|
NumElts1 == NumElts2 &&
|
|
|
|
EltTy1 == EltTy2)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// isSafeMemAccess - Check if a load/store/memcpy operates on the entire AI
|
|
|
|
/// alloca or has an offset and size that corresponds to a component element
|
|
|
|
/// within it. The offset checked here may have been formed from a GEP with a
|
|
|
|
/// pointer bitcasted to a different type.
|
2011-01-23 08:27:54 +00:00
|
|
|
///
|
|
|
|
/// If AllowWholeAccess is true, then this allows uses of the entire alloca as a
|
|
|
|
/// unit. If false, it only allows accesses known to be in a single element.
|
2011-01-23 07:29:29 +00:00
|
|
|
void SROA::isSafeMemAccess(uint64_t Offset, uint64_t MemSize,
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *MemOpType, bool isStore,
|
2011-01-23 08:27:54 +00:00
|
|
|
AllocaInfo &Info, Instruction *TheAccess,
|
|
|
|
bool AllowWholeAccess) {
|
2010-04-16 00:24:57 +00:00
|
|
|
// Check if this is a load/store of the entire alloca.
|
2011-01-23 08:27:54 +00:00
|
|
|
if (Offset == 0 && AllowWholeAccess &&
|
2011-01-23 07:29:29 +00:00
|
|
|
MemSize == TD->getTypeAllocSize(Info.AI->getAllocatedType())) {
|
2011-01-13 17:45:11 +00:00
|
|
|
// This can be safe for MemIntrinsics (where MemOpType is 0) and integer
|
|
|
|
// loads/stores (which are essentially the same as the MemIntrinsics with
|
|
|
|
// regard to copying padding between elements). But, if an alloca is
|
|
|
|
// flagged as both a source and destination of such operations, we'll need
|
|
|
|
// to check later for padding between elements.
|
|
|
|
if (!MemOpType || MemOpType->isIntegerTy()) {
|
|
|
|
if (isStore)
|
|
|
|
Info.isMemCpyDst = true;
|
|
|
|
else
|
|
|
|
Info.isMemCpySrc = true;
|
2010-04-16 00:24:57 +00:00
|
|
|
return;
|
|
|
|
}
|
2011-01-13 17:45:11 +00:00
|
|
|
// This is also safe for references using a type that is compatible with
|
|
|
|
// the type of the alloca, so that loads/stores can be rewritten using
|
|
|
|
// insertvalue/extractvalue.
|
2011-01-23 07:29:29 +00:00
|
|
|
if (isCompatibleAggregate(MemOpType, Info.AI->getAllocatedType())) {
|
if an alloca is only ever accessed as a unit, and is accessed with load/store instructions,
then don't try to decimate it into its individual pieces. This will just make a mess of the
IR and is pointless if none of the elements are individually accessed. This was generating
really terrible code for std::bitset (PR8980) because it happens to be lowered by clang
as an {[8 x i8]} structure instead of {i64}.
The testcase now is optimized to:
define i64 @test2(i64 %X) {
br label %L2
L2: ; preds = %0
ret i64 %X
}
before we generated:
define i64 @test2(i64 %X) {
%sroa.store.elt = lshr i64 %X, 56
%1 = trunc i64 %sroa.store.elt to i8
%sroa.store.elt8 = lshr i64 %X, 48
%2 = trunc i64 %sroa.store.elt8 to i8
%sroa.store.elt9 = lshr i64 %X, 40
%3 = trunc i64 %sroa.store.elt9 to i8
%sroa.store.elt10 = lshr i64 %X, 32
%4 = trunc i64 %sroa.store.elt10 to i8
%sroa.store.elt11 = lshr i64 %X, 24
%5 = trunc i64 %sroa.store.elt11 to i8
%sroa.store.elt12 = lshr i64 %X, 16
%6 = trunc i64 %sroa.store.elt12 to i8
%sroa.store.elt13 = lshr i64 %X, 8
%7 = trunc i64 %sroa.store.elt13 to i8
%8 = trunc i64 %X to i8
br label %L2
L2: ; preds = %0
%9 = zext i8 %1 to i64
%10 = shl i64 %9, 56
%11 = zext i8 %2 to i64
%12 = shl i64 %11, 48
%13 = or i64 %12, %10
%14 = zext i8 %3 to i64
%15 = shl i64 %14, 40
%16 = or i64 %15, %13
%17 = zext i8 %4 to i64
%18 = shl i64 %17, 32
%19 = or i64 %18, %16
%20 = zext i8 %5 to i64
%21 = shl i64 %20, 24
%22 = or i64 %21, %19
%23 = zext i8 %6 to i64
%24 = shl i64 %23, 16
%25 = or i64 %24, %22
%26 = zext i8 %7 to i64
%27 = shl i64 %26, 8
%28 = or i64 %27, %25
%29 = zext i8 %8 to i64
%30 = or i64 %29, %28
ret i64 %30
}
In this case, instcombine was able to eliminate the nonsense, but in PR8980 enough
PHIs are in play that instcombine backs off. It's better to not generate this stuff
in the first place.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@123571 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-16 06:18:28 +00:00
|
|
|
Info.hasSubelementAccess = true;
|
2011-01-13 17:45:11 +00:00
|
|
|
return;
|
if an alloca is only ever accessed as a unit, and is accessed with load/store instructions,
then don't try to decimate it into its individual pieces. This will just make a mess of the
IR and is pointless if none of the elements are individually accessed. This was generating
really terrible code for std::bitset (PR8980) because it happens to be lowered by clang
as an {[8 x i8]} structure instead of {i64}.
The testcase now is optimized to:
define i64 @test2(i64 %X) {
br label %L2
L2: ; preds = %0
ret i64 %X
}
before we generated:
define i64 @test2(i64 %X) {
%sroa.store.elt = lshr i64 %X, 56
%1 = trunc i64 %sroa.store.elt to i8
%sroa.store.elt8 = lshr i64 %X, 48
%2 = trunc i64 %sroa.store.elt8 to i8
%sroa.store.elt9 = lshr i64 %X, 40
%3 = trunc i64 %sroa.store.elt9 to i8
%sroa.store.elt10 = lshr i64 %X, 32
%4 = trunc i64 %sroa.store.elt10 to i8
%sroa.store.elt11 = lshr i64 %X, 24
%5 = trunc i64 %sroa.store.elt11 to i8
%sroa.store.elt12 = lshr i64 %X, 16
%6 = trunc i64 %sroa.store.elt12 to i8
%sroa.store.elt13 = lshr i64 %X, 8
%7 = trunc i64 %sroa.store.elt13 to i8
%8 = trunc i64 %X to i8
br label %L2
L2: ; preds = %0
%9 = zext i8 %1 to i64
%10 = shl i64 %9, 56
%11 = zext i8 %2 to i64
%12 = shl i64 %11, 48
%13 = or i64 %12, %10
%14 = zext i8 %3 to i64
%15 = shl i64 %14, 40
%16 = or i64 %15, %13
%17 = zext i8 %4 to i64
%18 = shl i64 %17, 32
%19 = or i64 %18, %16
%20 = zext i8 %5 to i64
%21 = shl i64 %20, 24
%22 = or i64 %21, %19
%23 = zext i8 %6 to i64
%24 = shl i64 %23, 16
%25 = or i64 %24, %22
%26 = zext i8 %7 to i64
%27 = shl i64 %26, 8
%28 = or i64 %27, %25
%29 = zext i8 %8 to i64
%30 = or i64 %29, %28
ret i64 %30
}
In this case, instcombine was able to eliminate the nonsense, but in PR8980 enough
PHIs are in play that instcombine backs off. It's better to not generate this stuff
in the first place.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@123571 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-16 06:18:28 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
|
|
|
// Check if the offset/size correspond to a component within the alloca type.
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *T = Info.AI->getAllocatedType();
|
if an alloca is only ever accessed as a unit, and is accessed with load/store instructions,
then don't try to decimate it into its individual pieces. This will just make a mess of the
IR and is pointless if none of the elements are individually accessed. This was generating
really terrible code for std::bitset (PR8980) because it happens to be lowered by clang
as an {[8 x i8]} structure instead of {i64}.
The testcase now is optimized to:
define i64 @test2(i64 %X) {
br label %L2
L2: ; preds = %0
ret i64 %X
}
before we generated:
define i64 @test2(i64 %X) {
%sroa.store.elt = lshr i64 %X, 56
%1 = trunc i64 %sroa.store.elt to i8
%sroa.store.elt8 = lshr i64 %X, 48
%2 = trunc i64 %sroa.store.elt8 to i8
%sroa.store.elt9 = lshr i64 %X, 40
%3 = trunc i64 %sroa.store.elt9 to i8
%sroa.store.elt10 = lshr i64 %X, 32
%4 = trunc i64 %sroa.store.elt10 to i8
%sroa.store.elt11 = lshr i64 %X, 24
%5 = trunc i64 %sroa.store.elt11 to i8
%sroa.store.elt12 = lshr i64 %X, 16
%6 = trunc i64 %sroa.store.elt12 to i8
%sroa.store.elt13 = lshr i64 %X, 8
%7 = trunc i64 %sroa.store.elt13 to i8
%8 = trunc i64 %X to i8
br label %L2
L2: ; preds = %0
%9 = zext i8 %1 to i64
%10 = shl i64 %9, 56
%11 = zext i8 %2 to i64
%12 = shl i64 %11, 48
%13 = or i64 %12, %10
%14 = zext i8 %3 to i64
%15 = shl i64 %14, 40
%16 = or i64 %15, %13
%17 = zext i8 %4 to i64
%18 = shl i64 %17, 32
%19 = or i64 %18, %16
%20 = zext i8 %5 to i64
%21 = shl i64 %20, 24
%22 = or i64 %21, %19
%23 = zext i8 %6 to i64
%24 = shl i64 %23, 16
%25 = or i64 %24, %22
%26 = zext i8 %7 to i64
%27 = shl i64 %26, 8
%28 = or i64 %27, %25
%29 = zext i8 %8 to i64
%30 = or i64 %29, %28
ret i64 %30
}
In this case, instcombine was able to eliminate the nonsense, but in PR8980 enough
PHIs are in play that instcombine backs off. It's better to not generate this stuff
in the first place.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@123571 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-16 06:18:28 +00:00
|
|
|
if (TypeHasComponent(T, Offset, MemSize)) {
|
|
|
|
Info.hasSubelementAccess = true;
|
2010-04-16 00:24:57 +00:00
|
|
|
return;
|
if an alloca is only ever accessed as a unit, and is accessed with load/store instructions,
then don't try to decimate it into its individual pieces. This will just make a mess of the
IR and is pointless if none of the elements are individually accessed. This was generating
really terrible code for std::bitset (PR8980) because it happens to be lowered by clang
as an {[8 x i8]} structure instead of {i64}.
The testcase now is optimized to:
define i64 @test2(i64 %X) {
br label %L2
L2: ; preds = %0
ret i64 %X
}
before we generated:
define i64 @test2(i64 %X) {
%sroa.store.elt = lshr i64 %X, 56
%1 = trunc i64 %sroa.store.elt to i8
%sroa.store.elt8 = lshr i64 %X, 48
%2 = trunc i64 %sroa.store.elt8 to i8
%sroa.store.elt9 = lshr i64 %X, 40
%3 = trunc i64 %sroa.store.elt9 to i8
%sroa.store.elt10 = lshr i64 %X, 32
%4 = trunc i64 %sroa.store.elt10 to i8
%sroa.store.elt11 = lshr i64 %X, 24
%5 = trunc i64 %sroa.store.elt11 to i8
%sroa.store.elt12 = lshr i64 %X, 16
%6 = trunc i64 %sroa.store.elt12 to i8
%sroa.store.elt13 = lshr i64 %X, 8
%7 = trunc i64 %sroa.store.elt13 to i8
%8 = trunc i64 %X to i8
br label %L2
L2: ; preds = %0
%9 = zext i8 %1 to i64
%10 = shl i64 %9, 56
%11 = zext i8 %2 to i64
%12 = shl i64 %11, 48
%13 = or i64 %12, %10
%14 = zext i8 %3 to i64
%15 = shl i64 %14, 40
%16 = or i64 %15, %13
%17 = zext i8 %4 to i64
%18 = shl i64 %17, 32
%19 = or i64 %18, %16
%20 = zext i8 %5 to i64
%21 = shl i64 %20, 24
%22 = or i64 %21, %19
%23 = zext i8 %6 to i64
%24 = shl i64 %23, 16
%25 = or i64 %24, %22
%26 = zext i8 %7 to i64
%27 = shl i64 %26, 8
%28 = or i64 %27, %25
%29 = zext i8 %8 to i64
%30 = or i64 %29, %28
ret i64 %30
}
In this case, instcombine was able to eliminate the nonsense, but in PR8980 enough
PHIs are in play that instcombine backs off. It's better to not generate this stuff
in the first place.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@123571 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-16 06:18:28 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
|
2011-01-23 07:05:44 +00:00
|
|
|
return MarkUnsafe(Info, TheAccess);
|
2009-01-08 05:42:05 +00:00
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// TypeHasComponent - Return true if T has a component type with the
|
|
|
|
/// specified offset and size. If Size is zero, do not check the size.
|
2011-07-18 04:54:35 +00:00
|
|
|
bool SROA::TypeHasComponent(Type *T, uint64_t Offset, uint64_t Size) {
|
|
|
|
Type *EltTy;
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t EltSize;
|
2011-07-18 04:54:35 +00:00
|
|
|
if (StructType *ST = dyn_cast<StructType>(T)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
const StructLayout *Layout = TD->getStructLayout(ST);
|
|
|
|
unsigned EltIdx = Layout->getElementContainingOffset(Offset);
|
|
|
|
EltTy = ST->getContainedType(EltIdx);
|
|
|
|
EltSize = TD->getTypeAllocSize(EltTy);
|
|
|
|
Offset -= Layout->getElementOffset(EltIdx);
|
2011-07-18 04:54:35 +00:00
|
|
|
} else if (ArrayType *AT = dyn_cast<ArrayType>(T)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
EltTy = AT->getElementType();
|
|
|
|
EltSize = TD->getTypeAllocSize(EltTy);
|
|
|
|
if (Offset >= AT->getNumElements() * EltSize)
|
|
|
|
return false;
|
|
|
|
Offset %= EltSize;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (Offset == 0 && (Size == 0 || EltSize == Size))
|
|
|
|
return true;
|
|
|
|
// Check if the component spans multiple elements.
|
|
|
|
if (Offset + Size > EltSize)
|
|
|
|
return false;
|
|
|
|
return TypeHasComponent(EltTy, Offset, Size);
|
|
|
|
}
|
2007-11-04 14:43:57 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// RewriteForScalarRepl - Alloca AI is being split into NewElts, so rewrite
|
|
|
|
/// the instruction I, which references it, to use the separate elements.
|
|
|
|
/// Offset indicates the position within AI that is referenced by this
|
|
|
|
/// instruction.
|
|
|
|
void SROA::RewriteForScalarRepl(Instruction *I, AllocaInst *AI, uint64_t Offset,
|
|
|
|
SmallVector<AllocaInst*, 32> &NewElts) {
|
2011-01-23 08:27:54 +00:00
|
|
|
for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI!=E;) {
|
|
|
|
Use &TheUse = UI.getUse();
|
|
|
|
Instruction *User = cast<Instruction>(*UI++);
|
2007-11-04 14:43:57 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (BitCastInst *BC = dyn_cast<BitCastInst>(User)) {
|
|
|
|
RewriteBitCast(BC, AI, Offset, NewElts);
|
2011-01-23 08:27:54 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(User)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
RewriteGEP(GEPI, AI, Offset, NewElts);
|
2011-01-23 08:27:54 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(User)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
ConstantInt *Length = dyn_cast<ConstantInt>(MI->getLength());
|
|
|
|
uint64_t MemSize = Length->getZExtValue();
|
|
|
|
if (Offset == 0 &&
|
|
|
|
MemSize == TD->getTypeAllocSize(AI->getAllocatedType()))
|
|
|
|
RewriteMemIntrinUserOfAlloca(MI, I, AI, NewElts);
|
|
|
|
// Otherwise the intrinsic can only touch a single element and the
|
|
|
|
// address operand will be updated, so nothing else needs to be done.
|
2011-01-23 08:27:54 +00:00
|
|
|
continue;
|
|
|
|
}
|
2011-07-25 23:14:22 +00:00
|
|
|
|
|
|
|
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(User)) {
|
|
|
|
if (II->getIntrinsicID() == Intrinsic::lifetime_start ||
|
|
|
|
II->getIntrinsicID() == Intrinsic::lifetime_end) {
|
|
|
|
RewriteLifetimeIntrinsic(II, AI, Offset, NewElts);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-23 08:27:54 +00:00
|
|
|
|
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(User)) {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *LIType = LI->getType();
|
2011-01-16 05:28:59 +00:00
|
|
|
|
2011-01-13 17:45:11 +00:00
|
|
|
if (isCompatibleAggregate(LIType, AI->getAllocatedType())) {
|
2010-04-16 00:24:57 +00:00
|
|
|
// Replace:
|
|
|
|
// %res = load { i32, i32 }* %alloc
|
|
|
|
// with:
|
|
|
|
// %load.0 = load i32* %alloc.0
|
|
|
|
// %insert.0 insertvalue { i32, i32 } zeroinitializer, i32 %load.0, 0
|
|
|
|
// %load.1 = load i32* %alloc.1
|
|
|
|
// %insert = insertvalue { i32, i32 } %insert.0, i32 %load.1, 1
|
|
|
|
// (Also works for arrays instead of structs)
|
|
|
|
Value *Insert = UndefValue::get(LIType);
|
2011-06-03 19:46:19 +00:00
|
|
|
IRBuilder<> Builder(LI);
|
2010-04-16 00:24:57 +00:00
|
|
|
for (unsigned i = 0, e = NewElts.size(); i != e; ++i) {
|
2011-06-03 19:46:19 +00:00
|
|
|
Value *Load = Builder.CreateLoad(NewElts[i], "load");
|
|
|
|
Insert = Builder.CreateInsertValue(Insert, Load, i, "insert");
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
|
|
|
LI->replaceAllUsesWith(Insert);
|
|
|
|
DeadInsts.push_back(LI);
|
|
|
|
} else if (LIType->isIntegerTy() &&
|
|
|
|
TD->getTypeAllocSize(LIType) ==
|
|
|
|
TD->getTypeAllocSize(AI->getAllocatedType())) {
|
|
|
|
// If this is a load of the entire alloca to an integer, rewrite it.
|
|
|
|
RewriteLoadUserOfWholeAlloca(LI, AI, NewElts);
|
|
|
|
}
|
2011-01-23 08:27:54 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (StoreInst *SI = dyn_cast<StoreInst>(User)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
Value *Val = SI->getOperand(0);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SIType = Val->getType();
|
2011-01-13 17:45:11 +00:00
|
|
|
if (isCompatibleAggregate(SIType, AI->getAllocatedType())) {
|
2010-04-16 00:24:57 +00:00
|
|
|
// Replace:
|
|
|
|
// store { i32, i32 } %val, { i32, i32 }* %alloc
|
|
|
|
// with:
|
|
|
|
// %val.0 = extractvalue { i32, i32 } %val, 0
|
|
|
|
// store i32 %val.0, i32* %alloc.0
|
|
|
|
// %val.1 = extractvalue { i32, i32 } %val, 1
|
|
|
|
// store i32 %val.1, i32* %alloc.1
|
|
|
|
// (Also works for arrays instead of structs)
|
2011-06-03 19:46:19 +00:00
|
|
|
IRBuilder<> Builder(SI);
|
2010-04-16 00:24:57 +00:00
|
|
|
for (unsigned i = 0, e = NewElts.size(); i != e; ++i) {
|
2011-06-03 19:46:19 +00:00
|
|
|
Value *Extract = Builder.CreateExtractValue(Val, i, Val->getName());
|
|
|
|
Builder.CreateStore(Extract, NewElts[i]);
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
|
|
|
DeadInsts.push_back(SI);
|
|
|
|
} else if (SIType->isIntegerTy() &&
|
|
|
|
TD->getTypeAllocSize(SIType) ==
|
|
|
|
TD->getTypeAllocSize(AI->getAllocatedType())) {
|
|
|
|
// If this is a store of the entire alloca from an integer, rewrite it.
|
|
|
|
RewriteStoreUserOfWholeAlloca(SI, AI, NewElts);
|
2007-05-30 06:11:23 +00:00
|
|
|
}
|
2011-01-23 08:27:54 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isa<SelectInst>(User) || isa<PHINode>(User)) {
|
|
|
|
// If we have a PHI user of the alloca itself (as opposed to a GEP or
|
|
|
|
// bitcast) we have to rewrite it. GEP and bitcast uses will be RAUW'd to
|
|
|
|
// the new pointer.
|
|
|
|
if (!isa<AllocaInst>(I)) continue;
|
|
|
|
|
|
|
|
assert(Offset == 0 && NewElts[0] &&
|
|
|
|
"Direct alloca use should have a zero offset");
|
|
|
|
|
|
|
|
// If we have a use of the alloca, we know the derived uses will be
|
|
|
|
// utilizing just the first element of the scalarized result. Insert a
|
|
|
|
// bitcast of the first alloca before the user as required.
|
|
|
|
AllocaInst *NewAI = NewElts[0];
|
|
|
|
BitCastInst *BCI = new BitCastInst(NewAI, AI->getType(), "", NewAI);
|
|
|
|
NewAI->moveBefore(BCI);
|
|
|
|
TheUse = BCI;
|
|
|
|
continue;
|
2007-05-30 06:11:23 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
|
|
|
}
|
2007-11-04 14:43:57 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// RewriteBitCast - Update a bitcast reference to the alloca being replaced
|
|
|
|
/// and recursively continue updating all of its uses.
|
|
|
|
void SROA::RewriteBitCast(BitCastInst *BC, AllocaInst *AI, uint64_t Offset,
|
|
|
|
SmallVector<AllocaInst*, 32> &NewElts) {
|
|
|
|
RewriteForScalarRepl(BC, AI, Offset, NewElts);
|
|
|
|
if (BC->getOperand(0) != AI)
|
|
|
|
return;
|
2007-05-30 06:11:23 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// The bitcast references the original alloca. Replace its uses with
|
2011-11-12 02:07:50 +00:00
|
|
|
// references to the alloca containing offset zero (which is normally at
|
|
|
|
// index zero, but might not be in cases involving structs with elements
|
|
|
|
// of size zero).
|
|
|
|
Type *T = AI->getAllocatedType();
|
|
|
|
uint64_t EltOffset = 0;
|
|
|
|
Type *IdxTy;
|
|
|
|
uint64_t Idx = FindElementAndOffset(T, EltOffset, IdxTy);
|
|
|
|
Instruction *Val = NewElts[Idx];
|
2010-04-16 00:24:57 +00:00
|
|
|
if (Val->getType() != BC->getDestTy()) {
|
|
|
|
Val = new BitCastInst(Val, BC->getDestTy(), "", BC);
|
|
|
|
Val->takeName(BC);
|
2007-05-30 06:11:23 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
BC->replaceAllUsesWith(Val);
|
|
|
|
DeadInsts.push_back(BC);
|
2007-05-30 06:11:23 +00:00
|
|
|
}
|
2007-03-05 07:52:57 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// FindElementAndOffset - Return the index of the element containing Offset
|
|
|
|
/// within the specified type, which must be either a struct or an array.
|
|
|
|
/// Sets T to the type of the element and Offset to the offset within that
|
|
|
|
/// element. IdxTy is set to the type of the index result to be used in a
|
|
|
|
/// GEP instruction.
|
2011-07-18 04:54:35 +00:00
|
|
|
uint64_t SROA::FindElementAndOffset(Type *&T, uint64_t &Offset,
|
|
|
|
Type *&IdxTy) {
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t Idx = 0;
|
2011-07-18 04:54:35 +00:00
|
|
|
if (StructType *ST = dyn_cast<StructType>(T)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
const StructLayout *Layout = TD->getStructLayout(ST);
|
|
|
|
Idx = Layout->getElementContainingOffset(Offset);
|
|
|
|
T = ST->getContainedType(Idx);
|
|
|
|
Offset -= Layout->getElementOffset(Idx);
|
|
|
|
IdxTy = Type::getInt32Ty(T->getContext());
|
|
|
|
return Idx;
|
2004-11-14 04:24:28 +00:00
|
|
|
}
|
2011-07-18 04:54:35 +00:00
|
|
|
ArrayType *AT = cast<ArrayType>(T);
|
2010-04-16 00:24:57 +00:00
|
|
|
T = AT->getElementType();
|
|
|
|
uint64_t EltSize = TD->getTypeAllocSize(T);
|
|
|
|
Idx = Offset / EltSize;
|
|
|
|
Offset -= Idx * EltSize;
|
|
|
|
IdxTy = Type::getInt64Ty(T->getContext());
|
|
|
|
return Idx;
|
2003-05-30 04:15:41 +00:00
|
|
|
}
|
2005-12-12 07:19:13 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// RewriteGEP - Check if this GEP instruction moves the pointer across
|
|
|
|
/// elements of the alloca that are being split apart, and if so, rewrite
|
|
|
|
/// the GEP to be relative to the new element.
|
|
|
|
void SROA::RewriteGEP(GetElementPtrInst *GEPI, AllocaInst *AI, uint64_t Offset,
|
|
|
|
SmallVector<AllocaInst*, 32> &NewElts) {
|
|
|
|
uint64_t OldOffset = Offset;
|
|
|
|
SmallVector<Value*, 8> Indices(GEPI->op_begin() + 1, GEPI->op_end());
|
2011-07-19 14:01:37 +00:00
|
|
|
Offset += TD->getIndexedOffset(GEPI->getPointerOperandType(), Indices);
|
2010-04-16 00:24:57 +00:00
|
|
|
|
|
|
|
RewriteForScalarRepl(GEPI, AI, Offset, NewElts);
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *T = AI->getAllocatedType();
|
|
|
|
Type *IdxTy;
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t OldIdx = FindElementAndOffset(T, OldOffset, IdxTy);
|
|
|
|
if (GEPI->getOperand(0) == AI)
|
|
|
|
OldIdx = ~0ULL; // Force the GEP to be rewritten.
|
|
|
|
|
|
|
|
T = AI->getAllocatedType();
|
|
|
|
uint64_t EltOffset = Offset;
|
|
|
|
uint64_t Idx = FindElementAndOffset(T, EltOffset, IdxTy);
|
|
|
|
|
|
|
|
// If this GEP does not move the pointer across elements of the alloca
|
|
|
|
// being split, then it does not needs to be rewritten.
|
|
|
|
if (Idx == OldIdx)
|
2010-04-15 23:50:26 +00:00
|
|
|
return;
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *i32Ty = Type::getInt32Ty(AI->getContext());
|
2010-04-16 00:24:57 +00:00
|
|
|
SmallVector<Value*, 8> NewArgs;
|
|
|
|
NewArgs.push_back(Constant::getNullValue(i32Ty));
|
|
|
|
while (EltOffset != 0) {
|
|
|
|
uint64_t EltIdx = FindElementAndOffset(T, EltOffset, IdxTy);
|
|
|
|
NewArgs.push_back(ConstantInt::get(IdxTy, EltIdx));
|
2009-01-31 02:28:54 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
Instruction *Val = NewElts[Idx];
|
|
|
|
if (NewArgs.size() > 1) {
|
2011-07-25 09:48:08 +00:00
|
|
|
Val = GetElementPtrInst::CreateInBounds(Val, NewArgs, "", GEPI);
|
2010-04-16 00:24:57 +00:00
|
|
|
Val->takeName(GEPI);
|
|
|
|
}
|
|
|
|
if (Val->getType() != GEPI->getType())
|
|
|
|
Val = new BitCastInst(Val, GEPI->getType(), Val->getName(), GEPI);
|
|
|
|
GEPI->replaceAllUsesWith(Val);
|
|
|
|
DeadInsts.push_back(GEPI);
|
2005-12-12 07:19:13 +00:00
|
|
|
}
|
|
|
|
|
2011-07-25 23:14:22 +00:00
|
|
|
/// RewriteLifetimeIntrinsic - II is a lifetime.start/lifetime.end. Rewrite it
|
|
|
|
/// to mark the lifetime of the scalarized memory.
|
|
|
|
void SROA::RewriteLifetimeIntrinsic(IntrinsicInst *II, AllocaInst *AI,
|
|
|
|
uint64_t Offset,
|
|
|
|
SmallVector<AllocaInst*, 32> &NewElts) {
|
|
|
|
ConstantInt *OldSize = cast<ConstantInt>(II->getArgOperand(0));
|
|
|
|
// Put matching lifetime markers on everything from Offset up to
|
|
|
|
// Offset+OldSize.
|
|
|
|
Type *AIType = AI->getAllocatedType();
|
|
|
|
uint64_t NewOffset = Offset;
|
|
|
|
Type *IdxTy;
|
|
|
|
uint64_t Idx = FindElementAndOffset(AIType, NewOffset, IdxTy);
|
|
|
|
|
|
|
|
IRBuilder<> Builder(II);
|
|
|
|
uint64_t Size = OldSize->getLimitedValue();
|
|
|
|
|
|
|
|
if (NewOffset) {
|
|
|
|
// Splice the first element and index 'NewOffset' bytes in. SROA will
|
|
|
|
// split the alloca again later.
|
|
|
|
Value *V = Builder.CreateBitCast(NewElts[Idx], Builder.getInt8PtrTy());
|
|
|
|
V = Builder.CreateGEP(V, Builder.getInt64(NewOffset));
|
|
|
|
|
|
|
|
IdxTy = NewElts[Idx]->getAllocatedType();
|
|
|
|
uint64_t EltSize = TD->getTypeAllocSize(IdxTy) - NewOffset;
|
|
|
|
if (EltSize > Size) {
|
|
|
|
EltSize = Size;
|
|
|
|
Size = 0;
|
|
|
|
} else {
|
|
|
|
Size -= EltSize;
|
|
|
|
}
|
|
|
|
if (II->getIntrinsicID() == Intrinsic::lifetime_start)
|
|
|
|
Builder.CreateLifetimeStart(V, Builder.getInt64(EltSize));
|
|
|
|
else
|
|
|
|
Builder.CreateLifetimeEnd(V, Builder.getInt64(EltSize));
|
|
|
|
++Idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (; Idx != NewElts.size() && Size; ++Idx) {
|
|
|
|
IdxTy = NewElts[Idx]->getAllocatedType();
|
|
|
|
uint64_t EltSize = TD->getTypeAllocSize(IdxTy);
|
|
|
|
if (EltSize > Size) {
|
|
|
|
EltSize = Size;
|
|
|
|
Size = 0;
|
|
|
|
} else {
|
|
|
|
Size -= EltSize;
|
|
|
|
}
|
|
|
|
if (II->getIntrinsicID() == Intrinsic::lifetime_start)
|
|
|
|
Builder.CreateLifetimeStart(NewElts[Idx],
|
|
|
|
Builder.getInt64(EltSize));
|
|
|
|
else
|
|
|
|
Builder.CreateLifetimeEnd(NewElts[Idx],
|
|
|
|
Builder.getInt64(EltSize));
|
|
|
|
}
|
|
|
|
DeadInsts.push_back(II);
|
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// RewriteMemIntrinUserOfAlloca - MI is a memcpy/memset/memmove from or to AI.
|
|
|
|
/// Rewrite it to copy or set the elements of the scalarized memory.
|
|
|
|
void SROA::RewriteMemIntrinUserOfAlloca(MemIntrinsic *MI, Instruction *Inst,
|
|
|
|
AllocaInst *AI,
|
|
|
|
SmallVector<AllocaInst*, 32> &NewElts) {
|
|
|
|
// If this is a memcpy/memmove, construct the other pointer as the
|
|
|
|
// appropriate type. The "Other" pointer is the pointer that goes to memory
|
|
|
|
// that doesn't have anything to do with the alloca that we are promoting. For
|
|
|
|
// memset, this Value* stays null.
|
|
|
|
Value *OtherPtr = 0;
|
|
|
|
unsigned MemAlignment = MI->getAlignment();
|
|
|
|
if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI)) { // memmove/memcopy
|
|
|
|
if (Inst == MTI->getRawDest())
|
|
|
|
OtherPtr = MTI->getRawSource();
|
|
|
|
else {
|
|
|
|
assert(Inst == MTI->getRawSource());
|
|
|
|
OtherPtr = MTI->getRawDest();
|
2005-12-12 07:19:13 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
2009-03-08 03:37:16 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If there is an other pointer, we want to convert it to the same pointer
|
|
|
|
// type as AI has, so we can GEP through it safely.
|
|
|
|
if (OtherPtr) {
|
2010-07-08 00:27:05 +00:00
|
|
|
unsigned AddrSpace =
|
|
|
|
cast<PointerType>(OtherPtr->getType())->getAddressSpace();
|
2010-04-16 00:24:57 +00:00
|
|
|
|
|
|
|
// Remove bitcasts and all-zero GEPs from OtherPtr. This is an
|
|
|
|
// optimization, but it's also required to detect the corner case where
|
|
|
|
// both pointer operands are referencing the same memory, and where
|
|
|
|
// OtherPtr may be a bitcast or GEP that currently being rewritten. (This
|
|
|
|
// function is only called for mem intrinsics that access the whole
|
|
|
|
// aggregate, so non-zero GEPs are not an issue here.)
|
2010-07-08 00:27:05 +00:00
|
|
|
OtherPtr = OtherPtr->stripPointerCasts();
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Copying the alloca to itself is a no-op: just delete it.
|
|
|
|
if (OtherPtr == AI || OtherPtr == NewElts[0]) {
|
|
|
|
// This code will run twice for a no-op memcpy -- once for each operand.
|
|
|
|
// Put only one reference to MI on the DeadInsts list.
|
|
|
|
for (SmallVector<Value*, 32>::const_iterator I = DeadInsts.begin(),
|
|
|
|
E = DeadInsts.end(); I != E; ++I)
|
|
|
|
if (*I == MI) return;
|
|
|
|
DeadInsts.push_back(MI);
|
|
|
|
return;
|
2009-03-08 04:04:21 +00:00
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If the pointer is not the right type, insert a bitcast to the right
|
|
|
|
// type.
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *NewTy =
|
2010-07-08 00:27:05 +00:00
|
|
|
PointerType::get(AI->getType()->getElementType(), AddrSpace);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-07-08 00:27:05 +00:00
|
|
|
if (OtherPtr->getType() != NewTy)
|
|
|
|
OtherPtr = new BitCastInst(OtherPtr, NewTy, OtherPtr->getName(), MI);
|
2005-12-12 07:19:13 +00:00
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Process each element of the aggregate.
|
|
|
|
bool SROADest = MI->getRawDest() == Inst;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
Constant *Zero = Constant::getNullValue(Type::getInt32Ty(MI->getContext()));
|
2009-02-02 10:06:20 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
for (unsigned i = 0, e = NewElts.size(); i != e; ++i) {
|
|
|
|
// If this is a memcpy/memmove, emit a GEP of the other element address.
|
|
|
|
Value *OtherElt = 0;
|
|
|
|
unsigned OtherEltAlign = MemAlignment;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (OtherPtr) {
|
|
|
|
Value *Idx[2] = { Zero,
|
|
|
|
ConstantInt::get(Type::getInt32Ty(MI->getContext()), i) };
|
2011-07-25 09:48:08 +00:00
|
|
|
OtherElt = GetElementPtrInst::CreateInBounds(OtherPtr, Idx,
|
2010-04-16 00:24:57 +00:00
|
|
|
OtherPtr->getName()+"."+Twine(i),
|
|
|
|
MI);
|
|
|
|
uint64_t EltOffset;
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *OtherPtrTy = cast<PointerType>(OtherPtr->getType());
|
|
|
|
Type *OtherTy = OtherPtrTy->getElementType();
|
|
|
|
if (StructType *ST = dyn_cast<StructType>(OtherTy)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
EltOffset = TD->getStructLayout(ST)->getElementOffset(i);
|
|
|
|
} else {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *EltTy = cast<SequentialType>(OtherTy)->getElementType();
|
2010-04-16 00:24:57 +00:00
|
|
|
EltOffset = TD->getTypeAllocSize(EltTy)*i;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// The alignment of the other pointer is the guaranteed alignment of the
|
|
|
|
// element, which is affected by both the known alignment of the whole
|
|
|
|
// mem intrinsic and the alignment of the element. If the alignment of
|
|
|
|
// the memcpy (f.e.) is 32 but the element is at a 4-byte offset, then the
|
|
|
|
// known alignment is just 4 bytes.
|
|
|
|
OtherEltAlign = (unsigned)MinAlign(OtherEltAlign, EltOffset);
|
2009-02-03 19:45:44 +00:00
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
Value *EltPtr = NewElts[i];
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *EltTy = cast<PointerType>(EltPtr->getType())->getElementType();
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If we got down to a scalar, insert a load or store as appropriate.
|
|
|
|
if (EltTy->isSingleValueType()) {
|
|
|
|
if (isa<MemTransferInst>(MI)) {
|
|
|
|
if (SROADest) {
|
|
|
|
// From Other to Alloca.
|
|
|
|
Value *Elt = new LoadInst(OtherElt, "tmp", false, OtherEltAlign, MI);
|
|
|
|
new StoreInst(Elt, EltPtr, MI);
|
|
|
|
} else {
|
|
|
|
// From Alloca to Other.
|
|
|
|
Value *Elt = new LoadInst(EltPtr, "tmp", MI);
|
|
|
|
new StoreInst(Elt, OtherElt, false, OtherEltAlign, MI);
|
|
|
|
}
|
|
|
|
continue;
|
2009-04-21 16:52:12 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
assert(isa<MemSetInst>(MI));
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If the stored element is zero (common case), just store a null
|
|
|
|
// constant.
|
|
|
|
Constant *StoreVal;
|
2010-06-30 09:16:16 +00:00
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(MI->getArgOperand(1))) {
|
2010-04-16 00:24:57 +00:00
|
|
|
if (CI->isZero()) {
|
|
|
|
StoreVal = Constant::getNullValue(EltTy); // 0.0, null, 0, <0,0>
|
|
|
|
} else {
|
|
|
|
// If EltTy is a vector type, get the element type.
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ValTy = EltTy->getScalarType();
|
2009-03-08 04:04:21 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Construct an integer with the right value.
|
|
|
|
unsigned EltSize = TD->getTypeSizeInBits(ValTy);
|
|
|
|
APInt OneVal(EltSize, CI->getZExtValue());
|
|
|
|
APInt TotalVal(OneVal);
|
|
|
|
// Set each byte.
|
|
|
|
for (unsigned i = 0; 8*i < EltSize; ++i) {
|
|
|
|
TotalVal = TotalVal.shl(8);
|
|
|
|
TotalVal |= OneVal;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Convert the integer value to the appropriate type.
|
2010-04-16 01:05:38 +00:00
|
|
|
StoreVal = ConstantInt::get(CI->getContext(), TotalVal);
|
2010-04-16 00:24:57 +00:00
|
|
|
if (ValTy->isPointerTy())
|
|
|
|
StoreVal = ConstantExpr::getIntToPtr(StoreVal, ValTy);
|
|
|
|
else if (ValTy->isFloatingPointTy())
|
|
|
|
StoreVal = ConstantExpr::getBitCast(StoreVal, ValTy);
|
|
|
|
assert(StoreVal->getType() == ValTy && "Type mismatch!");
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If the requested value was a vector constant, create it.
|
2011-10-11 21:26:40 +00:00
|
|
|
if (EltTy->isVectorTy()) {
|
|
|
|
unsigned NumElts = cast<VectorType>(EltTy)->getNumElements();
|
2012-01-25 06:02:56 +00:00
|
|
|
StoreVal = ConstantVector::getSplat(NumElts, StoreVal);
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
new StoreInst(StoreVal, EltPtr, MI);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// Otherwise, if we're storing a byte variable, use a memset call for
|
|
|
|
// this element.
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
unsigned EltSize = TD->getTypeAllocSize(EltTy);
|
2011-11-12 02:07:50 +00:00
|
|
|
if (!EltSize)
|
|
|
|
continue;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-12-26 22:57:41 +00:00
|
|
|
IRBuilder<> Builder(MI);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Finally, insert the meminst for this element.
|
2010-12-26 22:57:41 +00:00
|
|
|
if (isa<MemSetInst>(MI)) {
|
|
|
|
Builder.CreateMemSet(EltPtr, MI->getArgOperand(1), EltSize,
|
|
|
|
MI->isVolatile());
|
2010-04-16 00:24:57 +00:00
|
|
|
} else {
|
2010-12-26 22:57:41 +00:00
|
|
|
assert(isa<MemTransferInst>(MI));
|
|
|
|
Value *Dst = SROADest ? EltPtr : OtherElt; // Dest ptr
|
|
|
|
Value *Src = SROADest ? OtherElt : EltPtr; // Src ptr
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-12-26 22:57:41 +00:00
|
|
|
if (isa<MemCpyInst>(MI))
|
|
|
|
Builder.CreateMemCpy(Dst, Src, EltSize, OtherEltAlign,MI->isVolatile());
|
|
|
|
else
|
|
|
|
Builder.CreateMemMove(Dst, Src, EltSize,OtherEltAlign,MI->isVolatile());
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
2005-12-12 07:19:13 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
DeadInsts.push_back(MI);
|
2005-12-12 07:19:13 +00:00
|
|
|
}
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// RewriteStoreUserOfWholeAlloca - We found a store of an integer that
|
|
|
|
/// overwrites the entire allocation. Extract out the pieces of the stored
|
|
|
|
/// integer and store them individually.
|
|
|
|
void SROA::RewriteStoreUserOfWholeAlloca(StoreInst *SI, AllocaInst *AI,
|
|
|
|
SmallVector<AllocaInst*, 32> &NewElts){
|
|
|
|
// Extract each element out of the integer according to its structure offset
|
|
|
|
// and store the element value to the individual alloca.
|
|
|
|
Value *SrcVal = SI->getOperand(0);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *AllocaEltTy = AI->getAllocatedType();
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t AllocaSizeBits = TD->getTypeAllocSizeInBits(AllocaEltTy);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-01-16 05:58:24 +00:00
|
|
|
IRBuilder<> Builder(SI);
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Handle tail padding by extending the operand
|
|
|
|
if (TD->getTypeSizeInBits(SrcVal->getType()) != AllocaSizeBits)
|
2011-01-16 05:58:24 +00:00
|
|
|
SrcVal = Builder.CreateZExt(SrcVal,
|
|
|
|
IntegerType::get(SI->getContext(), AllocaSizeBits));
|
2009-02-02 10:06:20 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
DEBUG(dbgs() << "PROMOTING STORE TO WHOLE ALLOCA: " << *AI << '\n' << *SI
|
|
|
|
<< '\n');
|
2009-02-02 10:06:20 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// There are two forms here: AI could be an array or struct. Both cases
|
|
|
|
// have different ways to compute the element offset.
|
2011-07-18 04:54:35 +00:00
|
|
|
if (StructType *EltSTy = dyn_cast<StructType>(AllocaEltTy)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
const StructLayout *Layout = TD->getStructLayout(EltSTy);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
for (unsigned i = 0, e = NewElts.size(); i != e; ++i) {
|
|
|
|
// Get the number of bits to shift SrcVal to get the value.
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *FieldTy = EltSTy->getElementType(i);
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t Shift = Layout->getElementOffsetInBits(i);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (TD->isBigEndian())
|
|
|
|
Shift = AllocaSizeBits-Shift-TD->getTypeAllocSizeInBits(FieldTy);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
Value *EltVal = SrcVal;
|
|
|
|
if (Shift) {
|
|
|
|
Value *ShiftVal = ConstantInt::get(EltVal->getType(), Shift);
|
2011-01-16 05:58:24 +00:00
|
|
|
EltVal = Builder.CreateLShr(EltVal, ShiftVal, "sroa.store.elt");
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Truncate down to an integer of the right size.
|
|
|
|
uint64_t FieldSizeBits = TD->getTypeSizeInBits(FieldTy);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Ignore zero sized fields like {}, they obviously contain no data.
|
|
|
|
if (FieldSizeBits == 0) continue;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (FieldSizeBits != AllocaSizeBits)
|
2011-01-16 05:58:24 +00:00
|
|
|
EltVal = Builder.CreateTrunc(EltVal,
|
|
|
|
IntegerType::get(SI->getContext(), FieldSizeBits));
|
2010-04-16 00:24:57 +00:00
|
|
|
Value *DestField = NewElts[i];
|
|
|
|
if (EltVal->getType() == FieldTy) {
|
|
|
|
// Storing to an integer field of this size, just do it.
|
|
|
|
} else if (FieldTy->isFloatingPointTy() || FieldTy->isVectorTy()) {
|
|
|
|
// Bitcast to the right element type (for fp/vector values).
|
2011-01-16 05:58:24 +00:00
|
|
|
EltVal = Builder.CreateBitCast(EltVal, FieldTy);
|
2010-04-16 00:24:57 +00:00
|
|
|
} else {
|
|
|
|
// Otherwise, bitcast the dest pointer (for aggregates).
|
2011-01-16 05:58:24 +00:00
|
|
|
DestField = Builder.CreateBitCast(DestField,
|
|
|
|
PointerType::getUnqual(EltVal->getType()));
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
|
|
|
new StoreInst(EltVal, DestField, SI);
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2008-02-29 07:12:06 +00:00
|
|
|
} else {
|
2011-07-18 04:54:35 +00:00
|
|
|
ArrayType *ATy = cast<ArrayType>(AllocaEltTy);
|
|
|
|
Type *ArrayEltTy = ATy->getElementType();
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t ElementOffset = TD->getTypeAllocSizeInBits(ArrayEltTy);
|
|
|
|
uint64_t ElementSizeBits = TD->getTypeSizeInBits(ArrayEltTy);
|
2009-02-02 10:06:20 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t Shift;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (TD->isBigEndian())
|
|
|
|
Shift = AllocaSizeBits-ElementOffset;
|
2011-01-13 20:59:44 +00:00
|
|
|
else
|
2010-04-16 00:24:57 +00:00
|
|
|
Shift = 0;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
for (unsigned i = 0, e = NewElts.size(); i != e; ++i) {
|
|
|
|
// Ignore zero sized fields like {}, they obviously contain no data.
|
|
|
|
if (ElementSizeBits == 0) continue;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
Value *EltVal = SrcVal;
|
|
|
|
if (Shift) {
|
|
|
|
Value *ShiftVal = ConstantInt::get(EltVal->getType(), Shift);
|
2011-01-16 05:58:24 +00:00
|
|
|
EltVal = Builder.CreateLShr(EltVal, ShiftVal, "sroa.store.elt");
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Truncate down to an integer of the right size.
|
|
|
|
if (ElementSizeBits != AllocaSizeBits)
|
2011-01-16 05:58:24 +00:00
|
|
|
EltVal = Builder.CreateTrunc(EltVal,
|
|
|
|
IntegerType::get(SI->getContext(),
|
|
|
|
ElementSizeBits));
|
2010-04-16 00:24:57 +00:00
|
|
|
Value *DestField = NewElts[i];
|
|
|
|
if (EltVal->getType() == ArrayEltTy) {
|
|
|
|
// Storing to an integer field of this size, just do it.
|
|
|
|
} else if (ArrayEltTy->isFloatingPointTy() ||
|
|
|
|
ArrayEltTy->isVectorTy()) {
|
|
|
|
// Bitcast to the right element type (for fp/vector values).
|
2011-01-16 05:58:24 +00:00
|
|
|
EltVal = Builder.CreateBitCast(EltVal, ArrayEltTy);
|
2010-04-16 00:24:57 +00:00
|
|
|
} else {
|
|
|
|
// Otherwise, bitcast the dest pointer (for aggregates).
|
2011-01-16 05:58:24 +00:00
|
|
|
DestField = Builder.CreateBitCast(DestField,
|
|
|
|
PointerType::getUnqual(EltVal->getType()));
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
|
|
|
new StoreInst(EltVal, DestField, SI);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (TD->isBigEndian())
|
|
|
|
Shift -= ElementOffset;
|
2011-01-13 20:59:44 +00:00
|
|
|
else
|
2010-04-16 00:24:57 +00:00
|
|
|
Shift += ElementOffset;
|
|
|
|
}
|
2008-02-29 07:03:13 +00:00
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
DeadInsts.push_back(SI);
|
2008-02-29 07:03:13 +00:00
|
|
|
}
|
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// RewriteLoadUserOfWholeAlloca - We found a load of the entire allocation to
|
|
|
|
/// an integer. Load the individual pieces to form the aggregate value.
|
|
|
|
void SROA::RewriteLoadUserOfWholeAlloca(LoadInst *LI, AllocaInst *AI,
|
|
|
|
SmallVector<AllocaInst*, 32> &NewElts) {
|
|
|
|
// Extract each element out of the NewElts according to its structure offset
|
|
|
|
// and form the result value.
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *AllocaEltTy = AI->getAllocatedType();
|
2010-04-16 00:24:57 +00:00
|
|
|
uint64_t AllocaSizeBits = TD->getTypeAllocSizeInBits(AllocaEltTy);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
DEBUG(dbgs() << "PROMOTING LOAD OF WHOLE ALLOCA: " << *AI << '\n' << *LI
|
|
|
|
<< '\n');
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// There are two forms here: AI could be an array or struct. Both cases
|
|
|
|
// have different ways to compute the element offset.
|
|
|
|
const StructLayout *Layout = 0;
|
|
|
|
uint64_t ArrayEltBitOffset = 0;
|
2011-07-18 04:54:35 +00:00
|
|
|
if (StructType *EltSTy = dyn_cast<StructType>(AllocaEltTy)) {
|
2010-04-16 00:24:57 +00:00
|
|
|
Layout = TD->getStructLayout(EltSTy);
|
|
|
|
} else {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ArrayEltTy = cast<ArrayType>(AllocaEltTy)->getElementType();
|
2010-04-16 00:24:57 +00:00
|
|
|
ArrayEltBitOffset = TD->getTypeAllocSizeInBits(ArrayEltTy);
|
2011-01-13 20:59:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Value *ResultVal =
|
2010-04-16 00:24:57 +00:00
|
|
|
Constant::getNullValue(IntegerType::get(LI->getContext(), AllocaSizeBits));
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
for (unsigned i = 0, e = NewElts.size(); i != e; ++i) {
|
|
|
|
// Load the value from the alloca. If the NewElt is an aggregate, cast
|
|
|
|
// the pointer to an integer of the same size before doing the load.
|
|
|
|
Value *SrcField = NewElts[i];
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *FieldTy =
|
2010-04-16 00:24:57 +00:00
|
|
|
cast<PointerType>(SrcField->getType())->getElementType();
|
|
|
|
uint64_t FieldSizeBits = TD->getTypeSizeInBits(FieldTy);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Ignore zero sized fields like {}, they obviously contain no data.
|
|
|
|
if (FieldSizeBits == 0) continue;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
IntegerType *FieldIntTy = IntegerType::get(LI->getContext(),
|
2010-04-16 00:24:57 +00:00
|
|
|
FieldSizeBits);
|
|
|
|
if (!FieldTy->isIntegerTy() && !FieldTy->isFloatingPointTy() &&
|
|
|
|
!FieldTy->isVectorTy())
|
|
|
|
SrcField = new BitCastInst(SrcField,
|
|
|
|
PointerType::getUnqual(FieldIntTy),
|
|
|
|
"", LI);
|
|
|
|
SrcField = new LoadInst(SrcField, "sroa.load.elt", LI);
|
2009-03-08 04:17:04 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// If SrcField is a fp or vector of the right size but that isn't an
|
|
|
|
// integer type, bitcast to an integer so we can shift it.
|
|
|
|
if (SrcField->getType() != FieldIntTy)
|
|
|
|
SrcField = new BitCastInst(SrcField, FieldIntTy, "", LI);
|
2009-03-08 04:17:04 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Zero extend the field to be the same size as the final alloca so that
|
|
|
|
// we can shift and insert it.
|
|
|
|
if (SrcField->getType() != ResultVal->getType())
|
|
|
|
SrcField = new ZExtInst(SrcField, ResultVal->getType(), "", LI);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Determine the number of bits to shift SrcField.
|
|
|
|
uint64_t Shift;
|
|
|
|
if (Layout) // Struct case.
|
|
|
|
Shift = Layout->getElementOffsetInBits(i);
|
|
|
|
else // Array case.
|
|
|
|
Shift = i*ArrayEltBitOffset;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (TD->isBigEndian())
|
|
|
|
Shift = AllocaSizeBits-Shift-FieldIntTy->getBitWidth();
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
if (Shift) {
|
|
|
|
Value *ShiftVal = ConstantInt::get(SrcField->getType(), Shift);
|
|
|
|
SrcField = BinaryOperator::CreateShl(SrcField, ShiftVal, "", LI);
|
2009-02-03 19:30:11 +00:00
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
|
2010-06-27 07:58:26 +00:00
|
|
|
// Don't create an 'or x, 0' on the first iteration.
|
|
|
|
if (!isa<Constant>(ResultVal) ||
|
|
|
|
!cast<Constant>(ResultVal)->isNullValue())
|
|
|
|
ResultVal = BinaryOperator::CreateOr(SrcField, ResultVal, "", LI);
|
|
|
|
else
|
|
|
|
ResultVal = SrcField;
|
2009-02-03 19:30:11 +00:00
|
|
|
}
|
2009-02-02 10:06:20 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Handle tail padding by truncating the result
|
|
|
|
if (TD->getTypeSizeInBits(LI->getType()) != AllocaSizeBits)
|
|
|
|
ResultVal = new TruncInst(ResultVal, LI->getType(), "", LI);
|
2009-02-02 10:06:20 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
LI->replaceAllUsesWith(ResultVal);
|
|
|
|
DeadInsts.push_back(LI);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// HasPadding - Return true if the specified type has any structure or
|
2011-01-13 17:45:08 +00:00
|
|
|
/// alignment padding in between the elements that would be split apart
|
|
|
|
/// by SROA; return false otherwise.
|
2011-07-18 04:54:35 +00:00
|
|
|
static bool HasPadding(Type *Ty, const TargetData &TD) {
|
|
|
|
if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
|
2011-01-13 17:45:08 +00:00
|
|
|
Ty = ATy->getElementType();
|
|
|
|
return TD.getTypeSizeInBits(Ty) != TD.getTypeAllocSizeInBits(Ty);
|
|
|
|
}
|
2010-04-16 00:24:57 +00:00
|
|
|
|
2011-01-13 17:45:08 +00:00
|
|
|
// SROA currently handles only Arrays and Structs.
|
2011-07-18 04:54:35 +00:00
|
|
|
StructType *STy = cast<StructType>(Ty);
|
2011-01-13 17:45:08 +00:00
|
|
|
const StructLayout *SL = TD.getStructLayout(STy);
|
|
|
|
unsigned PrevFieldBitOffset = 0;
|
|
|
|
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
|
|
|
|
unsigned FieldBitOffset = SL->getElementOffsetInBits(i);
|
|
|
|
|
|
|
|
// Check to see if there is any padding between this element and the
|
|
|
|
// previous one.
|
|
|
|
if (i) {
|
|
|
|
unsigned PrevFieldEnd =
|
2010-04-16 00:24:57 +00:00
|
|
|
PrevFieldBitOffset+TD.getTypeSizeInBits(STy->getElementType(i-1));
|
2011-01-13 17:45:08 +00:00
|
|
|
if (PrevFieldEnd < FieldBitOffset)
|
2010-04-16 00:24:57 +00:00
|
|
|
return true;
|
|
|
|
}
|
2011-01-13 17:45:08 +00:00
|
|
|
PrevFieldBitOffset = FieldBitOffset;
|
2009-01-31 02:28:54 +00:00
|
|
|
}
|
2011-01-13 17:45:08 +00:00
|
|
|
// Check for tail padding.
|
|
|
|
if (unsigned EltCount = STy->getNumElements()) {
|
|
|
|
unsigned PrevFieldEnd = PrevFieldBitOffset +
|
|
|
|
TD.getTypeSizeInBits(STy->getElementType(EltCount-1));
|
|
|
|
if (PrevFieldEnd < SL->getSizeInBits())
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
2010-04-16 00:24:57 +00:00
|
|
|
}
|
2009-02-02 10:06:20 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
/// isSafeStructAllocaToScalarRepl - Check to see if the specified allocation of
|
|
|
|
/// an aggregate can be broken down into elements. Return 0 if not, 3 if safe,
|
|
|
|
/// or 1 if safe after canonicalization has been performed.
|
|
|
|
bool SROA::isSafeAllocaToScalarRepl(AllocaInst *AI) {
|
|
|
|
// Loop over the use list of the alloca. We can only transform it if all of
|
|
|
|
// the users are safe to transform.
|
2011-01-23 07:29:29 +00:00
|
|
|
AllocaInfo Info(AI);
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-01-23 07:29:29 +00:00
|
|
|
isSafeForScalarRepl(AI, 0, Info);
|
2010-04-16 00:24:57 +00:00
|
|
|
if (Info.isUnsafe) {
|
|
|
|
DEBUG(dbgs() << "Cannot transform: " << *AI << '\n');
|
|
|
|
return false;
|
2008-02-29 07:03:13 +00:00
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
// Okay, we know all the users are promotable. If the aggregate is a memcpy
|
|
|
|
// source and destination, we have to be careful. In particular, the memcpy
|
|
|
|
// could be moving around elements that live in structure padding of the LLVM
|
|
|
|
// types, but may actually be used. In these cases, we refuse to promote the
|
|
|
|
// struct.
|
|
|
|
if (Info.isMemCpySrc && Info.isMemCpyDst &&
|
|
|
|
HasPadding(AI->getAllocatedType(), *TD))
|
|
|
|
return false;
|
|
|
|
|
2011-01-16 17:46:19 +00:00
|
|
|
// If the alloca never has an access to just *part* of it, but is accessed
|
|
|
|
// via loads and stores, then we should use ConvertToScalarInfo to promote
|
if an alloca is only ever accessed as a unit, and is accessed with load/store instructions,
then don't try to decimate it into its individual pieces. This will just make a mess of the
IR and is pointless if none of the elements are individually accessed. This was generating
really terrible code for std::bitset (PR8980) because it happens to be lowered by clang
as an {[8 x i8]} structure instead of {i64}.
The testcase now is optimized to:
define i64 @test2(i64 %X) {
br label %L2
L2: ; preds = %0
ret i64 %X
}
before we generated:
define i64 @test2(i64 %X) {
%sroa.store.elt = lshr i64 %X, 56
%1 = trunc i64 %sroa.store.elt to i8
%sroa.store.elt8 = lshr i64 %X, 48
%2 = trunc i64 %sroa.store.elt8 to i8
%sroa.store.elt9 = lshr i64 %X, 40
%3 = trunc i64 %sroa.store.elt9 to i8
%sroa.store.elt10 = lshr i64 %X, 32
%4 = trunc i64 %sroa.store.elt10 to i8
%sroa.store.elt11 = lshr i64 %X, 24
%5 = trunc i64 %sroa.store.elt11 to i8
%sroa.store.elt12 = lshr i64 %X, 16
%6 = trunc i64 %sroa.store.elt12 to i8
%sroa.store.elt13 = lshr i64 %X, 8
%7 = trunc i64 %sroa.store.elt13 to i8
%8 = trunc i64 %X to i8
br label %L2
L2: ; preds = %0
%9 = zext i8 %1 to i64
%10 = shl i64 %9, 56
%11 = zext i8 %2 to i64
%12 = shl i64 %11, 48
%13 = or i64 %12, %10
%14 = zext i8 %3 to i64
%15 = shl i64 %14, 40
%16 = or i64 %15, %13
%17 = zext i8 %4 to i64
%18 = shl i64 %17, 32
%19 = or i64 %18, %16
%20 = zext i8 %5 to i64
%21 = shl i64 %20, 24
%22 = or i64 %21, %19
%23 = zext i8 %6 to i64
%24 = shl i64 %23, 16
%25 = or i64 %24, %22
%26 = zext i8 %7 to i64
%27 = shl i64 %26, 8
%28 = or i64 %27, %25
%29 = zext i8 %8 to i64
%30 = or i64 %29, %28
ret i64 %30
}
In this case, instcombine was able to eliminate the nonsense, but in PR8980 enough
PHIs are in play that instcombine backs off. It's better to not generate this stuff
in the first place.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@123571 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-16 06:18:28 +00:00
|
|
|
// the alloca instead of promoting each piece at a time and inserting fission
|
|
|
|
// and fusion code.
|
|
|
|
if (!Info.hasSubelementAccess && Info.hasALoadOrStore) {
|
|
|
|
// If the struct/array just has one element, use basic SRoA.
|
2011-07-18 04:54:35 +00:00
|
|
|
if (StructType *ST = dyn_cast<StructType>(AI->getAllocatedType())) {
|
if an alloca is only ever accessed as a unit, and is accessed with load/store instructions,
then don't try to decimate it into its individual pieces. This will just make a mess of the
IR and is pointless if none of the elements are individually accessed. This was generating
really terrible code for std::bitset (PR8980) because it happens to be lowered by clang
as an {[8 x i8]} structure instead of {i64}.
The testcase now is optimized to:
define i64 @test2(i64 %X) {
br label %L2
L2: ; preds = %0
ret i64 %X
}
before we generated:
define i64 @test2(i64 %X) {
%sroa.store.elt = lshr i64 %X, 56
%1 = trunc i64 %sroa.store.elt to i8
%sroa.store.elt8 = lshr i64 %X, 48
%2 = trunc i64 %sroa.store.elt8 to i8
%sroa.store.elt9 = lshr i64 %X, 40
%3 = trunc i64 %sroa.store.elt9 to i8
%sroa.store.elt10 = lshr i64 %X, 32
%4 = trunc i64 %sroa.store.elt10 to i8
%sroa.store.elt11 = lshr i64 %X, 24
%5 = trunc i64 %sroa.store.elt11 to i8
%sroa.store.elt12 = lshr i64 %X, 16
%6 = trunc i64 %sroa.store.elt12 to i8
%sroa.store.elt13 = lshr i64 %X, 8
%7 = trunc i64 %sroa.store.elt13 to i8
%8 = trunc i64 %X to i8
br label %L2
L2: ; preds = %0
%9 = zext i8 %1 to i64
%10 = shl i64 %9, 56
%11 = zext i8 %2 to i64
%12 = shl i64 %11, 48
%13 = or i64 %12, %10
%14 = zext i8 %3 to i64
%15 = shl i64 %14, 40
%16 = or i64 %15, %13
%17 = zext i8 %4 to i64
%18 = shl i64 %17, 32
%19 = or i64 %18, %16
%20 = zext i8 %5 to i64
%21 = shl i64 %20, 24
%22 = or i64 %21, %19
%23 = zext i8 %6 to i64
%24 = shl i64 %23, 16
%25 = or i64 %24, %22
%26 = zext i8 %7 to i64
%27 = shl i64 %26, 8
%28 = or i64 %27, %25
%29 = zext i8 %8 to i64
%30 = or i64 %29, %28
ret i64 %30
}
In this case, instcombine was able to eliminate the nonsense, but in PR8980 enough
PHIs are in play that instcombine backs off. It's better to not generate this stuff
in the first place.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@123571 91177308-0d34-0410-b5e6-96231b3b80d8
2011-01-16 06:18:28 +00:00
|
|
|
if (ST->getNumElements() > 1) return false;
|
|
|
|
} else {
|
|
|
|
if (cast<ArrayType>(AI->getAllocatedType())->getNumElements() > 1)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2011-01-23 08:27:54 +00:00
|
|
|
|
2010-04-16 00:24:57 +00:00
|
|
|
return true;
|
2008-02-29 07:03:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
|
|
|
|
/// PointsToConstantGlobal - Return true if V (possibly indirectly) points to
|
|
|
|
/// some part of a constant global variable. This intentionally only accepts
|
|
|
|
/// constant expressions because we don't can't rewrite arbitrary instructions.
|
|
|
|
static bool PointsToConstantGlobal(Value *V) {
|
|
|
|
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
|
|
|
|
return GV->isConstant();
|
|
|
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
|
2011-01-13 20:59:44 +00:00
|
|
|
if (CE->getOpcode() == Instruction::BitCast ||
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
CE->getOpcode() == Instruction::GetElementPtr)
|
|
|
|
return PointsToConstantGlobal(CE->getOperand(0));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isOnlyCopiedFromConstantGlobal - Recursively walk the uses of a (derived)
|
|
|
|
/// pointer to an alloca. Ignore any reads of the pointer, return false if we
|
|
|
|
/// see any stores or other unknown uses. If we see pointer arithmetic, keep
|
|
|
|
/// track of whether it moves the pointer (with isOffset) but otherwise traverse
|
|
|
|
/// the uses. If we see a memcpy/memmove that targets an unoffseted pointer to
|
2010-11-24 22:04:20 +00:00
|
|
|
/// the alloca, and if the source pointer is a pointer to a constant global, we
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
/// can optimize this.
|
2011-06-27 05:40:02 +00:00
|
|
|
static bool
|
|
|
|
isOnlyCopiedFromConstantGlobal(Value *V, MemTransferInst *&TheCopy,
|
|
|
|
bool isOffset,
|
|
|
|
SmallVector<Instruction *, 4> &LifetimeMarkers) {
|
|
|
|
// We track lifetime intrinsics as we encounter them. If we decide to go
|
|
|
|
// ahead and replace the value with the global, this lets the caller quickly
|
|
|
|
// eliminate the markers.
|
|
|
|
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI!=E; ++UI) {
|
2010-04-06 19:32:30 +00:00
|
|
|
User *U = cast<Instruction>(*UI);
|
|
|
|
|
fix a small oversight in the "eliminate memcpy from constant global"
optimization. If the alloca that is "memcpy'd from constant" also has
a memcpy from *it*, ignore it: it is a load. We now optimize the testcase to:
define void @test2() {
%B = alloca %T
%a = bitcast %T* @G to i8*
%b = bitcast %T* %B to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %a, i64 124, i32 4, i1 false)
call void @bar(i8* %b)
ret void
}
previously we would generate:
define void @test() {
%B = alloca %T
%b = bitcast %T* %B to i8*
%G.0 = getelementptr inbounds %T* @G, i32 0, i32 0
%tmp3 = load i8* %G.0, align 4
%G.1 = getelementptr inbounds %T* @G, i32 0, i32 1
%G.15 = bitcast [123 x i8]* %G.1 to i8*
%1 = bitcast [123 x i8]* %G.1 to i984*
%srcval = load i984* %1, align 1
%B.0 = getelementptr inbounds %T* %B, i32 0, i32 0
store i8 %tmp3, i8* %B.0, align 4
%B.1 = getelementptr inbounds %T* %B, i32 0, i32 1
%B.12 = bitcast [123 x i8]* %B.1 to i8*
%2 = bitcast [123 x i8]* %B.1 to i984*
store i984 %srcval, i984* %2, align 1
call void @bar(i8* %b)
ret void
}
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@119682 91177308-0d34-0410-b5e6-96231b3b80d8
2010-11-18 06:20:47 +00:00
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
|
2009-01-28 20:16:43 +00:00
|
|
|
// Ignore non-volatile loads, they are always ok.
|
2011-09-12 20:23:13 +00:00
|
|
|
if (!LI->isSimple()) return false;
|
fix a small oversight in the "eliminate memcpy from constant global"
optimization. If the alloca that is "memcpy'd from constant" also has
a memcpy from *it*, ignore it: it is a load. We now optimize the testcase to:
define void @test2() {
%B = alloca %T
%a = bitcast %T* @G to i8*
%b = bitcast %T* %B to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %a, i64 124, i32 4, i1 false)
call void @bar(i8* %b)
ret void
}
previously we would generate:
define void @test() {
%B = alloca %T
%b = bitcast %T* %B to i8*
%G.0 = getelementptr inbounds %T* @G, i32 0, i32 0
%tmp3 = load i8* %G.0, align 4
%G.1 = getelementptr inbounds %T* @G, i32 0, i32 1
%G.15 = bitcast [123 x i8]* %G.1 to i8*
%1 = bitcast [123 x i8]* %G.1 to i984*
%srcval = load i984* %1, align 1
%B.0 = getelementptr inbounds %T* %B, i32 0, i32 0
store i8 %tmp3, i8* %B.0, align 4
%B.1 = getelementptr inbounds %T* %B, i32 0, i32 1
%B.12 = bitcast [123 x i8]* %B.1 to i8*
%2 = bitcast [123 x i8]* %B.1 to i984*
store i984 %srcval, i984* %2, align 1
call void @bar(i8* %b)
ret void
}
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@119682 91177308-0d34-0410-b5e6-96231b3b80d8
2010-11-18 06:20:47 +00:00
|
|
|
continue;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-04-06 19:32:30 +00:00
|
|
|
if (BitCastInst *BCI = dyn_cast<BitCastInst>(U)) {
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
// If uses of the bitcast are ok, we are ok.
|
2011-06-27 05:40:02 +00:00
|
|
|
if (!isOnlyCopiedFromConstantGlobal(BCI, TheCopy, isOffset,
|
|
|
|
LifetimeMarkers))
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
return false;
|
|
|
|
continue;
|
|
|
|
}
|
2010-04-06 19:32:30 +00:00
|
|
|
if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(U)) {
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
// If the GEP has all zero indices, it doesn't offset the pointer. If it
|
|
|
|
// doesn't, it does.
|
|
|
|
if (!isOnlyCopiedFromConstantGlobal(GEP, TheCopy,
|
2011-06-27 05:40:02 +00:00
|
|
|
isOffset || !GEP->hasAllZeroIndices(),
|
|
|
|
LifetimeMarkers))
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
return false;
|
|
|
|
continue;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2010-11-18 06:41:51 +00:00
|
|
|
if (CallSite CS = U) {
|
2010-11-24 22:04:20 +00:00
|
|
|
// If this is the function being called then we treat it like a load and
|
|
|
|
// ignore it.
|
|
|
|
if (CS.isCallee(UI))
|
|
|
|
continue;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-05-06 10:30:37 +00:00
|
|
|
// If this is a readonly/readnone call site, then we know it is just a
|
|
|
|
// load (but one that potentially returns the value itself), so we can
|
|
|
|
// ignore it if we know that the value isn't captured.
|
|
|
|
unsigned ArgNo = CS.getArgumentNo(UI);
|
|
|
|
if (CS.onlyReadsMemory() &&
|
2011-11-20 19:09:04 +00:00
|
|
|
(CS.getInstruction()->use_empty() || CS.doesNotCapture(ArgNo)))
|
2011-05-06 10:30:37 +00:00
|
|
|
continue;
|
|
|
|
|
2010-11-18 06:41:51 +00:00
|
|
|
// If this is being passed as a byval argument, the caller is making a
|
|
|
|
// copy, so it is only a read of the alloca.
|
2011-11-20 19:09:04 +00:00
|
|
|
if (CS.isByValArgument(ArgNo))
|
2010-11-18 06:41:51 +00:00
|
|
|
continue;
|
|
|
|
}
|
2011-01-13 20:59:44 +00:00
|
|
|
|
2011-06-27 05:40:02 +00:00
|
|
|
// Lifetime intrinsics can be handled by the caller.
|
|
|
|
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(U)) {
|
|
|
|
if (II->getIntrinsicID() == Intrinsic::lifetime_start ||
|
|
|
|
II->getIntrinsicID() == Intrinsic::lifetime_end) {
|
|
|
|
assert(II->use_empty() && "Lifetime markers have no result to use!");
|
|
|
|
LifetimeMarkers.push_back(II);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
// If this is isn't our memcpy/memmove, reject it as something we can't
|
|
|
|
// handle.
|
2010-04-15 21:59:20 +00:00
|
|
|
MemTransferInst *MI = dyn_cast<MemTransferInst>(U);
|
|
|
|
if (MI == 0)
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
return false;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
fix a small oversight in the "eliminate memcpy from constant global"
optimization. If the alloca that is "memcpy'd from constant" also has
a memcpy from *it*, ignore it: it is a load. We now optimize the testcase to:
define void @test2() {
%B = alloca %T
%a = bitcast %T* @G to i8*
%b = bitcast %T* %B to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %a, i64 124, i32 4, i1 false)
call void @bar(i8* %b)
ret void
}
previously we would generate:
define void @test() {
%B = alloca %T
%b = bitcast %T* %B to i8*
%G.0 = getelementptr inbounds %T* @G, i32 0, i32 0
%tmp3 = load i8* %G.0, align 4
%G.1 = getelementptr inbounds %T* @G, i32 0, i32 1
%G.15 = bitcast [123 x i8]* %G.1 to i8*
%1 = bitcast [123 x i8]* %G.1 to i984*
%srcval = load i984* %1, align 1
%B.0 = getelementptr inbounds %T* %B, i32 0, i32 0
store i8 %tmp3, i8* %B.0, align 4
%B.1 = getelementptr inbounds %T* %B, i32 0, i32 1
%B.12 = bitcast [123 x i8]* %B.1 to i8*
%2 = bitcast [123 x i8]* %B.1 to i984*
store i984 %srcval, i984* %2, align 1
call void @bar(i8* %b)
ret void
}
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@119682 91177308-0d34-0410-b5e6-96231b3b80d8
2010-11-18 06:20:47 +00:00
|
|
|
// If the transfer is using the alloca as a source of the transfer, then
|
2010-11-18 07:32:33 +00:00
|
|
|
// ignore it since it is a load (unless the transfer is volatile).
|
fix a small oversight in the "eliminate memcpy from constant global"
optimization. If the alloca that is "memcpy'd from constant" also has
a memcpy from *it*, ignore it: it is a load. We now optimize the testcase to:
define void @test2() {
%B = alloca %T
%a = bitcast %T* @G to i8*
%b = bitcast %T* %B to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %a, i64 124, i32 4, i1 false)
call void @bar(i8* %b)
ret void
}
previously we would generate:
define void @test() {
%B = alloca %T
%b = bitcast %T* %B to i8*
%G.0 = getelementptr inbounds %T* @G, i32 0, i32 0
%tmp3 = load i8* %G.0, align 4
%G.1 = getelementptr inbounds %T* @G, i32 0, i32 1
%G.15 = bitcast [123 x i8]* %G.1 to i8*
%1 = bitcast [123 x i8]* %G.1 to i984*
%srcval = load i984* %1, align 1
%B.0 = getelementptr inbounds %T* %B, i32 0, i32 0
store i8 %tmp3, i8* %B.0, align 4
%B.1 = getelementptr inbounds %T* %B, i32 0, i32 1
%B.12 = bitcast [123 x i8]* %B.1 to i8*
%2 = bitcast [123 x i8]* %B.1 to i984*
store i984 %srcval, i984* %2, align 1
call void @bar(i8* %b)
ret void
}
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@119682 91177308-0d34-0410-b5e6-96231b3b80d8
2010-11-18 06:20:47 +00:00
|
|
|
if (UI.getOperandNo() == 1) {
|
|
|
|
if (MI->isVolatile()) return false;
|
|
|
|
continue;
|
|
|
|
}
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
|
|
|
|
// If we already have seen a copy, reject the second one.
|
|
|
|
if (TheCopy) return false;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
// If the pointer has been offset from the start of the alloca, we can't
|
|
|
|
// safely handle this.
|
|
|
|
if (isOffset) return false;
|
|
|
|
|
|
|
|
// If the memintrinsic isn't using the alloca as the dest, reject it.
|
2010-07-16 09:38:02 +00:00
|
|
|
if (UI.getOperandNo() != 0) return false;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
// If the source of the memcpy/move is not a constant global, reject it.
|
2010-04-15 21:59:20 +00:00
|
|
|
if (!PointsToConstantGlobal(MI->getSource()))
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
return false;
|
2011-01-13 20:59:44 +00:00
|
|
|
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
// Otherwise, the transform is safe. Remember the copy instruction.
|
|
|
|
TheCopy = MI;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// isOnlyCopiedFromConstantGlobal - Return true if the specified alloca is only
|
|
|
|
/// modified by a copy from a constant global. If we can prove this, we can
|
|
|
|
/// replace any uses of the alloca with uses of the global directly.
|
2011-06-27 05:40:02 +00:00
|
|
|
MemTransferInst *
|
|
|
|
SROA::isOnlyCopiedFromConstantGlobal(AllocaInst *AI,
|
|
|
|
SmallVector<Instruction*, 4> &ToDelete) {
|
2010-04-15 21:59:20 +00:00
|
|
|
MemTransferInst *TheCopy = 0;
|
2011-06-27 05:40:02 +00:00
|
|
|
if (::isOnlyCopiedFromConstantGlobal(AI, TheCopy, false, ToDelete))
|
If an alloca only has two types of uses: 1) reads 2) a memcpy/memmove that
copies from a constant global, then we can change the reads to read from the
global instead of from the alloca. This eliminates the alloca and the memcpy,
and promotes secondary optimizations (because the loads are now loads from
a constant global).
This is important for a common C idiom:
void foo() {
int A[] = {1,2,3,4,5,6,7,8,9...};
... only reads of A ...
}
For some reason, people forget to mark the array static or const.
This triggers on these multisource benchmarks:
JM/ldecode: block_pos, [3 x [4 x [4 x i32]]]
FreeBench/mason: m, [18 x i32], inlined 4 times
MiBench/office-stringsearch: search_strings, [1332 x i8*]
MiBench/office-stringsearch: find_strings, [1333 x i8*]
Prolangs-C++/city: dirs, [9 x i8*], inlined 4 places
and these spec benchmarks:
177.mesa: message, [8 x [32 x i8]]
186.crafty: bias_rl45, [64 x i32]
186.crafty: diag_sq, [64 x i32]
186.crafty: empty, [9 x i8]
186.crafty: xlate, [15 x i8]
186.crafty: status, [13 x i8]
186.crafty: bdinfo, [25 x i8]
445.gobmk: routines, [16 x i8*]
458.sjeng: piece_rep, [14 x i8*]
458.sjeng: t, [13 x i32], inlined 4 places.
464.h264ref: block8x8_idx, [3 x [4 x [4 x i32]]]
464.h264ref: block_pos, [3 x [4 x [4 x i32]]]
464.h264ref: j_off_tab, [12 x i32]
This implements Transforms/ScalarRepl/memcpy-from-global.ll
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36429 91177308-0d34-0410-b5e6-96231b3b80d8
2007-04-25 06:40:51 +00:00
|
|
|
return TheCopy;
|
|
|
|
return 0;
|
|
|
|
}
|