/* { dg-do run } */
/* { dg-require-effective-target vsx_hw } */
/* { dg-options "-O2 -ftree-vectorize -mvsx -fno-vect-cost-model -fdump-tree-vect-details" } */

/* To test condition reduction vectorization, where comparison operands are of
   double type and condition true/false values are integer type.  Cover all
   float point comparison codes.  */

#include <math.h>

extern void
abort (void) __attribute__ ((noreturn));

#define N 27
#define FP_TYPE double

#define LTGT(a, b) (__builtin_islessgreater ((a), (b)))
#define UNORD(a, b) (__builtin_isunordered ((a), (b)))
#define ORD(a, b) (!__builtin_isunordered ((a), (b)))
#define UNEQ(a, b) (!__builtin_islessgreater ((a), (b)))
#define UNGT(a, b) (!__builtin_islessequal ((a), (b)))
#define UNGE(a, b) (!__builtin_isless ((a), (b)))
#define UNLT(a, b) (!__builtin_isgreaterequal ((a), (b)))
#define UNLE(a, b) (!__builtin_isgreater ((a), (b)))

__attribute__ ((noinline)) int
test_eq (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (a[i] == min_v)
      last = i;

  return last;
}

__attribute__ ((noinline)) int
test_ne (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (a[i] != min_v)
      last = i;

  return last;
}

__attribute__ ((noinline)) int
test_gt (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (a[i] > min_v)
      last = i;

  return last;
}

__attribute__ ((noinline)) int
test_ge (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (a[i] >= min_v)
      last = i;

  return last;
}

__attribute__ ((noinline)) int
test_lt (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (a[i] < min_v)
      last = i;

  return last;
}

__attribute__ ((noinline)) int
test_le (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (a[i] <= min_v)
      last = i;

  return last;
}

__attribute__ ((noinline)) int
test_ltgt (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (LTGT (a[i], min_v))
      last = i;

  return last;
}

__attribute__ ((noinline)) int
test_ord (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (ORD (a[i], min_v))
      last = i;

  return last;
}

__attribute__ ((noinline)) int
test_unord (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (UNORD (a[i], min_v))
      last = i;

  return last;
}

__attribute__ ((noinline)) int
test_uneq (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (UNEQ (a[i], min_v))
      last = i;

  return last;
}

__attribute__ ((noinline)) int
test_ungt (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (UNGT (a[i], min_v))
      last = i;

  return last;
}

__attribute__ ((noinline)) int
test_unge (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (UNGE (a[i], min_v))
      last = i;

  return last;
}

__attribute__ ((noinline)) int
test_unlt (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (UNLT (a[i], min_v))
      last = i;

  return last;
}

__attribute__ ((noinline)) int
test_unle (FP_TYPE *a, FP_TYPE min_v)
{
  int last = 0;

  for (int i = 0; i < N; i++)
    if (UNLE (a[i], min_v))
      last = i;

  return last;
}

int
main (void)
{
  int ret = 0;

  FP_TYPE a1[N] = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1,  2,  3, 4,
		   5,  6,  7,  8,  9,  10, 21, 22, 23, 24, 25, 26, 27};

  FP_TYPE a2[N] = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20,  1,  2,  3, 4,
		   5,  6,  7,  8,  9,  10, 21, 22, 23, NAN, 25, 26, 27};

  FP_TYPE a3[N] = {21, 22, 23, 24, 25, 26, 27, 28, 29, 10, 11, 12, 13, 14,
		   15, 16, 17, 18, 19, 20, 1,  2,  3,  4,  5,  6,  7};

  FP_TYPE a4[N] = {21, 22, 23, 24, 25, 26, 27, 28, 29, 10, 11,  12, 13, 14,
		   15, 16, 17, 18, 19, 20, 1,  2,  3,  4,  NAN, 6,  7};

  FP_TYPE a5[N] = {21, 22, 23, 24, 25, 26, 27, 28, 29, 10, 11,  12, 13, 14,
		   15, 16, 17, 18, 19, 20, 1,  2,  3,  4,  NAN, 10, 10};

  ret = test_eq (a1, 10);
  if (ret != 19)
    abort ();

  ret = test_ne (a1, 10);
  if (ret != 26)
    abort ();

  ret = test_gt (a3, 10);
  if (ret != 19)
    abort ();

  ret = test_ge (a3, 10);
  if (ret != 19)
    abort ();

  ret = test_lt (a1, 10);
  if (ret != 18)
    abort ();

  ret = test_le (a1, 10);
  if (ret != 19)
    abort ();

  ret = test_ltgt (a3, 10);
  if (ret != 26)
    abort ();

  ret = test_ltgt (a5, 10);
  if (ret != 23)
    abort ();

  ret = test_unord (a5, 10);
  if (ret != 24)
    abort ();

  ret = test_ord (a5, 10);
  if (ret != 26)
    abort ();

  ret = test_uneq (a1, 10);
  if (ret != 19)
    abort ();

  ret = test_uneq (a4, 10);
  if (ret != 24)
    abort ();

  ret = test_ungt (a3, 10);
  if (ret != 19)
    abort ();

  ret = test_ungt (a4, 10);
  if (ret != 24)
    abort ();

  ret = test_unge (a3, 10);
  if (ret != 19)
    abort ();

  ret = test_ungt (a4, 10);
  if (ret != 24)
    abort ();

  ret = test_unlt (a1, 10);
  if (ret != 18)
    abort ();

  ret = test_unlt (a2, 10);
  if (ret != 23)
    abort ();

  ret = test_unle (a1, 10);
  if (ret != 19)
    abort ();

  ret = test_unle (a2, 10);
  if (ret != 23)
    abort ();

  return 0;
}

/* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 14 "vect" { target has_arch_pwr8 } } } */