// RUN: %clang_builtins %s %librt -lm -o %t && %run %t
// REQUIRES: librt_has_divtc3
// REQUIRES: c99-complex

//
// This test should be XFAILed on 32-bit sparc (sparc-target-arch, Issue
// #41838), but that is currently hidden, which caused an XPASS (Issue #72398).
//
#include <stdio.h>

#include "int_lib.h"
#include "int_math.h"
#include <complex.h>
#include <math.h>

// Returns: the quotient of (a + ib) / (c + id)
#if defined(CRT_HAS_TF_MODE)

COMPILER_RT_ABI Qcomplex __divtc3(tf_float __a, tf_float __b, tf_float __c,
                                  tf_float __d);

enum {zero, non_zero, inf, NaN, non_zero_nan};

static int classify(Qcomplex x) {
  tf_float real = COMPLEXTF_REAL(x);
  tf_float imag = COMPLEXTF_IMAGINARY(x);
  if (real == 0.0 && imag == 0.0)
    return zero;
  if (crt_isinf(real) || crt_isinf(imag))
    return inf;
  if (crt_isnan(real) && crt_isnan(imag))
    return NaN;
  if (crt_isnan(real)) {
    if (imag == 0.0)
      return NaN;
    return non_zero_nan;
  }
  if (crt_isnan(imag)) {
    if (real == 0.0)
      return NaN;
    return non_zero_nan;
  }
  return non_zero;
}

static int test__divtc3(tf_float a, tf_float b, tf_float c, tf_float d) {
  Qcomplex r = __divtc3(a, b, c, d);
  Qcomplex dividend;
  Qcomplex divisor;

  COMPLEXTF_REAL(dividend) = a;
  COMPLEXTF_IMAGINARY(dividend) = b;
  COMPLEXTF_REAL(divisor) = c;
  COMPLEXTF_IMAGINARY(divisor) = d;

  switch (classify(dividend)) {
  case zero:
    switch (classify(divisor)) {
    case zero:
      if (classify(r) != NaN)
        return 1;
      break;
    case non_zero:
      if (classify(r) != zero)
        return 1;
      break;
    case inf:
      if (classify(r) != zero)
        return 1;
      break;
    case NaN:
      if (classify(r) != NaN)
        return 1;
      break;
    case non_zero_nan:
      if (classify(r) != NaN)
        return 1;
      break;
    }
    break;
  case non_zero:
    switch (classify(divisor)) {
    case zero:
      if (classify(r) != inf)
        return 1;
      break;
    case non_zero:
      if (classify(r) != non_zero)
        return 1;
      {
        tf_float zReal = (a * c + b * d) / (c * c + d * d);
        tf_float zImag = (b * c - a * d) / (c * c + d * d);
        Qcomplex diff =
            __divtc3(COMPLEXTF_REAL(r) - zReal, COMPLEXTF_IMAGINARY(r) - zImag,
                     COMPLEXTF_REAL(r), COMPLEXTF_IMAGINARY(r));
        // cabsl(z) == hypotl(creall(z), cimagl(z))
#ifdef CRT_LDBL_128BIT
        if (hypotl(COMPLEXTF_REAL(diff), COMPLEXTF_IMAGINARY(diff)) > 1.e-6)
#else
        // Avoid dependency on __trunctfxf2 for ld80 platforms and use double instead.
        if (hypot(COMPLEXTF_REAL(diff), COMPLEXTF_IMAGINARY(diff)) > 1.e-6)
#endif
          return 1;
      }
      break;
    case inf:
      if (classify(r) != zero)
        return 1;
      break;
    case NaN:
      if (classify(r) != NaN)
        return 1;
      break;
    case non_zero_nan:
      if (classify(r) != NaN)
        return 1;
      break;
    }
    break;
  case inf:
    switch (classify(divisor)) {
    case zero:
      if (classify(r) != inf)
        return 1;
      break;
    case non_zero:
      if (classify(r) != inf)
        return 1;
      break;
    case inf:
      if (classify(r) != NaN)
        return 1;
      break;
    case NaN:
      if (classify(r) != NaN)
        return 1;
      break;
    case non_zero_nan:
      if (classify(r) != NaN)
        return 1;
      break;
    }
    break;
  case NaN:
    switch (classify(divisor)) {
    case zero:
      if (classify(r) != NaN)
        return 1;
      break;
    case non_zero:
      if (classify(r) != NaN)
        return 1;
      break;
    case inf:
      if (classify(r) != NaN)
        return 1;
      break;
    case NaN:
      if (classify(r) != NaN)
        return 1;
      break;
    case non_zero_nan:
      if (classify(r) != NaN)
        return 1;
      break;
    }
    break;
  case non_zero_nan:
    switch (classify(divisor)) {
    case zero:
      if (classify(r) != inf)
        return 1;
      break;
    case non_zero:
      if (classify(r) != NaN)
        return 1;
      break;
    case inf:
      if (classify(r) != NaN)
        return 1;
      break;
    case NaN:
      if (classify(r) != NaN)
        return 1;
      break;
    case non_zero_nan:
      if (classify(r) != NaN)
        return 1;
      break;
    }
    break;
  }

  return 0;
}

