Subversion Repositories openrisc

/* libgcc routines for 68000 w/o floating-point hardware.
   Copyright (C) 1994, 1996, 1997, 1998, 2008, 2009 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 3, or (at your option) any
later version.

This file 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.

Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.

You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
<http://www.gnu.org/licenses/>.  */

/* Use this one for any 680x0; assumes no floating point hardware.
   The trailing " '" appearing on some lines is for ANSI preprocessors.  Yuk.
   Some of this code comes from MINIX, via the folks at ericsson.
   D. V. Henkel-Wallace (gumby@cygnus.com) Fete Bastille, 1992
*/

/* These are predefined by new versions of GNU cpp.  */

#ifndef __USER_LABEL_PREFIX__
#define __USER_LABEL_PREFIX__ _
#endif

#ifndef __REGISTER_PREFIX__
#define __REGISTER_PREFIX__
#endif

#ifndef __IMMEDIATE_PREFIX__
#define __IMMEDIATE_PREFIX__ #
#endif

/* ANSI concatenation macros.  */

#define CONCAT1(a, b) CONCAT2(a, b)
#define CONCAT2(a, b) a ## b

/* Use the right prefix for global labels.  */

#define SYM(x) CONCAT1 (__USER_LABEL_PREFIX__, x)

/* Note that X is a function.  */
        
#ifdef __ELF__
#define FUNC(x) .type SYM(x),function
#else
/* The .proc pseudo-op is accepted, but ignored, by GAS.  We could just 
   define this to the empty string for non-ELF systems, but defining it
   to .proc means that the information is available to the assembler if
   the need arises.  */
#define FUNC(x) .proc
#endif
                
/* Use the right prefix for registers.  */

#define REG(x) CONCAT1 (__REGISTER_PREFIX__, x)

/* Use the right prefix for immediate values.  */

#define IMM(x) CONCAT1 (__IMMEDIATE_PREFIX__, x)

#define d0 REG (d0)
#define d1 REG (d1)
#define d2 REG (d2)
#define d3 REG (d3)
#define d4 REG (d4)
#define d5 REG (d5)
#define d6 REG (d6)
#define d7 REG (d7)
#define a0 REG (a0)
#define a1 REG (a1)
#define a2 REG (a2)
#define a3 REG (a3)
#define a4 REG (a4)
#define a5 REG (a5)
#define a6 REG (a6)
#define fp REG (fp)
#define sp REG (sp)
#define pc REG (pc)

/* Provide a few macros to allow for PIC code support.
 * With PIC, data is stored A5 relative so we've got to take a bit of special
 * care to ensure that all loads of global data is via A5.  PIC also requires
 * jumps and subroutine calls to be PC relative rather than absolute.  We cheat
 * a little on this and in the PIC case, we use short offset branches and
 * hope that the final object code is within range (which it should be).
 */
#ifndef __PIC__

        /* Non PIC (absolute/relocatable) versions */

        .macro PICCALL addr
        jbsr    \addr
        .endm

        .macro PICJUMP addr
        jmp     \addr
        .endm

        .macro PICLEA sym, reg
        lea     \sym, \reg
        .endm

        .macro PICPEA sym, areg
        pea     \sym
        .endm

#else /* __PIC__ */

# if defined (__uClinux__)

        /* Versions for uClinux */

#  if defined(__ID_SHARED_LIBRARY__)

        /* -mid-shared-library versions  */

        .macro PICLEA sym, reg
        movel   a5@(_current_shared_library_a5_offset_), \reg
        movel   \sym@GOT(\reg), \reg
        .endm

        .macro PICPEA sym, areg
        movel   a5@(_current_shared_library_a5_offset_), \areg
        movel   \sym@GOT(\areg), sp@-
        .endm

        .macro PICCALL addr
        PICLEA  \addr,a0
        jsr     a0@
        .endm

        .macro PICJUMP addr
        PICLEA  \addr,a0
        jmp     a0@
        .endm

#  else /* !__ID_SHARED_LIBRARY__ */

        /* Versions for -msep-data */

        .macro PICLEA sym, reg
        movel   \sym@GOT(a5), \reg
        .endm

        .macro PICPEA sym, areg
        movel   \sym@GOT(a5), sp@-
        .endm

        .macro PICCALL addr
#if defined (__mcoldfire__) && !defined (__mcfisab__) && !defined (__mcfisac__)
        lea     \addr-.-8,a0
        jsr     pc@(a0)
#else
        jbsr    \addr
#endif
        .endm

        .macro PICJUMP addr
        /* ISA C has no bra.l instruction, and since this assembly file
           gets assembled into multiple object files, we avoid the
           bra instruction entirely.  */
#if defined (__mcoldfire__) && !defined (__mcfisab__)
        lea     \addr-.-8,a0
        jmp     pc@(a0)
#else
        bra     \addr
#endif
        .endm

#  endif

# else /* !__uClinux__ */

        /* Versions for Linux */

        .macro PICLEA sym, reg
        movel   #_GLOBAL_OFFSET_TABLE_@GOTPC, \reg
        lea     (-6, pc, \reg), \reg
        movel   \sym@GOT(\reg), \reg
        .endm

        .macro PICPEA sym, areg
        movel   #_GLOBAL_OFFSET_TABLE_@GOTPC, \areg
        lea     (-6, pc, \areg), \areg
        movel   \sym@GOT(\areg), sp@-
        .endm

        .macro PICCALL addr
#if defined (__mcoldfire__) && !defined (__mcfisab__) && !defined (__mcfisac__)
        lea     \addr-.-8,a0
        jsr     pc@(a0)
#else
        jbsr    \addr
#endif
        .endm

        .macro PICJUMP addr
        /* ISA C has no bra.l instruction, and since this assembly file
           gets assembled into multiple object files, we avoid the
           bra instruction entirely.  */
#if defined (__mcoldfire__) && !defined (__mcfisab__)
        lea     \addr-.-8,a0
        jmp     pc@(a0)
#else
        bra     \addr
#endif
        .endm

# endif
#endif /* __PIC__ */


#ifdef L_floatex

| This is an attempt at a decent floating point (single, double and 
| extended double) code for the GNU C compiler. It should be easy to
| adapt to other compilers (but beware of the local labels!).

| Starting date: 21 October, 1990

| It is convenient to introduce the notation (s,e,f) for a floating point
| number, where s=sign, e=exponent, f=fraction. We will call a floating
| point number fpn to abbreviate, independently of the precision.
| Let MAX_EXP be in each case the maximum exponent (255 for floats, 1023 
| for doubles and 16383 for long doubles). We then have the following 
| different cases:
|  1. Normalized fpns have 0 < e < MAX_EXP. They correspond to 
|     (-1)^s x 1.f x 2^(e-bias-1).
|  2. Denormalized fpns have e=0. They correspond to numbers of the form
|     (-1)^s x 0.f x 2^(-bias).
|  3. +/-INFINITY have e=MAX_EXP, f=0.
|  4. Quiet NaN (Not a Number) have all bits set.
|  5. Signaling NaN (Not a Number) have s=0, e=MAX_EXP, f=1.

|=============================================================================
|                                  exceptions
|=============================================================================

| This is the floating point condition code register (_fpCCR):
|
| struct {
|   short _exception_bits;      
|   short _trap_enable_bits;    
|   short _sticky_bits;
|   short _rounding_mode;
|   short _format;
|   short _last_operation;
|   union {
|     float sf;
|     double df;
|   } _operand1;
|   union {
|     float sf;
|     double df;
|   } _operand2;
| } _fpCCR;

        .data
        .even

        .globl  SYM (_fpCCR)
        
SYM (_fpCCR):
__exception_bits:
        .word   0
__trap_enable_bits:
        .word   0
__sticky_bits:
        .word   0
__rounding_mode:
        .word   ROUND_TO_NEAREST
__format:
        .word   NIL
__last_operation:
        .word   NOOP
__operand1:
        .long   0
        .long   0
__operand2:
        .long   0
        .long   0

| Offsets:
EBITS  = __exception_bits - SYM (_fpCCR)
TRAPE  = __trap_enable_bits - SYM (_fpCCR)
STICK  = __sticky_bits - SYM (_fpCCR)
ROUND  = __rounding_mode - SYM (_fpCCR)
FORMT  = __format - SYM (_fpCCR)
LASTO  = __last_operation - SYM (_fpCCR)
OPER1  = __operand1 - SYM (_fpCCR)
OPER2  = __operand2 - SYM (_fpCCR)

| The following exception types are supported:
INEXACT_RESULT          = 0x0001
UNDERFLOW               = 0x0002
OVERFLOW                = 0x0004
DIVIDE_BY_ZERO          = 0x0008
INVALID_OPERATION       = 0x0010

| The allowed rounding modes are:
UNKNOWN           = -1
ROUND_TO_NEAREST  = 0 | round result to nearest representable value
ROUND_TO_ZERO     = 1 | round result towards zero
ROUND_TO_PLUS     = 2 | round result towards plus infinity
ROUND_TO_MINUS    = 3 | round result towards minus infinity

| The allowed values of format are:
NIL          = 0
SINGLE_FLOAT = 1
DOUBLE_FLOAT = 2
LONG_FLOAT   = 3

| The allowed values for the last operation are:
NOOP         = 0
ADD          = 1
MULTIPLY     = 2
DIVIDE       = 3
NEGATE       = 4
COMPARE      = 5
EXTENDSFDF   = 6
TRUNCDFSF    = 7

|=============================================================================
|                           __clear_sticky_bits
|=============================================================================

| The sticky bits are normally not cleared (thus the name), whereas the 
| exception type and exception value reflect the last computation. 
| This routine is provided to clear them (you can also write to _fpCCR,
| since it is globally visible).

        .globl  SYM (__clear_sticky_bit)

        .text
        .even

| void __clear_sticky_bits(void);
SYM (__clear_sticky_bit):               
        PICLEA  SYM (_fpCCR),a0
#ifndef __mcoldfire__
        movew   IMM (0),a0@(STICK)
#else
        clr.w   a0@(STICK)
#endif
        rts

|=============================================================================
|                           $_exception_handler
|=============================================================================

        .globl  $_exception_handler

        .text
        .even

| This is the common exit point if an exception occurs.
| NOTE: it is NOT callable from C!
| It expects the exception type in d7, the format (SINGLE_FLOAT,
| DOUBLE_FLOAT or LONG_FLOAT) in d6, and the last operation code in d5.
| It sets the corresponding exception and sticky bits, and the format. 
| Depending on the format if fills the corresponding slots for the 
| operands which produced the exception (all this information is provided
| so if you write your own exception handlers you have enough information
| to deal with the problem).
| Then checks to see if the corresponding exception is trap-enabled, 
| in which case it pushes the address of _fpCCR and traps through 
| trap FPTRAP (15 for the moment).

FPTRAP = 15

$_exception_handler:
        PICLEA  SYM (_fpCCR),a0
        movew   d7,a0@(EBITS)   | set __exception_bits
#ifndef __mcoldfire__
        orw     d7,a0@(STICK)   | and __sticky_bits
#else
        movew   a0@(STICK),d4
        orl     d7,d4
        movew   d4,a0@(STICK)
#endif
        movew   d6,a0@(FORMT)   | and __format
        movew   d5,a0@(LASTO)   | and __last_operation

| Now put the operands in place:
#ifndef __mcoldfire__
        cmpw    IMM (SINGLE_FLOAT),d6
#else
        cmpl    IMM (SINGLE_FLOAT),d6
#endif
        beq     1f
        movel   a6@(8),a0@(OPER1)
        movel   a6@(12),a0@(OPER1+4)
        movel   a6@(16),a0@(OPER2)
        movel   a6@(20),a0@(OPER2+4)
        bra     2f
1:      movel   a6@(8),a0@(OPER1)
        movel   a6@(12),a0@(OPER2)
2:
| And check whether the exception is trap-enabled:
#ifndef __mcoldfire__
        andw    a0@(TRAPE),d7   | is exception trap-enabled?
#else
        clrl    d6
        movew   a0@(TRAPE),d6
        andl    d6,d7
#endif
        beq     1f              | no, exit
        PICPEA  SYM (_fpCCR),a1 | yes, push address of _fpCCR
        trap    IMM (FPTRAP)    | and trap
#ifndef __mcoldfire__
1:      moveml  sp@+,d2-d7      | restore data registers
#else
1:      moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6              | and return
        rts
#endif /* L_floatex */

#ifdef  L_mulsi3
        .text
        FUNC(__mulsi3)
        .globl  SYM (__mulsi3)
SYM (__mulsi3):
        movew   sp@(4), d0      /* x0 -> d0 */
        muluw   sp@(10), d0     /* x0*y1 */
        movew   sp@(6), d1      /* x1 -> d1 */
        muluw   sp@(8), d1      /* x1*y0 */
#ifndef __mcoldfire__
        addw    d1, d0
#else
        addl    d1, d0
#endif
        swap    d0
        clrw    d0
        movew   sp@(6), d1      /* x1 -> d1 */
        muluw   sp@(10), d1     /* x1*y1 */
        addl    d1, d0

        rts
#endif /* L_mulsi3 */

#ifdef  L_udivsi3
        .text
        FUNC(__udivsi3)
        .globl  SYM (__udivsi3)
SYM (__udivsi3):
#ifndef __mcoldfire__
        movel   d2, sp@-
        movel   sp@(12), d1     /* d1 = divisor */
        movel   sp@(8), d0      /* d0 = dividend */

        cmpl    IMM (0x10000), d1 /* divisor >= 2 ^ 16 ?   */
        jcc     L3              /* then try next algorithm */
        movel   d0, d2
        clrw    d2
        swap    d2
        divu    d1, d2          /* high quotient in lower word */
        movew   d2, d0          /* save high quotient */
        swap    d0
        movew   sp@(10), d2     /* get low dividend + high rest */
        divu    d1, d2          /* low quotient */
        movew   d2, d0
        jra     L6

L3:     movel   d1, d2          /* use d2 as divisor backup */
L4:     lsrl    IMM (1), d1     /* shift divisor */
        lsrl    IMM (1), d0     /* shift dividend */
        cmpl    IMM (0x10000), d1 /* still divisor >= 2 ^ 16 ?  */
        jcc     L4
        divu    d1, d0          /* now we have 16-bit divisor */
        andl    IMM (0xffff), d0 /* mask out divisor, ignore remainder */

/* Multiply the 16-bit tentative quotient with the 32-bit divisor.  Because of
   the operand ranges, this might give a 33-bit product.  If this product is
   greater than the dividend, the tentative quotient was too large. */
        movel   d2, d1
        mulu    d0, d1          /* low part, 32 bits */
        swap    d2
        mulu    d0, d2          /* high part, at most 17 bits */
        swap    d2              /* align high part with low part */
        tstw    d2              /* high part 17 bits? */
        jne     L5              /* if 17 bits, quotient was too large */
        addl    d2, d1          /* add parts */
        jcs     L5              /* if sum is 33 bits, quotient was too large */
        cmpl    sp@(8), d1      /* compare the sum with the dividend */
        jls     L6              /* if sum > dividend, quotient was too large */
L5:     subql   IMM (1), d0     /* adjust quotient */

L6:     movel   sp@+, d2
        rts

#else /* __mcoldfire__ */

/* ColdFire implementation of non-restoring division algorithm from
   Hennessy & Patterson, Appendix A. */
        link    a6,IMM (-12)
        moveml  d2-d4,sp@
        movel   a6@(8),d0
        movel   a6@(12),d1
        clrl    d2              | clear p
        moveq   IMM (31),d4
L1:     addl    d0,d0           | shift reg pair (p,a) one bit left
        addxl   d2,d2
        movl    d2,d3           | subtract b from p, store in tmp.
        subl    d1,d3
        jcs     L2              | if no carry,
        bset    IMM (0),d0      | set the low order bit of a to 1,
        movl    d3,d2           | and store tmp in p.
L2:     subql   IMM (1),d4
        jcc     L1
        moveml  sp@,d2-d4       | restore data registers
        unlk    a6              | and return
        rts
#endif /* __mcoldfire__ */

#endif /* L_udivsi3 */

#ifdef  L_divsi3
        .text
        FUNC(__divsi3)
        .globl  SYM (__divsi3)
SYM (__divsi3):
        movel   d2, sp@-

        moveq   IMM (1), d2     /* sign of result stored in d2 (=1 or =-1) */
        movel   sp@(12), d1     /* d1 = divisor */
        jpl     L1
        negl    d1
#ifndef __mcoldfire__
        negb    d2              /* change sign because divisor <0  */
#else
        negl    d2              /* change sign because divisor <0  */
#endif
L1:     movel   sp@(8), d0      /* d0 = dividend */
        jpl     L2
        negl    d0
