Quelle  sint.S   Sprache: Sparc

|
| sint.sa 3.1 12/10/90
|
| The entry point sINT computes the rounded integer
| equivalent of the input argument, sINTRZ computes
| the integer rounded to zero of the input argument.
|
| Entry points sint and sintrz are called from do_func
| to emulate the fint and fintrz unimplemented instructions,
| respectively.  Entry point sintdo is used by bindec.
|
| Input: (Entry points sint and sintrz) Double-extended
|  number X in the ETEMP space in the floating-point
|  save stack.
|        (Entry point sintdo) Double-extended number X in
|  location pointed to by the address register a0.
|        (Entry point sintd) Double-extended denormalized
|  number X in the ETEMP space in the floating-point
|  save stack.
|
| Output: The function returns int(X) or intrz(X) in fp0.
|
| Modifies: fp0.
|
| Algorithm: (sint and sintrz)
|
| 1. If exp(X) >= 63, return X.
|    If exp(X) < 0, return +/- 0 or +/- 1, according to
|    the rounding mode.
|
| 2. (X is in range) set rsc = 63 - exp(X). Unnormalize the
|    result to the exponent $403e.
|
| 3. Round the result in the mode given in USER_FPCR. For
|    sintrz, force round-to-zero mode.
|
| 4. Normalize the rounded result; store in fp0.
|
| For the denormalized cases, force the correct result
| for the given sign and rounding mode.
|
|          Sign(X)
|  RMODE   +    -
|  -----  --------
|   RN    +0   -0
|   RZ    +0   -0
|   RM    +0   -1
|   RP    +1   -0
|
|
|  Copyright (C) Motorola, Inc. 1990
|   All Rights Reserved
|
|       For details on the license for this file, please see the
|       file, README, in this same directory.

|SINT    idnt    2,1 | Motorola 040 Floating Point Software Package

 |section 8

#include "fpsp.h"

 |xref dnrm_lp
 |xref nrm_set
 |xref round
 |xref t_inx2
 |xref ld_pone
 |xref ld_mone
 |xref ld_pzero
 |xref ld_mzero
 |xref snzrinx

|
| FINT
|
 .global sint
