Updated from /src/gmp-1.937
authorroland <roland>
Fri, 1 Mar 1996 18:43:39 +0000 (18:43 +0000)
committerroland <roland>
Fri, 1 Mar 1996 18:43:39 +0000 (18:43 +0000)
stdlib/gmp-impl.h
stdlib/gmp.h
sysdeps/m88k/add_n.s
sysdeps/m88k/mul_1.s
sysdeps/m88k/sub_n.s
sysdeps/vax/gmp-mparam.h
sysdeps/z8000/mul_1.s

index 2f0956d..83d4e32 100644 (file)
@@ -1,6 +1,6 @@
 /* Include file for internal GNU MP types and definitions.
 
-Copyright (C) 1991, 1993, 1994 Free Software Foundation, Inc.
+Copyright (C) 1991, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
 
 This file is part of the GNU MP Library.
 
@@ -18,25 +18,50 @@ You should have received a copy of the GNU Library General Public License
 along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
-#if ! defined (alloca)
-#if defined (__GNUC__)
+/* When using gcc, make sure to use its builtin alloca.  */
+#if ! defined (alloca) && defined (__GNUC__)
 #define alloca __builtin_alloca
-#endif
+#define HAVE_ALLOCA
 #endif
 
+/* When using cc, do whatever necessary to allow use of alloca.  For many
+   machines, this means including alloca.h.  IBM's compilers need a #pragma
+   in "each module that needs to use alloca".  */
 #if ! defined (alloca)
-#if defined (__sparc__) || defined (sparc) || defined (__sgi)
+/* We need lots of variants for MIPS, to cover all versions and perversions
+   of OSes for MIPS.  */
+#if defined (__mips) || defined (MIPSEL) || defined (MIPSEB) \
+ || defined (_MIPSEL) || defined (_MIPSEB) || defined (__sgi) \
+ || defined (__alpha) || defined (__sparc) || defined (sparc) \
+ || defined (__ksr__)
 #include <alloca.h>
+#define HAVE_ALLOCA
+#endif
+#if defined (_IBMR2)
+#pragma alloca
+#define HAVE_ALLOCA
+#endif
+#if defined (__DECC)
+#define alloca(x) __ALLOCA(x)
+#define HAVE_ALLOCA
 #endif
 #endif
 
+#if ! defined (HAVE_ALLOCA) || USE_STACK_ALLOC
+#include "stack-alloc.h"
+#else
+#define TMP_DECL(m)
+#define TMP_ALLOC(x) alloca(x)
+#define TMP_MARK(m)
+#define TMP_FREE(m)
+#endif
+
 #ifndef NULL
-#define NULL 0L
+#define NULL ((void *) 0)
 #endif
 
 #if ! defined (__GNUC__)
 #define inline                 /* Empty */
-void *alloca();
 #endif
 
 #define ABS(x) (x >= 0 ? x : -x)
@@ -46,7 +71,7 @@ void *alloca();
 #include "gmp-mparam.h"
 /* #include "longlong.h" */
 
-#ifdef __STDC__
+#if defined (__STDC__)  || defined (__cplusplus)
 void *malloc (size_t);
 void *realloc (void *, size_t);
 void free (void *);
@@ -119,35 +144,6 @@ void _mp_default_free ();
       }                                                                        \
   } while (0)
 
-/*  Swap (mp_ptr, mp_size_t) (U, UL) with (V, VL)  */
-#define MPN_SWAP(u, l, v, m) \
-  do {                                                                 \
-    { mp_ptr _; _ = (u), (u) = (v), (v) = _;}                          \
-    { mp_size_t _; _ = (l), (l) = (m), (m) = _;}                       \
-  } while (0)
-
-/*  Return true iff the limb X has less bits than the limb Y.  */
-#define MPN_LESS_BITS_LIMB(x,y) ((x) < (y) && (x) < ((x) ^ (y)))
-
-/*  Return true iff (mp_ptr, mp_size_t) (U, UL) has less bits than (V, VL).  */
-#define MPN_LESS_BITS(u, l, v, m) \
-  ((l) < (m)                                                           \
-   || ((l) == (m) && (l) != 0 && MPN_LESS_BITS_LIMB ((u)[(l - 1)], (v)[(l) - 1])))
-
-/*  Return true iff (mp_ptr, mp_size_t) (U, UL) has more bits than (V, VL).  */
-#define MPN_MORE_BITS(u, l, v, m) MPN_LESS_BITS (v, m, u, l)
-
-/*  Perform twos complement on (mp_ptr, mp_size_t) (U, UL), 
-    putting result at (v, VL).  Precondition: U[0] != 0.  */
-#define MPN_COMPL_INCR(u, v, l)        \
-  do {                                                                 \
-    mp_size_t _ = 0;                                                   \
-    (u)[0] = -(v)[_];                                                  \
-    while (_++ < (l))                                                  \
-      (u)[_] = ~(v)[_];                                                        \
-  } while (0)
-#define MPN_COMPL MPN_COMPL_INCR
-
 /* Initialize the MP_INT X with space for NLIMBS limbs.
    X should be a temporary variable, and it will be automatically
    cleared out when the running function returns.
@@ -156,23 +152,23 @@ void _mp_default_free ();
 #define MPZ_TMP_INIT(X, NLIMBS) \
   do {                                                                 \
     mpz_ptr __x = (X);                                                 \
-    __x->alloc = (NLIMBS);                                             \
-    __x->d = (mp_ptr) alloca ((NLIMBS) * BYTES_PER_MP_LIMB);           \
+    __x->_mp_alloc = (NLIMBS);                                         \
+    __x->_mp_d = (mp_ptr) TMP_ALLOC ((NLIMBS) * BYTES_PER_MP_LIMB);    \
   } while (0)
 
 #define MPN_MUL_N_RECURSE(prodp, up, vp, size, tspace) \
   do {                                                                 \
     if ((size) < KARATSUBA_THRESHOLD)                                  \
-      ____mpn_mul_n_basecase (prodp, up, vp, size);                    \
+      impn_mul_n_basecase (prodp, up, vp, size);                       \
     else                                                               \
-      ____mpn_mul_n (prodp, up, vp, size, tspace);                     \
+      impn_mul_n (prodp, up, vp, size, tspace);                        \
   } while (0);
 #define MPN_SQR_N_RECURSE(prodp, up, size, tspace) \
   do {                                                                 \
     if ((size) < KARATSUBA_THRESHOLD)                                  \
-      ____mpn_sqr_n_basecase (prodp, up, size);                                \
+      impn_sqr_n_basecase (prodp, up, size);                           \
     else                                                               \
-      ____mpn_sqr_n (prodp, up, size, tspace);                         \
+      impn_sqr_n (prodp, up, size, tspace);                            \
   } while (0);
 
 /* Structure for conversion between internal binary format and
@@ -198,6 +194,13 @@ struct bases
   mp_limb big_base_inverted;
 };
 
+/* Access macros for structure fields for user-visible structures with
+   hidden fields.  */
+#define size(X) (X)._mp_size
+#define alloc(X) (X)._mp_alloc
+#define prec(X) (X)._mp_prec
+#define limbs(X) (X)._mp_d
+
 extern const struct bases __mp_bases[];
 extern mp_size_t __gmp_default_fp_limb_precision;
 
