uss_fpopns.s

VXWORKS源代码

/* Copyright 1991-1992 Wind River Systems, Inc. */
	.data
	.globl	_copyright_wind_river
	.long	_copyright_wind_river

/*
modification history
--------------------
01g,14mar95,tmk  inverted conditional assembly logic for 68000/10 to allow for
		 CPUs other than 68020.
01f,23aug92,jcf  changed bxxx to jxx.
01e,26may92,rrr  the tree shuffle
01d,30mar92,kdl  added include of "uss_fp.h"; commented-out ".set" directives
		 (SPR #1398).
01c,04oct91,rrr  passed through the ansification filter
		  -changed ASMLANGUAGE to _ASMLANGUAGE
		  -changed copyright notice
01b,29jan91,kdl  added include of vxWorks.h for conditional assembly.
01a,28jan91,kdl  modified original US Software version to use conditional
		 assembly for 68000/10 multiply and divide operations.
*/


/*
DESCRIPTION

|       ttl     FPAC 68K/FPOPNS: IEEE Single Precision Operations
|FPOPNS idnt    1,0             ; IEEE Single Precision Operations
|                               ; FPOPNS.A68
|
| * * * * * * * * * *
|
|       Copyright (c) 1985,1989 by
|       United States Software Corporation
|       14215 N.W. Science Park Drive
|       Portland, Oregon  97229
|
|       This software is furnished under a license and may be used
|       and copied only in accordance with the terms of such license
|       and with the inclusion of the above copyright notice.
|       This software or any other copies thereof may not be provided
|       or otherwise made available to any other person.  No title to
|       and ownership of the software is hereby transferred.
|
|       The information in this software is subject to change without
|       notice and should not be construed as a commitment by United
|       States Software Corporation.
|
|       Released:       12 January 1989         V2.0
|
| * * * * * * * * * *
|

NOMANUAL
*/

#define	_ASMLANGUAGE
#include "vxWorks.h"
#include "uss_fp.h"


|       .set    comp64,0                |the 64 bit multiply/divide flag

|       opt     BRS             ; Default to forward branches SHORT
|
        .globl  FLOAT
        .globl  FIX
        .globl  INT
        .globl  AINT
        .globl  FPADD
        .globl  FPMUL
        .globl  FPDIV
        .globl  FPRDIV
        .globl  FPCMP
|
        .globl  GETFP1,FOPRSL
|
        .globl  FNANRS,FINFRS,FUNFRS,FZERRS
|
|
|       xref    FPERR,NANFLG,INFFLG,UNFFLG
|
|
|       .set    FBIAS,127               | Single precision format exponent bias
|
|
|       .set    CCRC,0x01               | Carry bit in CCR
|       .set    CCRV,0x02               | Overflow bit in CCR
|       .set    CCRZ,0x04               | Zero bit in CCR
|       .set    CCRN,0x08               | Negative bit in CCR
|       .set    CCRX,0x10               | Extend bit in CCR
|
|
|       .set    ERNAN,3
|       .set    EROVF,2
|       .set    ERUNF,1
|
|
        .text           | General code section
/*
|
|       page
|
|  FLOAT
|  =====
|  Float the integer value in D0 into a single precision floating
|  point value on the stack.
|
*/

FLOAT:
        moveal  sp@+,a0 | Return addr into a0
        subal   a2,a2           | Set a2 = 0
        andl    d0,d0
        jne     FLT01           | J/ value <> 0
|
        movel   d0,sp@- | Place 0 value on stack
        jmp     a0@             | Return
|
FLT01:
        jge     FLT02           | J/ value > 0
        subql   #1,a2           | Set a2 = -1
        negl    d0
|
FLT02:
        movel   #FBIAS+15,d2    | Default bias value
        swap    d0
        andw    d0,d0
        jeq     FLT03           | J/ 16 bit shift required
|
        swap    d0              | Undo the shift
        addw    #16,d2          | Reflect the larger number
|
FLT03:
        andl    d0,d0
        jmi     FLT06           | J/ value normalized
