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