Back to index

glibc  2.9
Defines | Typedefs | Enumerations | Functions | Variables
test-tgmath2.c File Reference
#include <math.h>
#include <complex.h>
#include <stdio.h>
#include <string.h>
#include <tgmath.h>
#include "test-tgmath2.c"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

#define __NO_MATH_INLINES   1
#define FAIL(str)
#define TEST_TYPE_ONLY(expr, rettype)
#define TEST2(expr, type, rettype, fn)
#define TEST(expr, type, fn)   TEST2(expr, type, type, fn)
#define FIRST(x, y)   (y, x)
#define SECOND(x, y)   (x, y)
#define NON_LDBL_TEST(fn, argm, arg, type, fnt)
#define NON_LDBL_CTEST(fn, argm, arg, type, fnt)
#define BINARY_TEST(fn, fnt)
#define BINARY_CTEST(fn, fnt)
#define my_remquo(x, y)   remquo (x, y, &quo)
#define my_fma(x, y)   fma (x, y, vfloat3)
#define my_fma(x, y)   fma (x, vfloat3, y)
#define my_fma(x, y)   fma (Vfloat3, x, y)
#define HAVE_MAIN
#define F(name)   name
#define TYPE   double
#define CTYPE   cdouble
#define T   Tdouble
#define C   Tcdouble
#define F(name)   name##f
#define TYPE   float
#define CTYPE   cfloat
#define T   Tfloat
#define C   Tcfloat
#define F(name)   name##l
#define TYPE   ldouble
#define CTYPE   cldouble
#define T   Tldouble
#define C   Tcldouble

Typedefs

typedef complex float cfloat
typedef complex double cdouble
typedef long double ldouble
typedef complex long double cldouble

Enumerations

enum  {
  Tfloat = 0, Tcfloat, Tdouble, Tcdouble,
  Tldouble, Tcldouble, Tlast
}
enum  {
  C_cos = 0, C_fabs, C_cabs, C_conj,
  C_expm1, C_lrint, C_ldexp, C_atan2,
  C_remquo, C_pow, C_fma, C_last
}

Functions

int test (const int Vint4, const long long int Vllong4)
int main (void)

Variables

float vfloat1
float vfloat2
float vfloat3
double vdouble1
double vdouble2
double vdouble3
ldouble vldouble1
ldouble vldouble2
ldouble vldouble3
cfloat vcfloat1
cfloat vcfloat2
cfloat vcfloat3
cdouble vcdouble1
cdouble vcdouble2
cdouble vcdouble3
cldouble vcldouble1
cldouble vcldouble2
cldouble vcldouble4
int vint1
int vint2
int vint3
long int vlong1
long int vlong2
long int vlong3
long long int vllong1
long long int vllong2
long long int vllong3
const float Vfloat1 = 1
const float Vfloat2 = 2
const float Vfloat3 = 3
const double Vdouble1 = 1
const double Vdouble2 = 2
const double Vdouble3 = 3
const ldouble Vldouble1 = 1
const ldouble Vldouble2 = 2
const ldouble Vldouble3 = 3
const cfloat Vcfloat1 = 1
const cfloat Vcfloat2 = 2
const cfloat Vcfloat3 = 3
const cdouble Vcdouble1 = 1
const cdouble Vcdouble2 = 2
const cdouble Vcdouble3 = 3
const cldouble Vcldouble1 = 1
const cldouble Vcldouble2 = 2
const cldouble Vcldouble4 = 3
const int Vint1 = 1
const int Vint2 = 2
const int Vint3 = 3
const long int Vlong1 = 1
const long int Vlong2 = 2
const long int Vlong3 = 3
const long long int Vllong1 = 1
const long long int Vllong2 = 2
const long long int Vllong3 = 3
int count
int counts [Tlast][C_last]

Define Documentation

#define __NO_MATH_INLINES   1

Definition at line 23 of file test-tgmath2.c.

