Separated math and memory functions into their own files to limit the amount of objec...
[reactos.git] / reactos / lib / rtl / i386 / aullrem_asm.s
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * PURPOSE: Run-Time Library
5 * FILE: lib/rtl/i386/aullrem.S
6 * PROGRAMER: Alex Ionescu (alex@relsoft.net)
7 * Eric Kohl (ekohl@rz-online.de)
8 *
9 * Copyright (C) 2002 Michael Ringgaard.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 *
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 * 3. Neither the name of the project nor the names of its contributors
22 * may be used to endorse or promote products derived from this software
23 * without specific prior written permission.
24
25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES// LOSS OF USE, DATA, OR PROFITS// OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * SUCH DAMAGE.
36 */
37
38 .globl __aullrem
39
40 /* DATA ********************************************************************/
41
42 fzero:
43 .long 0 // Floating point zero
44 .long 0 // Floating point zero
45
46 __fltused:
47 .long 0x9875
48
49 .intel_syntax noprefix
50
51 /* FUNCTIONS ***************************************************************/
52
53 //
54 // ullrem - unsigned long remainder
55 //
56 // Purpose:
57 // Does a unsigned long remainder of the arguments. Arguments are
58 // not changed.
59 //
60 // Entry:
61 // Arguments are passed on the stack:
62 // 1st pushed: divisor (QWORD)
63 // 2nd pushed: dividend (QWORD)
64 //
65 // Exit:
66 // EDX:EAX contains the remainder (dividend%divisor)
67 // NOTE: this routine removes the parameters from the stack.
68 //
69 // Uses:
70 // ECX
71 //
72
73 __aullrem:
74
75 push ebx
76
77 // Set up the local stack and save the index registers. When this is done
78 // the stack frame will look as follows (assuming that the expression a%b will
79 // generate a call to ullrem(a, b)):
80 //
81 // -----------------
82 // | |
83 // |---------------|
84 // | |
85 // |--divisor (b)--|
86 // | |
87 // |---------------|
88 // | |
89 // |--dividend (a)-|
90 // | |
91 // |---------------|
92 // | return addr** |
93 // |---------------|
94 // ESP---->| EBX |
95 // -----------------
96 //
97
98 #undef DVNDLO
99 #undef DVNDHI
100 #undef DVSRLO
101 #undef DVSRHI
102 #define DVNDLO [esp + 8] // stack address of dividend (a)
103 #define DVNDHI [esp + 8] // stack address of dividend (a)
104 #define DVSRLO [esp + 16] // stack address of divisor (b)
105 #define DVSRHI [esp + 20] // stack address of divisor (b)
106
107 // Now do the divide. First look to see if the divisor is less than 4194304K.
108 // If so, then we can use a simple algorithm with word divides, otherwise
109 // things get a little more complex.
110 //
111
112 mov eax,DVSRHI // check to see if divisor < 4194304K
113 or eax,eax
114 jnz short ...L1 // nope, gotta do this the hard way
115 mov ecx,DVSRLO // load divisor
116 mov eax,DVNDHI // load high word of dividend
117 xor edx,edx
118 div ecx // edx <- remainder, eax <- quotient
119 mov eax,DVNDLO // edx:eax <- remainder:lo word of dividend
120 div ecx // edx <- final remainder
121 mov eax,edx // edx:eax <- remainder
122 xor edx,edx
123 jmp short ...L2 // restore stack and return
124
125 //
126 // Here we do it the hard way. Remember, eax contains DVSRHI
127 //
128
129 ...L1:
130 mov ecx,eax // ecx:ebx <- divisor
131 mov ebx,DVSRLO
132 mov edx,DVNDHI // edx:eax <- dividend
133 mov eax,DVNDLO
134 ...L3:
135 shr ecx,1 // shift divisor right one bit// hi bit <- 0
136 rcr ebx,1
137 shr edx,1 // shift dividend right one bit// hi bit <- 0
138 rcr eax,1
139 or ecx,ecx
140 jnz short ...L3 // loop until divisor < 4194304K
141 div ebx // now divide, ignore remainder
142
143 //
144 // We may be off by one, so to check, we will multiply the quotient
145 // by the divisor and check the result against the orignal dividend
146 // Note that we must also check for overflow, which can occur if the
147 // dividend is close to 2**64 and the quotient is off by 1.
148 //
149
150 mov ecx,eax // save a copy of quotient in ECX
151 mul dword ptr DVSRHI
152 xchg ecx,eax // put partial product in ECX, get quotient in EAX
153 mul dword ptr DVSRLO
154 add edx,ecx // EDX:EAX = QUOT * DVSR
155 jc short ...L4 // carry means Quotient is off by 1
156
157 //
158 // do long compare here between original dividend and the result of the
159 // multiply in edx:eax. If original is larger or equal, we're ok, otherwise
160 // subtract the original divisor from the result.
161 //
162
163 cmp edx,DVNDHI // compare hi words of result and original
164 ja short ...L4 // if result > original, do subtract
165 jb short ...L5 // if result < original, we're ok
166 cmp eax,DVNDLO // hi words are equal, compare lo words
167 jbe short ...L5 // if less or equal we're ok, else subtract
168 ...L4:
169 sub eax,DVSRLO // subtract divisor from result
170 sbb edx,DVSRHI
171 ...L5:
172
173 //
174 // Calculate remainder by subtracting the result from the original dividend.
175 // Since the result is already in a register, we will perform the subtract in
176 // the opposite direction and negate the result to make it positive.
177 //
178
179 sub eax,DVNDLO // subtract original dividend from result
180 sbb edx,DVNDHI
181 neg edx // and negate it
182 neg eax
183 sbb edx,0
184
185 //
186 // Just the cleanup left to do. dx:ax contains the remainder.
187 // Restore the saved registers and return.
188 //
189
190 ...L2:
191
192 pop ebx
193
194 ret 16