URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [config/] [m68k/] [fpgnulib.c] - Blame information for rev 282

Details | Compare with Previous | View Log


/* This is a stripped down version of floatlib.c.  It supplies only those
   functions which exist in libgcc, but for which there is not assembly
   language versions in m68k/lb1sf68.asm.
 
   It also includes simplistic support for extended floats (by working in
   double precision).  You must compile this file again with -DEXTFLOAT
   to get this support.  */
 
/*
** gnulib support for software floating point.
** Copyright (C) 1991 by Pipeline Associates, Inc.  All rights reserved.
** Permission is granted to do *anything* you want with this file,
** commercial or otherwise, provided this message remains intact.  So there!
** I would appreciate receiving any updates/patches/changes that anyone
** makes, and am willing to be the repository for said changes (am I
** making a big mistake?).
**
** Pat Wood
** Pipeline Associates, Inc.
** pipeline!phw@motown.com or
** sun!pipeline!phw or
** uunet!motown!pipeline!phw
**
** 05/01/91 -- V1.0 -- first release to gcc mailing lists
** 05/04/91 -- V1.1 -- added float and double prototypes and return values
**                  -- fixed problems with adding and subtracting zero
**                  -- fixed rounding in truncdfsf2
**                  -- fixed SWAP define and tested on 386
*/
 
/*
** The following are routines that replace the gnulib soft floating point
** routines that are called automatically when -msoft-float is selected.
** The support single and double precision IEEE format, with provisions
** for byte-swapped machines (tested on 386).  Some of the double-precision
** routines work at full precision, but most of the hard ones simply punt
** and call the single precision routines, producing a loss of accuracy.
** long long support is not assumed or included.
** Overall accuracy is close to IEEE (actually 68882) for single-precision
** arithmetic.  I think there may still be a 1 in 1000 chance of a bit
** being rounded the wrong way during a multiply.  I'm not fussy enough to
** bother with it, but if anyone is, knock yourself out.
**
** Efficiency has only been addressed where it was obvious that something
** would make a big difference.  Anyone who wants to do this right for
** best speed should go in and rewrite in assembler.
**
** I have tested this only on a 68030 workstation and 386/ix integrated
** in with -msoft-float.
*/
 
/* the following deal with IEEE single-precision numbers */
#define EXCESS          126L
#define SIGNBIT         0x80000000L
#define HIDDEN          (1L << 23L)
#define SIGN(fp)        ((fp) & SIGNBIT)
#define EXP(fp)         (((fp) >> 23L) & 0xFF)
#define MANT(fp)        (((fp) & 0x7FFFFFL) | HIDDEN)
#define PACK(s,e,m)     ((s) | ((e) << 23L) | (m))
 
/* the following deal with IEEE double-precision numbers */
#define EXCESSD         1022L
#define HIDDEND         (1L << 20L)
#define EXPDBITS        11
#define EXPDMASK        0x7FFL
#define EXPD(fp)        (((fp.l.upper) >> 20L) & 0x7FFL)
#define SIGND(fp)       ((fp.l.upper) & SIGNBIT)
#define MANTD(fp)       (((((fp.l.upper) & 0xFFFFF) | HIDDEND) << 10) | \
                                (fp.l.lower >> 22))
#define MANTDMASK       0xFFFFFL /* mask of upper part */
 
/* the following deal with IEEE extended-precision numbers */
#define EXCESSX         16382L
#define HIDDENX         (1L << 31L)
#define EXPXBITS        15
#define EXPXMASK        0x7FFF
#define EXPX(fp)        (((fp.l.upper) >> 16) & EXPXMASK)
#define SIGNX(fp)       ((fp.l.upper) & SIGNBIT)
#define MANTXMASK       0x7FFFFFFFL /* mask of upper part */
 
union double_long
{
  double d;
  struct {
      long upper;
      unsigned long lower;
    } l;
};
 
union float_long {
  float f;
  long l;
};
 
union long_double_long
{
  long double ld;
  struct
    {
      long upper;
      unsigned long middle;
      unsigned long lower;
    } l;
};
 
#ifndef EXTFLOAT
 
int
__unordsf2(float a, float b)
{
  union float_long fl;
 
  fl.f = a;
  if (EXP(fl.l) == EXP(~0u) && (MANT(fl.l) & ~HIDDEN) != 0)
    return 1;
  fl.f = b;
  if (EXP(fl.l) == EXP(~0u) && (MANT(fl.l) & ~HIDDEN) != 0)
    return 1;
  return 0;
}
 
