<feed xmlns='http://www.w3.org/2005/Atom'>
<title>llvm/test/Transforms/LoopIdiom, branch release_32</title>
<subtitle>http://llvm.org</subtitle>
<id>https://git.amat.us/llvm/atom/test/Transforms/LoopIdiom?h=release_32</id>
<link rel='self' href='https://git.amat.us/llvm/atom/test/Transforms/LoopIdiom?h=release_32'/>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/'/>
<updated>2012-11-02T08:40:24Z</updated>
<entry>
<title>Add a testcase to loop-idiom to cover PR14241 when we start handling</title>
<updated>2012-11-02T08:40:24Z</updated>
<author>
<name>Chandler Carruth</name>
<email>chandlerc@gmail.com</email>
</author>
<published>2012-11-02T08:40:24Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=52df6c2eec06861d9e933bae5b055f0b4e52f74f'/>
<id>urn:sha1:52df6c2eec06861d9e933bae5b055f0b4e52f74f</id>
<content type='text'>
strided loops again.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@167287 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>Revert the switch of loop-idiom to use the new dependence analysis.</title>
<updated>2012-11-02T08:33:25Z</updated>
<author>
<name>Chandler Carruth</name>
<email>chandlerc@gmail.com</email>
</author>
<published>2012-11-02T08:33:25Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=a864748284f4bab974ffb13b840a611c1f9bc7ac'/>
<id>urn:sha1:a864748284f4bab974ffb13b840a611c1f9bc7ac</id>
<content type='text'>
The new analysis is not yet ready for prime time. It has a *critical*
flawed assumption, and some troubling shortages of testing. Until it's
been hammered into better shape, let's stick with the working code. This
should be easy to revert itself when the analysis is ready.

Fixes PR14241, a miscompile of any memcpy-able loop which uses a pointer
as the induction mechanism. If you have been seeing miscompiles in this
revision range, you really want to test with this backed out. The
results of this miscompile are a bit subtle as they can lead to
downstream passes concluding things are impossible which are in fact
possible.

Thanks to David Blaikie for the majority of the reduction of this
miscompile. I'll be checking in the test case in a non-revert commit.

Revesions reverted here:

r167045: LoopIdiom: Fix a serious missed optimization: we only turned
         top-level loops into memmove.
r166877: LoopIdiom: Add checks to avoid turning memmove into an infinite
         loop.
r166875: LoopIdiom: Recognize memmove loops.
r166874: LoopIdiom: Replace custom dependence analysis with
         DependenceAnalysis.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@167286 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>LCSSA: Add a workaround for another nasty SCEV cache invalidation issue.</title>
