Subversion Repositories or1k_old

|

|       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.h"

|

|       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

|

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