/* Generate expected output for libm tests with MPFR and MPC.

   Copyright (C) 2013-2018 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public

   License as published by the Free Software Foundation; either

   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with the GNU C Library; if not, see

   <http://www.gnu.org/licenses/>.  */

/* Compile this program as:

   gcc -std=gnu11 -O2 -Wall -Wextra gen-auto-libm-tests.c -lmpc -lmpfr -lgmp \

     -o gen-auto-libm-tests

   (use of current MPC and MPFR versions recommended) and run it as:

   gen-auto-libm-tests auto-libm-test-in <func> auto-libm-test-out-<func>

   to generate results for normal libm functions, or

   gen-auto-libm-tests --narrow auto-libm-test-in <func> \

     auto-libm-test-out-narrow-<func>

   to generate results for a function rounding results to a narrower

   type (in the case of fma and sqrt, both output files are generated

   from the same test inputs).

   The input file auto-libm-test-in contains three kinds of lines:

   Lines beginning with "#" are comments, and are ignored, as are

   empty lines.

   Other lines are test lines, of the form "function input1 input2

   ... [flag1 flag2 ...]".  Inputs are either finite real numbers or

   integers, depending on the function under test.  Real numbers may

   be in any form acceptable to mpfr_strtofr (base 0); integers in any

   form acceptable to mpz_set_str (base 0).  In addition, real numbers

   may be certain special strings such as "pi", as listed in the

   special_real_inputs array.

   Each flag is a flag name possibly followed by a series of

   ":condition".  Conditions may be any of the names of floating-point

   formats in the floating_point_formats array, "long32" and "long64"

   to indicate the number of bits in the "long" type, or other strings

   for which libm-test.inc defines a TEST_COND_<condition> macro (with

   "-"- changed to "_" in the condition name) evaluating to nonzero

   when the condition is true and zero when the condition is false.

   The meaning is that the flag applies to the test if all the listed

   conditions are true.  "flag:cond1:cond2 flag:cond3:cond4" means the

   flag applies if ((cond1 && cond2) || (cond3 && cond4)).

   A real number specified as an input is considered to represent the

   set of real numbers arising from rounding the given number in any

   direction for any supported floating-point format; any roundings

   that give infinity are ignored.  Each input on a test line has all

   the possible roundings considered independently.  Each resulting

   choice of the tuple of inputs to the function is ignored if the

   mathematical result of the function involves a NaN or an exact

   infinity, and is otherwise considered for each floating-point

   format for which all those inputs are exactly representable.  Thus

   tests may result in "overflow", "underflow" and "inexact"

   exceptions; "invalid" may arise only when the final result type is

   an integer type and it is the conversion of a mathematically

   defined finite result to integer type that results in that

   exception.

   By default, it is assumed that "overflow" and "underflow"

   exceptions should be correct, but that "inexact" exceptions should

   only be correct for functions listed as exactly determined.  For

   such functions, "underflow" exceptions should respect whether the

   machine has before-rounding or after-rounding tininess detection.

   For other functions, it is considered that if the exact result is

   somewhere between the greatest magnitude subnormal of a given sign

   (exclusive) and the least magnitude normal of that sign

   (inclusive), underflow exceptions are permitted but optional on all

   machines, and they are also permitted but optional for smaller

   subnormal exact results for functions that are not exactly

   determined.  errno setting is expected for overflow to infinity and

   underflow to zero (for real functions), and for out-of-range

   conversion of a finite result to integer type, and is considered

   permitted but optional for all other cases where overflow

   exceptions occur, and where underflow exceptions occur or are

   permitted.  In other cases (where no overflow or underflow is

   permitted), errno is expected to be left unchanged.

   The flag "no-test-inline" indicates a test is disabled for inline

   function testing; "ignore-zero-inf-sign" indicates the the signs of

   zero and infinite results should be ignored; "xfail" indicates the

   test is disabled as expected to produce incorrect results,

   "xfail-rounding" indicates the test is disabled only in rounding

   modes other than round-to-nearest.  Otherwise, test flags are of

   the form "spurious-<exception>" and "missing-<exception>", for any

   exception ("overflow", "underflow", "inexact", "invalid",

   "divbyzero"), "spurious-errno" and "missing-errno", to indicate

   when tests are expected to deviate from the exception and errno

   settings corresponding to the mathematical results.  "xfail",

   "xfail-rounding", "spurious-" and "missing-" flags should be

   accompanied by a comment referring to an open bug in glibc

   Bugzilla.

   The output file auto-libm-test-out-<func> contains the test lines from

   auto-libm-test-in, and, after the line for a given test, some

   number of output test lines.  An output test line is of the form "=

   function rounding-mode format input1 input2 ... : output1 output2

   ... : flags".  rounding-mode is "tonearest", "towardzero", "upward"

   or "downward".  format is a name from the floating_point_formats

   array, possibly followed by a sequence of ":flag" for flags from

   "long32" and "long64".  Inputs and outputs are specified as hex

   floats with the required suffix for the floating-point type, or

   plus_infty or minus_infty for infinite expected results, or as

   integer constant expressions (not necessarily with the right type)

   or IGNORE for integer inputs and outputs.  Flags are

   "no-test-inline", "ignore-zero-info-sign", "xfail", "<exception>",

   "<exception>-ok", "errno-<value>", "errno-<value>-ok", which may be

   unconditional or conditional.  "<exception>" indicates that a

   correct result means the given exception should be raised.

   "errno-<value>" indicates that a correct result means errno should

   be set to the given value.  "-ok" means not to test for the given

   exception or errno value (whether because it was marked as possibly

   missing or spurious, or because the calculation of correct results

   indicated it was optional).  Conditions "before-rounding" and

   "after-rounding" indicate tests where expectations for underflow

   exceptions depend on how the architecture detects tininess.

   For functions rounding their results to a narrower type, the format

   given on an output test line is the result format followed by

   information about the requirements on the argument format to be

   able to represent the argument values, in the form

   "format:arg_fmt(MAX_EXP,NUM_ONES,MIN_EXP,MAX_PREC)".  Instead of

   separate lines for separate argument formats, an output test line

   relates to all argument formats that can represent the values.

   MAX_EXP is the maximum exponent of a nonzero bit in any argument,

   or 0 if all arguments are zero; NUM_ONES is the maximum number of

   leading bits with value 1 in an argument with exponent MAX_EXP, or

   0 if all arguments are zero; MIN_EXP is the minimum exponent of a

   nonzero bit in any argument, or 0 if all arguments are zero;

   MAX_PREC is the maximum precision required to represent all

   arguments, or 0 if all arguments are zero.  */