<updated>2012-10-31T10:01:29Z</updated>
<author>
<name>Benjamin Kramer</name>
<email>benny.kra@googlemail.com</email>
</author>
<published>2012-10-31T10:01:29Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=4ad3d981b91ac1293b8f2be29e6452d5206107b8'/>
<id>urn:sha1:4ad3d981b91ac1293b8f2be29e6452d5206107b8</id>
<content type='text'>
I'm not entirely happy with this solution, but I don't see a smarter way currently.
Fixes PR14214.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@167112 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>DependenceAnalysis: Don't crash if there is no constant operand.</title>
<updated>2012-10-31T09:20:38Z</updated>
<author>
<name>Benjamin Kramer</name>
<email>benny.kra@googlemail.com</email>
</author>
<published>2012-10-31T09:20:38Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=061938b90b1addc3c3269bdbfeae1029f0c05a43'/>
<id>urn:sha1:061938b90b1addc3c3269bdbfeae1029f0c05a43</id>
<content type='text'>
This makes the code match the comments. Resolves a crash in loop idiom (PR14219).

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@167110 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>LoopIdiom: Fix a serious missed optimization: we only turned top-level loops into memmove.</title>
<updated>2012-10-30T19:49:39Z</updated>
<author>
<name>Benjamin Kramer</name>
<email>benny.kra@googlemail.com</email>
</author>
<published>2012-10-30T19:49:39Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=415f869cf30a272072c0533a2dea85496a210309'/>
<id>urn:sha1:415f869cf30a272072c0533a2dea85496a210309</id>
<content type='text'>
Thanks to Preston Briggs for catching this!

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@167045 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>LoopIdiom: Add checks to avoid turning memmove into an infinite loop.</title>
<updated>2012-10-27T15:18:28Z</updated>
<author>
<name>Benjamin Kramer</name>
<email>benny.kra@googlemail.com</email>
</author>
<published>2012-10-27T15:18:28Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=badffcf8fddf3978acf9843a43e66766e9e830c6'/>
<id>urn:sha1:badffcf8fddf3978acf9843a43e66766e9e830c6</id>
<content type='text'>
I don't think this is possible with the current implementation but that may change eventually.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@166877 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>LoopIdiom: Recognize memmove loops.</title>
<updated>2012-10-27T14:25:51Z</updated>
<author>
<name>Benjamin Kramer</name>
<email>benny.kra@googlemail.com</email>
</author>
<published>2012-10-27T14:25:51Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=d11c5d08a5f4f030d6e357378d0d46d93efd9a59'/>
<id>urn:sha1:d11c5d08a5f4f030d6e357378d0d46d93efd9a59</id>
<content type='text'>
This turns loops like
  for (unsigned i = 0; i != n; ++i)
    p[i] = p[i+1];
into memmove, which has a highly optimized implementation in most libcs.

This was really easy with the new DependenceAnalysis :)

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@166875 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>LoopIdiom: Replace custom dependence analysis with DependenceAnalysis.</title>
<updated>2012-10-27T14:25:44Z</updated>
<author>
<name>Benjamin Kramer</name>
<email>benny.kra@googlemail.com</email>
</author>
<published>2012-10-27T14:25:44Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=96c8735e28f2f89be37cdd907f680c6c1bf16052'/>
<id>urn:sha1:96c8735e28f2f89be37cdd907f680c6c1bf16052</id>
<content type='text'>
Requires a lot less code and complexity on loop-idiom's side and the more
precise analysis can catch more cases, like the one I included as a test case.
This also fixes the edge-case miscompilation from PR9481.

Compile time performance seems to be slightly worse, but this is mostly due
to an extra LCSSA run scheduled by the PassManager and should be fixed there.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@166874 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>Revert r166390 "LoopIdiom: Replace custom dependence analysis with LoopDependenceAnalysis."</title>
<updated>2012-10-21T19:31:16Z</updated>
<author>
<name>Benjamin Kramer</name>
<email>benny.kra@googlemail.com</email>
</author>
<published>2012-10-21T19:31:16Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=3740e798bc850cd5d40185959801606433b0221f'/>
<id>urn:sha1:3740e798bc850cd5d40185959801606433b0221f</id>
<content type='text'>
It passes all tests, produces better results than the old code but uses the
wrong pass, LoopDependenceAnalysis, which is old and unmaintained. "Why is it
still in tree?", you might ask. The answer is obviously: "To confuse developers."

Just swapping in the new dependency pass sends the pass manager into an infinte
loop, I'll try to figure out why tomorrow.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@166399 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>LoopIdiom: Replace custom dependence analysis with LoopDependenceAnalysis.</title>
<updated>2012-10-21T15:03:07Z</updated>
<author>
<name>Benjamin Kramer</name>
<email>benny.kra@googlemail.com</email>
</author>
<published>2012-10-21T15:03:07Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=5c6e9ae14e012bfe1fdf0e19957922d3c4d85670'/>
<id>urn:sha1:5c6e9ae14e012bfe1fdf0e19957922d3c4d85670</id>
<content type='text'>
Requires a lot less code and complexity on loop-idiom's side and the more
precise analysis can catch more cases, like the one I included as a test case.
This also fixes the edge-case miscompilation from PR9481. I'm not entirely
sure that all cases are handled that the old checks handled but LDA will
certainly become smarter in the future.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@166390 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
</feed>
