RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-20 03:23:01 +02:00
Code Issues Projects Releases Wiki Activity
69,093 Commits 4 Branches 5 Tags 704 MiB
36b007d63b
Commit Graph

7545 Commits

Author SHA1 Message Date
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
Chris Lattner
a3fea736c1 various cleanups for transformConstExprCastCall 
llvm-svn: 122237
 2010-12-20 08:25:06 +00:00
Chris Lattner
ba962825a4 when eliding a byval copy due to inlining a readonly function, we have 
to make sure that the reused alloca has sufficient alignment.

llvm-svn: 122236
 2010-12-20 08:10:40 +00:00
Chris Lattner
c0a48df9f9 pull byval processing out to its own helper function. 
llvm-svn: 122235
 2010-12-20 07:57:41 +00:00
Chris Lattner
029952c844 fix PR8769, a miscompilation by inliner when inlining a function with a byval 
argument.  The generated alloca has to have at least the alignment of the
byval, if not, the client may be making assumptions that the new alloca won't
satisfy.

llvm-svn: 122234
 2010-12-20 07:45:28 +00:00
Mon P Wang
4ab0ea216d Avoid dropping the address space when InstCombine optimizes memset 
llvm-svn: 122215
 2010-12-20 01:05:30 +00:00
Chris Lattner
c8327b2f7c fix an oversight caught by Frits! 
llvm-svn: 122204
 2010-12-19 23:24:04 +00:00
Chris Lattner
45f7e2d4cb tidy up 
llvm-svn: 122190
 2010-12-19 20:24:28 +00:00
Chris Lattner
7858cb9c08 move a transformation to a more logical place, simplifying it. 
llvm-svn: 122183
 2010-12-19 19:43:52 +00:00
Chris Lattner
3bc741a0d2 recognize an unsigned add with overflow idiom into uadd. 
This resolves a README entry and technically resolves PR4916,
but we still get poor code for the testcase in that PR because
GVN isn't CSE'ing uadd with add, filed as PR8817.

Previously we got:

_test7:                                 ## @test7
	addq	%rsi, %rdi
	cmpq	%rdi, %rsi
	movl	$42, %eax
	cmovaq	%rsi, %rax
	ret

Now we get:

_test7:                                 ## @test7
	addq	%rsi, %rdi
	movl	$42, %eax
	cmovbq	%rsi, %rax
	ret

llvm-svn: 122182
 2010-12-19 19:37:52 +00:00
Chris Lattner
faef9b6bfb optimize uadd(x, cst) into a comparison when the normal 
result is dead.  This is required for my next patch to not
regress the testsuite.

llvm-svn: 122181
 2010-12-19 19:35:32 +00:00
Chris Lattner
c5074803db use IC.ReplaceInstUsesWith instead of a raw RAUW so that uses of 
the old thing end up on the instcombine worklist.  Not doing this
can cause an extra top-level iteration of instcombine, burning
compile time.

llvm-svn: 122179
 2010-12-19 18:38:44 +00:00
Chris Lattner
d1f114d8f2 generalize the sadd creation code to not require that the 
sadd formed is half the size of the original type. We can
now compile this into a sadd.i8:

unsigned char X(char a, char b) {
  int res = a+b;
  if ((unsigned )(res+128) > 255U)
    abort();
  return res;
}

llvm-svn: 122178
 2010-12-19 18:35:09 +00:00
Chris Lattner
bb0d067691 fix another miscompile in the llvm.sadd formation logic: it wasn't 
checking to see if the high bits of the original add result were dead.
Inserting a smaller add and zexting back to that size is not good enough.

This is likely to be the fix for 8816.

llvm-svn: 122177
 2010-12-19 18:22:06 +00:00
Chris Lattner
c7876edb16 fix a bug (possibly 8816) in the sadd forming xform: it isn't 
profitable (or safe) to promote code when the add-with-constant
has other uses.

llvm-svn: 122175
 2010-12-19 17:59:02 +00:00
Chris Lattner
cc804862d5 rework the code added in r122072 to pull it out to its own 
helper function, clean up comments, and reduce indentation.
No functionality change.

llvm-svn: 122174
 2010-12-19 17:52:50 +00:00
Chris Lattner
bb93cd80d6 Enhance LICM to promote alias sets whose pointers themselves are stored, 
which doesn't affect the memory address being promoted.