#define _GNU_SOURCE

#include <assert.h>

#include <ctype.h>

#include <errno.h>

#include <error.h>

#include <stdbool.h>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <gmp.h>

#include <mpfr.h>

#include <mpc.h>

#define ARRAY_SIZE(A) (sizeof (A) / sizeof ((A)[0]))

/* The supported floating-point formats.  */

typedef enum

  {

    fp_flt_32,

    fp_dbl_64,

    fp_ldbl_96_intel,

    fp_ldbl_96_m68k,

    fp_ldbl_128,

    fp_ldbl_128ibm,

    fp_num_formats,

    fp_first_format = 0

  } fp_format;

/* Structure describing a single floating-point format.  */

typedef struct

{

  /* The name of the format.  */

  const char *name;

  /* A string for the largest normal value, or NULL for IEEE formats

     where this can be determined automatically.  */

  const char *max_string;

  /* The number of mantissa bits.  */

  int mant_dig;

  /* The least N such that 2^N overflows.  */

  int max_exp;

  /* One more than the least N such that 2^N is normal.  */

  int min_exp;

  /* The largest normal value.  */

  mpfr_t max;

  /* The value 0.5ulp above the least positive normal value.  */

  mpfr_t min_plus_half;

  /* The least positive normal value, 2^(MIN_EXP-1).  */

  mpfr_t min;

  /* The greatest positive subnormal value.  */

  mpfr_t subnorm_max;

  /* The least positive subnormal value, 2^(MIN_EXP-MANT_DIG).  */

  mpfr_t subnorm_min;

} fp_format_desc;

/* List of floating-point formats, in the same order as the fp_format

   enumeration.  */

static fp_format_desc fp_formats[fp_num_formats] =

  {

    { "binary32", NULL, 24, 128, -125, {}, {}, {}, {}, {} },

    { "binary64", NULL, 53, 1024, -1021, {}, {}, {}, {}, {} },

    { "intel96", NULL, 64, 16384, -16381, {}, {}, {}, {}, {} },

    { "m68k96", NULL, 64, 16384, -16382, {}, {}, {}, {}, {} },

    { "binary128", NULL, 113, 16384, -16381, {}, {}, {}, {}, {} },

    { "ibm128", "0x1.fffffffffffff7ffffffffffff8p+1023",

      106, 1024, -968, {}, {}, {}, {}, {} },

  };