#ifndef __mcoldfire__
        negb    d2
#else
        negl    d2
#endif

L2:     movel   d1, sp@-
        movel   d0, sp@-
        PICCALL SYM (__udivsi3) /* divide abs(dividend) by abs(divisor) */
        addql   IMM (8), sp

        tstb    d2
        jpl     L3
        negl    d0

L3:     movel   sp@+, d2
        rts
#endif /* L_divsi3 */

#ifdef  L_umodsi3
        .text
        FUNC(__umodsi3)
        .globl  SYM (__umodsi3)
SYM (__umodsi3):
        movel   sp@(8), d1      /* d1 = divisor */
        movel   sp@(4), d0      /* d0 = dividend */
        movel   d1, sp@-
        movel   d0, sp@-
        PICCALL SYM (__udivsi3)
        addql   IMM (8), sp
        movel   sp@(8), d1      /* d1 = divisor */
#ifndef __mcoldfire__
        movel   d1, sp@-
        movel   d0, sp@-
        PICCALL SYM (__mulsi3)  /* d0 = (a/b)*b */
        addql   IMM (8), sp
#else
        mulsl   d1,d0
#endif
        movel   sp@(4), d1      /* d1 = dividend */
        subl    d0, d1          /* d1 = a - (a/b)*b */
        movel   d1, d0
        rts
#endif /* L_umodsi3 */

#ifdef  L_modsi3
        .text
        FUNC(__modsi3)
        .globl  SYM (__modsi3)
SYM (__modsi3):
        movel   sp@(8), d1      /* d1 = divisor */
        movel   sp@(4), d0      /* d0 = dividend */
        movel   d1, sp@-
        movel   d0, sp@-
        PICCALL SYM (__divsi3)
        addql   IMM (8), sp
        movel   sp@(8), d1      /* d1 = divisor */
#ifndef __mcoldfire__
        movel   d1, sp@-
        movel   d0, sp@-
        PICCALL SYM (__mulsi3)  /* d0 = (a/b)*b */
        addql   IMM (8), sp
#else
        mulsl   d1,d0
#endif
        movel   sp@(4), d1      /* d1 = dividend */
        subl    d0, d1          /* d1 = a - (a/b)*b */
        movel   d1, d0
        rts
#endif /* L_modsi3 */


#ifdef  L_double

        .globl  SYM (_fpCCR)
        .globl  $_exception_handler

QUIET_NaN      = 0xffffffff

D_MAX_EXP      = 0x07ff
D_BIAS         = 1022
DBL_MAX_EXP    = D_MAX_EXP - D_BIAS
DBL_MIN_EXP    = 1 - D_BIAS
DBL_MANT_DIG   = 53

INEXACT_RESULT          = 0x0001
UNDERFLOW               = 0x0002
OVERFLOW                = 0x0004
DIVIDE_BY_ZERO          = 0x0008
INVALID_OPERATION       = 0x0010

DOUBLE_FLOAT = 2

NOOP         = 0
ADD          = 1
MULTIPLY     = 2
DIVIDE       = 3
NEGATE       = 4
COMPARE      = 5
EXTENDSFDF   = 6
TRUNCDFSF    = 7

UNKNOWN           = -1
ROUND_TO_NEAREST  = 0 | round result to nearest representable value
ROUND_TO_ZERO     = 1 | round result towards zero
ROUND_TO_PLUS     = 2 | round result towards plus infinity
ROUND_TO_MINUS    = 3 | round result towards minus infinity

| Entry points:

        .globl SYM (__adddf3)
        .globl SYM (__subdf3)
        .globl SYM (__muldf3)
        .globl SYM (__divdf3)
        .globl SYM (__negdf2)
        .globl SYM (__cmpdf2)
        .globl SYM (__cmpdf2_internal)
        .hidden SYM (__cmpdf2_internal)

        .text
        .even

| These are common routines to return and signal exceptions.    

Ld$den:
| Return and signal a denormalized number
        orl     d7,d0
        movew   IMM (INEXACT_RESULT+UNDERFLOW),d7
        moveq   IMM (DOUBLE_FLOAT),d6
        PICJUMP $_exception_handler

Ld$infty:
Ld$overflow:
| Return a properly signed INFINITY and set the exception flags 
        movel   IMM (0x7ff00000),d0
        movel   IMM (0),d1
        orl     d7,d0
        movew   IMM (INEXACT_RESULT+OVERFLOW),d7
        moveq   IMM (DOUBLE_FLOAT),d6
        PICJUMP $_exception_handler

Ld$underflow:
| Return 0 and set the exception flags 
        movel   IMM (0),d0
        movel   d0,d1
        movew   IMM (INEXACT_RESULT+UNDERFLOW),d7
        moveq   IMM (DOUBLE_FLOAT),d6
        PICJUMP $_exception_handler

Ld$inop:
| Return a quiet NaN and set the exception flags
        movel   IMM (QUIET_NaN),d0
        movel   d0,d1
        movew   IMM (INEXACT_RESULT+INVALID_OPERATION),d7
        moveq   IMM (DOUBLE_FLOAT),d6
        PICJUMP $_exception_handler

Ld$div$0:
| Return a properly signed INFINITY and set the exception flags
        movel   IMM (0x7ff00000),d0
        movel   IMM (0),d1
        orl     d7,d0
        movew   IMM (INEXACT_RESULT+DIVIDE_BY_ZERO),d7
        moveq   IMM (DOUBLE_FLOAT),d6
        PICJUMP $_exception_handler

|=============================================================================
|=============================================================================
|                         double precision routines
|=============================================================================
|=============================================================================

| A double precision floating point number (double) has the format:
|
| struct _double {
|  unsigned int sign      : 1;  /* sign bit */ 
|  unsigned int exponent  : 11; /* exponent, shifted by 126 */
|  unsigned int fraction  : 52; /* fraction */
| } double;
| 
| Thus sizeof(double) = 8 (64 bits). 
|
| All the routines are callable from C programs, and return the result 
| in the register pair d0-d1. They also preserve all registers except 
| d0-d1 and a0-a1.

|=============================================================================
|                              __subdf3
|=============================================================================

| double __subdf3(double, double);
        FUNC(__subdf3)
SYM (__subdf3):
        bchg    IMM (31),sp@(12) | change sign of second operand
                                | and fall through, so we always add
|=============================================================================
|                              __adddf3
|=============================================================================

| double __adddf3(double, double);
        FUNC(__adddf3)
SYM (__adddf3):
#ifndef __mcoldfire__
        link    a6,IMM (0)      | everything will be done in registers
        moveml  d2-d7,sp@-      | save all data registers and a2 (but d0-d1)
#else
        link    a6,IMM (-24)
        moveml  d2-d7,sp@
#endif
        movel   a6@(8),d0       | get first operand
        movel   a6@(12),d1      | 
        movel   a6@(16),d2      | get second operand
        movel   a6@(20),d3      | 

        movel   d0,d7           | get d0's sign bit in d7 '
        addl    d1,d1           | check and clear sign bit of a, and gain one
        addxl   d0,d0           | bit of extra precision
        beq     Ladddf$b        | if zero return second operand

        movel   d2,d6           | save sign in d6 
        addl    d3,d3           | get rid of sign bit and gain one bit of
        addxl   d2,d2           | extra precision
        beq     Ladddf$a        | if zero return first operand

        andl    IMM (0x80000000),d7 | isolate a's sign bit '
        swap    d6              | and also b's sign bit '
#ifndef __mcoldfire__
        andw    IMM (0x8000),d6 |
        orw     d6,d7           | and combine them into d7, so that a's sign '
                                | bit is in the high word and b's is in the '
                                | low word, so d6 is free to be used
#else
        andl    IMM (0x8000),d6
        orl     d6,d7
#endif
        movel   d7,a0           | now save d7 into a0, so d7 is free to
                                | be used also

| Get the exponents and check for denormalized and/or infinity.

        movel   IMM (0x001fffff),d6 | mask for the fraction
        movel   IMM (0x00200000),d7 | mask to put hidden bit back

        movel   d0,d4           | 
        andl    d6,d0           | get fraction in d0
        notl    d6              | make d6 into mask for the exponent
        andl    d6,d4           | get exponent in d4
        beq     Ladddf$a$den    | branch if a is denormalized
        cmpl    d6,d4           | check for INFINITY or NaN
        beq     Ladddf$nf       | 
        orl     d7,d0           | and put hidden bit back
Ladddf$1:
        swap    d4              | shift right exponent so that it starts
#ifndef __mcoldfire__
        lsrw    IMM (5),d4      | in bit 0 and not bit 20
#else
        lsrl    IMM (5),d4      | in bit 0 and not bit 20
#endif
| Now we have a's exponent in d4 and fraction in d0-d1 '
        movel   d2,d5           | save b to get exponent
        andl    d6,d5           | get exponent in d5
        beq     Ladddf$b$den    | branch if b is denormalized
        cmpl    d6,d5           | check for INFINITY or NaN
        beq     Ladddf$nf
        notl    d6              | make d6 into mask for the fraction again
        andl    d6,d2           | and get fraction in d2
        orl     d7,d2           | and put hidden bit back
Ladddf$2:
        swap    d5              | shift right exponent so that it starts
#ifndef __mcoldfire__
        lsrw    IMM (5),d5      | in bit 0 and not bit 20
#else
        lsrl    IMM (5),d5      | in bit 0 and not bit 20
#endif

| Now we have b's exponent in d5 and fraction in d2-d3. '

| The situation now is as follows: the signs are combined in a0, the 
| numbers are in d0-d1 (a) and d2-d3 (b), and the exponents in d4 (a)
| and d5 (b). To do the rounding correctly we need to keep all the
| bits until the end, so we need to use d0-d1-d2-d3 for the first number
| and d4-d5-d6-d7 for the second. To do this we store (temporarily) the
| exponents in a2-a3.

#ifndef __mcoldfire__
        moveml  a2-a3,sp@-      | save the address registers
#else
        movel   a2,sp@- 
        movel   a3,sp@- 
        movel   a4,sp@- 
#endif

        movel   d4,a2           | save the exponents
        movel   d5,a3           | 

        movel   IMM (0),d7      | and move the numbers around
        movel   d7,d6           |
        movel   d3,d5           |
        movel   d2,d4           |
        movel   d7,d3           |
        movel   d7,d2           |

| Here we shift the numbers until the exponents are the same, and put 
| the largest exponent in a2.
#ifndef __mcoldfire__
        exg     d4,a2           | get exponents back
        exg     d5,a3           |
        cmpw    d4,d5           | compare the exponents
#else
        movel   d4,a4           | get exponents back
        movel   a2,d4
        movel   a4,a2
        movel   d5,a4
        movel   a3,d5
        movel   a4,a3
        cmpl    d4,d5           | compare the exponents
#endif
        beq     Ladddf$3        | if equal don't shift '
        bhi     9f              | branch if second exponent is higher

| Here we have a's exponent larger than b's, so we have to shift b. We do 
| this by using as counter d2:
1:      movew   d4,d2           | move largest exponent to d2
#ifndef __mcoldfire__
        subw    d5,d2           | and subtract second exponent
        exg     d4,a2           | get back the longs we saved
        exg     d5,a3           |
#else
        subl    d5,d2           | and subtract second exponent
        movel   d4,a4           | get back the longs we saved
        movel   a2,d4
        movel   a4,a2
        movel   d5,a4
        movel   a3,d5
        movel   a4,a3
#endif
| if difference is too large we don't shift (actually, we can just exit) '
#ifndef __mcoldfire__
        cmpw    IMM (DBL_MANT_DIG+2),d2
#else
        cmpl    IMM (DBL_MANT_DIG+2),d2
#endif
        bge     Ladddf$b$small
#ifndef __mcoldfire__
        cmpw    IMM (32),d2     | if difference >= 32, shift by longs
#else
        cmpl    IMM (32),d2     | if difference >= 32, shift by longs
#endif
        bge     5f
2:
#ifndef __mcoldfire__
        cmpw    IMM (16),d2     | if difference >= 16, shift by words   
#else
        cmpl    IMM (16),d2     | if difference >= 16, shift by words   
#endif
        bge     6f
        bra     3f              | enter dbra loop

4:
#ifndef __mcoldfire__
        lsrl    IMM (1),d4
        roxrl   IMM (1),d5
        roxrl   IMM (1),d6
        roxrl   IMM (1),d7
#else
        lsrl    IMM (1),d7
        btst    IMM (0),d6
        beq     10f
        bset    IMM (31),d7
10:     lsrl    IMM (1),d6
        btst    IMM (0),d5
        beq     11f
        bset    IMM (31),d6
11:     lsrl    IMM (1),d5
        btst    IMM (0),d4
        beq     12f
        bset    IMM (31),d5
12:     lsrl    IMM (1),d4
#endif
3:
#ifndef __mcoldfire__
        dbra    d2,4b
#else
        subql   IMM (1),d2
        bpl     4b      
#endif
        movel   IMM (0),d2
        movel   d2,d3   
        bra     Ladddf$4
5:
        movel   d6,d7
        movel   d5,d6
        movel   d4,d5
        movel   IMM (0),d4
#ifndef __mcoldfire__
        subw    IMM (32),d2
#else
        subl    IMM (32),d2
#endif
        bra     2b
6:
        movew   d6,d7
        swap    d7
        movew   d5,d6
        swap    d6
        movew   d4,d5
        swap    d5
        movew   IMM (0),d4
        swap    d4
#ifndef __mcoldfire__
        subw    IMM (16),d2
#else
        subl    IMM (16),d2
#endif
        bra     3b
        
9:
#ifndef __mcoldfire__
        exg     d4,d5
        movew   d4,d6
        subw    d5,d6           | keep d5 (largest exponent) in d4
        exg     d4,a2
        exg     d5,a3
#else
        movel   d5,d6
        movel   d4,d5
        movel   d6,d4
        subl    d5,d6
        movel   d4,a4
        movel   a2,d4
        movel   a4,a2
        movel   d5,a4
        movel   a3,d5
        movel   a4,a3
#endif
| if difference is too large we don't shift (actually, we can just exit) '
#ifndef __mcoldfire__
        cmpw    IMM (DBL_MANT_DIG+2),d6
#else
        cmpl    IMM (DBL_MANT_DIG+2),d6
#endif
        bge     Ladddf$a$small
#ifndef __mcoldfire__
        cmpw    IMM (32),d6     | if difference >= 32, shift by longs
#else
        cmpl    IMM (32),d6     | if difference >= 32, shift by longs
#endif
        bge     5f
2:
#ifndef __mcoldfire__
        cmpw    IMM (16),d6     | if difference >= 16, shift by words   
#else
        cmpl    IMM (16),d6     | if difference >= 16, shift by words   
#endif
        bge     6f
        bra     3f              | enter dbra loop

4:
#ifndef __mcoldfire__
        lsrl    IMM (1),d0
        roxrl   IMM (1),d1
        roxrl   IMM (1),d2
        roxrl   IMM (1),d3
#else
        lsrl    IMM (1),d3
        btst    IMM (0),d2
        beq     10f
        bset    IMM (31),d3
10:     lsrl    IMM (1),d2
        btst    IMM (0),d1
        beq     11f
        bset    IMM (31),d2
11:     lsrl    IMM (1),d1
        btst    IMM (0),d0
        beq     12f
        bset    IMM (31),d1
12:     lsrl    IMM (1),d0
#endif
3:
#ifndef __mcoldfire__
        dbra    d6,4b
#else
        subql   IMM (1),d6
        bpl     4b
#endif
        movel   IMM (0),d7
        movel   d7,d6
        bra     Ladddf$4
5:
        movel   d2,d3
        movel   d1,d2
        movel   d0,d1
        movel   IMM (0),d0
#ifndef __mcoldfire__
        subw    IMM (32),d6
#else
        subl    IMM (32),d6
#endif
        bra     2b
6:
        movew   d2,d3
        swap    d3
        movew   d1,d2
        swap    d2
        movew   d0,d1
        swap    d1
        movew   IMM (0),d0
        swap    d0
#ifndef __mcoldfire__
        subw    IMM (16),d6
#else
        subl    IMM (16),d6
#endif
        bra     3b
Ladddf$3:
#ifndef __mcoldfire__
        exg     d4,a2   
        exg     d5,a3
#else
        movel   d4,a4
        movel   a2,d4
        movel   a4,a2
        movel   d5,a4
        movel   a3,d5
        movel   a4,a3
#endif
Ladddf$4:       
| Now we have the numbers in d0--d3 and d4--d7, the exponent in a2, and
| the signs in a4.

