1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
/* $OpenBSD: __remq.S,v 1.1 2007/11/25 18:25:34 deraadt Exp $ */
/* $NetBSD: divrem.m4,v 1.5 1996/10/17 04:26:25 cgd Exp $ */
/*
* Copyright (c) 1994, 1995 Carnegie-Mellon University.
* All rights reserved.
*
* Author: Chris G. Demetriou
*
* Permission to use, copy, modify and distribute this software and
* its documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
* FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
* School of Computer Science
* Carnegie Mellon University
* Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie the
* rights to redistribute these changes.
*/
/*
* Division and remainder.
*
* The use of m4 is modeled after the sparc code, but the algorithm is
* simple binary long division.
*
* Note that the loops could probably benefit from unrolling.
*/
/*
* M4 Parameters
* __remq name of function to generate
* rem rem=div: t10 / t11 -> t12; rem=rem: t10 % t11 -> t12
* true true=true: signed; true=false: unsigned
* 64 total number of bits
*/
#include <machine/asm.h>
LEAF(__remq, 0) /* XXX */
lda sp, -64(sp)
stq t0, 0(sp)
stq t1, 8(sp)
stq t2, 16(sp)
stq t3, 24(sp)
stq t4, 32(sp)
stq t10, 40(sp)
stq t11, 48(sp)
mov zero, t12 /* Initialize result to zero */
/* Compute sign of result. If either is negative, this is easy. */
or t10, t11, t4 /* not the sign, but... */
srl t4, 64 - 1, t4 /* rather, or of high bits */
blbc t4, Ldoit /* neither negative? do it! */
mov t10, t4 /* sign follows t10. */
srl t4, 64 - 1, t4 /* make negation the low bit. */
srl t10, 64 - 1, t1 /* is t10 negative? */
blbc t1, LnegB /* no. */
/* t10 is negative; flip it. */
subq zero, t10, t10
srl t11, 64 - 1, t1 /* is t11 negative? */
blbc t1, Ldoit /* no. */
LnegB:
/* t11 is definitely negative, no matter how we got here. */
subq zero, t11, t11
Ldoit:
/* kill the special cases. */
beq t11, Ldotrap /* division by zero! */
cmpult t10, t11, t2 /* t10 < t11? */
/* t12 is already zero, from above. t10 is untouched. */
bne t2, Lret_result
cmpeq t10, t11, t2 /* t10 == t11? */
cmovne t2, 1, t12
cmovne t2, zero, t10
bne t2, Lret_result
/*
* Find out how many bits of zeros are at the beginning of the divisor.
*/
LBbits:
ldiq t3, 1 /* t1 = 0; t0 = 1<<64-1 */
mov zero, t1
sll t3, 64-1, t0
LBloop:
and t11, t0, t2 /* if bit in t11 is set, done. */
bne t2, LAbits
addq t1, 1, t1 /* increment t1, bit */
srl t0, 1, t0
cmplt t1, 64-1, t2 /* if t1 leaves one bit, done. */
bne t2, LBloop
LAbits:
beq t1, Ldodiv /* If t1 = 0, divide now. */
ldiq t3, 1 /* t0 = 1<<64-1 */
sll t3, 64-1, t0
LAloop:
and t10, t0, t2 /* if bit in t10 is set, done. */
bne t2, Ldodiv
subq t1, 1, t1 /* decrement t1, bit */
srl t0, 1, t0
bne t1, LAloop /* If t1 != 0, loop again */
Ldodiv:
sll t11, t1, t11 /* t11 <<= i */
ldiq t3, 1
sll t3, t1, t0
Ldivloop:
cmpult t10, t11, t2
or t12, t0, t3
cmoveq t2, t3, t12
subq t10, t11, t3
cmoveq t2, t3, t10
srl t0, 1, t0
srl t11, 1, t11
beq t10, Lret_result
bne t0, Ldivloop
Lret_result:
mov t10, t12
/* Check to see if we should negate it. */
subqv zero, t12, t3
cmovlbs t4, t3, t12
ldq t0, 0(sp)
ldq t1, 8(sp)
ldq t2, 16(sp)
ldq t3, 24(sp)
ldq t4, 32(sp)
ldq t10, 40(sp)
ldq t11, 48(sp)
lda sp, 64(sp)
ret zero, (t9), 1
Ldotrap:
ldiq a0, -2 /* This is the signal to SIGFPE! */
call_pal PAL_gentrap
mov zero, t10 /* so that zero will be returned */
br zero, Lret_result
END(__remq)
|
