path: root/private/ntos/dll/i386/emload.asm

        subttl  emload.asm - FLD and FILD instructions
        page
;*******************************************************************************
;emload.asm - FLD and FILD instructions
;
;        Microsoft Confidential
;
;	 Copyright (c) Microsoft Corporation 1991
;        All Rights Reserved
;
;Purpose:
;       FLD and FILD instructions
;Inputs:
;	edi = [CURstk]
;	dseg:esi = pointer to memory operand
;
;Revision History:
;
; []	09/05/91  TP	Initial 32-bit version.
;
;*******************************************************************************


	PrevStackWrap	edi,LdStk	;Tied to PrevStackElem below

;*******
EM_ENTRY eFLDreg
eFLDreg:
;*******
;	edi = [CURstk]
;	esi = pointer to st(i) from instruction field

	PrevStackElem	edi,LdStk	;Point to receiving location
	cmp	EMSEG:[edi].bTag,bTAG_EMPTY	;Is it empty?
	jnz	FldErr
	mov	ecx,EMSEG:[esi].ExpSgn
	cmp	cl,bTAG_EMPTY
	jz	FldErr
	mov	ebx,EMSEG:[esi].lManHi
	mov	esi,EMSEG:[esi].lManLo
	mov	EMSEG:[CURstk],edi
	mov	EMSEG:[edi].lManLo,esi
	mov	EMSEG:[edi].lManHi,ebx
	mov	EMSEG:[edi].ExpSgn,ecx
	ret


;This is common code that stores a value into the stack after being loaded
;into registers by the appropriate routine.

	PrevStackWrap	edi,Load	;Tied to PrevStackElem below

FldCont:
;mantissa in ebx:esi, exp/sign in ecx
;edi = [CURstk]
	PrevStackElem	edi,Load	;Point to receiving location
	cmp	EMSEG:[edi].bTag,bTAG_EMPTY	;Is it empty?
	jnz	FldErr
	cmp	cl,bTAG_NAN		;Returning a NAN?
	jz	FldNAN
SaveStack:
	mov	EMSEG:[CURstk],edi
	mov	EMSEG:[edi].lManLo,esi
	mov	EMSEG:[edi].lManHi,ebx
	mov	EMSEG:[edi].ExpSgn,ecx
	ret

FldErr:
	or	EMSEG:[SWcc],C1		;Signal overflow
	mov	EMSEG:[CURerr],StackFlag;Kills possible denormal exception
Unsupported:
	call	ReturnIndefinite	;in emarith.asm
	jz	FldExit			;Unmasked, do nothing
	mov	EMSEG:[CURstk],edi	;Update top of stack
FldExit:
	ret

FldNAN:
;Is it a signaling NAN?
	test	ebx,1 shl 30		;Check for SNAN
	jnz	SaveStack		;If QNAN, just use it as result
	or	EMSEG:[CURerr],Invalid	;Flag the error
	or	ebx,1 shl 30		;Make it into a QNAN
	test	EMSEG:[CWmask],Invalid	;Is it masked?
	jnz	SaveStack		;If so, update with masked response
	ret


;****************
;Load Single Real
;****************

EM_ENTRY eFLD32
eFLD32:
	push	offset FldCont		;Return address
					;Fall into Load32Real
Load32Real:
;dseg:esi points to IEEE 32-bit real number
;On exit:
;	mantissa in ebx:esi, exponent in high ecx, sign in ch bit 7, tag in cl
;preserves edi.

        mov     EMSEG:[PrevDataOff],esi       ;Save operand pointer
	mov	ecx,dseg:[esi]		;Get number
	mov	ebx,ecx			;Save copy of mantissa
	shl	ebx,8			;Normalize
	shr	ecx,7			;Bring exponent down
	and	ecx,0FFH shl 16		;Look at just exponent
	mov	ch,dseg:[esi+3]		;Get sign again
	jz	short ZeroOrDenorm32	;Exponent is zero
	xor	esi,esi			;Zero out the low bits
	or	ebx,1 shl 31		;Set implied bit
	cmp	ecx,SexpMax shl 16
	jge	NANorInf		;Max exp., must be NAN or Infinity
	add	ecx,(TexpBias-SexpBias) shl 16	;Change to extended format bias
	mov	cl,bTAG_SNGL
	ret

ZeroOrDenorm32:
;Exponent is zero. Number is either zero or denormalized
	xor	esi,esi			;Zero out the low bits
	and	ebx,not (1 shl 31)	;Keep just mantissa
	jnz	Norm32
	mov	cl,bTAG_ZERO
	ret

Norm32:
	add	ecx,(TexpBias-SexpBias+1-31) shl 16	;Fix up bias
	jmp	FixDenorm


NANorInf:
;Shared by single and double real
	and	ecx,bSign shl 8		;Save only sign in ch
	or	ecx,TexpMax shl 16 + bTAG_NAN	;Max exp.
	cmp	ebx,1 shl 31		;Only 1 bit set means infinity
	jnz	@F
	or	esi,esi
	jnz	@F
	mov	cl,bTAG_INF
@@:
	ret

;****************
;Load Double Real
;****************

