* libdecnumber: Import decNumber sources from the dfp-branch.

From-SVN: r107629

ChangeLog

+2005-11-29  Ben Elliston  <bje@au.ibm.com>
+
+	* libdecnumber: Import decNumber sources from the dfp-branch.
+
 2005-11-21  Kean Johnston  <jkj@sco.com>
 
 	* config.sub, config.guess: Sync from upstream sources.

libdecnumber/ChangeLog

+2005-11-29  Ben Elliston  <bje@au.ibm.com>
+
+	* decimal32.h, decimal64.h, decimal128.h: New.
+        * decimal32.c, decimal64.c, decimal128.c: Likewise.
+	* decContext.c, decContext.h: Likewise.
+	* decUtility.c, decUtility.h: Likewise.
+	* decNumber.c, decNumber.h, decNumberLocal.h: Likewise.
+	* decDPD.h: Likewise.
+	* decLibrary.c, decRound.c: Likewise.

libdecnumber/decContext.c

+/* Decimal context module for the decNumber C Library.
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Contributed by IBM Corporation.  Author Mike Cowlishaw.
+
+   This file is part of GCC.
+
+   GCC is free software; you can redistribute it and/or modify it under
+   the terms of the GNU General Public License as published by the Free
+   Software Foundation; either version 2, or (at your option) any later
+   version.
+
+   GCC 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 General Public License
+   for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GCC; see the file COPYING.  If not, write to the Free
+   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
+
+/*  This module compirises the routines for handling the arithmetic
+    context structures. */
+
+#include <string.h>		/* for strcmp */
+#include "decContext.h"		/* context and base types */
+#include "decNumberLocal.h"	/* decNumber local types, etc. */
+
+/* ------------------------------------------------------------------ */
+/* decContextDefault -- initialize a context structure                */
+/*                                                                    */
+/*  context is the structure to be initialized                        */
+/*  kind selects the required set of default values, one of:          */
+/*      DEC_INIT_BASE       -- select ANSI X3-274 defaults            */
+/*      DEC_INIT_DECIMAL32  -- select IEEE 754r defaults, 32-bit      */
+/*      DEC_INIT_DECIMAL64  -- select IEEE 754r defaults, 64-bit      */
+/*      DEC_INIT_DECIMAL128 -- select IEEE 754r defaults, 128-bit     */
+/*      For any other value a valid context is returned, but with     */
+/*      Invalid_operation set in the status field.                    */
+/*  returns a context structure with the appropriate initial values.  */
+/* ------------------------------------------------------------------ */
+decContext *
+decContextDefault (decContext * context, Int kind)
+{
+  /* set defaults... */
+  context->digits = 9;		/* 9 digits */
+  context->emax = DEC_MAX_EMAX;	/* 9-digit exponents */
+  context->emin = DEC_MIN_EMIN;	/* .. balanced */
+  context->round = DEC_ROUND_HALF_UP;	/* 0.5 rises */
+  context->traps = DEC_Errors;	/* all but informational */
+  context->status = 0;		/* cleared */
+  context->clamp = 0;		/* no clamping */
+#if DECSUBSET
+  context->extended = 0;	/* cleared */
+#endif
+  switch (kind)
+    {
+    case DEC_INIT_BASE:
+      /* [use defaults] */
+      break;
+    case DEC_INIT_DECIMAL32:
+      context->digits = 7;	/* digits */
+      context->emax = 96;	/* Emax */
+      context->emin = -95;	/* Emin */
+      context->round = DEC_ROUND_HALF_EVEN;	/* 0.5 to nearest even */
+      context->traps = 0;	/* no traps set */
+      context->clamp = 1;	/* clamp exponents */
+#if DECSUBSET
+      context->extended = 1;	/* set */
+#endif
+      break;
+    case DEC_INIT_DECIMAL64:
+      context->digits = 16;	/* digits */
+      context->emax = 384;	/* Emax */
+      context->emin = -383;	/* Emin */
+      context->round = DEC_ROUND_HALF_EVEN;	/* 0.5 to nearest even */
+      context->traps = 0;	/* no traps set */
+      context->clamp = 1;	/* clamp exponents */
+#if DECSUBSET
+      context->extended = 1;	/* set */
+#endif
+      break;
+    case DEC_INIT_DECIMAL128:
+      context->digits = 34;	/* digits */
+      context->emax = 6144;	/* Emax */
+      context->emin = -6143;	/* Emin */
+      context->round = DEC_ROUND_HALF_EVEN;	/* 0.5 to nearest even */
+      context->traps = 0;	/* no traps set */
+      context->clamp = 1;	/* clamp exponents */
+#if DECSUBSET
+      context->extended = 1;	/* set */
+#endif
+      break;
+
+    default:			/* invalid Kind */
+      /* use defaults, and .. */
+      decContextSetStatus (context, DEC_Invalid_operation);	/* trap */
+    }
+  return context;
+}				/* decContextDefault */
+
+/* ------------------------------------------------------------------ */
+/* decContextStatusToString -- convert status flags to a string       */
+/*                                                                    */
+/*  context is a context with valid status field                      */
+/*                                                                    */
+/*  returns a constant string describing the condition.  If multiple  */
+/*    (or no) flags are set, a generic constant message is returned.  */
+/* ------------------------------------------------------------------ */
+const char *
+decContextStatusToString (decContext * context)
+{
+  Int status = context->status;
+  if (status == DEC_Conversion_syntax)
+    return DEC_Condition_CS;
+  if (status == DEC_Division_by_zero)
+    return DEC_Condition_DZ;
+  if (status == DEC_Division_impossible)
+    return DEC_Condition_DI;
+  if (status == DEC_Division_undefined)
+    return DEC_Condition_DU;
+  if (status == DEC_Inexact)
+    return DEC_Condition_IE;
+  if (status == DEC_Insufficient_storage)
+    return DEC_Condition_IS;
+  if (status == DEC_Invalid_context)
+    return DEC_Condition_IC;
+  if (status == DEC_Invalid_operation)
+    return DEC_Condition_IO;
+#if DECSUBSET
+  if (status == DEC_Lost_digits)
+    return DEC_Condition_LD;
+#endif
+  if (status == DEC_Overflow)
+    return DEC_Condition_OV;
+  if (status == DEC_Clamped)
+    return DEC_Condition_PA;
+  if (status == DEC_Rounded)
+    return DEC_Condition_RO;
+  if (status == DEC_Subnormal)
+    return DEC_Condition_SU;
+  if (status == DEC_Underflow)
+    return DEC_Condition_UN;
+  if (status == 0)
+    return DEC_Condition_ZE;
+  return DEC_Condition_MU;	/* Multiple errors */
+}				/* decContextStatusToString */
+
+/* ------------------------------------------------------------------ */
+/* decContextSetStatusFromString -- set status from a string          */
+/*                                                                    */
+/*  context is the controlling context                                */
+/*  string is a string exactly equal to one that might be returned    */
+/*            by decContextStatusToString                             */
+/*                                                                    */
+/*  The status bit corresponding to the string is set, and a trap     */
+/*  is raised if appropriate.                                         */
+/*                                                                    */
+/*  returns the context structure, unless the string is equal to      */
+/*    DEC_Condition_MU or is not recognized.  In these cases NULL is  */
+/*    returned.                                                       */
+/* ------------------------------------------------------------------ */
+decContext *
+decContextSetStatusFromString (decContext * context, char *string)
+{
+  if (strcmp (string, DEC_Condition_CS) == 0)
+    return decContextSetStatus (context, DEC_Conversion_syntax);
+  if (strcmp (string, DEC_Condition_DZ) == 0)
+    return decContextSetStatus (context, DEC_Division_by_zero);
+  if (strcmp (string, DEC_Condition_DI) == 0)
+    return decContextSetStatus (context, DEC_Division_impossible);
+  if (strcmp (string, DEC_Condition_DU) == 0)
+    return decContextSetStatus (context, DEC_Division_undefined);
+  if (strcmp (string, DEC_Condition_IE) == 0)
+    return decContextSetStatus (context, DEC_Inexact);
+  if (strcmp (string, DEC_Condition_IS) == 0)
+    return decContextSetStatus (context, DEC_Insufficient_storage);
+  if (strcmp (string, DEC_Condition_IC) == 0)
+    return decContextSetStatus (context, DEC_Invalid_context);
+  if (strcmp (string, DEC_Condition_IO) == 0)
+    return decContextSetStatus (context, DEC_Invalid_operation);
+#if DECSUBSET
+  if (strcmp (string, DEC_Condition_LD) == 0)
+    return decContextSetStatus (context, DEC_Lost_digits);
+#endif
+  if (strcmp (string, DEC_Condition_OV) == 0)
+    return decContextSetStatus (context, DEC_Overflow);
+  if (strcmp (string, DEC_Condition_PA) == 0)
+    return decContextSetStatus (context, DEC_Clamped);
+  if (strcmp (string, DEC_Condition_RO) == 0)
+    return decContextSetStatus (context, DEC_Rounded);
+  if (strcmp (string, DEC_Condition_SU) == 0)
+    return decContextSetStatus (context, DEC_Subnormal);
+  if (strcmp (string, DEC_Condition_UN) == 0)
+    return decContextSetStatus (context, DEC_Underflow);
+  if (strcmp (string, DEC_Condition_ZE) == 0)
+    return context;
+  return NULL;			/* Multiple status, or unknown */
+}				/* decContextSetStatusFromString */
+
+/* ------------------------------------------------------------------ */
+/* decContextSetStatus -- set status and raise trap if appropriate    */
+/*                                                                    */
+/*  context is the controlling context                                */
+/*  status  is the DEC_ exception code                                */
+/*  returns the context structure                                     */
+/*                                                                    */
+/* Control may never return from this routine, if there is a signal   */
+/* handler and it takes a long jump.                                  */
+/* ------------------------------------------------------------------ */
+decContext *
+decContextSetStatus (decContext * context, uInt status)
+{
+  context->status |= status;
+  if (status & context->traps)
+    raise (SIGFPE);
+  return context;
+}				/* decContextSetStatus */