/* The supported rounding modes.  */

typedef enum

  {

    rm_downward,

    rm_tonearest,

    rm_towardzero,

    rm_upward,

    rm_num_modes,

    rm_first_mode = 0

  } rounding_mode;

/* Structure describing a single rounding mode.  */

typedef struct

{

  /* The name of the rounding mode.  */

  const char *name;

  /* The MPFR rounding mode.  */

  mpfr_rnd_t mpfr_mode;

  /* The MPC rounding mode.  */

  mpc_rnd_t mpc_mode;

} rounding_mode_desc;

/* List of rounding modes, in the same order as the rounding_mode

   enumeration.  */

static const rounding_mode_desc rounding_modes[rm_num_modes] =

  {

    { "downward", MPFR_RNDD, MPC_RNDDD },

    { "tonearest", MPFR_RNDN, MPC_RNDNN },

    { "towardzero", MPFR_RNDZ, MPC_RNDZZ },

    { "upward", MPFR_RNDU, MPC_RNDUU },

  };

/* The supported exceptions.  */

typedef enum

  {

    exc_divbyzero,

    exc_inexact,

    exc_invalid,

    exc_overflow,

    exc_underflow,

    exc_num_exceptions,

    exc_first_exception = 0

  } fp_exception;

/* List of exceptions, in the same order as the fp_exception

   enumeration.  */

static const char *const exceptions[exc_num_exceptions] =

  {

    "divbyzero",

    "inexact",

    "invalid",

    "overflow",

    "underflow",

  };

/* The internal precision to use for most MPFR calculations, which

   must be at least 2 more than the greatest precision of any

   supported floating-point format.  */

static int internal_precision;

/* A value that overflows all supported floating-point formats.  */

static mpfr_t global_max;

/* A value that is at most half the least subnormal in any

   floating-point format and so is rounded the same way as all

   sufficiently small positive values.  */

static mpfr_t global_min;

/* The maximum number of (real or integer) arguments to a function

   handled by this program (complex arguments count as two real

   arguments).  */

#define MAX_NARGS 4

/* The maximum number of (real or integer) return values from a

   function handled by this program.  */

#define MAX_NRET 2

/* A type of a function argument or return value.  */

typedef enum

  {

    /* No type (not a valid argument or return value).  */

    type_none,

    /* A floating-point value with the type corresponding to that of

       the function.  */

    type_fp,

    /* An integer value of type int.  */

    type_int,

    /* An integer value of type long.  */

    type_long,

    /* An integer value of type long long.  */

    type_long_long,

  } arg_ret_type;

/* A type of a generic real or integer value.  */

typedef enum

  {

    /* No type.  */

    gtype_none,

    /* Floating-point (represented with MPFR).  */

    gtype_fp,

    /* Integer (represented with GMP).  */

    gtype_int,

  } generic_value_type;

/* A generic value (argument or result).  */

typedef struct

{

  /* The type of this value.  */

  generic_value_type type;

  /* Its value.  */

  union

  {

    mpfr_t f;

    mpz_t i;

  } value;

} generic_value;

/* A type of input flag.  */

typedef enum

  {

    flag_no_test_inline,

    flag_ignore_zero_inf_sign,

    flag_xfail,

    flag_xfail_rounding,

    /* The "spurious" and "missing" flags must be in the same order as

       the fp_exception enumeration.  */

    flag_spurious_divbyzero,

    flag_spurious_inexact,

    flag_spurious_invalid,

    flag_spurious_overflow,

    flag_spurious_underflow,

    flag_spurious_errno,

    flag_missing_divbyzero,

    flag_missing_inexact,

    flag_missing_invalid,

    flag_missing_overflow,

    flag_missing_underflow,

    flag_missing_errno,

    num_input_flag_types,

    flag_first_flag = 0,

    flag_spurious_first = flag_spurious_divbyzero,

    flag_missing_first = flag_missing_divbyzero

  } input_flag_type;

/* List of flags, in the same order as the input_flag_type

   enumeration.  */

