decbin.s

VXWORKS源代码

/* decbin.s - Motorola 68040 FP BCD/binary conversion routines (EXC) */

/* Copyright 1991-1993 Wind River Systems, Inc. */
	.data
	.globl	_copyright_wind_river
	.long	_copyright_wind_river

/*
modification history
--------------------
01e,21jul93,kdl  added .text (SPR #2372).
01d,23aug92,jcf  changed bxxx to jxx.
01c,26may92,rrr  the tree shuffle
01b,10jan92,kdl  added modification history; general cleanup.
01a,15aug91,kdl  original version, from Motorola FPSP v2.0.
*/

/*
DESCRIPTION


	__x_decbinsa 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	a6@(ETEMP).

	Output:	Exact floating-point representation of the packed bcd value.

	Saves and Modifies: D2-D5

	Speed: The program __x_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	A6@(ETEMP).

	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 __x_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 0x0100.  This will signal unimpsa that an enabled inex1
	exception occured.  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

NOMANUAL
*/

#include "fpsp040E.h"

|
|	__x_PTENRN, __x_PTENRM, and __x_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	__x_PTENRN
|	xref	__x_PTENRM
|	xref	__x_PTENRP

RTABLE:	.byte	0,0,0,0
	.byte	2,3,2,3
	.byte	2,3,3,2
	.byte	3,2,2,3

	.globl	__x_decbin
	.globl	__x_calc_e
	.globl	__x_pwrten
	.globl	__x_calc_m
	.globl	__x_norm
	.globl	__x_ap_st_z
	.globl	__x_ap_st_n
|
#define	FNIBS		7
#define	FSTRT		0
|
#define	ESTRT		4
#define	EDIGITS 	2
|
| Constants in single precision
FZERO: 	.long	0x00000000
FONE: 	.long	0x3F800000
FTEN: 	.long	0x41200000

#define	TEN		10

|

	.text

__x_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:
|
|  __x_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
|
__x_calc_e:
	movel	#EDIGITS,d2	| # of nibbles (digits) in fraction part
	movel	#ESTRT,d3	| counter to pick up digits
	lea	a6@(FP_SCR1),a0	| load tmp bcd storage address
	movel	a6@(ETEMP),a0@	| save input bcd value
	movel	a6@(ETEMP_HI),a0@(4) | save words 2 and 3
	movel	a6@(ETEMP_LO),a0@(8) | 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
	jeq 	e_pos		/* | don't negate if pos */
	negl	d1		| negate before subtracting
e_pos:
	subl	#16,d1		| sub to compensate for shift of mant
	jge 	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,a6@(L_SCR1)	| 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:
|
|  __x_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
|
__x_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 lonqword into d4
	movel	#FSTRT,d3	| counter to pick up digits
	movel	#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
	jle 	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
	jeq 	__x_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