/* Copyright 1991-2001 Wind River Systems, Inc. *//*modification history--------------------01c,14jul99,tdl  added FUNC / FUNC_LABEL01b,24oct96,yp   stuck in a # in USSC mailing addr so cpp will work01a,24jan95,hdn  original US Software version.*/#* * * * * * * * * *#       Filename:   EMUOPER.ASM##       Copyright (C) 1990,1991 By#       # United States Software Corporation#       # 14215 N.W. Science Park Drive#       # Portland, Oregon 97229##       This software is furnished under a license and may be used#       and copied only in accordance with the terms of such license#       and with the inclusion of the above copyright notice.#       This software or any other copies thereof may not be provided#       or otherwise made available to any other person.  No title to#       and ownership of the software is hereby transferred.##       The information in this software is subject to change without#       notice and should not be construed as a commitment by United#       States Software Corporation.##       Version:        V3.09  01/19/95 GOFAST  WRS GNU version of GF-PROT#       Released:       1 March 1991##* * * * * * * * * *#define _ASMLANGUAGE#include "vxWorks.h"#include "asm.h"	.data	.globl  FUNC(copyright_wind_river)	.long   FUNC(copyright_wind_river)	.include	"emuIncALib.s"	.text#        extrn   roundi:near,rounde:near,chkarg:near#        extrn   retnan:near,tnormal:near,renorm:near,getqn:near#        extrn   mul10:near,shiftr:near,exproc:near,exprop:near#        extrn   exret:near#DGROUP  GROUP   hwseg#CGROUP  GROUP   emuseg#hwseg   segment RW para public 'DATA'#        assume  ds:DGROUP, es:DGROUP, ss:DGROUP#        extrn   h_ctrl:word,h_stat:word,s_iptr:dword,s_memp:dword#hwseg   ends#emuseg  segment public USE32 'CODE'#        assume  cs:CGROUP__lib:#        subttl  Convert To Internal Floating-Point Format#        page# convert 16-bit or 32-bit integer to extended floating-point# input:        *eax = signed integer# output:       EP in ecx:edx:eax	.globl	witoep,wiepwitoep:					movswl	(%eax),%edx		jmp	wiep2			.globl	sitoepsitoep:					movl	(%eax),%edx	#pick up numberwiep2:	#SAVEII	movl	%esi,s_iptr		movl	%eax,s_memp	wiep:	movl	$31,%ecx	#initial sign -> cx	xorl	%eax,%eax		orl	%edx,%edx	#weed out zero	jz	liep20			jns	siep5		#if negative, set sign, negate	orl	$0x80000000,%ecx		negl	%edx		siep5:	bsrl	%edx,%esi		subl	%esi,%ecx		shll	%cl,%edx		negw	%cx			addw	$tBIAS+31,%cx		ret			# convert 64-bit integer to extended floating-point# input:        *eax = signed integer# output:       EP in ecx:edx:eax	.globl	litoeplitoep:					#SAVEII	movl	%esi,s_iptr		movl	%eax,s_memp		movl	4(%eax),%edx	#pick up number	movl	(%eax),%eax		movl	%eax,%ecx	#jump if all zero	orl	%edx,%ecx		jz	liep20			movl	$tBIAS+63,%ecx	#initial exponent -> cx	orl	%edx,%edx	#if negative, set sign, negate	jns	liep5			orl	$0x80000000,%ecx		notl	%edx			negl	%eax			sbbl	$-1,%edx		js	liep7		liep5:	decl	%ecx		#shift left until high bit = 1	addl	%eax,%eax		adcl	%edx,%edx		jns	liep5		liep7:	ret			liep20:	movl	$0x00010000,%ecx	#zero	ret			# convert 10-byte packed decimal integer to extended floating-point# input:        *eax = signed integer# output:       EP in ecx:edx:eax	.globl	pdtoeppdtoep:					movl	$9,%ecx		#set up loop counter and pointer	lea	9(%eax),%edi		xorl	%edx,%edx	#initialize mantissa	xorl	%eax,%eax					pdep3:	call	mul10		#multiply mantissa by 10	decl	%edi		#pick up next 2-digit	movb	(%edi),%bl		pushl	%ebx		#add low digit to mantissa	shrb	$4,%bl			andl	$0x0f,%ebx		addl	%ebx,%eax		adcl	$0,%edx			call	mul10		#again multiply mantissa by 10	popl	%ebx		#add high digit to mantissa	andl	$0x0f,%ebx		addl	%ebx,%eax		adcl	$0,%edx			loop	pdep3		#loop for all digits	movl	%eax,%ecx	#jump if all zero	orl	%edx,%ecx		jz	pdep20			movl	$tBIAS+63,%ecx	#initial exponent -> cxpdep5:	decl	%ecx		#shift left until high bit = 1	addl	%eax,%eax		adcl	%edx,%edx		jns	pdep5		pdep7:	movb	9(%edi),%bl	#set the sign bit	andb	$0x80,%bl		shll	$24,%ebx		orl	%ebx,%ecx		ret			pdep20:	movl	$0x00010000,%ecx	#zero	jmp	pdep7		# convert single-precision to extended floating-point# input:        *eax = single-precision# output:       EP in ecx:edx:eax	.globl	fptoepfptoep:					#SAVEII	movl	%esi,s_iptr		movl	%eax,s_memp		movl	(%eax),%edx	#pick up number	movl	%edx,%ecx	#sign, exponent to ecx	sarl	$23,%ecx		andl	$0x800000ff,%ecx		shll	$9,%edx		#mantissa -> edx:eax	xorl	%eax,%eax		cmpb	$0,%cl		#go handle zero and denormal	jz	fpep20			cmpb	$-1,%cl		#go handle INF and NaN	jz	dpep30			rcrl	$1,%edx		fpep7:	addw	$tBIAS-sBIAS,%cx	#adjust bias	ret			fpep20:	shrl	$1,%edx		#this is either zero or denormal	jz	dpep29		#   zero if mantissa = 0	orb	$denorm,h_stat		call	exprop			incl	%ecx		fpep21:	decw	%cx			addl	%edx,%edx		jns	fpep21			jmp	fpep7		# convert double-precision to extended floating-point# input:        eax -> double-precision# output:       EP in ecx:edx:eax	.globl	dptoepdptoep:					#SAVEII	movl	%esi,s_iptr		movl	%eax,s_memp		movl	4(%eax),%edx	#pick up number	movl	(%eax),%eax		movl	%edx,%ecx	#sign, exponent to ecx	sarl	$20,%ecx		andl	$0x800007ff,%ecx		shldl	$12,%eax,%edx	#mantissa -> edx:eax	shll	$11,%eax		orw	%cx,%cx			jz	dpep20			cmpw	$0x7ff,%cx		jz	dpep30			rcrl	$1,%edx		dpep7:	addw	$tBIAS-lBIAS,%cx	#adjust exponent biasdpep9:	ret			dpep30:	orl	$0x00027fff,%ecx	#this is INF or NaN	movl	%edx,%ebx	#   INF if mantissa 800..00	shrdl	$1,%ecx,%edx		orl	%eax,%ebx		jz	dpep9		nanret:	btl	$30,%edx		jc	dpep32			orw	$invop,h_stat		call	exproc			btsl	$30,%edx	dpep32:	xorl	%ebx,%ebx		ret			dpep20:	shrl	$1,%edx		#this is either zero or denormal	movl	%edx,%ebx	#   zero if mantissa = 0	orl	%eax,%ebx		jz	dpep29			orb	$denorm,h_stat		call	exprop			incl	%ecx		dpep21:	decw	%cx			addl	%eax,%eax		adcl	%edx,%edx		jns	dpep21			jmp	dpep7		dpep29:	btsl	$16,%ecx	#zero	ret			# convert extended floating-point number to internal formal# input:        EP in *ss:eax# output:       EP in ecx:edx:eax	.globl	eptoepeptoep:					movl	4(%eax),%edx	#pick up the number	movzwl	8(%eax),%ecx		movl	(%eax),%eax		addw	%cx,%cx			rcrl	$1,%ecx			jz	epe11		#tags: 10 = INF, denormal, illegal	cmpw	$0x7fff,%cx	#      01 = zero	jz	epe6			orl	%edx,%edx		jns	epe6			movl	%edx,%ebx		orl	%eax,%ebx		jz	epe6			ret			epe6:	btsl	$17,%ecx	#illegal etc	ret			epe11:	movl	%edx,%ebx	#this is zero or denormal	orl	%eax,%ebx		jnz	epe6			btsl	$16,%ecx		ret							#        subttl  Convert From Internal Floating-Point Format#        page# convert extended floating-point to 16 or 32 bit integer# input:        EP in ecx:edx:eax# output:       eax = signed integer	.globl	eptowieptowi:					movl	$15,%ebx	#integer size	jmp	epsi1			.globl	eptosieptosi:					movl	$31,%ebx	#integer sizeepsi1:	testl	$0x00020000,%ecx	#weed out specials	jnz	epsi20		epsi3:	subw	$tBIAS,%cx	#subtract the bias	cmpw	%bx,%cx		#if exponent too large, return INF	jge	epsi32			subw	$63,%cx		#here shift right	negw	%cx			call	shiftr			call	roundi		#IEEE rounding	adcl	$0,%eax			orl	%ecx,%ecx	#if negative take 2s complement	jns	epsi11			negl	%eax		epsi11:	ret			#returnepsi20:	rorl	$8,%ecx		#check for stack underflow	cmpb	$3,%ch			roll	$8,%ecx			jz	epsi80			orw	%cx,%cx		#specials, but denormals go back	jz	epsi3			jmp	epsi30		epsi32:	jg	epsi30		#overflow	addl	%edx,%edx		orl	%eax,%edx		jz	epsi34		epsi30:	orb	$invop,h_stat	#either +INF or -INF	call	exproc		epsi34:	movl	$1,%eax			movb	%bl,%cl			shll	%cl,%eax		ret			epsi80:	orb	$stacku,h_stat	#stack underflow	call	exproc			jmp	epsi34		# convert extended floating-point to 64-bit integer# input:        EP in ecx:edx:eax# output:       edx:eax = signed integer	.globl	eptolieptoli:					testl	$0x00020000,%ecx	#weed out specials	jnz	epli20		epli3:	subw	$tBIAS,%cx	#subtract the bias	cmpw	$63,%cx		#if exponent too large, return INF	je	epli32			jg	epli30			subw	$63,%cx		#here shift right	negw	%cx			call	shiftr			call	roundi		#do IEEE rounding	adcl	$0,%eax			adcl	$0,%edx			orl	%ecx,%ecx	#if negative take 2s complement	jns	epli11			notl	%edx			negl	%eax			sbbl	$-1,%edx	epli11:	ret			#returnepli20:	shldl	$16,%ecx,%ebx	#check for stack underflow	cmpb	$3,%bl			jz	epli80			orw	%cx,%cx		#specials, but denormals go back	jz	epli3			jmp	epli30		epli32:	addl	%edx,%edx	#treat 0x80000000 as special case	orl	%eax,%edx		jz	epli34		epli30:	orb	$invop,h_stat	#either +INF or -INF	call	exproc		epli34:	movl	$0x80000000,%edx		xorl	%eax,%eax		jmp	epli11		epli80:	orb	$stacku,h_stat	#stack underflow	call	exproc			jmp	epli34		# convert EP to 10-byte packed-decimal integer# input:        EP in ecx:edx:eax#               edi pointer to result area# output:       signed integer in result area	.globl	eptopdeppd20:	shldl	$16,%ecx,%ebx	#check for stack underflow	cmpb	$3,%bl			jz	eppd80			orw	%cx,%cx		#specials, but denormals go back	jz	eppd3		eppd30:	orb	$invop,h_stat	#either +INF or -INF	call	exproc		eppd34:	movl	$0xffff8000,%eax		movl	%eax,6(%edi)		movl	$6,%ecx			repz				stosb				ret			eppd80:	orb	$stacku,h_stat	#stack underflow	call	exproc			jmp	eppd34		eppd33:	subl	$9,%edi		#number too big	jmp	eppd30		eptopd:					movl	%ecx,6(%edi)	#store the sign	btl	$17,%ecx	#weed out specials	jc	eppd20		eppd3:	subw	$tBIAS+63,%cx	#subtract the bias	jge	eppd30			negw	%cx			call	shiftr			call	roundi		#do IEEE rounding	adcl	$0,%eax			adcl	$0,%edx			movl	%edx,%esi	#get the digits by dividing with 10	movl	$9,%ecx			pushl	%ebp			movl	$10,%ebp	eppd11:	xchgl	%esi,%eax		xorl	%edx,%edx		divl	%ebp			xchgl	%esi,%eax		divl	%ebp			movb	%dl,%bl			xchgl	%esi,%eax		xorl	%edx,%edx		divl	%ebp			xchgl	%esi,%eax		divl	%ebp			shlb	$4,%dl			orb	%bl,%dl			movb	%dl,(%edi)		incl	%edi			loop	eppd11			popl	%ebp			orl	%eax,%eax		jnz	eppd33			ret			# convert extended floating-point to single-precision floating-point# input:        EP in ecx:edx:eax# output:       eax = floating-point	.globl	eptofpepfp2:	shldl	$16,%ecx,%ebx	#check for stack underflow	cmpb	$3,%bl			jz	epfp38			btsl	$16,%ecx	#check zero, denormal	jc	epfp9			orw	%cx,%cx			jz	epfp3			orl	%edx,%edx		jns	epfp36			jmp	epfp30		eptofp:					testl	$0x00030000,%ecx	#jump if special value	jnz	epfp2		epfp3:	addw	$sBIAS-tBIAS,%cx	#adjust the bias	cmpw	$0,%cx		#weed out underflow and overflow	jle	epfp20			cmpw	$0x0ff,%cx		jnc	epfp32		epfp6:	addl	%edx,%edx	#shift left to delete hidden bit				epfp7:	movl	%edx,%ebx	#set rounding bits	shll	$23,%ebx		addl	$-1,%eax		adcl	%ebx,%ebx		jz	epfp71			movb	$0x80,%bl	epfp71:	rcrb	$1,%bl		epfp8:	shldl	$9,%ecx,%eax	#combine sign, exponent, mantissa	movb	%cl,%al			shldl	$23,%edx,%eax		orb	%cl,%cl		#set underflow if necessary	jnz	epfp11			testb	$underf,h_ctrl		jz	epfp13			orb	%bl,%bl			jz	epfp11		epfp13:	orb	$underf,h_stat		call	exproc		epfp11:	call	roundi		#IEEE rounding	adcl	$0,%eax			ret			epfp9:	addl	%ecx,%ecx	#return signed zero	rcrl	$1,%eax			ret			epfp20:	negw	%cx		#underflow, we return zero or denormal	jz	epfp7			cmpw	$25,%cx			jc	epfp23			movw	$25,%cx		epfp23:	xorl	%ebx,%ebx		shrdl	%cl,%edx,%ebx		shrl	%cl,%edx		xorw	%cx,%cx			orl	%ebx,%ebx		jz	epfp7			orb	$1,%dl			jmp	epfp7		epfp30:	btcl	$31,%edx	#this is NaN or INF	orl	%edx,%eax		jnz	epfp34			movw	$2*sBIAS+1,%cx		jmp	epfp7		epfp32:	orb	$overf,h_stat	#this is overflow	call	exproc			movw	$2*sBIAS,%cx		movl	$-1,%edx		jmp	epfp7		epfp38:	call	getqn			orb	$stacku,h_stat		jmp	epfp39		epfp36:	call	getqn		#this is NaN	jmp	epfp37		epfp34:	btl	$30,%edx		jc	epfp35		epfp37:	orb	$invop,h_stat	epfp39:	call	exproc			btsl	$30,%edx	epfp35:	movw	$2*sBIAS+1,%cx		addl	%edx,%edx		xorl	%ebx,%ebx		jmp	epfp8		# convert extended floating-point to double-precision floating-point# input:        EP in ecx:edx:eax# output:       edx:eax = double-precision	.globl	eptodpepdp32:	orb	$overf,h_stat	#this is overflow	call	exproc			movw	$0x7fe,%cx		movl	$-1,%edx		movl	%edx,%eax		jmp	epdp6