llvm-svn: 122172
 2010-12-19 05:57:25 +00:00
Chris Lattner
71fcecf597 fix PR8602, a bug in an assertion: a volatile store *of* a pointer 
does not make the alias set for that pointer volatile, just stores
*to* the pointer.

llvm-svn: 122171
 2010-12-19 05:51:54 +00:00
Chris Lattner
0965f3f76d revert r122164, I'm going to go with a different approach. 
llvm-svn: 122168
 2010-12-19 04:23:03 +00:00
Chris Lattner
14a3e26146 first step to fixing PR8642: don't fold away empty basic blocks 
which have trapping constant exprs in them due to PHI nodes.
Eliminating them can cause the constant expr to be evalutated
on new paths if the input edges are critical.

llvm-svn: 122164
 2010-12-19 03:02:34 +00:00
Chris Lattner
25d76d1e53 simplify this a bit. 
llvm-svn: 122156
 2010-12-18 20:22:49 +00:00
Bill Wendling
b1f6875ae3 Whitespace fixes. No functionality change. 
llvm-svn: 122110
 2010-12-17 23:27:41 +00:00
Nate Begeman
063d88d6fb Add vector versions of some existing scalar transforms to aid codegen in matching psign & pblend operations to the IR produced by clang/gcc for their C idioms. 
llvm-svn: 122105
 2010-12-17 23:12:19 +00:00
Owen Anderson
6acf8c9125 Reapply r121905 (automatic synthesis of @llvm.sadd.with.overflow) with a fix for a bug that manifested itself 
on the DragonEgg self-host bot.  Unfortunately, the testcase is pretty messy and doesn't reduce well due to
interactions with other parts of InstCombine.

llvm-svn: 122072
 2010-12-17 18:08:00 +00:00
Benjamin Kramer
39b30b18fa SimplifyCFG: Ranges can be larger than 64 bits. Fixes Release-selfhost build. 
llvm-svn: 122054
 2010-12-17 10:48:14 +00:00
Chris Lattner
e92f8121d4 improve switch formation to handle small range 
comparisons formed by comparisons.  For example,
this:

void foo(unsigned x) {
  if (x == 0 || x == 1 || x == 3 || x == 4 || x == 6) 
    bar();
}

compiles into:

_foo:                                   ## @foo
## BB#0:                                ## %entry
	cmpl	$6, %edi
	ja	LBB0_2
## BB#1:                                ## %entry
	movl	%edi, %eax
	movl	$91, %ecx
	btq	%rax, %rcx
	jb	LBB0_3

instead of:

_foo:                                   ## @foo
## BB#0:                                ## %entry
	cmpl	$2, %edi
	jb	LBB0_4
## BB#1:                                ## %switch.early.test
	cmpl	$6, %edi
	ja	LBB0_3
## BB#2:                                ## %switch.early.test
	movl	%edi, %eax
	movl	$88, %ecx
	btq	%rax, %rcx
	jb	LBB0_4

This catches a bunch of cases in GCC, which look like this:

 %804 = load i32* @which_alternative, align 4, !tbaa !0
 %805 = icmp ult i32 %804, 2
 %806 = icmp eq i32 %804, 3
 %or.cond121 = or i1 %805, %806
 %807 = icmp eq i32 %804, 4
 %or.cond124 = or i1 %or.cond121, %807
 br i1 %or.cond124, label %.thread, label %808

turning this into a range comparison.

llvm-svn: 122045
 2010-12-17 06:20:15 +00:00
Dan Gohman
f8949c3d1a Revert r64460. strtol and friends cannot be marked readonly, even with 
a null endptr argument, because they may write to errno.

This fixes a seflhost miscompile observed on Linux targets when TBAA
was enabled.

llvm-svn: 122014
 2010-12-17 01:09:43 +00:00
Frits van Bommel
56dc4fc838 Fix a bug in the loop in JumpThreading::ProcessThreadableEdges() where it could falsely produce a MultipleDestSentinel value if the first predecessor ended with an 'indirectbr'. If that happened, it caused an unnecessary FindMostPopularDest() call. 
This wasn't a correctness problem, but it broke the fast path for single-predecessor blocks.

llvm-svn: 121966
 2010-12-16 12:16:00 +00:00