@@ -288,6 +291,11 @@ typedef mp_limb UWtype;
 typedef unsigned int UHWtype;
 #define W_TYPE_SIZE BITS_PER_MP_LIMB
 
+/* Internal mpn calls */
+#define impn_mul_n_basecase    __MPN(impn_mul_n_basecase)
+#define impn_mul_n             __MPN(impn_mul_n)
+#define impn_sqr_n_basecase    __MPN(impn_sqr_n_basecase)
+#define impn_sqr_n             __MPN(impn_sqr_n)
 
 #ifndef IEEE_DOUBLE_BIG_ENDIAN
 #define IEEE_DOUBLE_BIG_ENDIAN 1
@@ -298,10 +306,10 @@ union ieee_double_extract
 {
   struct
     {
-      unsigned long sig:1;
-      unsigned long exp:11;
-      unsigned long manh:20;
-      unsigned long manl:32;
+      unsigned int sig:1;
+      unsigned int exp:11;
+      unsigned int manh:20;
+      unsigned int manl:32;
     } s;
   double d;
 };
@@ -310,10 +318,10 @@ union ieee_double_extract
 {
   struct
     {
-      unsigned long manl:32;
-      unsigned long manh:20;
-      unsigned long exp:11;
-      unsigned long sig:1;
+      unsigned int manl:32;
+      unsigned int manh:20;
+      unsigned int exp:11;
+      unsigned int sig:1;
     } s;
   double d;
 };
index 2437799..5f1b48d 100644 (file)
@@ -1,6 +1,6 @@
 /* gmp.h -- Definitions for GNU multiple precision functions.
 
-Copyright (C) 1991, 1993, 1994 Free Software Foundation, Inc.
+Copyright (C) 1991, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
 
 This file is part of the GNU MP Library.
 
@@ -21,22 +21,31 @@ the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 #ifndef __GMP_H__
 
 #ifndef __GNU_MP__
+#define __GNU_MP__ 2
 #define __need_size_t
 #include <stddef.h>
 #undef __need_size_t
 
-#if defined (__STDC__)
+#if defined (__STDC__) || defined (__cplusplus)
 #define __gmp_const const
 #else
 #define __gmp_const
 #endif
 
 #if defined (__GNUC__)
-#define __gmp_inline inline
+#define __gmp_inline __inline__
 #else
 #define __gmp_inline
 #endif
 
+#ifndef _EXTERN_INLINE
+#ifdef __GNUC__
+#define _EXTERN_INLINE extern __inline__
+#else
+#define _EXTERN_INLINE static
+#endif
+#endif
+
 #ifdef _SHORT_LIMB
 typedef unsigned int           mp_limb;
 typedef int                    mp_limb_signed;
@@ -52,30 +61,30 @@ typedef long int            mp_limb_signed;
 
 typedef mp_limb *              mp_ptr;
 typedef __gmp_const mp_limb *  mp_srcptr;
-typedef int                    mp_size_t;
+typedef long int               mp_size_t;
 typedef long int               mp_exp_t;
 
 #ifndef __MP_SMALL__
 typedef struct
 {
-  mp_size_t alloc;             /* Number of *limbs* allocated and pointed
+  int _mp_alloc;               /* Number of *limbs* allocated and pointed
                                   to by the D field.  */
-  mp_size_t size;              /* abs(SIZE) is the number of limbs
+  int _mp_size;                        /* abs(SIZE) is the number of limbs
                                   the last field points to.  If SIZE
                                   is negative this is a negative
                                   number.  */
-  mp_limb *d;                  /* Pointer to the limbs.  */
+  mp_limb *_mp_d;              /* Pointer to the limbs.  */
 } __mpz_struct;
 #else
 typedef struct
 {
-  short int alloc;             /* Number of *limbs* allocated and pointed
+  short int _mp_alloc;         /* Number of *limbs* allocated and pointed
                                   to by the D field.  */
-  short int size;              /* abs(SIZE) is the number of limbs
+  short int _mp_size;          /* abs(SIZE) is the number of limbs
                                   the last field points to.  If SIZE
                                   is negative this is a negative
                                   number.  */
-  mp_limb *d;                  /* Pointer to the limbs.  */
+  mp_limb *_mp_d;              /* Pointer to the limbs.  */
 } __mpz_struct;
 #endif
 #endif /* __GNU_MP__ */
@@ -89,20 +98,20 @@ typedef __mpz_struct mpz_t[1];
    the numerator.  */
 typedef struct
 {
-  __mpz_struct num;
-  __mpz_struct den;
+  __mpz_struct _mp_num;
+  __mpz_struct _mp_den;
 #if 0
-  long int num_alloc;          /* Number of limbs allocated
+  int _mp_num_alloc;           /* Number of limbs allocated
                                   for the numerator.  */
-  long int num_size;           /* The absolute value of this field is the
+  int _mp_num_size;            /* The absolute value of this field is the
                                   length of the numerator; the sign is the
                                   sign of the entire rational number.  */
-  mp_ptr num;                  /* Pointer to the numerator limbs.  */
-  long int den_alloc;          /* Number of limbs allocated
+  mp_ptr _mp_num;              /* Pointer to the numerator limbs.  */
+  int _mp_den_alloc;           /* Number of limbs allocated
                                   for the denominator.  */
-  long int den_size;           /* Length of the denominator.  (This field
+  int _mp_den_size;            /* Length of the denominator.  (This field
                                   should always be positive.) */
-  mp_ptr den;                  /* Pointer to the denominator limbs.  */
+  mp_ptr _mp_den;              /* Pointer to the denominator limbs.  */
 #endif
 } __mpq_struct;
 