libdecnumber/decContext.h

+/* Decimal Context module header for the decNumber C Library
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Contributed by IBM Corporation.  Author Mike Cowlishaw.
+
+   This file is part of GCC.
+
+   GCC is free software; you can redistribute it and/or modify it under
+   the terms of the GNU General Public License as published by the Free
+   Software Foundation; either version 2, or (at your option) any later
+   version.
+
+   GCC 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 General Public License
+   for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GCC; see the file COPYING.  If not, write to the Free
+   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
+
+/* ------------------------------------------------------------------ */
+/*                                                                    */
+/* Context must always be set correctly:                              */
+/*                                                                    */
+/*  digits   -- must be in the range 1 through 999999999              */
+/*  emax     -- must be in the range 0 through 999999999              */
+/*  emin     -- must be in the range 0 through -999999999             */
+/*  round    -- must be one of the enumerated rounding modes          */
+/*  traps    -- only defined bits may be set                          */
+/*  status   -- [any bits may be cleared, but not set, by user]       */
+/*  clamp    -- must be either 0 or 1                                 */
+/*  extended -- must be either 0 or 1 [present only if DECSUBSET]     */
+/*                                                                    */
+/* ------------------------------------------------------------------ */
+
+#if !defined(DECCONTEXT)
+#define DECCONTEXT
+#define DECCNAME     "decContext"	/* Short name */
+#define DECCFULLNAME "Decimal Context Descriptor"	/* Verbose name */
+#define DECCAUTHOR   "Mike Cowlishaw"	/* Who to blame */
+
+#include <stdint.h>		/* C99 standard integers */
+#include <signal.h>		/* for traps */
+
+
+  /* Conditional code flag -- set this to 0 for best performance */
+#define DECSUBSET 0		/* 1 to enable subset arithmetic */
+
+  /* Context for operations, with associated constants */
+enum rounding
+{
+  DEC_ROUND_CEILING,		/* round towards +infinity */
+  DEC_ROUND_UP,			/* round away from 0 */
+  DEC_ROUND_HALF_UP,		/* 0.5 rounds up */
+  DEC_ROUND_HALF_EVEN,		/* 0.5 rounds to nearest even */
+  DEC_ROUND_HALF_DOWN,		/* 0.5 rounds down */
+  DEC_ROUND_DOWN,		/* round towards 0 (truncate) */
+  DEC_ROUND_FLOOR,		/* round towards -infinity */
+  DEC_ROUND_MAX			/* enum must be less than this */
+};
+
+typedef struct
+{
+  int32_t digits;		/* working precision */
+  int32_t emax;			/* maximum positive exponent */
+  int32_t emin;			/* minimum negative exponent */
+  enum rounding round;		/* rounding mode */
+  uint32_t traps;		/* trap-enabler flags */
+  uint32_t status;		/* status flags */
+  uint8_t clamp;		/* flag: apply IEEE exponent clamp */
+#if DECSUBSET
+  uint8_t extended;		/* flag: special-values allowed */
+#endif
+} decContext;
+
+  /* Maxima and Minima */
+#define DEC_MAX_DIGITS 999999999
+#define DEC_MIN_DIGITS         1
+#define DEC_MAX_EMAX   999999999
+#define DEC_MIN_EMAX           0
+#define DEC_MAX_EMIN           0
+#define DEC_MIN_EMIN  -999999999
+
+  /* Trap-enabler and Status flags (exceptional conditions), and their names */
+  /* Top byte is reserved for internal use */
+#define DEC_Conversion_syntax    0x00000001
+#define DEC_Division_by_zero     0x00000002
+#define DEC_Division_impossible  0x00000004
+#define DEC_Division_undefined   0x00000008
+#define DEC_Insufficient_storage 0x00000010	/* [used if malloc fails] */
+#define DEC_Inexact              0x00000020
+#define DEC_Invalid_context      0x00000040
+#define DEC_Invalid_operation    0x00000080
+#if DECSUBSET
+#define DEC_Lost_digits          0x00000100
+#endif
+#define DEC_Overflow             0x00000200
+#define DEC_Clamped              0x00000400
+#define DEC_Rounded              0x00000800
+#define DEC_Subnormal            0x00001000
+#define DEC_Underflow            0x00002000
+
+  /* IEEE 854 groupings for the flags */
+  /* [DEC_Clamped, DEC_Lost_digits, DEC_Rounded, and DEC_Subnormal are */
+  /* not in IEEE 854] */
+#define DEC_IEEE_854_Division_by_zero  (DEC_Division_by_zero)
+#if DECSUBSET
+#define DEC_IEEE_854_Inexact           (DEC_Inexact | DEC_Lost_digits)
+#else
+#define DEC_IEEE_854_Inexact           (DEC_Inexact)
+#endif
+#define DEC_IEEE_854_Invalid_operation (DEC_Conversion_syntax |     \
+                                          DEC_Division_impossible |   \
+                                          DEC_Division_undefined |    \
+                                          DEC_Insufficient_storage |  \
+                                          DEC_Invalid_context |       \
+                                          DEC_Invalid_operation)
+#define DEC_IEEE_854_Overflow          (DEC_Overflow)
+#define DEC_IEEE_854_Underflow         (DEC_Underflow)
+
+  /* flags which are normally errors (results are qNaN, infinite, or 0) */
+#define DEC_Errors (DEC_IEEE_854_Division_by_zero |                 \
+                      DEC_IEEE_854_Invalid_operation |                \
+                      DEC_IEEE_854_Overflow | DEC_IEEE_854_Underflow)
+  /* flags which cause a result to become qNaN */
+#define DEC_NaNs    DEC_IEEE_854_Invalid_operation
+
+  /* flags which are normally for information only (have finite results) */
+#if DECSUBSET
+#define DEC_Information (DEC_Clamped | DEC_Rounded | DEC_Inexact     \
+                          | DEC_Lost_digits)
+#else
+#define DEC_Information (DEC_Clamped | DEC_Rounded | DEC_Inexact)
+#endif
+
+  /* name strings for the exceptional conditions */
+
+#define DEC_Condition_CS "Conversion syntax"
+#define DEC_Condition_DZ "Division by zero"
+#define DEC_Condition_DI "Division impossible"
+#define DEC_Condition_DU "Division undefined"
+#define DEC_Condition_IE "Inexact"
+#define DEC_Condition_IS "Insufficient storage"
+#define DEC_Condition_IC "Invalid context"
+#define DEC_Condition_IO "Invalid operation"
+#if DECSUBSET
+#define DEC_Condition_LD "Lost digits"
+#endif
+#define DEC_Condition_OV "Overflow"
+#define DEC_Condition_PA "Clamped"
+#define DEC_Condition_RO "Rounded"
+#define DEC_Condition_SU "Subnormal"
+#define DEC_Condition_UN "Underflow"
+#define DEC_Condition_ZE "No status"
+#define DEC_Condition_MU "Multiple status"
+#define DEC_Condition_Length 21	/* length of the longest string, */
+				   /* including terminator */
+
+  /* Initialization descriptors, used by decContextDefault */
+#define DEC_INIT_BASE         0
+#define DEC_INIT_DECIMAL32   32
+#define DEC_INIT_DECIMAL64   64
+#define DEC_INIT_DECIMAL128 128
+
+  /* decContext routines */
+#ifdef IN_LIBGCC2
+#define decContextDefault __decContextDefault
+#define decContextSetStatus __decContextSetStatus
+#define decContextStatusToString __decContextStatusToString
+#define decContextSetStatusFromString __decContextSetStatusFromString
+#endif
+decContext *decContextDefault (decContext *, int32_t);
+decContext *decContextSetStatus (decContext *, uint32_t);
+const char *decContextStatusToString (decContext *);
+decContext *decContextSetStatusFromString (decContext *, char *);
+
+#endif