#define BINARY_CTEST (   fn,
  fnt 
)
#define BINARY_TEST (   fn,
  fnt 
)
Value:
TEST (fn (vfloat1, vfloat2), float, fnt); \
  TEST (fn (Vfloat1, vfloat2), float, fnt); \
  TEST (fn (vfloat1, Vfloat2), float, fnt); \
  TEST (fn (Vfloat1, Vfloat2), float, fnt); \
  TEST (fn (vldouble1, vldouble2), ldouble, fnt); \
  TEST (fn (Vldouble1, vldouble2), ldouble, fnt); \
  TEST (fn (vldouble1, Vldouble2), ldouble, fnt); \
  TEST (fn (Vldouble1, Vldouble2), ldouble, fnt); \
  NON_LDBL_TEST (fn, FIRST, vldouble2, ldouble, fnt); \
  NON_LDBL_TEST (fn, SECOND, vldouble2, ldouble, fnt); \
  NON_LDBL_TEST (fn, FIRST, Vldouble2, ldouble, fnt); \
  NON_LDBL_TEST (fn, SECOND, Vldouble2, ldouble, fnt); \
  NON_LDBL_TEST (fn, FIRST, vdouble2, double, fnt); \
  NON_LDBL_TEST (fn, SECOND, vdouble2, double, fnt); \
  NON_LDBL_TEST (fn, FIRST, Vdouble2, double, fnt); \
  NON_LDBL_TEST (fn, SECOND, Vdouble2, double, fnt); \
  NON_LDBL_TEST (fn, FIRST, vint2, double, fnt); \
  NON_LDBL_TEST (fn, SECOND, vint2, double, fnt); \
  NON_LDBL_TEST (fn, FIRST, Vint2, double, fnt); \
  NON_LDBL_TEST (fn, SECOND, Vint2, double, fnt); \
  NON_LDBL_TEST (fn, FIRST, vllong2, double, fnt); \
  NON_LDBL_TEST (fn, SECOND, vllong2, double, fnt); \
  NON_LDBL_TEST (fn, FIRST, Vllong2, double, fnt); \
  NON_LDBL_TEST (fn, SECOND, Vllong2, double, fnt);
#define C   Tcdouble

Definition at line 366 of file test-tgmath2.c.

#define C   Tcfloat

Definition at line 366 of file test-tgmath2.c.

#define C   Tcldouble

Definition at line 366 of file test-tgmath2.c.

#define CTYPE   cdouble

Definition at line 364 of file test-tgmath2.c.

#define CTYPE   cfloat

Definition at line 364 of file test-tgmath2.c.

#define CTYPE   cldouble

Definition at line 364 of file test-tgmath2.c.

#define F (   name)    name

Definition at line 362 of file test-tgmath2.c.

#define F (   name)    name##f

Definition at line 362 of file test-tgmath2.c.

#define F (   name)    name##l

Definition at line 362 of file test-tgmath2.c.

#define FAIL (   str)
Value:
do                                                      \
    {                                                   \
      printf ("%s failure on line %d\n", (str), __LINE__);     \
      result = 1;                                       \
    }                                                   \
  while (0)
#define FIRST (   x,
  y 
)    (y, x)
#define HAVE_MAIN

Definition at line 345 of file test-tgmath2.c.

#define my_fma (   x,
  y 
)    fma (x, y, vfloat3)
#define my_fma (   x,
  y 
)    fma (x, vfloat3, y)
#define my_fma (   x,
  y 
)    fma (Vfloat3, x, y)
#define my_remquo (   x,
  y 
)    remquo (x, y, &quo)
#define NON_LDBL_CTEST (   fn,
  argm,
  arg,
  type,
  fnt 
)
Value:
NON_LDBL_TEST(fn, argm, arg, type, fnt); \
  TEST (fn argm (arg, vcfloat1), type, fnt); \
  TEST (fn argm (arg, vcdouble1), type, fnt); \
  TEST (fn argm (arg, Vcfloat1), type, fnt); \
  TEST (fn argm (arg, Vcdouble1), type, fnt);
#define NON_LDBL_TEST (   fn,
  argm,
  arg,
  type,
  fnt 
)
Value:
TEST (fn argm (arg, vfloat1), type, fnt); \
  TEST (fn argm (arg, vdouble1), type, fnt); \
  TEST (fn argm (arg, vint1), type, fnt); \
  TEST (fn argm (arg, vllong1), type, fnt); \
  TEST (fn argm (arg, Vfloat1), type, fnt); \
  TEST (fn argm (arg, Vdouble1), type, fnt); \
  TEST (fn argm (arg, Vint1), type, fnt); \
  TEST (fn argm (arg, Vllong1), type, fnt);