@@ -111,17 +120,17 @@ typedef __mpq_struct mpq_t[1];
 
 typedef struct
 {
-  mp_size_t prec;              /* Max precision, in number of `mp_limb's.
+  int _mp_prec;                        /* Max precision, in number of `mp_limb's.
                                   Set by mpf_init and modified by
                                   mpf_set_prec.  The area pointed to
                                   by the `d' field contains `prec' + 1
                                   limbs.  */
-  mp_size_t size;              /* abs(SIZE) is the number of limbs
+  int _mp_size;                        /* abs(SIZE) is the number of limbs
                                   the last field points to.  If SIZE
                                   is negative this is a negative
                                   number.  */
-  mp_exp_t exp;                        /* Exponent, in the base of `mp_limb'.  */
-  mp_limb *d;                  /* Pointer to the limbs.  */
+  mp_exp_t _mp_exp;            /* Exponent, in the base of `mp_limb'.  */
+  mp_limb *_mp_d;              /* Pointer to the limbs.  */
 } __mpf_struct;
 
 /* typedef __mpf_struct MP_FLOAT; */
@@ -136,36 +145,62 @@ typedef __mpf_struct *mpf_ptr;
 typedef __gmp_const __mpq_struct *mpq_srcptr;
 typedef __mpq_struct *mpq_ptr;
 
-#if defined (__STDC__)
+#ifndef _PROTO
+#if defined (__STDC__) || defined (__cplusplus)
 #define _PROTO(x) x
 #else
 #define _PROTO(x) ()
 #endif
+#endif
+
+#ifndef __MPN
+#define __MPN(x) __mpn_##x
+#endif
 
 #if defined (FILE) || defined (_STDIO_H_) || defined (__STDIO_H__) || defined (H_STDIO)
 #define _GMP_H_HAVE_FILE 1
 #endif
 
-void mp_set_memory_functions _PROTO((void *(*) (size_t),
-                                    void *(*) (void *, size_t, size_t),
-                                    void (*) (void *, size_t)));
+void mp_set_memory_functions _PROTO ((void *(*) (size_t),
+                                     void *(*) (void *, size_t, size_t),
+                                     void (*) (void *, size_t)));
 
 /**************** Integer (i.e. Z) routines.  ****************/
 
+#if defined (__cplusplus)
+extern "C" {
+#endif
 void *_mpz_realloc _PROTO ((mpz_ptr, mp_size_t));
 
 void mpz_abs _PROTO ((mpz_ptr, mpz_srcptr));
 void mpz_add _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 void mpz_add_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 void mpz_and _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
+void mpz_array_init _PROTO ((mpz_ptr, mp_size_t, mp_size_t));
+void mpz_cdiv_q _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
+unsigned long int mpz_cdiv_q_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
+void mpz_cdiv_qr _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr));
+unsigned long int mpz_cdiv_qr_ui _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int));
+void mpz_cdiv_r _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
+unsigned long int mpz_cdiv_r_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
+unsigned long int mpz_cdiv_ui _PROTO ((mpz_srcptr, unsigned long int));
 void mpz_clear _PROTO ((mpz_ptr));
 void mpz_clrbit _PROTO ((mpz_ptr, unsigned long int));
 int mpz_cmp _PROTO ((mpz_srcptr, mpz_srcptr));
 int mpz_cmp_si _PROTO ((mpz_srcptr, signed long int));
 int mpz_cmp_ui _PROTO ((mpz_srcptr, unsigned long int));
 void mpz_com _PROTO ((mpz_ptr, mpz_srcptr));
-void mpz_div_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
+void mpz_divexact _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 void mpz_fac_ui _PROTO ((mpz_ptr, unsigned long int));
+void mpz_fdiv_q _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
+void mpz_fdiv_q_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
+unsigned long int mpz_fdiv_q_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
+void mpz_fdiv_qr _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr));
+unsigned long int mpz_fdiv_qr_ui _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int));
+void mpz_fdiv_r _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
+void mpz_fdiv_r_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
+unsigned long int mpz_fdiv_r_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
+unsigned long int mpz_fdiv_ui _PROTO ((mpz_srcptr, unsigned long int));
 void mpz_gcd _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 unsigned long int mpz_gcd_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 void mpz_gcdext _PROTO ((mpz_ptr, mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr));
@@ -176,23 +211,27 @@ mp_limb mpz_getlimbn _PROTO ((mpz_srcptr, mp_size_t));
 mp_size_t mpz_hamdist _PROTO ((mpz_srcptr, mpz_srcptr));
 void mpz_init _PROTO ((mpz_ptr));
 #ifdef _GMP_H_HAVE_FILE
-void mpz_inp_raw _PROTO ((mpz_ptr, FILE *));
-int mpz_inp_str _PROTO ((mpz_ptr, FILE *, int));
+size_t mpz_inp_binary _PROTO ((mpz_ptr, FILE *));
+size_t mpz_inp_raw _PROTO ((mpz_ptr, FILE *));
+size_t mpz_inp_str _PROTO ((mpz_ptr, FILE *, int));
 #endif
-void mpz_ior _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 void mpz_init_set _PROTO ((mpz_ptr, mpz_srcptr));
 void mpz_init_set_si _PROTO ((mpz_ptr, signed long int));
 int mpz_init_set_str _PROTO ((mpz_ptr, const char *, int));
 void mpz_init_set_ui _PROTO ((mpz_ptr, unsigned long int));
-void mpz_lcm _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
-void mpz_mod_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
+int mpz_invert _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
+void mpz_ior _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
+int mpz_jacobi _PROTO ((mpz_srcptr, mpz_srcptr));
+int mpz_legendre _PROTO ((mpz_srcptr, mpz_srcptr));
+void mpz_mod _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 void mpz_mul _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 void mpz_mul_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 void mpz_mul_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 void mpz_neg _PROTO ((mpz_ptr, mpz_srcptr));
 #ifdef _GMP_H_HAVE_FILE
-void mpz_out_raw _PROTO ((FILE *, mpz_srcptr));
-void mpz_out_str _PROTO ((FILE *, int, mpz_srcptr));
+size_t mpz_out_binary _PROTO ((FILE *, mpz_srcptr));
+size_t mpz_out_raw _PROTO ((FILE *, mpz_srcptr));
+size_t mpz_out_str _PROTO ((FILE *, int, mpz_srcptr));
 #endif
 int mpz_perfect_square_p _PROTO ((mpz_srcptr));
 mp_size_t mpz_popcount _PROTO ((mpz_srcptr));
@@ -202,34 +241,30 @@ void mpz_powm_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int, mpz_srcptr));
 int mpz_probab_prime_p _PROTO ((mpz_srcptr, int));
 void mpz_random _PROTO ((mpz_ptr, mp_size_t));
 void mpz_random2 _PROTO ((mpz_ptr, mp_size_t));
