llvm-6502/test/Transforms
Chris Lattner 7e9b427c87 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
..
ADCE
ArgumentPromotion
BlockPlacement
BranchFolding
CodeExtractor
CodeGenPrepare temporarily revert r123526. While working on a follow-on patch I 2011-01-15 07:51:19 +00:00
ConstantMerge Make constmerge a two-pass algorithm so that it won't miss merging 2011-01-15 18:14:21 +00:00
ConstProp Teach constant folding to perform conversions from constant floating 2011-01-11 01:07:24 +00:00
CorrelatedValuePropagation
DeadArgElim
DeadStoreElimination
EarlyCSE Duncan deftly points out that readnone functions aren't 2011-01-03 23:38:13 +00:00
FunctionAttrs
GlobalDCE
GlobalOpt Improve the safety of my globalopt enhancement by ensuring that the bitcast 2011-01-16 04:33:33 +00:00
GVN Give GVN back the ability to perform simple conditional propagation on conditional branch values. 2010-12-21 23:54:34 +00:00
IndVarSimplify
Inline relax testcase a bit. 2011-01-14 07:46:33 +00:00
InstCombine enhance FoldOpIntoPhi in instcombine to try harder when a phi has 2011-01-16 05:28:59 +00:00
InstSimplify Turn X-(X-Y) into Y. According to my auto-simplifier this is the most common 2011-01-14 15:26:10 +00:00
Internalize
IPConstantProp
JumpThreading
LCSSA
LICM
LoopDeletion
LoopIdiom Teach loop-idiom to turn a loop containing a memset into a larger memset 2011-01-04 07:46:33 +00:00
LoopRotate merge tests into one crash.ll test. 2011-01-11 07:50:07 +00:00
LoopSimplify Fix PR8702 by not having LoopSimplify claim to preserve LCSSA form. As described 2011-01-02 13:38:21 +00:00
LoopStrengthReduce
LoopUnroll
LoopUnswitch
LowerAtomic
LowerInvoke
LowerSetJmp
LowerSwitch
Mem2Reg
MemCpyOpt revert 123144, reenabling the rest of memset formation. 2011-01-12 03:25:15 +00:00
MergeFunc
PruneEH
Reassociate
ScalarRepl if an alloca is only ever accessed as a unit, and is accessed with load/store instructions, 2011-01-16 06:18:28 +00:00
SCCP
SimplifyCFG
SimplifyLibCalls
Sink
SRETPromotion
StripSymbols
TailCallElim
TailDup