util.s

VXWORKS源代码

/* util.s - Motorola 68040 FP utility routines (EXC) */

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

/*
modification history
--------------------
01f,21jul93,kdl  added .text (SPR #2372).
01e,23aug92,jcf  changed bxxx to jxx.
01d,26may92,rrr  the tree shuffle
01c,10jan92,kdl  general cleanup.
01b,17dec91,kdl	 put in changes from Motorola v3.7 (FPSP v2.1):
		 handle implied precision in __x_ovf_r_k;
		 comment-out __x_check_force routine.
01a,15aug91,kdl  original version, from Motorola FPSP v2.0;
		 changed {byte,word,long}_d{0-7} labels to avoid
		 confusion when converting to mit format.
*/

/*
DESCRIPTION


	utilsa 3.3 4/26/91

	This file contains routines used by other programs.

	__x_ovf_res: used by overflow to force the correct
		     result. __x_ovf_r_k, __x_ovf_r_x2, __x_ovf_r_x3 are
		     derivatives of this routine.
	__x_get_fline: get user's opcode word
	__x_g_dfmtou: returns the destination format.
	__x_g_opcls: returns the opclass of the float instruction.
	__x_g_rndpr: returns the rounding precision.
	__x_reg_dest: write byte, word, or long data to Dn


		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.

UTIL	idnt    2,1 Motorola 040 Floating Point Software Package

	section	8

NOMANUAL
*/

#include "fpsp040E.h"

|	xref	__x_mem_read

	.globl	__x_g_dfmtou
	.globl	__x_g_opcls
	.globl	__x_g_rndpr
	.globl	__x_get_fline
	.globl	__x_reg_dest

|
| Final result table for __x_ovf_res. Note that the negative counterparts
| are unnecessary as __x_ovf_res always returns the sign separately from
| the exponent.
|					| +inf
EXT_PINF:	.long	0x7fff0000,0x00000000,0x00000000,0x00000000
|					| largest +ext
EXT_PLRG:	.long	0x7ffe0000,0xffffffff,0xffffffff,0x00000000
|					| largest magnitude +sgl in ext
SGL_PLRG:	.long	0x407e0000,0xffffff00,0x00000000,0x00000000
|					| largest magnitude +dbl in ext
DBL_PLRG:	.long	0x43fe0000,0xffffffff,0xfffff800,0x00000000
|					| largest -ext

tblovfl:
	.long	EXT_RN
	.long	EXT_RZ
	.long	EXT_RM
	.long	EXT_RP
	.long	SGL_RN
	.long	SGL_RZ
	.long	SGL_RM
	.long	SGL_RP
	.long	DBL_RN
	.long	DBL_RZ
	.long	DBL_RM
	.long	DBL_RP
	.long	error
	.long	error
	.long	error
	.long	error

|	.globl	__x_check_force
|
| 	__x_check_force --- check the rounding precision of the instruction
|
| This entry point is used by the exception handlers.
|
| Check the CMDREG1B or CMDREG3B command word to decide the rounding
| precision of the instruction.
|
| Input:	rounding precision in	a6@(USER_FPCR).
| Output:	a6@(USER_FPCR) is possibly modified to reflect the
|		rounding precision of the instruction.
| Register Usage:	d0 is scratch register.

|__x_check_force:
|	btst	#E3,a6@(E_BYTE)		| check for nu exception
|	jeq 	e1_exc			| it is cu exception
|e3_exc:
|	movew	a6@(CMDREG3B),d0	| get the command word
|	andiw	#0x00000060,d0		| clear all bits except 6 and 5
|	cmpil	#0x00000040,d0
|	jeq 	f_sgl			| force precision is single
|	cmpil	#0x00000060,d0
|	jeq 	f_dbl			| force precision is double
|	movew	a6@(CMDREG3B),d0	| get the command word again
|	andil	#0x7f,d0		| clear all except operation
|	cmpil	#0x33,d0
|	jeq 	f_sglmd			| fsglmul or fsgldiv
|	cmpil	#0x30,d0
|	jeq 	f_sglmd
|	rts
|e1_exc:
|	movew	a6@(CMDREG1B),d0	| get command word
|	andil	#0x00000044,d0		| clear all bits except 6 and 2
|	cmpil	#0x00000040,d0
|	jeq 	f_sgl			| the instruction is force single
|	cmpil	#0x00000044,d0
|	jeq 	f_dbl			| the instruction is force double
|	movew	a6@(CMDREG1B),d0		| again get the command word
|	andil	#0x0000007f,d0		| clear all except the op code
|	cmpil	#0x00000027,d0
|	jeq 	f_sglmd			| fsglmul
|	cmpil 	#0x00000024,d0
|	jeq 	f_sglmd			| fsgldiv
|	rts
|f_sgl:
|	andib	#0x3f,a6@(fpcr_MODE)	| single precision
|	orib	#0x40,a6@(fpcr_MODE)
|	rts
|f_dbl:
|	andib	#0x3f,a6@(fpcr_MODE)
|	orib	#0x80,a6@(fpcr_MODE)
|	rts
|f_sglmd:
|	andib	#0x3f,a6@(fpcr_MODE)
|	rts

