Subversion Repositories openrisc_me

//
//      $Id: round.S,v 1.2 2001-09-27 12:01:22 chris Exp $
//
//      round.sa 3.4 7/29/91
//
//      handle rounding and normalization tasks
//
//
//
//              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.

//ROUND idnt    2,1 | Motorola 040 Floating Point Software Package

        |section        8

#include "fpsp.defs"

//
//      round --- round result according to precision/mode
//
//      a0 points to the input operand in the internal extended format 
//      d1(high word) contains rounding precision:
//              ext = $0000xxxx
//              sgl = $0001xxxx
//              dbl = $0002xxxx
//      d1(low word) contains rounding mode:
//              RN  = $xxxx0000
//              RZ  = $xxxx0001
//              RM  = $xxxx0010
//              RP  = $xxxx0011
//      d0{31:29} contains the g,r,s bits (extended)
//
//      On return the value pointed to by a0 is correctly rounded,
//      a0 is preserved and the g-r-s bits in d0 are cleared.
//      The result is not typed - the tag field is invalid.  The
//      result is still in the internal extended format.
//
//      The INEX bit of USER_FPSR will be set if the rounded result was
//      inexact (i.e. if any of the g-r-s bits were set).
//

        .global round
round:
// If g=r=s=0 then result is exact and round is done, else set 
// the inex flag in status reg and continue.  
//
        bsrs    ext_grs                 //this subroutine looks at the 
//                                      :rounding precision and sets 
//                                      ;the appropriate g-r-s bits.
        tstl    %d0                     //if grs are zero, go force
        bne     rnd_cont                //lower bits to zero for size
        
        swap    %d1                     //set up d1.w for round prec.
        bra     truncate

rnd_cont:
//
// Use rounding mode as an index into a jump table for these modes.
//
        orl     #inx2a_mask,USER_FPSR(%a6) //set inex2/ainex
        lea     mode_tab,%a1
        movel   (%a1,%d1.w*4),%a1
        jmp     (%a1)
//
// Jump table indexed by rounding mode in d1.w.  All following assumes
// grs != 0.
//
mode_tab:
        .long   rnd_near
        .long   rnd_zero
        .long   rnd_mnus
        .long   rnd_plus
//
//      ROUND PLUS INFINITY
//
//      If sign of fp number = 0 (positive), then add 1 to l.
//
rnd_plus:
        swap    %d1                     //set up d1 for round prec.
        tstb    LOCAL_SGN(%a0)          //check for sign
        bmi     truncate                //if positive then truncate
        movel   #0xffffffff,%d0         //force g,r,s to be all f's
        lea     add_to_l,%a1
        movel   (%a1,%d1.w*4),%a1
        jmp     (%a1)
//
//      ROUND MINUS INFINITY
//
//      If sign of fp number = 1 (negative), then add 1 to l.
//
rnd_mnus:
        swap    %d1                     //set up d1 for round prec.
        tstb    LOCAL_SGN(%a0)          //check for sign        
        bpl     truncate                //if negative then truncate
        movel   #0xffffffff,%d0         //force g,r,s to be all f's
        lea     add_to_l,%a1
        movel   (%a1,%d1.w*4),%a1
        jmp     (%a1)
//
//      ROUND ZERO
//
//      Always truncate.
rnd_zero:
        swap    %d1                     //set up d1 for round prec.
        bra     truncate
//
//
//      ROUND NEAREST
//
//      If (g=1), then add 1 to l and if (r=s=0), then clear l
//      Note that this will round to even in case of a tie.
//
rnd_near:
        swap    %d1                     //set up d1 for round prec.
        asll    #1,%d0                  //shift g-bit to c-bit
        bcc     truncate                //if (g=1) then
        lea     add_to_l,%a1
        movel   (%a1,%d1.w*4),%a1
        jmp     (%a1)

//
//      ext_grs --- extract guard, round and sticky bits
//
// Input:       d1 =            PREC:ROUND
// Output:      d0{31:29}=      guard, round, sticky
//
// The ext_grs extract the guard/round/sticky bits according to the
// selected rounding precision. It is called by the round subroutine
// only.  All registers except d0 are kept intact. d0 becomes an 
// updated guard,round,sticky in d0{31:29}
//
// Notes: the ext_grs uses the round PREC, and therefore has to swap d1
//       prior to usage, and needs to restore d1 to original.
//
ext_grs:
        swap    %d1                     //have d1.w point to round precision
        cmpiw   #0,%d1
        bnes    sgl_or_dbl
        bras    end_ext_grs
 
