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, 506 insertions, 0 deletions

diff --git a/c/src/lib/libcpu/m68k/m68040/fpsp/decbin.s b/c/src/lib/libcpu/m68k/m68040/fpsp/decbin.s
new file mode 100644
index 0000000000..c1abffe4b3
--- /dev/null
+++ b/c/src/lib/libcpu/m68k/m68040/fpsp/decbin.s
@@ -0,0 +1,506 @@
+//
+//	decbin.sa 3.3 12/19/90
+//
+//	Description: Converts normalized packed bcd value pointed to by
+//	register A6 to extended-precision value in FP0.
+//
+//	Input: Normalized packed bcd value in ETEMP(a6).
+//
+//	Output:	Exact floating-point representation of the packed bcd value.
+//
+//	Saves and Modifies: D2-D5
+//
+//	Speed: The program decbin takes ??? cycles to execute.
+//
+//	Object Size:
+//
+//	External Reference(s): None.
+//
+//	Algorithm:
+//	Expected is a normal bcd (i.e. non-exceptional; all inf, zero,
+//	and NaN operands are dispatched without entering this routine)
+//	value in 68881/882 format at location ETEMP(A6).
+//
+//	A1.	Convert the bcd exponent to binary by successive adds and muls.
+//	Set the sign according to SE. Subtract 16 to compensate
+//	for the mantissa which is to be interpreted as 17 integer
+//	digits, rather than 1 integer and 16 fraction digits.
+//	Note: this operation can never overflow.
+//
+//	A2. Convert the bcd mantissa to binary by successive
+//	adds and muls in FP0. Set the sign according to SM.
+//	The mantissa digits will be converted with the decimal point
+//	assumed following the least-significant digit.
+//	Note: this operation can never overflow.
+//
+//	A3. Count the number of leading/trailing zeros in the
+//	bcd string.  If SE is positive, count the leading zeros;
+//	if negative, count the trailing zeros.  Set the adjusted
+//	exponent equal to the exponent from A1 and the zero count
+//	added if SM = 1 and subtracted if SM = 0.  Scale the
+//	mantissa the equivalent of forcing in the bcd value:
+//
+//	SM = 0	a non-zero digit in the integer position
+//	SM = 1	a non-zero digit in Mant0, lsd of the fraction
+//
+//	this will insure that any value, regardless of its
+//	representation (ex. 0.1E2, 1E1, 10E0, 100E-1), is converted
+//	consistently.
+//
+//	A4. Calculate the factor 10^exp in FP1 using a table of
+//	10^(2^n) values.  To reduce the error in forming factors
+//	greater than 10^27, a directed rounding scheme is used with
+//	tables rounded to RN, RM, and RP, according to the table
+//	in the comments of the pwrten section.
+//
+//	A5. Form the final binary number by scaling the mantissa by
+//	the exponent factor.  This is done by multiplying the
+//	mantissa in FP0 by the factor in FP1 if the adjusted
+//	exponent sign is positive, and dividing FP0 by FP1 if
+//	it is negative.
+//
+//	Clean up and return.  Check if the final mul or div resulted
+//	in an inex2 exception.  If so, set inex1 in the fpsr and 
+//	check if the inex1 exception is enabled.  If so, set d7 upper
+//	word to $0100.  This will signal unimp.sa that an enabled inex1
+//	exception occurred.  Unimp will fix the stack.
+//	
+
+//		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.
+
+//DECBIN    idnt    2,1 | Motorola 040 Floating Point Software Package
+
+	|section	8
+
+	.include "fpsp.defs"
+
+//
+//	PTENRN, PTENRM, and PTENRP are arrays of powers of 10 rounded
+//	to nearest, minus, and plus, respectively.  The tables include
+//	10**{1,2,4,8,16,32,64,128,256,512,1024,2048,4096}.  No rounding
+//	is required until the power is greater than 27, however, all
+//	tables include the first 5 for ease of indexing.
+//
+	|xref	PTENRN
+	|xref	PTENRM
+	|xref	PTENRP
+
+RTABLE:	.byte	0,0,0,0
+	.byte	2,3,2,3
+	.byte	2,3,3,2
+	.byte	3,2,2,3
+
+	.global	decbin
+	.global	calc_e
+	.global	pwrten
+	.global	calc_m
+	.global	norm
+	.global	ap_st_z
+	.global	ap_st_n
+//
+	.set	FNIBS,7
+	.set	FSTRT,0
+//
+	.set	ESTRT,4
+	.set	EDIGITS,2	// 
+//
+// Constants in single precision
+FZERO: 	.long	0x00000000
+FONE: 	.long	0x3F800000
+FTEN: 	.long	0x41200000
+
+	.set	TEN,10
+
+//
+decbin:
+	| fmovel	#0,FPCR		;clr real fpcr
+	moveml	%d2-%d5,-(%a7)
+//
+// Calculate exponent:
+//  1. Copy bcd value in memory for use as a working copy.
+//  2. Calculate absolute value of exponent in d1 by mul and add.
+//  3. Correct for exponent sign.
+//  4. Subtract 16 to compensate for interpreting the mant as all integer digits.
+//     (i.e., all digits assumed left of the decimal point.)
+//
+// Register usage:
+//
+//  calc_e:
+//	(*)  d0: temp digit storage
+//	(*)  d1: accumulator for binary exponent
+//	(*)  d2: digit count
+//	(*)  d3: offset pointer
+//	( )  d4: first word of bcd
+//	( )  a0: pointer to working bcd value
+//	( )  a6: pointer to original bcd value
+//	(*)  FP_SCR1: working copy of original bcd value
+//	(*)  L_SCR1: copy of original exponent word
+//
+calc_e:
+	movel	#EDIGITS,%d2	//# of nibbles (digits) in fraction part
+	moveql	#ESTRT,%d3	//counter to pick up digits
+	leal	FP_SCR1(%a6),%a0	//load tmp bcd storage address
+	movel	ETEMP(%a6),(%a0)	//save input bcd value
+	movel	ETEMP_HI(%a6),4(%a0) //save words 2 and 3
+	movel	ETEMP_LO(%a6),8(%a0) //and work with these
+	movel	(%a0),%d4	//get first word of bcd
+	clrl	%d1		//zero d1 for accumulator
+e_gd:
+	mulul	#TEN,%d1	//mul partial product by one digit place
+	bfextu	%d4{%d3:#4},%d0	//get the digit and zero extend into d0
+	addl	%d0,%d1		//d1 = d1 + d0
+	addqb	#4,%d3		//advance d3 to the next digit
+	dbf	%d2,e_gd	//if we have used all 3 digits, exit loop
+	btst	#30,%d4		//get SE
+	beqs	e_pos		//don't negate if pos
+	negl	%d1		//negate before subtracting
+e_pos:
+	subl	#16,%d1		//sub to compensate for shift of mant
+	bges	e_save		//if still pos, do not neg
+	negl	%d1		//now negative, make pos and set SE
+	orl	#0x40000000,%d4	//set SE in d4,
+	orl	#0x40000000,(%a0)	//and in working bcd
+e_save:
+	movel	%d1,L_SCR1(%a6)	//save exp in memory
+//
+//
+// Calculate mantissa:
+//  1. Calculate absolute value of mantissa in fp0 by mul and add.
+//  2. Correct for mantissa sign.
+//     (i.e., all digits assumed left of the decimal point.)
+//
+// Register usage:
+//
+//  calc_m:
+//	(*)  d0: temp digit storage
+//	(*)  d1: lword counter
+//	(*)  d2: digit count
+//	(*)  d3: offset pointer
+//	( )  d4: words 2 and 3 of bcd
+//	( )  a0: pointer to working bcd value
+//	( )  a6: pointer to original bcd value
+//	(*) fp0: mantissa accumulator
+//	( )  FP_SCR1: working copy of original bcd value
+//	( )  L_SCR1: copy of original exponent word
+//
+calc_m:
+	moveql	#1,%d1		//word counter, init to 1
+	fmoves	FZERO,%fp0	//accumulator
+//
+//
+//  Since the packed number has a long word between the first & second parts,
+//  get the integer digit then skip down & get the rest of the
+//  mantissa.  We will unroll the loop once.
+//
+	bfextu	(%a0){#28:#4},%d0	//integer part is ls digit in long word
+	faddb	%d0,%fp0		//add digit to sum in fp0
+//
+//
+//  Get the rest of the mantissa.
+//
+loadlw:
+	movel	(%a0,%d1.L*4),%d4	//load mantissa longword into d4
+	moveql	#FSTRT,%d3	//counter to pick up digits
+	moveql	#FNIBS,%d2	//reset number of digits per a0 ptr
+md2b:
+	fmuls	FTEN,%fp0	//fp0 = fp0 * 10
+	bfextu	%d4{%d3:#4},%d0	//get the digit and zero extend
+	faddb	%d0,%fp0	//fp0 = fp0 + digit
+//
+//
+//  If all the digits (8) in that long word have been converted (d2=0),
+//  then inc d1 (=2) to point to the next long word and reset d3 to 0
+//  to initialize the digit offset, and set d2 to 7 for the digit count;
+//  else continue with this long word.
+//
+	addqb	#4,%d3		//advance d3 to the next digit
+	dbf	%d2,md2b		//check for last digit in this lw
+nextlw:
+	addql	#1,%d1		//inc lw pointer in mantissa
+	cmpl	#2,%d1		//test for last lw
+	ble	loadlw		//if not, get last one
+	
+//
+//  Check the sign of the mant and make the value in fp0 the same sign.
+//
+m_sign:
+	btst	#31,(%a0)	//test sign of the mantissa
+	beqs	ap_st_z		//if clear, go to append/strip zeros
+	fnegx	%fp0		//if set, negate fp0
+	
+//
+// Append/strip zeros:
+//
+//  For adjusted exponents which have an absolute value greater than 27*,
+//  this routine calculates the amount needed to normalize the mantissa
+//  for the adjusted exponent.  That number is subtracted from the exp
+//  if the exp was positive, and added if it was negative.  The purpose
+//  of this is to reduce the value of the exponent and the possibility
+//  of error in calculation of pwrten.
+//
+//  1. Branch on the sign of the adjusted exponent.
+//  2p.(positive exp)
+//   2. Check M16 and the digits in lwords 2 and 3 in descending order.
+//   3. Add one for each zero encountered until a non-zero digit.
+//   4. Subtract the count from the exp.
+//   5. Check if the exp has crossed zero in #3 above; make the exp abs
+//	   and set SE.
+//	6. Multiply the mantissa by 10**count.
+//  2n.(negative exp)
+//   2. Check the digits in lwords 3 and 2 in descending order.
+//   3. Add one for each zero encountered until a non-zero digit.
+//   4. Add the count to the exp.
+//   5. Check if the exp has crossed zero in #3 above; clear SE.
+//   6. Divide the mantissa by 10**count.
+//
+//  *Why 27?  If the adjusted exponent is within -28 < expA < 28, than
+//   any adjustment due to append/strip zeros will drive the resultant
+//   exponent towards zero.  Since all pwrten constants with a power
+//   of 27 or less are exact, there is no need to use this routine to
+//   attempt to lessen the resultant exponent.
+//
+// Register usage:
+//
+//  ap_st_z:
+//	(*)  d0: temp digit storage
+//	(*)  d1: zero count
+//	(*)  d2: digit count
+//	(*)  d3: offset pointer
+//	( )  d4: first word of bcd
+//	(*)  d5: lword counter
+//	( )  a0: pointer to working bcd value
+//	( )  FP_SCR1: working copy of original bcd value
+//	( )  L_SCR1: copy of original exponent word
+//
+//
+// First check the absolute value of the exponent to see if this
+// routine is necessary.  If so, then check the sign of the exponent
+// and do append (+) or strip (-) zeros accordingly.
+// This section handles a positive adjusted exponent.
+//
+ap_st_z:
+	movel	L_SCR1(%a6),%d1	//load expA for range test
+	cmpl	#27,%d1		//test is with 27
+	ble	pwrten		//if abs(expA) <28, skip ap/st zeros
+	btst	#30,(%a0)	//check sign of exp
+	bnes	ap_st_n		//if neg, go to neg side
+	clrl	%d1		//zero count reg
+	movel	(%a0),%d4		//load lword 1 to d4
+	bfextu	%d4{#28:#4},%d0	//get M16 in d0
+	bnes	ap_p_fx		//if M16 is non-zero, go fix exp
+	addql	#1,%d1		//inc zero count
+	moveql	#1,%d5		//init lword counter
+	movel	(%a0,%d5.L*4),%d4	//get lword 2 to d4
+	bnes	ap_p_cl		//if lw 2 is zero, skip it
+	addql	#8,%d1		//and inc count by 8
+	addql	#1,%d5		//inc lword counter
+	movel	(%a0,%d5.L*4),%d4	//get lword 3 to d4
+ap_p_cl:
+	clrl	%d3		//init offset reg
+	moveql	#7,%d2		//init digit counter
+ap_p_gd:
+	bfextu	%d4{%d3:#4},%d0	//get digit
+	bnes	ap_p_fx		//if non-zero, go to fix exp
+	addql	#4,%d3		//point to next digit
+	addql	#1,%d1		//inc digit counter
+	dbf	%d2,ap_p_gd	//get next digit
+ap_p_fx:
+	movel	%d1,%d0		//copy counter to d2
+	movel	L_SCR1(%a6),%d1	//get adjusted exp from memory
+	subl	%d0,%d1		//subtract count from exp
+	bges	ap_p_fm		//if still pos, go to pwrten
+	negl	%d1		//now its neg; get abs
+	movel	(%a0),%d4		//load lword 1 to d4
+	orl	#0x40000000,%d4	// and set SE in d4
+	orl	#0x40000000,(%a0)	// and in memory
+//
+// Calculate the mantissa multiplier to compensate for the striping of
+// zeros from the mantissa.
+//
+ap_p_fm:
+	movel	#PTENRN,%a1	//get address of power-of-ten table
+	clrl	%d3		//init table index
+	fmoves	FONE,%fp1	//init fp1 to 1
+	moveql	#3,%d2		//init d2 to count bits in counter
+ap_p_el:
+	asrl	#1,%d0		//shift lsb into carry
+	bccs	ap_p_en		//if 1, mul fp1 by pwrten factor
+	fmulx	(%a1,%d3),%fp1	//mul by 10**(d3_bit_no)
+ap_p_en:
+	addl	#12,%d3		//inc d3 to next rtable entry
+	tstl	%d0		//check if d0 is zero
+	bnes	ap_p_el		//if not, get next bit
+	fmulx	%fp1,%fp0		//mul mantissa by 10**(no_bits_shifted)
+	bras	pwrten		//go calc pwrten
+//
+// This section handles a negative adjusted exponent.
+//
+ap_st_n:
+	clrl	%d1		//clr counter
+	moveql	#2,%d5		//set up d5 to point to lword 3
+	movel	(%a0,%d5.L*4),%d4	//get lword 3
+	bnes	ap_n_cl		//if not zero, check digits
+	subl	#1,%d5		//dec d5 to point to lword 2
+	addql	#8,%d1		//inc counter by 8
+	movel	(%a0,%d5.L*4),%d4	//get lword 2
+ap_n_cl:
+	movel	#28,%d3		//point to last digit
+	moveql	#7,%d2		//init digit counter
+ap_n_gd:
+	bfextu	%d4{%d3:#4},%d0	//get digit
+	bnes	ap_n_fx		//if non-zero, go to exp fix
+	subql	#4,%d3		//point to previous digit
+	addql	#1,%d1		//inc digit counter
+	dbf	%d2,ap_n_gd	//get next digit
+ap_n_fx:
+	movel	%d1,%d0		//copy counter to d0
+	movel	L_SCR1(%a6),%d1	//get adjusted exp from memory
+	subl	%d0,%d1		//subtract count from exp
+	bgts	ap_n_fm		//if still pos, go fix mantissa
+	negl	%d1		//take abs of exp and clr SE
+	movel	(%a0),%d4		//load lword 1 to d4
+	andl	#0xbfffffff,%d4	// and clr SE in d4
+	andl	#0xbfffffff,(%a0)	// and in memory
+//
+// Calculate the mantissa multiplier to compensate for the appending of
+// zeros to the mantissa.
+//
+ap_n_fm:
+	movel	#PTENRN,%a1	//get address of power-of-ten table
+	clrl	%d3		//init table index
+	fmoves	FONE,%fp1	//init fp1 to 1
+	moveql	#3,%d2		//init d2 to count bits in counter
+ap_n_el:
+	asrl	#1,%d0		//shift lsb into carry
+	bccs	ap_n_en		//if 1, mul fp1 by pwrten factor
+	fmulx	(%a1,%d3),%fp1	//mul by 10**(d3_bit_no)
+ap_n_en:
+	addl	#12,%d3		//inc d3 to next rtable entry
+	tstl	%d0		//check if d0 is zero
+	bnes	ap_n_el		//if not, get next bit
+	fdivx	%fp1,%fp0		//div mantissa by 10**(no_bits_shifted)
+//
+//
+// Calculate power-of-ten factor from adjusted and shifted exponent.
+//
+// Register usage:
+//
+//  pwrten:
+//	(*)  d0: temp
+//	( )  d1: exponent
+//	(*)  d2: {FPCR[6:5],SM,SE} as index in RTABLE; temp
+//	(*)  d3: FPCR work copy
+//	( )  d4: first word of bcd
+//	(*)  a1: RTABLE pointer
+//  calc_p:
+//	(*)  d0: temp
+//	( )  d1: exponent
+//	(*)  d3: PWRTxx table index
+//	( )  a0: pointer to working copy of bcd
+//	(*)  a1: PWRTxx pointer
+//	(*) fp1: power-of-ten accumulator
+//
+// Pwrten calculates the exponent factor in the selected rounding mode
+// according to the following table:
+//	
+//	Sign of Mant  Sign of Exp  Rounding Mode  PWRTEN Rounding Mode
+//
+//	ANY	  ANY	RN	RN
+//
+//	 +	   +	RP	RP
+//	 -	   +	RP	RM
+//	 +	   -	RP	RM
+//	 -	   -	RP	RP
+//
+//	 +	   +	RM	RM
+//	 -	   +	RM	RP
+//	 +	   -	RM	RP
+//	 -	   -	RM	RM
+//
+//	 +	   +	RZ	RM
+//	 -	   +	RZ	RM
+//	 +	   -	RZ	RP
+//	 -	   -	RZ	RP
+//
+//
+pwrten:
+	movel	USER_FPCR(%a6),%d3 //get user's FPCR
+	bfextu	%d3{#26:#2},%d2	//isolate rounding mode bits
+	movel	(%a0),%d4		//reload 1st bcd word to d4
+	asll	#2,%d2		//format d2 to be
+	bfextu	%d4{#0:#2},%d0	// {FPCR[6],FPCR[5],SM,SE}
+	addl	%d0,%d2		//in d2 as index into RTABLE
+	leal	RTABLE,%a1	//load rtable base
+	moveb	(%a1,%d2),%d0	//load new rounding bits from table
+	clrl	%d3			//clear d3 to force no exc and extended
+	bfins	%d0,%d3{#26:#2}	//stuff new rounding bits in FPCR
+	fmovel	%d3,%FPCR		//write new FPCR
+	asrl	#1,%d0		//write correct PTENxx table
+	bccs	not_rp		//to a1
+	leal	PTENRP,%a1	//it is RP
+	bras	calc_p		//go to init section
+not_rp:
+	asrl	#1,%d0		//keep checking
+	bccs	not_rm
+	leal	PTENRM,%a1	//it is RM
+	bras	calc_p		//go to init section
+not_rm:
+	leal	PTENRN,%a1	//it is RN
+calc_p:
+	movel	%d1,%d0		//copy exp to d0;use d0
+	bpls	no_neg		//if exp is negative,
+	negl	%d0		//invert it
+	orl	#0x40000000,(%a0)	//and set SE bit
+no_neg:
+	clrl	%d3		//table index
+	fmoves	FONE,%fp1	//init fp1 to 1
+e_loop:
+	asrl	#1,%d0		//shift next bit into carry
+	bccs	e_next		//if zero, skip the mul
+	fmulx	(%a1,%d3),%fp1	//mul by 10**(d3_bit_no)
+e_next:
+	addl	#12,%d3		//inc d3 to next rtable entry
+	tstl	%d0		//check if d0 is zero
+	bnes	e_loop		//not zero, continue shifting
+//
+//
+//  Check the sign of the adjusted exp and make the value in fp0 the
+//  same sign. If the exp was pos then multiply fp1*fp0;
+//  else divide fp0/fp1.
+//
+// Register Usage:
+//  norm:
+//	( )  a0: pointer to working bcd value
+//	(*) fp0: mantissa accumulator
+//	( ) fp1: scaling factor - 10**(abs(exp))
+//
+norm:
+	btst	#30,(%a0)	//test the sign of the exponent
+	beqs	mul		//if clear, go to multiply
+div:
+	fdivx	%fp1,%fp0		//exp is negative, so divide mant by exp
+	bras	end_dec
+mul:
+	fmulx	%fp1,%fp0		//exp is positive, so multiply by exp
+//
+//
+// Clean up and return with result in fp0.
+//
+// If the final mul/div in decbin incurred an inex exception,
+// it will be inex2, but will be reported as inex1 by get_op.
+//
+end_dec:
+	fmovel	%FPSR,%d0		//get status register	
+	bclrl	#inex2_bit+8,%d0	//test for inex2 and clear it
+	fmovel	%d0,%FPSR		//return status reg w/o inex2
+	beqs	no_exc		//skip this if no exc
+	orl	#inx1a_mask,USER_FPSR(%a6) //set inex1/ainex
+no_exc:
+	moveml	(%a7)+,%d2-%d5
+	rts
+	|end