libdecnumber/decLibrary.c

+/* Temporary library support for decimal floating point.
+   Copyright (C) 2005 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING.  If not, write to the Free
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
+
+#include "decContext.h"
+#include "decimal128.h"
+#include "decimal64.h"
+#include "decimal32.h"
+
+void __host_to_ieee_32 (_Decimal32, decimal32 *);
+void __host_to_ieee_64 (_Decimal64, decimal64 *);
+void __host_to_ieee_128 (_Decimal128, decimal128 *);
+
+extern int isinfd32 (_Decimal32);
+extern int isinfd64 (_Decimal64);
+extern int isinfd128 (_Decimal128);
+extern void __dfp_enable_traps (void);
+extern void __dfp_raise (int exception __attribute__ ((unused)));
+
+int
+isinfd32 (_Decimal32 arg)
+{
+  decNumber dn;
+  decimal32 d32;
+
+  __host_to_ieee_32 (arg, &d32);
+  decimal32ToNumber (&d32, &dn);
+  return (decNumberIsInfinite (&dn));
+}
+
+int
+isinfd64 (_Decimal64 arg)
+{
+  decNumber dn;
+  decimal64 d64;
+
+  __host_to_ieee_64 (arg, &d64);
+  decimal64ToNumber (&d64, &dn);
+  return (decNumberIsInfinite (&dn));
+}
+
+int
+isinfd128 (_Decimal128 arg)
+{
+  decNumber dn;
+  decimal128 d128;
+
+  __host_to_ieee_128 (arg, &d128);
+  decimal128ToNumber (&d128, &dn);
+  return (decNumberIsInfinite (&dn));
+}
+
+int __dfp_traps;
+
+void
+__dfp_enable_traps (void)
+{
+  __dfp_traps = 1;
+}
+
+void
+__dfp_raise (int exception __attribute__ ((unused)))
+{
+  raise (SIGFPE);
+}

libdecnumber/decNumber.h

+/* Decimal Number module header for the decNumber C Library
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Contributed by IBM Corporation.  Author Mike Cowlishaw.
+
+   This file is part of GCC.
+
+   GCC is free software; you can redistribute it and/or modify it under
+   the terms of the GNU General Public License as published by the Free
+   Software Foundation; either version 2, or (at your option) any later
+   version.
+
+   GCC 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 General Public License
+   for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GCC; see the file COPYING.  If not, write to the Free
+   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
+
+#if !defined(DECNUMBER)
+#define DECNUMBER
+#define DECNAME     "decNumber"	/* Short name */
+#define DECVERSION  "decNumber 3.24"	/* Version [16 max.] */
+#define DECFULLNAME "Decimal Number Module"	/* Verbose name */
+#define DECAUTHOR   "Mike Cowlishaw"	/* Who to blame */
+
+#if !defined(DECCONTEXT)
+#include "decContext.h"
+#endif
+
+
+  /* Bit settings for decNumber.bits */
+#define DECNEG    0x80		/* Sign; 1=negative, 0=positive or zero */
+#define DECINF    0x40		/* 1=Infinity */
+#define DECNAN    0x20		/* 1=NaN */
+#define DECSNAN   0x10		/* 1=sNaN */
+  /* The remaining bits are reserved; they must be 0 */
+#define DECSPECIAL (DECINF|DECNAN|DECSNAN)	/* any special value */
+
+  /* DECNUMDIGITS is the default number of digits we can hold in the */
+  /* structure.  If undefined, 1 is assumed and it is assumed that the */
+  /* structure will be immediately followed by extra space (if */
+  /* required).  DECNUMDIGITS is always >0. */
+#if !defined(DECNUMDIGITS)
+#define DECNUMDIGITS 1
+#endif
+
+
+  /* Define the decNumber data structure.  The size and shape of the */
+  /* units array in the structure is determined by the following */
+  /* constant.  This must not be changed without recompiling the */
+  /* decNumber library modules. */
+#define DECDPUN 4		/* Decimal Digits Per UNit [must be in */
+				   /* range 1-9; power of 2 recommended]. */
+  /* The size (integer data type) of each unit is determined by the */
+  /* number of digits it will hold. */
+#if   DECDPUN<=2
+#define decNumberUnit uint8_t
+#elif DECDPUN<=4
+#define decNumberUnit uint16_t
+#else
+#define decNumberUnit uint32_t
+#endif
+  /* The number of decNumberUnits we need is ceiling of DECNUMDIGITS/DECDPUN */
+#define DECNUMUNITS ((DECNUMDIGITS+DECDPUN-1)/DECDPUN)
+
+  /* The data structure... */
+typedef struct
+{
+  int32_t digits;		/* Count of digits in the coefficient; >0 */
+  int32_t exponent;		/* Unadjusted exponent, unbiased, in */
+  /* range: -1999999997 through 999999999 */
+  uint8_t bits;			/* Indicator bits (see above) */
+  decNumberUnit lsu[DECNUMUNITS];	/* Coefficient, from least significant unit */
+} decNumber;
+
+  /* Notes: */
+  /* 1. If digits is > DECDPUN then there will be more than one */
+  /*    decNumberUnits immediately following the first element of lsu. */
+  /*    These contain the remaining (more significant) digits of the */
+  /*    number, and may be in the lsu array, or may be guaranteed by */
+  /*    some other mechanism (such as being contained in another */
+  /*    structure, or being overlaid on dynamically allocated storage). */
+  /* */
+  /*    Each integer of the coefficient (except the possibly the last) */
+  /*    contains DECDPUN digits (e.g., a value in the range 0 through */
+  /*    99999999 if DECDPUN is 8, or 0 through 9999 if DECDPUN is 4). */
+  /* */
+  /* 2. A decNumber converted to a string may need up to digits+14 */
+  /*    characters.  The worst cases (non-exponential and exponential */
+  /*    formats) are: -0.00000{9...}# */
+  /*             and: -9.{9...}E+999999999#   (where # is '\0') */
+
+
+  /* ------------------------------------------------------------------ */
+  /* decNumber public functions and macros                              */
+  /* ------------------------------------------------------------------ */
+
+#ifdef IN_LIBGCC2
+#define decNumberFromString __decNumberFromString
+#define decNumberToString __decNumberToString
+#define decNumberToEngString __decNumberToEngString
+#define decNumberAbs __decNumberAbs
+#define decNumberAdd __decNumberAdd
+#define decNumberCompare __decNumberCompare
+#define decNumberDivide __decNumberDivide
+#define decNumberDivideInteger __decNumberDivideInteger
+#define decNumberMax __decNumberMax
+#define decNumberMin __decNumberMin
+#define decNumberMinus __decNumberMinus
+#define decNumberMultiply __decNumberMultiply
+#define decNumberNormalize __decNumberNormalize
+#define decNumberPlus __decNumberPlus
+#define decNumberPower __decNumberPower
+#define decNumberQuantize __decNumberQuantize
+#define decNumberRemainder __decNumberRemainder
+#define decNumberRemainderNear __decNumberRemainderNear
+#define decNumberRescale __decNumberRescale
+#define decNumberSameQuantum __decNumberSameQuantum
+#define decNumberSquareRoot __decNumberSquareRoot
+#define decNumberSubtract __decNumberSubtract
+#define decNumberToIntegralValue __decNumberToIntegralValue
+#define decNumberCopy __decNumberCopy
+#define decNumberTrim __decNumberTrim
+#define decNumberVersion __decNumberVersion
+#define decNumberZero __decNumberZero
+#endif
+
+  /* Conversions */
+decNumber *decNumberFromString (decNumber *, char *, decContext *);
+char *decNumberToString (decNumber *, char *);
+char *decNumberToEngString (decNumber *, char *);
+
+  /* Operators */
+decNumber *decNumberAbs (decNumber *, decNumber *, decContext *);
+decNumber *decNumberAdd (decNumber *, decNumber *, decNumber *, decContext *);
+decNumber *decNumberCompare (decNumber *, decNumber *, decNumber *,
+			     decContext *);
+decNumber *decNumberDivide (decNumber *, decNumber *, decNumber *,
+			    decContext *);
+decNumber *decNumberDivideInteger (decNumber *, decNumber *, decNumber *,
+				   decContext *);
+decNumber *decNumberMax (decNumber *, decNumber *, decNumber *, decContext *);
+decNumber *decNumberMin (decNumber *, decNumber *, decNumber *, decContext *);
+decNumber *decNumberMinus (decNumber *, decNumber *, decContext *);
+decNumber *decNumberMultiply (decNumber *, decNumber *, decNumber *,
+			      decContext *);
+decNumber *decNumberNormalize (decNumber *, decNumber *, decContext *);
+decNumber *decNumberPlus (decNumber *, decNumber *, decContext *);
+decNumber *decNumberPower (decNumber *, decNumber *, decNumber *,
+			   decContext *);
+decNumber *decNumberQuantize (decNumber *, decNumber *, decNumber *,
+			      decContext *);
+decNumber *decNumberRemainder (decNumber *, decNumber *, decNumber *,
+			       decContext *);
+decNumber *decNumberRemainderNear (decNumber *, decNumber *, decNumber *,
+				   decContext *);
+decNumber *decNumberRescale (decNumber *, decNumber *, decNumber *,
+			     decContext *);
+decNumber *decNumberSameQuantum (decNumber *, decNumber *, decNumber *);
+decNumber *decNumberSquareRoot (decNumber *, decNumber *, decContext *);
+decNumber *decNumberSubtract (decNumber *, decNumber *, decNumber *,
+			      decContext *);
+decNumber *decNumberToIntegralValue (decNumber *, decNumber *, decContext *);
+
+  /* Utilities */
+decNumber *decNumberCopy (decNumber *, decNumber *);
+decNumber *decNumberTrim (decNumber *);
+const char *decNumberVersion (void);
+decNumber *decNumberZero (decNumber *);
+
+  /* Macros */
+#define decNumberIsZero(dn)     (*(dn)->lsu==0 \
+                                   && (dn)->digits==1 \
+                                   && (((dn)->bits&DECSPECIAL)==0))
+#define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0)
+#define decNumberIsNaN(dn)      (((dn)->bits&(DECNAN|DECSNAN))!=0)
+#define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0)
+#define decNumberNegate(dn) (((dn)->bits)^=DECNEG)
+
+#endif