EM_ENTRY eFLD64
eFLD64:
	push	offset FldCont		;Return address
					;Fall into Load64Real
Load64Real:
;dseg:esi points to IEEE 64-bit real number
;On exit:
;	mantissa in ebx:esi, exponent in high ecx, sign in ch bit 7, tag in cl
;preserves edi.

        mov     EMSEG:[PrevDataOff],esi       ;Save operand pointer
	mov	ecx,dseg:[esi+4]		;Get sign, exp., and high mantissa
	mov	ebx,ecx			;Save copy of mantissa
	shr	ecx,4			;Bring exponent down
	and	ecx,7FFH shl 16		;Look at just exponent
	mov	ch,dseg:[esi+7]		;Get sign again
	mov	esi,dseg:[esi]		;Get low 32 bits of op
	jz	short ZeroOrDenorm64	;Exponent is zero
	shld	ebx,esi,31-20
	shl	esi,31-20		;Normalize
	or	ebx,1 shl 31		;Set implied bit
	cmp	ecx,DexpMax shl 16
	jge	NANorInf		;Max exp., must be NAN or Infinity
	add	ecx,(TexpBias-DexpBias) shl 16	;Change to extended format bias
SetNormTag:
	or	esi,esi			;Any bits in low half?
.erre	bTAG_VALID eq 1
.erre	bTAG_SNGL eq 0
	setnz   cl                      ;if low half==0 then cl=0 else cl=1
	ret

ZeroOrDenorm64:
;Exponent is zero. Number is either zero or denormalized
	and	ebx,0FFFFFH		;Keep just mantissa
	jnz	ShortNorm64		;Are top 20 bits zero?
	or	esi,esi			;Are low 32 bits zero too?
	jnz	LongNorm64
	mov	cl,bTAG_ZERO
	ret

LongNorm64:
	xchg	ebx,esi			;Shift up 32 bits
	sub	ecx,32 shl 16		;Correct exponent
ShortNorm64:
	add	ecx,(TexpBias-DexpBias+12-31) shl 16	;Fix up bias
FixDenorm:
	or	EMSEG:[CURerr],Denormal	;Set Denormal Exception
	bsr	edx,ebx			;Scan for MSB
;Bit number in edx ranges from 0 to 31
	mov	cl,dl
	not	cl			;Convert bit number to shift count
	shld	ebx,esi,cl
	shl	esi,cl
	shl	edx,16			;Move exp. adjustment to high end
	add	ecx,edx			;Adjust exponent
	jmp	SetNormTag


;******************
;Load Short Integer
;******************

EM_ENTRY eFILD16
eFILD16:
	push	offset FldCont		;Return address
					;Fall into Load16Int
Load16Int:
;dseg:esi points to 16-bit integer
;On exit:
;	mantissa in ebx:esi, exponent in high ecx, sign in ch bit 7, tag in cl
;preserves edi.

        mov     EMSEG:[PrevDataOff],esi       ;Save operand pointer
	mov	ax,dseg:[esi]
NormInt16:
	xor	esi,esi			;Extend with zero
	cwd				;extend sign through dx
	xor	ax,dx
	sub	ax,dx			;Take ABS() of integer
	bsr	cx,ax			;Find MSB
	jz	ZeroInt
;Bit number in cx ranges from 0 to 15
	not	ecx			;Convert to shift count
	shl	eax,cl			;Normalize
	not	ecx
.erre	TexpBias eq 0
	shl	ecx,16			;Move exponent to high half
	mov	ch,dh			;Set sign
	mov	ebx,eax			;Mantissa to ebx
	mov	cl,bTAG_SNGL
	ret

ZeroInt:
	xor	ebx,ebx
	mov	ecx,ebx
	mov	cl,bTAG_ZERO
	ret


;******************
;Load Long Integer
;******************

EM_ENTRY eFILD32
eFILD32:
	push	offset FldCont		;Return address
					;Fall into Load32Int
Load32Int:
;dseg:esi points to 32-bit integer
;On exit:
;	mantissa in ebx:esi, exponent in high ecx, sign in ch bit 7, tag in cl
;preserves edi.

        mov     EMSEG:[PrevDataOff],esi       ;Save operand pointer
	mov	eax,dseg:[esi]
	xor	esi,esi			;Extend with zero
	or	eax,eax			;It it zero?
	jz	ZeroInt
	cdq				;extend sign through edx
	xor	eax,edx
	sub	eax,edx			;Take ABS() of integer
	mov	ebx,eax			;Mantissa to ebx
;BSR uses 3 clocks/bit, so speed it up by checking the top half
;This saves 36 clocks on 386 (42 on 486sx)
;Cost is 13 clocks on 386 if high word isn't zero (5 on 486sx)
.erre	TexpBias eq 0
	xor	eax,eax			;Initialize exponent
	cmp	ebx,0FFFFH		;Upper bits zero?
	ja	@F
	shl	ebx,16
	sub	eax,16
@@:
	bsr	ecx,ebx			;Find MSB
	add	eax,ecx			;Compute expoment
	not	cl			;Convert bit number to shift count
	shl	ebx,cl			;Normalize
	shrd	ecx,eax,16		;Move exponent to high half of ecx
	mov	ch,dh			;Set sign
	mov	cl,bTAG_SNGL
	ret