Duncan Sands
22de496ae3 Speculatively revert commit 121905 since it looks like it might have broken the 
dragonegg self-host buildbot.  Original commit message:

Add an InstCombine transform to recognize instances of manual overflow-safe addition
(performing the addition in a wider type and explicitly checking for overflow), and
fold them down to intrinsics.  This currently only supports signed-addition, but could
be generalized if someone works out the magic constant formulas for other operations.

llvm-svn: 121965
 2010-12-16 09:40:54 +00:00
Dan Gohman
e106936414 Make memcpyopt TBAA-aware. 
llvm-svn: 121944
 2010-12-16 02:51:19 +00:00
Dan Gohman
a2fd4f2e22 Preserve TBAA tags when doing load PRE. 
llvm-svn: 121921
 2010-12-15 23:53:55 +00:00
Owen Anderson
aefeb448a9 Add an InstCombine transform to recognize instances of manual overflow-safe addition 
(performing the addition in a wider type and explicitly checking for overflow), and
fold them down to intrinsics.  This currently only supports signed-addition, but could
be generalized if someone works out the magic constant formulas for other operations.

Fixes <rdar://problem/8558713>.

llvm-svn: 121905
 2010-12-15 22:32:38 +00:00
Dan Gohman
295ba3ab26 Move Value::getUnderlyingObject to be a standalone 
function so that it can live in Analysis instead of
VMCore.

llvm-svn: 121885
 2010-12-15 20:02:24 +00:00
Duncan Sands
2699fb1072 Move Sub simplifications and additional Add simplifications out of 
instcombine and into InstructionSimplify.

llvm-svn: 121861
 2010-12-15 14:07:39 +00:00
Frits van Bommel
83b7c3773f Teach jump threading to "look through" a select when the branch direction of a terminator depends on it. 
When it sees a promising select it now tries to figure out whether the condition of the select is known in any of the predecessors and if so it maps the operands appropriately.

llvm-svn: 121859
 2010-12-15 09:51:20 +00:00
Chris Lattner
1499119975 make qsort predicate more conformant by returning 0 for equal values. 
llvm-svn: 121838
 2010-12-15 04:52:41 +00:00
Owen Anderson
de42e1136e Fix PR8790, another instance where unreachable code can cause instruction simplification to fail, 
this case involve a select that simplifies to itself.

llvm-svn: 121817
 2010-12-15 00:55:35 +00:00
Owen Anderson
df08ec80df Cleanup trailing whitespace. 
llvm-svn: 121816
 2010-12-15 00:52:44 +00:00
Chris Lattner
c1aaf52608 - Insert new instructions before DomBlock's terminator, 
which is simpler than finding a place to insert in BB.
 - Don't perform the 'if condition hoisting' xform on certain
   i1 PHIs, as it interferes with switch formation.

This re-fixes "example 7", without breaking the world hopefully.

llvm-svn: 121764
 2010-12-14 08:46:09 +00:00
Chris Lattner
22d4dc5a4d fix two significant issues with FoldTwoEntryPHINode: 
first, it can kick in on blocks whose conditions have been
folded to a constant, even though one of the edges will be
trivially folded.

second, it doesn't clean up the "if diamond" that it just 
eliminated away.  This is a problem because other simplifycfg
xforms kick in depending on the order of block visitation,
causing pointless work.

llvm-svn: 121762
 2010-12-14 08:01:53 +00:00
Chris Lattner
362f9a82c0 remove the instsimplify logic I added in r121754. It is apparently 
breaking the selfhost builds, though I can't fathom how.

llvm-svn: 121761
 2010-12-14 07:53:03 +00:00
Chris Lattner
c2e42269ae clean up logic, convert std::set to SmallPtrSet, handle the case 
when all 2-entry phis are simplified away.

llvm-svn: 121760
 2010-12-14 07:41:39 +00:00
Chris Lattner
8e4194276b tidy up a bit, move DEBUG down to when we commit to doing the transform so we 
don't print it unless the xform happens.

llvm-svn: 121758
 2010-12-14 07:23:10 +00:00
Chris Lattner
811462b2f4 use SimplifyInstruction instead of reimplementing part of it. 
llvm-svn: 121757
 2010-12-14 07:20:29 +00:00
