//
// $Id$
//
// 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
//
// 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.
//BINSTR idnt 2,1 | Motorola 040 Floating Point Software Package
|section 8
#include "fpsp.defs"
.global binstr
binstr:
moveml %d0-%d7,-(%a7)
//
// A1: Init d7
//
moveql #1,%d7 //init d7 for second digit
subql #1,%d0 //for dbf d0 would have LEN+1 passes
//
// A2. Copy d2:d3 to d4:d5. Start loop.
//
loop:
movel %d2,%d4 //copy the fraction before muls
movel %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
asll #3,%d2 //shift d2 left by 3 places
bfextu %d3{#0:#3},%d6 //copy 3 msbs of d3 into d6
asll #3,%d3 //shift d3 left by 3 places
orl %d6,%d2 //or in msbs from d3 into d2
//
// A4. Multiply d4:d5 by 2; add carry out to d1.
//
asll #1,%d5 //mul d5 by 2
roxll #1,%d4 //mul d4 by 2
swap %d6 //put 0 in d6 lower word
addxw %d6,%d1 //add in extend from mul by 2
//
// A5. Add mul by 8 to mul by 2. D1 contains the digit formed.
//
addl %d5,%d3 //add lower 32 bits
nop //ERRATA ; FIX #13 (Rev. 1.2 6/6/90)
addxl %d4,%d2 //add with extend upper 32 bits
nop //ERRATA ; FIX #13 (Rev. 1.2 6/6/90)
addxw %d6,%d1 //add in extend from add to d1
swap %d6 //with d6 = 0; put 0 in upper word
//
// A6. Test d7 and branch.
//
tstw %d7 //if zero, store digit & to loop
beqs first_d //if non-zero, form byte & write
sec_d:
swap %d7 //bring first digit to word d7b
aslw #4,%d7 //first digit in upper 4 bits d7b
addw %d1,%d7 //add in ls digit to d7b
moveb %d7,(%a0)+ //store d7b byte in memory
swap %d7 //put LEN counter in word d7a
clrw %d7 //set d7a to signal no digits done
dbf %d0,loop //do loop some more!
bras end_bstr //finished, so exit
first_d:
swap %d7 //put digit word in d7b
movew %d1,%d7 //put new digit in d7b
swap %d7 //put LEN counter in word d7a
addqw #1,%d7 //set d7a to signal first digit done
dbf %d0,loop //do loop some more!
swap %d7 //put last digit in string
lslw #4,%d7 //move it to upper 4 bits
moveb %d7,(%a0)+ //store it in memory string
//
// Clean up and return with result in fp0.
//
end_bstr:
moveml (%a7)+,%d0-%d7
rts
|end