|
|	__x_ovf_r_k --- overflow result calculation
|
| This entry point is used by kernel_ex.
|
| This forces the destination precision to be extended
|
| Input:	operand in ETEMP
| Output:	a result is in ETEMP (internal extended format)
|

	.text

	.globl	__x_ovf_r_k
__x_ovf_r_k:
	lea	a6@(ETEMP),a0		| a0 points to source operand
	bclr	#sign_bit,a6@(ETEMP_EX)
	sne	a6@(ETEMP_SGN)		| convert to internal IEEE format

|
|	__x_ovf_r_x2 --- overflow result calculation
|
| This entry point used by x_ovfl.  (opclass 0 and 2)
|
| Input		a0  points to an operand in the internal extended format
| Output	a0  points to the result in the internal extended format
|
| This sets the round precision according to the user fpcr unless the
| instruction is fsgldiv or fsglmul or fsadd, fdadd, fsub, fdsub, fsmul,
| fdmul, fsdiv, fddiv, fssqrt, fsmove, fdmove, fsabs, fdabs, fsneg, fdneg.
| If the instruction is fsgldiv of fsglmul, the rounding precision must be
| extended.  If the instruction is not fsgldiv or fsglmul but a force-
| precision instruction, the rounding precision is then set to the force
| precision.

	.globl	__x_ovf_r_x2
__x_ovf_r_x2:
	btst	#E3,a6@(E_BYTE)		| check for nu exception
	jeq 	ovf_e1_exc		| it is cu exception
ovf_e3_exc:
	movew	a6@(CMDREG3B),d0	| get the command word
	andiw	#0x00000060,d0		| clear all bits except 6 and 5
	cmpil	#0x00000040,d0
	jeq 	ovff_sgl		| force precision is single
	cmpil	#0x00000060,d0
	jeq 	ovff_dbl		| force precision is double
	movew	a6@(CMDREG3B),d0	| get the command word again
	andil	#0x7f,d0		| clear all except operation
	cmpil	#0x33,d0
	jeq 	ovf_fsgl		| fsglmul or fsgldiv
	cmpil	#0x30,d0
	jeq 	ovf_fsgl
	jra 	ovf_fpcr		| instruction is none of the above
|					| use fpcr
ovf_e1_exc:
	movew	a6@(CMDREG1B),d0	| get command word
	andil	#0x00000044,d0		| clear all bits except 6 and 2
	cmpil	#0x00000040,d0
	jeq 	ovff_sgl		| the instruction is force single
	cmpil	#0x00000044,d0
	jeq 	ovff_dbl		| the instruction is force double
	movew	a6@(CMDREG1B),d0	| again get the command word
	andil	#0x0000007f,d0		| clear all except the op code
	cmpil	#0x00000027,d0
	jeq 	ovf_fsgl		| fsglmul
	cmpil 	#0x00000024,d0
	jeq 	ovf_fsgl		| fsgldiv
	jra 	ovf_fpcr		| none of the above, use fpcr
|
|
| Inst is either fsgldiv or fsglmul.  Force extended precision.
|
ovf_fsgl:
	clrl	d0
	jra 	__x_ovf_res

ovff_sgl:
	movel	#0x00000001,d0		| set single
	jra 	__x_ovf_res
ovff_dbl:
	movel	#0x00000002,d0		| set double
	jra 	__x_ovf_res