| Here we have to decide whether to add or subtract the numbers:
#ifndef __mcoldfire__
        exg     d7,a0           | get the signs 
        exg     d6,a3           | a3 is free to be used
#else
        movel   d7,a4
        movel   a0,d7
        movel   a4,a0
        movel   d6,a4
        movel   a3,d6
        movel   a4,a3
#endif
        movel   d7,d6           |
        movew   IMM (0),d7      | get a's sign in d7 '
        swap    d6              |
        movew   IMM (0),d6      | and b's sign in d6 '
        eorl    d7,d6           | compare the signs
        bmi     Lsubdf$0        | if the signs are different we have 
                                | to subtract
#ifndef __mcoldfire__
        exg     d7,a0           | else we add the numbers
        exg     d6,a3           |
#else
        movel   d7,a4
        movel   a0,d7
        movel   a4,a0
        movel   d6,a4
        movel   a3,d6
        movel   a4,a3
#endif
        addl    d7,d3           |
        addxl   d6,d2           |
        addxl   d5,d1           | 
        addxl   d4,d0           |

        movel   a2,d4           | return exponent to d4
        movel   a0,d7           | 
        andl    IMM (0x80000000),d7 | d7 now has the sign

#ifndef __mcoldfire__
        moveml  sp@+,a2-a3      
#else
        movel   sp@+,a4 
        movel   sp@+,a3 
        movel   sp@+,a2 
#endif

| Before rounding normalize so bit #DBL_MANT_DIG is set (we will consider
| the case of denormalized numbers in the rounding routine itself).
| As in the addition (not in the subtraction!) we could have set 
| one more bit we check this:
        btst    IMM (DBL_MANT_DIG+1),d0 
        beq     1f
#ifndef __mcoldfire__
        lsrl    IMM (1),d0
        roxrl   IMM (1),d1
        roxrl   IMM (1),d2
        roxrl   IMM (1),d3
        addw    IMM (1),d4
#else
        lsrl    IMM (1),d3
        btst    IMM (0),d2
        beq     10f
        bset    IMM (31),d3
10:     lsrl    IMM (1),d2
        btst    IMM (0),d1
        beq     11f
        bset    IMM (31),d2
11:     lsrl    IMM (1),d1
        btst    IMM (0),d0
        beq     12f
        bset    IMM (31),d1
12:     lsrl    IMM (1),d0
        addl    IMM (1),d4
#endif
1:
        lea     pc@(Ladddf$5),a0 | to return from rounding routine
        PICLEA  SYM (_fpCCR),a1 | check the rounding mode
#ifdef __mcoldfire__
        clrl    d6
#endif
        movew   a1@(6),d6       | rounding mode in d6
        beq     Lround$to$nearest
#ifndef __mcoldfire__
        cmpw    IMM (ROUND_TO_PLUS),d6
#else
        cmpl    IMM (ROUND_TO_PLUS),d6
#endif
        bhi     Lround$to$minus
        blt     Lround$to$zero
        bra     Lround$to$plus
Ladddf$5:
| Put back the exponent and check for overflow
#ifndef __mcoldfire__
        cmpw    IMM (0x7ff),d4  | is the exponent big?
#else
        cmpl    IMM (0x7ff),d4  | is the exponent big?
#endif
        bge     1f
        bclr    IMM (DBL_MANT_DIG-1),d0
#ifndef __mcoldfire__
        lslw    IMM (4),d4      | put exponent back into position
#else
        lsll    IMM (4),d4      | put exponent back into position
#endif
        swap    d0              | 
#ifndef __mcoldfire__
        orw     d4,d0           |
#else
        orl     d4,d0           |
#endif
        swap    d0              |
        bra     Ladddf$ret
1:
        moveq   IMM (ADD),d5
        bra     Ld$overflow

Lsubdf$0:
| Here we do the subtraction.
#ifndef __mcoldfire__
        exg     d7,a0           | put sign back in a0
        exg     d6,a3           |
#else
        movel   d7,a4
        movel   a0,d7
        movel   a4,a0
        movel   d6,a4
        movel   a3,d6
        movel   a4,a3
#endif
        subl    d7,d3           |
        subxl   d6,d2           |
        subxl   d5,d1           |
        subxl   d4,d0           |
        beq     Ladddf$ret$1    | if zero just exit
        bpl     1f              | if positive skip the following
        movel   a0,d7           |
        bchg    IMM (31),d7     | change sign bit in d7
        movel   d7,a0           |
        negl    d3              |
        negxl   d2              |
        negxl   d1              | and negate result
        negxl   d0              |
1:      
        movel   a2,d4           | return exponent to d4
        movel   a0,d7
        andl    IMM (0x80000000),d7 | isolate sign bit
#ifndef __mcoldfire__
        moveml  sp@+,a2-a3      |
#else
        movel   sp@+,a4
        movel   sp@+,a3
        movel   sp@+,a2
#endif

| Before rounding normalize so bit #DBL_MANT_DIG is set (we will consider
| the case of denormalized numbers in the rounding routine itself).
| As in the addition (not in the subtraction!) we could have set 
| one more bit we check this:
        btst    IMM (DBL_MANT_DIG+1),d0 
        beq     1f
#ifndef __mcoldfire__
        lsrl    IMM (1),d0
        roxrl   IMM (1),d1
        roxrl   IMM (1),d2
        roxrl   IMM (1),d3
        addw    IMM (1),d4
#else
        lsrl    IMM (1),d3
        btst    IMM (0),d2
        beq     10f
        bset    IMM (31),d3
10:     lsrl    IMM (1),d2
        btst    IMM (0),d1
        beq     11f
        bset    IMM (31),d2
11:     lsrl    IMM (1),d1
        btst    IMM (0),d0
        beq     12f
        bset    IMM (31),d1
12:     lsrl    IMM (1),d0
        addl    IMM (1),d4
#endif
1:
        lea     pc@(Lsubdf$1),a0 | to return from rounding routine
        PICLEA  SYM (_fpCCR),a1 | check the rounding mode
#ifdef __mcoldfire__
        clrl    d6
#endif
        movew   a1@(6),d6       | rounding mode in d6
        beq     Lround$to$nearest
#ifndef __mcoldfire__
        cmpw    IMM (ROUND_TO_PLUS),d6
#else
        cmpl    IMM (ROUND_TO_PLUS),d6
#endif
        bhi     Lround$to$minus
        blt     Lround$to$zero
        bra     Lround$to$plus
