<html>
<head>
<base href="https://llvm.org/bugs/" />
</head>
<body><table border="1" cellspacing="0" cellpadding="8">
<tr>
<th>Bug ID</th>
<td><a class="bz_bug_link
bz_status_NEW "
title="NEW --- - shuffle and vectorize repeated scalar ops on extracted elements"
href="https://llvm.org/bugs/show_bug.cgi?id=31880">31880</a>
</td>
</tr>
<tr>
<th>Summary</th>
<td>shuffle and vectorize repeated scalar ops on extracted elements
</td>
</tr>
<tr>
<th>Product</th>
<td>libraries
</td>
</tr>
<tr>
<th>Version</th>
<td>trunk
</td>
</tr>
<tr>
<th>Hardware</th>
<td>PC
</td>
</tr>
<tr>
<th>OS</th>
<td>All
</td>
</tr>
<tr>
<th>Status</th>
<td>NEW
</td>
</tr>
<tr>
<th>Severity</th>
<td>normal
</td>
</tr>
<tr>
<th>Priority</th>
<td>P
</td>
</tr>
<tr>
<th>Component</th>
<td>Transformation Utilities
</td>
</tr>
<tr>
<th>Assignee</th>
<td>unassignedbugs@nondot.org
</td>
</tr>
<tr>
<th>Reporter</th>
<td>spatel+llvm@rotateright.com
</td>
</tr>
<tr>
<th>CC</th>
<td>llvm-bugs@lists.llvm.org
</td>
</tr>
<tr>
<th>Classification</th>
<td>Unclassified
</td>
</tr></table>
<p>
<div>
<pre>Forking this off from the (possibly more specific and less useful) <a class="bz_bug_link
bz_status_NEW "
title="NEW --- - vectorize repeated scalar ops that don't get put back into a vector"
href="show_bug.cgi?id=31879">bug 31879</a>
and the motivating (complex numbers) <a class="bz_bug_link
bz_status_NEW "
title="NEW --- - Squaring a complex float gives inefficient code"
href="show_bug.cgi?id=31866">bug 31866</a>:
; For vectors <x0, x1> and <y0, y1>, return <x0*x0, y1*y1>
define <2 x i8> @g(<2 x i8> %x, <2 x i8> %y) {
%x0 = extractelement <2 x i8> %x, i32 0
%y1 = extractelement <2 x i8> %y, i32 1
%x0x0 = mul i8 %x0, %x0
%y1y1 = mul i8 %y1, %y1
%ins1 = insertelement <2 x i8> undef, i8 %x0x0, i32 0
%ins2 = insertelement <2 x i8> %ins1, i8 %y1y1, i32 1
ret <2 x i8> %ins2
}
The canonical IR should be:
define <2 x i8> @h(<2 x i8> %x, <2 x i8> %y) {
%x0y1 = shufflevector <2 x i8> %x, <2 x i8> %y, <2 x i32> <i32 0, i32 3>
%x0x0y1y1 = mul <2 x i8> %x0y1, %x0y1
ret <2 x i8> %x0x0y1y1
}
This is obviously less instructions and does no extra computational work. Ie,
there are still just two 8-bit multiplies, and we're not operating on unknown
vector elements. Therefore, this is safe even for FP vectors that might contain
perf bombs like denorms because we're still not going to touch them.
The backend will scalarize the vector op if it is not supported to effectively
undo this transform. That should also eliminate the shuffle.
Note that we don't create arbitrary shuffles in IR because it could be
disastrous for the backend, but this is a special case: it's a "blend" (x86
terminology). Ie, we're taking elements from the 2 source vectors without
crossing vector lanes. There's precedent for this type of shuffle because we
canonicalize vector selects to this form:
define <2 x i8> @h(<2 x i8> %x, <2 x i8> %y) {
%x0y1 = select <2 x i1> <i1 true, i1 false>, <2 x i8> %x, <2 x i8> %y
%mul = mul <2 x i8> %x0y1, %x0y1
ret <2 x i8> %mul
}
$ ./opt -instcombine scalarizedmath.ll -S
define <2 x i8> @h(<2 x i8> %x, <2 x i8> %y) {
%x0y1 = shufflevector <2 x i8> %x, <2 x i8> %y, <2 x i32> <i32 0, i32 3>
%mul = mul <2 x i8> %x0y1, %x0y1
ret <2 x i8> %mul
}</pre>
</div>
</p>
<hr>
<span>You are receiving this mail because:</span>
<ul>
<li>You are on the CC list for the bug.</li>
</ul>
</body>
</html>