mirror of https://github.com/acidanthera/audk.git
CryptoPkg: Add instrinsics to support building openssl3 on IA32 windows
This dependency is needed to build openssl lib with openssl3 under IA32 Windows, so added implementation for _alldiv, _aulldiv, _aullrem and _alldvrm instrinsics. Signed-off-by: Yi Li <yi1.li@intel.com> Cc: Jiewen Yao <jiewen.yao@intel.com> Cc: Xiaoyu Lu <xiaoyu1.lu@intel.com> Cc: Guomin Jiang <guomin.jiang@intel.com> Reviewed-by: Jiewen Yao <jiewen.yao@intel.com> Acked-by: Ard Biesheuvel <ardb@kernel.org> Tested-by: Ard Biesheuvel <ardb@kernel.org> Tested-by: Brian J. Johnson <brian.johnson@hpe.com> Tested-by: Kenneth Lautner <klautner@microsoft.com>
This commit is contained in:
Yi Li
mergify[bot]
parent
cea8e3b513
commit
bf1ff73c8c
|
|
@ -0,0 +1,203 @@
|
|||
;***
|
||||
;lldiv.asm - signed long divide routine
|
||||
;
|
||||
; Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
; SPDX-License-Identifier: BSD-2-Clause-Patent
|
||||
;
|
||||
;Purpose:
|
||||
; defines the signed long divide routine
|
||||
; __alldiv
|
||||
;
|
||||
;Original Implemenation: MSVC 14.29.30133
|
||||
;
|
||||
;*******************************************************************************
|
||||
.686
|
||||
.model flat,C
|
||||
.code
|
||||
|
||||
|
||||
|
||||
;***
|
||||
;lldiv - signed long divide
|
||||
;
|
||||
;Purpose:
|
||||
; Does a signed long divide of the arguments. Arguments are
|
||||
; not changed.
|
||||
;
|
||||
;Entry:
|
||||
; Arguments are passed on the stack:
|
||||
; 1st pushed: divisor (QWORD)
|
||||
; 2nd pushed: dividend (QWORD)
|
||||
;
|
||||
;Exit:
|
||||
; EDX:EAX contains the quotient (dividend/divisor)
|
||||
; NOTE: this routine removes the parameters from the stack.
|
||||
;
|
||||
;Uses:
|
||||
; ECX
|
||||
;
|
||||
;Exceptions:
|
||||
;
|
||||
;*******************************************************************************
|
||||
_alldiv PROC NEAR
|
||||
|
||||
HIWORD EQU [4] ;
|
||||
LOWORD EQU [0]
|
||||
|
||||
push edi
|
||||
push esi
|
||||
push ebx
|
||||
|
||||
; Set up the local stack and save the index registers. When this is done
|
||||
; the stack frame will look as follows (assuming that the expression a/b will
|
||||
; generate a call to lldiv(a, b)):
|
||||
;
|
||||
; -----------------
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |--divisor (b)--|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |--dividend (a)-|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | return addr** |
|
||||
; |---------------|
|
||||
; | EDI |
|
||||
; |---------------|
|
||||
; | ESI |
|
||||
; |---------------|
|
||||
; ESP---->| EBX |
|
||||
; -----------------
|
||||
;
|
||||
|
||||
DVND equ [esp + 16] ; stack address of dividend (a)
|
||||
DVSR equ [esp + 24] ; stack address of divisor (b)
|
||||
|
||||
|
||||
; Determine sign of the result (edi = 0 if result is positive, non-zero
|
||||
; otherwise) and make operands positive.
|
||||
|
||||
xor edi,edi ; result sign assumed positive
|
||||
|
||||
mov eax,HIWORD(DVND) ; hi word of a
|
||||
or eax,eax ; test to see if signed
|
||||
jge short L1 ; skip rest if a is already positive
|
||||
inc edi ; complement result sign flag
|
||||
mov edx,LOWORD(DVND) ; lo word of a
|
||||
neg eax ; make a positive
|
||||
neg edx
|
||||
sbb eax,0
|
||||
mov HIWORD(DVND),eax ; save positive value
|
||||
mov LOWORD(DVND),edx
|
||||
L1:
|
||||
mov eax,HIWORD(DVSR) ; hi word of b
|
||||
or eax,eax ; test to see if signed
|
||||
jge short L2 ; skip rest if b is already positive
|
||||
inc edi ; complement the result sign flag
|
||||
mov edx,LOWORD(DVSR) ; lo word of a
|
||||
neg eax ; make b positive
|
||||
neg edx
|
||||
sbb eax,0
|
||||
mov HIWORD(DVSR),eax ; save positive value
|
||||
mov LOWORD(DVSR),edx
|
||||
L2:
|
||||
|
||||
;
|
||||
; Now do the divide. First look to see if the divisor is less than 4194304K.
|
||||
; If so, then we can use a simple algorithm with word divides, otherwise
|
||||
; things get a little more complex.
|
||||
;
|
||||
; NOTE - eax currently contains the high order word of DVSR
|
||||
;
|
||||
|
||||
or eax,eax ; check to see if divisor < 4194304K
|
||||
jnz short L3 ; nope, gotta do this the hard way
|
||||
mov ecx,LOWORD(DVSR) ; load divisor
|
||||
mov eax,HIWORD(DVND) ; load high word of dividend
|
||||
xor edx,edx
|
||||
div ecx ; eax <- high order bits of quotient
|
||||
mov ebx,eax ; save high bits of quotient
|
||||
mov eax,LOWORD(DVND) ; edx:eax <- remainder:lo word of dividend
|
||||
div ecx ; eax <- low order bits of quotient
|
||||
mov edx,ebx ; edx:eax <- quotient
|
||||
jmp short L4 ; set sign, restore stack and return
|
||||
|
||||
;
|
||||
; Here we do it the hard way. Remember, eax contains the high word of DVSR
|
||||
;
|
||||
|
||||
L3:
|
||||
mov ebx,eax ; ebx:ecx <- divisor
|
||||
mov ecx,LOWORD(DVSR)
|
||||
mov edx,HIWORD(DVND) ; edx:eax <- dividend
|
||||
mov eax,LOWORD(DVND)
|
||||
L5:
|
||||
shr ebx,1 ; shift divisor right one bit
|
||||
rcr ecx,1
|
||||
shr edx,1 ; shift dividend right one bit
|
||||
rcr eax,1
|
||||
or ebx,ebx
|
||||
jnz short L5 ; loop until divisor < 4194304K
|
||||
div ecx ; now divide, ignore remainder
|
||||
mov esi,eax ; save quotient
|
||||
|
||||
;
|
||||
; We may be off by one, so to check, we will multiply the quotient
|
||||
; by the divisor and check the result against the orignal dividend
|
||||
; Note that we must also check for overflow, which can occur if the
|
||||
; dividend is close to 2**64 and the quotient is off by 1.
|
||||
;
|
||||
|
||||
mul dword ptr HIWORD(DVSR) ; QUOT * HIWORD(DVSR)
|
||||
mov ecx,eax
|
||||
mov eax,LOWORD(DVSR)
|
||||
mul esi ; QUOT * LOWORD(DVSR)
|
||||
add edx,ecx ; EDX:EAX = QUOT * DVSR
|
||||
jc short L6 ; carry means Quotient is off by 1
|
||||
|
||||
;
|
||||
; do long compare here between original dividend and the result of the
|
||||
; multiply in edx:eax. If original is larger or equal, we are ok, otherwise
|
||||
; subtract one (1) from the quotient.
|
||||
;
|
||||
|
||||
cmp edx,HIWORD(DVND) ; compare hi words of result and original
|
||||
ja short L6 ; if result > original, do subtract
|
||||
jb short L7 ; if result < original, we are ok
|
||||
cmp eax,LOWORD(DVND) ; hi words are equal, compare lo words
|
||||
jbe short L7 ; if less or equal we are ok, else subtract
|
||||
L6:
|
||||
dec esi ; subtract 1 from quotient
|
||||
L7:
|
||||
xor edx,edx ; edx:eax <- quotient
|
||||
mov eax,esi
|
||||
|
||||
;
|
||||
; Just the cleanup left to do. edx:eax contains the quotient. Set the sign
|
||||
; according to the save value, cleanup the stack, and return.
|
||||
;
|
||||
|
||||
L4:
|
||||
dec edi ; check to see if result is negative
|
||||
jnz short L8 ; if EDI == 0, result should be negative
|
||||
neg edx ; otherwise, negate the result
|
||||
neg eax
|
||||
sbb edx,0
|
||||
|
||||
;
|
||||
; Restore the saved registers and return.
|
||||
;
|
||||
|
||||
L8:
|
||||
pop ebx
|
||||
pop esi
|
||||
pop edi
|
||||
|
||||
ret 16
|
||||
|
||||
_alldiv ENDP
|
||||
|
||||
end
|
||||
|
|
@ -0,0 +1,157 @@
|
|||
;***
|
||||
;ulldiv.asm - unsigned long divide routine
|
||||
;
|
||||
; Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
; SPDX-License-Identifier: BSD-2-Clause-Patent
|
||||
;
|
||||
;Purpose:
|
||||
; defines the unsigned long divide routine
|
||||
; __aulldiv
|
||||
;
|
||||
;Original Implemenation: MSVC 14.29.30133
|
||||
;
|
||||
;*******************************************************************************
|
||||
.686
|
||||
.model flat,C
|
||||
.code
|
||||
|
||||
;***
|
||||
;ulldiv - unsigned long divide
|
||||
;
|
||||
;Purpose:
|
||||
; Does a unsigned long divide of the arguments. Arguments are
|
||||
; not changed.
|
||||
;
|
||||
;Entry:
|
||||
; Arguments are passed on the stack:
|
||||
; 1st pushed: divisor (QWORD)
|
||||
; 2nd pushed: dividend (QWORD)
|
||||
;
|
||||
;Exit:
|
||||
; EDX:EAX contains the quotient (dividend/divisor)
|
||||
; NOTE: this routine removes the parameters from the stack.
|
||||
;
|
||||
;Uses:
|
||||
; ECX
|
||||
;
|
||||
;Exceptions:
|
||||
;
|
||||
;*******************************************************************************
|
||||
_aulldiv PROC NEAR
|
||||
|
||||
HIWORD EQU [4] ;
|
||||
LOWORD EQU [0]
|
||||
|
||||
push ebx
|
||||
push esi
|
||||
|
||||
; Set up the local stack and save the index registers. When this is done
|
||||
; the stack frame will look as follows (assuming that the expression a/b will
|
||||
; generate a call to uldiv(a, b)):
|
||||
;
|
||||
; -----------------
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |--divisor (b)--|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |--dividend (a)-|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | return addr** |
|
||||
; |---------------|
|
||||
; | EBX |
|
||||
; |---------------|
|
||||
; ESP---->| ESI |
|
||||
; -----------------
|
||||
;
|
||||
|
||||
DVND equ [esp + 12] ; stack address of dividend (a)
|
||||
DVSR equ [esp + 20] ; stack address of divisor (b)
|
||||
|
||||
;
|
||||
; Now do the divide. First look to see if the divisor is less than 4194304K.
|
||||
; If so, then we can use a simple algorithm with word divides, otherwise
|
||||
; things get a little more complex.
|
||||
;
|
||||
|
||||
mov eax,HIWORD(DVSR) ; check to see if divisor < 4194304K
|
||||
or eax,eax
|
||||
jnz short L1 ; nope, gotta do this the hard way
|
||||
mov ecx,LOWORD(DVSR) ; load divisor
|
||||
mov eax,HIWORD(DVND) ; load high word of dividend
|
||||
xor edx,edx
|
||||
div ecx ; get high order bits of quotient
|
||||
mov ebx,eax ; save high bits of quotient
|
||||
mov eax,LOWORD(DVND) ; edx:eax <- remainder:lo word of dividend
|
||||
div ecx ; get low order bits of quotient
|
||||
mov edx,ebx ; edx:eax <- quotient hi:quotient lo
|
||||
jmp short L2 ; restore stack and return
|
||||
|
||||
;
|
||||
; Here we do it the hard way. Remember, eax contains DVSRHI
|
||||
;
|
||||
|
||||
L1:
|
||||
mov ecx,eax ; ecx:ebx <- divisor
|
||||
mov ebx,LOWORD(DVSR)
|
||||
mov edx,HIWORD(DVND) ; edx:eax <- dividend
|
||||
mov eax,LOWORD(DVND)
|
||||
L3:
|
||||
shr ecx,1 ; shift divisor right one bit; hi bit <- 0
|
||||
rcr ebx,1
|
||||
shr edx,1 ; shift dividend right one bit; hi bit <- 0
|
||||
rcr eax,1
|
||||
or ecx,ecx
|
||||
jnz short L3 ; loop until divisor < 4194304K
|
||||
div ebx ; now divide, ignore remainder
|
||||
mov esi,eax ; save quotient
|
||||
|
||||
;
|
||||
; We may be off by one, so to check, we will multiply the quotient
|
||||
; by the divisor and check the result against the original dividend
|
||||
; Note that we must also check for overflow, which can occur if the
|
||||
; dividend is close to 2**64 and the quotient is off by 1.
|
||||
;
|
||||
|
||||
mul dword ptr HIWORD(DVSR) ; QUOT * HIWORD(DVSR)
|
||||
mov ecx,eax
|
||||
mov eax,LOWORD(DVSR)
|
||||
mul esi ; QUOT * LOWORD(DVSR)
|
||||
add edx,ecx ; EDX:EAX = QUOT * DVSR
|
||||
jc short L4 ; carry means Quotient is off by 1
|
||||
|
||||
;
|
||||
; do long compare here between original dividend and the result of the
|
||||
; multiply in edx:eax. If original is larger or equal, we are ok, otherwise
|
||||
; subtract one (1) from the quotient.
|
||||
;
|
||||
|
||||
cmp edx,HIWORD(DVND) ; compare hi words of result and original
|
||||
ja short L4 ; if result > original, do subtract
|
||||
jb short L5 ; if result < original, we are ok
|
||||
cmp eax,LOWORD(DVND) ; hi words are equal, compare lo words
|
||||
jbe short L5 ; if less or equal we are ok, else subtract
|
||||
L4:
|
||||
dec esi ; subtract 1 from quotient
|
||||
L5:
|
||||
xor edx,edx ; edx:eax <- quotient
|
||||
mov eax,esi
|
||||
|
||||
;
|
||||
; Just the cleanup left to do. edx:eax contains the quotient.
|
||||
; Restore the saved registers and return.
|
||||
;
|
||||
|
||||
L2:
|
||||
|
||||
pop esi
|
||||
pop ebx
|
||||
|
||||
ret 16
|
||||
|
||||
_aulldiv ENDP
|
||||
|
||||
end
|
||||
|
|
@ -0,0 +1,184 @@
|
|||
;***
|
||||
;ulldvrm.asm - unsigned long divide and remainder routine
|
||||
;
|
||||
; Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
; SPDX-License-Identifier: BSD-2-Clause-Patent
|
||||
;
|
||||
;Purpose:
|
||||
; defines the unsigned long divide and remainder routine
|
||||
; __aulldvrm
|
||||
;
|
||||
;Original Implemenation: MSVC 14.29.30133
|
||||
;
|
||||
;*******************************************************************************
|
||||
.686
|
||||
.model flat,C
|
||||
.code
|
||||
|
||||
|
||||
;***
|
||||
;ulldvrm - unsigned long divide and remainder
|
||||
;
|
||||
;Purpose:
|
||||
; Does a unsigned long divide and remainder of the arguments. Arguments
|
||||
; are not changed.
|
||||
;
|
||||
;Entry:
|
||||
; Arguments are passed on the stack:
|
||||
; 1st pushed: divisor (QWORD)
|
||||
; 2nd pushed: dividend (QWORD)
|
||||
;
|
||||
;Exit:
|
||||
; EDX:EAX contains the quotient (dividend/divisor)
|
||||
; EBX:ECX contains the remainder (divided % divisor)
|
||||
; NOTE: this routine removes the parameters from the stack.
|
||||
;
|
||||
;Uses:
|
||||
; ECX
|
||||
;
|
||||
;Exceptions:
|
||||
;
|
||||
;*******************************************************************************
|
||||
_aulldvrm PROC NEAR
|
||||
|
||||
HIWORD EQU [4] ;
|
||||
LOWORD EQU [0]
|
||||
push esi
|
||||
|
||||
; Set up the local stack and save the index registers. When this is done
|
||||
; the stack frame will look as follows (assuming that the expression a/b will
|
||||
; generate a call to aulldvrm(a, b)):
|
||||
;
|
||||
; -----------------
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |--divisor (b)--|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |--dividend (a)-|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | return addr** |
|
||||
; |---------------|
|
||||
; ESP---->| ESI |
|
||||
; -----------------
|
||||
;
|
||||
|
||||
DVND equ [esp + 8] ; stack address of dividend (a)
|
||||
DVSR equ [esp + 16] ; stack address of divisor (b)
|
||||
|
||||
;
|
||||
; Now do the divide. First look to see if the divisor is less than 4194304K.
|
||||
; If so, then we can use a simple algorithm with word divides, otherwise
|
||||
; things get a little more complex.
|
||||
;
|
||||
|
||||
mov eax,HIWORD(DVSR) ; check to see if divisor < 4194304K
|
||||
or eax,eax
|
||||
jnz short L1 ; nope, gotta do this the hard way
|
||||
mov ecx,LOWORD(DVSR) ; load divisor
|
||||
mov eax,HIWORD(DVND) ; load high word of dividend
|
||||
xor edx,edx
|
||||
div ecx ; get high order bits of quotient
|
||||
mov ebx,eax ; save high bits of quotient
|
||||
mov eax,LOWORD(DVND) ; edx:eax <- remainder:lo word of dividend
|
||||
div ecx ; get low order bits of quotient
|
||||
mov esi,eax ; ebx:esi <- quotient
|
||||
|
||||
;
|
||||
; Now we need to do a multiply so that we can compute the remainder.
|
||||
;
|
||||
mov eax,ebx ; set up high word of quotient
|
||||
mul dword ptr LOWORD(DVSR) ; HIWORD(QUOT) * DVSR
|
||||
mov ecx,eax ; save the result in ecx
|
||||
mov eax,esi ; set up low word of quotient
|
||||
mul dword ptr LOWORD(DVSR) ; LOWORD(QUOT) * DVSR
|
||||
add edx,ecx ; EDX:EAX = QUOT * DVSR
|
||||
jmp short L2 ; complete remainder calculation
|
||||
|
||||
;
|
||||
; Here we do it the hard way. Remember, eax contains DVSRHI
|
||||
;
|
||||
|
||||
L1:
|
||||
mov ecx,eax ; ecx:ebx <- divisor
|
||||
mov ebx,LOWORD(DVSR)
|
||||
mov edx,HIWORD(DVND) ; edx:eax <- dividend
|
||||
mov eax,LOWORD(DVND)
|
||||
L3:
|
||||
shr ecx,1 ; shift divisor right one bit; hi bit <- 0
|
||||
rcr ebx,1
|
||||
shr edx,1 ; shift dividend right one bit; hi bit <- 0
|
||||
rcr eax,1
|
||||
or ecx,ecx
|
||||
jnz short L3 ; loop until divisor < 4194304K
|
||||
div ebx ; now divide, ignore remainder
|
||||
mov esi,eax ; save quotient
|
||||
|
||||
;
|
||||
; We may be off by one, so to check, we will multiply the quotient
|
||||
; by the divisor and check the result against the original dividend
|
||||
; Note that we must also check for overflow, which can occur if the
|
||||
; dividend is close to 2**64 and the quotient is off by 1.
|
||||
;
|
||||
|
||||
mul dword ptr HIWORD(DVSR) ; QUOT * HIWORD(DVSR)
|
||||
mov ecx,eax
|
||||
mov eax,LOWORD(DVSR)
|
||||
mul esi ; QUOT * LOWORD(DVSR)
|
||||
add edx,ecx ; EDX:EAX = QUOT * DVSR
|
||||
jc short L4 ; carry means Quotient is off by 1
|
||||
|
||||
;
|
||||
; do long compare here between original dividend and the result of the
|
||||
; multiply in edx:eax. If original is larger or equal, we are ok, otherwise
|
||||
; subtract one (1) from the quotient.
|
||||
;
|
||||
|
||||
cmp edx,HIWORD(DVND) ; compare hi words of result and original
|
||||
ja short L4 ; if result > original, do subtract
|
||||
jb short L5 ; if result < original, we are ok
|
||||
cmp eax,LOWORD(DVND) ; hi words are equal, compare lo words
|
||||
jbe short L5 ; if less or equal we are ok, else subtract
|
||||
L4:
|
||||
dec esi ; subtract 1 from quotient
|
||||
sub eax,LOWORD(DVSR) ; subtract divisor from result
|
||||
sbb edx,HIWORD(DVSR)
|
||||
L5:
|
||||
xor ebx,ebx ; ebx:esi <- quotient
|
||||
|
||||
L2:
|
||||
;
|
||||
; Calculate remainder by subtracting the result from the original dividend.
|
||||
; Since the result is already in a register, we will do the subtract in the
|
||||
; opposite direction and negate the result.
|
||||
;
|
||||
|
||||
sub eax,LOWORD(DVND) ; subtract dividend from result
|
||||
sbb edx,HIWORD(DVND)
|
||||
neg edx ; otherwise, negate the result
|
||||
neg eax
|
||||
sbb edx,0
|
||||
|
||||
;
|
||||
; Now we need to get the quotient into edx:eax and the remainder into ebx:ecx.
|
||||
;
|
||||
mov ecx,edx
|
||||
mov edx,ebx
|
||||
mov ebx,ecx
|
||||
mov ecx,eax
|
||||
mov eax,esi
|
||||
;
|
||||
; Just the cleanup left to do. edx:eax contains the quotient.
|
||||
; Restore the saved registers and return.
|
||||
;
|
||||
|
||||
pop esi
|
||||
|
||||
ret 16
|
||||
|
||||
_aulldvrm ENDP
|
||||
|
||||
end
|
||||
|
|
@ -0,0 +1,163 @@
|
|||
;***
|
||||
;ullrem.asm - unsigned long remainder routine
|
||||
;
|
||||
; Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
; SPDX-License-Identifier: BSD-2-Clause-Patent
|
||||
;
|
||||
;Purpose:
|
||||
; defines the unsigned long remainder routine
|
||||
; __aullrem
|
||||
;
|
||||
;Original Implemenation: MSVC 14.29.30133
|
||||
;
|
||||
;*******************************************************************************
|
||||
.686
|
||||
.model flat,C
|
||||
.code
|
||||
|
||||
|
||||
;***
|
||||
;ullrem - unsigned long remainder
|
||||
;
|
||||
;Purpose:
|
||||
; Does a unsigned long remainder of the arguments. Arguments are
|
||||
; not changed.
|
||||
;
|
||||
;Entry:
|
||||
; Arguments are passed on the stack:
|
||||
; 1st pushed: divisor (QWORD)
|
||||
; 2nd pushed: dividend (QWORD)
|
||||
;
|
||||
;Exit:
|
||||
; EDX:EAX contains the remainder (dividend%divisor)
|
||||
; NOTE: this routine removes the parameters from the stack.
|
||||
;
|
||||
;Uses:
|
||||
; ECX
|
||||
;
|
||||
;Exceptions:
|
||||
;
|
||||
;*******************************************************************************
|
||||
_aullrem PROC NEAR
|
||||
|
||||
HIWORD EQU [4] ;
|
||||
LOWORD EQU [0]
|
||||
|
||||
push ebx
|
||||
|
||||
; Set up the local stack and save the index registers. When this is done
|
||||
; the stack frame will look as follows (assuming that the expression a%b will
|
||||
; generate a call to ullrem(a, b)):
|
||||
;
|
||||
; -----------------
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |--divisor (b)--|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | |
|
||||
; |--dividend (a)-|
|
||||
; | |
|
||||
; |---------------|
|
||||
; | return addr** |
|
||||
; |---------------|
|
||||
; ESP---->| EBX |
|
||||
; -----------------
|
||||
;
|
||||
|
||||
DVND equ [esp + 8] ; stack address of dividend (a)
|
||||
DVSR equ [esp + 16] ; stack address of divisor (b)
|
||||
|
||||
; Now do the divide. First look to see if the divisor is less than 4194304K.
|
||||
; If so, then we can use a simple algorithm with word divides, otherwise
|
||||
; things get a little more complex.
|
||||
;
|
||||
|
||||
mov eax,HIWORD(DVSR) ; check to see if divisor < 4194304K
|
||||
or eax,eax
|
||||
jnz short L1 ; nope, gotta do this the hard way
|
||||
mov ecx,LOWORD(DVSR) ; load divisor
|
||||
mov eax,HIWORD(DVND) ; load high word of dividend
|
||||
xor edx,edx
|
||||
div ecx ; edx <- remainder, eax <- quotient
|
||||
mov eax,LOWORD(DVND) ; edx:eax <- remainder:lo word of dividend
|
||||
div ecx ; edx <- final remainder
|
||||
mov eax,edx ; edx:eax <- remainder
|
||||
xor edx,edx
|
||||
jmp short L2 ; restore stack and return
|
||||
|
||||
;
|
||||
; Here we do it the hard way. Remember, eax contains DVSRHI
|
||||
;
|
||||
|
||||
L1:
|
||||
mov ecx,eax ; ecx:ebx <- divisor
|
||||
mov ebx,LOWORD(DVSR)
|
||||
mov edx,HIWORD(DVND) ; edx:eax <- dividend
|
||||
mov eax,LOWORD(DVND)
|
||||
L3:
|
||||
shr ecx,1 ; shift divisor right one bit; hi bit <- 0
|
||||
rcr ebx,1
|
||||
shr edx,1 ; shift dividend right one bit; hi bit <- 0
|
||||
rcr eax,1
|
||||
or ecx,ecx
|
||||
jnz short L3 ; loop until divisor < 4194304K
|
||||
div ebx ; now divide, ignore remainder
|
||||
|
||||
;
|
||||
; We may be off by one, so to check, we will multiply the quotient
|
||||
; by the divisor and check the result against the orignal dividend
|
||||
; Note that we must also check for overflow, which can occur if the
|
||||
; dividend is close to 2**64 and the quotient is off by 1.
|
||||
;
|
||||
|
||||
mov ecx,eax ; save a copy of quotient in ECX
|
||||
mul dword ptr HIWORD(DVSR)
|
||||
xchg ecx,eax ; put partial product in ECX, get quotient in EAX
|
||||
mul dword ptr LOWORD(DVSR)
|
||||
add edx,ecx ; EDX:EAX = QUOT * DVSR
|
||||
jc short L4 ; carry means Quotient is off by 1
|
||||
|
||||
;
|
||||
; do long compare here between original dividend and the result of the
|
||||
; multiply in edx:eax. If original is larger or equal, we're ok, otherwise
|
||||
; subtract the original divisor from the result.
|
||||
;
|
||||
|
||||
cmp edx,HIWORD(DVND) ; compare hi words of result and original
|
||||
ja short L4 ; if result > original, do subtract
|
||||
jb short L5 ; if result < original, we're ok
|
||||
cmp eax,LOWORD(DVND) ; hi words are equal, compare lo words
|
||||
jbe short L5 ; if less or equal we're ok, else subtract
|
||||
L4:
|
||||
sub eax,LOWORD(DVSR) ; subtract divisor from result
|
||||
sbb edx,HIWORD(DVSR)
|
||||
L5:
|
||||
|
||||
;
|
||||
; Calculate remainder by subtracting the result from the original dividend.
|
||||
; Since the result is already in a register, we will perform the subtract in
|
||||
; the opposite direction and negate the result to make it positive.
|
||||
;
|
||||
|
||||
sub eax,LOWORD(DVND) ; subtract original dividend from result
|
||||
sbb edx,HIWORD(DVND)
|
||||
neg edx ; and negate it
|
||||
neg eax
|
||||
sbb edx,0
|
||||
|
||||
;
|
||||
; Just the cleanup left to do. dx:ax contains the remainder.
|
||||
; Restore the saved registers and return.
|
||||
;
|
||||
|
||||
L2:
|
||||
|
||||
pop ebx
|
||||
|
||||
ret 16
|
||||
|
||||
_aullrem ENDP
|
||||
|
||||
end
|
||||
|
|
@ -32,6 +32,10 @@
|
|||
Ia32/MathFtol.c | MSFT
|
||||
Ia32/MathLlmul.asm | MSFT
|
||||
Ia32/MathLlshr.asm | MSFT
|
||||
Ia32/MathUlldiv.asm | MSFT
|
||||
Ia32/MathUlldvrm.asm | MSFT
|
||||
Ia32/MathLldiv.asm | MSFT
|
||||
Ia32/MathUllrem.asm | MSFT
|
||||
|
||||
Ia32/MathLShiftS64.c | INTEL
|
||||
Ia32/MathRShiftU64.c | INTEL
|
||||
|
|
|
|||
Loading…
Reference in New Issue