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, 82 insertions, 0 deletions

diff --git a/gcc/testsuite/go.test/test/cmplxdivide.c b/gcc/testsuite/go.test/test/cmplxdivide.c
new file mode 100644
index 000000000..b3c6055ed
--- /dev/null
+++ b/gcc/testsuite/go.test/test/cmplxdivide.c
@@ -0,0 +1,82 @@
+// Copyright 2010 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// gcc '-std=c99' cmplxdivide.c && a.out >cmplxdivide1.go
+
+#include <complex.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+#define nelem(x) (sizeof(x)/sizeof((x)[0]))
+
+double f[] = {
+	0,
+	1,
+	-1,
+	2,
+	NAN,
+	INFINITY,
+	-INFINITY,
+};
+
+char*
+fmt(double g)
+{
+	static char buf[10][30];
+	static int n;
+	char *p;
+	
+	p = buf[n++];
+	if(n == 10)
+		n = 0;
+	sprintf(p, "%g", g);
+	if(strcmp(p, "-0") == 0)
+		strcpy(p, "negzero");
+	return p;
+}
+
+int
+iscnan(double complex d)
+{
+	return !isinf(creal(d)) && !isinf(cimag(d)) && (isnan(creal(d)) || isnan(cimag(d)));
+}
+
+double complex zero;	// attempt to hide zero division from gcc
+
+int
+main(void)
+{
+	int i, j, k, l;
+	double complex n, d, q;
+	
+	printf("// # generated by cmplxdivide.c\n");
+	printf("\n");
+	printf("package main\n");
+	printf("var tests = []Test{\n");
+	for(i=0; i<nelem(f); i++)
+	for(j=0; j<nelem(f); j++)
+	for(k=0; k<nelem(f); k++)
+	for(l=0; l<nelem(f); l++) {
+		n = f[i] + f[j]*I;
+		d = f[k] + f[l]*I;
+		q = n/d;
+		
+		// BUG FIX.
+		// Gcc gets the wrong answer for NaN/0 unless both sides are NaN.
+		// That is, it treats (NaN+NaN*I)/0 = NaN+NaN*I (a complex NaN)
+		// but it then computes (1+NaN*I)/0 = Inf+NaN*I (a complex infinity).
+		// Since both numerators are complex NaNs, it seems that the
+		// results should agree in kind.  Override the gcc computation in this case.
+		if(iscnan(n) && d == 0)
+			q = (NAN+NAN*I) / zero;
+
+		printf("\tTest{cmplx(%s, %s), cmplx(%s, %s), cmplx(%s, %s)},\n",
+			fmt(creal(n)), fmt(cimag(n)),
+			fmt(creal(d)), fmt(cimag(d)),
+			fmt(creal(q)), fmt(cimag(q)));
+	}
+	printf("}\n");
+	return 0;
+}