static const char *const input_flags[num_input_flag_types] =

  {

    "no-test-inline",

    "ignore-zero-inf-sign",

    "xfail",

    "xfail-rounding",

    "spurious-divbyzero",

    "spurious-inexact",

    "spurious-invalid",

    "spurious-overflow",

    "spurious-underflow",

    "spurious-errno",

    "missing-divbyzero",

    "missing-inexact",

    "missing-invalid",

    "missing-overflow",

    "missing-underflow",

    "missing-errno",

  };

/* An input flag, possibly conditional.  */

typedef struct

{

  /* The type of this flag.  */

  input_flag_type type;

  /* The conditions on this flag, as a string ":cond1:cond2..." or

     NULL.  */

  const char *cond;

} input_flag;

/* Structure describing a single test from the input file (which may

   expand into many tests in the output).  The choice of function,

   which implies the numbers and types of arguments and results, is

   implicit rather than stored in this structure (except as part of

   the source line).  */

typedef struct

{

  /* The text of the input line describing the test, including the

     trailing newline.  */

  const char *line;

  /* The number of combinations of interpretations of input values for

     different floating-point formats and rounding modes.  */

  size_t num_input_cases;

  /* The corresponding lists of inputs.  */

  generic_value **inputs;

  /* The number of flags for this test.  */

  size_t num_flags;

  /* The corresponding list of flags.  */

  input_flag *flags;

  /* The old output for this test.  */

  const char *old_output;

} input_test;

/* Ways to calculate a function.  */

typedef enum

  {

    /* MPFR function with a single argument and result.  */

    mpfr_f_f,

    /* MPFR function with two arguments and one result.  */

    mpfr_ff_f,

    /* MPFR function with three arguments and one result.  */

    mpfr_fff_f,

    /* MPFR function with a single argument and floating-point and

       integer results.  */

    mpfr_f_f1,

    /* MPFR function with integer and floating-point arguments and one

       result.  */

    mpfr_if_f,

    /* MPFR function with a single argument and two floating-point

       results.  */

    mpfr_f_11,

    /* MPC function with a single complex argument and one real

       result.  */

    mpc_c_f,

    /* MPC function with a single complex argument and one complex

       result.  */

    mpc_c_c,

    /* MPC function with two complex arguments and one complex

       result.  */

    mpc_cc_c,

  } func_calc_method;

/* Description of how to calculate a function.  */

typedef struct

{

  /* Which method is used to calculate the function.  */

  func_calc_method method;

  /* The specific function called.  */

  union

  {

    int (*mpfr_f_f) (mpfr_t, const mpfr_t, mpfr_rnd_t);

    int (*mpfr_ff_f) (mpfr_t, const mpfr_t, const mpfr_t, mpfr_rnd_t);

    int (*mpfr_fff_f) (mpfr_t, const mpfr_t, const mpfr_t, const mpfr_t,

		       mpfr_rnd_t);

    int (*mpfr_f_f1) (mpfr_t, int *, const mpfr_t, mpfr_rnd_t);

    int (*mpfr_if_f) (mpfr_t, long, const mpfr_t, mpfr_rnd_t);

    int (*mpfr_f_11) (mpfr_t, mpfr_t, const mpfr_t, mpfr_rnd_t);

    int (*mpc_c_f) (mpfr_t, const mpc_t, mpfr_rnd_t);

    int (*mpc_c_c) (mpc_t, const mpc_t, mpc_rnd_t);

    int (*mpc_cc_c) (mpc_t, const mpc_t, const mpc_t, mpc_rnd_t);

  } func;

} func_calc_desc;

/* Structure describing a function handled by this program.  */

typedef struct

{

  /* The name of the function.  */

  const char *name;

  /* The number of arguments.  */

  size_t num_args;

  /* The types of the arguments.  */

  arg_ret_type arg_types[MAX_NARGS];

  /* The number of return values.  */

  size_t num_ret;

  /* The types of the return values.  */

  arg_ret_type ret_types[MAX_NRET];

  /* Whether the function has exactly determined results and

     exceptions.  */

  bool exact;

  /* Whether the function is a complex function, so errno setting is

     optional.  */

  bool complex_fn;

  /* Whether to treat arguments given as floating-point constants as

     exact only, rather than rounding them up and down to all

     formats.  */

  bool exact_args;

  /* How to calculate this function.  */

  func_calc_desc calc;

  /* The number of tests allocated for this function.  */

  size_t num_tests_alloc;

  /* The number of tests for this function.  */

  size_t num_tests;

  /* The tests themselves.  */

  input_test *tests;

} test_function;