|
| The precision is in the fpcr.
|
ovf_fpcr:
	bfextu	a6@(fpcr_MODE){#0:#2},d0 | set round precision
	jra 	__x_ovf_res

|
|
|	__x_ovf_r_x3 --- overflow result calculation
|
| This entry point used by x_ovfl. (opclass 3 only)
|
| Input		a0  points to an operand in the internal extended format
| Output	a0  points to the result in the internal extended format
|
| This sets the round precision according to the destination size.
|
	.globl	__x_ovf_r_x3
__x_ovf_r_x3:
	bsrl	__x_g_dfmtou	| get dest fmt in d0{1:0}
|				| for fmovout, the destination format
|				| is the rounding precision

|
|	__x_ovf_res --- overflow result calculation
|
| Input:
|	a0 	points to operand in internal extended format
| Output:
|	a0 	points to result in internal extended format
|
	.globl	__x_ovf_res
__x_ovf_res:
	lsll	#2,d0			| move round precision to d0{3:2}
	bfextu	a6@(fpcr_MODE){#2:#2},d1 | set round mode
	orl	d1,d0			| index is fmt:mode in d0{3:0}
	lea	tblovfl,a1		| load a1 with table address
	movel	a1@(d0:w:4),a1		| use d0 as index to the table
	jmp	a1@			| go to the correct routine
|
|case DEST_FMT = EXT
|
EXT_RN:
	lea	EXT_PINF,a1		| answer is +/- infinity
	bset	#inf_bit,a6@(FPSR_CC)
	jra 	set_sign		| now go set the sign
EXT_RZ:
	lea	EXT_PLRG,a1		| answer is +/- large number
	jra 	set_sign		| now go set the sign
EXT_RM:
	tstb	a0@(LOCAL_SGN)		| if negative overflow
	jeq 	e_rm_pos
e_rm_neg:
	lea	EXT_PINF,a1		| answer is negative infinity
	orl	#neginf_mask,a6@(USER_FPSR)
	jra 	end_ovfr
e_rm_pos:
	lea	EXT_PLRG,a1		| answer is large positive number
	jra 	end_ovfr
EXT_RP:
	tstb	a0@(LOCAL_SGN)		| if negative overflow
	jeq 	e_rp_pos
e_rp_neg:
	lea	EXT_PLRG,a1		| answer is large negative number
	bset	#neg_bit,a6@(FPSR_CC)
	jra 	end_ovfr
e_rp_pos:
	lea	EXT_PINF,a1		| answer is positive infinity
	bset	#inf_bit,a6@(FPSR_CC)
	jra 	end_ovfr
|
|case DEST_FMT = DBL
|
DBL_RN:
	lea	EXT_PINF,a1		| answer is +/- infinity
	bset	#inf_bit,a6@(FPSR_CC)
	jra 	set_sign
DBL_RZ:
	lea	DBL_PLRG,a1		| answer is +/- large number
	jra 	set_sign		| now go set the sign
DBL_RM:
	tstb	a0@(LOCAL_SGN)		| if negative overflow
	jeq 	d_rm_pos
d_rm_neg:
	lea	EXT_PINF,a1		| answer is negative infinity
	orl	#neginf_mask,a6@(USER_FPSR)
	jra 	end_ovfr	| inf is same for all precisions (ext,dbl,sgl)
d_rm_pos:
	lea	DBL_PLRG,a1		| answer is large positive number
	jra 	end_ovfr
DBL_RP:
	tstb	a0@(LOCAL_SGN)		| if negative overflow
	jeq 	d_rp_pos
d_rp_neg:
	lea	DBL_PLRG,a1		| answer is large negative number
	bset	#neg_bit,a6@(FPSR_CC)
	jra 	end_ovfr
d_rp_pos:
	lea	EXT_PINF,a1		| answer is positive infinity
	bset	#inf_bit,a6@(FPSR_CC)
	jra 	end_ovfr
|
|case DEST_FMT = SGL
|
SGL_RN:
	lea	EXT_PINF,a1		| answer is +/-  infinity
	bset	#inf_bit,a6@(FPSR_CC)
	jra 	set_sign
SGL_RZ:
	lea	SGL_PLRG,a1		| anwer is +/- large number
	jra 	set_sign
SGL_RM:
	tstb	a0@(LOCAL_SGN)		| if negative overflow
	jeq 	s_rm_pos
s_rm_neg:
	lea	EXT_PINF,a1		| answer is negative infinity
	orl	#neginf_mask,a6@(USER_FPSR)
	jra 	end_ovfr
s_rm_pos:
	lea	SGL_PLRG,a1		| answer is large positive number
	jra 	end_ovfr
SGL_RP:
	tstb	a0@(LOCAL_SGN)		| if negative overflow
	jeq 	s_rp_pos
s_rp_neg:
	lea	SGL_PLRG,a1		| answer is large negative number
	bset	#neg_bit,a6@(FPSR_CC)
	jra 	end_ovfr
s_rp_pos:
	lea	EXT_PINF,a1		| answer is postive infinity
	bset	#inf_bit,a6@(FPSR_CC)
	jra 	end_ovfr

set_sign:
	tstb	a0@(LOCAL_SGN)		| if negative overflow
	jeq 	end_ovfr
neg_sign:
	bset	#neg_bit,a6@(FPSR_CC)

end_ovfr:
	movew	a1@(LOCAL_EX),a0@(LOCAL_EX) | do not overwrite sign
	movel	a1@(LOCAL_HI),a0@(LOCAL_HI)
	movel	a1@(LOCAL_LO),a0@(LOCAL_LO)
	rts


|
|	ERROR
|
error:
	rts
|
|	__x_get_fline --- get f-line opcode of interrupted instruction
|
|	Returns opcode in the low word of d0.
|
__x_get_fline:
	movel	a6@(USER_fpi),a0	| opcode address
	movel	#0,a7@-			| reserve a word on the stack
	lea	a7@(2),a1		| point to low word of temporary
	movel	#2,d0			| count
	bsrl	__x_mem_read
	movel	a7@+,d0
	rts
|
| 	__x_g_rndpr --- put rounding precision in d0{1:0}
|
|	valid return codes are:
|		00 - extended
|		01 - single
|		10 - double
|
| begin
| get rounding precision (cmdreg3b{6:5})
| begin
|  case	opclass = 011 (move out)
|	get destination format - this is the also the rounding precision
|
|  case	opclass = 0x0
|	if E3
|	    *case RndPr(from cmdreg3b{6:5} = 11  then RND_PREC = DBL
|	    *case RndPr(from cmdreg3b{6:5} = 10  then RND_PREC = SGL