gcc/testsuite/gcc.target/powerpc/float128-2.c

/* { dg-do run { target { powerpc*-*-linux* } } } */
/* { dg-require-effective-target ppc_float128_sw } */
/* { dg-require-effective-target vsx_hw } */
/* { dg-options "-mvsx -O2" } */

/*
 * Test program to make sure we are getting more precision than the 53 bits we
 * get with IEEE double.
 */

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <stddef.h>

#ifndef TYPE
#define TYPE __float128
#endif

#ifndef NO_INLINE
#define NO_INLINE __attribute__((__noinline__))
#endif

static TYPE power_of_two (ssize_t) NO_INLINE;
static TYPE calc1 (TYPE) NO_INLINE;
static TYPE calc2 (TYPE) NO_INLINE;
static TYPE calc3 (TYPE) NO_INLINE;

#ifndef POWER2
#define POWER2 60
#endif


/*
 * Print TYPE in hex.
 */


#if defined(DEBUG) || defined(DEBUG2)
static void print_hex (const char *prefix, TYPE, const char *suffix) NO_INLINE;

#if defined (__i386__) || defined (__x86_64__) || defined (__LITTLE_ENDIAN__)
#define ENDIAN_REVERSE(N, MAX)        ((MAX) - 1 - (N))

#else
#define ENDIAN_REVERSE(N, MAX)        (N)
#endif

static void
print_hex (const char *prefix, TYPE value, const char *suffix)
{
  union {
    TYPE f128;
    unsigned char uc[sizeof (TYPE)];
  } u;

  size_t i;

  u.f128 = value;
  printf ("%s0x", prefix);
  for (i = 0; i < sizeof (TYPE); i++)
    printf ("%.2x", u.uc[ ENDIAN_REVERSE (i, sizeof (TYPE)) ]);

  printf (", %24.2Lf%s", (long double)value, suffix);
}
#endif


/*
 * Return a power of two.
 */

static TYPE
power_of_two (ssize_t num)
{
  TYPE ret = (TYPE) 1.0;
  ssize_t i;

  if (num >= 0)
    {
      for (i = 0; i < num; i++)
	ret *= (TYPE) 2.0;
    }
  else
    {
      ssize_t num2 = -num;
      for (i = 0; i < num2; i++)
	ret /= (TYPE) 2.0;
    }

#ifdef DEBUG
  printf ("power_of_two (%2ld)   = ", (long) num);
  print_hex ("", ret, "\n");
#endif

  return ret;
}


#ifdef ADDSUB
static TYPE add (TYPE a, TYPE b) NO_INLINE;
static TYPE sub (TYPE a, TYPE b) NO_INLINE;

static TYPE
add (TYPE a, TYPE b)
{
  TYPE c;
#ifdef DEBUG
  print_hex ("add, arg1           = ", a, "\n");
  print_hex ("add, arg2           = ", b, "\n");
#endif
  c = a + b;
#ifdef DEBUG
  print_hex ("add, result         = ", c, "\n");
#endif
  return c;
}

static TYPE
sub (TYPE a, TYPE b)
{
  TYPE c;
#ifdef DEBUG
  print_hex ("sub, arg1           = ", a, "\n");
  print_hex ("sub, arg2           = ", b, "\n");
#endif
  c = a - b;
#ifdef DEBUG
  print_hex ("sub, result         = ", c, "\n");
#endif
  return c;
}

#else
#define add(x, y) ((x) + (y))
#define sub(x, y) ((x) - (y))
#endif

/*
 * Various calculations.  Add in 2**POWER2, and subtract 2**(POWER2-1) twice, and we should
 * get the original value.
 */

static TYPE
calc1 (TYPE num)
{
  TYPE num2 = add (power_of_two (POWER2), num);
  TYPE ret;

#ifdef DEBUG
  print_hex ("calc1 (before call) = ", num2, "\n");
#endif

  ret = calc2 (num2);

#ifdef DEBUG
  print_hex ("calc1 (after call)  = ", ret, "\n");
#endif

  return ret;
}

static TYPE
calc2 (TYPE num)
{
  TYPE num2 = sub (num, power_of_two (POWER2-1));
  TYPE ret;

#ifdef DEBUG
  print_hex ("calc2 (before call) = ", num2, "\n");
#endif

  ret = calc3 (num2);

#ifdef DEBUG
  print_hex ("calc2 (after call)  = ", ret, "\n");
#endif

  return ret;
}

static TYPE
calc3 (TYPE num)
{
  TYPE ret = sub (num, (((TYPE) 2.0) * power_of_two (POWER2-2)));

#ifdef DEBUG
  print_hex ("calc3               = ", ret, "\n");
#endif

  return ret;
}


int
main (void)
{
  TYPE input, output;

#ifdef DEBUG
  printf ("Testing, %ld bytes\n", (long) sizeof (TYPE));
#endif

  input = power_of_two (-1);
  if ((double)input != 0.5)
    {
#if defined(DEBUG) || defined(DEBUG2)
      print_hex ("Input should be 0.5:  ", output, "\n");
      return 1;
#else
      __builtin_abort ();
#endif
    }

  output = calc1 (input);
  if ((double)output != 0.5)
    {
#if defined(DEBUG) || defined(DEBUG2)
      print_hex ("Output should be 0.5: ", output, "\n");
      return 1;
#else
      __builtin_abort ();
#endif
    }

  return 0;
}