[Bug optimization/12303] New: Compiling altivec code with optimisation on causes internal compiler error

["darren at nasoftware dot co dot uk" <gcc-bugzilla at gcc dot gnu dot org>]

PLEASE REPLY TO gcc-bugzilla@gcc.gnu.org ONLY, *NOT* gcc-bugs@gcc.gnu.org.

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=12303

           Summary: Compiling altivec code with optimisation on causes
                    internal compiler error
           Product: gcc
           Version: 3.3.1
            Status: UNCONFIRMED
          Severity: normal
          Priority: P2
         Component: optimization
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: darren at nasoftware dot co dot uk
                CC: gcc-bugs at gcc dot gnu dot org
 GCC build triplet: powerpc-unknown-linux-gnu
  GCC host triplet: powerpc-unknown-linux-gnu
GCC target triplet: powerpc-unknown-linux-gnu

Compiling the code included below causes an internal compiler error.  The code
compiled fine with version 3.3 of the compiler, however it crashes with 3.3.1.

gcc -v:
Reading specs from
/usr/local/gcc-3.3.1/lib/gcc-lib/powerpc-unknown-linux-gnu/3.3.1/specs
Configured with: ../gcc-3.3.1/configure --prefix=/usr/local/gcc-3.3.1
--enable-altivec --enable-languages=c++,f77,c
Thread model: posix
gcc version 3.3.1

Command line:
gcc -c -maltivec -mabi=altivec -O3 test2.c

