darwin64-abi.c

来自「Mac OS X 10.4.9 for x86 Source Code gcc」· C语言 代码 · 共 629 行 · 第 1/2 页

/* APPLE LOCAL file 64-bit ABI testing */
/* { dg-do run { target "powerpc*-*-darwin*" } } */
/* { dg-options "-m64 -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
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;
    }
}

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;
    }
}

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;
    }
}

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;
    }
}

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;
    }
}

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

main()
{
  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);