RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 11:02:59 +02:00
Code Issues Projects Releases Wiki Activity
69,518 Commits 4 Branches 5 Tags 704 MiB
f9a384e203
Commit Graph

7632 Commits

Author SHA1 Message Date
Chris Lattner
dc7b2160ba Fix FoldSingleEntryPHINodes to update memdep and AA when it deletes 
phi nodes.  It is called from MergeBlockIntoPredecessor which is 
called from GVN, which claims to preserve these.

I'm skeptical that this is the actual problem behind PR8954, but
this is a stab in the right direction.

llvm-svn: 123222
 2011-01-11 08:13:40 +00:00
Chris Lattner
b1a9c9ed36 random cleanups 
llvm-svn: 123221
 2011-01-11 08:00:40 +00:00
Chris Lattner
5731a92f5b remove a bogus assertion: the latch block of a loop is not 
neccesarily an uncond branch to the header.  This fixes 
PR8955 (the assertion tripping).

llvm-svn: 123219
 2011-01-11 07:47:59 +00:00
Owen Anderson
4479341626 Fix a random missed optimization by making InstCombine more aggressive when determining which bits are demanded by 
a comparison against a constant.

llvm-svn: 123203
 2011-01-11 00:36:45 +00:00
Chandler Carruth
772e26df36 Teach instcombine about the rest of the SSE and SSE2 conversion 
intrinsics element dependencies. Reviewed by Nick.

llvm-svn: 123161
 2011-01-10 07:19:37 +00:00
Chris Lattner
1404348022 another random stab in the dark trying to fix llvm-gcc-i386-linux-selfhost 
llvm-svn: 123149
 2011-01-10 02:34:11 +00:00
Chris Lattner
b5562212e2 another (more) aggressive attempt to bring llvm-gcc-i386-linux-selfhost 
back to life.

llvm-svn: 123146
 2011-01-10 00:47:34 +00:00
Chris Lattner
e8e9ec58bf temporarily disable memset formation from memsets in an effort to restore buildbot stability. 
llvm-svn: 123144
 2011-01-09 23:52:48 +00:00
Chris Lattner
82de29fb76 fix a few old bugs (found by inspection) where we would zap instructions 
without informing memdep.  This could cause nondeterminstic weirdness 
based on where instructions happen to get allocated, and will hopefully
breath some life into some broken testers.

llvm-svn: 123124
 2011-01-09 19:26:10 +00:00
Tobias Grosser
9899845dd3 Instcombine: Fix pattern where the sext did not dominate the icmp using it 
llvm-svn: 123121
 2011-01-09 16:00:11 +00:00
Cameron Zwarich
afbf7a9fe3 LoopInstSimplify preserves LoopSimplify. 
llvm-svn: 123117
 2011-01-09 12:35:16 +00:00
Chris Lattner
fa37cac39c reduce indentation. Print <nuw> and <nsw> when dumping SCEV AddRec's 
that have the bit set.

llvm-svn: 123104
 2011-01-09 02:16:18 +00:00
Chris Lattner
7df7b47828 fix a latent bug in memcpyoptimizer that my recent patches exposed: it wasn't 
updating memdep when fusing stores together.  This fixes the crash optimizing
the bullet benchmark.

llvm-svn: 123091
 2011-01-08 22:19:21 +00:00
Chris Lattner
563e57abbd tryMergingIntoMemset can only handle constant length memsets. 
llvm-svn: 123090
 2011-01-08 22:11:56 +00:00
Chris Lattner
98136397bd Merge memsets followed by neighboring memsets and other stores into 
larger memsets.  Among other things, this fixes rdar://8760394 and
allows us to handle "Example 2" from http://blog.regehr.org/archives/320,
compiling it into a single 4096-byte memset:

_mad_synth_mute:                        ## @mad_synth_mute
## BB#0:                                ## %entry
	pushq	%rax
	movl	$4096, %esi             ## imm = 0x1000
	callq	___bzero
	popq	%rax
	ret

llvm-svn: 123089
 2011-01-08 21:19:19 +00:00
Chris Lattner
e09439ed9d fix an issue in IsPointerOffset that prevented us from recognizing that 
P and P+1 are relative to the same base pointer.

llvm-svn: 123087
 2011-01-08 21:07:56 +00:00
Chris Lattner
20bf2d50b8 enhance memcpyopt to merge a store and a subsequent 
memset into a single larger memset.

llvm-svn: 123086
 2011-01-08 20:54:51 +00:00
Chris Lattner
19aedc848c constify TargetData references. 
Split memset formation logic out into its own
"tryMergingIntoMemset" helper function.

llvm-svn: 123081
 2011-01-08 20:24:01 +00:00
Chris Lattner
7d3c4712e9 When loop rotation happens, it is *very* common for the duplicated condbr 
to be foldable into an uncond branch.  When this happens, we can make a
much simpler CFG for the loop, which is important for nested loop cases
where we want the outer loop to be aggressively optimized.

Handle this case more aggressively.  For example, previously on
phi-duplicate.ll we would get this:


define void @test(i32 %N, double* %G) nounwind ssp {
entry:
  %cmp1 = icmp slt i64 1, 1000
  br i1 %cmp1, label %bb.nph, label %for.end

bb.nph:                                           ; preds = %entry
  br label %for.body

for.body:                                         ; preds = %bb.nph, %for.cond
  %j.02 = phi i64 [ 1, %bb.nph ], [ %inc, %for.cond ]
  %arrayidx = getelementptr inbounds double* %G, i64 %j.02
  %tmp3 = load double* %arrayidx
  %sub = sub i64 %j.02, 1
  %arrayidx6 = getelementptr inbounds double* %G, i64 %sub
  %tmp7 = load double* %arrayidx6
  %add = fadd double %tmp3, %tmp7
  %arrayidx10 = getelementptr inbounds double* %G, i64 %j.02
  store double %add, double* %arrayidx10
  %inc = add nsw i64 %j.02, 1
  br label %for.cond

for.cond:                                         ; preds = %for.body
  %cmp = icmp slt i64 %inc, 1000
  br i1 %cmp, label %for.body, label %for.cond.for.end_crit_edge

for.cond.for.end_crit_edge:                       ; preds = %for.cond
  br label %for.end

for.end:                                          ; preds = %for.cond.for.end_crit_edge, %entry
  ret void
}

Now we get the much nicer:

define void @test(i32 %N, double* %G) nounwind ssp {
entry:
  br label %for.body

for.body:                                         ; preds = %entry, %for.body
  %j.01 = phi i64 [ 1, %entry ], [ %inc, %for.body ]
  %arrayidx = getelementptr inbounds double* %G, i64 %j.01
  %tmp3 = load double* %arrayidx
  %sub = sub i64 %j.01, 1
  %arrayidx6 = getelementptr inbounds double* %G, i64 %sub
  %tmp7 = load double* %arrayidx6
  %add = fadd double %tmp3, %tmp7
  %arrayidx10 = getelementptr inbounds double* %G, i64 %j.01
  store double %add, double* %arrayidx10
  %inc = add nsw i64 %j.01, 1
  %cmp = icmp slt i64 %inc, 1000
  br i1 %cmp, label %for.body, label %for.end

for.end:                                          ; preds = %for.body
  ret void
}

With all of these recent changes, we are now able to compile:

void foo(char *X) {
 for (int i = 0; i != 100; ++i) 
   for (int j = 0; j != 100; ++j)
     X[j+i*100] = 0;
}

into a single memset of 10000 bytes.  This series of changes
should also be helpful for other nested loop scenarios as well.

llvm-svn: 123079
 2011-01-08 19:59:06 +00:00
Chris Lattner
a01093c990 split ssa updating code out to its own helper function. Don't bother 
moving the OrigHeader block anymore: we just merge it away anyway so
its code layout doesn't matter.

llvm-svn: 123077
 2011-01-08 19:26:33 +00:00