libdecnumber/decNumberLocal.h

+/* decNumber package local type, tuning, and macro definitions.
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Contributed by IBM Corporation.  Author Mike Cowlishaw.
+
+   This file is part of GCC.
+
+   GCC is free software; you can redistribute it and/or modify it under
+   the terms of the GNU General Public License as published by the Free
+   Software Foundation; either version 2, or (at your option) any later
+   version.
+
+   GCC 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 General Public License
+   for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GCC; see the file COPYING.  If not, write to the Free
+   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
+
+/* ------------------------------------------------------------------ */
+/* This header file is included by all modules in the decNumber       */
+/* library, and contains local type definitions, tuning parameters,   */
+/* etc.  It must only be included once, and should not need to be     */
+/* used by application programs.  decNumber.h must be included first. */
+/* ------------------------------------------------------------------ */
+
+#if !defined(DECNUMBERLOC)
+#define DECNUMBERLOC
+#define DECNLAUTHOR   "Mike Cowlishaw"	/* Who to blame */
+
+  /* Local names for common types -- decNumber modules do not use int or
+     long directly */
+#define Flag   uint8_t
+#define Byte   int8_t
+#define uByte  uint8_t
+#define Short  int16_t
+#define uShort uint16_t
+#define Int    int32_t
+#define uInt   uint32_t
+#define Unit   decNumberUnit
+
+
+  /* Tuning parameter */
+#define DECBUFFER 36		/* Maximum size basis for local buffers. */
+			      /* Should be a common maximum precision */
+			      /* rounded up to a multiple of 4; must */
+			      /* be non-negative. */
+
+  /* Conditional code flags -- set these to 0 for best performance */
+#define DECCHECK  0		/* 1 to enable robust checking */
+#define DECALLOC  0		/* 1 to enable memory allocation accounting */
+#define DECTRACE  0		/* 1 to trace critical intermediates, etc. */
+
+
+  /* Development use defines */
+#if DECALLOC
+     /* if these interfere with your C includes, just comment them out */
+#define  int ?			/* enable to ensure we do not use plain C */
+#define  long ??		/* .. 'int' or 'long' types from here on */
+#endif
+
+  /* Limits and constants */
+#define DECNUMMAXP 999999999	/* maximum precision we can handle (9 digits) */
+#define DECNUMMAXE 999999999	/* maximum adjusted exponent ditto (9 digits) */
+#define DECNUMMINE -999999999	/* minimum adjusted exponent ditto (9 digits) */
+#if (DECNUMMAXP != DEC_MAX_DIGITS)
+#error Maximum digits mismatch
+#endif
+#if (DECNUMMAXE != DEC_MAX_EMAX)
+#error Maximum exponent mismatch
+#endif
+#if (DECNUMMINE != DEC_MIN_EMIN)
+#error Minimum exponent mismatch
+#endif
+
+  /* Set DECDPUNMAX -- the maximum integer that fits in DECDPUN digits */
+#if   DECDPUN==1
+#define DECDPUNMAX 9
+#elif DECDPUN==2
+#define DECDPUNMAX 99
+#elif DECDPUN==3
+#define DECDPUNMAX 999
+#elif DECDPUN==4
+#define DECDPUNMAX 9999
+#elif DECDPUN==5
+#define DECDPUNMAX 99999
+#elif DECDPUN==6
+#define DECDPUNMAX 999999
+#elif DECDPUN==7
+#define DECDPUNMAX 9999999
+#elif DECDPUN==8
+#define DECDPUNMAX 99999999
+#elif DECDPUN==9
+#define DECDPUNMAX 999999999
+#elif defined(DECDPUN)
+#error DECDPUN must be in the range 1-9
+#endif
+
+
+  /* ----- Shared data ----- */
+  /* The powers of of ten array (powers[n]==10**n, 0<=n<=10) */
+extern const uInt powers[];
+
+  /* ----- Macros ----- */
+  /* ISZERO -- return true if decNumber dn is a zero */
+  /* [performance-critical in some situations] */
+#define ISZERO(dn) decNumberIsZero(dn)	/* now just a local name */
+
+  /* X10 and X100 -- multiply integer i by 10 or 100 */
+  /* [shifts are usually faster than multiply; could be conditional] */
+#define X10(i)  (((i)<<1)+((i)<<3))
+#define X100(i) (((i)<<2)+((i)<<5)+((i)<<6))
+
+  /* D2U -- return the number of Units needed to hold d digits */
+#if DECDPUN==8
+#define D2U(d) ((unsigned)((d)+7)>>3)
+#elif DECDPUN==4
+#define D2U(d) ((unsigned)((d)+3)>>2)
+#else
+#define D2U(d) (((d)+DECDPUN-1)/DECDPUN)
+#endif
+
+#else
+#error decNumberLocal included more than once
+#endif