#define ARGS1(T1) 1, { T1 }

#define ARGS2(T1, T2) 2, { T1, T2 }

#define ARGS3(T1, T2, T3) 3, { T1, T2, T3 }

#define ARGS4(T1, T2, T3, T4) 4, { T1, T2, T3, T4 }

#define RET1(T1) 1, { T1 }

#define RET2(T1, T2) 2, { T1, T2 }

#define CALC(TYPE, FN) { TYPE, { .TYPE = FN } }

#define FUNC(NAME, ARGS, RET, EXACT, COMPLEX_FN, EXACT_ARGS, CALC)	\

  {									\

    NAME, ARGS, RET, EXACT, COMPLEX_FN, EXACT_ARGS, CALC, 0, 0, NULL	\

  }

#define FUNC_mpfr_f_f(NAME, MPFR_FUNC, EXACT)				\

  FUNC (NAME, ARGS1 (type_fp), RET1 (type_fp), EXACT, false, false,	\

	CALC (mpfr_f_f, MPFR_FUNC))

#define FUNC_mpfr_ff_f(NAME, MPFR_FUNC, EXACT)				\

  FUNC (NAME, ARGS2 (type_fp, type_fp), RET1 (type_fp), EXACT, false,	\

	false, CALC (mpfr_ff_f, MPFR_FUNC))

#define FUNC_mpfr_if_f(NAME, MPFR_FUNC, EXACT)				\

  FUNC (NAME, ARGS2 (type_int, type_fp), RET1 (type_fp), EXACT, false,	\

	false, CALC (mpfr_if_f, MPFR_FUNC))

#define FUNC_mpc_c_f(NAME, MPFR_FUNC, EXACT)				\

  FUNC (NAME, ARGS2 (type_fp, type_fp), RET1 (type_fp), EXACT, true,	\

	false, CALC (mpc_c_f, MPFR_FUNC))

#define FUNC_mpc_c_c(NAME, MPFR_FUNC, EXACT)				\

  FUNC (NAME, ARGS2 (type_fp, type_fp), RET2 (type_fp, type_fp), EXACT, \

	true, false, CALC (mpc_c_c, MPFR_FUNC))

/* List of functions handled by this program.  */