+mp_size_t mpz_scan0 _PROTO ((mpz_srcptr, mp_size_t));
+mp_size_t mpz_scan1 _PROTO ((mpz_srcptr, mp_size_t));
 void mpz_set _PROTO ((mpz_ptr, mpz_srcptr));
+void mpz_set_d _PROTO ((mpz_ptr, double));
 void mpz_set_si _PROTO ((mpz_ptr, signed long int));
 int mpz_set_str _PROTO ((mpz_ptr, const char *, int));
 void mpz_set_ui _PROTO ((mpz_ptr, unsigned long int));
+void mpz_setbit _PROTO ((mpz_ptr, unsigned long int));
 size_t mpz_size _PROTO ((mpz_srcptr));
 size_t mpz_sizeinbase _PROTO ((mpz_srcptr, int));
 void mpz_sqrt _PROTO ((mpz_ptr, mpz_srcptr));
 void mpz_sqrtrem _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr));
 void mpz_sub _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 void mpz_sub_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
+void mpz_tdiv_q _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
+void mpz_tdiv_q_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
+void mpz_tdiv_q_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
+void mpz_tdiv_qr _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr));
+void mpz_tdiv_qr_ui _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int));
+void mpz_tdiv_r _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
+void mpz_tdiv_r_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
+void mpz_tdiv_r_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 void mpz_ui_pow_ui _PROTO ((mpz_ptr, unsigned long int, unsigned long int));
 
-void mpz_fdiv_q _PROTO((mpz_ptr, mpz_srcptr, mpz_srcptr));
-unsigned long int mpz_fdiv_q_ui _PROTO((mpz_ptr, mpz_srcptr, unsigned long int));
-void mpz_fdiv_qr _PROTO((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr));
-unsigned long int mpz_fdiv_qr_ui _PROTO((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int));
-void mpz_fdiv_r _PROTO((mpz_ptr, mpz_srcptr, mpz_srcptr));
-unsigned long int mpz_fdiv_r_ui _PROTO((mpz_ptr, mpz_srcptr, unsigned long int));
-unsigned long int mpz_fdiv_ui _PROTO((mpz_srcptr, unsigned long int));
-void mpz_tdiv_q _PROTO((mpz_ptr, mpz_srcptr, mpz_srcptr));
-void mpz_tdiv_q_ui _PROTO((mpz_ptr, mpz_srcptr, unsigned long int));
-void mpz_tdiv_qr _PROTO((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr));
-void mpz_tdiv_qr_ui _PROTO((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int));
-void mpz_tdiv_r _PROTO((mpz_ptr, mpz_srcptr, mpz_srcptr));
-void mpz_tdiv_r_ui _PROTO((mpz_ptr, mpz_srcptr, unsigned long int));
-
-void mpz_array_init (mpz_ptr, size_t, mp_size_t);
-
 /**************** Rational (i.e. Q) routines.  ****************/
 
 void mpq_init _PROTO ((mpq_ptr));
@@ -243,11 +278,14 @@ void mpq_mul _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr));
 void mpq_div _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr));
 void mpq_neg _PROTO ((mpq_ptr, mpq_srcptr));
 int mpq_cmp _PROTO ((mpq_srcptr, mpq_srcptr));
+int mpq_cmp_ui _PROTO ((mpq_srcptr, unsigned long int, unsigned long int));
 void mpq_inv _PROTO ((mpq_ptr, mpq_srcptr));
 void mpq_set_num _PROTO ((mpq_ptr, mpz_srcptr));
 void mpq_set_den _PROTO ((mpq_ptr, mpz_srcptr));
 void mpq_get_num _PROTO ((mpz_ptr, mpq_srcptr));
 void mpq_get_den _PROTO ((mpz_ptr, mpq_srcptr));
+double mpq_get_d _PROTO ((mpq_srcptr));
+void mpq_canonicalize _PROTO ((mpq_ptr));
 
 /**************** Float (i.e. F) routines.  ****************/
 
@@ -256,8 +294,9 @@ void mpf_add _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr));
 void mpf_add_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 void mpf_clear _PROTO ((mpf_ptr));
 int mpf_cmp _PROTO ((mpf_srcptr, mpf_srcptr));
-int mpf_cmp_si _PROTO ((mpf_srcptr, long int));
+int mpf_cmp_si _PROTO ((mpf_srcptr, signed long int));
 int mpf_cmp_ui _PROTO ((mpf_srcptr, unsigned long int));
+int mpf_diff _PROTO ((mpf_srcptr, mpf_srcptr, unsigned long int));
 void mpf_div _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr));
 void mpf_div_2exp _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 void mpf_div_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
@@ -266,11 +305,11 @@ char *mpf_get_str _PROTO ((char *, mp_exp_t *, int, size_t, mpf_srcptr));
 void mpf_init _PROTO ((mpf_ptr));
 void mpf_init2 _PROTO ((mpf_ptr, mp_size_t));
 #ifdef _GMP_H_HAVE_FILE
-void mpf_inp_str _PROTO ((mpf_ptr, FILE *, int));
+size_t mpf_inp_str _PROTO ((mpf_ptr, FILE *, int));
 #endif
 void mpf_init_set _PROTO ((mpf_ptr, mpf_srcptr));
 void mpf_init_set_d _PROTO ((mpf_ptr, double));
-void mpf_init_set_si _PROTO ((mpf_ptr, long int));
+void mpf_init_set_si _PROTO ((mpf_ptr, signed long int));
 int mpf_init_set_str _PROTO ((mpf_ptr, char *, int));
 void mpf_init_set_ui _PROTO ((mpf_ptr, unsigned long int));
 void mpf_mul _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr));
@@ -278,12 +317,14 @@ void mpf_mul_2exp _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 void mpf_mul_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 void mpf_neg _PROTO ((mpf_ptr, mpf_srcptr));
 #ifdef _GMP_H_HAVE_FILE
-void mpf_out_str _PROTO ((mpf_ptr, int, size_t, FILE *));
+size_t mpf_out_str _PROTO ((FILE *, int, size_t, mpf_srcptr));
 #endif
+void mpf_random2 _PROTO ((mpf_ptr, mp_size_t, mp_size_t));
 void mpf_set _PROTO ((mpf_ptr, mpf_srcptr));
 void mpf_set_d _PROTO ((mpf_ptr, double));
 mp_size_t mpf_set_default_prec _PROTO ((mp_size_t));
