obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 305 insertions, 0 deletions

diff --git a/gcc/testsuite/gcc.target/spu/intrinsics-2.c b/gcc/testsuite/gcc.target/spu/intrinsics-2.c
new file mode 100644
index 000000000..43a272b91
--- /dev/null
+++ b/gcc/testsuite/gcc.target/spu/intrinsics-2.c
@@ -0,0 +1,305 @@
+/* { dg-do run } */
+/* { dg-options "-std=c99" } */
+#include <vec_types.h>
+extern void abort (void);
+extern void exit (int);
+
+typedef union {
+  vec_ullong2   vull;
+  vec_double2   vd;
+  unsigned int  ui[4];
+  unsigned long long ull[2];
+  double        d[2];
+} v128;
+
+static v128 a, b, c, d, a0, b0, a1, b1;
+static int samples = 10;
+unsigned int seed = 0;
+
+unsigned int rand_local()
+{
+  seed = seed * 69607 + 54329;
+  return (seed);
+}
+
+double rand_double(double min, double max)
+{
+  union {
+    unsigned int ui[2];
+    double d;
+  } x;
+
+  x.ui[0] = (rand_local() & 0x000FFFFF) | 0x3FF00000;
+  x.ui[1] = rand_local();
+  x.d -= 1.0;
+  x.d *= max - min;
+  x.d += min;
+  return (x.d);
+}
+
+vec_double2 rand_vd(double min, double max)
+{
+  int i;
+  static v128 val;
+
+  for (i=0; i<2; i++) val.d[i] = rand_double(min, max);
+  return (val.vd);
+}
+
+int test_spu_cmpeq()
+{
+  int i, j;
+  unsigned long long exp;
+
+  /* double */
+  for (i=0; i<samples; i++) {
+    a.vd = rand_vd(-4.0, 4.0);
+    b.vd = rand_vd(-4.0, 4.0);
+    d.vull = spu_cmpeq(a.vd, b.vd);
+    for (j=0; j<2; j++) {
+      exp = (a.d[j] == b.d[j]) ? 
+	    (((unsigned long long)(0xFFFFFFFF) << 32) 
+	     | (unsigned long long)(0xFFFFFFFF)) : 0;
+      if (exp != d.ull[j]) abort();
+    }
+  }
+
+  /* compare zeros  */
+    d.vull = spu_cmpeq(a0.vd, b0.vd);
+    for (j=0; j<2; j++) {
+      exp = (a0.d[j] == b0.d[j]) ? 
+	    (((unsigned long long)(0xFFFFFFFF) << 32) 
+	     | (unsigned long long)(0xFFFFFFFF)) : 0;
+      if (exp != d.ull[j]) abort();
+    }
+
+  /* compare NaNs  */
+    d.vull = spu_cmpeq(a1.vd, b1.vd);
+    for (j=0; j<2; j++) {
+      exp = (a1.d[j] == b1.d[j]) ? 
+	    (((unsigned long long)(0xFFFFFFFF) << 32) 
+	     | (unsigned long long)(0xFFFFFFFF)) : 0;
+      if (exp != d.ull[j]) abort();
+    }
+  return 0;
+}
+
+int test_spu_cmpgt()
+{   
+  int i, j;
+  unsigned long long exp;
+
+  /* double */
+  for (i=0; i<samples; i++) {
+    a.vd = rand_vd(-4.0, 4.0);
+    b.vd = rand_vd(-4.0, 4.0);
+    d.vull = spu_cmpgt(a.vd, b.vd);
+    for (j=0; j<2; j++) {
+      exp = (a.d[j] > b.d[j]) ? 
+	    (((unsigned long long)(0xFFFFFFFF) << 32) 
+	     | (unsigned long long)(0xFFFFFFFF)) : 0;
+      if (exp != d.ull[j]) abort();
+    } 
+  }
+
+  /* compare zeros  */
+    d.vull = spu_cmpgt(a0.vd, b0.vd);
+    for (j=0; j<2; j++) {
+      exp = (a0.d[j] > b0.d[j]) ? 
+	    (((unsigned long long)(0xFFFFFFFF) << 32) 
+	     | (unsigned long long)(0xFFFFFFFF)) : 0;
+      if (exp != d.ull[j]) abort();
+    }
+  /* compare NaNs  */
+    d.vull = spu_cmpgt(a1.vd, b1.vd);
+    for (j=0; j<2; j++) {
+      exp = (a1.d[j] > b1.d[j]) ? 
+	    (((unsigned long long)(0xFFFFFFFF) << 32) 
+	     | (unsigned long long)(0xFFFFFFFF)) : 0;
+      if (exp != d.ull[j]) abort();
+    }
+  return 0;
+}
+
+int test_spu_cmpabseq()
+{   
+  int i, j;
+  unsigned long long exp;
+
+  /* double */
+  for (i=0; i<samples; i++) {
+    a.vd = rand_vd(-4.0, 4.0);
+    b.vd = rand_vd(-4.0, 4.0);
+    d.vull = spu_cmpabseq(a.vd, b.vd);
+    for (j=0; j<2; j++) {
+      exp = ((a.d[j] == b.d[j]) || (-a.d[j] == b.d[j]) || (a.d[j] == -b.d[j])) ?
+	    (((unsigned long long)(0xFFFFFFFF) << 32) 
+	     | (unsigned long long)(0xFFFFFFFF)) : 0;
+      if (exp != d.ull[j]) abort();
+    } 
+  }
+
+  /* compare zeros  */
+    d.vull = spu_cmpabseq(a0.vd, b0.vd);
+    for (j=0; j<2; j++) {
+      exp = ((a0.d[j] == b0.d[j]) || (-a0.d[j] == b0.d[j]) || (a0.d[j] == -b0.d[j])) ?
+	    (((unsigned long long)(0xFFFFFFFF) << 32) 
+	     | (unsigned long long)(0xFFFFFFFF)) : 0;
+      if (exp != d.ull[j]) abort();
+    }
+
+  /* compare NaNs  */
+    d.vull = spu_cmpabseq(a1.vd, b1.vd);
+    for (j=0; j<2; j++) {
+      exp = ((a1.d[j] == b1.d[j]) || (-a1.d[j] == b1.d[j]) || (a1.d[j] == -b1.d[j])) ?
+	    (((unsigned long long)(0xFFFFFFFF) << 32) 
+	     | (unsigned long long)(0xFFFFFFFF)) : 0;
+      if (exp != d.ull[j]) abort();
+    }
+  return 0;
+}
+
+int test_spu_cmpabsgt()
+{
+  int i, j;
+  unsigned long long exp;
+  double abs_a, abs_b;
+  
+  /* double */
+  for (i=0; i<samples; i++) {
+    a.vd = rand_vd(-4.0, 4.0);
+    b.vd = rand_vd(-4.0, 4.0);
+    d.vull = spu_cmpabsgt(a.vd, b.vd);
+    for (j=0; j<2; j++) {
+      double abs_a = (a.d[j] < 0.0) ? -a.d[j] : a.d[j];
+      double abs_b = (b.d[j] < 0.0) ? -b.d[j] : b.d[j];
+      exp = (abs_a > abs_b) ? 
+	    (((unsigned long long)(0xFFFFFFFF) << 32) 
+	     | (unsigned long long)(0xFFFFFFFF)) : 0;
+      if (exp != d.ull[j]) abort();
+    }
+  }
+
+  /* compare zeros  */
+    d.vull = spu_cmpabsgt(a0.vd, b0.vd);
+    for (j=0; j<2; j++) {
+      abs_a = (a0.d[j] < 0.0) ? -a0.d[j] : a0.d[j];
+      abs_b = (b0.d[j] < 0.0) ? -b0.d[j] : b0.d[j];
+      exp = (abs_a > abs_b) ? 
+	    (((unsigned long long)(0xFFFFFFFF) << 32) 
+	     | (unsigned long long)(0xFFFFFFFF)) : 0;
+      if (exp != d.ull[j]) abort();
+    }
+  /* compare NaNs  */
+    d.vull = spu_cmpabsgt(a1.vd, b1.vd);
+    for (j=0; j<2; j++) {
+      abs_a = (a1.d[j] < 0.0) ? -a1.d[j] : a1.d[j];
+      abs_b = (b1.d[j] < 0.0) ? -b1.d[j] : b1.d[j];
+      exp = (abs_a > abs_b) ? 
+	    (((unsigned long long)(0xFFFFFFFF) << 32) 
+	     | (unsigned long long)(0xFFFFFFFF)) : 0;
+      if (exp != d.ull[j]) abort();
+    }
+  return 0;
+}
+
+int test_spu_testsv()
+{
+  int i, j;
+  unsigned long long exp;
+  struct _samples {
+    unsigned long long v;
+    unsigned int sv;
+ } samples[] = {
+  {0x0000000000000000ULL, SPU_SV_POS_ZERO},
+  {0x8000000000000000ULL, SPU_SV_NEG_ZERO},
+  {0x0000000000000001ULL, SPU_SV_POS_DENORM},
+  {0x0000000080000000ULL, SPU_SV_POS_DENORM},
+  {0x0000000100000000ULL, SPU_SV_POS_DENORM},
+  {0x0008000000000000ULL, SPU_SV_POS_DENORM},
+  {0x000FFFFFFFFFFFFFULL, SPU_SV_POS_DENORM},
+  {0x00000000FFF00000ULL, SPU_SV_POS_DENORM},
+  {0x8000000000000001ULL, SPU_SV_NEG_DENORM},
+  {0x8000000080000000ULL, SPU_SV_NEG_DENORM},
+  {0x8000000100000000ULL, SPU_SV_NEG_DENORM},
+  {0x8008000000000000ULL, SPU_SV_NEG_DENORM},
+  {0x800FFFFFFFFFFFFFULL, SPU_SV_NEG_DENORM},
+  {0x80000000FFF00000ULL, SPU_SV_NEG_DENORM},
+  {0x0010000000000000ULL, 0},
+  {0x0010000000000001ULL, 0},
+  {0x3FF0000000000000ULL, 0},
+  {0x3FF00000FFF00000ULL, 0},
+  {0xBFF0000000000000ULL, 0},
+  {0xBFF00000FFF00000ULL, 0},
+  {0x7FE0000000000000ULL, 0},
+  {0x7FEFFFFFFFFFFFFFULL, 0},
+  {0x8010000000000000ULL, 0},
+  {0x8010000000000001ULL, 0},
+  {0xFFE0000000000000ULL, 0},
+  {0xFFEFFFFFFFFFFFFFULL, 0},
+  {0x7FF0000000000000ULL, SPU_SV_POS_INFINITY},
+  {0xFFF0000000000000ULL, SPU_SV_NEG_INFINITY},
+  {0x7FF0000000000001ULL, SPU_SV_NAN},
+  {0x7FF0000080000000ULL, SPU_SV_NAN},
+  {0x7FF0000100000000ULL, SPU_SV_NAN},
+  {0x7FFFFFFFFFFFFFFFULL, SPU_SV_NAN},
+  {0xFFF0000000000001ULL, SPU_SV_NAN},
+  {0xFFF0000080000000ULL, SPU_SV_NAN},
+  {0xFFF0000100000000ULL, SPU_SV_NAN},
+  {0xFFFFFFFFFFFFFFFFULL, SPU_SV_NAN}
+ };
+
+  unsigned char cnt = sizeof(samples)/sizeof(struct _samples);
+  int e0;
+    for (e0=0; e0<cnt; e0++)
+    {   
+      a.ull[0] = samples[e0].v;
+      a.d[1] = rand_double(-1, -4);
+
+      d.vull = spu_testsv(a.vd, SPU_SV_NEG_DENORM);
+      exp = (SPU_SV_NEG_DENORM & samples[e0].sv) ? 0xFFFFFFFFFFFFFFFFULL : 0ULL;
+      if (exp != d.ull[0] || d.ull[1] != 0) abort();
+    
+      d.vull = spu_testsv(a.vd, SPU_SV_POS_DENORM);
+      exp = (SPU_SV_POS_DENORM & samples[e0].sv) ? 0xFFFFFFFFFFFFFFFFULL : 0ULL;
+      if (exp != d.ull[0] || d.ull[1] != 0) abort();
+    
+      d.vull = spu_testsv(a.vd, SPU_SV_NEG_ZERO);
+      exp = (SPU_SV_NEG_ZERO & samples[e0].sv) ? 0xFFFFFFFFFFFFFFFFULL : 0ULL;
+      if (exp != d.ull[0] || d.ull[1] != 0) abort();
+    
+      d.vull = spu_testsv(a.vd, SPU_SV_POS_ZERO);
+      exp = (SPU_SV_POS_ZERO & samples[e0].sv) ? 0xFFFFFFFFFFFFFFFFULL : 0ULL;
+      if (exp != d.ull[0] || d.ull[1] != 0) abort();
+    
+      d.vull = spu_testsv(a.vd, SPU_SV_NEG_INFINITY);
+      exp = (SPU_SV_NEG_INFINITY & samples[e0].sv) ? 0xFFFFFFFFFFFFFFFFULL : 0ULL;
+      if (exp != d.ull[0] || d.ull[1] != 0) abort();
+    
+      d.vull = spu_testsv(a.vd, SPU_SV_POS_INFINITY);
+      exp = (SPU_SV_POS_INFINITY & samples[e0].sv) ? 0xFFFFFFFFFFFFFFFFULL : 0ULL;
+      if (exp != d.ull[0] || d.ull[1] != 0) abort();
+    
+      d.vull = spu_testsv(a.vd, SPU_SV_NAN);
+      exp = (SPU_SV_NAN & samples[e0].sv) ? 0xFFFFFFFFFFFFFFFFULL : 0ULL;
+      if (exp != d.ull[0] || d.ull[1] != 0) abort();
+   }  
+  return 0;
+}
+
+int main()
+{
+  /* +0.0 and -0.0  */
+  a0.d[0] = 0.0; a0.d[1] = -0.0; b0.d[0] = -0.0; b0.d[1] = 0.0;
+  /* NaN  */
+  a1.d[0] = 0.0/0.0; a1.d[1] = 0.0/-0.0; b1.d[0] = -0.0/0.0;  b1.d[1] = -0.0/-0.0;
+
+  test_spu_cmpeq();
+  test_spu_cmpabseq();
+  test_spu_cmpgt();
+  test_spu_cmpabsgt();
+  test_spu_testsv();
+  return 0;
+}
+
+