int
__unorddf2(double a, double b)
{
  union double_long dl;
 
  dl.d = a;
  if (EXPD(dl) == EXPDMASK
      && ((dl.l.upper & MANTDMASK) != 0 || dl.l.lower != 0))
    return 1;
  dl.d = b;
  if (EXPD(dl) == EXPDMASK
      && ((dl.l.upper & MANTDMASK) != 0 || dl.l.lower != 0))
    return 1;
  return 0;
}
 
/* convert unsigned int to double */
double
__floatunsidf (unsigned long a1)
{
  long exp = 32 + EXCESSD;
  union double_long dl;
 
  if (!a1)
    {
      dl.l.upper = dl.l.lower = 0;
      return dl.d;
    }
 
  while (a1 < 0x2000000L)
    {
      a1 <<= 4;
      exp -= 4;
    }
 
  while (a1 < 0x80000000L)
    {
      a1 <<= 1;
      exp--;
    }
 
  /* pack up and go home */
  dl.l.upper = exp << 20L;
  dl.l.upper |= (a1 >> 11L) & ~HIDDEND;
  dl.l.lower = a1 << 21L;
 
  return dl.d;
}
 
/* convert int to double */
double
__floatsidf (long a1)
{
  long sign = 0, exp = 31 + EXCESSD;
  union double_long dl;
 
  if (!a1)
    {
      dl.l.upper = dl.l.lower = 0;
      return dl.d;
    }
 
  if (a1 < 0)
    {
      sign = SIGNBIT;
      a1 = (long)-(unsigned long)a1;
      if (a1 < 0)
        {
          dl.l.upper = SIGNBIT | ((32 + EXCESSD) << 20L);
          dl.l.lower = 0;
          return dl.d;
        }
    }
 
  while (a1 < 0x1000000L)
    {
      a1 <<= 4;
      exp -= 4;
    }
 
  while (a1 < 0x40000000L)
    {
      a1 <<= 1;
      exp--;
    }
 
  /* pack up and go home */
  dl.l.upper = sign;
  dl.l.upper |= exp << 20L;
  dl.l.upper |= (a1 >> 10L) & ~HIDDEND;
  dl.l.lower = a1 << 22L;
 
  return dl.d;
}
 
/* convert unsigned int to float */
float
__floatunsisf (unsigned long l)
{
  double foo = __floatunsidf (l);
  return foo;
}
 
/* convert int to float */
float
__floatsisf (long l)
{
  double foo = __floatsidf (l);
  return foo;
}
 
/* convert float to double */
double
__extendsfdf2 (float a1)
{
  register union float_long fl1;
  register union double_long dl;
  register long exp;
  register long mant;
 
  fl1.f = a1;
 
  dl.l.upper = SIGN (fl1.l);
  if ((fl1.l & ~SIGNBIT) == 0)
    {
      dl.l.lower = 0;
      return dl.d;
    }
 
  exp = EXP(fl1.l);
  mant = MANT (fl1.l) & ~HIDDEN;
  if (exp == 0)
    {
      /* Denormal.  */
      exp = 1;
      while (!(mant & HIDDEN))
        {
          mant <<= 1;
          exp--;
        }
      mant &= ~HIDDEN;
    }
  exp = exp - EXCESS + EXCESSD;
  dl.l.upper |= exp << 20;
  dl.l.upper |= mant >> 3;
  dl.l.lower = mant << 29;
 
  return dl.d;
}
 
/* convert double to float */
float
__truncdfsf2 (double a1)
{
  register long exp;
  register long mant;
  register union float_long fl;
  register union double_long dl1;
  int sticky;
  int shift;
 
  dl1.d = a1;
 
  if ((dl1.l.upper & ~SIGNBIT) == 0 && !dl1.l.lower)
    {
      fl.l = SIGND(dl1);
      return fl.f;
    }
 
  exp = EXPD (dl1) - EXCESSD + EXCESS;
 
  sticky = dl1.l.lower & ((1 << 22) - 1);
  mant = MANTD (dl1);
  /* shift double mantissa 6 bits so we can round */
  sticky |= mant & ((1 << 6) - 1);
  mant >>= 6;
 
  /* Check for underflow and denormals.  */
  if (exp <= 0)
    {
      if (exp < -24)
        {
          sticky |= mant;
          mant = 0;
        }
      else
        {
          sticky |= mant & ((1 << (1 - exp)) - 1);
          mant >>= 1 - exp;
        }
      exp = 0;
    }
 
  /* now round */
  shift = 1;
  if ((mant & 1) && (sticky || (mant & 2)))
    {
      int rounding = exp ? 2 : 1;
 
      mant += 1;
 
      /* did the round overflow? */
      if (mant >= (HIDDEN << rounding))
        {
          exp++;
          shift = rounding;
        }
    }
  /* shift down */
  mant >>= shift;
 
  mant &= ~HIDDEN;
 
  /* pack up and go home */
  fl.l = PACK (SIGND (dl1), exp, mant);
  return (fl.f);
}
 
