Added the MC68040 Floating Point Support Package. This was ported

to RTEMS by Eric Norum.  It is freely distributable and was acquired
from the Motorola WWW site.  More info is in the FPSP README.

1 files changed, 140 insertions, 0 deletions

diff --git a/c/src/lib/libcpu/m68k/m68040/fpsp/binstr.s b/c/src/lib/libcpu/m68k/m68040/fpsp/binstr.s
new file mode 100644
index 0000000000..5688d505f1
--- /dev/null
+++ b/c/src/lib/libcpu/m68k/m68040/fpsp/binstr.s
@@ -0,0 +1,140 @@
+//
+//	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