Lsubdf$1:
| Put back the exponent and sign (we don't have overflow). '
        bclr    IMM (DBL_MANT_DIG-1),d0 
#ifndef __mcoldfire__
        lslw    IMM (4),d4      | put exponent back into position
#else
        lsll    IMM (4),d4      | put exponent back into position
#endif
        swap    d0              | 
#ifndef __mcoldfire__
        orw     d4,d0           |
#else
        orl     d4,d0           |
#endif
        swap    d0              |
        bra     Ladddf$ret

| If one of the numbers was too small (difference of exponents >= 
| DBL_MANT_DIG+1) we return the other (and now we don't have to '
| check for finiteness or zero).
Ladddf$a$small:
#ifndef __mcoldfire__
        moveml  sp@+,a2-a3      
#else
        movel   sp@+,a4
        movel   sp@+,a3
        movel   sp@+,a2
#endif
        movel   a6@(16),d0
        movel   a6@(20),d1
        PICLEA  SYM (_fpCCR),a0
        movew   IMM (0),a0@
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7      | restore data registers
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6              | and return
        rts

Ladddf$b$small:
#ifndef __mcoldfire__
        moveml  sp@+,a2-a3      
#else
        movel   sp@+,a4 
        movel   sp@+,a3 
        movel   sp@+,a2 
#endif
        movel   a6@(8),d0
        movel   a6@(12),d1
        PICLEA  SYM (_fpCCR),a0
        movew   IMM (0),a0@
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7      | restore data registers
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6              | and return
        rts

Ladddf$a$den:
        movel   d7,d4           | d7 contains 0x00200000
        bra     Ladddf$1

Ladddf$b$den:
        movel   d7,d5           | d7 contains 0x00200000
        notl    d6
        bra     Ladddf$2

Ladddf$b:
| Return b (if a is zero)
        movel   d2,d0
        movel   d3,d1
        bne     1f                      | Check if b is -0
        cmpl    IMM (0x80000000),d0
        bne     1f
        andl    IMM (0x80000000),d7     | Use the sign of a
        clrl    d0
        bra     Ladddf$ret
Ladddf$a:
        movel   a6@(8),d0
        movel   a6@(12),d1
1:
        moveq   IMM (ADD),d5
| Check for NaN and +/-INFINITY.
        movel   d0,d7                   |
        andl    IMM (0x80000000),d7     |
        bclr    IMM (31),d0             |
        cmpl    IMM (0x7ff00000),d0     |
        bge     2f                      |
        movel   d0,d0                   | check for zero, since we don't  '
        bne     Ladddf$ret              | want to return -0 by mistake
        bclr    IMM (31),d7             |
        bra     Ladddf$ret              |
2:
        andl    IMM (0x000fffff),d0     | check for NaN (nonzero fraction)
        orl     d1,d0                   |
        bne     Ld$inop                 |
        bra     Ld$infty                |
        
Ladddf$ret$1:
#ifndef __mcoldfire__
        moveml  sp@+,a2-a3      | restore regs and exit
#else
        movel   sp@+,a4
        movel   sp@+,a3
        movel   sp@+,a2
#endif

Ladddf$ret:
| Normal exit.
        PICLEA  SYM (_fpCCR),a0
        movew   IMM (0),a0@
        orl     d7,d0           | put sign bit back
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6
        rts

Ladddf$ret$den:
| Return a denormalized number.
#ifndef __mcoldfire__
        lsrl    IMM (1),d0      | shift right once more
        roxrl   IMM (1),d1      |
#else
        lsrl    IMM (1),d1
        btst    IMM (0),d0
        beq     10f
        bset    IMM (31),d1
10:     lsrl    IMM (1),d0
#endif
        bra     Ladddf$ret

Ladddf$nf:
        moveq   IMM (ADD),d5
| This could be faster but it is not worth the effort, since it is not
| executed very often. We sacrifice speed for clarity here.
        movel   a6@(8),d0       | get the numbers back (remember that we
        movel   a6@(12),d1      | did some processing already)
        movel   a6@(16),d2      | 
        movel   a6@(20),d3      | 
        movel   IMM (0x7ff00000),d4 | useful constant (INFINITY)
        movel   d0,d7           | save sign bits
        movel   d2,d6           | 
        bclr    IMM (31),d0     | clear sign bits
        bclr    IMM (31),d2     | 
| We know that one of them is either NaN of +/-INFINITY
| Check for NaN (if either one is NaN return NaN)
        cmpl    d4,d0           | check first a (d0)
        bhi     Ld$inop         | if d0 > 0x7ff00000 or equal and
        bne     2f
        tstl    d1              | d1 > 0, a is NaN
        bne     Ld$inop         | 
2:      cmpl    d4,d2           | check now b (d1)
        bhi     Ld$inop         | 
        bne     3f
        tstl    d3              | 
        bne     Ld$inop         | 
3:
| Now comes the check for +/-INFINITY. We know that both are (maybe not
| finite) numbers, but we have to check if both are infinite whether we
| are adding or subtracting them.
        eorl    d7,d6           | to check sign bits
        bmi     1f
        andl    IMM (0x80000000),d7 | get (common) sign bit
        bra     Ld$infty
1:
| We know one (or both) are infinite, so we test for equality between the
| two numbers (if they are equal they have to be infinite both, so we
| return NaN).
        cmpl    d2,d0           | are both infinite?
        bne     1f              | if d0 <> d2 they are not equal
        cmpl    d3,d1           | if d0 == d2 test d3 and d1
        beq     Ld$inop         | if equal return NaN
1:      
        andl    IMM (0x80000000),d7 | get a's sign bit '
        cmpl    d4,d0           | test now for infinity
        beq     Ld$infty        | if a is INFINITY return with this sign
        bchg    IMM (31),d7     | else we know b is INFINITY and has
        bra     Ld$infty        | the opposite sign

|=============================================================================
|                              __muldf3
|=============================================================================

| double __muldf3(double, double);
        FUNC(__muldf3)
SYM (__muldf3):
#ifndef __mcoldfire__
        link    a6,IMM (0)
        moveml  d2-d7,sp@-
#else
        link    a6,IMM (-24)
        moveml  d2-d7,sp@
#endif
        movel   a6@(8),d0               | get a into d0-d1
        movel   a6@(12),d1              | 
        movel   a6@(16),d2              | and b into d2-d3
        movel   a6@(20),d3              |
        movel   d0,d7                   | d7 will hold the sign of the product
        eorl    d2,d7                   |
        andl    IMM (0x80000000),d7     |
        movel   d7,a0                   | save sign bit into a0 
        movel   IMM (0x7ff00000),d7     | useful constant (+INFINITY)
        movel   d7,d6                   | another (mask for fraction)
        notl    d6                      |
        bclr    IMM (31),d0             | get rid of a's sign bit '
        movel   d0,d4                   | 
        orl     d1,d4                   | 
        beq     Lmuldf$a$0              | branch if a is zero
        movel   d0,d4                   |
        bclr    IMM (31),d2             | get rid of b's sign bit '
        movel   d2,d5                   |
        orl     d3,d5                   | 
        beq     Lmuldf$b$0              | branch if b is zero
        movel   d2,d5                   | 
        cmpl    d7,d0                   | is a big?
        bhi     Lmuldf$inop             | if a is NaN return NaN
        beq     Lmuldf$a$nf             | we still have to check d1 and b ...
        cmpl    d7,d2                   | now compare b with INFINITY
        bhi     Lmuldf$inop             | is b NaN?
        beq     Lmuldf$b$nf             | we still have to check d3 ...
| Here we have both numbers finite and nonzero (and with no sign bit).
| Now we get the exponents into d4 and d5.
        andl    d7,d4                   | isolate exponent in d4
        beq     Lmuldf$a$den            | if exponent zero, have denormalized
        andl    d6,d0                   | isolate fraction
        orl     IMM (0x00100000),d0     | and put hidden bit back
        swap    d4                      | I like exponents in the first byte
#ifndef __mcoldfire__
        lsrw    IMM (4),d4              | 
#else
        lsrl    IMM (4),d4              | 
#endif
Lmuldf$1:                       
        andl    d7,d5                   |
        beq     Lmuldf$b$den            |
        andl    d6,d2                   |
        orl     IMM (0x00100000),d2     | and put hidden bit back
        swap    d5                      |
#ifndef __mcoldfire__
        lsrw    IMM (4),d5              |
#else
        lsrl    IMM (4),d5              |
#endif
Lmuldf$2:                               |
#ifndef __mcoldfire__
        addw    d5,d4                   | add exponents
        subw    IMM (D_BIAS+1),d4       | and subtract bias (plus one)
#else
        addl    d5,d4                   | add exponents
        subl    IMM (D_BIAS+1),d4       | and subtract bias (plus one)
#endif

| We are now ready to do the multiplication. The situation is as follows:
| both a and b have bit 52 ( bit 20 of d0 and d2) set (even if they were 
| denormalized to start with!), which means that in the product bit 104 
| (which will correspond to bit 8 of the fourth long) is set.

| Here we have to do the product.
| To do it we have to juggle the registers back and forth, as there are not
| enough to keep everything in them. So we use the address registers to keep
| some intermediate data.

#ifndef __mcoldfire__
        moveml  a2-a3,sp@-      | save a2 and a3 for temporary use
#else
        movel   a2,sp@-
        movel   a3,sp@-
        movel   a4,sp@-
#endif
        movel   IMM (0),a2      | a2 is a null register
        movel   d4,a3           | and a3 will preserve the exponent

| First, shift d2-d3 so bit 20 becomes bit 31:
#ifndef __mcoldfire__
        rorl    IMM (5),d2      | rotate d2 5 places right
        swap    d2              | and swap it
        rorl    IMM (5),d3      | do the same thing with d3
        swap    d3              |
        movew   d3,d6           | get the rightmost 11 bits of d3
        andw    IMM (0x07ff),d6 |
        orw     d6,d2           | and put them into d2
        andw    IMM (0xf800),d3 | clear those bits in d3
#else
        moveq   IMM (11),d7     | left shift d2 11 bits
        lsll    d7,d2
        movel   d3,d6           | get a copy of d3
        lsll    d7,d3           | left shift d3 11 bits
        andl    IMM (0xffe00000),d6 | get the top 11 bits of d3
        moveq   IMM (21),d7     | right shift them 21 bits
        lsrl    d7,d6
        orl     d6,d2           | stick them at the end of d2
#endif

        movel   d2,d6           | move b into d6-d7
        movel   d3,d7           | move a into d4-d5
        movel   d0,d4           | and clear d0-d1-d2-d3 (to put result)
        movel   d1,d5           |
        movel   IMM (0),d3      |
        movel   d3,d2           |
        movel   d3,d1           |
        movel   d3,d0           |

| We use a1 as counter: 
        movel   IMM (DBL_MANT_DIG-1),a1         
#ifndef __mcoldfire__
        exg     d7,a1
#else
        movel   d7,a4
        movel   a1,d7
        movel   a4,a1
#endif

1:
#ifndef __mcoldfire__
        exg     d7,a1           | put counter back in a1
#else
        movel   d7,a4
        movel   a1,d7
        movel   a4,a1
#endif
        addl    d3,d3           | shift sum once left
        addxl   d2,d2           |
        addxl   d1,d1           |
        addxl   d0,d0           |
        addl    d7,d7           |
        addxl   d6,d6           |
        bcc     2f              | if bit clear skip the following
#ifndef __mcoldfire__
        exg     d7,a2           |
#else
        movel   d7,a4
        movel   a2,d7
        movel   a4,a2
#endif
        addl    d5,d3           | else add a to the sum
        addxl   d4,d2           |
        addxl   d7,d1           |
        addxl   d7,d0           |
#ifndef __mcoldfire__
        exg     d7,a2           | 
#else
        movel   d7,a4
        movel   a2,d7
        movel   a4,a2
#endif
2:
#ifndef __mcoldfire__
        exg     d7,a1           | put counter in d7
        dbf     d7,1b           | decrement and branch
#else
        movel   d7,a4
        movel   a1,d7
        movel   a4,a1
        subql   IMM (1),d7
        bpl     1b
#endif

        movel   a3,d4           | restore exponent
#ifndef __mcoldfire__
        moveml  sp@+,a2-a3
#else
        movel   sp@+,a4
        movel   sp@+,a3
        movel   sp@+,a2
#endif

| Now we have the product in d0-d1-d2-d3, with bit 8 of d0 set. The 
| first thing to do now is to normalize it so bit 8 becomes bit 
| DBL_MANT_DIG-32 (to do the rounding); later we will shift right.
        swap    d0
        swap    d1
        movew   d1,d0
        swap    d2
        movew   d2,d1
        swap    d3
        movew   d3,d2
        movew   IMM (0),d3
#ifndef __mcoldfire__
        lsrl    IMM (1),d0
        roxrl   IMM (1),d1
        roxrl   IMM (1),d2
        roxrl   IMM (1),d3
        lsrl    IMM (1),d0
        roxrl   IMM (1),d1
        roxrl   IMM (1),d2
        roxrl   IMM (1),d3
        lsrl    IMM (1),d0
        roxrl   IMM (1),d1
        roxrl   IMM (1),d2
        roxrl   IMM (1),d3
#else
        moveq   IMM (29),d6
        lsrl    IMM (3),d3
        movel   d2,d7
        lsll    d6,d7
        orl     d7,d3
        lsrl    IMM (3),d2
        movel   d1,d7
        lsll    d6,d7
        orl     d7,d2
        lsrl    IMM (3),d1
        movel   d0,d7
        lsll    d6,d7
        orl     d7,d1
        lsrl    IMM (3),d0
#endif
        
| Now round, check for over- and underflow, and exit.
        movel   a0,d7           | get sign bit back into d7
        moveq   IMM (MULTIPLY),d5

        btst    IMM (DBL_MANT_DIG+1-32),d0
        beq     Lround$exit
#ifndef __mcoldfire__
        lsrl    IMM (1),d0
        roxrl   IMM (1),d1
        addw    IMM (1),d4
#else
        lsrl    IMM (1),d1
        btst    IMM (0),d0
        beq     10f
        bset    IMM (31),d1
10:     lsrl    IMM (1),d0
        addl    IMM (1),d4
#endif
        bra     Lround$exit

Lmuldf$inop:
        moveq   IMM (MULTIPLY),d5
        bra     Ld$inop

Lmuldf$b$nf:
        moveq   IMM (MULTIPLY),d5
        movel   a0,d7           | get sign bit back into d7
        tstl    d3              | we know d2 == 0x7ff00000, so check d3
        bne     Ld$inop         | if d3 <> 0 b is NaN
        bra     Ld$overflow     | else we have overflow (since a is finite)

Lmuldf$a$nf:
        moveq   IMM (MULTIPLY),d5
        movel   a0,d7           | get sign bit back into d7
        tstl    d1              | we know d0 == 0x7ff00000, so check d1
        bne     Ld$inop         | if d1 <> 0 a is NaN
        bra     Ld$overflow     | else signal overflow

| If either number is zero return zero, unless the other is +/-INFINITY or
| NaN, in which case we return NaN.
Lmuldf$b$0:
        moveq   IMM (MULTIPLY),d5
#ifndef __mcoldfire__
        exg     d2,d0           | put b (==0) into d0-d1
        exg     d3,d1           | and a (with sign bit cleared) into d2-d3
        movel   a0,d0           | set result sign
#else
        movel   d0,d2           | put a into d2-d3
        movel   d1,d3
        movel   a0,d0           | put result zero into d0-d1
        movq    IMM(0),d1
#endif
        bra     1f
Lmuldf$a$0:
        movel   a0,d0           | set result sign
        movel   a6@(16),d2      | put b into d2-d3 again
        movel   a6@(20),d3      |
        bclr    IMM (31),d2     | clear sign bit
1:      cmpl    IMM (0x7ff00000),d2 | check for non-finiteness
        bge     Ld$inop         | in case NaN or +/-INFINITY return NaN
        PICLEA  SYM (_fpCCR),a0
        movew   IMM (0),a0@
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6
        rts

| If a number is denormalized we put an exponent of 1 but do not put the 
| hidden bit back into the fraction; instead we shift left until bit 21
| (the hidden bit) is set, adjusting the exponent accordingly. We do this
| to ensure that the product of the fractions is close to 1.
Lmuldf$a$den:
        movel   IMM (1),d4
        andl    d6,d0
1:      addl    d1,d1           | shift a left until bit 20 is set
        addxl   d0,d0           |
#ifndef __mcoldfire__
        subw    IMM (1),d4      | and adjust exponent
#else
        subl    IMM (1),d4      | and adjust exponent
#endif
        btst    IMM (20),d0     |
        bne     Lmuldf$1        |
        bra     1b

Lmuldf$b$den:
        movel   IMM (1),d5
        andl    d6,d2
1:      addl    d3,d3           | shift b left until bit 20 is set
        addxl   d2,d2           |
#ifndef __mcoldfire__
        subw    IMM (1),d5      | and adjust exponent
#else
        subql   IMM (1),d5      | and adjust exponent
#endif
        btst    IMM (20),d2     |
        bne     Lmuldf$2        |
        bra     1b


|=============================================================================
|                              __divdf3
|=============================================================================

| double __divdf3(double, double);
        FUNC(__divdf3)
SYM (__divdf3):
#ifndef __mcoldfire__
        link    a6,IMM (0)
        moveml  d2-d7,sp@-
#else
        link    a6,IMM (-24)
        moveml  d2-d7,sp@
#endif
        movel   a6@(8),d0       | get a into d0-d1
        movel   a6@(12),d1      | 
        movel   a6@(16),d2      | and b into d2-d3
        movel   a6@(20),d3      |
        movel   d0,d7           | d7 will hold the sign of the result
        eorl    d2,d7           |
        andl    IMM (0x80000000),d7
        movel   d7,a0           | save sign into a0
        movel   IMM (0x7ff00000),d7 | useful constant (+INFINITY)
        movel   d7,d6           | another (mask for fraction)
        notl    d6              |
        bclr    IMM (31),d0     | get rid of a's sign bit '
        movel   d0,d4           |
        orl     d1,d4           |
        beq     Ldivdf$a$0      | branch if a is zero
        movel   d0,d4           |
        bclr    IMM (31),d2     | get rid of b's sign bit '
        movel   d2,d5           |
        orl     d3,d5           |
        beq     Ldivdf$b$0      | branch if b is zero
        movel   d2,d5
        cmpl    d7,d0           | is a big?
        bhi     Ldivdf$inop     | if a is NaN return NaN
        beq     Ldivdf$a$nf     | if d0 == 0x7ff00000 we check d1
        cmpl    d7,d2           | now compare b with INFINITY 
        bhi     Ldivdf$inop     | if b is NaN return NaN
        beq     Ldivdf$b$nf     | if d2 == 0x7ff00000 we check d3
| Here we have both numbers finite and nonzero (and with no sign bit).
| Now we get the exponents into d4 and d5 and normalize the numbers to
| ensure that the ratio of the fractions is around 1. We do this by
| making sure that both numbers have bit #DBL_MANT_DIG-32-1 (hidden bit)
| set, even if they were denormalized to start with.
| Thus, the result will satisfy: 2 > result > 1/2.
        andl    d7,d4           | and isolate exponent in d4
        beq     Ldivdf$a$den    | if exponent is zero we have a denormalized
        andl    d6,d0           | and isolate fraction
        orl     IMM (0x00100000),d0 | and put hidden bit back
        swap    d4              | I like exponents in the first byte
#ifndef __mcoldfire__
        lsrw    IMM (4),d4      | 
#else
        lsrl    IMM (4),d4      | 
#endif
Ldivdf$1:                       | 
        andl    d7,d5           |
        beq     Ldivdf$b$den    |
        andl    d6,d2           |
        orl     IMM (0x00100000),d2
        swap    d5              |
#ifndef __mcoldfire__
        lsrw    IMM (4),d5      |
#else
        lsrl    IMM (4),d5      |
#endif
Ldivdf$2:                       |
#ifndef __mcoldfire__
        subw    d5,d4           | subtract exponents
        addw    IMM (D_BIAS),d4 | and add bias
#else
        subl    d5,d4           | subtract exponents
        addl    IMM (D_BIAS),d4 | and add bias
#endif

| We are now ready to do the division. We have prepared things in such a way
| that the ratio of the fractions will be less than 2 but greater than 1/2.
| At this point the registers in use are:
| d0-d1 hold a (first operand, bit DBL_MANT_DIG-32=0, bit 
| DBL_MANT_DIG-1-32=1)
| d2-d3 hold b (second operand, bit DBL_MANT_DIG-32=1)
| d4    holds the difference of the exponents, corrected by the bias
| a0    holds the sign of the ratio

| To do the rounding correctly we need to keep information about the
| nonsignificant bits. One way to do this would be to do the division
| using four registers; another is to use two registers (as originally
| I did), but use a sticky bit to preserve information about the 
| fractional part. Note that we can keep that info in a1, which is not
| used.
        movel   IMM (0),d6      | d6-d7 will hold the result
        movel   d6,d7           | 
        movel   IMM (0),a1      | and a1 will hold the sticky bit

        movel   IMM (DBL_MANT_DIG-32+1),d5      
        
1:      cmpl    d0,d2           | is a < b?
        bhi     3f              | if b > a skip the following
        beq     4f              | if d0==d2 check d1 and d3
2:      subl    d3,d1           | 
        subxl   d2,d0           | a <-- a - b
        bset    d5,d6           | set the corresponding bit in d6
3:      addl    d1,d1           | shift a by 1
        addxl   d0,d0           |
#ifndef __mcoldfire__
        dbra    d5,1b           | and branch back
#else
        subql   IMM (1), d5
        bpl     1b
#endif
        bra     5f                      
4:      cmpl    d1,d3           | here d0==d2, so check d1 and d3
        bhi     3b              | if d1 > d2 skip the subtraction
        bra     2b              | else go do it
5:
| Here we have to start setting the bits in the second long.
        movel   IMM (31),d5     | again d5 is counter

1:      cmpl    d0,d2           | is a < b?
        bhi     3f              | if b > a skip the following
        beq     4f              | if d0==d2 check d1 and d3
2:      subl    d3,d1           | 
        subxl   d2,d0           | a <-- a - b
        bset    d5,d7           | set the corresponding bit in d7
3:      addl    d1,d1           | shift a by 1
        addxl   d0,d0           |
#ifndef __mcoldfire__
        dbra    d5,1b           | and branch back
#else
        subql   IMM (1), d5
        bpl     1b
#endif
        bra     5f                      
4:      cmpl    d1,d3           | here d0==d2, so check d1 and d3
        bhi     3b              | if d1 > d2 skip the subtraction
        bra     2b              | else go do it
5:
| Now go ahead checking until we hit a one, which we store in d2.
        movel   IMM (DBL_MANT_DIG),d5
1:      cmpl    d2,d0           | is a < b?
        bhi     4f              | if b < a, exit
        beq     3f              | if d0==d2 check d1 and d3
2:      addl    d1,d1           | shift a by 1
        addxl   d0,d0           |
#ifndef __mcoldfire__
        dbra    d5,1b           | and branch back
#else
        subql   IMM (1), d5
        bpl     1b
#endif
        movel   IMM (0),d2      | here no sticky bit was found
        movel   d2,d3
        bra     5f                      
3:      cmpl    d1,d3           | here d0==d2, so check d1 and d3
        bhi     2b              | if d1 > d2 go back
4:
| Here put the sticky bit in d2-d3 (in the position which actually corresponds
| to it; if you don't do this the algorithm loses in some cases). '
        movel   IMM (0),d2
        movel   d2,d3
#ifndef __mcoldfire__
        subw    IMM (DBL_MANT_DIG),d5
        addw    IMM (63),d5
        cmpw    IMM (31),d5
#else
        subl    IMM (DBL_MANT_DIG),d5
        addl    IMM (63),d5
        cmpl    IMM (31),d5
#endif
        bhi     2f
1:      bset    d5,d3
        bra     5f
#ifndef __mcoldfire__
        subw    IMM (32),d5
#else
        subl    IMM (32),d5
#endif
2:      bset    d5,d2
5:
| Finally we are finished! Move the longs in the address registers to
| their final destination:
        movel   d6,d0
        movel   d7,d1
        movel   IMM (0),d3

| Here we have finished the division, with the result in d0-d1-d2-d3, with
| 2^21 <= d6 < 2^23. Thus bit 23 is not set, but bit 22 could be set.
| If it is not, then definitely bit 21 is set. Normalize so bit 22 is
| not set:
        btst    IMM (DBL_MANT_DIG-32+1),d0
        beq     1f
#ifndef __mcoldfire__
        lsrl    IMM (1),d0
        roxrl   IMM (1),d1
        roxrl   IMM (1),d2
        roxrl   IMM (1),d3
        addw    IMM (1),d4
#else
        lsrl    IMM (1),d3
        btst    IMM (0),d2
        beq     10f
        bset    IMM (31),d3
10:     lsrl    IMM (1),d2
        btst    IMM (0),d1
        beq     11f
        bset    IMM (31),d2
11:     lsrl    IMM (1),d1
        btst    IMM (0),d0
        beq     12f
        bset    IMM (31),d1
12:     lsrl    IMM (1),d0
        addl    IMM (1),d4
#endif
1:
| Now round, check for over- and underflow, and exit.
        movel   a0,d7           | restore sign bit to d7
        moveq   IMM (DIVIDE),d5
        bra     Lround$exit

Ldivdf$inop:
        moveq   IMM (DIVIDE),d5
        bra     Ld$inop

Ldivdf$a$0:
| If a is zero check to see whether b is zero also. In that case return
| NaN; then check if b is NaN, and return NaN also in that case. Else
| return a properly signed zero.
        moveq   IMM (DIVIDE),d5
        bclr    IMM (31),d2     |
        movel   d2,d4           | 
        orl     d3,d4           | 
        beq     Ld$inop         | if b is also zero return NaN
        cmpl    IMM (0x7ff00000),d2 | check for NaN
        bhi     Ld$inop         | 
        blt     1f              |
        tstl    d3              |
        bne     Ld$inop         |
1:      movel   a0,d0           | else return signed zero
        moveq   IMM(0),d1       | 
        PICLEA  SYM (_fpCCR),a0 | clear exception flags
        movew   IMM (0),a0@     |
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7      | 
#else
        moveml  sp@,d2-d7       | 
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6              | 
        rts                     |       

Ldivdf$b$0:
        moveq   IMM (DIVIDE),d5
| If we got here a is not zero. Check if a is NaN; in that case return NaN,
| else return +/-INFINITY. Remember that a is in d0 with the sign bit 
| cleared already.
        movel   a0,d7           | put a's sign bit back in d7 '
        cmpl    IMM (0x7ff00000),d0 | compare d0 with INFINITY
        bhi     Ld$inop         | if larger it is NaN
        tstl    d1              | 
        bne     Ld$inop         | 
        bra     Ld$div$0        | else signal DIVIDE_BY_ZERO

Ldivdf$b$nf:
        moveq   IMM (DIVIDE),d5
| If d2 == 0x7ff00000 we have to check d3.
        tstl    d3              |
        bne     Ld$inop         | if d3 <> 0, b is NaN
        bra     Ld$underflow    | else b is +/-INFINITY, so signal underflow

Ldivdf$a$nf:
        moveq   IMM (DIVIDE),d5
| If d0 == 0x7ff00000 we have to check d1.
        tstl    d1              |
        bne     Ld$inop         | if d1 <> 0, a is NaN
| If a is INFINITY we have to check b
        cmpl    d7,d2           | compare b with INFINITY 
        bge     Ld$inop         | if b is NaN or INFINITY return NaN
        tstl    d3              |
        bne     Ld$inop         | 
        bra     Ld$overflow     | else return overflow

| If a number is denormalized we put an exponent of 1 but do not put the 
| bit back into the fraction.
Ldivdf$a$den:
        movel   IMM (1),d4
        andl    d6,d0
1:      addl    d1,d1           | shift a left until bit 20 is set
        addxl   d0,d0
#ifndef __mcoldfire__
        subw    IMM (1),d4      | and adjust exponent
#else
        subl    IMM (1),d4      | and adjust exponent
#endif
        btst    IMM (DBL_MANT_DIG-32-1),d0
        bne     Ldivdf$1
        bra     1b

Ldivdf$b$den:
        movel   IMM (1),d5
        andl    d6,d2
1:      addl    d3,d3           | shift b left until bit 20 is set
        addxl   d2,d2
#ifndef __mcoldfire__
        subw    IMM (1),d5      | and adjust exponent
#else
        subql   IMM (1),d5      | and adjust exponent
#endif
        btst    IMM (DBL_MANT_DIG-32-1),d2
        bne     Ldivdf$2
        bra     1b

Lround$exit:
| This is a common exit point for __muldf3 and __divdf3. When they enter
| this point the sign of the result is in d7, the result in d0-d1, normalized
| so that 2^21 <= d0 < 2^22, and the exponent is in the lower byte of d4.

| First check for underlow in the exponent:
#ifndef __mcoldfire__
        cmpw    IMM (-DBL_MANT_DIG-1),d4                
#else
        cmpl    IMM (-DBL_MANT_DIG-1),d4                
#endif
        blt     Ld$underflow    
| It could happen that the exponent is less than 1, in which case the 
| number is denormalized. In this case we shift right and adjust the 
| exponent until it becomes 1 or the fraction is zero (in the latter case 
| we signal underflow and return zero).
        movel   d7,a0           |
        movel   IMM (0),d6      | use d6-d7 to collect bits flushed right
        movel   d6,d7           | use d6-d7 to collect bits flushed right
#ifndef __mcoldfire__
        cmpw    IMM (1),d4      | if the exponent is less than 1 we 
#else
        cmpl    IMM (1),d4      | if the exponent is less than 1 we 
#endif
        bge     2f              | have to shift right (denormalize)
1:
#ifndef __mcoldfire__
        addw    IMM (1),d4      | adjust the exponent
        lsrl    IMM (1),d0      | shift right once 
        roxrl   IMM (1),d1      |
        roxrl   IMM (1),d2      |
        roxrl   IMM (1),d3      |
        roxrl   IMM (1),d6      | 
        roxrl   IMM (1),d7      |
        cmpw    IMM (1),d4      | is the exponent 1 already?
#else
        addl    IMM (1),d4      | adjust the exponent
        lsrl    IMM (1),d7
        btst    IMM (0),d6
        beq     13f
        bset    IMM (31),d7
13:     lsrl    IMM (1),d6
        btst    IMM (0),d3
        beq     14f
        bset    IMM (31),d6
14:     lsrl    IMM (1),d3
        btst    IMM (0),d2
        beq     10f
        bset    IMM (31),d3
10:     lsrl    IMM (1),d2
        btst    IMM (0),d1
        beq     11f
        bset    IMM (31),d2
11:     lsrl    IMM (1),d1
        btst    IMM (0),d0
        beq     12f
        bset    IMM (31),d1
12:     lsrl    IMM (1),d0
        cmpl    IMM (1),d4      | is the exponent 1 already?
#endif
        beq     2f              | if not loop back
        bra     1b              |
        bra     Ld$underflow    | safety check, shouldn't execute '
2:      orl     d6,d2           | this is a trick so we don't lose  '
        orl     d7,d3           | the bits which were flushed right
        movel   a0,d7           | get back sign bit into d7
| Now call the rounding routine (which takes care of denormalized numbers):
        lea     pc@(Lround$0),a0 | to return from rounding routine
        PICLEA  SYM (_fpCCR),a1 | check the rounding mode
#ifdef __mcoldfire__
        clrl    d6
#endif
        movew   a1@(6),d6       | rounding mode in d6
        beq     Lround$to$nearest
#ifndef __mcoldfire__
        cmpw    IMM (ROUND_TO_PLUS),d6
#else
        cmpl    IMM (ROUND_TO_PLUS),d6
#endif
        bhi     Lround$to$minus
        blt     Lround$to$zero
        bra     Lround$to$plus
Lround$0:
| Here we have a correctly rounded result (either normalized or denormalized).

| Here we should have either a normalized number or a denormalized one, and
| the exponent is necessarily larger or equal to 1 (so we don't have to  '
| check again for underflow!). We have to check for overflow or for a 
| denormalized number (which also signals underflow).
| Check for overflow (i.e., exponent >= 0x7ff).
#ifndef __mcoldfire__
        cmpw    IMM (0x07ff),d4
#else
        cmpl    IMM (0x07ff),d4
#endif
        bge     Ld$overflow
| Now check for a denormalized number (exponent==0):
        movew   d4,d4
        beq     Ld$den
1:
| Put back the exponents and sign and return.
#ifndef __mcoldfire__
        lslw    IMM (4),d4      | exponent back to fourth byte
#else
        lsll    IMM (4),d4      | exponent back to fourth byte
#endif
        bclr    IMM (DBL_MANT_DIG-32-1),d0
        swap    d0              | and put back exponent
#ifndef __mcoldfire__
        orw     d4,d0           | 
#else
        orl     d4,d0           | 
#endif
        swap    d0              |
        orl     d7,d0           | and sign also

        PICLEA  SYM (_fpCCR),a0
        movew   IMM (0),a0@
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6
        rts

|=============================================================================
|                              __negdf2
|=============================================================================

| double __negdf2(double, double);
        FUNC(__negdf2)
SYM (__negdf2):
#ifndef __mcoldfire__
        link    a6,IMM (0)
        moveml  d2-d7,sp@-
#else
        link    a6,IMM (-24)
        moveml  d2-d7,sp@
#endif
        moveq   IMM (NEGATE),d5
        movel   a6@(8),d0       | get number to negate in d0-d1
        movel   a6@(12),d1      |
        bchg    IMM (31),d0     | negate
        movel   d0,d2           | make a positive copy (for the tests)
        bclr    IMM (31),d2     |
        movel   d2,d4           | check for zero
        orl     d1,d4           |
        beq     2f              | if zero (either sign) return +zero
        cmpl    IMM (0x7ff00000),d2 | compare to +INFINITY
        blt     1f              | if finite, return
        bhi     Ld$inop         | if larger (fraction not zero) is NaN
        tstl    d1              | if d2 == 0x7ff00000 check d1
        bne     Ld$inop         |
        movel   d0,d7           | else get sign and return INFINITY
        andl    IMM (0x80000000),d7
        bra     Ld$infty                
1:      PICLEA  SYM (_fpCCR),a0
        movew   IMM (0),a0@
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6
        rts
2:      bclr    IMM (31),d0
        bra     1b

|=============================================================================
|                              __cmpdf2
|=============================================================================

GREATER =  1
LESS    = -1
EQUAL   =  0

| int __cmpdf2_internal(double, double, int);
SYM (__cmpdf2_internal):
#ifndef __mcoldfire__
        link    a6,IMM (0)
        moveml  d2-d7,sp@-      | save registers
#else
        link    a6,IMM (-24)
        moveml  d2-d7,sp@
#endif
        moveq   IMM (COMPARE),d5
        movel   a6@(8),d0       | get first operand
        movel   a6@(12),d1      |
        movel   a6@(16),d2      | get second operand
        movel   a6@(20),d3      |
| First check if a and/or b are (+/-) zero and in that case clear
| the sign bit.
        movel   d0,d6           | copy signs into d6 (a) and d7(b)
        bclr    IMM (31),d0     | and clear signs in d0 and d2
        movel   d2,d7           |
        bclr    IMM (31),d2     |
        cmpl    IMM (0x7ff00000),d0 | check for a == NaN
        bhi     Lcmpd$inop              | if d0 > 0x7ff00000, a is NaN
        beq     Lcmpdf$a$nf     | if equal can be INFINITY, so check d1
        movel   d0,d4           | copy into d4 to test for zero
        orl     d1,d4           |
        beq     Lcmpdf$a$0      |
Lcmpdf$0:
        cmpl    IMM (0x7ff00000),d2 | check for b == NaN
        bhi     Lcmpd$inop              | if d2 > 0x7ff00000, b is NaN
        beq     Lcmpdf$b$nf     | if equal can be INFINITY, so check d3
        movel   d2,d4           |
        orl     d3,d4           |
        beq     Lcmpdf$b$0      |
Lcmpdf$1:
| Check the signs
        eorl    d6,d7
        bpl     1f
| If the signs are not equal check if a >= 0
        tstl    d6
        bpl     Lcmpdf$a$gt$b   | if (a >= 0 && b < 0) => a > b
        bmi     Lcmpdf$b$gt$a   | if (a < 0 && b >= 0) => a < b
1:
| If the signs are equal check for < 0
        tstl    d6
        bpl     1f
| If both are negative exchange them
#ifndef __mcoldfire__
        exg     d0,d2
        exg     d1,d3
#else
        movel   d0,d7
        movel   d2,d0
        movel   d7,d2
        movel   d1,d7
        movel   d3,d1
        movel   d7,d3
#endif
1:
| Now that they are positive we just compare them as longs (does this also
| work for denormalized numbers?).
        cmpl    d0,d2
        bhi     Lcmpdf$b$gt$a   | |b| > |a|
        bne     Lcmpdf$a$gt$b   | |b| < |a|
| If we got here d0 == d2, so we compare d1 and d3.
        cmpl    d1,d3
        bhi     Lcmpdf$b$gt$a   | |b| > |a|
        bne     Lcmpdf$a$gt$b   | |b| < |a|
| If we got here a == b.
        movel   IMM (EQUAL),d0
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7      | put back the registers
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6
        rts
Lcmpdf$a$gt$b:
        movel   IMM (GREATER),d0
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7      | put back the registers
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6
        rts
Lcmpdf$b$gt$a:
        movel   IMM (LESS),d0
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7      | put back the registers
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6
        rts

Lcmpdf$a$0:     
        bclr    IMM (31),d6
        bra     Lcmpdf$0
Lcmpdf$b$0:
        bclr    IMM (31),d7
        bra     Lcmpdf$1

Lcmpdf$a$nf:
        tstl    d1
        bne     Ld$inop
        bra     Lcmpdf$0

Lcmpdf$b$nf:
        tstl    d3
        bne     Ld$inop
        bra     Lcmpdf$1

Lcmpd$inop:
        movl    a6@(24),d0
        moveq   IMM (INEXACT_RESULT+INVALID_OPERATION),d7
        moveq   IMM (DOUBLE_FLOAT),d6
        PICJUMP $_exception_handler

| int __cmpdf2(double, double);
        FUNC(__cmpdf2)
SYM (__cmpdf2):
        link    a6,IMM (0)
        pea     1
        movl    a6@(20),sp@-
        movl    a6@(16),sp@-
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpdf2_internal)
        unlk    a6
        rts

|=============================================================================
|                           rounding routines
|=============================================================================

| The rounding routines expect the number to be normalized in registers
| d0-d1-d2-d3, with the exponent in register d4. They assume that the 
| exponent is larger or equal to 1. They return a properly normalized number
| if possible, and a denormalized number otherwise. The exponent is returned
| in d4.

Lround$to$nearest:
| We now normalize as suggested by D. Knuth ("Seminumerical Algorithms"):
| Here we assume that the exponent is not too small (this should be checked
| before entering the rounding routine), but the number could be denormalized.

| Check for denormalized numbers:
1:      btst    IMM (DBL_MANT_DIG-32),d0
        bne     2f              | if set the number is normalized
| Normalize shifting left until bit #DBL_MANT_DIG-32 is set or the exponent 
| is one (remember that a denormalized number corresponds to an 
| exponent of -D_BIAS+1).
#ifndef __mcoldfire__
        cmpw    IMM (1),d4      | remember that the exponent is at least one
#else
        cmpl    IMM (1),d4      | remember that the exponent is at least one
#endif
        beq     2f              | an exponent of one means denormalized
        addl    d3,d3           | else shift and adjust the exponent
        addxl   d2,d2           |
        addxl   d1,d1           |
        addxl   d0,d0           |
#ifndef __mcoldfire__
        dbra    d4,1b           |
#else
        subql   IMM (1), d4
        bpl     1b
#endif
2:
| Now round: we do it as follows: after the shifting we can write the
| fraction part as f + delta, where 1 < f < 2^25, and 0 <= delta <= 2.
| If delta < 1, do nothing. If delta > 1, add 1 to f. 
| If delta == 1, we make sure the rounded number will be even (odd?) 
| (after shifting).
        btst    IMM (0),d1      | is delta < 1?
        beq     2f              | if so, do not do anything
        orl     d2,d3           | is delta == 1?
        bne     1f              | if so round to even
        movel   d1,d3           | 
        andl    IMM (2),d3      | bit 1 is the last significant bit
        movel   IMM (0),d2      |
        addl    d3,d1           |
        addxl   d2,d0           |
        bra     2f              | 
1:      movel   IMM (1),d3      | else add 1 
        movel   IMM (0),d2      |
        addl    d3,d1           |
        addxl   d2,d0
| Shift right once (because we used bit #DBL_MANT_DIG-32!).
2:
#ifndef __mcoldfire__
        lsrl    IMM (1),d0
        roxrl   IMM (1),d1              
#else
        lsrl    IMM (1),d1
        btst    IMM (0),d0
        beq     10f
        bset    IMM (31),d1
10:     lsrl    IMM (1),d0
#endif

| Now check again bit #DBL_MANT_DIG-32 (rounding could have produced a
| 'fraction overflow' ...).
        btst    IMM (DBL_MANT_DIG-32),d0        
        beq     1f
#ifndef __mcoldfire__
        lsrl    IMM (1),d0
        roxrl   IMM (1),d1
        addw    IMM (1),d4
#else
        lsrl    IMM (1),d1
        btst    IMM (0),d0
        beq     10f
        bset    IMM (31),d1
10:     lsrl    IMM (1),d0
        addl    IMM (1),d4
#endif
1:
| If bit #DBL_MANT_DIG-32-1 is clear we have a denormalized number, so we 
| have to put the exponent to zero and return a denormalized number.
        btst    IMM (DBL_MANT_DIG-32-1),d0
        beq     1f
        jmp     a0@
1:      movel   IMM (0),d4
        jmp     a0@

Lround$to$zero:
Lround$to$plus:
Lround$to$minus:
        jmp     a0@
#endif /* L_double */

#ifdef  L_float

        .globl  SYM (_fpCCR)
        .globl  $_exception_handler

QUIET_NaN    = 0xffffffff
SIGNL_NaN    = 0x7f800001
INFINITY     = 0x7f800000

F_MAX_EXP      = 0xff
F_BIAS         = 126
FLT_MAX_EXP    = F_MAX_EXP - F_BIAS
FLT_MIN_EXP    = 1 - F_BIAS
FLT_MANT_DIG   = 24

INEXACT_RESULT          = 0x0001
UNDERFLOW               = 0x0002
OVERFLOW                = 0x0004
DIVIDE_BY_ZERO          = 0x0008
INVALID_OPERATION       = 0x0010

SINGLE_FLOAT = 1

NOOP         = 0
ADD          = 1
MULTIPLY     = 2
DIVIDE       = 3
NEGATE       = 4
COMPARE      = 5
EXTENDSFDF   = 6
TRUNCDFSF    = 7

UNKNOWN           = -1
ROUND_TO_NEAREST  = 0 | round result to nearest representable value
ROUND_TO_ZERO     = 1 | round result towards zero
ROUND_TO_PLUS     = 2 | round result towards plus infinity
ROUND_TO_MINUS    = 3 | round result towards minus infinity

| Entry points:

        .globl SYM (__addsf3)
        .globl SYM (__subsf3)
        .globl SYM (__mulsf3)
        .globl SYM (__divsf3)
        .globl SYM (__negsf2)
        .globl SYM (__cmpsf2)
        .globl SYM (__cmpsf2_internal)
        .hidden SYM (__cmpsf2_internal)

| These are common routines to return and signal exceptions.    

        .text
        .even

Lf$den:
| Return and signal a denormalized number
        orl     d7,d0
        moveq   IMM (INEXACT_RESULT+UNDERFLOW),d7
        moveq   IMM (SINGLE_FLOAT),d6
        PICJUMP $_exception_handler

Lf$infty:
Lf$overflow:
| Return a properly signed INFINITY and set the exception flags 
        movel   IMM (INFINITY),d0
        orl     d7,d0
        moveq   IMM (INEXACT_RESULT+OVERFLOW),d7
        moveq   IMM (SINGLE_FLOAT),d6
        PICJUMP $_exception_handler

Lf$underflow:
| Return 0 and set the exception flags 
        moveq   IMM (0),d0
        moveq   IMM (INEXACT_RESULT+UNDERFLOW),d7
        moveq   IMM (SINGLE_FLOAT),d6
        PICJUMP $_exception_handler

Lf$inop:
| Return a quiet NaN and set the exception flags
        movel   IMM (QUIET_NaN),d0
        moveq   IMM (INEXACT_RESULT+INVALID_OPERATION),d7
        moveq   IMM (SINGLE_FLOAT),d6
        PICJUMP $_exception_handler

Lf$div$0:
| Return a properly signed INFINITY and set the exception flags
        movel   IMM (INFINITY),d0
        orl     d7,d0
        moveq   IMM (INEXACT_RESULT+DIVIDE_BY_ZERO),d7
        moveq   IMM (SINGLE_FLOAT),d6
        PICJUMP $_exception_handler

|=============================================================================
|=============================================================================
|                         single precision routines
|=============================================================================
|=============================================================================

| A single precision floating point number (float) has the format:
|
| struct _float {
|  unsigned int sign      : 1;  /* sign bit */ 
|  unsigned int exponent  : 8;  /* exponent, shifted by 126 */
|  unsigned int fraction  : 23; /* fraction */
| } float;
| 
| Thus sizeof(float) = 4 (32 bits). 
|
| All the routines are callable from C programs, and return the result 
| in the single register d0. They also preserve all registers except 
| d0-d1 and a0-a1.

|=============================================================================
|                              __subsf3
|=============================================================================

| float __subsf3(float, float);
        FUNC(__subsf3)
SYM (__subsf3):
        bchg    IMM (31),sp@(8) | change sign of second operand
                                | and fall through
|=============================================================================
|                              __addsf3
|=============================================================================

| float __addsf3(float, float);
        FUNC(__addsf3)
SYM (__addsf3):
#ifndef __mcoldfire__
        link    a6,IMM (0)      | everything will be done in registers
        moveml  d2-d7,sp@-      | save all data registers but d0-d1
#else
        link    a6,IMM (-24)
        moveml  d2-d7,sp@
#endif
        movel   a6@(8),d0       | get first operand
        movel   a6@(12),d1      | get second operand
        movel   d0,a0           | get d0's sign bit '
        addl    d0,d0           | check and clear sign bit of a
        beq     Laddsf$b        | if zero return second operand
        movel   d1,a1           | save b's sign bit '
        addl    d1,d1           | get rid of sign bit
        beq     Laddsf$a        | if zero return first operand

| Get the exponents and check for denormalized and/or infinity.

        movel   IMM (0x00ffffff),d4     | mask to get fraction
        movel   IMM (0x01000000),d5     | mask to put hidden bit back

        movel   d0,d6           | save a to get exponent
        andl    d4,d0           | get fraction in d0
        notl    d4              | make d4 into a mask for the exponent
        andl    d4,d6           | get exponent in d6
        beq     Laddsf$a$den    | branch if a is denormalized
        cmpl    d4,d6           | check for INFINITY or NaN
        beq     Laddsf$nf
        swap    d6              | put exponent into first word
        orl     d5,d0           | and put hidden bit back
Laddsf$1:
| Now we have a's exponent in d6 (second byte) and the mantissa in d0. '
        movel   d1,d7           | get exponent in d7
        andl    d4,d7           | 
        beq     Laddsf$b$den    | branch if b is denormalized
        cmpl    d4,d7           | check for INFINITY or NaN
        beq     Laddsf$nf
        swap    d7              | put exponent into first word
        notl    d4              | make d4 into a mask for the fraction
        andl    d4,d1           | get fraction in d1
        orl     d5,d1           | and put hidden bit back
Laddsf$2:
| Now we have b's exponent in d7 (second byte) and the mantissa in d1. '

| Note that the hidden bit corresponds to bit #FLT_MANT_DIG-1, and we 
| shifted right once, so bit #FLT_MANT_DIG is set (so we have one extra
| bit).

        movel   d1,d2           | move b to d2, since we want to use
                                | two registers to do the sum
        movel   IMM (0),d1      | and clear the new ones
        movel   d1,d3           |