|
FLT04:
        subqw   #1,d2           | Dec exponent, shift mantissa
        asll    #1,d0
        jpl     FLT04           | J/ more shifts to do
|
FLT06:
        exg     d0,d2           | Position to standard d0/d2/a2 form
        jra     FOPRSL          | J/ single precision result (w/ round)
/*
|
|       page
|
|  FIX
|  ===
|  Routine to convert the single precision argument on the stack
|  to an integer value (with a dropoff flag).
|
*/

FIX:
        bsr     GETFP1          | Extract/unpack one single prec val
        bsr     FIX00           | Use internal routine
        jmp     a0@             | Return to caller
|
|
FIX00:
        andw    d0,d0
        jne     FIX01           | J/ value <> 0.0
|
        subl    d0,d0           | Return a zero value, no drop off
        rts
|
FIX01:
        cmpiw   #FBIAS,d0
        jcc     FIX02           | J/ abs() >= 1.0  [BCC == BHS]
|
        subl    d0,d0           | Return a zero value
        orib    #CCRC+CCRX,ccr  | Set carry/extend bits
| ###   ORI     #$11,CCR
        rts
|
FIX02:
        subiw   #FBIAS+31,d0
        jcs     FIX03           | J/ abs() < 2^31
|
        moveq   #-1,d0          | Set d0 to the maximum integer value
        lsrl    #1,d0           | d0 = 0x7FFFFFFF
        subl    a2,d0           | Account for the sign of the arg.
        rts
|
FIX03:
        negw    d0              | Positive shift count
        rorl    d0,d2           | Multibit shift
        moveq   #-1,d1          | Mask for bit dropout check
        lsrl    d0,d1
        notl    d1
        andl    d2,d1           | Bit(s) dropped left in d1
        eorl    d1,d2           | Integer value in d2
        movel   a2,d0
        eorl    d2,d0           | Negate as required, move to d0
        subl    a2,d0
        moveq   #-1,d2
        addl    d2,d1           | Set carry/extend if bits lost
        rts
/*
|
|       page
|
|  INT
|  ===
|  Return the largest integer smaller than the argument provided
|
*/

INT:
        bsr     GETFP1
        bsr     FIX00
|
        jcc     INT00           | J/ no bits lost
        cmpaw   #0,a2
        jeq     INT00           | J/ not negative
        subql   #1,d0           | Decrement integer value
INT00:
        jmp     a0@
/*
|
|       page
|
|  AINT
|  ====
|  Floating point corollary to the INT function
|
*/

AINT:
        bsr     GETFP1
        cmpiw   #FBIAS+23,d0    | Check for value too large
        jcc     FOPRSL          | J/ return with same value
|
        movew   d0,d3
        subiw   #FBIAS-1,d3
        jgt     AINT02          | J/ abs() >= 1.0
|
        movew   a2,d2
        jne     AINT01          | J/ 0.0 > value > -1.0
|
        movel   #0,sp@- | Return a zero value
        jmp     a0@
|
AINT01:
        movel   #0xBF800000,sp@-        | Return -1.0
        jmp     a0@
|
AINT02:
        moveq   #-1,d1          | Fill d1 with ones
        lsrl    d3,d1           | Shift mask over
        moveq   #1,d3
        addl    d1,d3           | Create increment bit
        andl    d2,d1           | Extract bits to drop
        jeq     FOPRSL          | J/ no drop off, return as provided
|
        eorl    d1,d2           | Remove bits that must be dropped
        cmpaw   #0,a2
        jeq     FOPRSL          | Bits dropped from a positive number
|
        addl    d3,d2           | Bump the magnitude (negative number)
        jcc     AINT03          | J/ no overflow
|
        roxll   #1,d2
        addqw   #1,d0
|
AINT03:
        jra     FOPRSL          | Return computed value
/*
|
|       page
|
|  FPADD
|  =====
|  Single precision add routine
|
*/

FPADD:
        bsr     GETFP2          | Fetch both operands
        cmpiw   #0xFF,d0
|
        jne     FPA010          | J/ operand not NaN/INF