/* convert double to int */
long
__fixdfsi (double a1)
{
  register union double_long dl1;
  register long exp;
  register long l;
 
  dl1.d = a1;
 
  if (!dl1.l.upper && !dl1.l.lower)
    return 0;
 
  exp = EXPD (dl1) - EXCESSD - 31;
  l = MANTD (dl1);
 
  if (exp > 0)
    {
      /* Return largest integer.  */
      return SIGND (dl1) ? 0x80000000L : 0x7fffffffL;
    }
 
  if (exp <= -32)
    return 0;
 
  /* shift down until exp = 0 */
  if (exp < 0)
    l >>= -exp;
 
  return (SIGND (dl1) ? -l : l);
}
 
/* convert float to int */
long
__fixsfsi (float a1)
{
  double foo = a1;
  return __fixdfsi (foo);
}
 
#else /* EXTFLOAT */
 
/* We do not need these routines for coldfire, as it has no extended
   float format. */
#if !defined (__mcoldfire__)
 
/* Primitive extended precision floating point support.
 
   We assume all numbers are normalized, don't do any rounding, etc.  */
 
/* Prototypes for the above in case we use them.  */
double __floatunsidf (unsigned long);
double __floatsidf (long);
float __floatsisf (long);
double __extendsfdf2 (float);
float __truncdfsf2 (double);
long __fixdfsi (double);
long __fixsfsi (float);
 
int
__unordxf2(long double a, long double b)
{
  union long_double_long ldl;
 
  ldl.ld = a;
  if (EXPX(ldl) == EXPXMASK
      && ((ldl.l.middle & MANTXMASK) != 0 || ldl.l.lower != 0))
    return 1;
  ldl.ld = b;
  if (EXPX(ldl) == EXPXMASK
      && ((ldl.l.middle & MANTXMASK) != 0 || ldl.l.lower != 0))
    return 1;
  return 0;
}
 
/* convert double to long double */
long double
__extenddfxf2 (double d)
{
  register union double_long dl;
  register union long_double_long ldl;
  register long exp;
 
  dl.d = d;
  /*printf ("dfxf in: %g\n", d);*/
 
  ldl.l.upper = SIGND (dl);
  if ((dl.l.upper & ~SIGNBIT) == 0 && !dl.l.lower)
    {
      ldl.l.middle = 0;
      ldl.l.lower = 0;
      return ldl.ld;
    }
 
  exp = EXPD (dl) - EXCESSD + EXCESSX;
  ldl.l.upper |= exp << 16;
  ldl.l.middle = HIDDENX;
  /* 31-20: # mantissa bits in ldl.l.middle - # mantissa bits in dl.l.upper */
  ldl.l.middle |= (dl.l.upper & MANTDMASK) << (31 - 20);
  /* 1+20: explicit-integer-bit + # mantissa bits in dl.l.upper */
  ldl.l.middle |= dl.l.lower >> (1 + 20);
  /* 32 - 21: # bits of dl.l.lower in ldl.l.middle */
  ldl.l.lower = dl.l.lower << (32 - 21);
 
  /*printf ("dfxf out: %s\n", dumpxf (ldl.ld));*/
  return ldl.ld;
}
 
/* convert long double to double */
double
__truncxfdf2 (long double ld)
{
  register long exp;
  register union double_long dl;
  register union long_double_long ldl;
 
  ldl.ld = ld;
  /*printf ("xfdf in: %s\n", dumpxf (ld));*/
 
  dl.l.upper = SIGNX (ldl);
  if ((ldl.l.upper & ~SIGNBIT) == 0 && !ldl.l.middle && !ldl.l.lower)
    {
      dl.l.lower = 0;
      return dl.d;
    }
 
  exp = EXPX (ldl) - EXCESSX + EXCESSD;
  /* ??? quick and dirty: keep `exp' sane */
  if (exp >= EXPDMASK)
    exp = EXPDMASK - 1;
  dl.l.upper |= exp << (32 - (EXPDBITS + 1));
  /* +1-1: add one for sign bit, but take one off for explicit-integer-bit */
  dl.l.upper |= (ldl.l.middle & MANTXMASK) >> (EXPDBITS + 1 - 1);
  dl.l.lower = (ldl.l.middle & MANTXMASK) << (32 - (EXPDBITS + 1 - 1));
  dl.l.lower |= ldl.l.lower >> (EXPDBITS + 1 - 1);
 
  /*printf ("xfdf out: %g\n", dl.d);*/
  return dl.d;
}
 