| Here we shift the numbers in registers d0 and d1 so the exponents are the
| same, and put the largest exponent in d6. Note that we are using two
| registers for each number (see the discussion by D. Knuth in "Seminumerical 
| Algorithms").
#ifndef __mcoldfire__
        cmpw    d6,d7           | compare exponents
#else
        cmpl    d6,d7           | compare exponents
#endif
        beq     Laddsf$3        | if equal don't shift '
        bhi     5f              | branch if second exponent largest
1:
        subl    d6,d7           | keep the largest exponent
        negl    d7
#ifndef __mcoldfire__
        lsrw    IMM (8),d7      | put difference in lower byte
#else
        lsrl    IMM (8),d7      | put difference in lower byte
#endif
| if difference is too large we don't shift (actually, we can just exit) '
#ifndef __mcoldfire__
        cmpw    IMM (FLT_MANT_DIG+2),d7         
#else
        cmpl    IMM (FLT_MANT_DIG+2),d7         
#endif
        bge     Laddsf$b$small
#ifndef __mcoldfire__
        cmpw    IMM (16),d7     | if difference >= 16 swap
#else
        cmpl    IMM (16),d7     | if difference >= 16 swap
#endif
        bge     4f
2:
#ifndef __mcoldfire__
        subw    IMM (1),d7
#else
        subql   IMM (1), d7
#endif
3:
#ifndef __mcoldfire__
        lsrl    IMM (1),d2      | shift right second operand
        roxrl   IMM (1),d3
        dbra    d7,3b
#else
        lsrl    IMM (1),d3
        btst    IMM (0),d2
        beq     10f
        bset    IMM (31),d3
10:     lsrl    IMM (1),d2
        subql   IMM (1), d7
        bpl     3b
#endif
        bra     Laddsf$3
4:
        movew   d2,d3
        swap    d3
        movew   d3,d2
        swap    d2
#ifndef __mcoldfire__
        subw    IMM (16),d7
#else
        subl    IMM (16),d7
#endif
        bne     2b              | if still more bits, go back to normal case
        bra     Laddsf$3
5:
#ifndef __mcoldfire__
        exg     d6,d7           | exchange the exponents
#else
        eorl    d6,d7
        eorl    d7,d6
        eorl    d6,d7
#endif
        subl    d6,d7           | keep the largest exponent
        negl    d7              |
#ifndef __mcoldfire__
        lsrw    IMM (8),d7      | put difference in lower byte
#else
        lsrl    IMM (8),d7      | put difference in lower byte
#endif
| if difference is too large we don't shift (and exit!) '
#ifndef __mcoldfire__
        cmpw    IMM (FLT_MANT_DIG+2),d7         
#else
        cmpl    IMM (FLT_MANT_DIG+2),d7         
#endif
        bge     Laddsf$a$small
#ifndef __mcoldfire__
        cmpw    IMM (16),d7     | if difference >= 16 swap
#else
        cmpl    IMM (16),d7     | if difference >= 16 swap
#endif
        bge     8f
6:
#ifndef __mcoldfire__
        subw    IMM (1),d7
#else
        subl    IMM (1),d7
#endif
7:
#ifndef __mcoldfire__
        lsrl    IMM (1),d0      | shift right first operand
        roxrl   IMM (1),d1
        dbra    d7,7b
#else
        lsrl    IMM (1),d1
        btst    IMM (0),d0
        beq     10f
        bset    IMM (31),d1
10:     lsrl    IMM (1),d0
        subql   IMM (1),d7
        bpl     7b
#endif
        bra     Laddsf$3
8:
        movew   d0,d1
        swap    d1
        movew   d1,d0
        swap    d0
#ifndef __mcoldfire__
        subw    IMM (16),d7
#else
        subl    IMM (16),d7
#endif
        bne     6b              | if still more bits, go back to normal case
                                | otherwise we fall through

| Now we have a in d0-d1, b in d2-d3, and the largest exponent in d6 (the
| signs are stored in a0 and a1).

Laddsf$3:
| Here we have to decide whether to add or subtract the numbers
#ifndef __mcoldfire__
        exg     d6,a0           | get signs back
        exg     d7,a1           | and save the exponents
#else
        movel   d6,d4
        movel   a0,d6
        movel   d4,a0
        movel   d7,d4
        movel   a1,d7
        movel   d4,a1
#endif
        eorl    d6,d7           | combine sign bits
        bmi     Lsubsf$0        | if negative a and b have opposite 
                                | sign so we actually subtract the
                                | numbers

| Here we have both positive or both negative
#ifndef __mcoldfire__
        exg     d6,a0           | now we have the exponent in d6
#else
        movel   d6,d4
        movel   a0,d6
        movel   d4,a0
#endif
        movel   a0,d7           | and sign in d7
        andl    IMM (0x80000000),d7
| Here we do the addition.
        addl    d3,d1
        addxl   d2,d0
| Note: now we have d2, d3, d4 and d5 to play with! 

| Put the exponent, in the first byte, in d2, to use the "standard" rounding
| routines:
        movel   d6,d2
#ifndef __mcoldfire__
        lsrw    IMM (8),d2
#else
        lsrl    IMM (8),d2
#endif

| Before rounding normalize so bit #FLT_MANT_DIG is set (we will consider
| the case of denormalized numbers in the rounding routine itself).
| As in the addition (not in the subtraction!) we could have set 
| one more bit we check this:
        btst    IMM (FLT_MANT_DIG+1),d0 
        beq     1f
