166 lines
5.5 KiB
Plaintext
166 lines
5.5 KiB
Plaintext
* $NetBSD: binstr.sa,v 1.3 1994/10/26 07:48:53 cgd Exp $
|
|
|
|
* MOTOROLA MICROPROCESSOR & MEMORY TECHNOLOGY GROUP
|
|
* M68000 Hi-Performance Microprocessor Division
|
|
* M68040 Software Package
|
|
*
|
|
* M68040 Software Package Copyright (c) 1993, 1994 Motorola Inc.
|
|
* All rights reserved.
|
|
*
|
|
* THE SOFTWARE is provided on an "AS IS" basis and without warranty.
|
|
* To the maximum extent permitted by applicable law,
|
|
* MOTOROLA DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED,
|
|
* INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A
|
|
* PARTICULAR PURPOSE and any warranty against infringement with
|
|
* regard to the SOFTWARE (INCLUDING ANY MODIFIED VERSIONS THEREOF)
|
|
* and any accompanying written materials.
|
|
*
|
|
* To the maximum extent permitted by applicable law,
|
|
* IN NO EVENT SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER
|
|
* (INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS
|
|
* PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR
|
|
* OTHER PECUNIARY LOSS) ARISING OF THE USE OR INABILITY TO USE THE
|
|
* SOFTWARE. Motorola assumes no responsibility for the maintenance
|
|
* and support of the SOFTWARE.
|
|
*
|
|
* You are hereby granted a copyright license to use, modify, and
|
|
* distribute the SOFTWARE so long as this entire notice is retained
|
|
* without alteration in any modified and/or redistributed versions,
|
|
* and that such modified versions are clearly identified as such.
|
|
* No licenses are granted by implication, estoppel or otherwise
|
|
* under any patents or trademarks of Motorola, Inc.
|
|
|
|
*
|
|
* binstr.sa 3.3 12/19/90
|
|
*
|
|
*
|
|
* Description: Converts a 64-bit binary integer to bcd.
|
|
*
|
|
* Input: 64-bit binary integer in d2:d3, desired length (LEN) in
|
|
* d0, and a pointer to start in memory for bcd characters
|
|
* in d0. (This pointer must point to byte 4 of the first
|
|
* lword of the packed decimal memory string.)
|
|
*
|
|
* Output: LEN bcd digits representing the 64-bit integer.
|
|
*
|
|
* Algorithm:
|
|
* The 64-bit binary is assumed to have a decimal point before
|
|
* bit 63. The fraction is multiplied by 10 using a mul by 2
|
|
* shift and a mul by 8 shift. The bits shifted out of the
|
|
* msb form a decimal digit. This process is iterated until
|
|
* LEN digits are formed.
|
|
*
|
|
* A1. Init d7 to 1. D7 is the byte digit counter, and if 1, the
|
|
* digit formed will be assumed the least significant. This is
|
|
* to force the first byte formed to have a 0 in the upper 4 bits.
|
|
*
|
|
* A2. Beginning of the loop:
|
|
* Copy the fraction in d2:d3 to d4:d5.
|
|
*
|
|
* A3. Multiply the fraction in d2:d3 by 8 using bit-field
|
|
* extracts and shifts. The three msbs from d2 will go into
|
|
* d1.
|
|
*
|
|
* A4. Multiply the fraction in d4:d5 by 2 using shifts. The msb
|
|
* will be collected by the carry.
|
|
*
|
|
* A5. Add using the carry the 64-bit quantities in d2:d3 and d4:d5
|
|
* into d2:d3. D1 will contain the bcd digit formed.
|
|
*
|
|
* A6. Test d7. If zero, the digit formed is the ms digit. If non-
|
|
* zero, it is the ls digit. Put the digit in its place in the
|
|
* upper word of d0. If it is the ls digit, write the word
|
|
* from d0 to memory.
|
|
*
|
|
* A7. Decrement d6 (LEN counter) and repeat the loop until zero.
|
|
*
|
|
* Implementation Notes:
|
|
*
|
|
* The registers are used as follows:
|
|
*
|
|
* d0: LEN counter
|
|
* d1: temp used to form the digit
|
|
* d2: upper 32-bits of fraction for mul by 8
|
|
* d3: lower 32-bits of fraction for mul by 8
|
|
* d4: upper 32-bits of fraction for mul by 2
|
|
* d5: lower 32-bits of fraction for mul by 2
|
|
* d6: temp for bit-field extracts
|
|
* d7: byte digit formation word;digit count {0,1}
|
|
* a0: pointer into memory for packed bcd string formation
|
|
*
|
|
|
|
BINSTR IDNT 2,1 Motorola 040 Floating Point Software Package
|
|
|
|
section 8
|
|
|
|
include fpsp.h
|
|
|
|
xdef binstr
|
|
binstr:
|
|
movem.l d0-d7,-(a7)
|
|
*
|
|
* A1: Init d7
|
|
*
|
|
moveq.l #1,d7 ;init d7 for second digit
|
|
subq.l #1,d0 ;for dbf d0 would have LEN+1 passes
|
|
*
|
|
* A2. Copy d2:d3 to d4:d5. Start loop.
|
|
*
|
|
loop:
|
|
move.l d2,d4 ;copy the fraction before muls
|
|
move.l d3,d5 ;to d4:d5
|
|
*
|
|
* A3. Multiply d2:d3 by 8; extract msbs into d1.
|
|
*
|
|
bfextu d2{0:3},d1 ;copy 3 msbs of d2 into d1
|
|
asl.l #3,d2 ;shift d2 left by 3 places
|
|
bfextu d3{0:3},d6 ;copy 3 msbs of d3 into d6
|
|
asl.l #3,d3 ;shift d3 left by 3 places
|
|
or.l d6,d2 ;or in msbs from d3 into d2
|
|
*
|
|
* A4. Multiply d4:d5 by 2; add carry out to d1.
|
|
*
|
|
add.l d5,d5 ;mul d5 by 2
|
|
addx.l d4,d4 ;mul d4 by 2
|
|
swap d6 ;put 0 in d6 lower word
|
|
addx.w d6,d1 ;add in extend from mul by 2
|
|
*
|
|
* A5. Add mul by 8 to mul by 2. D1 contains the digit formed.
|
|
*
|
|
add.l d5,d3 ;add lower 32 bits
|
|
nop ;ERRATA FIX #13 (Rev. 1.2 6/6/90)
|
|
addx.l d4,d2 ;add with extend upper 32 bits
|
|
nop ;ERRATA FIX #13 (Rev. 1.2 6/6/90)
|
|
addx.w d6,d1 ;add in extend from add to d1
|
|
swap d6 ;with d6 = 0; put 0 in upper word
|
|
*
|
|
* A6. Test d7 and branch.
|
|
*
|
|
tst.w d7 ;if zero, store digit & to loop
|
|
beq.b first_d ;if non-zero, form byte & write
|
|
sec_d:
|
|
swap d7 ;bring first digit to word d7b
|
|
asl.w #4,d7 ;first digit in upper 4 bits d7b
|
|
add.w d1,d7 ;add in ls digit to d7b
|
|
move.b d7,(a0)+ ;store d7b byte in memory
|
|
swap d7 ;put LEN counter in word d7a
|
|
clr.w d7 ;set d7a to signal no digits done
|
|
dbf.w d0,loop ;do loop some more!
|
|
bra.b end_bstr ;finished, so exit
|
|
first_d:
|
|
swap d7 ;put digit word in d7b
|
|
move.w d1,d7 ;put new digit in d7b
|
|
swap d7 ;put LEN counter in word d7a
|
|
addq.w #1,d7 ;set d7a to signal first digit done
|
|
dbf.w d0,loop ;do loop some more!
|
|
swap d7 ;put last digit in string
|
|
lsl.w #4,d7 ;move it to upper 4 bits
|
|
move.b d7,(a0)+ ;store it in memory string
|
|
*
|
|
* Clean up and return with result in fp0.
|
|
*
|
|
end_bstr:
|
|
movem.l (a7)+,d0-d7
|
|
rts
|
|
end
|