-void mpf_set_si _PROTO ((mpf_ptr, long int));
+void mpf_set_prec _PROTO ((mpf_ptr, mp_size_t));
+void mpf_set_si _PROTO ((mpf_ptr, signed long int));
 int mpf_set_str _PROTO ((mpf_ptr, const char *, int));
 void mpf_set_ui _PROTO ((mpf_ptr, unsigned long int));
 size_t mpf_size _PROTO ((mpf_srcptr));
@@ -292,68 +333,93 @@ void mpf_sqrt_ui _PROTO ((mpf_ptr, unsigned long int));
 void mpf_sub _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr));
 void mpf_sub_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 void mpf_ui_div _PROTO ((mpf_ptr, unsigned long int, mpf_srcptr));
-
+void mpf_ui_sub _PROTO ((mpf_ptr, unsigned long int, mpf_srcptr));
+#if defined (__cplusplus)
+}
+#endif
 /************ Low level positive-integer (i.e. N) routines.  ************/
 
 /* This is ugly, but we need to make usr calls reach the prefixed function.  */
-#define mpn_add_n      __mpn_add_n
-#define mpn_sub_n      __mpn_sub_n
-#define mpn_mul_1      __mpn_mul_1
-#define mpn_addmul_1   __mpn_addmul_1
-#define mpn_submul_1   __mpn_submul_1
-#define mpn_lshift     __mpn_lshift
-#define mpn_rshift     __mpn_rshift
-#define mpn_sub                __mpn_sub
-#define mpn_add                __mpn_add
-#define mpn_normal_size        __mpn_normal_size
-#define mpn_cmp                __mpn_cmp
-#define mpn_add_1      __mpn_add_1
-#define mpn_sub_1      __mpn_sub_1
-#define mpn_mul_n      __mpn_mul_n
-#define mpn_mul                __mpn_mul
-#define mpn_divmod     __mpn_divmod
-#define mpn_divmod_1   __mpn_divmod_1
-#define mpn_mod_1      __mpn_mod_1
-#define mpn_sqrt       __mpn_sqrt
-#define mpn_next_bit_set __mpn_next_bit_set
-#define mpn_popcount   __mpn_popcount
-#define mpn_hamdist    __mpn_hamdist
-#define mpn_random2    __mpn_random2
-#define mpn_set_str    __mpn_set_str
-#define mpn_get_str    __mpn_get_str
-#define mpn_gcd_1      __mpn_gcd_1
-
-mp_limb __mpn_add_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t));
-mp_limb __mpn_sub_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t));
-mp_limb __mpn_mul _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t));
-void __mpn_mul_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t));
-mp_limb __mpn_mul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb));
-mp_limb __mpn_addmul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb));
-mp_limb __mpn_submul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb));
-mp_limb __mpn_divmod _PROTO ((mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t));
-mp_limb __mpn_divmod_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb));
-mp_limb __mpn_mod_1 _PROTO ((mp_srcptr, mp_size_t, mp_limb));
-mp_limb __mpn_lshift _PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int));
-mp_limb __mpn_rshift _PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int));
-mp_size_t __mpn_sqrt _PROTO ((mp_ptr, mp_ptr, mp_srcptr, mp_size_t));
-int __mpn_cmp _PROTO ((mp_srcptr, mp_srcptr, mp_size_t));
-mp_size_t __mpn_next_bit_set _PROTO ((mp_srcptr, mp_size_t));
-mp_size_t __mpn_popcount _PROTO ((mp_srcptr, mp_size_t));
-mp_size_t __mpn_hamdist _PROTO ((mp_srcptr, mp_srcptr, mp_size_t));
-void __mpn_random2 _PROTO ((mp_ptr, mp_size_t));
-mp_size_t __mpn_set_str _PROTO ((mp_ptr, const unsigned char *, size_t, int));
-size_t __mpn_get_str _PROTO ((unsigned char *, int, mp_ptr, mp_size_t));
-mp_limb __mpn_gcd_1 _PROTO ((mp_srcptr, mp_size_t, mp_limb));
-
-
-static __gmp_inline mp_limb
-#if defined (__STDC__)
-__mpn_add_1 (register mp_ptr res_ptr,
-            register mp_srcptr s1_ptr,
-            register mp_size_t s1_size,
-            register mp_limb s2_limb)
+#define mpn_add                        __MPN(add)
+#define mpn_add_1              __MPN(add_1)
+#define mpn_add_n              __MPN(add_n)
+#define mpn_addmul_1           __MPN(addmul_1)
+#define mpn_bdivmod            __MPN(bdivmod)
+#define mpn_cmp                        __MPN(cmp)
+#define mpn_divmod_1           __MPN(divmod_1)
+#define mpn_divrem             __MPN(divrem)
+#define mpn_divrem_1           __MPN(divrem_1)
+#define mpn_dump               __MPN(dump)
+#define mpn_gcd                        __MPN(gcd)
+#define mpn_gcd_1              __MPN(gcd_1)
+#define mpn_gcdext             __MPN(gcdext)
+#define mpn_get_str            __MPN(get_str)
+#define mpn_hamdist            __MPN(hamdist)
+#define mpn_lshift             __MPN(lshift)
+#define mpn_mod_1              __MPN(mod_1)
+#define mpn_mul                        __MPN(mul)
+#define mpn_mul_1              __MPN(mul_1)
+#define mpn_mul_n              __MPN(mul_n)
+#define mpn_perfect_square_p   __MPN(perfect_square_p)
+#define mpn_popcount           __MPN(popcount)
+#define mpn_preinv_mod_1       __MPN(preinv_mod_1)
+#define mpn_random2            __MPN(random2)
+#define mpn_rshift             __MPN(rshift)
+#define mpn_scan0              __MPN(scan0)
+#define mpn_scan1              __MPN(scan1)
+#define mpn_set_str            __MPN(set_str)
+#define mpn_sqrtrem            __MPN(sqrtrem)
+#define mpn_sub                        __MPN(sub)
+#define mpn_sub_1              __MPN(sub_1)
+#define mpn_sub_n              __MPN(sub_n)
+#define mpn_submul_1           __MPN(submul_1)
+#define mpn_udiv_w_sdiv                __MPN(udiv_w_sdiv)
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+mp_limb mpn_add_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t));
+mp_limb mpn_addmul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb));
+mp_limb mpn_bdivmod _PROTO ((mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, unsigned long int));
+int mpn_cmp _PROTO ((mp_srcptr, mp_srcptr, mp_size_t));
+mp_limb mpn_divmod_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb));
+mp_limb mpn_divrem _PROTO ((mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr, mp_size_t));
+mp_limb mpn_divrem_1 _PROTO ((mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_limb));
+void mpn_dump _PROTO ((mp_srcptr, mp_size_t));
+mp_size_t mpn_gcd _PROTO ((mp_ptr, mp_ptr, mp_size_t, mp_ptr, mp_size_t));
+mp_limb mpn_gcd_1 _PROTO ((mp_srcptr, mp_size_t, mp_limb));
+mp_size_t mpn_gcdext _PROTO ((mp_ptr, mp_ptr, mp_ptr, mp_size_t, mp_ptr, mp_size_t));
+size_t mpn_get_str _PROTO ((unsigned char *, int, mp_ptr, mp_size_t));
+mp_size_t mpn_hamdist _PROTO ((mp_srcptr, mp_srcptr, mp_size_t));
+mp_limb mpn_lshift _PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int));
+mp_limb mpn_mod_1 _PROTO ((mp_srcptr, mp_size_t, mp_limb));
+mp_limb mpn_mul _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t));
+mp_limb mpn_mul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb));
+void mpn_mul_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t));
+int mpn_perfect_square_p _PROTO ((mp_srcptr, mp_size_t));
+mp_size_t mpn_popcount _PROTO ((mp_srcptr, mp_size_t));
+mp_limb mpn_preinv_mod_1 _PROTO ((mp_srcptr, mp_size_t, mp_limb, mp_limb));
+void mpn_random2 _PROTO ((mp_ptr, mp_size_t));
+mp_limb mpn_rshift _PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int));
+mp_size_t mpn_scan0 _PROTO ((mp_srcptr, mp_size_t));
+mp_size_t mpn_scan1 _PROTO ((mp_srcptr, mp_size_t));
+mp_size_t mpn_set_str _PROTO ((mp_ptr, const unsigned char *, size_t, int));
+mp_size_t mpn_sqrtrem _PROTO ((mp_ptr, mp_ptr, mp_srcptr, mp_size_t));
+mp_limb mpn_sub_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t));
+mp_limb mpn_submul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb));
+#if defined (__cplusplus)
+}
+#endif
+
+#if defined (__GNUC__) || defined (_FORCE_INLINES)
+_EXTERN_INLINE mp_limb
+#if defined (__STDC__) || defined (__cplusplus)
+mpn_add_1 (register mp_ptr res_ptr,
+          register mp_srcptr s1_ptr,
+          register mp_size_t s1_size,
+          register mp_limb s2_limb)
 #else