libdecnumber/decRound.c

+/* Temporary support for a libc-like fp environment for decimal float.
+   Copyright (C) 2005 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING.  If not, write to the Free
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
+
+#include "decContext.h"
+
+#define FE_DEC_DOWNWARD 0
+#define FE_DEC_TONEAREST 1
+#define FE_DEC_TONEARESTFROMZERO 2
+#define FE_DEC_TOWARDZERO 3
+#define FE_DEC_UPWARD 4
+#define FE_DEC_MAX 5
+
+extern void __dfp_set_round (int);
+extern int __dfp_get_round (void);
+extern enum rounding __decGetRound (void);
+
+/* FIXME: these should be in thread-local storage for runtime support.  */
+static enum rounding __dfp_rounding_mode = DEC_ROUND_HALF_EVEN;
+
+/* Set the decNumber rounding mode from the FE_DEC_* value in MODE.  */ 
+
+void
+__dfp_set_round (int mode)
+{
+  switch (mode)
+    {
+    case FE_DEC_DOWNWARD:
+      __dfp_rounding_mode = DEC_ROUND_FLOOR; break;
+    case FE_DEC_TONEAREST:
+      __dfp_rounding_mode = DEC_ROUND_HALF_EVEN; break;
+    case FE_DEC_TONEARESTFROMZERO:
+      __dfp_rounding_mode = DEC_ROUND_HALF_UP; break;
+    case FE_DEC_TOWARDZERO:
+      __dfp_rounding_mode = DEC_ROUND_DOWN; break;
+    case FE_DEC_UPWARD:
+      __dfp_rounding_mode = DEC_ROUND_CEILING; break;
+    default:
+     /* We can't use assert in libgcc, so just return the default mode.  */
+      __dfp_rounding_mode = DEC_ROUND_HALF_EVEN; break;
+    }
+}
+
+/* Return the decNumber rounding mode as an FE_DEC_* value.  */
+
+int
+__dfp_get_round (void)
+{
+  int mode;
+
+  switch (__dfp_rounding_mode)
+    {
+    case DEC_ROUND_FLOOR:
+      mode = FE_DEC_DOWNWARD; break;
+    case DEC_ROUND_HALF_EVEN:
+      mode = FE_DEC_TONEAREST; break;
+    case DEC_ROUND_HALF_UP:
+      mode = FE_DEC_TONEARESTFROMZERO; break;
+    case DEC_ROUND_DOWN:
+      mode = FE_DEC_TOWARDZERO; break;
+    case DEC_ROUND_CEILING:
+      mode = FE_DEC_UPWARD; break;
+    default:
+      /* We shouldn't get here, but can't use assert in libgcc.  */
+      mode = -1;
+    }
+  return mode;
+}
+
+/* Return the decNumber version of the current rounding mode.  */
+
+enum rounding
+__decGetRound (void)
+{
+  return __dfp_rounding_mode;
+}