#ifndef __mcoldfire__
        lsrl    IMM (1),d0
        roxrl   IMM (1),d1
#else
        lsrl    IMM (1),d1
        btst    IMM (0),d0
        beq     10f
        bset    IMM (31),d1
10:     lsrl    IMM (1),d0
#endif
        addl    IMM (1),d2
1:
        lea     pc@(Laddsf$4),a0 | to return from rounding routine
        PICLEA  SYM (_fpCCR),a1 | check the rounding mode
#ifdef __mcoldfire__
        clrl    d6
#endif
        movew   a1@(6),d6       | rounding mode in d6
        beq     Lround$to$nearest
#ifndef __mcoldfire__
        cmpw    IMM (ROUND_TO_PLUS),d6
#else
        cmpl    IMM (ROUND_TO_PLUS),d6
#endif
        bhi     Lround$to$minus
        blt     Lround$to$zero
        bra     Lround$to$plus
Laddsf$4:
| Put back the exponent, but check for overflow.
#ifndef __mcoldfire__
        cmpw    IMM (0xff),d2
#else
        cmpl    IMM (0xff),d2
#endif
        bhi     1f
        bclr    IMM (FLT_MANT_DIG-1),d0
#ifndef __mcoldfire__
        lslw    IMM (7),d2
#else
        lsll    IMM (7),d2
#endif
        swap    d2
        orl     d2,d0
        bra     Laddsf$ret
1:
        moveq   IMM (ADD),d5
        bra     Lf$overflow

Lsubsf$0:
| We are here if a > 0 and b < 0 (sign bits cleared).
| Here we do the subtraction.
        movel   d6,d7           | put sign in d7
        andl    IMM (0x80000000),d7

        subl    d3,d1           | result in d0-d1
        subxl   d2,d0           |
        beq     Laddsf$ret      | if zero just exit
        bpl     1f              | if positive skip the following
        bchg    IMM (31),d7     | change sign bit in d7
        negl    d1
        negxl   d0
1:
#ifndef __mcoldfire__
        exg     d2,a0           | now we have the exponent in d2
        lsrw    IMM (8),d2      | put it in the first byte
#else
        movel   d2,d4
        movel   a0,d2
        movel   d4,a0
        lsrl    IMM (8),d2      | put it in the first byte
#endif

| Now d0-d1 is positive and the sign bit is in d7.

| Note that we do not have to normalize, since in the subtraction bit
| #FLT_MANT_DIG+1 is never set, and denormalized numbers are handled by
| the rounding routines themselves.
        lea     pc@(Lsubsf$1),a0 | to return from rounding routine
        PICLEA  SYM (_fpCCR),a1 | check the rounding mode
#ifdef __mcoldfire__
        clrl    d6
#endif
        movew   a1@(6),d6       | rounding mode in d6
        beq     Lround$to$nearest
#ifndef __mcoldfire__
        cmpw    IMM (ROUND_TO_PLUS),d6
#else
        cmpl    IMM (ROUND_TO_PLUS),d6
#endif
        bhi     Lround$to$minus
        blt     Lround$to$zero
        bra     Lround$to$plus