-__mpn_add_1 (res_ptr, s1_ptr, s1_size, s2_limb)
+mpn_add_1 (res_ptr, s1_ptr, s1_size, s2_limb)
      register mp_ptr res_ptr;
      register mp_srcptr s1_ptr;
      register mp_size_t s1_size;
@@ -388,15 +454,15 @@ __mpn_add_1 (res_ptr, s1_ptr, s1_size, s2_limb)
   return 0;
 }
 
-static __gmp_inline mp_limb
-#if defined (__STDC__)
-__mpn_add (register mp_ptr res_ptr,
-          register mp_srcptr s1_ptr,
-          register mp_size_t s1_size,
-          register mp_srcptr s2_ptr,
-          register mp_size_t s2_size)
+_EXTERN_INLINE mp_limb
+#if defined (__STDC__) || defined (__cplusplus)
+mpn_add (register mp_ptr res_ptr,
+        register mp_srcptr s1_ptr,
+        register mp_size_t s1_size,
+        register mp_srcptr s2_ptr,
+        register mp_size_t s2_size)
 #else
-__mpn_add (res_ptr, s1_ptr, s1_size, s2_ptr, s2_size)
+mpn_add (res_ptr, s1_ptr, s1_size, s2_ptr, s2_size)
      register mp_ptr res_ptr;
      register mp_srcptr s1_ptr;
      register mp_size_t s1_size;
@@ -407,24 +473,24 @@ __mpn_add (res_ptr, s1_ptr, s1_size, s2_ptr, s2_size)
   mp_limb cy_limb = 0;
 
   if (s2_size != 0)
-    cy_limb = __mpn_add_n (res_ptr, s1_ptr, s2_ptr, s2_size);
+    cy_limb = mpn_add_n (res_ptr, s1_ptr, s2_ptr, s2_size);
 
   if (s1_size - s2_size != 0)
-    cy_limb =  __mpn_add_1 (res_ptr + s2_size,
-                           s1_ptr + s2_size,
-                           s1_size - s2_size,
-                           cy_limb);
+    cy_limb = mpn_add_1 (res_ptr + s2_size,
+                        s1_ptr + s2_size,
+                        s1_size - s2_size,
+                        cy_limb);
   return cy_limb;
 }
 
-static __gmp_inline mp_limb
-#if defined (__STDC__)
-__mpn_sub_1 (register mp_ptr res_ptr,
-            register mp_srcptr s1_ptr,
-            register mp_size_t s1_size,
-            register mp_limb s2_limb)
+_EXTERN_INLINE mp_limb
+#if defined (__STDC__) || defined (__cplusplus)
+mpn_sub_1 (register mp_ptr res_ptr,
+          register mp_srcptr s1_ptr,
+          register mp_size_t s1_size,
+          register mp_limb s2_limb)
 #else
-__mpn_sub_1 (res_ptr, s1_ptr, s1_size, s2_limb)
+mpn_sub_1 (res_ptr, s1_ptr, s1_size, s2_limb)
      register mp_ptr res_ptr;
      register mp_srcptr s1_ptr;
      register mp_size_t s1_size;
@@ -459,15 +525,15 @@ __mpn_sub_1 (res_ptr, s1_ptr, s1_size, s2_limb)
   return 0;
 }
 
-static __gmp_inline mp_limb
-#if defined (__STDC__)
-__mpn_sub (register mp_ptr res_ptr,
-          register mp_srcptr s1_ptr,
-          register mp_size_t s1_size,
-          register mp_srcptr s2_ptr,
-          register mp_size_t s2_size)
+_EXTERN_INLINE mp_limb
+#if defined (__STDC__) || defined (__cplusplus)
+mpn_sub (register mp_ptr res_ptr,
+        register mp_srcptr s1_ptr,
+        register mp_size_t s1_size,
+        register mp_srcptr s2_ptr,
+        register mp_size_t s2_size)
 #else
-__mpn_sub (res_ptr, s1_ptr, s1_size, s2_ptr, s2_size)
+mpn_sub (res_ptr, s1_ptr, s1_size, s2_ptr, s2_size)
      register mp_ptr res_ptr;
      register mp_srcptr s1_ptr;
      register mp_size_t s1_size;
@@ -478,36 +544,46 @@ __mpn_sub (res_ptr, s1_ptr, s1_size, s2_ptr, s2_size)
   mp_limb cy_limb = 0;
 
   if (s2_size != 0)