libdecnumber/decUtility.h

+/* Utility functions for decimal floating point support via decNumber.
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Contributed by IBM Corporation.  Author Mike Cowlishaw.
+
+   This file is part of GCC.
+
+   GCC is free software; you can redistribute it and/or modify it under
+   the terms of the GNU General Public License as published by the Free
+   Software Foundation; either version 2, or (at your option) any later
+   version.
+
+   GCC 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 General Public License
+   for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GCC; see the file COPYING.  If not, write to the Free
+   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
+
+#ifdef IN_LIBGCC2
+#define decDensePackCoeff __decDensePackCoeff
+#define decDenseUnpackCoeff __decDenseUnpackCoeff
+#endif
+
+extern void decDensePackCoeff (decNumber *, uByte *, Int, Int);
+extern void decDenseUnpackCoeff (uByte *, Int, decNumber *, Int, Int);
+extern unsigned long __dec_byte_swap (unsigned long in);

libdecnumber/decimal128.h

+/* Decimal 128-bit format module header for the decNumber C Library
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Contributed by IBM Corporation.  Author Mike Cowlishaw.
+
+   This file is part of GCC.
+
+   GCC is free software; you can redistribute it and/or modify it under
+   the terms of the GNU General Public License as published by the Free
+   Software Foundation; either version 2, or (at your option) any later
+   version.
+
+   GCC 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 General Public License
+   for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GCC; see the file COPYING.  If not, write to the Free
+   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
+
+#if !defined(DECIMAL128)
+#define DECIMAL128
+#define DEC128NAME     "decimal128"	/* Short name */
+#define DEC128FULLNAME "Decimal 128-bit Number"	/* Verbose name */
+#define DEC128AUTHOR   "Mike Cowlishaw"	/* Who to blame */
+
+#if defined(DECIMAL32)
+#error decimal128.h must precede decimal32.h for correct DECNUMDIGITS
+#else
+#if defined(DECIMAL64)
+#error decimal128.h must precede decimal64.h for correct DECNUMDIGITS
+#endif
+#endif
+
+  /* parameters for decimal128s */
+#define DECIMAL128_Bytes  16	/* length */
+#define DECIMAL128_Pmax   34	/* maximum precision (digits) */
+#define DECIMAL128_Emax   6144	/* maximum adjusted exponent */
+#define DECIMAL128_Emin  -6143	/* minimum adjusted exponent */
+#define DECIMAL128_Bias   6176	/* bias for the exponent */
+#define DECIMAL128_String 43	/* maximum string length, +1 */
+  /* highest biased exponent (Elimit-1) */
+#define DECIMAL128_Ehigh  (DECIMAL128_Emax+DECIMAL128_Bias-DECIMAL128_Pmax+1)
+
+#ifndef DECNUMDIGITS
+#define DECNUMDIGITS DECIMAL128_Pmax	/* size if not already defined */
+#endif
+#ifndef DECNUMBER
+#include "decNumber.h"		/* context and number library */
+#endif
+
+  /* Decimal 128-bit type, accessible by bytes */
+typedef struct
+{
+  uint8_t bytes[DECIMAL128_Bytes];	/* decimal128: 1, 5, 12, 110 bits */
+} decimal128;
+
+  /* special values [top byte excluding sign bit; last two bits are
+     don't-care for Infinity on input, last bit don't-care for NaN] */
+#if !defined(DECIMAL_NaN)
+#define DECIMAL_NaN     0x7c	/* 0 11111 00 NaN */
+#define DECIMAL_sNaN    0x7e	/* 0 11111 10 sNaN */
+#define DECIMAL_Inf     0x78	/* 0 11110 00 Infinity */
+#endif
+
+  /* Macros for accessing decimal128 fields.  These assume the argument
+     is a reference (pointer) to the decimal128 structure */
+  /* Get sign */
+#define decimal128Sign(d)       ((unsigned)(d)->bytes[0]>>7)
+
+  /* Get combination field */
+#define decimal128Comb(d)       (((d)->bytes[0] & 0x7c)>>2)
+
+  /* Get exponent continuation [does not remove bias] */
+#define decimal128ExpCon(d)     ((((d)->bytes[0] & 0x03)<<10)       \
+                                | ((unsigned)(d)->bytes[1]<<2)        \
+                                | ((unsigned)(d)->bytes[2]>>6))
+
+  /* Set sign [this assumes sign previously 0] */
+#define decimal128SetSign(d, b) {                                   \
+    (d)->bytes[0]|=((unsigned)(b)<<7);}
+
+  /* Set exponent continuation [does not apply bias] */
+  /* This assumes range has been checked and exponent previously 0; */
+  /* type of exponent must be unsigned */
+#define decimal128SetExpCon(d, e) {                                 \
+    (d)->bytes[0]|=(uint8_t)((e)>>10);                                \
+    (d)->bytes[1] =(uint8_t)(((e)&0x3fc)>>2);                         \
+    (d)->bytes[2]|=(uint8_t)(((e)&0x03)<<6);}
+
+  /* ------------------------------------------------------------------ */
+  /* Routines                                                           */
+  /* ------------------------------------------------------------------ */
+
+#ifdef IN_LIBGCC2
+#define decimal128FromString __decimal128FromString
+#define decimal128ToString __decimal128ToString
+#define decimal128ToEngString __decimal128ToEngString
+#define decimal128FromNumber __decimal128FromNumber
+#define decimal128ToNumber __decimal128ToNumber
+#endif
+
+  /* String conversions */
+decimal128 *decimal128FromString (decimal128 *, char *, decContext *);
+char *decimal128ToString (decimal128 *, char *);
+char *decimal128ToEngString (decimal128 *, char *);
+
+  /* decNumber conversions */
+decimal128 *decimal128FromNumber (decimal128 *, decNumber *, decContext *);
+decNumber *decimal128ToNumber (decimal128 *, decNumber *);
+
+#endif