#define SECOND (   x,
  y 
)    (x, y)
#define T   Tdouble

Definition at line 365 of file test-tgmath2.c.

#define T   Tfloat

Definition at line 365 of file test-tgmath2.c.

#define T   Tldouble

Definition at line 365 of file test-tgmath2.c.

#define TEST (   expr,
  type,
  fn 
)    TEST2(expr, type, type, fn)
#define TEST2 (   expr,
  type,
  rettype,
  fn 
)
Value:
do                                                      \
    {                                                   \
      __typeof__ (expr) texpr = 0;                      \
      TEST_TYPE_ONLY (expr, rettype);                          \
      if (count != 0)                                          \
       FAIL ("internal error");                         \
      if (counts[T##type][C_##fn] != 0)                        \
       FAIL ("internal error");                         \
      texpr = expr;                                     \
      __asm __volatile ("" : : "r" (&texpr));                  \
      if (count != 1 || counts[T##type][C_##fn] != 1)          \
       {                                                \
         FAIL ("wrong function called");                \
         memset (counts, 0, sizeof (counts));                  \
       }                                                \
      count = 0;                                        \
      counts[T##type][C_##fn] = 0;                      \
    }                                                   \
  while (0)
#define TEST_TYPE_ONLY (   expr,
  rettype 
)
Value:
do                                                      \
    {                                                   \
      __typeof__ (expr) texpr = 0;                      \
      __typeof__ (rettype) ttype = 0, *ptype;                  \
      if (sizeof (expr) != sizeof (rettype))                   \
       FAIL ("type");                                          \
      if (__alignof__ (expr) != __alignof__ (rettype))         \
       FAIL ("type");                                          \
      __asm ("" : "=r" (ptype) : "0" (&ttype), "r" (&texpr));  \
      if (&texpr == ptype)                              \
       FAIL ("type");                                          \
    }                                                   \
  while (0)
#define TYPE   double

Definition at line 363 of file test-tgmath2.c.

#define TYPE   float

Definition at line 363 of file test-tgmath2.c.

#define TYPE   ldouble

Definition at line 363 of file test-tgmath2.c.


Typedef Documentation

typedef complex double cdouble

Definition at line 33 of file test-tgmath2.c.

typedef complex float cfloat

Definition at line 32 of file test-tgmath2.c.

typedef complex long double cldouble

Definition at line 36 of file test-tgmath2.c.

typedef long double ldouble

Definition at line 35 of file test-tgmath2.c.


Enumeration Type Documentation

anonymous enum
Enumerator:
Tfloat 
Tcfloat 
Tdouble 
Tcdouble 
Tldouble 
Tcldouble 
Tlast 

Definition at line 60 of file test-tgmath2.c.

  {
    Tfloat = 0,
    Tcfloat,
    Tdouble,
    Tcdouble,
#ifndef NO_LONG_DOUBLE
    Tldouble,
    Tcldouble,
#else
    Tldouble = Tdouble,
    Tcldouble = Tcdouble,
#endif
    Tlast
  };
anonymous enum
Enumerator:
C_cos 
C_fabs 
C_cabs 
C_conj 
C_expm1 
C_lrint 
C_ldexp 
C_atan2 
C_remquo 
C_pow 
C_fma 
C_last 

Definition at line 75 of file test-tgmath2.c.


Function Documentation

int main ( void  )

Definition at line 339 of file test-tgmath2.c.

{
  return test (vint1, vllong1);
}
int test ( const int  Vint4,
const long long int  Vllong4 
)

Definition at line 94 of file test-tgmath2.c.

{
  int result = 0;
  int quo = 0;

#define FAIL(str) \
  do                                                    \
    {                                                   \
      printf ("%s failure on line %d\n", (str), __LINE__);     \
      result = 1;                                       \
    }                                                   \
  while (0)
#define TEST_TYPE_ONLY(expr, rettype) \
  do                                                    \
    {                                                   \
      __typeof__ (expr) texpr = 0;                      \
      __typeof__ (rettype) ttype = 0, *ptype;                  \
      if (sizeof (expr) != sizeof (rettype))                   \
       FAIL ("type");                                          \
      if (__alignof__ (expr) != __alignof__ (rettype))         \
       FAIL ("type");                                          \
      __asm ("" : "=r" (ptype) : "0" (&ttype), "r" (&texpr));  \
      if (&texpr == ptype)                              \
       FAIL ("type");                                          \
    }                                                   \
  while (0)
#define TEST2(expr, type, rettype, fn) \
  do                                                    \
    {                                                   \
      __typeof__ (expr) texpr = 0;                      \
      TEST_TYPE_ONLY (expr, rettype);                          \
      if (count != 0)                                          \
       FAIL ("internal error");                         \
      if (counts[T##type][C_##fn] != 0)                        \
       FAIL ("internal error");                         \
      texpr = expr;                                     \
      __asm __volatile ("" : : "r" (&texpr));                  \
      if (count != 1 || counts[T##type][C_##fn] != 1)          \
       {                                                \
         FAIL ("wrong function called");                \
         memset (counts, 0, sizeof (counts));                  \
       }                                                \
      count = 0;                                        \
      counts[T##type][C_##fn] = 0;                      \
    }                                                   \
  while (0)
#define TEST(expr, type, fn) TEST2(expr, type, type, fn)

  TEST (cos (vfloat1), float, cos);
  TEST (cos (vdouble1), double, cos);
  TEST (cos (vldouble1), ldouble, cos);
  TEST (cos (vint1), double, cos);
  TEST (cos (vllong1), double, cos);
  TEST (cos (vcfloat1), cfloat, cos);
  TEST (cos (vcdouble1), cdouble, cos);
  TEST (cos (vcldouble1), cldouble, cos);
  TEST (cos (Vfloat1), float, cos);
  TEST (cos (Vdouble1), double, cos);
  TEST (cos (Vldouble1), ldouble, cos);
  TEST (cos (Vint1), double, cos);
  TEST (cos (Vllong1), double, cos);
  TEST (cos (Vcfloat1), cfloat, cos);
  TEST (cos (Vcdouble1), cdouble, cos);
  TEST (cos (Vcldouble1), cldouble, cos);

  TEST (fabs (vfloat1), float, fabs);
  TEST (fabs (vdouble1), double, fabs);
  TEST (fabs (vldouble1), ldouble, fabs);
  TEST (fabs (vint1), double, fabs);
  TEST (fabs (vllong1), double, fabs);
  TEST (fabs (vcfloat1), float, cabs);
  TEST (fabs (vcdouble1), double, cabs);
  TEST (fabs (vcldouble1), ldouble, cabs);
  TEST (fabs (Vfloat1), float, fabs);
  TEST (fabs (Vdouble1), double, fabs);
  TEST (fabs (Vldouble1), ldouble, fabs);
#ifndef __OPTIMIZE__
  /* GCC is too smart to optimize these out.  */
  TEST (fabs (Vint1), double, fabs);
  TEST (fabs (Vllong1), double, fabs);
#else
  TEST_TYPE_ONLY (fabs (vllong1), double);
  TEST_TYPE_ONLY (fabs (vllong1), double);
#endif
  TEST (fabs (Vint4), double, fabs);
  TEST (fabs (Vllong4), double, fabs);
  TEST (fabs (Vcfloat1), float, cabs);
  TEST (fabs (Vcdouble1), double, cabs);
  TEST (fabs (Vcldouble1), ldouble, cabs);

  TEST (conj (vfloat1), cfloat, conj);
  TEST (conj (vdouble1), cdouble, conj);
  TEST (conj (vldouble1), cldouble, conj);
  TEST (conj (vint1), cdouble, conj);
  TEST (conj (vllong1), cdouble, conj);
  TEST (conj (vcfloat1), cfloat, conj);
  TEST (conj (vcdouble1), cdouble, conj);
  TEST (conj (vcldouble1), cldouble, conj);
  TEST (conj (Vfloat1), cfloat, conj);
  TEST (conj (Vdouble1), cdouble, conj);
  TEST (conj (Vldouble1), cldouble, conj);
  TEST (conj (Vint1), cdouble, conj);
  TEST (conj (Vllong1), cdouble, conj);
  TEST (conj (Vcfloat1), cfloat, conj);
  TEST (conj (Vcdouble1), cdouble, conj);
  TEST (conj (Vcldouble1), cldouble, conj);

  TEST (expm1 (vfloat1), float, expm1);
  TEST (expm1 (vdouble1), double, expm1);
  TEST (expm1 (vldouble1), ldouble, expm1);
  TEST (expm1 (vint1), double, expm1);
  TEST (expm1 (vllong1), double, expm1);
  TEST (expm1 (Vfloat1), float, expm1);
  TEST (expm1 (Vdouble1), double, expm1);
  TEST (expm1 (Vldouble1), ldouble, expm1);
  TEST (expm1 (Vint1), double, expm1);
  TEST (expm1 (Vllong1), double, expm1);

  TEST2 (lrint (vfloat1), float, long int, lrint);
  TEST2 (lrint (vdouble1), double, long int, lrint);
  TEST2 (lrint (vldouble1), ldouble, long int, lrint);
  TEST2 (lrint (vint1), double, long int, lrint);
  TEST2 (lrint (vllong1), double, long int, lrint);
  TEST2 (lrint (Vfloat1), float, long int, lrint);
  TEST2 (lrint (Vdouble1), double, long int, lrint);
  TEST2 (lrint (Vldouble1), ldouble, long int, lrint);
  TEST2 (lrint (Vint1), double, long int, lrint);
  TEST2 (lrint (Vllong1), double, long int, lrint);

  TEST (ldexp (vfloat1, 6), float, ldexp);
  TEST (ldexp (vdouble1, 6), double, ldexp);
  TEST (ldexp (vldouble1, 6), ldouble, ldexp);
  TEST (ldexp (vint1, 6), double, ldexp);
  TEST (ldexp (vllong1, 6), double, ldexp);
  TEST (ldexp (Vfloat1, 6), float, ldexp);
  TEST (ldexp (Vdouble1, 6), double, ldexp);
  TEST (ldexp (Vldouble1, 6), ldouble, ldexp);
  TEST (ldexp (Vint1, 6), double, ldexp);
  TEST (ldexp (Vllong1, 6), double, ldexp);

#define FIRST(x, y) (y, x)
#define SECOND(x, y) (x, y)
#define NON_LDBL_TEST(fn, argm, arg, type, fnt) \
  TEST (fn argm (arg, vfloat1), type, fnt); \
  TEST (fn argm (arg, vdouble1), type, fnt); \
  TEST (fn argm (arg, vint1), type, fnt); \
  TEST (fn argm (arg, vllong1), type, fnt); \
  TEST (fn argm (arg, Vfloat1), type, fnt); \
  TEST (fn argm (arg, Vdouble1), type, fnt); \
  TEST (fn argm (arg, Vint1), type, fnt); \
  TEST (fn argm (arg, Vllong1), type, fnt);
#define NON_LDBL_CTEST(fn, argm, arg, type, fnt) \
  NON_LDBL_TEST(fn, argm, arg, type, fnt); \
  TEST (fn argm (arg, vcfloat1), type, fnt); \
  TEST (fn argm (arg, vcdouble1), type, fnt); \
  TEST (fn argm (arg, Vcfloat1), type, fnt); \
  TEST (fn argm (arg, Vcdouble1), type, fnt);
#define BINARY_TEST(fn, fnt) \
  TEST (fn (vfloat1, vfloat2), float, fnt); \
  TEST (fn (Vfloat1, vfloat2), float, fnt); \
  TEST (fn (vfloat1, Vfloat2), float, fnt); \
  TEST (fn (Vfloat1, Vfloat2), float, fnt); \
  TEST (fn (vldouble1, vldouble2), ldouble, fnt); \
  TEST (fn (Vldouble1, vldouble2), ldouble, fnt); \
  TEST (fn (vldouble1, Vldouble2), ldouble, fnt); \
  TEST (fn (Vldouble1, Vldouble2), ldouble, fnt); \
  NON_LDBL_TEST (fn, FIRST, vldouble2, ldouble, fnt); \
  NON_LDBL_TEST (fn, SECOND, vldouble2, ldouble, fnt); \
  NON_LDBL_TEST (fn, FIRST, Vldouble2, ldouble, fnt); \
  NON_LDBL_TEST (fn, SECOND, Vldouble2, ldouble, fnt); \
  NON_LDBL_TEST (fn, FIRST, vdouble2, double, fnt); \
  NON_LDBL_TEST (fn, SECOND, vdouble2, double, fnt); \
  NON_LDBL_TEST (fn, FIRST, Vdouble2, double, fnt); \
  NON_LDBL_TEST (fn, SECOND, Vdouble2, double, fnt); \
  NON_LDBL_TEST (fn, FIRST, vint2, double, fnt); \
  NON_LDBL_TEST (fn, SECOND, vint2, double, fnt); \
  NON_LDBL_TEST (fn, FIRST, Vint2, double, fnt); \
  NON_LDBL_TEST (fn, SECOND, Vint2, double, fnt); \
  NON_LDBL_TEST (fn, FIRST, vllong2, double, fnt); \
  NON_LDBL_TEST (fn, SECOND, vllong2, double, fnt); \
  NON_LDBL_TEST (fn, FIRST, Vllong2, double, fnt); \
  NON_LDBL_TEST (fn, SECOND, Vllong2, double, fnt);
#define BINARY_CTEST(fn, fnt) \
  BINARY_TEST (fn, fnt); \
  TEST (fn (vcfloat1, vfloat2), cfloat, fnt); \
  TEST (fn (Vcfloat1, vfloat2), cfloat, fnt); \
  TEST (fn (vcfloat1, Vfloat2), cfloat, fnt); \
  TEST (fn (Vcfloat1, Vfloat2), cfloat, fnt); \
  TEST (fn (vcldouble1, vldouble2), cldouble, fnt); \
  TEST (fn (Vcldouble1, vldouble2), cldouble, fnt); \
  TEST (fn (vcldouble1, Vldouble2), cldouble, fnt); \
  TEST (fn (Vcldouble1, Vldouble2), cldouble, fnt); \
  TEST (fn (vcfloat1, vfloat2), cfloat, fnt); \
  TEST (fn (Vcfloat1, vfloat2), cfloat, fnt); \
  TEST (fn (vcfloat1, Vfloat2), cfloat, fnt); \
  TEST (fn (Vcfloat1, Vfloat2), cfloat, fnt); \
  TEST (fn (vcldouble1, vldouble2), cldouble, fnt); \
  TEST (fn (Vcldouble1, vldouble2), cldouble, fnt); \
  TEST (fn (vcldouble1, Vldouble2), cldouble, fnt); \
  TEST (fn (Vcldouble1, Vldouble2), cldouble, fnt); \
  TEST (fn (vcfloat1, vcfloat2), cfloat, fnt); \
  TEST (fn (Vcfloat1, vcfloat2), cfloat, fnt); \
  TEST (fn (vcfloat1, Vcfloat2), cfloat, fnt); \
  TEST (fn (Vcfloat1, Vcfloat2), cfloat, fnt); \
  TEST (fn (vcldouble1, vcldouble2), cldouble, fnt); \
  TEST (fn (Vcldouble1, vcldouble2), cldouble, fnt); \
  TEST (fn (vcldouble1, Vcldouble2), cldouble, fnt); \
  TEST (fn (Vcldouble1, Vcldouble2), cldouble, fnt); \
  NON_LDBL_CTEST (fn, FIRST, vcldouble2, cldouble, fnt); \
  NON_LDBL_CTEST (fn, SECOND, vcldouble2, cldouble, fnt); \
  NON_LDBL_CTEST (fn, FIRST, Vcldouble2, cldouble, fnt); \
  NON_LDBL_CTEST (fn, SECOND, Vcldouble2, cldouble, fnt); \
  NON_LDBL_CTEST (fn, FIRST, vcdouble2, cdouble, fnt); \
  NON_LDBL_CTEST (fn, SECOND, vcdouble2, cdouble, fnt); \
  NON_LDBL_CTEST (fn, FIRST, Vcdouble2, cdouble, fnt); \
  NON_LDBL_CTEST (fn, SECOND, Vcdouble2, cdouble, fnt);

  BINARY_TEST (atan2, atan2);

#define my_remquo(x, y) remquo (x, y, &quo)
  BINARY_TEST (my_remquo, remquo);
#undef my_remquo

  BINARY_CTEST (pow, pow);

  /* Testing all arguments of fma would be just too expensive,
     so test just some.  */
#define my_fma(x, y) fma (x, y, vfloat3)
  BINARY_TEST (my_fma, fma);
#undef my_fma
#define my_fma(x, y) fma (x, vfloat3, y)
  BINARY_TEST (my_fma, fma);
#undef my_fma
#define my_fma(x, y) fma (Vfloat3, x, y)
  BINARY_TEST (my_fma, fma);
#undef my_fma
  TEST (fma (vdouble1, Vdouble2, vllong3), double, fma);
  TEST (fma (vint1, Vint2, vint3), double, fma);
  TEST (fma (Vldouble1, vldouble2, Vldouble3), ldouble, fma);
  TEST (fma (vldouble1, vint2, Vdouble3), ldouble, fma);

  return result;
}

Here is the call graph for this function:


Variable Documentation

Definition at line 90 of file test-tgmath2.c.

Definition at line 91 of file test-tgmath2.c.

Definition at line 46 of file test-tgmath2.c.

Definition at line 55 of file test-tgmath2.c.

Definition at line 46 of file test-tgmath2.c.

Definition at line 55 of file test-tgmath2.c.

Definition at line 46 of file test-tgmath2.c.

Definition at line 55 of file test-tgmath2.c.

Definition at line 45 of file test-tgmath2.c.

Definition at line 54 of file test-tgmath2.c.

Definition at line 45 of file test-tgmath2.c.

Definition at line 54 of file test-tgmath2.c.

Definition at line 45 of file test-tgmath2.c.

Definition at line 54 of file test-tgmath2.c.

Definition at line 47 of file test-tgmath2.c.

Definition at line 56 of file test-tgmath2.c.

Definition at line 47 of file test-tgmath2.c.

Definition at line 56 of file test-tgmath2.c.

Definition at line 47 of file test-tgmath2.c.

Definition at line 56 of file test-tgmath2.c.

double vdouble1

Definition at line 43 of file test-tgmath2.c.

const double Vdouble1 = 1

Definition at line 52 of file test-tgmath2.c.

double vdouble2

Definition at line 43 of file test-tgmath2.c.

const double Vdouble2 = 2

Definition at line 52 of file test-tgmath2.c.

double vdouble3

Definition at line 43 of file test-tgmath2.c.

const double Vdouble3 = 3

Definition at line 52 of file test-tgmath2.c.

float vfloat1

Definition at line 42 of file test-tgmath2.c.

const float Vfloat1 = 1

Definition at line 51 of file test-tgmath2.c.

float vfloat2

Definition at line 42 of file test-tgmath2.c.

const float Vfloat2 = 2

Definition at line 51 of file test-tgmath2.c.

float vfloat3

Definition at line 42 of file test-tgmath2.c.

const float Vfloat3 = 3

Definition at line 51 of file test-tgmath2.c.

Definition at line 48 of file test-tgmath2.c.

Definition at line 57 of file test-tgmath2.c.

Definition at line 48 of file test-tgmath2.c.

Definition at line 57 of file test-tgmath2.c.

Definition at line 48 of file test-tgmath2.c.

Definition at line 57 of file test-tgmath2.c.

Definition at line 44 of file test-tgmath2.c.

Definition at line 53 of file test-tgmath2.c.

Definition at line 44 of file test-tgmath2.c.

Definition at line 53 of file test-tgmath2.c.

Definition at line 44 of file test-tgmath2.c.

Definition at line 53 of file test-tgmath2.c.

long long int vllong1

Definition at line 50 of file test-tgmath2.c.

const long long int Vllong1 = 1

Definition at line 59 of file test-tgmath2.c.

long long int vllong2

Definition at line 50 of file test-tgmath2.c.

const long long int Vllong2 = 2

Definition at line 59 of file test-tgmath2.c.

long long int vllong3

Definition at line 50 of file test-tgmath2.c.

const long long int Vllong3 = 3

Definition at line 59 of file test-tgmath2.c.

long int vlong1

Definition at line 49 of file test-tgmath2.c.

const long int Vlong1 = 1

Definition at line 58 of file test-tgmath2.c.

long int vlong2

Definition at line 49 of file test-tgmath2.c.

const long int Vlong2 = 2

Definition at line 58 of file test-tgmath2.c.

long int vlong3

Definition at line 49 of file test-tgmath2.c.

const long int Vlong3 = 3

Definition at line 58 of file test-tgmath2.c.