-    cy_limb = __mpn_sub_n (res_ptr, s1_ptr, s2_ptr, s2_size);
+    cy_limb = mpn_sub_n (res_ptr, s1_ptr, s2_ptr, s2_size);
 
   if (s1_size - s2_size != 0)
-    cy_limb =  __mpn_sub_1 (res_ptr + s2_size,
-                           s1_ptr + s2_size,
-                           s1_size - s2_size,
-                           cy_limb);
+    cy_limb = mpn_sub_1 (res_ptr + s2_size,
+                        s1_ptr + s2_size,
+                        s1_size - s2_size,
+                        cy_limb);
   return cy_limb;
 }
+#endif /* __GNUC__ */
 
-static __gmp_inline mp_size_t
-#if defined (__STDC__)
-__mpn_normal_size (mp_srcptr ptr, mp_size_t size)
-#else
-__mpn_normal_size (ptr, size)
-     mp_srcptr ptr;
-     mp_size_t size;
+/* Allow faster testing for negative, zero, and positive.  */
+#define mpz_sign(Z) ((Z)->_mp_size)
+#define mpf_sign(F) ((F)->_mp_size)
+#define mpq_sign(Q) ((Q)->_mp_num._mp_size)
+
+/* Allow direct user access to numerator and denominator of a mpq_t object.  */
+#define mpq_numref(Q) (&((Q)->_mp_num))
+#define mpq_denref(Q) (&((Q)->_mp_den))
+
+/* When using GCC, optimize certain common comparisons.  */
+#if defined (__GNUC__)
+#define mpz_cmp_ui(Z,UI) \
+  (__builtin_constant_p (UI) && (UI) == 0                              \
+   ? mpz_sign (Z) : mpz_cmp_ui (Z,UI))
+#define mpz_cmp_si(Z,UI) \
+  (__builtin_constant_p (UI) && (UI) == 0 ? mpz_sign (Z)               \
+   : __builtin_constant_p (UI) && (UI) > 0 ? mpz_cmp_ui (Z,UI)         \
+   : mpz_cmp_si (Z,UI))
+#define mpq_cmp_ui(Q,NUI,DUI) \
+  (__builtin_constant_p (NUI) && (NUI) == 0                            \
+   ? mpq_sign (Q) : mpq_cmp_ui (Q,NUI,DUI))
 #endif
-{
-  while (size)
-    {
-      size--;
-      if (ptr[size] != 0)
-       return size + 1;
-    }
-  return 0;
-}
 
-/* Compatibility with GMP 1.  */
+#define mpn_divmod(qp,np,nsize,dp,dsize) mpn_divrem (qp,0,np,nsize,dp,dsize)
+#if 0
+#define mpn_divmod_1(qp,np,nsize,dlimb) mpn_divrem_1 (qp,0,np,nsize,dlimb)
+#endif
 
+/* Compatibility with GMP 1.  */
 #define mpz_mdiv       mpz_fdiv_q
 #define mpz_mdivmod    mpz_fdiv_qr
 #define mpz_mmod       mpz_fdiv_r
@@ -516,10 +592,6 @@ __mpn_normal_size (ptr, size)
   ((r == 0) ? mpz_fdiv_q_ui (q,n,d) : mpz_fdiv_qr_ui (q,r,n,d))
 #define mpz_mmod_ui(r,n,d) \
   ((r == 0) ? mpz_fdiv_ui (n,d) : mpz_fdiv_r_ui (r,n,d))
-/* ??? Before release...
-#define mpz_div_2exp   mpz_fdiv_q_2exp
-#define mpz_mod_2exp   mpz_fdiv_r_2exp
-*/
 
 /* Useful synonyms, but not quite compatible with GMP 1.  */
 #define mpz_div                mpz_fdiv_q
@@ -527,10 +599,10 @@ __mpn_normal_size (ptr, size)
 #define mpz_div_ui     mpz_fdiv_q_ui
 #define mpz_divmod_ui  mpz_fdiv_qr_ui
 #define mpz_mod_ui     mpz_fdiv_r_ui
+#define mpz_div_2exp   mpz_fdiv_q_2exp
+#define mpz_mod_2exp   mpz_fdiv_r_2exp
 
-
-#define __GNU_MP__ 2
 #define __GNU_MP_VERSION 2
-#define __GNU_MP_VERSION_MINOR -900 /* ??? */
+#define __GNU_MP_VERSION_MINOR -927 /* ??? */
 #define __GMP_H__
 #endif /* __GMP_H__ */
index 7e4cccc..d564479 100644 (file)
@@ -1,7 +1,7 @@
 ; mc88100 __mpn_add -- Add two limb vectors of the same length > 0 and store
 ; sum in a third limb vector.
 
-; Copyright (C) 1992, 1994 Free Software Foundation, Inc.
+; Copyright (C) 1992, 1994, 1995 Free Software Foundation, Inc.
 
 ; This file is part of the GNU MP Library.
 
index 35c238d..6b8492c 100644 (file)
@@ -1,7 +1,7 @@
 ; mc88100 __mpn_mul_1 -- Multiply a limb vector with a single limb and
 ; store the product in a second limb vector.
 
-; Copyright (C) 1992, 1994 Free Software Foundation, Inc.
+; Copyright (C) 1992, 1994, 1995 Free Software Foundation, Inc.
 
 ; This file is part of the GNU MP Library.
 
@@ -55,14 +55,14 @@ ___mpn_mul_1:
        ; Make S1_PTR and RES_PTR point at the end of their blocks
        ; and negate SIZE.
        lda      r3,r3[r4]
-       lda      r6,r2[r4]              ; RES_PTR in r6 since r2 is retval
+       lda      r6,r2[r4]      ; RES_PTR in r6 since r2 is retval
        subu     r4,r0,r4
 
-       addu.co  r2,r0,r0               ; r2 = cy = 0
+       addu.co  r2,r0,r0       ; r2 = cy = 0
        ld       r9,r3[r4]
-       mask     r7,r5,0xffff           ; r7 = lo(S2_LIMB)
-       extu     r8,r5,16               ; r8 = hi(S2_LIMB)
-       bcnd.n   eq0,r8,Lsmall          ; jump if (hi(S2_LIMB) == 0)
+       mask     r7,r5,0xffff   ; r7 = lo(S2_LIMB)
+       extu     r8,r5,16       ; r8 = hi(S2_LIMB)
+       bcnd.n   eq0,r8,Lsmall  ; jump if (hi(S2_LIMB) == 0)
         subu    r6,r6,4
 
 ; General code for any value of S2_LIMB.