libdecnumber/decimal32.h

+/* Decimal 32-bit format module header for the decNumber C Library
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Contributed by IBM Corporation.  Author Mike Cowlishaw.
+
+   This file is part of GCC.
+
+   GCC is free software; you can redistribute it and/or modify it under
+   the terms of the GNU General Public License as published by the Free
+   Software Foundation; either version 2, or (at your option) any later
+   version.
+
+   GCC 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 General Public License
+   for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GCC; see the file COPYING.  If not, write to the Free
+   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
+
+#if !defined(DECIMAL32)
+#define DECIMAL32
+#define DEC32NAME     "decimal32"	/* Short name */
+#define DEC32FULLNAME "Decimal 32-bit Number"	/* Verbose name */
+#define DEC32AUTHOR   "Mike Cowlishaw"	/* Who to blame */
+
+  /* parameters for decimal32s */
+#define DECIMAL32_Bytes  4	/* length */
+#define DECIMAL32_Pmax   7	/* maximum precision (digits) */
+#define DECIMAL32_Emax   96	/* maximum adjusted exponent */
+#define DECIMAL32_Emin  -95	/* minimum adjusted exponent */
+#define DECIMAL32_Bias   101	/* bias for the exponent */
+#define DECIMAL32_String 15	/* maximum string length, +1 */
+  /* highest biased exponent (Elimit-1) */
+#define DECIMAL32_Ehigh  (DECIMAL32_Emax+DECIMAL32_Bias-DECIMAL32_Pmax+1)
+
+#ifndef DECNUMDIGITS
+#define DECNUMDIGITS DECIMAL32_Pmax	/* size if not already defined */
+#endif
+#ifndef DECNUMBER
+#include "decNumber.h"		/* context and number library */
+#endif
+
+  /* Decimal 32-bit type, accessible by bytes */
+typedef struct
+{
+  uint8_t bytes[DECIMAL32_Bytes];	/* decimal32: 1, 5, 6, 20 bits */
+} decimal32;
+
+  /* special values [top byte excluding sign bit; last two bits are
+     don't-care for Infinity on input, last bit don't-care for NaN] */
+#if !defined(DECIMAL_NaN)
+#define DECIMAL_NaN     0x7c	/* 0 11111 00 NaN */
+#define DECIMAL_sNaN    0x7e	/* 0 11111 10 sNaN */
+#define DECIMAL_Inf     0x78	/* 0 11110 00 Infinity */
+#endif
+
+  /* Macros for accessing decimal32 fields.  These assume the argument
+     is a reference (pointer) to the decimal32 structure */
+  /* Get sign */
+#define decimal32Sign(d)       ((unsigned)(d)->bytes[0]>>7)
+
+  /* Get combination field */
+#define decimal32Comb(d)       (((d)->bytes[0] & 0x7c)>>2)
+
+  /* Get exponent continuation [does not remove bias] */
+#define decimal32ExpCon(d)     ((((d)->bytes[0] & 0x03)<<4)         \
+                               | ((unsigned)(d)->bytes[1]>>4))
+
+  /* Set sign [this assumes sign previously 0] */
+#define decimal32SetSign(d, b) {                                    \
+    (d)->bytes[0]|=((unsigned)(b)<<7);}
+
+  /* Set exponent continuation [does not apply bias] */
+  /* This assumes range has been checked and exponent previously 0; */
+  /* type of exponent must be unsigned */
+#define decimal32SetExpCon(d, e) {                                  \
+    (d)->bytes[0]|=(uint8_t)((e)>>4);                                 \
+    (d)->bytes[1]|=(uint8_t)(((e)&0x0F)<<4);}
+
+  /* ------------------------------------------------------------------ */
+  /* Routines                                                           */
+  /* ------------------------------------------------------------------ */
+
+#ifdef IN_LIBGCC2
+#define decimal32FromString __decimal32FromString
+#define decimal32ToString __decimal32ToString
+#define decimal32ToEngString __decimal32ToEngString
+#define decimal32FromNumber __decimal32FromNumber
+#define decimal32ToNumber __decimal32ToNumber
+#endif
+
+/* String conversions.  */
+decimal32 *decimal32FromString (decimal32 *, char *, decContext *);
+char *decimal32ToString (decimal32 *, char *);
+char *decimal32ToEngString (decimal32 *, char *);
+
+/* decNumber conversions.  */
+decimal32 *decimal32FromNumber (decimal32 *, decNumber *, decContext *);
+decNumber *decimal32ToNumber (decimal32 *, decNumber *);
+
+#endif