Chris Lattner
e5f41b44c5 Implement a TODO: Enhance loopinfo to merge away the unconditional branch 
that it was leaving in loops after rotation (between the original latch
block and the original header.

With this change, it is possible for rotated loops to have just a single
basic block, which is useful.

llvm-svn: 123075
 2011-01-08 19:10:28 +00:00
Chris Lattner
145e4ee94e various code cleanups, enhance MergeBlockIntoPredecessor to preserve 
loop info.

llvm-svn: 123074
 2011-01-08 19:08:40 +00:00
Chris Lattner
b601620bcd inline preserveCanonicalLoopForm now that it is simple. 
llvm-svn: 123073
 2011-01-08 18:55:50 +00:00
Chris Lattner
db05334c7f Three major changes: 
1. Rip out LoopRotate's domfrontier updating code.  It isn't
   needed now that LICM doesn't use DF and it is super complex
   and gross.
2. Make DomTree updating code a lot simpler and faster.  The 
   old loop over all the blocks was just to find a block??
3. Change the code that inserts the new preheader to just use
   SplitCriticalEdge instead of doing an overcomplex 
   reimplementation of it.

No behavior change, except for the name of the inserted preheader.

llvm-svn: 123072
 2011-01-08 18:52:51 +00:00
Chris Lattner
f1a01c01d9 reduce nesting. 
llvm-svn: 123071
 2011-01-08 18:47:43 +00:00
Chris Lattner
2fb7c9c272 LoopRotate requires canonical loop form, so it always has preheaders 
and latch blocks.  Reorder entry conditions to make hte pass faster
and more logical.

llvm-svn: 123069
 2011-01-08 18:06:22 +00:00
Chris Lattner
c6d905407b use the LI ivar. 
llvm-svn: 123068
 2011-01-08 17:49:51 +00:00
Chris Lattner
0893592a39 some cleanups: remove dead arguments and eliminate ivars 
that are just passed to one function.

llvm-svn: 123067
 2011-01-08 17:48:33 +00:00
Chris Lattner
ab9a79eda3 fix an issue duncan pointed out, which could cause loop rotate 
to violate LCSSA form

llvm-svn: 123066
 2011-01-08 17:38:45 +00:00
Cameron Zwarich
9a35e69c7d Fix coding style issues. 
llvm-svn: 123065
 2011-01-08 17:07:11 +00:00
Cameron Zwarich
a40df277f1 Make more passes preserve dominators (or state that they preserve dominators if 
they all ready do). This removes two dominator recomputations prior to isel,
which is a 1% improvement in total llc time for 403.gcc.

The only potentially suspect thing is making GCStrategy recompute dominators if
it used a custom lowering strategy.

llvm-svn: 123064
 2011-01-08 17:01:52 +00:00
Cameron Zwarich
e97e0555d5 Contract subloop bodies. However, it is still important to visit the phis at the 
top of subloop headers, as the phi uses logically occur outside of the subloop.

llvm-svn: 123062
 2011-01-08 15:52:22 +00:00
Frits van Bommel
966cc00809 Fix a bug in r123034 (trying to sext/zext non-integers) and clean up a little. 
llvm-svn: 123061
 2011-01-08 10:51:36 +00:00
Chris Lattner
6729ce1c33 Have loop-rotate simplify instructions (yay instsimplify!) as it clones 
them into the loop preheader, eliminating silly instructions like
"icmp i32 0, 100" in fixed tripcount loops.  This also better exposes the 
bigger problem with loop rotate that I'd like to fix: once this has been
folded, the duplicated conditional branch *often* turns into an uncond branch.

Not aggressively handling this is pessimizing later loop optimizations 
somethin' fierce by making "dominates all exit blocks" checks fail.

llvm-svn: 123060
 2011-01-08 08:24:46 +00:00
Chris Lattner
397937fa0d Revamp the ValueMapper interfaces in a couple ways: 
1. Take a flags argument instead of a bool.  This makes
   it more clear to the reader what it is used for.
2. Add a flag that says that "remapping a value not in the
   map is ok".
3. Reimplement MapValue to share a bunch of code and be a lot
   more efficient.  For lookup failures, don't drop null values
   into the map.
4. Using the new flag a bunch of code can vaporize in LinkModules
   and LoopUnswitch, kill it.

No functionality change.

llvm-svn: 123058
 2011-01-08 08:15:20 +00:00
Chris Lattner
9700b4d5ce two minor changes: switch to the standard ValueToValueMapTy 
map from ValueMapper.h (giving us access to its utilities)
and add a fastpath in the loop rotation code, avoiding expensive
ssa updator manipulation for values with nothing to update.

llvm-svn: 123057
 2011-01-08 07:21:31 +00:00
Tobias Grosser
48469b566a InstCombine: Match min/max hidden by sext/zext 
X = sext x; x >s c ? X : C+1 --> X = sext x; X <s C+1 ? C+1 : X
X = sext x; x <s c ? X : C-1 --> X = sext x; X >s C-1 ? C-1 : X
X = zext x; x >u c ? X : C+1 --> X = zext x; X <u C+1 ? C+1 : X
X = zext x; x <u c ? X : C-1 --> X = zext x; X >u C-1 ? C-1 : X
X = sext x; x >u c ? X : C+1 --> X = sext x; X <u C+1 ? C+1 : X
X = sext x; x <u c ? X : C-1 --> X = sext x; X >u C-1 ? C-1 : X

Instead of calculating this with mixed types promote all to the
larger type. This enables scalar evolution to analyze this
expression. PR8866

llvm-svn: 123034
 2011-01-07 21:33:14 +00:00
Tobias Grosser
492e97f0e5 Some whitespace fixes 
llvm-svn: 123033
 2011-01-07 21:33:13 +00:00
Benjamin Kramer
62b5a4d14c Revert 122959, it needs more thought. Add it back to README.txt with additional notes. 
llvm-svn: 123030
 2011-01-07 20:42:20 +00:00
Jay Foad
03be607946 Remove all uses of the "ugly" method BranchInst::setUnconditionalDest(). 
llvm-svn: 123025
 2011-01-07 20:25:56 +00:00
Benjamin Kramer
fb2bb22b6f InstCombine: Turn _chk functions into the "unsafe" variant if length and max langth are equal. 
This happens when we take the (non-constant) length from a malloc.

llvm-svn: 122961
 2011-01-06 14:22:52 +00:00
Benjamin Kramer
5834b2bab8 InstCombine: If we call llvm.objectsize on a malloc call we can replace it with the size passed to malloc. 
llvm-svn: 122959
 2011-01-06 13:11:05 +00:00
Benjamin Kramer
d5e1c24646 InstCombine: Teach llvm.objectsize folding to look through GEPs. 
llvm-svn: 122958
 2011-01-06 13:07:49 +00:00
Cameron Zwarich
246056cbb7 Add the CallInst optimizations that don't involve expanding inline assembly to 
OptimizeInst() so that they can be used on a worklist instruction.

llvm-svn: 122945
 2011-01-06 02:56:42 +00:00
Cameron Zwarich
314d16039a Move the GEP handling in CodeGenPrepare to OptimizeInst(). 
llvm-svn: 122944
 2011-01-06 02:44:52 +00:00
Cameron Zwarich
40cfb75bd7 Split the optimizations in CodeGenPrepare that don't manipulate the iterators 
into a separate function, so that it can be called from a loop using a worklist
rather than a loop traversing a whole basic block.

llvm-svn: 122943
 2011-01-06 02:37:26 +00:00
Jakob Stoklund Olesen
b3e7b27c1f Zap the last two -Wself-assign warnings in llvm. 
Simplify RALinScan::DowngradeRegister with TRI::getOverlaps while we are there.

llvm-svn: 122940
 2011-01-06 01:33:22 +00:00
Cameron Zwarich
eeea9f7113 Stop reallocating SunkAddrs for each basic block. When we move to an instruction 
worklist, the key will need to become std::pair<BasicBlock*, Value*>.

llvm-svn: 122932
 2011-01-06 00:42:50 +00:00
Cameron Zwarich
2543ec1d29 Add some more statistics to CodeGenPrepare. 
llvm-svn: 122891
 2011-01-05 17:47:38 +00:00
Cameron Zwarich
eca6d2c70a Add some stats to CodeGenPrepare to make it easier to speed it up without 
regressing code quality.

llvm-svn: 122887
 2011-01-05 17:27:27 +00:00
Cameron Zwarich
a7b9603f24 Use pop_back_val instead of back followed by pop_back. 
llvm-svn: 122876
 2011-01-05 16:08:47 +00:00
Cameron Zwarich
1dc3325c51 Use a worklist for later iterations just like ordinary instsimplify. The next 
step is to only process instructions in subloops if they have been modified by
an earlier simplification.

llvm-svn: 122869
 2011-01-05 05:47:47 +00:00
Cameron Zwarich
498b19fe4f Change LoopInstSimplify back to a LoopPass. It revisits subloops rather than 
skipping them, but it should probably use a worklist and only revisit those
instructions in subloops that have actually changed. It should probably also
use a worklist after the first iteration like instsimplify now does. Regardless,
it's only 0.3% of opt -O2 time on 403.gcc if it replaces the instcombine placed
in the middle of the loop passes.

llvm-svn: 122868
 2011-01-05 05:15:53 +00:00
Owen Anderson
cc0a091a5b Don't bother value numbering instructions with void types in GVN. In theory this should allow us to insert 
fewer things into the value numbering maps, but any speedup is beneath the noise threshold on my machine
on 403.gcc.

llvm-svn: 122844
 2011-01-04 22:15:21 +00:00
Owen Anderson
21c2cbcdbc Complete the NumberTable --> LeaderTable rename. 
llvm-svn: 122828
 2011-01-04 19:29:46 +00:00
Owen Anderson
52b41efbe8 Fix typo in a comment. 
llvm-svn: 122827
 2011-01-04 19:25:18 +00:00
Owen Anderson
eab44ddb0d Prune #include's. 
llvm-svn: 122826
 2011-01-04 19:24:57 +00:00
Owen Anderson
e8b5675dfa Clarify terminology, settling on referring to what was the "number table" as the "leader table", and 
rename methods to make it much more clear what they're doing.

llvm-svn: 122823
 2011-01-04 19:13:25 +00:00
Owen Anderson
192bc8fe10 When removing a value from GVN's leaders list, don't drop the Next pointer in a corner case. 
llvm-svn: 122822
 2011-01-04 19:10:54 +00:00
Dale Johannesen
de70d69dff Improve the accuracy of the inlining heuristic looking for the 
case where a static caller is itself inlined everywhere else, and
thus may go away if it doesn't get too big due to inlining other
things into it.  If there are references to the caller other than
calls, it will not be removed; account for this.
This results in same-day completion of the case in PR8853.

llvm-svn: 122821
 2011-01-04 19:01:54 +00:00
Owen Anderson
0ebc81b8d6 Branch instructions don't produce values, so there's no need to generate a value number for them. This 
avoids adding them to the various value numbering tables, resulting in a minor (~3%) speedup for GVN
on 40.gcc.

llvm-svn: 122819
 2011-01-04 18:54:18 +00:00
Owen Anderson
035828ecc6 Remove commented out code. 
llvm-svn: 122817
 2011-01-04 18:22:08 +00:00
Cameron Zwarich
8df51d24bd Switch to the new style of asterisk placement. 
llvm-svn: 122815
 2011-01-04 18:19:19 +00:00
Chris Lattner
1f58120bfe Teach loop-idiom to turn a loop containing a memset into a larger memset 
when safe.

The testcase is basically this nested loop:
void foo(char *X) {
  for (int i = 0; i != 100; ++i) 
    for (int j = 0; j != 100; ++j)
      X[j+i*100] = 0;
}

which gets turned into a single memset now.  clang -O3 doesn't optimize
this yet though due to a phase ordering issue I haven't analyzed yet.

llvm-svn: 122806
 2011-01-04 07:46:33 +00:00
Chris Lattner
0c29b20b46 restructure this a bit. Initialize the WeakVH with "I", the 
instruction *after* the store.  The store will always be deleted
if the transformation kicks in, so we'd do an N^2 scan of every
loop block.  Whoops.

llvm-svn: 122805
 2011-01-04 07:27:30 +00:00
Cameron Zwarich
150ef32f67 Avoid finding loop back edges when we are not splitting critical edges in 
CodeGenPrepare (which is the default behavior).

llvm-svn: 122801
 2011-01-04 04:43:31 +00:00
Cameron Zwarich
61a903b51b Address most of Duncan's review comments. Also, make LoopInstSimplify a simple 
FunctionPass. It probably doesn't have a reason to be a LoopPass, as it will
probably drop the simple fixed point and either use RPO iteration or Duncan's
approach in instsimplify of only revisiting instructions that have changed.

The next step is to preserve LoopSimplify. This looks like it won't be too hard,
although the pass manager doesn't actually seem to respect when non-loop passes
claim to preserve LCSSA or LoopSimplify. This will have to be fixed.

llvm-svn: 122791
 2011-01-04 00:12:46 +00:00
Chris Lattner
0caf5cbbe7 use the very-handy getTruncateOrZeroExtend helper function, and 
stop setting NSW: signed overflow is possible.  Thanks to Dan
for pointing these out.

llvm-svn: 122790
 2011-01-04 00:06:55 +00:00
Owen Anderson
c724c5969d Fix comment. 
llvm-svn: 122788
 2011-01-03 23:51:56 +00:00
Owen Anderson
ce48a5e838 Use the new addEscapingValue callback to update GlobalsModRef when GVN adds PHIs of GEPs. For the moment, 
have GlobalsModRef handle this conservatively by simply removing the value from its maps.

llvm-svn: 122787
 2011-01-03 23:51:43 +00:00
Chris Lattner
cd13979300 Duncan deftly points out that readnone functions aren't 
invalidated by stores, so they can be handled as 'simple'
operations.

llvm-svn: 122785
 2011-01-03 23:38:13 +00:00
Owen Anderson
e7a89f4646 Simplify GVN's value expression structure, allowing the elimination of a lot of 
almost-but-not-quite-identical code.  No intended functionality change.

llvm-svn: 122760
 2011-01-03 19:00:11 +00:00
Chris Lattner
5b5347fde6 stength reduce my previous patch a bit. The only instructions 
that are allowed to have metadata operands are intrinsic calls,
and the only ones that take metadata currently return void.
Just reject all void instructions, which should not be value
numbered anyway.  To future proof things, add an assert to the
getHashValue impl for calls to check that metadata operands 
aren't present.

llvm-svn: 122759
 2011-01-03 18:43:03 +00:00
Chris Lattner
9f81cc5372 fix PR8895: metadata operands don't have a strong use of their 
nested values, so they can change and drop to null, which can
change the hash and cause havok.

It turns out that it isn't a good idea to value number stuff
with metadata operands anyway, so... don't.

llvm-svn: 122758
 2011-01-03 18:28:15 +00:00
Duncan Sands
667024a2eb Speed up instsimplify by about 10-15% by not bothering to retry 
InstructionSimplify on instructions that didn't change since the
last time round the loop.

llvm-svn: 122745
 2011-01-03 10:50:04 +00:00
Cameron Zwarich
3914a9751c Switch a worklist in CodeGenPrepare to SmallVector and increase the inline 
capacity on the Visited SmallPtrSet. On 403.gcc, this is about a 4.5% speedup of
CodeGenPrepare time (which itself is 10% of time spent in the backend).

This is progress towards PR8889.

llvm-svn: 122741
 2011-01-03 06:33:01 +00:00
Chris Lattner
c1ebe702b1 earlycse can do trivial with-a-block dead store 
elimination as well.  This deletes 60 stores in 176.gcc
that largely come from bitfield code.

llvm-svn: 122736
 2011-01-03 04:17:24 +00:00
Chris Lattner
e44a99ac89 switch the load table to use a recycling bump pointer allocator, 
speeding earlycse up by 6%.

llvm-svn: 122733
 2011-01-03 03:53:50 +00:00
Chris Lattner
d19ae32f2f now that loads are in their own table, we can implement 
store->load forwarding.  This allows EarlyCSE to zap 600 more
loads from 176.gcc.

llvm-svn: 122732
 2011-01-03 03:46:34 +00:00
Chris Lattner
b242caa491 split loads and calls into separate tables. Loads are now just indexed 
by their pointer instead of using MemoryValue to wrap it.

llvm-svn: 122731
 2011-01-03 03:41:27 +00:00
Chris Lattner
3d56e5f6d5 various cleanups, no functionality change. 
llvm-svn: 122729
 2011-01-03 03:28:23 +00:00
Chris Lattner
4cfdaa3f02 Teach EarlyCSE to do trivial CSE of loads and read-only calls. 
On 176.gcc, this catches 13090 loads and calls, and increases the
number of simple instructions CSE'd from 29658 to 36208.

llvm-svn: 122727
 2011-01-03 03:18:43 +00:00
Chris Lattner
4ad0cdebbb rename InstValue to SimpleValue, add some comments. 
llvm-svn: 122725
 2011-01-03 02:20:48 +00:00
Michael J. Spencer
1c649efb52 CMake: Add missing source file. 
llvm-svn: 122724
 2011-01-03 02:13:05 +00:00
Chris Lattner
e89f2f9078 Allocate nodes for the scoped hash table from a recyling bump pointer 
allocator.  This speeds up early cse by about 20%

llvm-svn: 122723
 2011-01-03 01:42:46 +00:00
Chris Lattner
f6a71c6cd5 reduce redundancy in the hashing code and other misc cleanups. 
llvm-svn: 122720
 2011-01-03 01:10:08 +00:00
Cameron Zwarich
a4f2efdd41 Add a new loop-instsimplify pass, with the intention of replacing the instance 
of instcombine that is currently in the middle of the loop pass pipeline. This
commit only checks in the pass; it will hopefully be enabled by default later.

llvm-svn: 122719
 2011-01-03 00:25:16 +00:00
Chris Lattner
506c2deff3 fix some pastos 
llvm-svn: 122718
 2011-01-02 23:29:58 +00:00
Chris Lattner
39d1fb3320 add DEBUG and -stats output to earlycse. 
Teach it to CSE the rest of the non-side-effecting instructions.

llvm-svn: 122716
 2011-01-02 23:19:45 +00:00
Chris Lattner
dbad0b5e40 Enhance earlycse to do CSE of casts, instsimplify and die. 
Add a testcase.

llvm-svn: 122715
 2011-01-02 23:04:14 +00:00
Chris Lattner
e396e846b4 split dom frontier handling stuff out to its own DominanceFrontier header, 
so that Dominators.h is *just* domtree.  Also prune #includes a bit.

llvm-svn: 122714
 2011-01-02 22:09:33 +00:00
Chris Lattner
688675a0be sketch out a new early cse pass. No functionality yet. 
llvm-svn: 122713
 2011-01-02 21:47:05 +00:00
Chris Lattner
0c2cfcf430 fix a miscompilation of tramp3d-v4: when forming a memcpy, we have to make 
sure that the loop we're promoting into a memcpy doesn't mutate the input
of the memcpy.  Before we were just checking that the dest of the memcpy
wasn't mod/ref'd by the loop.

llvm-svn: 122712
 2011-01-02 21:14:18 +00:00
Chris Lattner
c655681b32 If a loop iterates exactly once (has backedge count = 0) then don't 
mess with it.  We'd rather peel/unroll it than convert all of its 
stores into memsets.

llvm-svn: 122711
 2011-01-02 20:24:21 +00:00
Nick Lewycky
06b94a5e5b Also remove functions that use complex constant expressions in terms of 
another function.

llvm-svn: 122705
 2011-01-02 19:16:44 +00:00
Chris Lattner
c78e4bc366 enhance loop idiom recognition to scan *all* unconditionally executed 
blocks in a loop, instead of just the header block.  This makes it more
aggressive, able to handle Duncan's Ada examples.

llvm-svn: 122704
 2011-01-02 19:01:03 +00:00
Chris Lattner
3bb2e83433 make inSubLoop much more efficient. 
llvm-svn: 122703
 2011-01-02 18:53:08 +00:00
Chris Lattner
2bcd2564d6 rip out isExitBlockDominatedByBlockInLoop, calling DomTree::dominates instead. 
isExitBlockDominatedByBlockInLoop is a relic of the days when domtree was 
*just* a tree and didn't have DFS numbers.  Checking DFS numbers is faster
and easier than "limiting the search of the tree".

llvm-svn: 122702
 2011-01-02 18:45:39 +00:00
Chris Lattner
bbae3ddf12 add a list of opportunities for future improvement. 
llvm-svn: 122701
 2011-01-02 18:32:09 +00:00
Duncan Sands
2d1c116071 Fix PR8702 by not having LoopSimplify claim to preserve LCSSA form. As described 
in the PR, the pass could break LCSSA form when inserting preheaders.  It probably
would be easy enough to fix this, but since currently we always go into LCSSA form
after running this pass, doing so is not urgent.

llvm-svn: 122695
 2011-01-02 13:38:21 +00:00
Chris Lattner
f669d6a901 Allow loop-idiom to run on multiple BB loops, but still only scan the loop 
header for now for memset/memcpy opportunities.  It turns out that loop-rotate
is successfully rotating loops, but *DOESN'T MERGE THE BLOCKS*, turning "for 
loops" into 2 basic block loops that loop-idiom was ignoring.

With this fix, we form many *many* more memcpy and memsets than before, including
on the "history" loops in the viterbi benchmark, which look like this:

        for (j=0; j<MAX_history; ++j) {
          history_new[i][j+1] = history[2*i][j];
        }

Transforming these loops into memcpy's speeds up the viterbi benchmark from
11.98s to 3.55s on my machine.  Woo.

llvm-svn: 122685
 2011-01-02 07:58:36 +00:00
Chris Lattner
8a72a8f315 remove debugging code. 
llvm-svn: 122683
 2011-01-02 07:37:13 +00:00
Chris Lattner
bbd22e0c3c add some -stats output. 
llvm-svn: 122682
 2011-01-02 07:36:44 +00:00
Chris Lattner
2afc3c0dc4 improve loop rotation to use CodeMetrics to analyze the 
size of a loop header instead of its own code size estimator.
This allows it to handle bitcasts etc more precisely.

llvm-svn: 122681
 2011-01-02 07:35:53 +00:00
Chris Lattner
34a61ab676 teach loop idiom recognition to form memcpy's from simple loops. 
llvm-svn: 122678
 2011-01-02 03:37:56 +00:00
Nick Lewycky
68d915ae1a Remove functions from the FnSet when one of their callee's is being merged. This 
maintains the guarantee that the DenseSet expects two elements it contains to
not go from inequal to equal under its nose.

As a side-effect, this also lets us switch from iterating to a fixed-point to
actually maintaining a work queue of functions to look at again, and we don't
add thunks to our work queue so we don't need to detect and ignore them.

llvm-svn: 122677
 2011-01-02 02:46:33 +00:00
Chris Lattner
fda382af51 fix a globalopt crash on two Adobe-C++ testcases that the recent 
loop idiom pass exposed.

llvm-svn: 122674
 2011-01-01 22:31:46 +00:00
Chris Lattner
b9c1684fce add a validity check that was missed, fixing a crash on the 
new testcase.

llvm-svn: 122662
 2011-01-01 20:12:04 +00:00
Chris Lattner
9a9f43c4a2 improve validity check to handle constant-trip-count loops more 
aggressively.  In practice, this doesn't help anything though,
see the todo.

llvm-svn: 122660
 2011-01-01 19:54:22 +00:00
Chris Lattner
4651f8b037 implement the "no aliasing accesses in loop" safety check. This pass 
should be correct now.

llvm-svn: 122659
 2011-01-01 19:39:01 +00:00
Duncan Sands
74270e8100 Simplify this pass by using a depth-first iterator to ensure that all 
operands are visited before the instructions themselves.

llvm-svn: 122647
 2010-12-31 17:49:05 +00:00
Duncan Sands
ca280dbcd5 Zap dead instructions harder. 
llvm-svn: 122645
 2010-12-31 16:17:54 +00:00
Benjamin Kramer
c84434924f Make a bunch of symbols internal. 
llvm-svn: 122642
 2010-12-30 22:34:44 +00:00
Chris Lattner
51a906ce92 simplify this, isBytewiseValue handles the extra check. We still 
check for "multiple of a byte" in size to make it clear that the
>> 3 below is safe.

llvm-svn: 122604
 2010-12-28 18:53:48 +00:00
Duncan Sands
1395f115d8 Silence gcc warning about an unused variable when doing a release build. 
llvm-svn: 122593
 2010-12-28 09:41:15 +00:00
Chris Lattner
2658d522b1 fix some issues Frits noticed, add AliasAnalysis as a dependency 
llvm-svn: 122585
 2010-12-27 18:39:08 +00:00
Benjamin Kramer
30e1ba0fcc BuildLibCalls: Nuke EmitMemCpy, EmitMemMove and EmitMemSet. They are dead and superseded by IRBuilder. 
llvm-svn: 122576
 2010-12-27 00:25:32 +00:00
Benjamin Kramer
c66455a774 SimplifyLibCalls: Use IRBuilder to simplify code. 
llvm-svn: 122575
 2010-12-27 00:16:46 +00:00
Chris Lattner
a4249272b5 have loop-idiom nuke instructions that feed stores that get removed. 
llvm-svn: 122574
 2010-12-27 00:03:23 +00:00
Chris Lattner
d4daf9f002 implement enough of the memset inference algorithm to recognize and insert 
memsets.  This is still missing one important validity check, but this is enough
to compile stuff like this:

void test0(std::vector<char> &X) {
  for (std::vector<char>::iterator I = X.begin(), E = X.end(); I != E; ++I)
    *I = 0;
}

void test1(std::vector<int> &X) {
  for (long i = 0, e = X.size(); i != e; ++i)
    X[i] = 0x01010101;
}

With:
 $ clang t.cpp -S -o - -O2 -emit-llvm | opt -loop-idiom | opt -O3 | llc 

to:

__Z5test0RSt6vectorIcSaIcEE:            ## @_Z5test0RSt6vectorIcSaIcEE
## BB#0:                                ## %entry
	subq	$8, %rsp
	movq	(%rdi), %rax
	movq	8(%rdi), %rsi
	cmpq	%rsi, %rax
	je	LBB0_2
## BB#1:                                ## %bb.nph
	subq	%rax, %rsi
	movq	%rax, %rdi
	callq	___bzero
LBB0_2:                                 ## %for.end
	addq	$8, %rsp
	ret
...
__Z5test1RSt6vectorIiSaIiEE:            ## @_Z5test1RSt6vectorIiSaIiEE
## BB#0:                                ## %entry
	subq	$8, %rsp
	movq	(%rdi), %rax
	movq	8(%rdi), %rdx
	subq	%rax, %rdx
	cmpq	$4, %rdx
	jb	LBB1_2
## BB#1:                                ## %for.body.preheader
	andq	$-4, %rdx
	movl	$1, %esi
	movq	%rax, %rdi
	callq	_memset
LBB1_2:                                 ## %for.end
	addq	$8, %rsp
	ret

llvm-svn: 122573
 2010-12-26 23:42:51 +00:00
Chris Lattner
9007b56712 start using irbuilder to make mem intrinsics in a few passes. 
llvm-svn: 122572
 2010-12-26 22:57:41 +00:00
Chris Lattner
27961b5180 sketch more of this out. 
llvm-svn: 122567
 2010-12-26 20:45:45 +00:00
Chris Lattner
c56d20aa48 move isBytewiseValue out to ValueTracking.h/cpp 
llvm-svn: 122565
 2010-12-26 20:15:01 +00:00
Chris Lattner
73f562af94 actually add the file... 
llvm-svn: 122563
 2010-12-26 19:39:38 +00:00
Chris Lattner
e210c31646 Start of a pass for recognizing memset and memcpy idioms. 
No functionality yet.

llvm-svn: 122562
 2010-12-26 19:32:44 +00:00
Benjamin Kramer
626fccab8b Simplify code. 
llvm-svn: 122561
 2010-12-26 15:23:45 +00:00
Chris Lattner
a73a53e67f don't lose TD info 
llvm-svn: 122556
 2010-12-25 20:52:04 +00:00
Chris Lattner
38d6d6d367 switch the inliner alignment enforcement stuff to use the 
getOrEnforceKnownAlignment function, which simplifies the code
and makes it stronger.

llvm-svn: 122555
 2010-12-25 20:42:38 +00:00
Chris Lattner
c4cb20b9bf Move getOrEnforceKnownAlignment out of instcombine into Transforms/Utils. 
llvm-svn: 122554
 2010-12-25 20:37:57 +00:00
Benjamin Kramer
720b32b319 Fix a thinko pointed out by Frits van Bommel: looking through global variables in isBytewiseValue is not safe. 
llvm-svn: 122550
 2010-12-24 22:23:59 +00:00
Benjamin Kramer
49e40d4c4b MemCpyOpt: Turn memcpys from a constant into a memset if possible. 
This allows us to compile "int cst[] = {-1, -1, -1};" into
  movl  $-1, 16(%rsp)
  movq  $-1, 8(%rsp)
instead of
  movl  _cst+8(%rip), %eax
  movl  %eax, 16(%rsp)
  movq  _cst(%rip), %rax
  movq  %rax, 8(%rsp)

llvm-svn: 122548
 2010-12-24 21:17:12 +00:00
Owen Anderson
6afd90810e When determining if we can fold (x >> C1) << C2, the bits that we need to verify are zero 
are not the low bits of x, but the bits that WILL be the low bits after the operation completes.

llvm-svn: 122529
 2010-12-23 23:56:24 +00:00
Owen Anderson
be8084acdd It is possible for SimplifyCFG to cause PHI nodes to become redundant too late in the optimization 
pipeline to be caught by instcombine, and it's not feasible to catch them in SimplifyCFG because the
use-lists are in an inconsistent state at the point where it could know that it need to simplify them.
Instead, have CodeGenPrepare look for trivially redundant PHIs as part of its general cleanup effort.

llvm-svn: 122516
 2010-12-23 20:57:35 +00:00
Mon P Wang
eb2ae28352 Preserve the address space when generating bitcasts for MemTransferInst in ConvertToScalarInfo 
llvm-svn: 122462
 2010-12-23 01:41:32 +00:00
Jeffrey Yasskin
a199652a3e Change all self assignments X=X to (void)X, so that we can turn on a 
new gcc warning that complains on self-assignments and
self-initializations.

llvm-svn: 122458
 2010-12-23 00:58:24 +00:00
Benjamin Kramer
27d13684f5 InstCombine: creating selects from -1 and 0 is fine, they combine into a sext from i1. 
llvm-svn: 122453
 2010-12-22 23:12:15 +00:00
Duncan Sands
922251757b Add a generic expansion transform: A op (B op' C) -> (A op B) op' (A op C) 
if both A op B and A op C simplify.  This fires fairly often but doesn't
make that much difference.  On gcc-as-one-file it removes two "and"s and
turns one branch into a select.

llvm-svn: 122399
 2010-12-22 13:36:08 +00:00
Duncan Sands
9b28a173fe Add some statistics, good for understanding how much more powerful 
instcombine is compared to instsimplify.

llvm-svn: 122397
 2010-12-22 09:40:51 +00:00
Owen Anderson
b4f1511864 Give GVN back the ability to perform simple conditional propagation on conditional branch values. 
I still think that LVI should be handling this, but that capability is some ways off in the future,
and this matters for some significant benchmarks.

llvm-svn: 122378
 2010-12-21 23:54:34 +00:00
Owen Anderson
1ee218de0e Remove dead code. 
llvm-svn: 122371
 2010-12-21 22:31:24 +00:00
Benjamin Kramer
fd119319ea GVN's Expression is not POD-like (it contains a SmallVector). Simplify code while at it. 
llvm-svn: 122362
 2010-12-21 21:30:19 +00:00
Duncan Sands
c7868f60bc Visit instructions deterministically. Use a FIFO so as to approximately 
visit instructions before their uses, since InstructionSimplify does a
better job in that case.  All this prompted by Frits van Bommel.

llvm-svn: 122343
 2010-12-21 17:08:55 +00:00
Duncan Sands
6e2fd37144 If an instruction simplifies, try again to simplify any uses of it. This is 
not very important since the pass is only used for testing, but it does make
it more realistic.  Suggested by Frits van Bommel.

llvm-svn: 122336
 2010-12-21 16:12:03 +00:00
Duncan Sands
6b0ed93a81 Pull a few more simplifications out of instcombine (there are still 
plenty left though!), in particular for multiplication.

llvm-svn: 122330
 2010-12-21 14:00:22 +00:00
Duncan Sands
0a1b3c4cee Oops, forgot to add the pass itself! 
llvm-svn: 122265
 2010-12-20 21:07:42 +00:00
Duncan Sands
09fbb211eb Add a new convenience pass for testing InstructionSimplify. Previously 
it could only be tested indirectly, via instcombine, gvn or some other
pass that makes use of InstructionSimplify, which means that testcases
had to be carefully contrived to dance around any other transformations
that that pass did.

llvm-svn: 122264
 2010-12-20 20:54:37 +00:00
Benjamin Kramer
2b3ad7e4dc Add a check missing from my last commit and avoid a potential overflow situation. 
llvm-svn: 122258
 2010-12-20 20:00:31 +00:00
Benjamin Kramer
d38a47e082 Reduce indentation. 
llvm-svn: 122249
 2010-12-20 16:21:59 +00:00
Benjamin Kramer
bec7a6be15 Teach InstCombine to merge (icmp ult (X + CA), C1) | (icmp eq X, C2) into (icmp ult (X + CA), C1 + 1) if C2 + CA == C1. 
InstCombine creates these so now we compile x == 23 || x == 24 || x == 25 to
  %x.off = add i32 %x, -23
  %1 = icmp ult i32 %x.off, 3
instead of
  %x.off = add i32 %x, -23
  %1 = icmp ult i32 %x.off, 2
  %cmp3 = icmp eq i32 %x, 25
  %ret2 = or i1 %1, %cmp3

llvm-svn: 122248
 2010-12-20 16:18:51 +00:00
Chris Lattner
b27b5d0a3a fix PR8807 by making transformConstExprCastCall aware of byval arguments. 
llvm-svn: 122238
 2010-12-20 08:36:38 +00:00