static test_function test_functions[] =

  {

    FUNC_mpfr_f_f ("acos", mpfr_acos, false),

    FUNC_mpfr_f_f ("acosh", mpfr_acosh, false),

    FUNC_mpfr_ff_f ("add", mpfr_add, true),

    FUNC_mpfr_f_f ("asin", mpfr_asin, false),

    FUNC_mpfr_f_f ("asinh", mpfr_asinh, false),

    FUNC_mpfr_f_f ("atan", mpfr_atan, false),

    FUNC_mpfr_ff_f ("atan2", mpfr_atan2, false),

    FUNC_mpfr_f_f ("atanh", mpfr_atanh, false),

    FUNC_mpc_c_f ("cabs", mpc_abs, false),

    FUNC_mpc_c_c ("cacos", mpc_acos, false),

    FUNC_mpc_c_c ("cacosh", mpc_acosh, false),

    FUNC_mpc_c_f ("carg", mpc_arg, false),

    FUNC_mpc_c_c ("casin", mpc_asin, false),

    FUNC_mpc_c_c ("casinh", mpc_asinh, false),

    FUNC_mpc_c_c ("catan", mpc_atan, false),

    FUNC_mpc_c_c ("catanh", mpc_atanh, false),

    FUNC_mpfr_f_f ("cbrt", mpfr_cbrt, false),

    FUNC_mpc_c_c ("ccos", mpc_cos, false),

    FUNC_mpc_c_c ("ccosh", mpc_cosh, false),

    FUNC_mpc_c_c ("cexp", mpc_exp, false),

    FUNC_mpc_c_c ("clog", mpc_log, false),

    FUNC_mpc_c_c ("clog10", mpc_log10, false),

    FUNC_mpfr_f_f ("cos", mpfr_cos, false),

    FUNC_mpfr_f_f ("cosh", mpfr_cosh, false),

    FUNC ("cpow", ARGS4 (type_fp, type_fp, type_fp, type_fp),

	  RET2 (type_fp, type_fp), false, true, false,

	  CALC (mpc_cc_c, mpc_pow)),

    FUNC_mpc_c_c ("csin", mpc_sin, false),

    FUNC_mpc_c_c ("csinh", mpc_sinh, false),

    FUNC_mpc_c_c ("csqrt", mpc_sqrt, false),

    FUNC_mpc_c_c ("ctan", mpc_tan, false),

    FUNC_mpc_c_c ("ctanh", mpc_tanh, false),

    FUNC_mpfr_ff_f ("div", mpfr_div, true),

    FUNC_mpfr_f_f ("erf", mpfr_erf, false),

    FUNC_mpfr_f_f ("erfc", mpfr_erfc, false),

    FUNC_mpfr_f_f ("exp", mpfr_exp, false),

    FUNC_mpfr_f_f ("exp10", mpfr_exp10, false),

    FUNC_mpfr_f_f ("exp2", mpfr_exp2, false),

    FUNC_mpfr_f_f ("expm1", mpfr_expm1, false),

    FUNC ("fma", ARGS3 (type_fp, type_fp, type_fp), RET1 (type_fp),

	  true, false, true, CALC (mpfr_fff_f, mpfr_fma)),

    FUNC_mpfr_ff_f ("hypot", mpfr_hypot, false),

    FUNC_mpfr_f_f ("j0", mpfr_j0, false),

    FUNC_mpfr_f_f ("j1", mpfr_j1, false),

    FUNC_mpfr_if_f ("jn", mpfr_jn, false),

    FUNC ("lgamma", ARGS1 (type_fp), RET2 (type_fp, type_int), false, false,

	  false, CALC (mpfr_f_f1, mpfr_lgamma)),

    FUNC_mpfr_f_f ("log", mpfr_log, false),

    FUNC_mpfr_f_f ("log10", mpfr_log10, false),

    FUNC_mpfr_f_f ("log1p", mpfr_log1p, false),

    FUNC_mpfr_f_f ("log2", mpfr_log2, false),

    FUNC_mpfr_ff_f ("mul", mpfr_mul, true),

    FUNC_mpfr_ff_f ("pow", mpfr_pow, false),

    FUNC_mpfr_f_f ("sin", mpfr_sin, false),

    FUNC ("sincos", ARGS1 (type_fp), RET2 (type_fp, type_fp), false, false,

	  false, CALC (mpfr_f_11, mpfr_sin_cos)),

    FUNC_mpfr_f_f ("sinh", mpfr_sinh, false),

    FUNC_mpfr_ff_f ("sub", mpfr_sub, true),

    FUNC_mpfr_f_f ("sqrt", mpfr_sqrt, true),

    FUNC_mpfr_f_f ("tan", mpfr_tan, false),

    FUNC_mpfr_f_f ("tanh", mpfr_tanh, false),

    FUNC_mpfr_f_f ("tgamma", mpfr_gamma, false),

    FUNC_mpfr_f_f ("y0", mpfr_y0, false),

    FUNC_mpfr_f_f ("y1", mpfr_y1, false),

    FUNC_mpfr_if_f ("yn", mpfr_yn, false),

  };

/* Allocate memory, with error checking.  */

static void *

xmalloc (size_t n)

{

  void *p = malloc (n);

  if (p == NULL)

    error (EXIT_FAILURE, errno, "xmalloc failed");

  return p;

}

static void *

xrealloc (void *p, size_t n)

{

  p = realloc (p, n);

  if (p == NULL)

    error (EXIT_FAILURE, errno, "xrealloc failed");

  return p;

}

static char *

xstrdup (const char *s)

{

  char *p = strdup (s);

  if (p == NULL)

    error (EXIT_FAILURE, errno, "xstrdup failed");

  return p;

}

/* Assert that the result of an MPFR operation was exact; that is,

   that the returned ternary value was 0.  */

static void

assert_exact (int i)

{

  assert (i == 0);

}

/* Return the generic type of an argument or return value type T.  */

static generic_value_type

generic_arg_ret_type (arg_ret_type t)

{

  switch (t)

    {

    case type_fp:

      return gtype_fp;

    case type_int:

    case type_long:

    case type_long_long:

      return gtype_int;

    default:

      abort ();

    }

}

/* Free a generic_value *V.  */

static void

generic_value_free (generic_value *v)

{

  switch (v->type)

    {

    case gtype_fp:

      mpfr_clear (v->value.f);

      break;

    case gtype_int:

      mpz_clear (v->value.i);

      break;

    default:

      abort ();

    }

}

