예제 #1
0
int
fn1 (void)
{
  if (__builtin_constant_p ()) /* { dg-error "7:not enough" } */
    return 0;
  if (__builtin_constant_p (1, 2)) /* { dg-error "7:too many" } */
    return 1;
  if (__builtin_isfinite ()) /* { dg-error "7:not enough" } */
    return 3;
  if (__builtin_isfinite (1, 2)) /* { dg-error "7:too many" } */
    return 4;
  if (__builtin_isless (0)) /* { dg-error "7:not enough" } */
    return 5;
  if (__builtin_isless (1, 2, 3)) /* { dg-error "7:too many" } */
    return 6;
  if (__builtin_fpclassify (1, 2, 3, 4, 5)) /* { dg-error "7:not enough" } */
    return 7;
  if (__builtin_fpclassify (1, 2, 3, 4, 5, r, 6)) /* { dg-error "7:too many" } */
    return 8;
  if (__builtin_assume_aligned (p)) /* { dg-error "7:too few" } */
    return 9;
  if (__builtin_assume_aligned (p, r, p, p)) /* { dg-error "7:too many" } */
    return 10;
  if (__builtin_add_overflow ()) /* { dg-error "7:not enough" } */
    return 11;
  if (__builtin_add_overflow (1, 2, 3, &r)) /* { dg-error "7:too many" } */
    return 12;
  return -1;
}
예제 #2
0
long double
__truncl (long double x)
{
  double xh, xl, hi, lo;

  ldbl_unpack (x, &xh, &xl);

  /* Return Inf, Nan, +/-0 unchanged.  */
  if (__builtin_expect (xh != 0.0
			&& __builtin_isless (__builtin_fabs (xh),
					     __builtin_inf ()), 1))
    {
      double orig_xh;

      /* Long double arithmetic, including the canonicalisation below,
	 only works in round-to-nearest mode.  */

      /* Convert the high double to integer.  */
      orig_xh = xh;
      hi = ldbl_nearbyint (xh);

      /* Subtract integral high part from the value.  */
      xh -= hi;
      ldbl_canonicalize (&xh, &xl);

      /* Now convert the low double, adjusted for any remainder from the
         high double.  */
      lo = ldbl_nearbyint (xh);

      /* Adjust the result when the remainder is non-zero.  nearbyint
         rounds values to the nearest integer, and values halfway
         between integers to the nearest even integer.  floorl must
         round towards -Inf.  */
      xh -= lo;
      ldbl_canonicalize (&xh, &xl);

      if (orig_xh < 0.0)
	{
	  if (xh > 0.0 || (xh == 0.0 && xl > 0.0))
	    lo += 1.0;
	}
      else
	{
	  if (xh < 0.0 || (xh == 0.0 && xl < 0.0))
	    lo -= 1.0;
	}

      /* Ensure the final value is canonical.  In certain cases,
         rounding causes hi,lo calculated so far to be non-canonical.  */
      xh = hi;
      xl = lo;
      ldbl_canonicalize (&xh, &xl);

      /* Ensure we return -0 rather than +0 when appropriate.  */
      if (orig_xh < 0.0)
	xh = -__builtin_fabs (xh);
    }

  return ldbl_pack (xh, xl);
}
예제 #3
0
long double
__truncl (long double x)
{
  double xh, xl, hi, lo;

  ldbl_unpack (x, &xh, &xl);

  /* Return Inf, Nan, +/-0 unchanged.  */
  if (__builtin_expect (xh != 0.0
			&& __builtin_isless (__builtin_fabs (xh),
					     __builtin_inf ()), 1))
    {
      hi = __trunc (xh);
      if (hi != xh)
	{
	  /* The high part is not an integer; the low part does not
	     affect the result.  */
	  xh = hi;
	  xl = 0;
	}
      else
	{
	  /* The high part is a nonzero integer.  */
	  lo = xh > 0 ? __floor (xl) : __ceil (xl);
	  xh = hi;
	  xl = lo;
	  ldbl_canonicalize_int (&xh, &xl);
	}
    }

  return ldbl_pack (xh, xl);
}
예제 #4
0
void
fn0 (int n)
{
  p = __builtin_alloca_with_align (n, 6); /* { dg-error "39:must be a constant integer" } */

  r += __builtin_isfinite (0); /* { dg-error "28:non-floating-point argument in call" } */
  r += __builtin_isinf (0); /* { dg-error "25:non-floating-point argument in call" } */
  r += __builtin_isinf_sign (0); /* { dg-error "30:non-floating-point argument in call" } */
  r += __builtin_isnan (0); /* { dg-error "25:non-floating-point argument in call" } */
  r += __builtin_isnormal (0); /* { dg-error "28:non-floating-point argument in call" } */
  r += __builtin_signbit (0); /* { dg-error "27:non-floating-point argument in call" } */

  r += __builtin_isgreater (0, 0); /* { dg-error "8:non-floating-point arguments in call to function" } */
  r += __builtin_isgreaterequal (0, 0); /* { dg-error "8:non-floating-point arguments in call to function" } */
  r += __builtin_isless (0, 0); /* { dg-error "8:non-floating-point arguments in call to function" } */
  r += __builtin_islessequal (0, 0); /* { dg-error "8:non-floating-point arguments in call to function" } */
  r += __builtin_islessgreater (0, 0); /* { dg-error "8:non-floating-point arguments in call to function" } */
  r += __builtin_isunordered (0, 0); /* { dg-error "8:non-floating-point arguments in call to function" } */

  r += __builtin_fpclassify (1, 2, n, 4, 5, n); /* { dg-error "36:non-const integer argument 3 in call" } */
  r += __builtin_fpclassify (1, 2, 3, 4, 5, 6); /* { dg-error "45:non-floating-point argument in call" } */

  d = __builtin_assume_aligned (p, n, p); /* { dg-error "39:non-integer argument 3 in call" } */

  b = __builtin_add_overflow (n, *d, &r); /* { dg-error "34:argument 2 in call to function" } */
  b = __builtin_add_overflow (n, 5, d); /* { dg-error "37:argument 3 in call" } */
  b = __builtin_sub_overflow (n, *d, &r); /* { dg-error "34:argument 2 in call to function" } */
  b = __builtin_sub_overflow (n, 5, d); /* { dg-error "37:argument 3 in call" } */
  b = __builtin_mul_overflow (n, *d, &r); /* { dg-error "34:argument 2 in call to function" } */
  b = __builtin_mul_overflow (n, 5, d); /* { dg-error "37:argument 3 in call" } */
}
void TestD(double X, double Y) {
  A = __builtin_isgreater(X, Y);
  B = __builtin_isgreaterequal(X, Y);
  C = __builtin_isless(X, Y);
  D = __builtin_islessequal(X, Y);
  E = __builtin_islessgreater(X, Y);
  F = __builtin_isunordered(X, Y);
}
void TestF(float X, float Y) {
  A = __builtin_isgreater(X, Y);
  B = __builtin_isgreaterequal(X, Y);
  C = __builtin_isless(X, Y);
  D = __builtin_islessequal(X, Y);
  E = __builtin_islessgreater(X, Y);
  F = __builtin_isunordered(X, Y);
}
예제 #7
0
long double
__roundl (long double x)
{
  double xh, xl, hi, lo;

  ldbl_unpack (x, &xh, &xl);

  /* Return Inf, Nan, +/-0 unchanged.  */
  if (__builtin_expect (xh != 0.0
			&& __builtin_isless (__builtin_fabs (xh),
					     __builtin_inf ()), 1))
    {
      hi = __round (xh);
      if (hi != xh)
	{
	  /* The high part is not an integer; the low part only
	     affects the result if the high part is exactly half way
	     between two integers and the low part is nonzero with the
	     opposite sign.  */
	  if (fabs (hi - xh) == 0.5)
	    {
	      if (xh > 0 && xl < 0)
		xh = hi - 1;
	      else if (xh < 0 && xl > 0)
		xh = hi + 1;
	      else
		xh = hi;
	    }
	  else
	    xh = hi;
	  xl = 0;
	}
      else
	{
	  /* The high part is a nonzero integer.  */
	  lo = __round (xl);
	  if (fabs (lo - xl) == 0.5)
	    {
	      if (xh > 0 && xl < 0)
		xl = lo + 1;
	      else if (xh < 0 && lo > 0)
		xl = lo - 1;
	      else
		xl = lo;
	    }
	  else
	    xl = lo;
	  xh = hi;
	  ldbl_canonicalize_int (&xh, &xl);
	}
    }
  else
    /* Quiet signaling NaN arguments.  */
    xh += xh;

  return ldbl_pack (xh, xl);
}
예제 #8
0
long double
__roundl (long double x)
{
  double xh, xl, hi, lo;

  ldbl_unpack (x, &xh, &xl);

  /* Return Inf, Nan, +/-0 unchanged.  */
  if (__builtin_expect (xh != 0.0
			&& __builtin_isless (__builtin_fabs (xh),
					     __builtin_inf ()), 1))
    {
      double orig_xh;

      /* Long double arithmetic, including the canonicalisation below,
	 only works in round-to-nearest mode.  */

      /* Convert the high double to integer.  */
      orig_xh = xh;
      hi = ldbl_nearbyint (xh);

      /* Subtract integral high part from the value.  */
      xh -= hi;
      ldbl_canonicalize (&xh, &xl);

      /* Now convert the low double, adjusted for any remainder from the
	 high double.  */
      lo = ldbl_nearbyint (xh);

      /* Adjust the result when the remainder is exactly 0.5.  nearbyint
	 rounds values halfway between integers to the nearest even
	 integer.  roundl must round away from zero.
	 Also correct cases where nearbyint returns an incorrect value
	 for LO.  */
      xh -= lo;
      ldbl_canonicalize (&xh, &xl);
      if (xh == 0.5)
	{
	  if (xl > 0.0 || (xl == 0.0 && orig_xh > 0.0))
	    lo += 1.0;
	}
      else if (-xh == 0.5)
	{
	  if (xl < 0.0 || (xl == 0.0 && orig_xh < 0.0))
	    lo -= 1.0;
	}

      /* Ensure the final value is canonical.  In certain cases,
	 rounding causes hi,lo calculated so far to be non-canonical.  */
      xh = hi;
      xl = lo;
      ldbl_canonicalize (&xh, &xl);
    }

  return ldbl_pack (xh, xl);
}
예제 #9
0
void TestD(double X, double Y) {
  A = __builtin_isgreater(X, Y);
  B = __builtin_isgreaterequal(X, Y);
  C = __builtin_isless(X, Y);
  D = __builtin_islessequal(X, Y);
  E = __builtin_islessgreater(X, Y);
  F = __builtin_isunordered(X, Y);
  //G = __builtin_isordered(X, Y);    // Our current snapshot doesn't include this builtin.  FIXME
  H = __builtin_isunordered(X, Y);
}
예제 #10
0
void TestF(float X, float Y) {
  A = __builtin_isgreater(X, Y);
  B = __builtin_isgreaterequal(X, Y);
  C = __builtin_isless(X, Y);
  D = __builtin_islessequal(X, Y);
  E = __builtin_islessgreater(X, Y);
  F = __builtin_isunordered(X, Y);
  //G = __builtin_isordered(X, Y);    // Our current snapshot of GCC doesn't include this builtin
  H = __builtin_isunordered(X, Y);
}
예제 #11
0
파일: pr50310-2.c 프로젝트: pjump/gcc
int
main (void)
{
    int i;
    asm volatile ("" : : : "memory");
    for (i = 0; i < 4; i++)
        s3[0 * 4 + i] = __builtin_isgreater (s1[i], s2[i]) ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[1 * 4 + i] = (!__builtin_isgreater (s1[i], s2[i])) ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[2 * 4 + i] = __builtin_isgreaterequal (s1[i], s2[i]) ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[3 * 4 + i] = (!__builtin_isgreaterequal (s1[i], s2[i])) ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[4 * 4 + i] = __builtin_isless (s1[i], s2[i]) ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[5 * 4 + i] = (!__builtin_isless (s1[i], s2[i])) ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[6 * 4 + i] = __builtin_islessequal (s1[i], s2[i]) ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[7 * 4 + i] = (!__builtin_islessequal (s1[i], s2[i])) ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[8 * 4 + i] = __builtin_islessgreater (s1[i], s2[i]) ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[9 * 4 + i] = (!__builtin_islessgreater (s1[i], s2[i])) ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[10 * 4 + i] = __builtin_isunordered (s1[i], s2[i]) ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[11 * 4 + i] = (!__builtin_isunordered (s1[i], s2[i])) ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[12 * 4 + i] = s1[i] > s2[i] ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[13 * 4 + i] = s1[i] >= s2[i] ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[14 * 4 + i] = s1[i] < s2[i] ? -1.0 : 0.0;
    for (i = 0; i < 4; i++)
        s3[15 * 4 + i] = s1[i] <= s2[i] ? -1.0 : 0.0;
    asm volatile ("" : : : "memory");
    return 0;
}
예제 #12
0
void
check (TYPE a,
       TYPE b,
       int eq,
       int ne,
       int lt,
       int le,
       int gt,
       int ge,
       int i_lt,
       int i_le,
       int i_gt,
       int i_ge,
       int i_lg,
       int i_un)
{
  if (eq != (a == b))
    abort ();

  if (ne != (a != b))
    abort ();

  if (lt != (a < b))
    abort ();

  if (le != (a <= b))
    abort ();

  if (gt != (a > b))
    abort ();

  if (ge != (a >= b))
    abort ();

  if (i_lt != __builtin_isless (a, b))
    abort ();

  if (i_le != __builtin_islessequal (a, b))
    abort ();

  if (i_gt != __builtin_isgreater (a, b))
    abort ();

  if (i_ge != __builtin_isgreaterequal (a, b))
    abort ();

  if (i_lg != __builtin_islessgreater (a, b))
    abort ();

  if (i_un != __builtin_isunordered (a, b))
    abort ();
}
예제 #13
0
int main() {
  volatile float pos1 = 1.;
  volatile float neg1 = -1.;
  volatile float posZero = 0.;
  volatile float negZero = -0.;
  if (__builtin_isless(neg1, neg1) != 0) {
    return 1;
  }
  if (__builtin_isless(posZero, negZero) != 0) {
    return 1;
  }
  if (__builtin_isless(pos1, pos1) != 0) {
    return 1;
  }
  if (__builtin_isless(neg1, pos1) == 0) {
    return 1;
  }
  if (__builtin_isless(pos1, neg1) != 0) {
    return 1;
  }
  return 0;
}
예제 #14
0
파일: pr50310.c 프로젝트: 0day-ci/gcc
void
foo (void)
{
  int i;
  for (i = 0; i < 4; i++)
    s3[0 * 4 + i] = __builtin_isgreater (s1[i], s2[i]) ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[1 * 4 + i] = (!__builtin_isgreater (s1[i], s2[i])) ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[2 * 4 + i] = __builtin_isgreaterequal (s1[i], s2[i]) ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[3 * 4 + i] = (!__builtin_isgreaterequal (s1[i], s2[i])) ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[4 * 4 + i] = __builtin_isless (s1[i], s2[i]) ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[5 * 4 + i] = (!__builtin_isless (s1[i], s2[i])) ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[6 * 4 + i] = __builtin_islessequal (s1[i], s2[i]) ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[7 * 4 + i] = (!__builtin_islessequal (s1[i], s2[i])) ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[8 * 4 + i] = __builtin_islessgreater (s1[i], s2[i]) ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[9 * 4 + i] = (!__builtin_islessgreater (s1[i], s2[i])) ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[10 * 4 + i] = __builtin_isunordered (s1[i], s2[i]) ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[11 * 4 + i] = (!__builtin_isunordered (s1[i], s2[i])) ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[12 * 4 + i] = s1[i] > s2[i] ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[13 * 4 + i] = s1[i] <= s2[i] ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[14 * 4 + i] = s1[i] < s2[i] ? -1.0 : 0.0;
  for (i = 0; i < 4; i++)
    s3[15 * 4 + i] = s1[i] >= s2[i] ? -1.0 : 0.0;
}
예제 #15
0
int test3(double x)
{
  if (x ==  1) return __builtin_fpclassify(1,2,3,4,5,x,x); /* { dg-error "too many arguments" } */
  if (x ==  2) return __builtin_isfinite(x, x); /* { dg-error "too many arguments" } */
  if (x ==  3) return __builtin_isinf_sign(x, x); /* { dg-error "too many arguments" } */
  if (x ==  4) return __builtin_isinf(x, x); /* { dg-error "too many arguments" } */
  if (x ==  5) return __builtin_isnan(x, x); /* { dg-error "too many arguments" } */
  if (x ==  6) return __builtin_isnormal(x, x); /* { dg-error "too many arguments" } */
  if (x ==  7) return __builtin_isgreater(x, x, x); /* { dg-error "too many arguments" } */
  if (x ==  8) return __builtin_isgreaterequal(x, x, x); /* { dg-error "too many arguments" } */
  if (x ==  9) return __builtin_isless(x, x, x); /* { dg-error "too many arguments" } */
  if (x == 10) return __builtin_islessequal(x, x, x); /* { dg-error "too many arguments" } */
  if (x == 11) return __builtin_islessgreater(x, x, x); /* { dg-error "too many arguments" } */
  if (x == 12) return __builtin_isunordered(x, x, x); /* { dg-error "too many arguments" } */
  if (x == 13) return __builtin_signbit(x, x); /* { dg-error "too many arguments" } */
  return 0;
}
예제 #16
0
int test1(struct X x)
{
  if (x.x ==  1) return __builtin_fpclassify(1,2,3,4,5,x); /* { dg-error "non-floating-point argument" } */
  if (x.x ==  2) return __builtin_isfinite(x); /* { dg-error "non-floating-point argument" } */
  if (x.x ==  3) return __builtin_isinf_sign(x); /* { dg-error "non-floating-point argument" } */
  if (x.x ==  4) return __builtin_isinf(x); /* { dg-error "non-floating-point argument" } */
  if (x.x ==  5) return __builtin_isnan(x); /* { dg-error "non-floating-point argument" } */
  if (x.x ==  6) return __builtin_isnormal(x); /* { dg-error "non-floating-point argument" } */
  if (x.x ==  7) return __builtin_isgreater(x, x); /* { dg-error "non-floating-point arguments" } */
  if (x.x ==  8) return __builtin_isgreaterequal(x, x); /* { dg-error "non-floating-point arguments" } */
  if (x.x ==  9) return __builtin_isless(x, x); /* { dg-error "non-floating-point arguments" } */
  if (x.x == 10) return __builtin_islessequal(x, x); /* { dg-error "non-floating-point arguments" } */
  if (x.x == 11) return __builtin_islessgreater(x, x); /* { dg-error "non-floating-point arguments" } */
  if (x.x == 12) return __builtin_isunordered(x, x); /* { dg-error "non-floating-point arguments" } */
  if (x.x == 13) return __builtin_signbit(x); /* { dg-error "non-floating-point argument" } */

  return 0;
}
예제 #17
0
파일: builtins.c 프로젝트: qiongsiwu/CLang
int test1(float a, int b) {
  return __builtin_isless(a, b); // expected-note {{declared here}}
}
NOMIPS16 int f2 (double x, double y) { return __builtin_isless (x, y); }
예제 #19
0
// 'const float' promotes to double in varargs.
int test5(const float x, float float_number) {
  return __builtin_isless(x, float_number);
}
예제 #20
0
long double
__rintl (long double x)
{
    double xh, xl, hi, lo;

    ldbl_unpack (x, &xh, &xl);

    /* Return Inf, Nan, +/-0 unchanged.  */
    if (__builtin_expect (xh != 0.0
                          && __builtin_isless (__builtin_fabs (xh),
                                  __builtin_inf ()), 1))
    {
        double orig_xh;
        int save_round = fegetround ();

        /* Long double arithmetic, including the canonicalisation below,
        only works in round-to-nearest mode.  */
        fesetround (FE_TONEAREST);

        /* Convert the high double to integer.  */
        orig_xh = xh;
        hi = ldbl_nearbyint (xh);

        /* Subtract integral high part from the value.  If the low double
        happens to be exactly 0.5 or -0.5, you might think that this
         subtraction could result in an incorrect conversion.  For
         instance, subtracting an odd number would cause this function
         to round in the wrong direction.  However, if we have a
         canonical long double with the low double 0.5 or -0.5, then the
         high double must be even.  */
        xh -= hi;
        ldbl_canonicalize (&xh, &xl);

        /* Now convert the low double, adjusted for any remainder from the
        high double.  */
        lo = ldbl_nearbyint (xh);

        xh -= lo;
        ldbl_canonicalize (&xh, &xl);

        switch (save_round)
        {
        case FE_TONEAREST:
            if (xl > 0.0 && xh == 0.5)
                lo += 1.0;
            else if (xl < 0.0 && -xh == 0.5)
                lo -= 1.0;
            break;

        case FE_TOWARDZERO:
            if (orig_xh < 0.0)
                goto do_up;
        /* Fall thru */

        case FE_DOWNWARD:
            if (xh < 0.0 || (xh == 0.0 && xl < 0.0))
                lo -= 1.0;
            break;

        case FE_UPWARD:
do_up:
            if (xh > 0.0 || (xh == 0.0 && xl > 0.0))
                lo += 1.0;
            break;
        }

        /* Ensure the final value is canonical.  In certain cases,
           rounding causes hi,lo calculated so far to be non-canonical.  */
        xh = hi;
        xl = lo;
        ldbl_canonicalize (&xh, &xl);

        /* Ensure we return -0 rather than +0 when appropriate.  */
        if (orig_xh < 0.0)
            xh = -__builtin_fabs (xh);

        fesetround (save_round);
    }

    return ldbl_pack (xh, xl);
}
예제 #21
0
파일: fp-cmp-8.c 프로젝트: 0day-ci/gcc
static FLOAT
test_not_isless(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
{
  return !__builtin_isless(x, y) ? a : b;
}
/* { dg-options "-mhard-float -O2" } */
NOMIPS16 int f1 (float x, float y) { return __builtin_isless (x, y); }
예제 #23
0
int isless (float f1, float f2)
{
  int r = __builtin_isless (f1, f2);
  return !r ?  -1 : 1;
}
예제 #24
0
int test3(double a, float b) {
  return __builtin_isless(a, b);
}
예제 #25
0
int test1(float a, int b) {
  return __builtin_isless(a, b);
}
예제 #26
0
int test5(float a, long double b) {
  return __builtin_isless(a, b, b);  // expected-error {{too many arguments}}
}
예제 #27
0
파일: fp-test.c 프로젝트: 0mp/freebsd
int
main (void)
{
  /* TYPE: float */

  f1 = -f2;
  f1 = f2 + f3;
  f1 = f2 - f3;
  f1 = f2 * f3;
  f1 = f2 / f3;
  f1 += f2;
  f1 -= f2;
  f1 *= f2;
  f1 /= f2;

  si = f1 == f2;
  si = f1 != f2;
  si = f1 > f2;
  si = f1 < f2;
  si = f1 >= f2;
  si = f1 <= f2;

  si = __builtin_isgreater (f1, f2);
  si = __builtin_isgreaterequal (f1, f2);
  si = __builtin_isless (f1, f2);
  si = __builtin_islessequal (f1, f2);
  si = __builtin_islessgreater (f1, f2);
  si = __builtin_isunordered (f1, f2);

  sc = f1;
  uc = f1;
  ss = f1;
  us = f1;
  si = f1;
  ui = f1;
  sl = f1;
  ul = f1;
  d1 = f1;
  D1 = f1;

  f1 = sc;
  f1 = uc;
  f1 = ss;
  f1 = us;
  f1 = si;
  f1 = ui;
  f1 = sl;
  f1 = ul;
  f1 = d1;
  f1 = D1;

  d1 = -d2;
  d1 = d2 + d3;
  d1 = d2 - d3;
  d1 = d2 * d3;
  d1 = d2 / d3;
  d1 += d2;
  d1 -= d2;
  d1 *= d2;
  d1 /= d2;

  si = d1 == d2;
  si = d1 != d2;
  si = d1 > d2;
  si = d1 < d2;
  si = d1 >= d2;
  si = d1 <= d2;

  si = __builtin_isgreater (d1, d2);
  si = __builtin_isgreaterequal (d1, d2);
  si = __builtin_isless (d1, d2);
  si = __builtin_islessequal (d1, d2);
  si = __builtin_islessgreater (d1, d2);
  si = __builtin_isunordered (d1, d2);

  sc = d1;
  uc = d1;
  ss = d1;
  us = d1;
  si = d1;
  ui = d1;
  sl = d1;
  ul = d1;
  f1 = d1;
  D1 = d1;

  d1 = sc;
  d1 = uc;
  d1 = ss;
  d1 = us;
  d1 = si;
  d1 = ui;
  d1 = sl;
  d1 = ul;
  d1 = f1;
  d1 = D1;

  D1 = -D2;
  D1 = D2 + D3;
  D1 = D2 - D3;
  D1 = D2 * D3;
  D1 = D2 / D3;
  D1 += D2;
  D1 -= D2;
  D1 *= D2;
  D1 /= D2;

  si = D1 == D2;
  si = D1 != D2;
  si = D1 > D2;
  si = D1 < D2;
  si = D1 >= D2;
  si = D1 <= D2;

  si = __builtin_isgreater (D1, D2);
  si = __builtin_isgreaterequal (D1, D2);
  si = __builtin_isless (D1, D2);
  si = __builtin_islessequal (D1, D2);
  si = __builtin_islessgreater (D1, D2);
  si = __builtin_isunordered (D1, D2);

  sc = D1;
  uc = D1;
  ss = D1;
  us = D1;
  si = D1;
  ui = D1;
  sl = D1;
  ul = D1;
  f1 = D1;
  d1 = D1;

  D1 = sc;
  D1 = uc;
  D1 = ss;
  D1 = us;
  D1 = si;
  D1 = ui;
  D1 = sl;
  D1 = ul;
  D1 = f1;
  D1 = d1;

  d1 = acos (d2);
  d1 = asin (d2);
  d1 = atan (d2);
  d1 = atan2 (d2, d3);
  d1 = cos (d2);
  d1 = sin (d2);
  d1 = tan (d2);
  d1 = cosh (d2);
  d1 = sinh (d2);
  d1 = tanh (d2);
  d1 = exp (d2);
  d1 = frexp (d2, &i1);
  d1 = ldexp (d2, i2);
  d1 = log (d2);
  d1 = log10 (d2);
  d1 = modf (d2, &d3);
  d1 = pow (d2, d3);
  d1 = sqrt (d2);
  d1 = ceil (d2);
  d1 = fabs (d2);
  d1 = floor (d2);
  d1 = fmod (d2, d3);

  return 0;
}
inline bool isless(const Y& v1,const Y& v2)
{
    return __builtin_isless(v1,v2);
}