/* convert a float to a long double */
long double
__extendsfxf2 (float f)
{
  long double foo = __extenddfxf2 (__extendsfdf2 (f));
  return foo;
}
 
/* convert a long double to a float */
float
__truncxfsf2 (long double ld)
{
  float foo = __truncdfsf2 (__truncxfdf2 (ld));
  return foo;
}
 
/* convert an int to a long double */
long double
__floatsixf (long l)
{
  double foo = __floatsidf (l);
  return foo;
}
 
/* convert an unsigned int to a long double */
long double
__floatunsixf (unsigned long l)
{
  double foo = __floatunsidf (l);
  return foo;
}
 
/* convert a long double to an int */
long
__fixxfsi (long double ld)
{
  long foo = __fixdfsi ((double) ld);
  return foo;
}
 
/* The remaining provide crude math support by working in double precision.  */
 
long double
__addxf3 (long double x1, long double x2)
{
  return (double) x1 + (double) x2;
}
 
long double
__subxf3 (long double x1, long double x2)
{
  return (double) x1 - (double) x2;
}
 
long double
__mulxf3 (long double x1, long double x2)
{
  return (double) x1 * (double) x2;
}
 
long double
__divxf3 (long double x1, long double x2)
{
  return (double) x1 / (double) x2;
}
 
long double
__negxf2 (long double x1)
{
  return - (double) x1;
}
 
long
__cmpxf2 (long double x1, long double x2)
{
  return __cmpdf2 ((double) x1, (double) x2);
}
 
long
__eqxf2 (long double x1, long double x2)
{
  return __cmpdf2 ((double) x1, (double) x2);
}
 
long
__nexf2 (long double x1, long double x2)
{
  return __cmpdf2 ((double) x1, (double) x2);
}
 
long
__ltxf2 (long double x1, long double x2)
{
  return __cmpdf2 ((double) x1, (double) x2);
}
 
long
__lexf2 (long double x1, long double x2)
{
  return __cmpdf2 ((double) x1, (double) x2);
}
 
long
__gtxf2 (long double x1, long double x2)
{
  return __cmpdf2 ((double) x1, (double) x2);
}
 
long
__gexf2 (long double x1, long double x2)
{
  return __cmpdf2 ((double) x1, (double) x2);
}
 
#endif /* !__mcoldfire__ */
#endif /* EXTFLOAT */

Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [config/] [m68k/] [fpgnulib.c] - Blame information for rev 282