Lsubsf$1:
| Put back the exponent (we can't have overflow!). '
        bclr    IMM (FLT_MANT_DIG-1),d0
#ifndef __mcoldfire__
        lslw    IMM (7),d2
#else
        lsll    IMM (7),d2
#endif
        swap    d2
        orl     d2,d0
        bra     Laddsf$ret

| If one of the numbers was too small (difference of exponents >= 
| FLT_MANT_DIG+2) we return the other (and now we don't have to '
| check for finiteness or zero).
Laddsf$a$small:
        movel   a6@(12),d0
        PICLEA  SYM (_fpCCR),a0
        movew   IMM (0),a0@
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7      | restore data registers
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6              | and return
        rts

Laddsf$b$small:
        movel   a6@(8),d0
        PICLEA  SYM (_fpCCR),a0
        movew   IMM (0),a0@
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7      | restore data registers
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6              | and return
        rts

| If the numbers are denormalized remember to put exponent equal to 1.

Laddsf$a$den:
        movel   d5,d6           | d5 contains 0x01000000
        swap    d6
        bra     Laddsf$1

Laddsf$b$den:
        movel   d5,d7
        swap    d7
        notl    d4              | make d4 into a mask for the fraction
                                | (this was not executed after the jump)
        bra     Laddsf$2

| The rest is mainly code for the different results which can be 
| returned (checking always for +/-INFINITY and NaN).

Laddsf$b:
| Return b (if a is zero).
        movel   a6@(12),d0
        cmpl    IMM (0x80000000),d0     | Check if b is -0
        bne     1f
        movel   a0,d7
        andl    IMM (0x80000000),d7     | Use the sign of a
        clrl    d0
        bra     Laddsf$ret
Laddsf$a:
| Return a (if b is zero).
        movel   a6@(8),d0
1:
        moveq   IMM (ADD),d5
| We have to check for NaN and +/-infty.
        movel   d0,d7
        andl    IMM (0x80000000),d7     | put sign in d7
        bclr    IMM (31),d0             | clear sign
        cmpl    IMM (INFINITY),d0       | check for infty or NaN
        bge     2f
        movel   d0,d0           | check for zero (we do this because we don't '
        bne     Laddsf$ret      | want to return -0 by mistake
        bclr    IMM (31),d7     | if zero be sure to clear sign
        bra     Laddsf$ret      | if everything OK just return
2:
| The value to be returned is either +/-infty or NaN
        andl    IMM (0x007fffff),d0     | check for NaN
        bne     Lf$inop                 | if mantissa not zero is NaN
        bra     Lf$infty

Laddsf$ret:
| Normal exit (a and b nonzero, result is not NaN nor +/-infty).
| We have to clear the exception flags (just the exception type).
        PICLEA  SYM (_fpCCR),a0
        movew   IMM (0),a0@
        orl     d7,d0           | put sign bit
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7      | restore data registers
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6              | and return
        rts

Laddsf$ret$den:
| Return a denormalized number (for addition we don't signal underflow) '
        lsrl    IMM (1),d0      | remember to shift right back once
        bra     Laddsf$ret      | and return

| Note: when adding two floats of the same sign if either one is 
| NaN we return NaN without regard to whether the other is finite or 
| not. When subtracting them (i.e., when adding two numbers of 
| opposite signs) things are more complicated: if both are INFINITY 
| we return NaN, if only one is INFINITY and the other is NaN we return
| NaN, but if it is finite we return INFINITY with the corresponding sign.

Laddsf$nf:
        moveq   IMM (ADD),d5
| This could be faster but it is not worth the effort, since it is not
| executed very often. We sacrifice speed for clarity here.
        movel   a6@(8),d0       | get the numbers back (remember that we
        movel   a6@(12),d1      | did some processing already)
        movel   IMM (INFINITY),d4 | useful constant (INFINITY)
        movel   d0,d2           | save sign bits
        movel   d1,d3
        bclr    IMM (31),d0     | clear sign bits
        bclr    IMM (31),d1
| We know that one of them is either NaN of +/-INFINITY
| Check for NaN (if either one is NaN return NaN)
        cmpl    d4,d0           | check first a (d0)
        bhi     Lf$inop         
        cmpl    d4,d1           | check now b (d1)
        bhi     Lf$inop         
| Now comes the check for +/-INFINITY. We know that both are (maybe not
| finite) numbers, but we have to check if both are infinite whether we
| are adding or subtracting them.
        eorl    d3,d2           | to check sign bits
        bmi     1f
        movel   d0,d7
        andl    IMM (0x80000000),d7     | get (common) sign bit
        bra     Lf$infty
1:
| We know one (or both) are infinite, so we test for equality between the
| two numbers (if they are equal they have to be infinite both, so we
| return NaN).
        cmpl    d1,d0           | are both infinite?
        beq     Lf$inop         | if so return NaN

        movel   d0,d7
        andl    IMM (0x80000000),d7 | get a's sign bit '
        cmpl    d4,d0           | test now for infinity
        beq     Lf$infty        | if a is INFINITY return with this sign
        bchg    IMM (31),d7     | else we know b is INFINITY and has
        bra     Lf$infty        | the opposite sign

|=============================================================================
|                             __mulsf3
|=============================================================================

| float __mulsf3(float, float);
        FUNC(__mulsf3)
SYM (__mulsf3):
#ifndef __mcoldfire__
        link    a6,IMM (0)
        moveml  d2-d7,sp@-
#else
        link    a6,IMM (-24)
        moveml  d2-d7,sp@
#endif
        movel   a6@(8),d0       | get a into d0
        movel   a6@(12),d1      | and b into d1
        movel   d0,d7           | d7 will hold the sign of the product
        eorl    d1,d7           |
        andl    IMM (0x80000000),d7
        movel   IMM (INFINITY),d6       | useful constant (+INFINITY)
        movel   d6,d5                   | another (mask for fraction)
        notl    d5                      |
        movel   IMM (0x00800000),d4     | this is to put hidden bit back
        bclr    IMM (31),d0             | get rid of a's sign bit '
        movel   d0,d2                   |
        beq     Lmulsf$a$0              | branch if a is zero
        bclr    IMM (31),d1             | get rid of b's sign bit '
        movel   d1,d3           |
        beq     Lmulsf$b$0      | branch if b is zero
        cmpl    d6,d0           | is a big?
        bhi     Lmulsf$inop     | if a is NaN return NaN
        beq     Lmulsf$inf      | if a is INFINITY we have to check b
        cmpl    d6,d1           | now compare b with INFINITY
        bhi     Lmulsf$inop     | is b NaN?
        beq     Lmulsf$overflow | is b INFINITY?
| Here we have both numbers finite and nonzero (and with no sign bit).
| Now we get the exponents into d2 and d3.
        andl    d6,d2           | and isolate exponent in d2
        beq     Lmulsf$a$den    | if exponent is zero we have a denormalized
        andl    d5,d0           | and isolate fraction
        orl     d4,d0           | and put hidden bit back
        swap    d2              | I like exponents in the first byte
#ifndef __mcoldfire__
        lsrw    IMM (7),d2      | 
#else
        lsrl    IMM (7),d2      | 
#endif
Lmulsf$1:                       | number
        andl    d6,d3           |
        beq     Lmulsf$b$den    |
        andl    d5,d1           |
        orl     d4,d1           |
        swap    d3              |
#ifndef __mcoldfire__
        lsrw    IMM (7),d3      |
#else
        lsrl    IMM (7),d3      |
#endif
Lmulsf$2:                       |
#ifndef __mcoldfire__
        addw    d3,d2           | add exponents
        subw    IMM (F_BIAS+1),d2 | and subtract bias (plus one)
#else
        addl    d3,d2           | add exponents
        subl    IMM (F_BIAS+1),d2 | and subtract bias (plus one)
#endif

| We are now ready to do the multiplication. The situation is as follows:
| both a and b have bit FLT_MANT_DIG-1 set (even if they were 
| denormalized to start with!), which means that in the product 
| bit 2*(FLT_MANT_DIG-1) (that is, bit 2*FLT_MANT_DIG-2-32 of the 
| high long) is set. 

| To do the multiplication let us move the number a little bit around ...
        movel   d1,d6           | second operand in d6
        movel   d0,d5           | first operand in d4-d5
        movel   IMM (0),d4
        movel   d4,d1           | the sums will go in d0-d1
        movel   d4,d0

| now bit FLT_MANT_DIG-1 becomes bit 31:
        lsll    IMM (31-FLT_MANT_DIG+1),d6              

| Start the loop (we loop #FLT_MANT_DIG times):
        moveq   IMM (FLT_MANT_DIG-1),d3 
1:      addl    d1,d1           | shift sum 
        addxl   d0,d0
        lsll    IMM (1),d6      | get bit bn
        bcc     2f              | if not set skip sum
        addl    d5,d1           | add a
        addxl   d4,d0
2:
#ifndef __mcoldfire__
        dbf     d3,1b           | loop back
#else
        subql   IMM (1),d3
        bpl     1b
#endif

| Now we have the product in d0-d1, with bit (FLT_MANT_DIG - 1) + FLT_MANT_DIG
| (mod 32) of d0 set. The first thing to do now is to normalize it so bit 
| FLT_MANT_DIG is set (to do the rounding).
#ifndef __mcoldfire__
        rorl    IMM (6),d1
        swap    d1
        movew   d1,d3
        andw    IMM (0x03ff),d3
        andw    IMM (0xfd00),d1
#else
        movel   d1,d3
        lsll    IMM (8),d1
        addl    d1,d1
        addl    d1,d1
        moveq   IMM (22),d5
        lsrl    d5,d3
        orl     d3,d1
        andl    IMM (0xfffffd00),d1
#endif
        lsll    IMM (8),d0
        addl    d0,d0
        addl    d0,d0
#ifndef __mcoldfire__
        orw     d3,d0
#else
        orl     d3,d0
#endif

        moveq   IMM (MULTIPLY),d5
        
        btst    IMM (FLT_MANT_DIG+1),d0
        beq     Lround$exit
#ifndef __mcoldfire__
        lsrl    IMM (1),d0
        roxrl   IMM (1),d1
        addw    IMM (1),d2
#else
        lsrl    IMM (1),d1
        btst    IMM (0),d0
        beq     10f
        bset    IMM (31),d1
10:     lsrl    IMM (1),d0
        addql   IMM (1),d2
#endif
        bra     Lround$exit

Lmulsf$inop:
        moveq   IMM (MULTIPLY),d5
        bra     Lf$inop

Lmulsf$overflow:
        moveq   IMM (MULTIPLY),d5
        bra     Lf$overflow

Lmulsf$inf:
        moveq   IMM (MULTIPLY),d5
| If either is NaN return NaN; else both are (maybe infinite) numbers, so
| return INFINITY with the correct sign (which is in d7).
        cmpl    d6,d1           | is b NaN?
        bhi     Lf$inop         | if so return NaN
        bra     Lf$overflow     | else return +/-INFINITY

| If either number is zero return zero, unless the other is +/-INFINITY, 
| or NaN, in which case we return NaN.
Lmulsf$b$0:
| Here d1 (==b) is zero.
        movel   a6@(8),d1       | get a again to check for non-finiteness
        bra     1f
Lmulsf$a$0:
        movel   a6@(12),d1      | get b again to check for non-finiteness
1:      bclr    IMM (31),d1     | clear sign bit 
        cmpl    IMM (INFINITY),d1 | and check for a large exponent
        bge     Lf$inop         | if b is +/-INFINITY or NaN return NaN
        movel   d7,d0           | else return signed zero
        PICLEA  SYM (_fpCCR),a0 |
        movew   IMM (0),a0@     | 
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7      | 
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6              | 
        rts                     | 

| If a number is denormalized we put an exponent of 1 but do not put the 
| hidden bit back into the fraction; instead we shift left until bit 23
| (the hidden bit) is set, adjusting the exponent accordingly. We do this
| to ensure that the product of the fractions is close to 1.
Lmulsf$a$den:
        movel   IMM (1),d2
        andl    d5,d0
1:      addl    d0,d0           | shift a left (until bit 23 is set)
#ifndef __mcoldfire__
        subw    IMM (1),d2      | and adjust exponent
#else
        subql   IMM (1),d2      | and adjust exponent
#endif
        btst    IMM (FLT_MANT_DIG-1),d0
        bne     Lmulsf$1        |
        bra     1b              | else loop back

Lmulsf$b$den:
        movel   IMM (1),d3
        andl    d5,d1
1:      addl    d1,d1           | shift b left until bit 23 is set
#ifndef __mcoldfire__
        subw    IMM (1),d3      | and adjust exponent
#else
        subql   IMM (1),d3      | and adjust exponent
#endif
        btst    IMM (FLT_MANT_DIG-1),d1
        bne     Lmulsf$2        |
        bra     1b              | else loop back

|=============================================================================
|                             __divsf3
|=============================================================================

| float __divsf3(float, float);
        FUNC(__divsf3)
SYM (__divsf3):
#ifndef __mcoldfire__
        link    a6,IMM (0)
        moveml  d2-d7,sp@-
#else
        link    a6,IMM (-24)
        moveml  d2-d7,sp@
#endif
        movel   a6@(8),d0               | get a into d0
        movel   a6@(12),d1              | and b into d1
        movel   d0,d7                   | d7 will hold the sign of the result
        eorl    d1,d7                   |
        andl    IMM (0x80000000),d7     | 
        movel   IMM (INFINITY),d6       | useful constant (+INFINITY)
        movel   d6,d5                   | another (mask for fraction)
        notl    d5                      |
        movel   IMM (0x00800000),d4     | this is to put hidden bit back
        bclr    IMM (31),d0             | get rid of a's sign bit '
        movel   d0,d2                   |
        beq     Ldivsf$a$0              | branch if a is zero
        bclr    IMM (31),d1             | get rid of b's sign bit '
        movel   d1,d3                   |
        beq     Ldivsf$b$0              | branch if b is zero
        cmpl    d6,d0                   | is a big?
        bhi     Ldivsf$inop             | if a is NaN return NaN
        beq     Ldivsf$inf              | if a is INFINITY we have to check b
        cmpl    d6,d1                   | now compare b with INFINITY 
        bhi     Ldivsf$inop             | if b is NaN return NaN
        beq     Ldivsf$underflow
| Here we have both numbers finite and nonzero (and with no sign bit).
| Now we get the exponents into d2 and d3 and normalize the numbers to
| ensure that the ratio of the fractions is close to 1. We do this by
| making sure that bit #FLT_MANT_DIG-1 (hidden bit) is set.
        andl    d6,d2           | and isolate exponent in d2
        beq     Ldivsf$a$den    | if exponent is zero we have a denormalized
        andl    d5,d0           | and isolate fraction
        orl     d4,d0           | and put hidden bit back
        swap    d2              | I like exponents in the first byte
#ifndef __mcoldfire__
        lsrw    IMM (7),d2      | 
#else
        lsrl    IMM (7),d2      | 
#endif
Ldivsf$1:                       | 
        andl    d6,d3           |
        beq     Ldivsf$b$den    |
        andl    d5,d1           |
        orl     d4,d1           |
        swap    d3              |
#ifndef __mcoldfire__
        lsrw    IMM (7),d3      |
#else
        lsrl    IMM (7),d3      |
#endif
Ldivsf$2:                       |
#ifndef __mcoldfire__
        subw    d3,d2           | subtract exponents
        addw    IMM (F_BIAS),d2 | and add bias
#else
        subl    d3,d2           | subtract exponents
        addl    IMM (F_BIAS),d2 | and add bias
#endif
 
| We are now ready to do the division. We have prepared things in such a way
| that the ratio of the fractions will be less than 2 but greater than 1/2.
| At this point the registers in use are:
| d0    holds a (first operand, bit FLT_MANT_DIG=0, bit FLT_MANT_DIG-1=1)
| d1    holds b (second operand, bit FLT_MANT_DIG=1)
| d2    holds the difference of the exponents, corrected by the bias
| d7    holds the sign of the ratio
| d4, d5, d6 hold some constants
        movel   d7,a0           | d6-d7 will hold the ratio of the fractions
        movel   IMM (0),d6      | 
        movel   d6,d7

        moveq   IMM (FLT_MANT_DIG+1),d3
1:      cmpl    d0,d1           | is a < b?
        bhi     2f              |
        bset    d3,d6           | set a bit in d6
        subl    d1,d0           | if a >= b  a <-- a-b
        beq     3f              | if a is zero, exit
2:      addl    d0,d0           | multiply a by 2
#ifndef __mcoldfire__
        dbra    d3,1b
#else
        subql   IMM (1),d3
        bpl     1b
#endif

| Now we keep going to set the sticky bit ...
        moveq   IMM (FLT_MANT_DIG),d3
1:      cmpl    d0,d1
        ble     2f
        addl    d0,d0
#ifndef __mcoldfire__
        dbra    d3,1b
#else
        subql   IMM(1),d3
        bpl     1b
#endif
        movel   IMM (0),d1
        bra     3f
2:      movel   IMM (0),d1
#ifndef __mcoldfire__
        subw    IMM (FLT_MANT_DIG),d3
        addw    IMM (31),d3
#else
        subl    IMM (FLT_MANT_DIG),d3
        addl    IMM (31),d3
#endif
        bset    d3,d1
3:
        movel   d6,d0           | put the ratio in d0-d1
        movel   a0,d7           | get sign back

| Because of the normalization we did before we are guaranteed that 
| d0 is smaller than 2^26 but larger than 2^24. Thus bit 26 is not set,
| bit 25 could be set, and if it is not set then bit 24 is necessarily set.
        btst    IMM (FLT_MANT_DIG+1),d0         
        beq     1f              | if it is not set, then bit 24 is set
        lsrl    IMM (1),d0      |
#ifndef __mcoldfire__
        addw    IMM (1),d2      |
#else
        addl    IMM (1),d2      |
#endif
1:
| Now round, check for over- and underflow, and exit.
        moveq   IMM (DIVIDE),d5
        bra     Lround$exit

Ldivsf$inop:
        moveq   IMM (DIVIDE),d5
        bra     Lf$inop

Ldivsf$overflow:
        moveq   IMM (DIVIDE),d5
        bra     Lf$overflow

Ldivsf$underflow:
        moveq   IMM (DIVIDE),d5
        bra     Lf$underflow

Ldivsf$a$0:
        moveq   IMM (DIVIDE),d5
| If a is zero check to see whether b is zero also. In that case return
| NaN; then check if b is NaN, and return NaN also in that case. Else
| return a properly signed zero.
        andl    IMM (0x7fffffff),d1     | clear sign bit and test b
        beq     Lf$inop                 | if b is also zero return NaN
        cmpl    IMM (INFINITY),d1       | check for NaN
        bhi     Lf$inop                 | 
        movel   d7,d0                   | else return signed zero
        PICLEA  SYM (_fpCCR),a0         |
        movew   IMM (0),a0@             |
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7              | 
#else
        moveml  sp@,d2-d7               | 
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6                      | 
        rts                             | 
        
Ldivsf$b$0:
        moveq   IMM (DIVIDE),d5
| If we got here a is not zero. Check if a is NaN; in that case return NaN,
| else return +/-INFINITY. Remember that a is in d0 with the sign bit 
| cleared already.
        cmpl    IMM (INFINITY),d0       | compare d0 with INFINITY
        bhi     Lf$inop                 | if larger it is NaN
        bra     Lf$div$0                | else signal DIVIDE_BY_ZERO

Ldivsf$inf:
        moveq   IMM (DIVIDE),d5
| If a is INFINITY we have to check b
        cmpl    IMM (INFINITY),d1       | compare b with INFINITY 
        bge     Lf$inop                 | if b is NaN or INFINITY return NaN
        bra     Lf$overflow             | else return overflow

| If a number is denormalized we put an exponent of 1 but do not put the 
| bit back into the fraction.
Ldivsf$a$den:
        movel   IMM (1),d2
        andl    d5,d0
1:      addl    d0,d0           | shift a left until bit FLT_MANT_DIG-1 is set
#ifndef __mcoldfire__
        subw    IMM (1),d2      | and adjust exponent
#else
        subl    IMM (1),d2      | and adjust exponent
#endif
        btst    IMM (FLT_MANT_DIG-1),d0
        bne     Ldivsf$1
        bra     1b

Ldivsf$b$den:
        movel   IMM (1),d3
        andl    d5,d1
1:      addl    d1,d1           | shift b left until bit FLT_MANT_DIG is set
#ifndef __mcoldfire__
        subw    IMM (1),d3      | and adjust exponent
#else
        subl    IMM (1),d3      | and adjust exponent
#endif
        btst    IMM (FLT_MANT_DIG-1),d1
        bne     Ldivsf$2
        bra     1b

Lround$exit:
| This is a common exit point for __mulsf3 and __divsf3. 

| First check for underlow in the exponent:
#ifndef __mcoldfire__
        cmpw    IMM (-FLT_MANT_DIG-1),d2                
#else
        cmpl    IMM (-FLT_MANT_DIG-1),d2                
#endif
        blt     Lf$underflow    
| It could happen that the exponent is less than 1, in which case the 
| number is denormalized. In this case we shift right and adjust the 
| exponent until it becomes 1 or the fraction is zero (in the latter case 
| we signal underflow and return zero).
        movel   IMM (0),d6      | d6 is used temporarily
#ifndef __mcoldfire__
        cmpw    IMM (1),d2      | if the exponent is less than 1 we 
#else
        cmpl    IMM (1),d2      | if the exponent is less than 1 we 
#endif
        bge     2f              | have to shift right (denormalize)
1:
#ifndef __mcoldfire__
        addw    IMM (1),d2      | adjust the exponent
        lsrl    IMM (1),d0      | shift right once 
        roxrl   IMM (1),d1      |
        roxrl   IMM (1),d6      | d6 collect bits we would lose otherwise
        cmpw    IMM (1),d2      | is the exponent 1 already?
#else
        addql   IMM (1),d2      | adjust the exponent
        lsrl    IMM (1),d6
        btst    IMM (0),d1
        beq     11f
        bset    IMM (31),d6
11:     lsrl    IMM (1),d1
        btst    IMM (0),d0
        beq     10f
        bset    IMM (31),d1
10:     lsrl    IMM (1),d0
        cmpl    IMM (1),d2      | is the exponent 1 already?
#endif
        beq     2f              | if not loop back
        bra     1b              |
        bra     Lf$underflow    | safety check, shouldn't execute '
2:      orl     d6,d1           | this is a trick so we don't lose  '
                                | the extra bits which were flushed right
| Now call the rounding routine (which takes care of denormalized numbers):
        lea     pc@(Lround$0),a0 | to return from rounding routine
        PICLEA  SYM (_fpCCR),a1 | check the rounding mode
#ifdef __mcoldfire__
        clrl    d6
#endif
        movew   a1@(6),d6       | rounding mode in d6
        beq     Lround$to$nearest
#ifndef __mcoldfire__
        cmpw    IMM (ROUND_TO_PLUS),d6
#else
        cmpl    IMM (ROUND_TO_PLUS),d6
#endif
        bhi     Lround$to$minus
        blt     Lround$to$zero
        bra     Lround$to$plus
Lround$0:
| Here we have a correctly rounded result (either normalized or denormalized).

| Here we should have either a normalized number or a denormalized one, and
| the exponent is necessarily larger or equal to 1 (so we don't have to  '
| check again for underflow!). We have to check for overflow or for a 
| denormalized number (which also signals underflow).
| Check for overflow (i.e., exponent >= 255).
#ifndef __mcoldfire__
        cmpw    IMM (0x00ff),d2
#else
        cmpl    IMM (0x00ff),d2
#endif
        bge     Lf$overflow
| Now check for a denormalized number (exponent==0).
        movew   d2,d2
        beq     Lf$den
1:
| Put back the exponents and sign and return.
#ifndef __mcoldfire__
        lslw    IMM (7),d2      | exponent back to fourth byte
#else
        lsll    IMM (7),d2      | exponent back to fourth byte
#endif
        bclr    IMM (FLT_MANT_DIG-1),d0
        swap    d0              | and put back exponent
#ifndef __mcoldfire__
        orw     d2,d0           | 
#else
        orl     d2,d0
#endif
        swap    d0              |
        orl     d7,d0           | and sign also

        PICLEA  SYM (_fpCCR),a0
        movew   IMM (0),a0@
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6
        rts

|=============================================================================
|                             __negsf2
|=============================================================================

| This is trivial and could be shorter if we didn't bother checking for NaN '
| and +/-INFINITY.

| float __negsf2(float);
        FUNC(__negsf2)
SYM (__negsf2):
#ifndef __mcoldfire__
        link    a6,IMM (0)
        moveml  d2-d7,sp@-
#else
        link    a6,IMM (-24)
        moveml  d2-d7,sp@
#endif
        moveq   IMM (NEGATE),d5
        movel   a6@(8),d0       | get number to negate in d0
        bchg    IMM (31),d0     | negate
        movel   d0,d1           | make a positive copy
        bclr    IMM (31),d1     |
        tstl    d1              | check for zero
        beq     2f              | if zero (either sign) return +zero
        cmpl    IMM (INFINITY),d1 | compare to +INFINITY
        blt     1f              |
        bhi     Lf$inop         | if larger (fraction not zero) is NaN
        movel   d0,d7           | else get sign and return INFINITY
        andl    IMM (0x80000000),d7
        bra     Lf$infty                
1:      PICLEA  SYM (_fpCCR),a0
        movew   IMM (0),a0@
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6
        rts
2:      bclr    IMM (31),d0
        bra     1b

|=============================================================================
|                             __cmpsf2
|=============================================================================

GREATER =  1
LESS    = -1
EQUAL   =  0

| int __cmpsf2_internal(float, float, int);
SYM (__cmpsf2_internal):
#ifndef __mcoldfire__
        link    a6,IMM (0)
        moveml  d2-d7,sp@-      | save registers
#else
        link    a6,IMM (-24)
        moveml  d2-d7,sp@
#endif
        moveq   IMM (COMPARE),d5
        movel   a6@(8),d0       | get first operand
        movel   a6@(12),d1      | get second operand
| Check if either is NaN, and in that case return garbage and signal
| INVALID_OPERATION. Check also if either is zero, and clear the signs
| if necessary.
        movel   d0,d6
        andl    IMM (0x7fffffff),d0
        beq     Lcmpsf$a$0
        cmpl    IMM (0x7f800000),d0
        bhi     Lcmpf$inop
Lcmpsf$1:
        movel   d1,d7
        andl    IMM (0x7fffffff),d1
        beq     Lcmpsf$b$0
        cmpl    IMM (0x7f800000),d1
        bhi     Lcmpf$inop
Lcmpsf$2:
| Check the signs
        eorl    d6,d7
        bpl     1f
| If the signs are not equal check if a >= 0
        tstl    d6
        bpl     Lcmpsf$a$gt$b   | if (a >= 0 && b < 0) => a > b
        bmi     Lcmpsf$b$gt$a   | if (a < 0 && b >= 0) => a < b
1:
| If the signs are equal check for < 0
        tstl    d6
        bpl     1f
| If both are negative exchange them
#ifndef __mcoldfire__
        exg     d0,d1
#else
        movel   d0,d7
        movel   d1,d0
        movel   d7,d1
#endif
1:
| Now that they are positive we just compare them as longs (does this also
| work for denormalized numbers?).
        cmpl    d0,d1
        bhi     Lcmpsf$b$gt$a   | |b| > |a|
        bne     Lcmpsf$a$gt$b   | |b| < |a|
| If we got here a == b.
        movel   IMM (EQUAL),d0
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7      | put back the registers
#else
        moveml  sp@,d2-d7
#endif
        unlk    a6
        rts
Lcmpsf$a$gt$b:
        movel   IMM (GREATER),d0
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7      | put back the registers
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6
        rts
Lcmpsf$b$gt$a:
        movel   IMM (LESS),d0
#ifndef __mcoldfire__
        moveml  sp@+,d2-d7      | put back the registers
#else
        moveml  sp@,d2-d7
        | XXX if frame pointer is ever removed, stack pointer must
        | be adjusted here.
#endif
        unlk    a6
        rts

Lcmpsf$a$0:     
        bclr    IMM (31),d6
        bra     Lcmpsf$1
Lcmpsf$b$0:
        bclr    IMM (31),d7
        bra     Lcmpsf$2

Lcmpf$inop:
        movl    a6@(16),d0
        moveq   IMM (INEXACT_RESULT+INVALID_OPERATION),d7
        moveq   IMM (SINGLE_FLOAT),d6
        PICJUMP $_exception_handler

| int __cmpsf2(float, float);
        FUNC(__cmpsf2)
SYM (__cmpsf2):
        link    a6,IMM (0)
        pea     1
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpsf2_internal)
        unlk    a6
        rts

|=============================================================================
|                           rounding routines
|=============================================================================

| The rounding routines expect the number to be normalized in registers
| d0-d1, with the exponent in register d2. They assume that the 
| exponent is larger or equal to 1. They return a properly normalized number
| if possible, and a denormalized number otherwise. The exponent is returned
| in d2.

Lround$to$nearest:
| We now normalize as suggested by D. Knuth ("Seminumerical Algorithms"):
| Here we assume that the exponent is not too small (this should be checked
| before entering the rounding routine), but the number could be denormalized.

| Check for denormalized numbers:
1:      btst    IMM (FLT_MANT_DIG),d0
        bne     2f              | if set the number is normalized
| Normalize shifting left until bit #FLT_MANT_DIG is set or the exponent 
| is one (remember that a denormalized number corresponds to an 
| exponent of -F_BIAS+1).
#ifndef __mcoldfire__
        cmpw    IMM (1),d2      | remember that the exponent is at least one
#else
        cmpl    IMM (1),d2      | remember that the exponent is at least one
#endif
        beq     2f              | an exponent of one means denormalized
        addl    d1,d1           | else shift and adjust the exponent
        addxl   d0,d0           |
#ifndef __mcoldfire__
        dbra    d2,1b           |
#else
        subql   IMM (1),d2
        bpl     1b
#endif
2:
| Now round: we do it as follows: after the shifting we can write the
| fraction part as f + delta, where 1 < f < 2^25, and 0 <= delta <= 2.
| If delta < 1, do nothing. If delta > 1, add 1 to f. 
| If delta == 1, we make sure the rounded number will be even (odd?) 
| (after shifting).
        btst    IMM (0),d0      | is delta < 1?
        beq     2f              | if so, do not do anything
        tstl    d1              | is delta == 1?
        bne     1f              | if so round to even
        movel   d0,d1           | 
        andl    IMM (2),d1      | bit 1 is the last significant bit
        addl    d1,d0           | 
        bra     2f              | 
1:      movel   IMM (1),d1      | else add 1 
        addl    d1,d0           |
| Shift right once (because we used bit #FLT_MANT_DIG!).
2:      lsrl    IMM (1),d0              
| Now check again bit #FLT_MANT_DIG (rounding could have produced a
| 'fraction overflow' ...).
        btst    IMM (FLT_MANT_DIG),d0   
        beq     1f
        lsrl    IMM (1),d0
#ifndef __mcoldfire__
        addw    IMM (1),d2
#else
        addql   IMM (1),d2
#endif
1:
| If bit #FLT_MANT_DIG-1 is clear we have a denormalized number, so we 
| have to put the exponent to zero and return a denormalized number.
        btst    IMM (FLT_MANT_DIG-1),d0
        beq     1f
        jmp     a0@
1:      movel   IMM (0),d2
        jmp     a0@

Lround$to$zero:
Lround$to$plus:
Lround$to$minus:
        jmp     a0@
#endif /* L_float */

| gcc expects the routines __eqdf2, __nedf2, __gtdf2, __gedf2,
| __ledf2, __ltdf2 to all return the same value as a direct call to
| __cmpdf2 would.  In this implementation, each of these routines
| simply calls __cmpdf2.  It would be more efficient to give the
| __cmpdf2 routine several names, but separating them out will make it
| easier to write efficient versions of these routines someday.
| If the operands recompare unordered unordered __gtdf2 and __gedf2 return -1.
| The other routines return 1.

#ifdef  L_eqdf2
        .text
        FUNC(__eqdf2)
        .globl  SYM (__eqdf2)
SYM (__eqdf2):
        link    a6,IMM (0)
        pea     1
        movl    a6@(20),sp@-
        movl    a6@(16),sp@-
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpdf2_internal)
        unlk    a6
        rts
#endif /* L_eqdf2 */

#ifdef  L_nedf2
        .text
        FUNC(__nedf2)
        .globl  SYM (__nedf2)
SYM (__nedf2):
        link    a6,IMM (0)
        pea     1
        movl    a6@(20),sp@-
        movl    a6@(16),sp@-
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpdf2_internal)
        unlk    a6
        rts
#endif /* L_nedf2 */

#ifdef  L_gtdf2
        .text
        FUNC(__gtdf2)
        .globl  SYM (__gtdf2)
SYM (__gtdf2):
        link    a6,IMM (0)
        pea     -1
        movl    a6@(20),sp@-
        movl    a6@(16),sp@-
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpdf2_internal)
        unlk    a6
        rts