tf_float x[][2] = {{1.e-6, 1.e-6},
                   {-1.e-6, 1.e-6},
                   {-1.e-6, -1.e-6},
                   {1.e-6, -1.e-6},

                   {1.e+6, 1.e-6},
                   {-1.e+6, 1.e-6},
                   {-1.e+6, -1.e-6},
                   {1.e+6, -1.e-6},

                   {1.e-6, 1.e+6},
                   {-1.e-6, 1.e+6},
                   {-1.e-6, -1.e+6},
                   {1.e-6, -1.e+6},

                   {1.e+6, 1.e+6},
                   {-1.e+6, 1.e+6},
                   {-1.e+6, -1.e+6},
                   {1.e+6, -1.e+6},

                   {NAN, NAN},
                   {-INFINITY, NAN},
                   {-2, NAN},
                   {-1, NAN},
                   {-0.5, NAN},
                   {-0., NAN},
                   {+0., NAN},
                   {0.5, NAN},
                   {1, NAN},
                   {2, NAN},
                   {INFINITY, NAN},

                   {NAN, -INFINITY},
                   {-INFINITY, -INFINITY},
                   {-2, -INFINITY},
                   {-1, -INFINITY},
                   {-0.5, -INFINITY},
                   {-0., -INFINITY},
                   {+0., -INFINITY},
                   {0.5, -INFINITY},
                   {1, -INFINITY},
                   {2, -INFINITY},
                   {INFINITY, -INFINITY},

                   {NAN, -2},
                   {-INFINITY, -2},
                   {-2, -2},
                   {-1, -2},
                   {-0.5, -2},
                   {-0., -2},
                   {+0., -2},
                   {0.5, -2},
                   {1, -2},
                   {2, -2},
                   {INFINITY, -2},

                   {NAN, -1},
                   {-INFINITY, -1},
                   {-2, -1},
                   {-1, -1},
                   {-0.5, -1},
                   {-0., -1},
                   {+0., -1},
                   {0.5, -1},
                   {1, -1},
                   {2, -1},
                   {INFINITY, -1},

                   {NAN, -0.5},
                   {-INFINITY, -0.5},
                   {-2, -0.5},
                   {-1, -0.5},
                   {-0.5, -0.5},
                   {-0., -0.5},
                   {+0., -0.5},
                   {0.5, -0.5},
                   {1, -0.5},
                   {2, -0.5},
                   {INFINITY, -0.5},

                   {NAN, -0.},
                   {-INFINITY, -0.},
                   {-2, -0.},
                   {-1, -0.},
                   {-0.5, -0.},
                   {-0., -0.},
                   {+0., -0.},
                   {0.5, -0.},
                   {1, -0.},
                   {2, -0.},
                   {INFINITY, -0.},

                   {NAN, 0.},
                   {-INFINITY, 0.},
                   {-2, 0.},
                   {-1, 0.},
                   {-0.5, 0.},
                   {-0., 0.},
                   {+0., 0.},
                   {0.5, 0.},
                   {1, 0.},
                   {2, 0.},
                   {INFINITY, 0.},

                   {NAN, 0.5},
                   {-INFINITY, 0.5},
                   {-2, 0.5},
                   {-1, 0.5},
                   {-0.5, 0.5},
                   {-0., 0.5},
                   {+0., 0.5},
                   {0.5, 0.5},
                   {1, 0.5},
                   {2, 0.5},
                   {INFINITY, 0.5},

                   {NAN, 1},
                   {-INFINITY, 1},
                   {-2, 1},
                   {-1, 1},
                   {-0.5, 1},
                   {-0., 1},
                   {+0., 1},
                   {0.5, 1},
                   {1, 1},
                   {2, 1},
                   {INFINITY, 1},

                   {NAN, 2},
                   {-INFINITY, 2},
                   {-2, 2},
                   {-1, 2},
                   {-0.5, 2},
                   {-0., 2},
                   {+0., 2},
                   {0.5, 2},
                   {1, 2},
                   {2, 2},
                   {INFINITY, 2},

                   {NAN, INFINITY},
                   {-INFINITY, INFINITY},
                   {-2, INFINITY},
                   {-1, INFINITY},
                   {-0.5, INFINITY},
                   {-0., INFINITY},
                   {+0., INFINITY},
                   {0.5, INFINITY},
                   {1, INFINITY},
                   {2, INFINITY},
                   {INFINITY, INFINITY}

};

int main() {
  const unsigned N = sizeof(x) / sizeof(x[0]);
  unsigned i, j;
  for (i = 0; i < N; ++i) {
    for (j = 0; j < N; ++j) {
      if (test__divtc3(x[i][0], x[i][1], x[j][0], x[j][1])) {
        fprintf(stderr, "Failed for %g, %g, %g, %g\n", (double)x[i][0],
                (double)x[i][1], (double)x[j][0], (double)x[j][1]);
        return 1;
      }
    }
  }

  fprintf(stderr, "No errors found.\n");
  return 0;
}

#else

int main() {
  printf("skipped\n");
  return 0;
}

#endif // CRT_HAS_TF_MODE