Line No.	Rev	Author	Line
1	282	jeremybenn	`/* This is a stripped down version of floatlib.c. It supplies only those`
2			`functions which exist in libgcc, but for which there is not assembly`
3			`language versions in m68k/lb1sf68.asm.`
4
5			`It also includes simplistic support for extended floats (by working in`
6			`double precision). You must compile this file again with -DEXTFLOAT`
7			`to get this support. */`
8
9			`/*`
10			`** gnulib support for software floating point.`
11			`** Copyright (C) 1991 by Pipeline Associates, Inc. All rights reserved.`
12			`** Permission is granted to do anything you want with this file,`
13			`** commercial or otherwise, provided this message remains intact. So there!`
14			`** I would appreciate receiving any updates/patches/changes that anyone`
15			`** makes, and am willing to be the repository for said changes (am I`
16			`** making a big mistake?).`
17			`**`
18			`** Pat Wood`
19			`** Pipeline Associates, Inc.`
20			`** pipeline!phw@motown.com or`
21			`** sun!pipeline!phw or`
22			`** uunet!motown!pipeline!phw`
23			`**`
24			`** 05/01/91 -- V1.0 -- first release to gcc mailing lists`
25			`** 05/04/91 -- V1.1 -- added float and double prototypes and return values`
26			`** -- fixed problems with adding and subtracting zero`
27			`** -- fixed rounding in truncdfsf2`
28			`** -- fixed SWAP define and tested on 386`
29			`*/`
30
31			`/*`
32			`** The following are routines that replace the gnulib soft floating point`
33			`** routines that are called automatically when -msoft-float is selected.`
34			`** The support single and double precision IEEE format, with provisions`
35			`** for byte-swapped machines (tested on 386). Some of the double-precision`
36			`** routines work at full precision, but most of the hard ones simply punt`
37			`** and call the single precision routines, producing a loss of accuracy.`
38			`** long long support is not assumed or included.`
39			`** Overall accuracy is close to IEEE (actually 68882) for single-precision`
40			`** arithmetic. I think there may still be a 1 in 1000 chance of a bit`
41			`** being rounded the wrong way during a multiply. I'm not fussy enough to`
42			`** bother with it, but if anyone is, knock yourself out.`
43			`**`
44			`** Efficiency has only been addressed where it was obvious that something`
45			`** would make a big difference. Anyone who wants to do this right for`
46			`** best speed should go in and rewrite in assembler.`
47			`**`
48			`** I have tested this only on a 68030 workstation and 386/ix integrated`
49			`** in with -msoft-float.`
50			`*/`
51
52			`/* the following deal with IEEE single-precision numbers */`
53			`#define EXCESS 126L`
54			`#define SIGNBIT 0x80000000L`
55			`#define HIDDEN (1L << 23L)`
56			`#define SIGN(fp) ((fp) & SIGNBIT)`
57			`#define EXP(fp) (((fp) >> 23L) & 0xFF)`
58			`#define MANT(fp) (((fp) & 0x7FFFFFL) \| HIDDEN)`
59			`#define PACK(s,e,m) ((s) \| ((e) << 23L) \| (m))`
60
61			`/* the following deal with IEEE double-precision numbers */`
62			`#define EXCESSD 1022L`
63			`#define HIDDEND (1L << 20L)`
64			`#define EXPDBITS 11`
65			`#define EXPDMASK 0x7FFL`
66			`#define EXPD(fp) (((fp.l.upper) >> 20L) & 0x7FFL)`
67			`#define SIGND(fp) ((fp.l.upper) & SIGNBIT)`
68			`#define MANTD(fp) (((((fp.l.upper) & 0xFFFFF) \| HIDDEND) << 10) \| \`
69			`(fp.l.lower >> 22))`
70			`#define MANTDMASK 0xFFFFFL /* mask of upper part */`
71
72			`/* the following deal with IEEE extended-precision numbers */`
73			`#define EXCESSX 16382L`
74			`#define HIDDENX (1L << 31L)`
75			`#define EXPXBITS 15`
76			`#define EXPXMASK 0x7FFF`
77			`#define EXPX(fp) (((fp.l.upper) >> 16) & EXPXMASK)`
78			`#define SIGNX(fp) ((fp.l.upper) & SIGNBIT)`
79			`#define MANTXMASK 0x7FFFFFFFL /* mask of upper part */`
80
81			`union double_long`
82			`{`
83			`double d;`
84			`struct {`
85			`long upper;`
86			`unsigned long lower;`
87			`} l;`
88			`};`
89
90			`union float_long {`
91			`float f;`
92			`long l;`
93			`};`
94
95			`union long_double_long`
96			`{`
97			`long double ld;`
98			`struct`
99			`{`
100			`long upper;`
101			`unsigned long middle;`
102			`unsigned long lower;`
103			`} l;`
104			`};`
105
106			`#ifndef EXTFLOAT`
107
108			`int`
109			`__unordsf2(float a, float b)`
110			`{`
111			`union float_long fl;`
112
113			`fl.f = a;`
114			`if (EXP(fl.l) == EXP(~0u) && (MANT(fl.l) & ~HIDDEN) != 0)`
115			`return 1;`
116			`fl.f = b;`
117			`if (EXP(fl.l) == EXP(~0u) && (MANT(fl.l) & ~HIDDEN) != 0)`
118			`return 1;`
119			`return 0;`
120			`}`
121
122			`int`
123			`__unorddf2(double a, double b)`
124			`{`
125			`union double_long dl;`
126
127			`dl.d = a;`
128			`if (EXPD(dl) == EXPDMASK`
129			`&& ((dl.l.upper & MANTDMASK) != 0 \|\| dl.l.lower != 0))`
130			`return 1;`
131			`dl.d = b;`
132			`if (EXPD(dl) == EXPDMASK`
133			`&& ((dl.l.upper & MANTDMASK) != 0 \|\| dl.l.lower != 0))`
134			`return 1;`
135			`return 0;`
136			`}`
137
138			`/* convert unsigned int to double */`
139			`double`
140			`__floatunsidf (unsigned long a1)`
141			`{`
142			`long exp = 32 + EXCESSD;`
143			`union double_long dl;`
144
145			`if (!a1)`
146			`{`
147			`dl.l.upper = dl.l.lower = 0;`
148			`return dl.d;`
149			`}`
150
151			`while (a1 < 0x2000000L)`
152			`{`
153			`a1 <<= 4;`
154			`exp -= 4;`
155			`}`
156
157			`while (a1 < 0x80000000L)`
158			`{`
159			`a1 <<= 1;`
160			`exp--;`
161			`}`
162
163			`/* pack up and go home */`
164			`dl.l.upper = exp << 20L;`
165			`dl.l.upper \|= (a1 >> 11L) & ~HIDDEND;`
166			`dl.l.lower = a1 << 21L;`
167
168			`return dl.d;`
169			`}`
170
171			`/* convert int to double */`
172			`double`
173			`__floatsidf (long a1)`
174			`{`
175			`long sign = 0, exp = 31 + EXCESSD;`
176			`union double_long dl;`
177
178			`if (!a1)`
179			`{`
180			`dl.l.upper = dl.l.lower = 0;`
181			`return dl.d;`
182			`}`
183
184			`if (a1 < 0)`
185			`{`
186			`sign = SIGNBIT;`
187			`a1 = (long)-(unsigned long)a1;`
188			`if (a1 < 0)`
189			`{`
190			`dl.l.upper = SIGNBIT \| ((32 + EXCESSD) << 20L);`
191			`dl.l.lower = 0;`
192			`return dl.d;`
193			`}`
194			`}`
195
196			`while (a1 < 0x1000000L)`
197			`{`
198			`a1 <<= 4;`
199			`exp -= 4;`
200			`}`
201
202			`while (a1 < 0x40000000L)`
203			`{`
204			`a1 <<= 1;`
205			`exp--;`
206			`}`
207
208			`/* pack up and go home */`
209			`dl.l.upper = sign;`
210			`dl.l.upper \|= exp << 20L;`
211			`dl.l.upper \|= (a1 >> 10L) & ~HIDDEND;`
212			`dl.l.lower = a1 << 22L;`
213
214			`return dl.d;`
215			`}`
216
217			`/* convert unsigned int to float */`
218			`float`
219			`__floatunsisf (unsigned long l)`
220			`{`
221			`double foo = __floatunsidf (l);`
222			`return foo;`
223			`}`
224
225			`/* convert int to float */`
226			`float`
227			`__floatsisf (long l)`
228			`{`
229			`double foo = __floatsidf (l);`
230			`return foo;`
231			`}`
232
233			`/* convert float to double */`
234			`double`
235			`__extendsfdf2 (float a1)`
236			`{`
237			`register union float_long fl1;`
238			`register union double_long dl;`
239			`register long exp;`
240			`register long mant;`
241
242			`fl1.f = a1;`
243
244			`dl.l.upper = SIGN (fl1.l);`
245			`if ((fl1.l & ~SIGNBIT) == 0)`
246			`{`
247			`dl.l.lower = 0;`
248			`return dl.d;`
249			`}`
250
251			`exp = EXP(fl1.l);`
252			`mant = MANT (fl1.l) & ~HIDDEN;`
253			`if (exp == 0)`
254			`{`
255			`/* Denormal. */`
256			`exp = 1;`
257			`while (!(mant & HIDDEN))`
258			`{`
259			`mant <<= 1;`
260			`exp--;`
261			`}`
262			`mant &= ~HIDDEN;`
263			`}`
264			`exp = exp - EXCESS + EXCESSD;`
265			`dl.l.upper \|= exp << 20;`
266			`dl.l.upper \|= mant >> 3;`
267			`dl.l.lower = mant << 29;`
268
269			`return dl.d;`
270			`}`
271
272			`/* convert double to float */`
273			`float`
274			`__truncdfsf2 (double a1)`
275			`{`
276			`register long exp;`
277			`register long mant;`
278			`register union float_long fl;`
279			`register union double_long dl1;`
280			`int sticky;`
281			`int shift;`
282
283			`dl1.d = a1;`
284
285			`if ((dl1.l.upper & ~SIGNBIT) == 0 && !dl1.l.lower)`
286			`{`
287			`fl.l = SIGND(dl1);`
288			`return fl.f;`
289			`}`
290
291			`exp = EXPD (dl1) - EXCESSD + EXCESS;`
292
293			`sticky = dl1.l.lower & ((1 << 22) - 1);`
294			`mant = MANTD (dl1);`
295			`/* shift double mantissa 6 bits so we can round */`
296			`sticky \|= mant & ((1 << 6) - 1);`
297			`mant >>= 6;`
298
299			`/* Check for underflow and denormals. */`
300			`if (exp <= 0)`
301			`{`
302			`if (exp < -24)`
303			`{`
304			`sticky \|= mant;`
305			`mant = 0;`
306			`}`
307			`else`
308			`{`
309			`sticky \|= mant & ((1 << (1 - exp)) - 1);`
310			`mant >>= 1 - exp;`
311			`}`
312			`exp = 0;`
313			`}`
314
315			`/* now round */`
316			`shift = 1;`
317			`if ((mant & 1) && (sticky \|\| (mant & 2)))`
318			`{`
319			`int rounding = exp ? 2 : 1;`
320
321			`mant += 1;`
322
323			`/* did the round overflow? */`
324			`if (mant >= (HIDDEN << rounding))`
325			`{`
326			`exp++;`
327			`shift = rounding;`
328			`}`
329			`}`
330			`/* shift down */`
331			`mant >>= shift;`
332
333			`mant &= ~HIDDEN;`
334
335			`/* pack up and go home */`
336			`fl.l = PACK (SIGND (dl1), exp, mant);`
337			`return (fl.f);`
338			`}`
339
340			`/* convert double to int */`
341			`long`
342			`__fixdfsi (double a1)`
343			`{`
344			`register union double_long dl1;`
345			`register long exp;`
346			`register long l;`
347
348			`dl1.d = a1;`
349
350			`if (!dl1.l.upper && !dl1.l.lower)`
351			`return 0;`
352
353			`exp = EXPD (dl1) - EXCESSD - 31;`
354			`l = MANTD (dl1);`
355
356			`if (exp > 0)`
357			`{`
358			`/* Return largest integer. */`
359			`return SIGND (dl1) ? 0x80000000L : 0x7fffffffL;`
360			`}`
361
362			`if (exp <= -32)`
363			`return 0;`
364
365			`/* shift down until exp = 0 */`
366			`if (exp < 0)`
367			`l >>= -exp;`
368
369			`return (SIGND (dl1) ? -l : l);`
370			`}`
371
372			`/* convert float to int */`
373			`long`
374			`__fixsfsi (float a1)`
375			`{`
376			`double foo = a1;`
377			`return __fixdfsi (foo);`
378			`}`
379
380			`#else /* EXTFLOAT */`
381
382			`/* We do not need these routines for coldfire, as it has no extended`
383			`float format. */`
384			`#if !defined (__mcoldfire__)`
385
386			`/* Primitive extended precision floating point support.`
387
388			`We assume all numbers are normalized, don't do any rounding, etc. */`
389
390			`/* Prototypes for the above in case we use them. */`
391			`double __floatunsidf (unsigned long);`
392			`double __floatsidf (long);`
393			`float __floatsisf (long);`
394			`double __extendsfdf2 (float);`
395			`float __truncdfsf2 (double);`
396			`long __fixdfsi (double);`
397			`long __fixsfsi (float);`
398
399			`int`
400			`__unordxf2(long double a, long double b)`
401			`{`
402			`union long_double_long ldl;`
403
404			`ldl.ld = a;`
405			`if (EXPX(ldl) == EXPXMASK`
406			`&& ((ldl.l.middle & MANTXMASK) != 0 \|\| ldl.l.lower != 0))`
407			`return 1;`
408			`ldl.ld = b;`
409			`if (EXPX(ldl) == EXPXMASK`
410			`&& ((ldl.l.middle & MANTXMASK) != 0 \|\| ldl.l.lower != 0))`
411			`return 1;`
412			`return 0;`
413			`}`
414
415			`/* convert double to long double */`
416			`long double`
417			`__extenddfxf2 (double d)`
418			`{`
419			`register union double_long dl;`
420			`register union long_double_long ldl;`
421			`register long exp;`
422
423			`dl.d = d;`
424			`/printf ("dfxf in: %g\n", d);/`
425
426			`ldl.l.upper = SIGND (dl);`
427			`if ((dl.l.upper & ~SIGNBIT) == 0 && !dl.l.lower)`
428			`{`
429			`ldl.l.middle = 0;`
430			`ldl.l.lower = 0;`
431			`return ldl.ld;`
432			`}`
433
434			`exp = EXPD (dl) - EXCESSD + EXCESSX;`
435			`ldl.l.upper \|= exp << 16;`
436			`ldl.l.middle = HIDDENX;`
437			`/* 31-20: # mantissa bits in ldl.l.middle - # mantissa bits in dl.l.upper */`
438			`ldl.l.middle \|= (dl.l.upper & MANTDMASK) << (31 - 20);`
439			`/* 1+20: explicit-integer-bit + # mantissa bits in dl.l.upper */`
440			`ldl.l.middle \|= dl.l.lower >> (1 + 20);`
441			`/* 32 - 21: # bits of dl.l.lower in ldl.l.middle */`
442			`ldl.l.lower = dl.l.lower << (32 - 21);`
443
444			`/printf ("dfxf out: %s\n", dumpxf (ldl.ld));/`
445			`return ldl.ld;`
446			`}`
447
448			`/* convert long double to double */`
449			`double`
450			`__truncxfdf2 (long double ld)`
451			`{`
452			`register long exp;`
453			`register union double_long dl;`
454			`register union long_double_long ldl;`
455
456			`ldl.ld = ld;`
457			`/printf ("xfdf in: %s\n", dumpxf (ld));/`
458
459			`dl.l.upper = SIGNX (ldl);`
460			`if ((ldl.l.upper & ~SIGNBIT) == 0 && !ldl.l.middle && !ldl.l.lower)`
461			`{`
462			`dl.l.lower = 0;`
463			`return dl.d;`
464			`}`
465
466			`exp = EXPX (ldl) - EXCESSX + EXCESSD;`
467			/* ??? quick and dirty: keep `exp' sane */
468			`if (exp >= EXPDMASK)`
469			`exp = EXPDMASK - 1;`
470			`dl.l.upper \|= exp << (32 - (EXPDBITS + 1));`
471			`/* +1-1: add one for sign bit, but take one off for explicit-integer-bit */`
472			`dl.l.upper \|= (ldl.l.middle & MANTXMASK) >> (EXPDBITS + 1 - 1);`
473			`dl.l.lower = (ldl.l.middle & MANTXMASK) << (32 - (EXPDBITS + 1 - 1));`
474			`dl.l.lower \|= ldl.l.lower >> (EXPDBITS + 1 - 1);`
475
476			`/printf ("xfdf out: %g\n", dl.d);/`
477			`return dl.d;`
478			`}`
479
480			`/* convert a float to a long double */`
481			`long double`
482			`__extendsfxf2 (float f)`
483			`{`
484			`long double foo = __extenddfxf2 (__extendsfdf2 (f));`
485			`return foo;`
486			`}`
487
488			`/* convert a long double to a float */`
489			`float`
490			`__truncxfsf2 (long double ld)`
491			`{`
492			`float foo = __truncdfsf2 (__truncxfdf2 (ld));`
493			`return foo;`
494			`}`
495
496			`/* convert an int to a long double */`
497			`long double`
498			`__floatsixf (long l)`
499			`{`
500			`double foo = __floatsidf (l);`
501			`return foo;`
502			`}`
503
504			`/* convert an unsigned int to a long double */`
505			`long double`
506			`__floatunsixf (unsigned long l)`
507			`{`
508			`double foo = __floatunsidf (l);`
509			`return foo;`
510			`}`
511
512			`/* convert a long double to an int */`
513			`long`
514			`__fixxfsi (long double ld)`
515			`{`
516			`long foo = __fixdfsi ((double) ld);`
517			`return foo;`
518			`}`
519
520			`/* The remaining provide crude math support by working in double precision. */`
521
522			`long double`
523			`__addxf3 (long double x1, long double x2)`
524			`{`
525			`return (double) x1 + (double) x2;`
526			`}`
527
528			`long double`
529			`__subxf3 (long double x1, long double x2)`
530			`{`
531			`return (double) x1 - (double) x2;`
532			`}`
533
534			`long double`
535			`__mulxf3 (long double x1, long double x2)`
536			`{`
537			`return (double) x1 * (double) x2;`
538			`}`
539
540			`long double`
541			`__divxf3 (long double x1, long double x2)`
542			`{`
543			`return (double) x1 / (double) x2;`
544			`}`
545
546			`long double`
547			`__negxf2 (long double x1)`
548			`{`
549			`return - (double) x1;`
550			`}`
551
552			`long`
553			`__cmpxf2 (long double x1, long double x2)`
554			`{`
555			`return __cmpdf2 ((double) x1, (double) x2);`
556			`}`
557
558			`long`
559			`__eqxf2 (long double x1, long double x2)`
560			`{`
561			`return __cmpdf2 ((double) x1, (double) x2);`
562			`}`
563
564			`long`
565			`__nexf2 (long double x1, long double x2)`
566			`{`
567			`return __cmpdf2 ((double) x1, (double) x2);`
568			`}`
569
570			`long`
571			`__ltxf2 (long double x1, long double x2)`
572			`{`
573			`return __cmpdf2 ((double) x1, (double) x2);`
574			`}`
575
576			`long`
577			`__lexf2 (long double x1, long double x2)`
578			`{`
579			`return __cmpdf2 ((double) x1, (double) x2);`
580			`}`
581
582			`long`
583			`__gtxf2 (long double x1, long double x2)`
584			`{`
585			`return __cmpdf2 ((double) x1, (double) x2);`
586			`}`
587
588			`long`
589			`__gexf2 (long double x1, long double x2)`
590			`{`
591			`return __cmpdf2 ((double) x1, (double) x2);`
592			`}`
593
594			`#endif /* !__mcoldfire__ */`
595			`#endif /* EXTFLOAT */`