<feed xmlns='http://www.w3.org/2005/Atom'>
<title>llvm/test/Analysis, branch release_33</title>
<subtitle>http://llvm.org</subtitle>
<id>https://git.amat.us/llvm/atom/test/Analysis?h=release_33</id>
<link rel='self' href='https://git.amat.us/llvm/atom/test/Analysis?h=release_33'/>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/'/>
<updated>2013-05-06T16:51:08Z</updated>
<entry>
<title>AArch64: use MCJIT by default and enable related tests.</title>
<updated>2013-05-06T16:51:08Z</updated>
<author>
<name>Tim Northover</name>
<email>Tim.Northover@arm.com</email>
</author>
<published>2013-05-06T16:51:08Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=4c8850cd1c97eff659169967bb70b6e22c3ace27'/>
<id>urn:sha1:4c8850cd1c97eff659169967bb70b6e22c3ace27</id>
<content type='text'>
This just enables some testing I'd missed after implementing MCJIT
support.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@181215 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>Fix unchecked uses of DominatorTree in MemoryDependenceAnalysis.</title>
<updated>2013-05-06T02:07:24Z</updated>
<author>
<name>Matt Arsenault</name>
<email>Matthew.Arsenault@amd.com</email>
</author>
<published>2013-05-06T02:07:24Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=8b9dc21d6f12a0251cdb6116c2297c13d77073d5'/>
<id>urn:sha1:8b9dc21d6f12a0251cdb6116c2297c13d77073d5</id>
<content type='text'>
Use unknown results for places where it would be needed

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@181176 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>RegionInfo: Do not crash if unreachable block is found</title>
<updated>2013-05-03T15:48:34Z</updated>
<author>
<name>Tobias Grosser</name>
<email>grosser@fim.uni-passau.de</email>
</author>
<published>2013-05-03T15:48:34Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=333403abbda5722724025cda1f8f52ef36d31505'/>
<id>urn:sha1:333403abbda5722724025cda1f8f52ef36d31505</id>
<content type='text'>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@181025 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>TBAA: remove !tbaa from testing cases if not used.</title>
<updated>2013-04-29T22:42:01Z</updated>
<author>
<name>Manman Ren</name>
<email>mren@apple.com</email>
</author>
<published>2013-04-29T22:42:01Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=e78d832097fc4df6f624150017c54c7a3189cd19'/>
<id>urn:sha1:e78d832097fc4df6f624150017c54c7a3189cd19</id>
<content type='text'>
This will make it easier to turn on struct-path aware TBAA since the metadata
format will change.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@180743 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>Struct-path aware TBAA: change the format of TBAAStructType node.</title>
<updated>2013-04-27T00:26:11Z</updated>
<author>
<name>Manman Ren</name>
<email>mren@apple.com</email>
</author>
<published>2013-04-27T00:26:11Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=a5b314c27a585b979ac9c9da944aa3cec27d22a6'/>
<id>urn:sha1:a5b314c27a585b979ac9c9da944aa3cec27d22a6</id>
<content type='text'>
We switch the order of offset and field type to make TBAAStructType node
(name, parent node, offset) similar to scalar TBAA node (name, parent node).
TypeIsImmutable is added to TBAAStructTag node.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@180654 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>ARM cost model: Integer div and rem is lowered to a function call</title>
<updated>2013-04-25T21:16:18Z</updated>
<author>
<name>Arnold Schwaighofer</name>
<email>aschwaighofer@apple.com</email>
</author>
<published>2013-04-25T21:16:18Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=45c9e0b412495c2d660918b0e964529bcb5e05b8'/>
<id>urn:sha1:45c9e0b412495c2d660918b0e964529bcb5e05b8</id>
<content type='text'>
Reflect this in the cost model. I observed this in MiBench/consumer-lame.

radar://13354716

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@180576 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>Legalize vector truncates by parts rather than just splitting.</title>
<updated>2013-04-21T23:47:41Z</updated>
<author>
<name>Jim Grosbach</name>
<email>grosbach@apple.com</email>
</author>
<published>2013-04-21T23:47:41Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=0cb1019e9cd41237408eae09623eb9a34a4cbe0c'/>
<id>urn:sha1:0cb1019e9cd41237408eae09623eb9a34a4cbe0c</id>
<content type='text'>
Rather than just splitting the input type and hoping for the best, apply
a bit more cleverness. Just splitting the types until the source is
legal often leads to an illegal result time, which is then widened and a
scalarization step is introduced which leads to truly horrible code
generation. With the loop vectorizer, these sorts of operations are much
more common, and so it's worth extra effort to do them well.