|
        lsll    #1,d2           | Remove implicit bit
        jne     FNANRS          | J/  ?  + NaN -> NaN
|
        cmpiw   #0xFF,d1
        jne     FINFRS          | J/  0,num + INF -> INF
|
        lsll    #1,d3           | Remove implicit bit
        jne     FNANRS          | J/ INF + NaN -> NaN
|
        cmpal   a2,a3
        jne     FNANRS          | J/ INF - INF -> NaN
        jra     FINFRS          |    INF + INF -> INF
|
|
FPA010:
        cmpiw   #0xFF,d1
        jne     FPA040          | J/ not NaN or INF
|
        lsll    #1,d3           | Remove implicit bit
        jne     FNANRS          | J/ NaN + 0,num -> NaN
|
        moveal  a3,a2           | Move sign over
        jra     FINFRS          | INF result
|
|
FPXSUB:
        |dsw    0               | Entry for FPCMP
|
FPA040:
        andw    d1,d1
        jeq     FPA041          | J/ 0,num + 0 -> 0,num
|
        andw    d0,d0
        jne     FPA045          | J/ no zeroes involved
|
        movew   d1,d0           | Copy over data
        movel   d3,d2
        moveal  a3,a2
FPA041:
        jra     FOPR02          | Return w/o range check
|
|
FPA045:
        |dsw    0
|
        cmpw    d1,d0
        jcc     FPA060          | J/ op1.exp >= op2.exp
|
        exg     d2,d3           | Flip mantissas
        exg     d0,d1
        exg     a2,a3
|
FPA060:
        subw    d0,d1
        negw    d1
        cmpiw   #24,d1
        jhi     FOPRSL          | J/ op2 too small to matter
|
        lsrl    d1,d3
        cmpal   a2,a3
        jne     FPS100          | J/ subtract operation
|
        addl    d3,d2
        jcc     FOPRSL          | J/ no carry out
|
        roxrl   #1,d2           | Handle carry out
        addqw   #1,d0           | Bump the exponent
        jra     FOPRSL
|
|
FPS100:
        subl    d3,d2           | Do the subtract
        jeq     FZERRS          | J/ zero result
        jcc     FPS110
|
        negl    d2
|
        moveal  a3,a2           | Flip sign
|
FPS110:
        andl    d2,d2           | Normalization section
        jmi     FOPRSL          | J/ normalized
|
        subqw   #1,d0           | Decrease exponent value
FPS120:
        addl    d2,d2           | Left shift d2
        dbmi    d0,FPS120       | J/ not normalized
|
        jra     FOPRSL
/*
|
|       page
|
|  FPMUL
|  =====
|  Single precision multiply routine.
|
*/

FPMUL:
        bsr     GETFP2          | Fetch both operands
        movew   a2,d4
        movew   a3,d5
        eorw    d4,d5
        moveaw  d5,a2           | /* Result's sign */
|
        andw    d0,d0
        jne     FPM010          | J/ operand <> 0.0
|
        cmpiw   #0xFF,d1
        jeq     FNANRS          | J/ 0.0 * NaN,INF -> NaN
        jra     FZERRS          | J/ 0.0 * 0.0,num -> 0.0
|
FPM010:
        cmpiw   #0xFF,d0
        jne     FPM020          | J/ operand is a number
|
        lsll    #1,d2
        jne     FNANRS          | J/ NaN *  ?  -> NaN
|
        andw    d1,d1
        jeq     FNANRS          | J/ INF * 0.0 -> NaN
|
        cmpiw   #0xFF,d1
        jne     FINFRS          | J/ INF * num -> INF
        lsll    #1,d3
        jeq     FINFRS          | J/ INF * INF -> INF
        jra     FNANRS          | J/ INF * NaN -> NaN
|
FPM020:
        andw    d1,d1
        jeq     FZERRS          | J/ num * 0.0 -> 0.0
|
        cmpiw   #0xFF,d1
        jne     FPM040          | J/ num * num
|
        lsll    #1,d3
        jeq     FINFRS          | J/ num * INF -> INF
        jra     FNANRS          | J/ num * NaN -> NaN