//
// $Id$
//
// 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
//
// THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
// The copyright notice above does not evidence any
// actual or intended publication of such source code.
//SINT idnt 2,1 | Motorola 040 Floating Point Software Package
|section 8
#include "fpsp.defs"
|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