Add a legalization hook for the operands of a TRUNCATE node, which will
be encountered after the result type has been legalized, but if the
operand type is still illegal. If simple splitting of both types
ends up with the result type of each half still being legal, just
do that (v16i16 -&gt; v16i8 on ARM, for example). If, however, that would
result in an illegal result type (v8i32 -&gt; v8i8 on ARM, for example),
we can get more clever with power-two vectors. Specifically,
split the input type, but also widen the result element size, then
concatenate the halves and truncate again.  For example on ARM,
To perform a "%res = v8i8 trunc v8i32 %in" we transform to:
  %inlo = v4i32 extract_subvector %in, 0
  %inhi = v4i32 extract_subvector %in, 4
  %lo16 = v4i16 trunc v4i32 %inlo
  %hi16 = v4i16 trunc v4i32 %inhi
  %in16 = v8i16 concat_vectors v4i16 %lo16, v4i16 %hi16
  %res = v8i8 trunc v8i16 %in16

This allows instruction selection to generate three VMOVN instructions
instead of a sequences of moves, stores and loads.

Update the ARMTargetTransformInfo to take this improved legalization
into account.

Consider the simplified IR:

define &lt;16 x i8&gt; @test1(&lt;16 x i32&gt;* %ap) {
  %a = load &lt;16 x i32&gt;* %ap
  %tmp = trunc &lt;16 x i32&gt; %a to &lt;16 x i8&gt;
  ret &lt;16 x i8&gt; %tmp
}

define &lt;8 x i8&gt; @test2(&lt;8 x i32&gt;* %ap) {
  %a = load &lt;8 x i32&gt;* %ap
  %tmp = trunc &lt;8 x i32&gt; %a to &lt;8 x i8&gt;
  ret &lt;8 x i8&gt; %tmp
}

Previously, we would generate the truly hideous:
	.syntax unified
	.section	__TEXT,__text,regular,pure_instructions
	.globl	_test1
	.align	2