/* Copy a generic_value *SRC to *DEST.  */

static void

generic_value_copy (generic_value *dest, const generic_value *src)

{

  dest->type = src->type;

  switch (src->type)

    {

    case gtype_fp:

      mpfr_init (dest->value.f);

      assert_exact (mpfr_set (dest->value.f, src->value.f, MPFR_RNDN));

      break;

    case gtype_int:

      mpz_init (dest->value.i);

      mpz_set (dest->value.i, src->value.i);

      break;

    default:

      abort ();

    }

}

/* Initialize data for floating-point formats.  */

static void

init_fp_formats (void)

{

  int global_max_exp = 0, global_min_subnorm_exp = 0;

  for (fp_format f = fp_first_format; f < fp_num_formats; f++)

    {

      if (fp_formats[f].mant_dig + 2 > internal_precision)

	internal_precision = fp_formats[f].mant_dig + 2;

      if (fp_formats[f].max_exp > global_max_exp)

	global_max_exp = fp_formats[f].max_exp;

      int min_subnorm_exp = fp_formats[f].min_exp - fp_formats[f].mant_dig;

      if (min_subnorm_exp < global_min_subnorm_exp)

	global_min_subnorm_exp = min_subnorm_exp;

      mpfr_init2 (fp_formats[f].max, fp_formats[f].mant_dig);

      if (fp_formats[f].max_string != NULL)

	{

	  char *ep = NULL;

	  assert_exact (mpfr_strtofr (fp_formats[f].max,

				      fp_formats[f].max_string,

				      &ep, 0, MPFR_RNDN));

	  assert (*ep == 0);

	}

      else

	{

	  assert_exact (mpfr_set_ui_2exp (fp_formats[f].max, 1,

					  fp_formats[f].max_exp,

					  MPFR_RNDN));

	  mpfr_nextbelow (fp_formats[f].max);

	}

      mpfr_init2 (fp_formats[f].min, fp_formats[f].mant_dig);

      assert_exact (mpfr_set_ui_2exp (fp_formats[f].min, 1,

				      fp_formats[f].min_exp - 1,

				      MPFR_RNDN));

      mpfr_init2 (fp_formats[f].min_plus_half, fp_formats[f].mant_dig + 1);

      assert_exact (mpfr_set (fp_formats[f].min_plus_half,

			      fp_formats[f].min, MPFR_RNDN));

      mpfr_nextabove (fp_formats[f].min_plus_half);

      mpfr_init2 (fp_formats[f].subnorm_max, fp_formats[f].mant_dig);

      assert_exact (mpfr_set (fp_formats[f].subnorm_max, fp_formats[f].min,

			      MPFR_RNDN));

      mpfr_nextbelow (fp_formats[f].subnorm_max);

      mpfr_nextbelow (fp_formats[f].subnorm_max);

      mpfr_init2 (fp_formats[f].subnorm_min, fp_formats[f].mant_dig);

      assert_exact (mpfr_set_ui_2exp (fp_formats[f].subnorm_min, 1,

				      min_subnorm_exp, MPFR_RNDN));

    }

  mpfr_set_default_prec (internal_precision);

  mpfr_init (global_max);

  assert_exact (mpfr_set_ui_2exp (global_max, 1, global_max_exp, MPFR_RNDN));

  mpfr_init (global_min);

  assert_exact (mpfr_set_ui_2exp (global_min, 1, global_min_subnorm_exp - 1,

				  MPFR_RNDN));

}

/* Fill in mpfr_t values for special strings in input arguments.  */

static size_t

special_fill_max (mpfr_t res0, mpfr_t res1 __attribute__ ((unused)),

		  fp_format format)

{

  mpfr_init2 (res0, fp_formats[format].mant_dig);

  assert_exact (mpfr_set (res0, fp_formats[format].max, MPFR_RNDN));

  return 1;

}

static size_t

special_fill_minus_max (mpfr_t res0, mpfr_t res1 __attribute__ ((unused)),

			fp_format format)

{

  mpfr_init2 (res0, fp_formats[format].mant_dig);

  assert_exact (mpfr_neg (res0, fp_formats[format].max, MPFR_RNDN));

  return 1;

}

static size_t

special_fill_min (mpfr_t res0, mpfr_t res1 __attribute__ ((unused)),

		  fp_format format)