Chris Lattner
e2400eb801 simplify GetIfCondition by using getSinglePredecessor. 
llvm-svn: 121756
 2010-12-14 07:15:21 +00:00
Chris Lattner
8ea88e66dd use AddPredecessorToBlock in 3 places instead of a manual loop. 
llvm-svn: 121755
 2010-12-14 07:09:42 +00:00
Chris Lattner
a87ac36a54 make FoldTwoEntryPHINode use instsimplify a bit, make 
GetIfCondition faster by avoiding pred_iterator.  No
really interesting change.

llvm-svn: 121754
 2010-12-14 07:00:00 +00:00
Chris Lattner
027d572664 remove the dead (and terrible) llvm::RemoveSuccessor function. 
llvm-svn: 121753
 2010-12-14 06:51:55 +00:00
Chris Lattner
d9436ab7d7 improve DEBUG's a bit, switch to eraseFromParent() to simplify 
code a bit, switch from constant folding to instsimplify.

llvm-svn: 121751
 2010-12-14 06:17:25 +00:00
Chris Lattner
093b5b256d reapply my recent change that disables a piece of the switch formation 
work, but fixes 400.perlbmk.

llvm-svn: 121749
 2010-12-14 05:57:30 +00:00
Owen Anderson
5536134dc4 Fix recent buildbot breakage by pulling SimplifyCFG back to its state as of r121694, the most recent state 
where I'm confident there were no crashes or miscompilations.  XFAIL the test added since then for now.

llvm-svn: 121733
 2010-12-13 23:49:28 +00:00
Chris Lattner
dcba81d96f temporarily disable part of my previous patch, which causes an iterator invalidation issue, causing a crash on some versions of perlbmk. 
llvm-svn: 121728
 2010-12-13 23:02:19 +00:00
Chris Lattner
759d8aa712 add some DEBUG's. 
llvm-svn: 121711
 2010-12-13 19:55:30 +00:00
Benjamin Kramer
7f1cdac1e4 Fix sort predicate. qsort(3)'s predicate semantics differ from std::sort's. Fixes PR 8780. 
llvm-svn: 121705
 2010-12-13 18:20:38 +00:00
Chris Lattner
0368bf7457 reinstate my patch: the miscompile was caused by an inverted branch in the 
'and' case.

llvm-svn: 121695
 2010-12-13 08:12:19 +00:00
Chris Lattner
caad324345 Completely disable the optimization I added in r121680 until 
I can track down a miscompile.  This should bring the buildbots
back to life

llvm-svn: 121693
 2010-12-13 07:41:29 +00:00
Chris Lattner
5ce3e42d80 Make simplifycfg reprocess newly formed "br (cond1 | cond2)" conditions 
when simplifying, allowing them to be eagerly turned into switches.  This
is the last step required to get "Example 7" from this blog post:
http://blog.regehr.org/archives/320

On X86, we now generate this machine code, which (to my eye) seems better
than the ICC generated code:

_crud:                                  ## @crud
## BB#0:                                ## %entry
	cmpb	$33, %dil
	jb	LBB0_4
## BB#1:                                ## %switch.early.test
	addb	$-34, %dil
	cmpb	$58, %dil
	ja	LBB0_3
## BB#2:                                ## %switch.early.test
	movzbl	%dil, %eax
	movabsq	$288230376537592865, %rcx ## imm = 0x400000017001421
	btq	%rax, %rcx
	jb	LBB0_4
LBB0_3:                                 ## %lor.rhs
	xorl	%eax, %eax
	ret
LBB0_4:                                 ## %lor.end
	movl	$1, %eax
	ret

llvm-svn: 121690
 2010-12-13 07:00:06 +00:00
Chris Lattner
20b9e84c7e make this logic a bit simpler. 
llvm-svn: 121689
 2010-12-13 06:36:51 +00:00
Chris Lattner
74d917e19d split all the guts of SimplifyCFGOpt::run out into one function 
per terminator kind.

llvm-svn: 121688
 2010-12-13 06:25:44 +00:00
Chris Lattner
ea15ce73be fix a bug in r121680 that upset the various buildbots. 
llvm-svn: 121687
 2010-12-13 05:34:18 +00:00
Chris Lattner
1eb2e235c8 refactor the speculative execution logic to be factored into the cond branch code instead of 
doing a cfg search for every block simplified.