_test1:                                 @ @test1
@ BB#0:
	push	{r7}
	mov	r7, sp
	sub	sp, sp, #20
	bic	sp, sp, #7
	add	r1, r0, #48
	add	r2, r0, #32
	vld1.64	{d24, d25}, [r0:128]
	vld1.64	{d16, d17}, [r1:128]
	vld1.64	{d18, d19}, [r2:128]
	add	r1, r0, #16
	vmovn.i32	d22, q8
	vld1.64	{d16, d17}, [r1:128]
	vmovn.i32	d20, q9
	vmovn.i32	d18, q12
	vmov.u16	r0, d22[3]
	strb	r0, [sp, #15]
	vmov.u16	r0, d22[2]
	strb	r0, [sp, #14]
	vmov.u16	r0, d22[1]
	strb	r0, [sp, #13]
	vmov.u16	r0, d22[0]
	vmovn.i32	d16, q8
	strb	r0, [sp, #12]
	vmov.u16	r0, d20[3]
	strb	r0, [sp, #11]
	vmov.u16	r0, d20[2]
	strb	r0, [sp, #10]
	vmov.u16	r0, d20[1]
	strb	r0, [sp, #9]
	vmov.u16	r0, d20[0]
	strb	r0, [sp, #8]
	vmov.u16	r0, d18[3]
	strb	r0, [sp, #3]
	vmov.u16	r0, d18[2]
	strb	r0, [sp, #2]
	vmov.u16	r0, d18[1]
	strb	r0, [sp, #1]
	vmov.u16	r0, d18[0]
	strb	r0, [sp]
	vmov.u16	r0, d16[3]
	strb	r0, [sp, #7]
	vmov.u16	r0, d16[2]
	strb	r0, [sp, #6]
	vmov.u16	r0, d16[1]
	strb	r0, [sp, #5]
	vmov.u16	r0, d16[0]
	strb	r0, [sp, #4]
	vldmia	sp, {d16, d17}
	vmov	r0, r1, d16
	vmov	r2, r3, d17
	mov	sp, r7
	pop	{r7}
	bx	lr

	.globl	_test2
	.align	2
_test2:                                 @ @test2
@ BB#0:
	push	{r7}
	mov	r7, sp
	sub	sp, sp, #12
	bic	sp, sp, #7
	vld1.64	{d16, d17}, [r0:128]
	add	r0, r0, #16
	vld1.64	{d20, d21}, [r0:128]
	vmovn.i32	d18, q8
	vmov.u16	r0, d18[3]
	vmovn.i32	d16, q10
	strb	r0, [sp, #3]
	vmov.u16	r0, d18[2]
	strb	r0, [sp, #2]
	vmov.u16	r0, d18[1]
	strb	r0, [sp, #1]
	vmov.u16	r0, d18[0]
	strb	r0, [sp]
	vmov.u16	r0, d16[3]
	strb	r0, [sp, #7]
	vmov.u16	r0, d16[2]
	strb	r0, [sp, #6]
	vmov.u16	r0, d16[1]
	strb	r0, [sp, #5]
	vmov.u16	r0, d16[0]
	strb	r0, [sp, #4]
	ldm	sp, {r0, r1}
	mov	sp, r7
	pop	{r7}
	bx	lr

Now, however, we generate the much more straightforward:
	.syntax unified
	.section	__TEXT,__text,regular,pure_instructions
	.globl	_test1
	.align	2
_test1:                                 @ @test1
@ BB#0:
	add	r1, r0, #48
	add	r2, r0, #32
	vld1.64	{d20, d21}, [r0:128]
	vld1.64	{d16, d17}, [r1:128]
	add	r1, r0, #16
	vld1.64	{d18, d19}, [r2:128]
	vld1.64	{d22, d23}, [r1:128]
	vmovn.i32	d17, q8
	vmovn.i32	d16, q9
	vmovn.i32	d18, q10
	vmovn.i32	d19, q11
	vmovn.i16	d17, q8
	vmovn.i16	d16, q9
	vmov	r0, r1, d16
	vmov	r2, r3, d17
	bx	lr

	.globl	_test2
	.align	2
_test2:                                 @ @test2
@ BB#0:
	vld1.64	{d16, d17}, [r0:128]
	add	r0, r0, #16
	vld1.64	{d18, d19}, [r0:128]
	vmovn.i32	d16, q8
	vmovn.i32	d17, q9
	vmovn.i16	d16, q8
	vmov	r0, r1, d16
	bx	lr

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@179989 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>X86 cost model: Exit before calling getSimpleVT on non-simple VTs</title>
<updated>2013-04-17T20:04:53Z</updated>
<author>
<name>Arnold Schwaighofer</name>
<email>aschwaighofer@apple.com</email>
</author>
<published>2013-04-17T20:04:53Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=9c63f0d687cf1130ee2e76a6fdc87d71ae9d3961'/>
<id>urn:sha1:9c63f0d687cf1130ee2e76a6fdc87d71ae9d3961</id>
<content type='text'>
getSimpleVT can only handle simple value types.

radar://13676022

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@179714 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>CostModel: increase the default cost of supported floating point operations from 1 to two. Fixed a few tests that changes because now the cost of one insert + a vector operation on two doubles is lower than two scalar operations on doubles.</title>
<updated>2013-04-12T21:15:03Z</updated>
<author>
<name>Nadav Rotem</name>
<email>nrotem@apple.com</email>
</author>
<published>2013-04-12T21:15:03Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=9eb366acba65b5779d2129db3a6fb6a0414572d4'/>
<id>urn:sha1:9eb366acba65b5779d2129db3a6fb6a0414572d4</id>
<content type='text'>
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@179413 91177308-0d34-0410-b5e6-96231b3b80d8
</content>
</entry>
<entry>
<title>Aliasing rules for struct-path aware TBAA.</title>
<updated>2013-04-11T23:24:18Z</updated>
<author>
<name>Manman Ren</name>
<email>mren@apple.com</email>
</author>
<published>2013-04-11T23:24:18Z</published>
<link rel='alternate' type='text/html' href='https://git.amat.us/llvm/commit/?id=4df1854f263180fcd04cee3347990afe34749a89'/>
<id>urn:sha1:4df1854f263180fcd04cee3347990afe34749a89</id>
<content type='text'>
Added PathAliases to check if two struct-path tags can alias.
Added command line option -struct-path-tbaa.


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