{

  mpfr_init2 (res0, fp_formats[format].mant_dig);

  assert_exact (mpfr_set (res0, fp_formats[format].min, MPFR_RNDN));

  return 1;

}

static size_t

special_fill_minus_min (mpfr_t res0, mpfr_t res1 __attribute__ ((unused)),

			fp_format format)

{

  mpfr_init2 (res0, fp_formats[format].mant_dig);

  assert_exact (mpfr_neg (res0, fp_formats[format].min, MPFR_RNDN));

  return 1;

}

static size_t

special_fill_min_subnorm (mpfr_t res0, mpfr_t res1 __attribute__ ((unused)),

			  fp_format format)

{

  mpfr_init2 (res0, fp_formats[format].mant_dig);

  assert_exact (mpfr_set (res0, fp_formats[format].subnorm_min, MPFR_RNDN));

  return 1;

}

static size_t

special_fill_minus_min_subnorm (mpfr_t res0,

				mpfr_t res1 __attribute__ ((unused)),

				fp_format format)

{

  mpfr_init2 (res0, fp_formats[format].mant_dig);

  assert_exact (mpfr_neg (res0, fp_formats[format].subnorm_min, MPFR_RNDN));

  return 1;

}

static size_t

special_fill_min_subnorm_p120 (mpfr_t res0,

			       mpfr_t res1 __attribute__ ((unused)),

			       fp_format format)

{

  mpfr_init2 (res0, fp_formats[format].mant_dig);

  assert_exact (mpfr_mul_2ui (res0, fp_formats[format].subnorm_min,

			      120, MPFR_RNDN));

  return 1;

}

static size_t

special_fill_pi (mpfr_t res0, mpfr_t res1, fp_format format)

{

  mpfr_init2 (res0, fp_formats[format].mant_dig);

  mpfr_const_pi (res0, MPFR_RNDU);

  mpfr_init2 (res1, fp_formats[format].mant_dig);

  mpfr_const_pi (res1, MPFR_RNDD);

  return 2;

}

static size_t

special_fill_minus_pi (mpfr_t res0, mpfr_t res1, fp_format format)

{

  mpfr_init2 (res0, fp_formats[format].mant_dig);

  mpfr_const_pi (res0, MPFR_RNDU);

  assert_exact (mpfr_neg (res0, res0, MPFR_RNDN));

  mpfr_init2 (res1, fp_formats[format].mant_dig);

  mpfr_const_pi (res1, MPFR_RNDD);

  assert_exact (mpfr_neg (res1, res1, MPFR_RNDN));

  return 2;

}

static size_t

special_fill_pi_2 (mpfr_t res0, mpfr_t res1, fp_format format)

{

  mpfr_init2 (res0, fp_formats[format].mant_dig);

  mpfr_const_pi (res0, MPFR_RNDU);

  assert_exact (mpfr_div_ui (res0, res0, 2, MPFR_RNDN));

  mpfr_init2 (res1, fp_formats[format].mant_dig);

  mpfr_const_pi (res1, MPFR_RNDD);

  assert_exact (mpfr_div_ui (res1, res1, 2, MPFR_RNDN));

  return 2;

}

static size_t

special_fill_minus_pi_2 (mpfr_t res0, mpfr_t res1, fp_format format)

{

  mpfr_init2 (res0, fp_formats[format].mant_dig);

  mpfr_const_pi (res0, MPFR_RNDU);

  assert_exact (mpfr_div_ui (res0, res0, 2, MPFR_RNDN));

  assert_exact (mpfr_neg (res0, res0, MPFR_RNDN));

  mpfr_init2 (res1, fp_formats[format].mant_dig);

  mpfr_const_pi (res1, MPFR_RNDD);

  assert_exact (mpfr_div_ui (res1, res1, 2, MPFR_RNDN));

  assert_exact (mpfr_neg (res1, res1, MPFR_RNDN));

  return 2;

}

static size_t

special_fill_pi_4 (mpfr_t res0, mpfr_t res1, fp_format format)

{

  mpfr_init2 (res0, fp_formats[format].mant_dig);

  assert_exact (mpfr_set_si (res0, 1, MPFR_RNDN));

  mpfr_atan (res0, res0, MPFR_RNDU);

  mpfr_init2 (res1, fp_formats[format].mant_dig);

  assert_exact (mpfr_set_si (res1, 1, MPFR_RNDN));

  mpfr_atan (res1, res1, MPFR_RNDD);