2 * arch/alpha/lib/divide.S
4 * (C) 1995 Linus Torvalds
10 * The alpha chip doesn't provide hardware division, so we have to do it
11 * by hand. The compiler expects the functions
13 * __divqu: 64-bit unsigned long divide
14 * __remqu: 64-bit unsigned long remainder
15 * __divqs/__remqs: signed 64-bit
16 * __divlu/__remlu: unsigned 32-bit
17 * __divls/__remls: signed 32-bit
19 * These are not normal C functions: instead of the normal
20 * calling sequence, these expect their arguments in registers
21 * $24 and $25, and return the result in $27. Register $28 may
22 * be clobbered (assembly temporary), anything else must be saved.
26 * This is a rather simple bit-at-a-time algorithm: it's very good
27 * at dividing random 64-bit numbers, but the more usual case where
28 * the divisor is small is handled better by the DEC algorithm
29 * using lookup tables. This uses much less memory, though, and is
30 * nicer on the cache.. Besides, I don't know the copyright status
37 * $1 - shifted divisor
38 * $2 - modulus/quotient
40 * $23 - return address
44 * $27 - quotient/modulus
45 * $28 - compare status
48 #include <asm/export.h>
52 * Select function type and registers
61 #define DIV_ONLY(x,y...) x,##y
62 #define MOD_ONLY(x,y...)
63 #define func(x) __div##x
66 #define GETSIGN(x) xor $24,$25,x
69 #define DIV_ONLY(x,y...)
70 #define MOD_ONLY(x,y...) x,##y
71 #define func(x) __rem##x
74 #define GETSIGN(x) bis $24,$24,x
79 * For 32-bit operations, we need to extend to 64-bit
82 #define ufunction func(lu)
83 #define sfunction func(l)
84 #define LONGIFY(x) zapnot x,15,x
85 #define SLONGIFY(x) addl x,0,x
87 #define ufunction func(qu)
88 #define sfunction func(q)
112 DIV_ONLY(stq tmp2,32($30))
113 beq divisor, 9f /* div by zero */
117 * shift divisor left, using 3-bit shifts for
118 * 32-bit divides as we can't overflow. Three-bit
119 * shifts will result in looping three times less
120 * here, but can result in two loops more later.
121 * Thus using a large shift isn't worth it (and
122 * s8add pairs better than a sll..)
124 1: cmpult divisor,modulus,compare
125 s8addq divisor,$31,divisor
129 1: cmpult divisor,modulus,compare
131 addq divisor,divisor,divisor
137 /* ok, start to go right again.. */
138 2: DIV_ONLY(addq quotient,mask,tmp2)
140 cmpule divisor,modulus,compare
141 subq modulus,divisor,tmp1
142 DIV_ONLY(cmovne compare,tmp2,quotient)
143 srl divisor,1,divisor
144 cmovne compare,tmp1,modulus
151 DIV_ONLY(ldq tmp2,32($30))
155 EXPORT_SYMBOL(ufunction)
158 * Uhh.. Ugly signed division. I'd rather not have it at all, but
159 * it's needed in some circumstances. There are different ways to
160 * handle this, really. This does:
161 * -a / b = a / -b = -(a / b)
164 * which is probably not the best solution, but at least should
165 * have the property that (x/y)*y + (x%y) = x.
180 cmovlt $24,$28,$24 /* abs($24) */
184 cmovlt $25,$28,$25 /* abs($25) */
198 EXPORT_SYMBOL(sfunction)