sgl_or_dbl:
        moveml  %d2/%d3,-(%a7)          //make some temp registers
        cmpiw   #1,%d1
        bnes    grs_dbl
grs_sgl:
        bfextu  LOCAL_HI(%a0){#24:#2},%d3       //sgl prec. g-r are 2 bits right
        movel   #30,%d2                 //of the sgl prec. limits
        lsll    %d2,%d3                 //shift g-r bits to MSB of d3
        movel   LOCAL_HI(%a0),%d2               //get word 2 for s-bit test
        andil   #0x0000003f,%d2         //s bit is the or of all other 
        bnes    st_stky                 //bits to the right of g-r
        tstl    LOCAL_LO(%a0)           //test lower mantissa
        bnes    st_stky                 //if any are set, set sticky
        tstl    %d0                     //test original g,r,s
        bnes    st_stky                 //if any are set, set sticky
        bras    end_sd                  //if words 3 and 4 are clr, exit
grs_dbl:    
        bfextu  LOCAL_LO(%a0){#21:#2},%d3       //dbl-prec. g-r are 2 bits right
        movel   #30,%d2                 //of the dbl prec. limits
        lsll    %d2,%d3                 //shift g-r bits to the MSB of d3
        movel   LOCAL_LO(%a0),%d2               //get lower mantissa  for s-bit test
        andil   #0x000001ff,%d2         //s bit is the or-ing of all 
        bnes    st_stky                 //other bits to the right of g-r
        tstl    %d0                     //test word original g,r,s
        bnes    st_stky                 //if any are set, set sticky
        bras    end_sd                  //if clear, exit
st_stky:
        bset    #rnd_stky_bit,%d3
end_sd:
        movel   %d3,%d0                 //return grs to d0
        moveml  (%a7)+,%d2/%d3          //restore scratch registers
end_ext_grs:
        swap    %d1                     //restore d1 to original
        rts

//*******************  Local Equates
        .set    ad_1_sgl,0x00000100     //  constant to add 1 to l-bit in sgl prec
        .set    ad_1_dbl,0x00000800     //  constant to add 1 to l-bit in dbl prec


//Jump table for adding 1 to the l-bit indexed by rnd prec

add_to_l:
        .long   add_ext
        .long   add_sgl
        .long   add_dbl
        .long   add_dbl
//
//      ADD SINGLE
//
add_sgl:
        addl    #ad_1_sgl,LOCAL_HI(%a0)
        bccs    scc_clr                 //no mantissa overflow
        roxrw  LOCAL_HI(%a0)            //shift v-bit back in
        roxrw  LOCAL_HI+2(%a0)          //shift v-bit back in
        addw    #0x1,LOCAL_EX(%a0)      //and incr exponent
scc_clr:
        tstl    %d0                     //test for rs = 0
        bnes    sgl_done
        andiw  #0xfe00,LOCAL_HI+2(%a0)  //clear the l-bit
sgl_done:
        andil   #0xffffff00,LOCAL_HI(%a0) //truncate bits beyond sgl limit
        clrl    LOCAL_LO(%a0)           //clear d2
        rts

//
//      ADD EXTENDED
//
add_ext:
        addql  #1,LOCAL_LO(%a0)         //add 1 to l-bit
        bccs    xcc_clr                 //test for carry out
        addql  #1,LOCAL_HI(%a0)         //propagate carry
        bccs    xcc_clr
        roxrw  LOCAL_HI(%a0)            //mant is 0 so restore v-bit
        roxrw  LOCAL_HI+2(%a0)          //mant is 0 so restore v-bit
        roxrw   LOCAL_LO(%a0)
        roxrw   LOCAL_LO+2(%a0)
        addw    #0x1,LOCAL_EX(%a0)      //and inc exp
xcc_clr:
        tstl    %d0                     //test rs = 0
        bnes    add_ext_done
        andib   #0xfe,LOCAL_LO+3(%a0)   //clear the l bit
add_ext_done:
        rts
//
//      ADD DOUBLE
//
add_dbl:
        addl    #ad_1_dbl,LOCAL_LO(%a0)
        bccs    dcc_clr
        addql   #1,LOCAL_HI(%a0)                //propagate carry
        bccs    dcc_clr
        roxrw   LOCAL_HI(%a0)           //mant is 0 so restore v-bit
        roxrw   LOCAL_HI+2(%a0)         //mant is 0 so restore v-bit
        roxrw   LOCAL_LO(%a0)
        roxrw   LOCAL_LO+2(%a0)
        addw    #0x1,LOCAL_EX(%a0)      //incr exponent
dcc_clr:
        tstl    %d0                     //test for rs = 0
        bnes    dbl_done
        andiw   #0xf000,LOCAL_LO+2(%a0) //clear the l-bit

dbl_done:
        andil   #0xfffff800,LOCAL_LO(%a0) //truncate bits beyond dbl limit
        rts

error:
        rts
//
// Truncate all other bits
//
trunct:
        .long   end_rnd
        .long   sgl_done
        .long   dbl_done
        .long   dbl_done

truncate:
        lea     trunct,%a1
        movel   (%a1,%d1.w*4),%a1
        jmp     (%a1)

end_rnd:
        rts

//
//      NORMALIZE
//
// These routines (nrm_zero & nrm_set) normalize the unnorm.  This 
// is done by shifting the mantissa left while decrementing the 
// exponent.
//
// NRM_SET shifts and decrements until there is a 1 set in the integer 
// bit of the mantissa (msb in d1).
//
// NRM_ZERO shifts and decrements until there is a 1 set in the integer 
// bit of the mantissa (msb in d1) unless this would mean the exponent 
// would go less than 0.  In that case the number becomes a denorm - the 
// exponent (d0) is set to 0 and the mantissa (d1 & d2) is not 
// normalized.
//
// Note that both routines have been optimized (for the worst case) and 
// therefore do not have the easy to follow decrement/shift loop.
//
//      NRM_ZERO
//
//      Distance to first 1 bit in mantissa = X
//      Distance to 0 from exponent = Y
//      If X < Y
//      Then
//        nrm_set
//      Else
//        shift mantissa by Y
//        set exponent = 0
//
//input:
//      FP_SCR1 = exponent, ms mantissa part, ls mantissa part
//output:
//      L_SCR1{4} = fpte15 or ete15 bit
//
        .global nrm_zero
nrm_zero:
        movew   LOCAL_EX(%a0),%d0
        cmpw   #64,%d0          //see if exp > 64 
        bmis    d0_less
        bsr     nrm_set         //exp > 64 so exp won't exceed 0 
        rts
d0_less:
        moveml  %d2/%d3/%d5/%d6,-(%a7)
        movel   LOCAL_HI(%a0),%d1
        movel   LOCAL_LO(%a0),%d2

        bfffo   %d1{#0:#32},%d3 //get the distance to the first 1 
//                              ;in ms mant
        beqs    ms_clr          //branch if no bits were set
        cmpw    %d3,%d0         //of X>Y
        bmis    greater         //then exp will go past 0 (neg) if 
//                              ;it is just shifted
        bsr     nrm_set         //else exp won't go past 0
        moveml  (%a7)+,%d2/%d3/%d5/%d6
        rts     
greater:
        movel   %d2,%d6         //save ls mant in d6
        lsll    %d0,%d2         //shift ls mant by count
        lsll    %d0,%d1         //shift ms mant by count
        movel   #32,%d5
        subl    %d0,%d5         //make op a denorm by shifting bits 
        lsrl    %d5,%d6         //by the number in the exp, then 
//                              ;set exp = 0.
        orl     %d6,%d1         //shift the ls mant bits into the ms mant
        movel   #0,%d0          //same as if decremented exp to 0 
//                              ;while shifting
        movew   %d0,LOCAL_EX(%a0)
        movel   %d1,LOCAL_HI(%a0)
        movel   %d2,LOCAL_LO(%a0)
        moveml  (%a7)+,%d2/%d3/%d5/%d6
        rts
ms_clr:
        bfffo   %d2{#0:#32},%d3 //check if any bits set in ls mant
        beqs    all_clr         //branch if none set
        addw    #32,%d3
        cmpw    %d3,%d0         //if X>Y
        bmis    greater         //then branch
        bsr     nrm_set         //else exp won't go past 0
        moveml  (%a7)+,%d2/%d3/%d5/%d6
        rts
all_clr:
        movew   #0,LOCAL_EX(%a0)        //no mantissa bits set. Set exp = 0.
        moveml  (%a7)+,%d2/%d3/%d5/%d6
        rts
//
//      NRM_SET
//
        .global nrm_set
nrm_set:
        movel   %d7,-(%a7)
        bfffo   LOCAL_HI(%a0){#0:#32},%d7 //find first 1 in ms mant to d7)
        beqs    lower           //branch if ms mant is all 0's

        movel   %d6,-(%a7)

        subw    %d7,LOCAL_EX(%a0)       //sub exponent by count
        movel   LOCAL_HI(%a0),%d0       //d0 has ms mant
        movel   LOCAL_LO(%a0),%d1 //d1 has ls mant

        lsll    %d7,%d0         //shift first 1 to j bit position
        movel   %d1,%d6         //copy ls mant into d6
        lsll    %d7,%d6         //shift ls mant by count
        movel   %d6,LOCAL_LO(%a0)       //store ls mant into memory
        moveql  #32,%d6
        subl    %d7,%d6         //continue shift
        lsrl    %d6,%d1         //shift off all bits but those that will
//                              ;be shifted into ms mant
        orl     %d1,%d0         //shift the ls mant bits into the ms mant
        movel   %d0,LOCAL_HI(%a0)       //store ms mant into memory
        moveml  (%a7)+,%d7/%d6  //restore registers
        rts

//
// We get here if ms mant was = 0, and we assume ls mant has bits 
// set (otherwise this would have been tagged a zero not a denorm).
//
lower:
        movew   LOCAL_EX(%a0),%d0       //d0 has exponent
        movel   LOCAL_LO(%a0),%d1       //d1 has ls mant
        subw    #32,%d0         //account for ms mant being all zeros
        bfffo   %d1{#0:#32},%d7 //find first 1 in ls mant to d7)
        subw    %d7,%d0         //subtract shift count from exp
        lsll    %d7,%d1         //shift first 1 to integer bit in ms mant
        movew   %d0,LOCAL_EX(%a0)       //store ms mant
        movel   %d1,LOCAL_HI(%a0)       //store exp
        clrl    LOCAL_LO(%a0)   //clear ls mant
        movel   (%a7)+,%d7
        rts
//
//      denorm --- denormalize an intermediate result
//
//      Used by underflow.
//
// Input: 
//      a0       points to the operand to be denormalized
//               (in the internal extended format)
//               
//      d0:      rounding precision
// Output:
//      a0       points to the denormalized result
//               (in the internal extended format)
//
//      d0      is guard,round,sticky
//
// d0 comes into this routine with the rounding precision. It 
// is then loaded with the denormalized exponent threshold for the 
// rounding precision.
//

        .global denorm
denorm:
        btstb   #6,LOCAL_EX(%a0)        //check for exponents between $7fff-$4000
        beqs    no_sgn_ext      
        bsetb   #7,LOCAL_EX(%a0)        //sign extend if it is so
no_sgn_ext:

        cmpib   #0,%d0          //if 0 then extended precision
        bnes    not_ext         //else branch

        clrl    %d1             //load d1 with ext threshold
        clrl    %d0             //clear the sticky flag
        bsr     dnrm_lp         //denormalize the number
        tstb    %d1             //check for inex
        beq     no_inex         //if clr, no inex
        bras    dnrm_inex       //if set, set inex

not_ext:
        cmpil   #1,%d0          //if 1 then single precision
        beqs    load_sgl        //else must be 2, double prec

load_dbl:
        movew   #dbl_thresh,%d1 //put copy of threshold in d1
        movel   %d1,%d0         //copy d1 into d0
        subw    LOCAL_EX(%a0),%d0       //diff = threshold - exp
        cmpw    #67,%d0         //if diff > 67 (mant + grs bits)
        bpls    chk_stky        //then branch (all bits would be 
//                              ; shifted off in denorm routine)
        clrl    %d0             //else clear the sticky flag
        bsr     dnrm_lp         //denormalize the number
        tstb    %d1             //check flag
        beqs    no_inex         //if clr, no inex
        bras    dnrm_inex       //if set, set inex

load_sgl:
        movew   #sgl_thresh,%d1 //put copy of threshold in d1
        movel   %d1,%d0         //copy d1 into d0
        subw    LOCAL_EX(%a0),%d0       //diff = threshold - exp
        cmpw    #67,%d0         //if diff > 67 (mant + grs bits)
        bpls    chk_stky        //then branch (all bits would be 
//                              ; shifted off in denorm routine)
        clrl    %d0             //else clear the sticky flag
        bsr     dnrm_lp         //denormalize the number
        tstb    %d1             //check flag
        beqs    no_inex         //if clr, no inex
        bras    dnrm_inex       //if set, set inex

chk_stky:
        tstl    LOCAL_HI(%a0)   //check for any bits set
        bnes    set_stky
        tstl    LOCAL_LO(%a0)   //check for any bits set
        bnes    set_stky
        bras    clr_mant
set_stky:
        orl     #inx2a_mask,USER_FPSR(%a6) //set inex2/ainex
        movel   #0x20000000,%d0 //set sticky bit in return value
clr_mant:
        movew   %d1,LOCAL_EX(%a0)               //load exp with threshold
        movel   #0,LOCAL_HI(%a0)        //set d1 = 0 (ms mantissa)
        movel   #0,LOCAL_LO(%a0)                //set d2 = 0 (ms mantissa)
        rts
dnrm_inex:
        orl     #inx2a_mask,USER_FPSR(%a6) //set inex2/ainex
no_inex:
        rts

//
//      dnrm_lp --- normalize exponent/mantissa to specified threshold
//
// Input:
//      a0              points to the operand to be denormalized
//      d0{31:29}       initial guard,round,sticky
//      d1{15:0}        denormalization threshold
// Output:
//      a0              points to the denormalized operand
//      d0{31:29}       final guard,round,sticky
//      d1.b            inexact flag:  all ones means inexact result
//
// The LOCAL_LO and LOCAL_GRS parts of the value are copied to FP_SCR2
// so that bfext can be used to extract the new low part of the mantissa.
// Dnrm_lp can be called with a0 pointing to ETEMP or WBTEMP and there 
// is no LOCAL_GRS scratch word following it on the fsave frame.
//
        .global dnrm_lp
dnrm_lp:
        movel   %d2,-(%sp)              //save d2 for temp use
        btstb   #E3,E_BYTE(%a6)         //test for type E3 exception
        beqs    not_E3                  //not type E3 exception
        bfextu  WBTEMP_GRS(%a6){#6:#3},%d2      //extract guard,round, sticky  bit
        movel   #29,%d0
        lsll    %d0,%d2                 //shift g,r,s to their positions
        movel   %d2,%d0
not_E3:
        movel   (%sp)+,%d2              //restore d2
        movel   LOCAL_LO(%a0),FP_SCR2+LOCAL_LO(%a6)
        movel   %d0,FP_SCR2+LOCAL_GRS(%a6)
        movel   %d1,%d0                 //copy the denorm threshold
        subw    LOCAL_EX(%a0),%d1               //d1 = threshold - uns exponent
        bles    no_lp                   //d1 <= 0
        cmpw    #32,%d1                 
        blts    case_1                  //0 = d1 < 32 
        cmpw    #64,%d1
        blts    case_2                  //32 <= d1 < 64
        bra     case_3                  //d1 >= 64
//
// No normalization necessary
//
no_lp:
        clrb    %d1                     //set no inex2 reported
        movel   FP_SCR2+LOCAL_GRS(%a6),%d0      //restore original g,r,s
        rts
//
// case (0<d1<32)
//
case_1:
        movel   %d2,-(%sp)
        movew   %d0,LOCAL_EX(%a0)               //exponent = denorm threshold
        movel   #32,%d0
        subw    %d1,%d0                 //d0 = 32 - d1
        bfextu  LOCAL_EX(%a0){%d0:#32},%d2
        bfextu  %d2{%d1:%d0},%d2                //d2 = new LOCAL_HI
        bfextu  LOCAL_HI(%a0){%d0:#32},%d1      //d1 = new LOCAL_LO
        bfextu  FP_SCR2+LOCAL_LO(%a6){%d0:#32},%d0      //d0 = new G,R,S
        movel   %d2,LOCAL_HI(%a0)               //store new LOCAL_HI
        movel   %d1,LOCAL_LO(%a0)               //store new LOCAL_LO
        clrb    %d1
        bftst   %d0{#2:#30}     
        beqs    c1nstky
        bsetl   #rnd_stky_bit,%d0
        st      %d1
c1nstky:
        movel   FP_SCR2+LOCAL_GRS(%a6),%d2      //restore original g,r,s
        andil   #0xe0000000,%d2         //clear all but G,R,S
        tstl    %d2                     //test if original G,R,S are clear
        beqs    grs_clear
        orl     #0x20000000,%d0         //set sticky bit in d0
grs_clear:
        andil   #0xe0000000,%d0         //clear all but G,R,S
        movel   (%sp)+,%d2
        rts
//
// case (32<=d1<64)
//
case_2:
        movel   %d2,-(%sp)
        movew   %d0,LOCAL_EX(%a0)               //unsigned exponent = threshold
        subw    #32,%d1                 //d1 now between 0 and 32
        movel   #32,%d0
        subw    %d1,%d0                 //d0 = 32 - d1
        bfextu  LOCAL_EX(%a0){%d0:#32},%d2
        bfextu  %d2{%d1:%d0},%d2                //d2 = new LOCAL_LO
        bfextu  LOCAL_HI(%a0){%d0:#32},%d1      //d1 = new G,R,S
        bftst   %d1{#2:#30}
        bnes    c2_sstky                //bra if sticky bit to be set
        bftst   FP_SCR2+LOCAL_LO(%a6){%d0:#32}
        bnes    c2_sstky                //bra if sticky bit to be set
        movel   %d1,%d0
        clrb    %d1
        bras    end_c2
c2_sstky:
        movel   %d1,%d0
        bsetl   #rnd_stky_bit,%d0
        st      %d1
end_c2:
        clrl    LOCAL_HI(%a0)           //store LOCAL_HI = 0
        movel   %d2,LOCAL_LO(%a0)               //store LOCAL_LO
        movel   FP_SCR2+LOCAL_GRS(%a6),%d2      //restore original g,r,s
        andil   #0xe0000000,%d2         //clear all but G,R,S
        tstl    %d2                     //test if original G,R,S are clear
        beqs    clear_grs               
        orl     #0x20000000,%d0         //set sticky bit in d0
clear_grs:
        andil   #0xe0000000,%d0         //get rid of all but G,R,S
        movel   (%sp)+,%d2
        rts
//
// d1 >= 64 Force the exponent to be the denorm threshold with the
// correct sign.
//
case_3:
        movew   %d0,LOCAL_EX(%a0)
        tstw    LOCAL_SGN(%a0)
        bges    c3con
c3neg:
        orl     #0x80000000,LOCAL_EX(%a0)
c3con:
        cmpw    #64,%d1
        beqs    sixty_four
        cmpw    #65,%d1
        beqs    sixty_five
//
// Shift value is out of range.  Set d1 for inex2 flag and
// return a zero with the given threshold.
//
        clrl    LOCAL_HI(%a0)
        clrl    LOCAL_LO(%a0)
        movel   #0x20000000,%d0
        st      %d1
        rts

sixty_four:
        movel   LOCAL_HI(%a0),%d0
        bfextu  %d0{#2:#30},%d1
        andil   #0xc0000000,%d0
        bras    c3com
        
sixty_five:
        movel   LOCAL_HI(%a0),%d0
        bfextu  %d0{#1:#31},%d1
        andil   #0x80000000,%d0
        lsrl    #1,%d0                  //shift high bit into R bit

c3com:
        tstl    %d1
        bnes    c3ssticky
        tstl    LOCAL_LO(%a0)
        bnes    c3ssticky
        tstb    FP_SCR2+LOCAL_GRS(%a6)
        bnes    c3ssticky
        clrb    %d1
        bras    c3end

c3ssticky:
        bsetl   #rnd_stky_bit,%d0
        st      %d1
c3end:
        clrl    LOCAL_HI(%a0)
        clrl    LOCAL_LO(%a0)
        rts

        |end