Patchwork [Darwin/PPC,test-suite] merge darwin64 abi test.

login
register
mail settings
Submitter IainS
Date Nov. 3, 2010, 5:09 p.m.
Message ID <B6B38592-C775-465A-A1C5-636FF6EA4045@sandoe-acoustics.co.uk>
Download mbox | patch
Permalink /patch/70040/
State New
Headers show

Comments

IainS - Nov. 3, 2010, 5:09 p.m.
Hi,
This merges the darwin64 ppc test from the FSF apple/trunk branch.
(since we now have working 64 bit ppc ABI, we might as well test it).
It also switches off the existing ppc64-abi-1 test which is emitting  
asm that darwin's version of as doesn't grok.

OK for trunk?
Iain

gcc/testsuite:

	* gcc.target/powerpc/ppc64-abi-1.c: Skip for Darwin.

	merge from FSF 'apple/trunk' branch.
	* gcc.target/powerpc/darwin64-abi.c: New.
Mike Stump - Nov. 4, 2010, 5:26 p.m.
On Nov 3, 2010, at 10:09 AM, IainS wrote:
> This merges the darwin64 ppc test from the FSF apple/trunk branch.

> OK for trunk?

Ok.

Patch

Index: gcc/testsuite/gcc.target/powerpc/darwin64-abi.c
===================================================================
--- gcc/testsuite/gcc.target/powerpc/darwin64-abi.c	(revision 0)
+++ gcc/testsuite/gcc.target/powerpc/darwin64-abi.c	(revision 0)
@@ -0,0 +1,634 @@ 
+/* Darwin 64-bit ABI testing */
+/* { dg-do run { target { powerpc*-*-darwin* && lp64 } } } */
+/* { dg-options "-std=c99 -maltivec" } */
+
+/* Set this if 8-byte structs are being passed as integers.  */
+/* #define STRUCT8INT */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <complex.h>
+#include <altivec.h>
+
+extern void abort (void);
+
+struct s3c { char ch[3]; };
+struct ssc { short sh; char ch; };
+struct sif { int i; float f; };
+struct sfi { float f; int i; };
+struct sfii { float f; int i; int j; };
+struct sfil { float f; int i; long l; };
+struct sfif { float f; int i; float g; };
+struct sfill { float f; int i; long l, m; };
+struct sfl { float f; long l; };
+struct sfldl { float f; long l1; double d; long l2; };
+struct sfpp { float f; char *p1; char *p2; };
+
+
+struct sff { float f1, f2; };
+struct sfff { float f1, f2, f3; };
+struct sffff { float f1, f2, f3, f4; };
+
+struct sfD { float f; long double D; };
+
+struct sidi { int i1; double d; int i2; };
+
+struct sdd { double d1, d2; };
+struct sddd { double d1, d2, d3; };
+struct sdddd { double d1, d2, d3, d4; };
+struct s3d { double d[3]; };
+
+struct vr { union { int ielts[4]; float felts[4]; } elts; };
+
+typedef struct
+{
+  unsigned long gprs[32];
+  double fprs[32];
+  struct vr vrs[32];
+  unsigned char stack[1000];
+} reg_parms_t;
+
+reg_parms_t gparms;
+
+#define TESTFN(RET,NAME,PARAMS) \
+RET NAME PARAMS;  \
+RET dummy_ ## NAME PARAMS  \
+{  \
+  __asm__("b end_" #NAME "\n_" # NAME ":\n\t" SAVE_STATE "b _dummy_" # NAME "\n\tend_" #NAME ":\n\n" ); \
+}
+
+#define SAVE_STATE \
+SAVE_GPR(0)  \
+SAVE_GPR(1)  \
+SAVE_GPR(3)  \
+SAVE_GPR(4)  \
+SAVE_GPR(5)  \
+SAVE_GPR(6)  \
+SAVE_GPR(7)  \
+SAVE_GPR(8)  \
+SAVE_GPR(9)  \
+SAVE_GPR(10)  \
+SAVE_FPR(0)  \
+SAVE_FPR(1)  \
+SAVE_FPR(2)  \
+SAVE_FPR(3)  \
+SAVE_FPR(4)  \
+SAVE_FPR(5)  \
+SAVE_FPR(6)  \
+SAVE_FPR(7)  \
+SAVE_FPR(8)  \
+SAVE_FPR(9)  \
+SAVE_FPR(10)  \
+SAVE_FPR(12)  \
+SAVE_FPR(13)  \
+SAVE_VR(0)  \
+SAVE_VR(1)  \
+SAVE_VR(2)  \
+SAVE_VR(3)  \
+SAVE_VR(4)  \
+SAVE_STACK(112)  \
+SAVE_STACK(120)  \
+SAVE_STACK(128)  \
+SAVE_STACK(136)  \
+SAVE_STACK(144)  \
+
+
+#ifdef __LP64__
+#define SAVE_GPR(N) "std r" #N "," #N "*8(r25)\n\t"
+#define SAVE_FPR(N) "stfd f" #N "," #N "*8+256(r25)\n\t"
+#define SAVE_VR(N) "li r26," #N "*16+512\n\tstvx v" #N ",r25,r26\n\t"
+#define SAVE_STACK(N) "ld r26," #N "(r1)\n\tstd r26," #N "+1024(r25)\n\t"
+#else
+#define SAVE_GPR(N) "stw r" #N "," #N "*4(r25)\n\t"
+#define SAVE_FPR(N) "stfd f" #N "," #N "*8+128(r25)\n\t"
+#define SAVE_VR(N)
+#define SAVE_STACK(N)
+#endif
+
+TESTFN(void, fffi, (float x, float y, int z))
+
+#define clearall \
+__asm__ volatile ( \
+"\n\t" \
+"li r3,0x333\n\t" \
+"li r4,0x444 \n\t" \
+"li r5,0x555\n\t" \
+"li r6,0x666\n\t" \
+"li r7,0x777\n\t" \
+"li r8,0x888\n\t" \
+"li r9,0x999\n\t" \
+"li r10,0xaaa\n\t" \
+"fsub f0,f0,f0\n\t" \
+"fsub f1,f1,f1\n\t" \
+"fsub f2,f2,f2\n\t" \
+"fsub f3,f3,f3\n\t" \
+"fsub f4,f4,f4\n\t" \
+"fsub f5,f5,f5\n\t" \
+"fsub f6,f6,f6\n\t" \
+"fsub f7,f7,f7\n\t" \
+"vsubuwm v0,v0,v0\n\t" \
+"vsubuwm v1,v1,v1\n\t" \
+"vsubuwm v2,v2,v2\n\t" \
+"vsubuwm v3,v3,v3\n\t" \
+"vsubuwm v4,v4,v4\n\t" \
+: : : "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", \
+      "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
+      "v0", "v1", "v2", "v3", "v4" );
+
+TESTFN(void, fii, (int a, int b))
+TESTFN(void, fid, (int i, double d))
+TESTFN(void, fc, (complex float z))
+TESTFN(void, fffff, (float f1, float f2, float f3, float f4))
+TESTFN(void, fdddd, (double d1, double d2, double d3, double d4))
+TESTFN(void, f_s3c_ssc, (struct s3c s1, struct ssc s2))
+TESTFN(void, f_sff, (struct sff s))
+TESTFN(void, f_sfff, (struct sfff s))
+TESTFN(void, f_sffff, (struct sffff s))
+TESTFN(void, f_sdd, (struct sdd s))
+TESTFN(void, f_sddd, (struct sddd s))
+TESTFN(void, f_sdddd, (struct sdddd s))
+TESTFN(void, f_s3d, (struct s3d s))
+TESTFN(void, f_sif, (int i, struct sif s))
+TESTFN(void, fi_sif, (int i, struct sif s))
+TESTFN(void, fi_sif_i, (int i, struct sif s, int j))
+TESTFN(void, f_sfi, (int i, struct sfi s))
+TESTFN(void, fi_sfi, (int i, struct sfi s))
+TESTFN(void, fi_sfi_if, (int i, struct sfi s, int j, float f))
+TESTFN(void, fi_sfill, (int i, struct sfill s))
+TESTFN(void, fi_sfill_i, (int i, struct sfill s, int j))
+TESTFN(void, f_sfl, (struct sfl s))
+TESTFN(void, f_sfl_sfl_sfl_sfl_sfl, (struct sfl s1, struct sfl s2, struct sfl s3, struct sfl s4, struct sfl s5))
+TESTFN(void, fi_sff, (int i, struct sff s))
+TESTFN(void, f_sfpp_p, (struct sfpp s, char *p))
+TESTFN(void, f_sfldl, (struct sfldl s))
+TESTFN(void, fi_sff_i, (int i, struct sff s, int j))
+TESTFN(void, f_sfD_sfD_sfD_sfD_sfD, (struct sfD s1, struct sfD s2, struct sfD s3, struct sfD s4, struct sfD s5))
+TESTFN(void, fi_sidi, (int i, struct sidi s))
+TESTFN(void, fifvf_sfi_dots, (int i, float f, vector float vf, struct sfi s, ...))
+TESTFN(void, fifvf_sfii_dots, (int i, float f, vector float vf, struct sfii s, ...))
+
+int numerrs;
+
+#ifndef SKIP
+static __attribute__ ((noinline)) void
+check_gpr (int line, int reg, long expected)
+{
+  if (gparms.gprs[reg] != expected)
+    {
+      printf("%d: r%d is 0x%lx, expected 0x%lx\n",
+	     line, reg, gparms.gprs[reg], expected);
+      ++numerrs;
+    }
+}
+
+static __attribute__ ((noinline)) void
+check_gpr_double (int line, int reg, double expected)
+{
+  double tmp = *((double *) &(gparms.gprs[reg]));
+  if (tmp != expected)
+    {
+      printf("%d: r%d is %f (0x%llx), expected %f (0x%llx)\n",
+	     line, reg,
+	     tmp, *((long long *) &tmp),
+	     expected, *((long long *) &expected));
+      ++numerrs;
+    }
+}
+
+static __attribute__ ((noinline)) void
+check_gpr_float_pair (int line, int reg, float exp1, float exp2)
+{
+  float tmp1 = *((float *) &(gparms.gprs[reg]));
+  float tmp2 = *(((float *) &(gparms.gprs[reg])) + 1);
+
+  if (tmp1 != exp1 || tmp2 != exp2)
+    {
+      printf("%d: r%d is %f / %f (0x%llx), expected %f (0x%x) / %f (0x%x)\n",
+	     line, reg,
+	     tmp1, tmp2, *((long long *) &(gparms.gprs[reg])),
+	     exp1, *((int *) &exp1),
+	     exp2, *((int *) &exp2));
+      ++numerrs;
+    }
+}
+
+static __attribute__ ((noinline)) void
+check_fpr (int line, int reg, double expected)
+{
+  if (gparms.fprs[reg] != expected)
+    {
+      printf("%d: f%d is %f (0x%llx), expected %f (0x%llx)\n",
+	     line, reg,
+	     gparms.fprs[reg], *((long long *) &(gparms.fprs[reg])),
+	     expected, *((long long *) &expected));
+      ++numerrs;
+    }
+}
+
+static __attribute__ ((noinline)) void
+check_vr_int (int reg, int n1, int n2, int n3, int n4)
+{
+  if (gparms.vrs[reg].elts.ielts[0] != n1
+      || gparms.vrs[reg].elts.ielts[1] != n2
+      || gparms.vrs[reg].elts.ielts[2] != n3
+      || gparms.vrs[reg].elts.ielts[3] != n4)
+    {
+      printf("v%d is   (%d,%d,%d,%d) (0x%x,0x%x,0x%x,0x%x),\n"
+	     " expected (%d,%d,%d,%d) (0x%x,0x%x,0x%x,0x%x)\n",
+	     reg,
+	     gparms.vrs[reg].elts.ielts[0],
+	     gparms.vrs[reg].elts.ielts[1],
+	     gparms.vrs[reg].elts.ielts[2],
+	     gparms.vrs[reg].elts.ielts[3],
+	     gparms.vrs[reg].elts.ielts[0],
+	     gparms.vrs[reg].elts.ielts[1],
+	     gparms.vrs[reg].elts.ielts[2],
+	     gparms.vrs[reg].elts.ielts[3],
+	     n1, n2, n3, n4,
+	     n1, n2, n3, n4
+	     );
+      ++numerrs;
+    }
+}
+
+static __attribute__ ((noinline)) void
+check_vr_float (int reg, float f1, float f2, float f3, float f4)
+{
+  if (gparms.vrs[reg].elts.felts[0] != f1
+      || gparms.vrs[reg].elts.felts[1] != f2
+      || gparms.vrs[reg].elts.felts[2] != f3
+      || gparms.vrs[reg].elts.felts[3] != f4)
+    {
+      printf("v%d is    (%f,%f,%f,%f) (0x%x,0x%x,0x%x,0x%x),\n"
+	     " expected (%f,%f,%f,%f) (0x%x,0x%x,0x%x,0x%x)\n",
+	     reg,
+	     gparms.vrs[reg].elts.felts[0],
+	     gparms.vrs[reg].elts.felts[1],
+	     gparms.vrs[reg].elts.felts[2],
+	     gparms.vrs[reg].elts.felts[3],
+	     gparms.vrs[reg].elts.ielts[0],
+	     gparms.vrs[reg].elts.ielts[1],
+	     gparms.vrs[reg].elts.ielts[2],
+	     gparms.vrs[reg].elts.ielts[3],
+	     f1, f2, f3, f4,
+	     *((int *) &f1), *((int *) &f2), *((int *) &f3), *((int *) &f4)
+	     );
+      ++numerrs;
+    }
+}
+#endif
+
+int main (void)
+{
+  complex float cpx = 4.45f + I * 4.92f;
+  struct s3c s3c_loc;
+  struct ssc ssc_loc;
+  struct sfi sfi_loc;
+  struct sfi sfi_loc2 = { 6.3f, 0x1108 };
+  struct sfii sfii_loc;
+  struct sfii sfii_loc2 = { 6.9f, 0x1110, 0x6372 };
+  vector float vf_loc = (vector float) { 7.1f, 7.2f, 7.3f, 7.4f };
+  vector int vi_loc = (vector int) { 0xabc, 0xdef, 0xfed, 0xcba };
+
+  __asm__ ("mr r25,%0" : : "b" (&gparms) );
+
+  clearall;
+  fii(1, 2);
+  check_gpr (__LINE__, 3, 1);
+  check_gpr (__LINE__, 4, 2);
+
+  clearall;
+  fid(45, 4.5);
+  check_gpr (__LINE__, 3, 45);
+  check_fpr (__LINE__, 1, 4.5);
+
+  clearall;
+  fffi(1.2f, 3.4f, 456);
+  check_fpr(__LINE__, 1, 1.2f);
+
+  clearall;
+  fc(cpx);
+  /* Two floats are packed into r3 */
+  check_gpr_float_pair (__LINE__, 3, 4.45f, 4.92f);
+
+  clearall;
+  fffff (4.1f, 4.2f, 4.3f, 4.4f);
+  check_fpr (__LINE__, 1, 4.1f);
+  check_fpr (__LINE__, 4, 4.4f);
+
+  clearall;
+  fdddd (4.1, 4.2, 4.3, 4.4);
+  check_fpr (__LINE__, 1, 4.1);
+  check_fpr (__LINE__, 4, 4.4);
+
+  {
+    struct sff sff_loc = { 2.1f, 2.2f };
+    clearall;
+    f_sff(sff_loc);
+#ifdef STRUCT8INT
+    check_gpr_float_pair (__LINE__, 3, 2.1f, 2.2f);
+#else
+    check_fpr(__LINE__, 1, 2.1f);
+    check_fpr(__LINE__, 2, 2.2f);
+#endif
+    clearall;
+    fi_sff_i(65, sff_loc, 66);
+    check_gpr(__LINE__, 3, 65);
+#ifdef STRUCT8INT
+    check_gpr_float_pair (__LINE__, 4, 2.1f, 2.2f);
+#else
+    check_fpr(__LINE__, 1, 2.1f);
+    check_fpr(__LINE__, 2, 2.2f);
+#endif
+    check_gpr(__LINE__, 5, 66);
+  }
+
+  {
+    struct sfff sfff_loc = { 3.1f, 3.2f, 3.3f };
+    clearall;
+    f_sfff(sfff_loc);
+    check_fpr(__LINE__, 1, 3.1f);
+    check_fpr(__LINE__, 2, 3.2f);
+    check_fpr(__LINE__, 3, 3.3f);
+    clearall;
+    f_sfff(sfff_loc);
+    check_fpr(__LINE__, 1, 3.1f);
+    check_fpr(__LINE__, 2, 3.2f);
+    check_fpr(__LINE__, 3, 3.3f);
+  }
+
+  {
+    struct sffff sffff_loc = { 4.1f, 4.2f, 4.3f, 4.4f };
+    clearall;
+    f_sffff(sffff_loc);
+    check_gpr_float_pair(__LINE__, 3, 4.1f, 4.2f);
+    check_gpr_float_pair(__LINE__, 4, 4.3f, 4.4f);
+  }
+
+  {
+    struct sdd sdd_loc = { 2.1, 2.2 };
+    clearall;
+    f_sdd(sdd_loc);
+    /* 16-byte struct is passed in two GPRs.  */
+    check_gpr_double(__LINE__, 3, 2.1);
+    check_gpr_double(__LINE__, 4, 2.2);
+  }
+
+  {
+    struct sddd sddd_loc = { 3.1, 3.2, 3.3 };
+    clearall;
+    f_sddd(sddd_loc);
+    check_fpr(__LINE__, 1, 3.1);
+    check_fpr(__LINE__, 2, 3.2);
+    check_fpr(__LINE__, 3, 3.3);
+  }
+
+  {
+    struct sdddd sdddd_loc = { 4.1, 4.2, 4.3, 4.4 };
+    clearall;
+    f_sdddd(sdddd_loc);
+    check_fpr(__LINE__, 1, 4.1);
+    check_fpr(__LINE__, 2, 4.2);
+    check_fpr(__LINE__, 3, 4.3);
+    check_fpr(__LINE__, 4, 4.4);
+  }
+
+  {
+    struct s3d s3d_loc = { 89.92, 4.89, 90.9 };
+    clearall;
+    f_s3d(s3d_loc);
+    check_gpr_double (__LINE__, 3, 89.92);
+    check_gpr_double (__LINE__, 4, 4.89);
+    check_gpr_double (__LINE__, 5, 90.9);
+  }
+
+  {
+    s3c_loc.ch[0] = 'A';
+    s3c_loc.ch[1] = 'B';
+    s3c_loc.ch[2] = 'C';
+    ssc_loc.sh = 0x1234;
+    ssc_loc.ch = 'D';
+    clearall;
+    f_s3c_ssc(s3c_loc, ssc_loc);
+  }
+
+  {
+    struct sif sif_loc_n = { 334, 4.3f };
+    long floatcast;
+    floatcast = *((int *) &(sif_loc_n.f));
+    clearall;
+    fi_sif(29, sif_loc_n);
+    check_gpr (__LINE__, 3, 29);
+    check_gpr (__LINE__, 4, 334LL << 32 | floatcast);
+#ifdef STRUCT8INT
+#else
+    check_fpr (__LINE__, 1, 4.3f);
+#endif
+    clearall;
+    fi_sif_i(31, sif_loc_n, 33);
+    check_gpr (__LINE__, 3, 31);
+    check_gpr (__LINE__, 4, 334LL << 32 | floatcast);
+#ifdef STRUCT8INT
+#else
+    check_fpr (__LINE__, 1, 4.3f);
+#endif
+    check_gpr (__LINE__, 5, 33);
+  }
+
+  {
+    struct sfi sfi_loc_n = { 4.145f, 335 };
+    clearall;
+    fi_sfi(29, sfi_loc_n);
+    check_gpr (__LINE__, 3, 29);
+#ifdef STRUCT8INT
+    check_gpr (__LINE__, 4, 0x4084a3d70000014fLL);
+#else
+    check_fpr (__LINE__, 1, 4.145f);
+    check_gpr (__LINE__, 4, 335);
+#endif
+  }
+
+  {
+    struct sfi sfi_loc_n = { 4.145f, 335 };
+    clearall;
+    fi_sfi_if (29, sfi_loc_n, 65, 9.8f);
+    check_gpr (__LINE__, 3, 29);
+#ifdef STRUCT8INT
+    check_gpr (__LINE__, 4, 0x4084a3d70000014fLL);
+#else
+    check_fpr (__LINE__, 1, 4.145f);
+    check_gpr (__LINE__, 4, 335);
+#endif
+    check_gpr (__LINE__, 5, 65);
+    check_gpr (__LINE__, 6, 0x666);
+#ifdef STRUCT8INT
+    check_fpr (__LINE__, 1, 9.8f);
+#else
+    check_fpr (__LINE__, 2, 9.8f);
+#endif
+    check_gpr (__LINE__, 7, 0x777);
+  }
+
+  {
+    struct sfill sfill_loc_n = { 4.145f, 335, 10000000000LL, 20000000000LL };
+    clearall;
+    fi_sfill(29, sfill_loc_n);
+    check_gpr (__LINE__, 3, 29);
+    check_fpr (__LINE__, 1, 4.145f);
+    check_gpr (__LINE__, 4, 335);
+    check_gpr (__LINE__, 5, 10000000000LL);
+    check_gpr (__LINE__, 6, 20000000000LL);
+  }
+
+  {
+    struct sfl sfl_loc_n = { 4.145f, 335 };
+    clearall;
+    f_sfl (sfl_loc_n);
+    check_gpr_float_pair (__LINE__, 3, 4.145f, 0.0f);
+    check_gpr (__LINE__, 4, 335);
+    check_gpr (__LINE__, 5, 0x555);
+    clearall;
+    f_sfl_sfl_sfl_sfl_sfl (sfl_loc_n, sfl_loc_n, sfl_loc_n, sfl_loc_n, sfl_loc_n);
+    check_gpr_float_pair (__LINE__, 3, 4.145f, 0.0f);
+    check_gpr (__LINE__, 4, 335);
+    check_gpr (__LINE__, 6, 335);
+    check_gpr (__LINE__, 8, 335);
+    check_gpr (__LINE__, 10, 335);
+  }
+
+  {
+    struct sfldl sfldl_loc_n = { 4.145f, 335, 3.3, 336 };
+    clearall;
+    f_sfldl (sfldl_loc_n);
+    check_fpr (__LINE__, 1, 4.145f);
+    check_gpr (__LINE__, 4, 335);
+    check_fpr (__LINE__, 2, 3.3);
+    check_gpr (__LINE__, 6, 336);
+  }
+
+  {
+    char *p1 = "abc";
+    char *p2 = "def";
+    char *p3 = "ghi";
+    struct sfpp sfpp_loc_n = { 4.145f, p1, p2 };
+    clearall;
+    f_sfpp_p(sfpp_loc_n, p3);
+    check_fpr (__LINE__, 1, 4.145f);
+    check_gpr (__LINE__, 4, (long) p1);
+    check_gpr (__LINE__, 5, (long) p2);
+    check_gpr (__LINE__, 6, (long) p3);
+  }
+
+  {
+    struct sff sff_loc_n = { 4.145f, 335.3f };
+    clearall;
+    fi_sff(29, sff_loc_n);
+    check_gpr (__LINE__, 3, 29);
+#ifdef STRUCT8INT
+    check_gpr_float_pair (__LINE__, 4, 4.145f, 335.3f);
+#else
+    check_fpr (__LINE__, 1, 4.145f);
+    check_fpr (__LINE__, 2, 335.3f);
+#endif
+  }
+
+  {
+    struct sfD sfD_loc_n = { 4.145f, 335.335 };
+    clearall;
+    f_sfD_sfD_sfD_sfD_sfD (sfD_loc_n, sfD_loc_n, sfD_loc_n, sfD_loc_n, sfD_loc_n);
+    check_fpr (__LINE__, 1, 4.145f);
+    check_fpr (__LINE__, 2, 335.335);
+    check_fpr (__LINE__, 4, 4.145f);
+    check_fpr (__LINE__, 5, 335.335);
+    check_fpr (__LINE__, 7, 4.145f);
+    check_fpr (__LINE__, 10, 4.145f);
+    check_fpr (__LINE__, 13, 4.145f);
+  }
+
+  {
+    struct sidi sidi_loc_n = { 257, 4.14515, 258 };
+    clearall;
+    fi_sidi(16, sidi_loc_n);
+    check_gpr (__LINE__, 3, 16);
+    check_fpr (__LINE__, 1, 4.14515);
+    check_gpr (__LINE__, 4, 257LL << 32);
+    check_gpr (__LINE__, 5, 0x555);
+    check_gpr (__LINE__, 6, 258LL << 32);
+  }
+
+  sfi_loc.f = 5.2f;
+  sfi_loc.i = 98;
+  clearall;
+  fifvf_sfi_dots(41, 4.3f, vf_loc, sfi_loc, 4.63f, vi_loc, sfi_loc2);
+  __asm__ ("\n");
+  check_gpr (__LINE__, 3, 41);
+  check_fpr (__LINE__, 1, 4.3f); /* float skips r4 */
+  check_vr_float(2, 7.1f, 7.2f, 7.3f, 7.4f); /* vector skips r5/r6 */
+#ifdef STRUCT8INT
+  check_gpr (__LINE__, 7, 0x40a6666600000062);
+#else
+  check_fpr (__LINE__, 2, sfi_loc.f);
+  check_gpr (__LINE__, 7, sfi_loc.i);
+#endif
+  /* start of varying parameters */
+#ifdef STRUCT8INT
+  check_fpr (__LINE__, 2, 4.63f);
+#else
+  check_fpr (__LINE__, 3, 4.63f);
+#endif
+  check_gpr_double (__LINE__, 8, 4.63f);
+  /* vector takes up r9/r10 */
+  /* sfi_loc2 on stack */
+
+  clearall;
+  sfii_loc.f = 5.2f;
+  sfii_loc.i = 98;
+  sfii_loc.j = 777;
+  clearall;
+  fifvf_sfii_dots(41, 4.3f, vf_loc, sfii_loc, 4.63f, vi_loc, sfii_loc2);
+  __asm__ ("\n");
+  check_gpr (__LINE__, 3, 41);
+  check_fpr (__LINE__, 1, 4.3f); /* float skips r4 */
+  check_vr_float(2, 7.1f, 7.2f, 7.3f, 7.4f); /* vector skips r5/r6 */
+  check_fpr (__LINE__, 2, sfii_loc.f);
+  check_gpr (__LINE__, 7, sfii_loc.i);
+  check_gpr (__LINE__, 8, ((long)sfii_loc.j) << 32);
+  /* start of varying parameters */
+  check_fpr (__LINE__, 3, 4.63f);
+  check_gpr_double (__LINE__, 9, 4.63f);
+  /* vector takes up r10/stack (?) */
+  /* sfii_loc2 on stack */
+
+  if (numerrs > 0)
+    abort ();
+  return 0;
+}
+
+int dumpall()
+{
+  int i;
+
+  printf("\n");
+  for (i = 3; i <= 10; ++i)
+#ifdef __LP64__
+    printf("r%d=0x%16.16lx ", i, gparms.gprs[i]);
+#else
+    printf("r%d=0x%8.8x ", i, gparms.gprs[i]);
+#endif
+  printf("\n");
+  for (i = 1; i <= 13; ++i)
+    printf("f%d=%8.8f ", i, gparms.fprs[i]);
+  printf("\n");
+  for (i = 0; i <= 4; ++i)
+    printf("v%d=(%x,%x,%x,%x)  ", i,
+	   gparms.vrs[i].elts.ielts[0], gparms.vrs[i].elts.ielts[1],
+	   gparms.vrs[i].elts.ielts[2], gparms.vrs[i].elts.ielts[3]);
+  printf("\n");
+  for (i = 112; i < 152; ++i)
+    {
+      if (i > 112 && i % 8 == 0)
+	printf(" | ");
+      printf("%02x", gparms.stack[i]);
+    }
+  printf("\n");
+}
Index: gcc/testsuite/gcc.target/powerpc/ppc64-abi-1.c
===================================================================
--- gcc/testsuite/gcc.target/powerpc/ppc64-abi-1.c	(revision 166258)
+++ gcc/testsuite/gcc.target/powerpc/ppc64-abi-1.c	(working copy)
@@ -1,4 +1,5 @@ 
 /* { dg-do run { target { powerpc*-*-* && lp64 } } } */
+/* { dg-skip-if "" { *-*-darwin* } { "*" } { "" } } */
 /* { dg-options "-O2" } */
 #include <stdarg.h>
 #include <signal.h>