Compiler output:
test2.c: In function `crashbuild':
test2.c:235: error: unrecognizable insn:
(insn 858 556 347 2 (nil) (set (reg:V16QI 78 v1)
        (const_vector:V16QI [
                (const_int 0 [0x0])
                (const_int 1 [0x1])
                (const_int 2 [0x2])
                (const_int 3 [0x3])
                (const_int 4 [0x4])
                (const_int 5 [0x5])
                (const_int 6 [0x6])
                (const_int 7 [0x7])
                (const_int 8 [0x8])
                (const_int 9 [0x9])
                (const_int 10 [0xa])
                (const_int 11 [0xb])
                (const_int 12 [0xc])
                (const_int 13 [0xd])
                (const_int 14 [0xe])
                (const_int 15 [0xf])
            ])) -1 (nil)
    (nil))
test2.c:235: internal compiler error: in extract_insn, at recog.c:2175
Please submit a full bug report,
with preprocessed source if appropriate.
See <URL:http://gcc.gnu.org/bugs.html> for instructions.

Source for test2.c:
#include <altivec.h>

void crashbuild(float *A_re, float *A_im, const signed int strideA,
		const signed int jumpA,
		float *R_re, float *R_im, const signed int strideR,
		const signed int jumpR, unsigned int n)
{
  vector unsigned char vmask =
    (vector unsigned char){ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15 };

  vector float vec0A_0;
  vector float vec0A_1;
  vector float vec0A_2;
  vector float vec0A_3;
  vector float vec0A_a;
  vector float vec0A_b;

  vector float vec1A_0;
  vector float vec1A_1;
  vector float vec1A_2;
  vector float vec1A_3;
  vector float vec1A_a;
  vector float vec1A_b;

  vector float vec2A_0;
  vector float vec2A_1;
  vector float vec2A_2;
  vector float vec2A_3;
  vector float vec2A_a;
  vector float vec2A_b;

  vector float vec3A_0;
  vector float vec3A_1;
  vector float vec3A_2;
  vector float vec3A_3;
  vector float vec3A_a;
  vector float vec3A_b;

  float *v0A_re0_0 = A_re;
  float *v0A_re0_1 = v0A_re0_0 + strideA;
  float *v0A_re0_2 = v0A_re0_1 + strideA;
  float *v0A_re0_3 = v0A_re0_2 + strideA;
  vector float vec0A_re0;
  float *v0A_im0_0 = A_im;
  float *v0A_im0_1 = v0A_im0_0 + strideA;
  float *v0A_im0_2 = v0A_im0_1 + strideA;
  float *v0A_im0_3 = v0A_im0_2 + strideA;
  vector float vec0A_im0;

  float *v1A_re0_0 = A_re + 1 * jumpA;
  float *v1A_re0_1 = v1A_re0_0 + strideA;
  float *v1A_re0_2 = v1A_re0_1 + strideA;
  float *v1A_re0_3 = v1A_re0_2 + strideA;
  vector float vec1A_re0;
  float *v1A_im0_0 = A_im + 1 * jumpA;
  float *v1A_im0_1 = v1A_im0_0 + strideA;
  float *v1A_im0_2 = v1A_im0_1 + strideA;
  float *v1A_im0_3 = v1A_im0_2 + strideA;
  vector float vec1A_im0;

  float *v2A_re0_0 = A_re + 2 * jumpA;
  float *v2A_re0_1 = v2A_re0_0 + strideA;
  float *v2A_re0_2 = v2A_re0_1 + strideA;
  float *v2A_re0_3 = v2A_re0_2 + strideA;
  vector float vec2A_re0;
  float *v2A_im0_0 = A_im + 2 * jumpA;
  float *v2A_im0_1 = v2A_im0_0 + strideA;
  float *v2A_im0_2 = v2A_im0_1 + strideA;
  float *v2A_im0_3 = v2A_im0_2 + strideA;
  vector float vec2A_im0;

  float *v3A_re0_0 = A_re + 3 * jumpA;
  float *v3A_re0_1 = v3A_re0_0 + strideA;
  float *v3A_re0_2 = v3A_re0_1 + strideA;
  float *v3A_re0_3 = v3A_re0_2 + strideA;
  vector float vec3A_re0;
  float *v3A_im0_0 = A_im + 3 * jumpA;
  float *v3A_im0_1 = v3A_im0_0 + strideA;
  float *v3A_im0_2 = v3A_im0_1 + strideA;
  float *v3A_im0_3 = v3A_im0_2 + strideA;
  vector float vec3A_im0;

  float *v0R_re0_0 = R_re;
  float *v0R_re0_1 = v0R_re0_0 + strideR;
  float *v0R_re0_2 = v0R_re0_1 + strideR;
  float *v0R_re0_3 = v0R_re0_2 + strideR;
  vector float vec0R_re0;
  float *v0R_im0_0 = R_im;
  float *v0R_im0_1 = v0R_im0_0 + strideR;
  float *v0R_im0_2 = v0R_im0_1 + strideR;
  float *v0R_im0_3 = v0R_im0_2 + strideR;
  vector float vec0R_im0;

  float *v1R_re0_0 = R_re + 1 * jumpR;
  float *v1R_re0_1 = v1R_re0_0 + strideR;
  float *v1R_re0_2 = v1R_re0_1 + strideR;
  float *v1R_re0_3 = v1R_re0_2 + strideR;
  vector float vec1R_re0;
  float *v1R_im0_0 = R_im + 1 * jumpR;
  float *v1R_im0_1 = v1R_im0_0 + strideR;
  float *v1R_im0_2 = v1R_im0_1 + strideR;
  float *v1R_im0_3 = v1R_im0_2 + strideR;
  vector float vec1R_im0;

  float *v2R_re0_0 = R_re + 2 * jumpR;
  float *v2R_re0_1 = v2R_re0_0 + strideR;
  float *v2R_re0_2 = v2R_re0_1 + strideR;
  float *v2R_re0_3 = v2R_re0_2 + strideR;
  vector float vec2R_re0;
  float *v2R_im0_0 = R_im + 2 * jumpR;
  float *v2R_im0_1 = v2R_im0_0 + strideR;
  float *v2R_im0_2 = v2R_im0_1 + strideR;
  float *v2R_im0_3 = v2R_im0_2 + strideR;
  vector float vec2R_im0;

  float *v3R_re0_0 = R_re + 3 * jumpR;
  float *v3R_re0_1 = v3R_re0_0 + strideR;
  float *v3R_re0_2 = v3R_re0_1 + strideR;
  float *v3R_re0_3 = v3R_re0_2 + strideR;
  vector float vec3R_re0;
  float *v3R_im0_0 = R_im + 3 * jumpR;
  float *v3R_im0_1 = v3R_im0_0 + strideR;
  float *v3R_im0_2 = v3R_im0_1 + strideR;
  float *v3R_im0_3 = v3R_im0_2 + strideR;
  vector float vec3R_im0;

  for (n = n / (vec_step(vector float)); n > 0; n--) {

    vec0A_0 = vec_lde(0, v0A_re0_0);
    vec0A_1 = vec_lde(0, v0A_re0_1);
    vec0A_a = vec_perm(vec0A_0, vec0A_1, vmask);
    vec0A_2 = vec_lde(0, v0A_re0_2);
    vec0A_3 = vec_lde(0, v0A_re0_3);
    vec0A_b = vec_perm(vec0A_2, vec0A_3, vmask);
    vec0A_re0 = vec_perm(vec0A_a, vec0A_b, vmask);
    vec0A_0 = vec_lde(0, v0A_im0_0);
    vec0A_1 = vec_lde(0, v0A_im0_1);
    vec0A_a = vec_perm(vec0A_0, vec0A_1, vmask);
    vec0A_2 = vec_lde(0, v0A_im0_2);
    vec0A_3 = vec_lde(0, v0A_im0_3);
    vec0A_b = vec_perm(vec0A_2, vec0A_3, vmask);
    vec0A_im0 = vec_perm(vec0A_a, vec0A_b, vmask);

    vec1A_0 = vec_lde(0, v1A_re0_0);
    vec1A_1 = vec_lde(0, v1A_re0_1);
    vec1A_a = vec_perm(vec1A_0, vec1A_1, vmask);
    vec1A_2 = vec_lde(0, v1A_re0_2);
    vec1A_3 = vec_lde(0, v1A_re0_3);
    vec1A_b = vec_perm(vec1A_2, vec1A_3, vmask);
    vec1A_re0 = vec_perm(vec1A_a, vec1A_b, vmask);
    vec1A_0 = vec_lde(0, v1A_im0_0);
    vec1A_1 = vec_lde(0, v1A_im0_1);
    vec1A_a = vec_perm(vec1A_0, vec1A_1, vmask);
    vec1A_2 = vec_lde(0, v1A_im0_2);
    vec1A_3 = vec_lde(0, v1A_im0_3);
    vec1A_b = vec_perm(vec1A_2, vec1A_3, vmask);
    vec1A_im0 = vec_perm(vec1A_a, vec1A_b, vmask);

    vec2A_0 = vec_lde(0, v2A_re0_0);
    vec2A_1 = vec_lde(0, v2A_re0_1);
    vec2A_a = vec_perm(vec2A_0, vec2A_1, vmask);
    vec2A_2 = vec_lde(0, v2A_re0_2);
    vec2A_3 = vec_lde(0, v2A_re0_3);
    vec2A_b = vec_perm(vec2A_2, vec2A_3, vmask);
    vec2A_re0 = vec_perm(vec2A_a, vec2A_b, vmask);
    vec2A_0 = vec_lde(0, v2A_im0_0);
    vec2A_1 = vec_lde(0, v2A_im0_1);
    vec2A_a = vec_perm(vec2A_0, vec2A_1, vmask);
    vec2A_2 = vec_lde(0, v2A_im0_2);
    vec2A_3 = vec_lde(0, v2A_im0_3);
    vec2A_b = vec_perm(vec2A_2, vec2A_3, vmask);
    vec2A_im0 = vec_perm(vec2A_a, vec2A_b, vmask);

    vec3A_0 = vec_lde(0, v3A_re0_0);
    vec3A_1 = vec_lde(0, v3A_re0_1);
    vec3A_a = vec_perm(vec3A_0, vec3A_1, vmask);
    vec3A_2 = vec_lde(0, v3A_re0_2);
    vec3A_3 = vec_lde(0, v3A_re0_3);
    vec3A_b = vec_perm(vec3A_2, vec3A_3, vmask);
    vec3A_re0 = vec_perm(vec3A_a, vec3A_b, vmask);
    vec3A_0 = vec_lde(0, v3A_im0_0);
    vec3A_1 = vec_lde(0, v3A_im0_1);
    vec3A_a = vec_perm(vec3A_0, vec3A_1, vmask);
    vec3A_2 = vec_lde(0, v3A_im0_2);
    vec3A_3 = vec_lde(0, v3A_im0_3);
    vec3A_b = vec_perm(vec3A_2, vec3A_3, vmask);
    vec3A_im0 = vec_perm(vec3A_a, vec3A_b, vmask);

    vec0R_re0 = vec0A_re0;
    vec0R_im0 = vec0A_im0;
    vec1R_re0 = vec1A_re0;
    vec1R_im0 = vec1A_im0;
    vec2R_re0 = vec2A_re0;
    vec2R_im0 = vec2A_im0;
    vec3R_re0 = vec3A_re0;
    vec3R_im0 = vec3A_im0;

    vec_ste(vec0R_re0, 0, v0R_re0_0);
    vec_ste(vec0R_re0, 0, v0R_re0_1);
    vec_ste(vec0R_re0, 0, v0R_re0_2);
    vec_ste(vec0R_re0, 0, v0R_re0_3);
    vec_ste(vec0R_im0, 0, v0R_im0_0);
    vec_ste(vec0R_im0, 0, v0R_im0_1);
    vec_ste(vec0R_im0, 0, v0R_im0_2);
    vec_ste(vec0R_im0, 0, v0R_im0_3);

    vec_ste(vec1R_re0, 0, v1R_re0_0);
    vec_ste(vec1R_re0, 0, v1R_re0_1);
    vec_ste(vec1R_re0, 0, v1R_re0_2);
    vec_ste(vec1R_re0, 0, v1R_re0_3);
    vec_ste(vec1R_im0, 0, v1R_im0_0);
    vec_ste(vec1R_im0, 0, v1R_im0_1);
    vec_ste(vec1R_im0, 0, v1R_im0_2);
    vec_ste(vec1R_im0, 0, v1R_im0_3);

    vec_ste(vec2R_re0, 0, v2R_re0_0);
    vec_ste(vec2R_re0, 0, v2R_re0_1);
    vec_ste(vec2R_re0, 0, v2R_re0_2);
    vec_ste(vec2R_re0, 0, v2R_re0_3);
    vec_ste(vec2R_im0, 0, v2R_im0_0);
    vec_ste(vec2R_im0, 0, v2R_im0_1);
    vec_ste(vec2R_im0, 0, v2R_im0_2);
    vec_ste(vec2R_im0, 0, v2R_im0_3);

    vec_ste(vec3R_re0, 0, v3R_re0_0);
    vec_ste(vec3R_re0, 0, v3R_re0_1);
    vec_ste(vec3R_re0, 0, v3R_re0_2);
    vec_ste(vec3R_re0, 0, v3R_re0_3);
    vec_ste(vec3R_im0, 0, v3R_im0_0);
    vec_ste(vec3R_im0, 0, v3R_im0_1);
    vec_ste(vec3R_im0, 0, v3R_im0_2);
    vec_ste(vec3R_im0, 0, v3R_im0_3);
  }
}