;*****************
;Load Quad Integer
;*****************

EM_ENTRY eFILD64
eFILD64:
        mov     EMSEG:[PrevDataOff],esi       ;Save operand pointer
	mov	ebx,dseg:[esi+4]		;Get high 32 bits
	mov	eax,ebx			;Make copy of sign
	mov	esi,dseg:[esi]		;Get low 32 bits
	mov	ecx,ebx
	or	ecx,esi			;Is it zero?
	jz	ZeroQuad
NormQuadInt:
;Entry point from eFBLD
;eax bit 31 = sign
;ebx:esi = integer
;edi = [CURstk]
.erre	TexpBias eq 0
	mov     ax,32                   ;Initialize exponent
	or	ebx,ebx			;Check sign
	jz	LongNormInt
	jns	FindBit
	not	ebx
	neg	esi			;CY set if non-zero
	sbb	ebx,-1			;Add one if esi == 0
	jnz	FindBit			;Check for high bits zero
LongNormInt:
	xchg	ebx,esi			;Normalize 32 bits
	xor     ax,ax                   ;Reduce exponent by 32
FindBit:
;BSR uses 3 clocks/bit, so speed it up by checking the top half
;This saves 35 clocks on 386 (41 on 486sx)
;Cost is 11 clocks on 386 if high word isn't zero (4 on 486sx)
	cmp	ebx,0FFFFH		;Upper bits zero?
	ja	@F
	shld	ebx,esi,16
	shl	esi,16
	sub	eax,16
@@:
	bsr	ecx,ebx			;Find MSB
	add	eax,ecx			;Compute expoment
	not	cl			;Convert bit number to shift count
	shld	ebx,esi,cl		;Normalize
	shl	esi,cl
	mov     ecx,eax                 ;Move sign and exponent to ecx
	rol     ecx,16                  ;Swap sign and exponent halves
	or	esi,esi			;Any bits in low half?
.erre	bTAG_VALID eq 1
.erre	bTAG_SNGL eq 0
	setnz   cl                      ;if low half==0 then cl=0 else cl=1
	jmp	FldCont

ZeroQuad:
	mov	cl,bTAG_ZERO
	jmp	FldCont


;****************
;Load Temp Real
;****************

	PrevStackWrap	edi,Ld80	;Tied to PrevStackElem below

EM_ENTRY eFLD80
eFLD80:
;This is not considered an "arithmetic" operation (like all the others are),
;so SNANs do NOT cause an exception.  However, unsupported formats do.
        mov     EMSEG:[PrevDataOff],esi	;Save operand pointer
	PrevStackElem	edi,Ld80	;Point to receiving location
	cmp	EMSEG:[edi].bTag,bTAG_EMPTY	;Is it empty?
	jnz	FldErr
LoadTempReal:
	mov	ebx,dseg:[esi+4]	;Get high half of mantissa
	mov	cx,dseg:[esi+8]		;Get exponent and sign
	mov	esi,dseg:[esi]		;Get low half of mantissa
	mov	eax,ecx	
	and	ch,7FH			;Mask off sign bit
	shl	ecx,16			;Move exponent to high end
	mov	ch,ah			;Restore sign
	jz	ZeroOrDenorm80
;Check for unsupported format: unnormals (MSB not set)
	or	ebx,ebx
	jns	Unsupported
	sub	ecx,(IexpBias-TexpBias) shl 16	;Correct the bias
	cmp	ecx,TexpMax shl 16
	jge	NANorInf80
SetupTag:
	or	esi,esi			;Any bits in low half?
.erre	bTAG_VALID eq 1
.erre	bTAG_SNGL eq 0
	setnz   cl                      ;if low half==0 then cl=0 else cl=1
	jmp	SaveStack

NANorInf80:
	mov	cl,bTAG_NAN
	cmp	ebx,1 shl 31		;Only 1 bit set means infinity
	jnz	SaveStack
	or	esi,esi
	jnz	SaveStack
	mov	cl,bTAG_INF
	jmp	SaveStack

ZeroOrDenorm80:
;Exponent is zero. Number is either zero or denormalized
	or	ebx,ebx
	jnz	ShortNorm80		;Are top 32 bits zero?
	or	esi,esi			;Are low 32 bits zero too?
	jnz	LongNorm80
	mov	cl,bTAG_ZERO
	jmp	SaveStack

;This code accepts and works correctly with pseudo-denormals (MSB already set)
LongNorm80:
	xchg	ebx,esi			;Shift up 32 bits
	sub	ecx,32 shl 16		;Correct exponent
ShortNorm80:
	add	ecx,(TexpBias-IexpBias+1-31) shl 16	;Fix up bias
	bsr	edx,ebx			;Scan for MSB
;Bit number in edx ranges from 0 to 31
	mov	cl,dl
	not	cl			;Convert bit number to shift count
	shld	ebx,esi,cl
	shl	esi,cl
	shl	edx,16			;Move exp. adjustment to high end
	add	ecx,edx			;Adjust exponent
	jmp	SetUpTag