#endif /* L_gtdf2 */

#ifdef  L_gedf2
        .text
        FUNC(__gedf2)
        .globl  SYM (__gedf2)
SYM (__gedf2):
        link    a6,IMM (0)
        pea     -1
        movl    a6@(20),sp@-
        movl    a6@(16),sp@-
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpdf2_internal)
        unlk    a6
        rts
#endif /* L_gedf2 */

#ifdef  L_ltdf2
        .text
        FUNC(__ltdf2)
        .globl  SYM (__ltdf2)
SYM (__ltdf2):
        link    a6,IMM (0)
        pea     1
        movl    a6@(20),sp@-
        movl    a6@(16),sp@-
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpdf2_internal)
        unlk    a6
        rts
#endif /* L_ltdf2 */

#ifdef  L_ledf2
        .text
        FUNC(__ledf2)
        .globl  SYM (__ledf2)
SYM (__ledf2):
        link    a6,IMM (0)
        pea     1
        movl    a6@(20),sp@-
        movl    a6@(16),sp@-
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpdf2_internal)
        unlk    a6
        rts
#endif /* L_ledf2 */

| The comments above about __eqdf2, et. al., also apply to __eqsf2,
| et. al., except that the latter call __cmpsf2 rather than __cmpdf2.

#ifdef  L_eqsf2
        .text
        FUNC(__eqsf2)
        .globl  SYM (__eqsf2)
SYM (__eqsf2):
        link    a6,IMM (0)
        pea     1
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpsf2_internal)
        unlk    a6
        rts
#endif /* L_eqsf2 */

#ifdef  L_nesf2
        .text
        FUNC(__nesf2)
        .globl  SYM (__nesf2)
SYM (__nesf2):
        link    a6,IMM (0)
        pea     1
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpsf2_internal)
        unlk    a6
        rts
#endif /* L_nesf2 */

#ifdef  L_gtsf2
        .text
        FUNC(__gtsf2)
        .globl  SYM (__gtsf2)
SYM (__gtsf2):
        link    a6,IMM (0)
        pea     -1
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpsf2_internal)
        unlk    a6
        rts
#endif /* L_gtsf2 */

#ifdef  L_gesf2
        .text
        FUNC(__gesf2)
        .globl  SYM (__gesf2)
SYM (__gesf2):
        link    a6,IMM (0)
        pea     -1
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpsf2_internal)
        unlk    a6
        rts
#endif /* L_gesf2 */

#ifdef  L_ltsf2
        .text
        FUNC(__ltsf2)
        .globl  SYM (__ltsf2)
SYM (__ltsf2):
        link    a6,IMM (0)
        pea     1
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpsf2_internal)
        unlk    a6
        rts
#endif /* L_ltsf2 */

#ifdef  L_lesf2
        .text
        FUNC(__lesf2)
        .globl  SYM (__lesf2)
SYM (__lesf2):
        link    a6,IMM (0)
        pea     1
        movl    a6@(12),sp@-
        movl    a6@(8),sp@-
        PICCALL SYM (__cmpsf2_internal)
        unlk    a6
        rts
#endif /* L_lesf2 */

#if defined (__ELF__) && defined (__linux__)
        /* Make stack non-executable for ELF linux targets.  */
        .section        .note.GNU-stack,"",@progbits
#endif