[Bug middle-end/51017] GCC 4.6 performance regression (vs. 4.4/4.5)

["solar-gcc at openwall dot com" <gcc-bugzilla@gcc.gnu.org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51017

--- Comment #10 from Alexander Peslyak <solar-gcc at openwall dot com> ---
I decided to take a look at the generated code.  Compared to 4.6.2, GCC 4.9.2
started generating lots of xorps, orps, andps, andnps where it previously
generated pxor, por, pand, pandn.  Changing those with:

sed -i 's/xorps/pxor/g; s/orps/por/g; s/andps/pand/g; s/andnps/pandn/g'

made no difference for performance on this machine (still 4.9.2's poor
performance).

The next suspect were the varieties of MOV instructions.  In 4.9.2's generated
code, there were 1319 movaps, 721 movups.  In 4.6.2's, there were 1258 movaps,
465 movups.  Simply changing all movups to movaps in 4.9.2's original code with
sed (thus, with no other changes except for this one), resulting in a total of
2040 movaps, brought the performance to levels similar to GCC 4.4 and 4.5's
(and is better than 4.6's, but worse than 4.3's).  So movups appear to be the
main culprit.  The same hack for 4.6.2's code brought its performance almost to
4.3's level (still 5% worse, though), and significantly above 4.9.2's (so
there's still some other, smaller regression with 4.9.2).

Here are my new results:

4.1.0o - 2960K c/s, 28182 bytes, 1758 movaps, 0 movups
4.3.6o - 2956K c/s, 28229 bytes, 1755 movaps, 0 movups
4.4.6o - 2694K c/s, 29316 bytes, 1709 movaps, 7 movups
4.4.6h - 2714K c/s, 29316 bytes, 1716 movaps, 0 movups
4.5.3o - 2709K c/s, 29203 bytes, 1669 movaps, 0 movups
4.6.2o - 2121K c/s, 29624 bytes, 1258 movaps, 465 movups
4.6.2h - 2817K c/s, 29624 bytes, 1723 movaps, 0 movups
4.9.2o - 1852K c/s, 28256 bytes, 1319 movaps, 721 movups
4.9.2h - 2688K c/s, 28256 bytes, 2040 movaps, 0 movups

"o" means original, "h" means hacked generated assembly code (all movups
changed to movaps).  (BTW, there were no movdqa/movdqu in any of these code
versions.)

Now I am wondering to what extent this is a GCC issue and to what extent it
might be my source code's, if GCC is somehow unsure it can assume alignment. 
What are the conditions when GCC should in fact use movups?  Is it intentional
that newer versions of GCC are being more careful at this, resulting in worse
performance?