gcc -m32  -O3 -funroll-loops -msse2 -mfpmath=sse -ffast-math also miscompiled.

What exact revision do you mean?  r62283 is quite a bit old...

I suppose r222514.

(In reply to Richard Biener from comment #3)
> I suppose r222514.

Yes, it is.

Also reproduces with -Ofast -march=bdver2 -m32 so I suppose -O3 -ffast-math -m32 -msse2 should also reproduce it.

I wont get to look into this before Monday, any help in bisecting (-fno-tree-vectorize for which file(s) fix it?  for which function?) appreciated
until then.

At least milc is C and not too big ;)

Also fails with the test input.

Building rephase.c:rephase with -fno-tree-slp-vectorize makes it succeed.

The loop is basically

register int i,j,k,dir;
register site *s;

    for(i=0,s=lattice;i<sites_on_node;i++,s++){
 for(dir=0;dir<=3;dir++){
     for(j=0;j<3;j++)for(k=0;k<3;k++){
  s->link[dir].e[j][k].real *= s->phase[dir];
  s->link[dir].e[j][k].imag *= s->phase[dir];
     }
 }
    }

where the inner two loops are unrolled and SLP applies to them.  We need to perform swapping on some of the mult operands and then somehow fail to use
the correct vectors to build up s->phase[dir] from parts.

  vect_cst_.35_44 = {_117, _121};
  vect_cst_.36_45 = {_110, _114};
  vect_cst_.37_46 = {_103, _107};
  vect_cst_.38_47 = {_92, _96};
  vect_cst_.39_48 = {_85, _89};
  vect_cst_.40_52 = {_78, _82};
  vect_cst_.41_53 = {_49, _71};
  vect_cst_.42_54 = {_31, _60};
  vect_cst_.43_55 = {_24, _27};

note how these should be all {_24, _24} but only the first one is correct.

I think this is a latent issue since we do the swapping tricks.

Testcase that also fails with -m64.

/* { dg-do run } */
/* { dg-additional-options "-O3" } */
/* { dg-require-effective-target vect_double } */

#include "tree-vect.h"

extern void abort (void);
extern void *malloc (__SIZE_TYPE__);

struct site {
    struct {
        struct {
            double real;
            double imag;
        } e[3][3];
    } link[32];
    double phase[32];
} *lattice;
int sites_on_node;

void rephase (void)
{
  int i,j,k,dir;
  struct site *s;
  for(i=0,s=lattice;i<sites_on_node;i++,s++)
    for(dir=0;dir<32;dir++)
      for(j=0;j<3;j++)for(k=0;k<3;k++)
        {
          s->link[dir].e[j][k].real *= s->phase[dir];
          s->link[dir].e[j][k].imag *= s->phase[dir];
        }
}

int main()
{
  int i,j,k;
  check_vect ();
  sites_on_node = 1;
  lattice = malloc (sizeof (struct site) * sites_on_node);
  for (i = 0; i < 32; ++i)
    {
      lattice->phase[i] = i;
      for (j = 0; j < 3; ++j)
        for (k = 0; k < 3; ++k)
          {
            lattice->link[i].e[j][k].real = 1.0;
            lattice->link[i].e[j][k].imag = 1.0;
            __asm__ volatile ("" : : : "memory");
          }
    }
  rephase ();
  for (i = 0; i < 32; ++i)
    for (j = 0; j < 3; ++j)
      for (k = 0; k < 3; ++k)
        if (lattice->link[i].e[j][k].real != i
            || lattice->link[i].e[j][k].imag != i)
          abort ();
  return 0;
}

/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "slp1" } } */
/* { dg-final { cleanup-tree-dump "slp1" } } */
/* { dg-final { cleanup-tree-dump "vect" } } */

Testing a fix.  The issue is latent with at least constant operands - but it's
probably impossible(?) to get bogus operand order on those.  In theory if the
loads from phase were just in a different BB the issue would reproduce as well.
OTOH then GCC 5 swaps in vect_get_and_check_slp_defs which already does swap
operands in the IL...

Author: rguenth
Date: Mon May  4 13:31:02 2015
New Revision: 222764

URL: https://gcc.gnu.org/viewcvs?rev=222764&root=gcc&view=rev
Log:
2015-05-04  Richard Biener  <rguenther@suse.de>

	PR tree-optimization/65935
	* tree-vect-slp.c (vect_build_slp_tree): If we swapped operands
	then make sure to apply that swapping to the IL.

	* gcc.dg/vect/bb-slp-pr65935.c: New testcase.

Added:
    trunk/gcc/testsuite/gcc.dg/vect/bb-slp-pr65935.c
Modified:
    trunk/gcc/ChangeLog
    trunk/gcc/testsuite/ChangeLog
    trunk/gcc/tree-vect-slp.c

Fixed.