You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
416 lines
11 KiB
416 lines
11 KiB
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
|