llvm-svn: 121686
 2010-12-13 05:26:52 +00:00
Chris Lattner
4b9e3a31b0 simplify a bunch of code. 
llvm-svn: 121685
 2010-12-13 05:20:28 +00:00
Chris Lattner
d79dd057bf move HoistThenElseCodeToIf up to a more logical and efficient-to-handle place. 
llvm-svn: 121684
 2010-12-13 05:15:29 +00:00
Chris Lattner
80f8577d74 move 'MergeBlocksIntoPredecessor' call earlier. Use 
getSinglePredecessor to simplify code.

llvm-svn: 121683
 2010-12-13 05:10:48 +00:00
Chris Lattner
7ad8e06c3b factor new code out to a SimplifyBranchOnICmpChain helper function. 
llvm-svn: 121681
 2010-12-13 05:03:41 +00:00
Chris Lattner
5cbbcc56ad enhance the "change or icmp's into switch" xform to handle one value in an 
'or sequence' that it doesn't understand.  This allows us to optimize
something insane like this:

int crud (unsigned char c, unsigned x)
 {
   if(((((((((( (int) c <= 32 ||
                    (int) c == 46) || (int) c == 44)
                  || (int) c == 58) || (int) c == 59) || (int) c == 60)
               || (int) c == 62) || (int) c == 34) || (int) c == 92)
            || (int) c == 39) != 0)
     foo();
 }

into:

define i32 @crud(i8 zeroext %c, i32 %x) nounwind ssp noredzone {
entry:
  %cmp = icmp ult i8 %c, 33
  br i1 %cmp, label %if.then, label %switch.early.test

switch.early.test:                                ; preds = %entry
  switch i8 %c, label %if.end [
    i8 39, label %if.then
    i8 44, label %if.then
    i8 58, label %if.then
    i8 59, label %if.then
    i8 60, label %if.then
    i8 62, label %if.then
    i8 46, label %if.then
    i8 92, label %if.then
    i8 34, label %if.then
  ]

by pulling the < comparison out ahead of the newly formed switch.

llvm-svn: 121680
 2010-12-13 04:50:38 +00:00
Chris Lattner
f6be61e969 merge two very similar functions into one that has a bool argument. 
llvm-svn: 121678
 2010-12-13 04:26:26 +00:00
Chris Lattner
003b79e2d3 don't bother handling non-canonical icmp's 
llvm-svn: 121676
 2010-12-13 04:18:32 +00:00
Chris Lattner
9bd0b12342 inline a function, making the result much simpler. 
llvm-svn: 121675
 2010-12-13 04:15:19 +00:00
Chris Lattner
25b642edfd Fix my previous patch to handle a degenerate case that the llvm-gcc 
bootstrap buildbot tripped over.

llvm-svn: 121674
 2010-12-13 03:43:57 +00:00
Chris Lattner
9b089512e9 convert some methods to be static functions 
llvm-svn: 121673
 2010-12-13 03:30:12 +00:00
Chris Lattner
46cc5158bb zap two more std::sorts. 
llvm-svn: 121672
 2010-12-13 03:24:30 +00:00
Chris Lattner
a21c02e807 fix a fairly serious oversight with switch formation from 
or'd conditions.  Previously we'd compile something like this:

int crud (unsigned char c) {
   return c == 62 || c == 34 || c == 92;
}

into:

  switch i8 %c, label %lor.rhs [
    i8 62, label %lor.end
    i8 34, label %lor.end
  ]

lor.rhs:                                          ; preds = %entry
  %cmp8 = icmp eq i8 %c, 92
  br label %lor.end

lor.end:                                          ; preds = %entry, %entry, %lor.rhs
  %0 = phi i1 [ true, %entry ], [ %cmp8, %lor.rhs ], [ true, %entry ]
  %lor.ext = zext i1 %0 to i32
  ret i32 %lor.ext

which failed to merge the compare-with-92 into the switch.  With this patch
we simplify this all the way to:

  switch i8 %c, label %lor.rhs [
    i8 62, label %lor.end
    i8 34, label %lor.end
    i8 92, label %lor.end
  ]

lor.rhs:                                          ; preds = %entry
  br label %lor.end

lor.end:                                          ; preds = %entry, %entry, %entry, %lor.rhs
  %0 = phi i1 [ true, %entry ], [ false, %lor.rhs ], [ true, %entry ], [ true, %entry ]
  %lor.ext = zext i1 %0 to i32
  ret i32 %lor.ext

which is much better for codegen's switch lowering stuff.  This kicks in 33 times
on 176.gcc (for example) cutting 103 instructions off the generated code.

llvm-svn: 121671
 2010-12-13 03:18:54 +00:00
Chris Lattner
6d4df726a6 simplify code and reduce indentation 
llvm-svn: 121670
 2010-12-13 02:38:13 +00:00
Chris Lattner
134d892049 convert an std::sort to array_pod_sort. 
llvm-svn: 121669
 2010-12-13 02:00:58 +00:00
Chris Lattner
153b680cdd move the "br (X == 0 | X == 1), T, F" -> switch optimization to a new 
location in simplifycfg.  In the old days, SimplifyCFG was never run on
the entry block, so we had to scan over all preds of the BB passed into
simplifycfg to do this xform, now we can just check blocks ending with
a condbranch.  This avoids a scan over all preds of every simplified 
block, which should be a significant compile-time perf win on functions
with lots of edges.  No functionality change.

llvm-svn: 121668
 2010-12-13 01:57:34 +00:00
Chris Lattner
644a93e06b reduce indentation and generally simplify code, no functionality change. 
llvm-svn: 121667
 2010-12-13 01:47:07 +00:00
Chris Lattner
859fad7373 use getFirstNonPHIOrDbg to simplify this code. 
llvm-svn: 121664
 2010-12-13 01:28:06 +00:00
Benjamin Kramer
a638216447 Generalize the and-icmp-select instcombine further by allowing selects of the form 
(x & 2^n) ? 2^m+C : C

we can offset both arms by C to get the "(x & 2^n) ? 2^m : 0" form, optimize the
select to a shift and apply the offset afterwards.

llvm-svn: 121609
 2010-12-11 10:49:22 +00:00
Benjamin Kramer
5a1721f4ac Factor the (x & 2^n) ? 2^m : 0 instcombine into its own method and generalize it 
to catch cases where n != m with a shift.

llvm-svn: 121608
 2010-12-11 09:42:59 +00:00
Chris Lattner
996691e79c enhance memcpyopt to zap memcpy's that have the same src/dst. 
llvm-svn: 121362
 2010-12-09 07:45:45 +00:00
Chris Lattner
4fef82afa0 fix PR8753, eliminating a case where we'd infinitely make a 
substitution because it doesn't actually change the IR.  Patch by
Jakub Staszak!

llvm-svn: 121361
 2010-12-09 07:39:50 +00:00
Dan Gohman
3d9fc7db03 Really check that the bits that will become zero are actually already zero 
before eliminating the operation that zeros them. This fixes rdar://8739316.

llvm-svn: 121353
 2010-12-09 02:52:17 +00:00
Frits van Bommel
e7f51111ce Remove some dead code from the jump threading pass. 
The last uses of these functions were removed in r113852 when LazyValueInfo was permanently enabled and removed the need for them.

llvm-svn: 121133
 2010-12-07 13:08:07 +00:00
Jay Foad
79e18ed269 PR5207: Change APInt methods trunc(), sext(), zext(), sextOrTrunc() and 
zextOrTrunc(), and APSInt methods extend(), extOrTrunc() and new method
trunc(), to be const and to return a new value instead of modifying the
object in place.

llvm-svn: 121120
 2010-12-07 08:25:19 +00:00
Chris Lattner
12c2c17ac7 reapply r121100 with a tweak to constant fold ConstExprs with TargetData 
(if available) as we go so that we get simple constantexprs not insane ones.
This fixes the failure of clang/test/CodeGenCXX/virtual-base-ctor.cpp
that the previous iteration of this patch had.

llvm-svn: 121111
 2010-12-07 04:33:29 +00:00
Eric Christopher
cab6997dc8 Temporarily revert r121100 as it's causing clang to fail 
CodeGenCXX/virtual-base-ctor.cpp.

llvm-svn: 121102
 2010-12-07 02:41:11 +00:00
Chris Lattner
5996a47663 fix PR8710 - teach global opt that some constantexprs are too complex to 
put in a global variable's initializer.

llvm-svn: 121100
 2010-12-07 01:59:32 +00:00