@@ -75,28 +75,27 @@ ___mpn_mul_1:
        br.n    L1
        addu     r4,r4,1
 
-Loop:
-       ld       r9,r3[r4]
+Loop:  ld       r9,r3[r4]
        st       r26,r6[r4]
-; bcnd ne0,r0,0                        ; bubble
+; bcnd ne0,r0,0                ; bubble
        addu     r4,r4,1
-L1:    mul      r26,r9,r5              ; low word of product   mul_1   WB ld
-       mask     r12,r9,0xffff          ; r12 = lo(s1_limb)     mask_1
-       mul      r11,r12,r7             ; r11 =  prod_0         mul_2   WB mask_1
-       mul      r10,r12,r8             ; r10 = prod_1a         mul_3
-       extu     r13,r9,16              ; r13 = hi(s1_limb)     extu_1  WB mul_1
-       mul      r12,r13,r7             ; r12 = prod_1b         mul_4   WB extu_1
-       mul      r25,r13,r8             ; r25  = prod_2         mul_5   WB mul_2
-       extu     r11,r11,16             ; r11 = hi(prod_0)      extu_2  WB mul_3
-       addu     r10,r10,r11            ;                       addu_1  WB extu_2
-; bcnd ne0,r0,0                        ; bubble                        WB addu_1
-       addu.co  r10,r10,r12            ;                               WB mul_4
-       mask.u   r10,r10,0xffff         ; move the 16 most significant bits...
-       addu.ci  r10,r10,r0             ; ...to the low half of the word...
-       rot      r10,r10,16             ; ...and put carry in pos 16.
-       addu.co  r26,r26,r2             ; add old carry limb
+L1:    mul      r26,r9,r5      ; low word of product   mul_1   WB ld
+       mask     r12,r9,0xffff  ; r12 = lo(s1_limb)     mask_1
+       mul      r11,r12,r7     ; r11 =  prod_0         mul_2   WB mask_1
+       mul      r10,r12,r8     ; r10 = prod_1a         mul_3
+       extu     r13,r9,16      ; r13 = hi(s1_limb)     extu_1  WB mul_1
+       mul      r12,r13,r7     ; r12 = prod_1b         mul_4   WB extu_1
+       mul      r25,r13,r8     ; r25  = prod_2         mul_5   WB mul_2
+       extu     r11,r11,16     ; r11 = hi(prod_0)      extu_2  WB mul_3
+       addu     r10,r10,r11    ;                       addu_1  WB extu_2
+; bcnd ne0,r0,0                ; bubble                        WB addu_1
+       addu.co  r10,r10,r12    ;                               WB mul_4
+       mask.u   r10,r10,0xffff ; move the 16 most significant bits...
+       addu.ci  r10,r10,r0     ; ...to the low half of the word...
+       rot      r10,r10,16     ; ...and put carry in pos 16.
+       addu.co  r26,r26,r2     ; add old carry limb
        bcnd.n   ne0,r4,Loop
-        addu.ci r2,r25,r10             ; compute new carry limb
+        addu.ci r2,r25,r10     ; compute new carry limb
 
        st       r26,r6[r4]
        ld.d     r25,r31,8
@@ -109,20 +108,19 @@ Lsmall:
        br.n    SL1
        addu     r4,r4,1
 
-SLoop:
-       ld       r9,r3[r4]              ;
-       st       r8,r6[r4]              ;
-       addu     r4,r4,1                ;
-SL1:   mul      r8,r9,r5               ; low word of product
-       mask     r12,r9,0xffff          ; r12 = lo(s1_limb)
-       extu     r13,r9,16              ; r13 = hi(s1_limb)
-       mul      r11,r12,r7             ; r11 =  prod_0
-       mul      r12,r13,r7             ; r12 = prod_1b
-       addu.cio r8,r8,r2               ; add old carry limb
-       extu     r10,r11,16             ; r11 = hi(prod_0)
-       addu     r10,r10,r12            ;
+SLoop: ld       r9,r3[r4]      ;
+       st       r8,r6[r4]      ;
+       addu     r4,r4,1        ;
+SL1:   mul      r8,r9,r5       ; low word of product
+       mask     r12,r9,0xffff  ; r12 = lo(s1_limb)
+       extu     r13,r9,16      ; r13 = hi(s1_limb)
+       mul      r11,r12,r7     ; r11 =  prod_0
+       mul      r12,r13,r7     ; r12 = prod_1b
+       addu.cio r8,r8,r2       ; add old carry limb
+       extu     r10,r11,16     ; r11 = hi(prod_0)
+       addu     r10,r10,r12    ;
        bcnd.n   ne0,r4,SLoop
-       extu     r2,r10,16              ; r2 = new carry limb
+       extu     r2,r10,16      ; r2 = new carry limb
 
        jmp.n    r1
        st       r8,r6[r4]
index 3963cd5..cd0b791 100644 (file)
@@ -1,7 +1,7 @@
 ; mc88100 __mpn_sub -- Subtract two limb vectors of the same length > 0 and
 ; store difference in a third limb vector.
 
-; Copyright (C) 1992, 1994 Free Software Foundation, Inc.
+; Copyright (C) 1992, 1994, 1996 Free Software Foundation, Inc.
 
 ; This file is part of the GNU MP Library.
 
@@ -41,9 +41,10 @@ ___mpn_sub_n:
        extu    r10,r5,3
        ld      r7,r4,0                 ; read first limb from s2_ptr
 
-       subu.co r5,r0,r5                ; (clear carry as side effect)
+       subu    r5,r0,r5
        mak     r5,r5,3<4>
-       bcnd    eq0,r5,Lzero
+       bcnd.n  eq0,r5,Lzero
+       subu.co r0,r0,r0                ; initialize carry
 
        or      r12,r0,lo16(Lbase)
        or.u    r12,r12,hi16(Lbase)
index 687f12a..ddc308a 100644 (file)
@@ -1,6 +1,6 @@
 /* gmp-mparam.h -- Compiler/machine parameter header file.
 
-Copyright (C) 1991, 1993, 1994 Free Software Foundation, Inc.
+Copyright (C) 1991, 1993, 1994, 1995 Free Software Foundation, Inc.
 
 This file is part of the GNU MP Library.
 
index 2075225..0150e85 100644 (file)
@@ -1,7 +1,7 @@
 ! Z8000 __mpn_mul_1 -- Multiply a limb vector with a limb and store
 ! the result in a second limb vector.
 
-! Copyright (C) 1993, 1994 Free Software Foundation, Inc.
+! Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
 
 ! This file is part of the GNU MP Library.