libdecnumber/decimal64.h

+/* Decimal 64-bit format module header for the decNumber C Library
+   Copyright (C) 2005 Free Software Foundation, Inc.
+   Contributed by IBM Corporation.  Author Mike Cowlishaw.
+
+   This file is part of GCC.
+
+   GCC is free software; you can redistribute it and/or modify it under
+   the terms of the GNU General Public License as published by the Free
+   Software Foundation; either version 2, or (at your option) any later
+   version.
+
+   GCC 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 General Public License
+   for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GCC; see the file COPYING.  If not, write to the Free
+   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
+
+#if !defined(DECIMAL64)
+#define DECIMAL64
+#define DEC64NAME     "decimal64"	/* Short name */
+#define DEC64FULLNAME "Decimal 64-bit Number"	/* Verbose name */
+#define DEC64AUTHOR   "Mike Cowlishaw"	/* Who to blame */
+
+#if defined(DECIMAL32)
+#error decimal64.h must precede decimal32.h for correct DECNUMDIGITS
+#endif
+
+  /* parameters for decimal64s */
+#define DECIMAL64_Bytes  8	/* length */
+#define DECIMAL64_Pmax   16	/* maximum precision (digits) */
+#define DECIMAL64_Emax   384	/* maximum adjusted exponent */
+#define DECIMAL64_Emin  -383	/* minimum adjusted exponent */
+#define DECIMAL64_Bias   398	/* bias for the exponent */
+#define DECIMAL64_String 24	/* maximum string length, +1 */
+  /* highest biased exponent (Elimit-1) */
+#define DECIMAL64_Ehigh  (DECIMAL64_Emax+DECIMAL64_Bias-DECIMAL64_Pmax+1)
+
+#ifndef DECNUMDIGITS
+#define DECNUMDIGITS DECIMAL64_Pmax	/* size if not already defined */
+#endif
+#ifndef DECNUMBER
+#include "decNumber.h"		/* context and number library */
+#endif
+
+  /* Decimal 64-bit type, accessible by bytes */
+typedef struct
+{
+  uint8_t bytes[DECIMAL64_Bytes];	/* decimal64: 1, 5, 8, 50 bits */
+} decimal64;
+
+  /* special values [top byte excluding sign bit; last two bits are
+     don't-care for Infinity on input, last bit don't-care for NaN] */
+#if !defined(DECIMAL_NaN)
+#define DECIMAL_NaN     0x7c	/* 0 11111 00 NaN */
+#define DECIMAL_sNaN    0x7e	/* 0 11111 10 sNaN */
+#define DECIMAL_Inf     0x78	/* 0 11110 00 Infinity */
+#endif
+
+  /* Macros for accessing decimal64 fields.  These assume the argument
+     is a reference (pointer) to the decimal64 structure */
+  /* Get sign */
+#define decimal64Sign(d)       ((unsigned)(d)->bytes[0]>>7)
+
+  /* Get combination field */
+#define decimal64Comb(d)       (((d)->bytes[0] & 0x7c)>>2)
+
+  /* Get exponent continuation [does not remove bias] */
+#define decimal64ExpCon(d)     ((((d)->bytes[0] & 0x03)<<6)         \
+                               | ((unsigned)(d)->bytes[1]>>2))
+
+  /* Set sign [this assumes sign previously 0] */
+#define decimal64SetSign(d, b) {                                    \
+    (d)->bytes[0]|=((unsigned)(b)<<7);}
+
+  /* Set exponent continuation [does not apply bias] */
+  /* This assumes range has been checked and exponent previously 0; type */
+  /* of exponent must be unsigned */
+#define decimal64SetExpCon(d, e) {                                  \
+    (d)->bytes[0]|=(uint8_t)((e)>>6);                                 \
+    (d)->bytes[1]|=(uint8_t)(((e)&0x3F)<<2);}
+
+  /* ------------------------------------------------------------------ */
+  /* Routines                                                           */
+  /* ------------------------------------------------------------------ */
+
+#ifdef IN_LIBGCC2
+#define decimal64FromString __decimal64FromString
+#define decimal64ToString __decimal64ToString
+#define decimal64ToEngString __decimal64ToEngString
+#define decimal64FromNumber __decimal64FromNumber
+#define decimal64ToNumber __decimal64ToNumber
+#endif
+
+  /* String conversions */
+decimal64 *decimal64FromString (decimal64 *, char *, decContext *);
+char *decimal64ToString (decimal64 *, char *);
+char *decimal64ToEngString (decimal64 *, char *);
+
+  /* decNumber conversions */
+decimal64 *decimal64FromNumber (decimal64 *, decNumber *, decContext *);
+decNumber *decimal64ToNumber (decimal64 *, decNumber *);
+
+#endif