sint:
 bfextu FPCR_MODE(%a6){#2:#2},%d1 |use user's mode for rounding
|     ;implicitly has extend precision
|     ;in upper word.
 movel %d1,L_SCR1(%a6)  |save mode bits
 bras sintexc

|
| FINT with extended denorm inputs.
|
 .global sintd
sintd:
 btstb #5,FPCR_MODE(%a6)
 beq snzrinx  |if round nearest or round zero, +/- 0
 btstb #4,FPCR_MODE(%a6)
 beqs rnd_mns
rnd_pls:
 btstb #sign_bit,LOCAL_EX(%a0)
 bnes sintmz
 bsr ld_pone  |if round plus inf and pos, answer is +1
 bra t_inx2
rnd_mns:
 btstb #sign_bit,LOCAL_EX(%a0)
 beqs sintpz
 bsr ld_mone  |if round mns inf and neg, answer is -1
 bra t_inx2
sintpz:
 bsr ld_pzero
 bra t_inx2
sintmz:
 bsr ld_mzero
 bra t_inx2

|
| FINTRZ
|
 .global sintrz
sintrz:
 movel #1,L_SCR1(%a6)  |use rz mode for rounding
|     ;implicitly has extend precision
|     ;in upper word.
 bras sintexc
|
| SINTDO
|
| Input: a0 points to an IEEE extended format operand
| Output: fp0 has the result
|
| Exceptions:
|
| If the subroutine results in an inexact operation, the inx2 and
| ainx bits in the USER_FPSR are set.
|
|
 .global sintdo
sintdo:
 bfextu FPCR_MODE(%a6){#2:#2},%d1 |use user's mode for rounding
|     ;implicitly has ext precision
|     ;in upper word.
 movel %d1,L_SCR1(%a6)  |save mode bits
|
| Real work of sint is in sintexc
|
sintexc:
 bclrb #sign_bit,LOCAL_EX(%a0) |convert to internal extended
|     ;format
 sne LOCAL_SGN(%a0)
 cmpw #0x403e,LOCAL_EX(%a0) |check if (unbiased) exp > 63
 bgts out_rnge   |branch if exp < 63
 cmpw #0x3ffd,LOCAL_EX(%a0) |check if (unbiased) exp < 0
 bgt in_rnge   |if 63 >= exp > 0, do calc
|
| Input is less than zero.  Restore sign, and check for directed
| rounding modes.  L_SCR1 contains the rmode in the lower byte.
|
un_rnge:
 btstb #1,L_SCR1+3(%a6)  |check for rn and rz
 beqs un_rnrz
 tstb LOCAL_SGN(%a0)  |check for sign
 bnes un_rmrp_neg
|
| Sign is +.  If rp, load +1.0, if rm, load +0.0
|
 cmpib #3,L_SCR1+3(%a6)  |check for rp
 beqs un_ldpone  |if rp, load +1.0
 bsr ld_pzero  |if rm, load +0.0
 bra t_inx2
un_ldpone:
 bsr ld_pone
 bra t_inx2
|
| Sign is -.  If rm, load -1.0, if rp, load -0.0
|
un_rmrp_neg:
 cmpib #2,L_SCR1+3(%a6)  |check for rm
 beqs un_ldmone  |if rm, load -1.0
 bsr ld_mzero  |if rp, load -0.0
 bra t_inx2
un_ldmone:
 bsr ld_mone
 bra t_inx2
|
| Rmode is rn or rz; return signed zero
|
un_rnrz:
 tstb LOCAL_SGN(%a0)  |check for sign
 bnes un_rnrz_neg
 bsr ld_pzero
 bra t_inx2
un_rnrz_neg:
 bsr ld_mzero
 bra t_inx2

|
| Input is greater than 2^63.  All bits are significant.  Return
| the input.
|
out_rnge:
 bfclr LOCAL_SGN(%a0){#0:#8} |change back to IEEE ext format
 beqs intps
 bsetb #sign_bit,LOCAL_EX(%a0)
intps:
 fmovel %fpcr,-(%sp)
 fmovel #0,%fpcr
 fmovex LOCAL_EX(%a0),%fp0 |if exp > 63
|     ;then return X to the user
|     ;there are no fraction bits
 fmovel (%sp)+,%fpcr
 rts

in_rnge:
|     ;shift off fraction bits
 clrl %d0   |clear d0 - initial g,r,s for
|     ;dnrm_lp
 movel #0x403e,%d1  |set threshold for dnrm_lp
|     ;assumes a0 points to operand
 bsr dnrm_lp
|     ;returns unnormalized number
|     ;pointed by a0
|     ;output d0 supplies g,r,s
|     ;used by round
 movel L_SCR1(%a6),%d1  |use selected rounding mode
|
|
 bsr round   |round the unnorm based on users
|     ;input a0 ptr to ext X
|     ; d0 g,r,s bits
|     ; d1 PREC/MODE info
|     ;output a0 ptr to rounded result
|     ;inexact flag set in USER_FPSR
|     ;if initial grs set
|
| normalize the rounded result and store value in fp0
|
 bsr nrm_set   |normalize the unnorm
|     ;Input: a0 points to operand to
|     ;be normalized
|     ;Output: a0 points to normalized
|     ;result
 bfclr LOCAL_SGN(%a0){#0:#8}
 beqs nrmrndp
 bsetb #sign_bit,LOCAL_EX(%a0) |return to IEEE extended format
nrmrndp:
 fmovel %fpcr,-(%sp)
 fmovel #0,%fpcr
 fmovex LOCAL_EX(%a0),%fp0 |move result to fp0
 fmovel (%sp)+,%fpcr
 rts

 |end