source: rtems/bsps/m68k/shared/fpsp/binstr.S @ d7d66d7

5
Last change on this file since d7d66d7 was 3cf2bf63, checked in by Sebastian Huber <sebastian.huber@…>, on 03/26/18 at 10:17:06

bsps/m68k: Move fpsp support to bsps

This patch is a part of the BSP source reorganization.

Update #3285.

  • Property mode set to 100644
File size: 4.4 KB
Line 
1#include "fpsp-namespace.h"
2//
3//
4//      binstr.sa 3.3 12/19/90
5//
6//      Description: Converts a 64-bit binary integer to bcd.
7//
8//      Input: 64-bit binary integer in d2:d3, desired length (LEN) in
9//          d0, and a  pointer to start in memory for bcd characters
10//          in d0. (This pointer must point to byte 4 of the first
11//          lword of the packed decimal memory string.)
12//
13//      Output: LEN bcd digits representing the 64-bit integer.
14//
15//      Algorithm:
16//              The 64-bit binary is assumed to have a decimal point before
17//              bit 63.  The fraction is multiplied by 10 using a mul by 2
18//              shift and a mul by 8 shift.  The bits shifted out of the
19//              msb form a decimal digit.  This process is iterated until
20//              LEN digits are formed.
21//
22//      A1. Init d7 to 1.  D7 is the byte digit counter, and if 1, the
23//              digit formed will be assumed the least significant.  This is
24//              to force the first byte formed to have a 0 in the upper 4 bits.
25//
26//      A2. Beginning of the loop:
27//              Copy the fraction in d2:d3 to d4:d5.
28//
29//      A3. Multiply the fraction in d2:d3 by 8 using bit-field
30//              extracts and shifts.  The three msbs from d2 will go into
31//              d1.
32//
33//      A4. Multiply the fraction in d4:d5 by 2 using shifts.  The msb
34//              will be collected by the carry.
35//
36//      A5. Add using the carry the 64-bit quantities in d2:d3 and d4:d5
37//              into d2:d3.  D1 will contain the bcd digit formed.
38//
39//      A6. Test d7.  If zero, the digit formed is the ms digit.  If non-
40//              zero, it is the ls digit.  Put the digit in its place in the
41//              upper word of d0.  If it is the ls digit, write the word
42//              from d0 to memory.
43//
44//      A7. Decrement d6 (LEN counter) and repeat the loop until zero.
45//
46//      Implementation Notes:
47//
48//      The registers are used as follows:
49//
50//              d0: LEN counter
51//              d1: temp used to form the digit
52//              d2: upper 32-bits of fraction for mul by 8
53//              d3: lower 32-bits of fraction for mul by 8
54//              d4: upper 32-bits of fraction for mul by 2
55//              d5: lower 32-bits of fraction for mul by 2
56//              d6: temp for bit-field extracts
57//              d7: byte digit formation word;digit count {0,1}
58//              a0: pointer into memory for packed bcd string formation
59//
60
61//              Copyright (C) Motorola, Inc. 1990
62//                      All Rights Reserved
63//
64//      THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
65//      The copyright notice above does not evidence any
66//      actual or intended publication of such source code.
67
68//BINSTR    idnt    2,1 | Motorola 040 Floating Point Software Package
69
70        |section        8
71
72#include "fpsp.defs"
73
74        .global binstr
75binstr:
76        moveml  %d0-%d7,-(%a7)
77//
78// A1: Init d7
79//
80        moveql  #1,%d7                  //init d7 for second digit
81        subql   #1,%d0                  //for dbf d0 would have LEN+1 passes
82//
83// A2. Copy d2:d3 to d4:d5.  Start loop.
84//
85loop:
86        movel   %d2,%d4                 //copy the fraction before muls
87        movel   %d3,%d5                 //to d4:d5
88//
89// A3. Multiply d2:d3 by 8; extract msbs into d1.
90//
91        bfextu  %d2{#0:#3},%d1          //copy 3 msbs of d2 into d1
92        asll    #3,%d2                  //shift d2 left by 3 places
93        bfextu  %d3{#0:#3},%d6          //copy 3 msbs of d3 into d6
94        asll    #3,%d3                  //shift d3 left by 3 places
95        orl     %d6,%d2                 //or in msbs from d3 into d2
96//
97// A4. Multiply d4:d5 by 2; add carry out to d1.
98//
99        asll    #1,%d5                  //mul d5 by 2
100        roxll   #1,%d4                  //mul d4 by 2
101        swap    %d6                     //put 0 in d6 lower word
102        addxw   %d6,%d1                 //add in extend from mul by 2
103//
104// A5. Add mul by 8 to mul by 2.  D1 contains the digit formed.
105//
106        addl    %d5,%d3                 //add lower 32 bits
107        nop                             //ERRATA ; FIX #13 (Rev. 1.2 6/6/90)
108        addxl   %d4,%d2                 //add with extend upper 32 bits
109        nop                             //ERRATA ; FIX #13 (Rev. 1.2 6/6/90)
110        addxw   %d6,%d1                 //add in extend from add to d1
111        swap    %d6                     //with d6 = 0; put 0 in upper word
112//
113// A6. Test d7 and branch.
114//
115        tstw    %d7                     //if zero, store digit & to loop
116        beqs    first_d                 //if non-zero, form byte & write
117sec_d:
118        swap    %d7                     //bring first digit to word d7b
119        aslw    #4,%d7                  //first digit in upper 4 bits d7b
120        addw    %d1,%d7                 //add in ls digit to d7b
121        moveb   %d7,(%a0)+              //store d7b byte in memory
122        swap    %d7                     //put LEN counter in word d7a
123        clrw    %d7                     //set d7a to signal no digits done
124        dbf     %d0,loop                //do loop some more!
125        bras    end_bstr                //finished, so exit
126first_d:
127        swap    %d7                     //put digit word in d7b
128        movew   %d1,%d7                 //put new digit in d7b
129        swap    %d7                     //put LEN counter in word d7a
130        addqw   #1,%d7                  //set d7a to signal first digit done
131        dbf     %d0,loop                //do loop some more!
132        swap    %d7                     //put last digit in string
133        lslw    #4,%d7                  //move it to upper 4 bits
134        moveb   %d7,(%a0)+              //store it in memory string
135//
136// Clean up and return with result in fp0.
137//
138end_bstr:
139        moveml  (%a7)+,%d0-%d7
140        rts
141        |end
Note: See TracBrowser for help on using the repository browser.