xref: /openbmc/linux/arch/arm/lib/lib1funcs.S (revision 94cdda6b) 
1/*
2 * linux/arch/arm/lib/lib1funcs.S: Optimized ARM division routines
3 *
4 * Author: Nicolas Pitre <nico@fluxnic.net>
5 *   - contributed to gcc-3.4 on Sep 30, 2003
6 *   - adapted for the Linux kernel on Oct 2, 2003
7 */
8
9/* Copyright 1995, 1996, 1998, 1999, 2000, 2003 Free Software Foundation, Inc.
10
11This file is free software; you can redistribute it and/or modify it
12under the terms of the GNU General Public License as published by the
13Free Software Foundation; either version 2, or (at your option) any
14later version.
15
16In addition to the permissions in the GNU General Public License, the
17Free Software Foundation gives you unlimited permission to link the
18compiled version of this file into combinations with other programs,
19and to distribute those combinations without any restriction coming
20from the use of this file.  (The General Public License restrictions
21do apply in other respects; for example, they cover modification of
22the file, and distribution when not linked into a combine
23executable.)
24
25This file is distributed in the hope that it will be useful, but
26WITHOUT ANY WARRANTY; without even the implied warranty of
27MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
28General Public License for more details.
29
30You should have received a copy of the GNU General Public License
31along with this program; see the file COPYING.  If not, write to
32the Free Software Foundation, 59 Temple Place - Suite 330,
33Boston, MA 02111-1307, USA.  */
34
35
36#include <linux/linkage.h>
37#include <asm/assembler.h>
38#include <asm/unwind.h>
39
40.macro ARM_DIV_BODY dividend, divisor, result, curbit
41
42#if __LINUX_ARM_ARCH__ >= 5
43
44	clz	\curbit, \divisor
45	clz	\result, \dividend
46	sub	\result, \curbit, \result
47	mov	\curbit, #1
48	mov	\divisor, \divisor, lsl \result
49	mov	\curbit, \curbit, lsl \result
50	mov	\result, #0
51
52#else
53
54	@ Initially shift the divisor left 3 bits if possible,
55	@ set curbit accordingly.  This allows for curbit to be located
56	@ at the left end of each 4 bit nibbles in the division loop
57	@ to save one loop in most cases.
58	tst	\divisor, #0xe0000000
59	moveq	\divisor, \divisor, lsl #3
60	moveq	\curbit, #8
61	movne	\curbit, #1
62
63	@ Unless the divisor is very big, shift it up in multiples of
64	@ four bits, since this is the amount of unwinding in the main
65	@ division loop.  Continue shifting until the divisor is
66	@ larger than the dividend.
671:	cmp	\divisor, #0x10000000
68	cmplo	\divisor, \dividend
69	movlo	\divisor, \divisor, lsl #4
70	movlo	\curbit, \curbit, lsl #4
71	blo	1b
72
73	@ For very big divisors, we must shift it a bit at a time, or
74	@ we will be in danger of overflowing.
751:	cmp	\divisor, #0x80000000
76	cmplo	\divisor, \dividend
77	movlo	\divisor, \divisor, lsl #1
78	movlo	\curbit, \curbit, lsl #1
79	blo	1b
80
81	mov	\result, #0
82
83#endif
84
85	@ Division loop
861:	cmp	\dividend, \divisor
87	subhs	\dividend, \dividend, \divisor
88	orrhs	\result,   \result,   \curbit
89	cmp	\dividend, \divisor,  lsr #1
90	subhs	\dividend, \dividend, \divisor, lsr #1
91	orrhs	\result,   \result,   \curbit,  lsr #1
92	cmp	\dividend, \divisor,  lsr #2
93	subhs	\dividend, \dividend, \divisor, lsr #2
94	orrhs	\result,   \result,   \curbit,  lsr #2
95	cmp	\dividend, \divisor,  lsr #3
96	subhs	\dividend, \dividend, \divisor, lsr #3
97	orrhs	\result,   \result,   \curbit,  lsr #3
98	cmp	\dividend, #0			@ Early termination?
99	movnes	\curbit,   \curbit,  lsr #4	@ No, any more bits to do?
100	movne	\divisor,  \divisor, lsr #4
101	bne	1b
102
103.endm
104
105
106.macro ARM_DIV2_ORDER divisor, order
107
108#if __LINUX_ARM_ARCH__ >= 5
109
110	clz	\order, \divisor
111	rsb	\order, \order, #31
112
113#else
114
115	cmp	\divisor, #(1 << 16)
116	movhs	\divisor, \divisor, lsr #16
117	movhs	\order, #16
118	movlo	\order, #0
119
120	cmp	\divisor, #(1 << 8)
121	movhs	\divisor, \divisor, lsr #8
122	addhs	\order, \order, #8
123
124	cmp	\divisor, #(1 << 4)
125	movhs	\divisor, \divisor, lsr #4
126	addhs	\order, \order, #4
127
128	cmp	\divisor, #(1 << 2)
129	addhi	\order, \order, #3
130	addls	\order, \order, \divisor, lsr #1
131
132#endif
133
134.endm
135
136
137.macro ARM_MOD_BODY dividend, divisor, order, spare
138
139#if __LINUX_ARM_ARCH__ >= 5
140
141	clz	\order, \divisor
142	clz	\spare, \dividend
143	sub	\order, \order, \spare
144	mov	\divisor, \divisor, lsl \order
145
146#else
147
148	mov	\order, #0
149
150	@ Unless the divisor is very big, shift it up in multiples of
151	@ four bits, since this is the amount of unwinding in the main
152	@ division loop.  Continue shifting until the divisor is
153	@ larger than the dividend.
1541:	cmp	\divisor, #0x10000000
155	cmplo	\divisor, \dividend
156	movlo	\divisor, \divisor, lsl #4
157	addlo	\order, \order, #4
158	blo	1b
159
160	@ For very big divisors, we must shift it a bit at a time, or
161	@ we will be in danger of overflowing.
1621:	cmp	\divisor, #0x80000000
163	cmplo	\divisor, \dividend
164	movlo	\divisor, \divisor, lsl #1
165	addlo	\order, \order, #1
166	blo	1b
167
168#endif
169
170	@ Perform all needed substractions to keep only the reminder.
171	@ Do comparisons in batch of 4 first.
172	subs	\order, \order, #3		@ yes, 3 is intended here
173	blt	2f
174
1751:	cmp	\dividend, \divisor
176	subhs	\dividend, \dividend, \divisor
177	cmp	\dividend, \divisor,  lsr #1
178	subhs	\dividend, \dividend, \divisor, lsr #1
179	cmp	\dividend, \divisor,  lsr #2
180	subhs	\dividend, \dividend, \divisor, lsr #2
181	cmp	\dividend, \divisor,  lsr #3
182	subhs	\dividend, \dividend, \divisor, lsr #3
183	cmp	\dividend, #1
184	mov	\divisor, \divisor, lsr #4
185	subges	\order, \order, #4
186	bge	1b
187
188	tst	\order, #3
189	teqne	\dividend, #0
190	beq	5f
191
192	@ Either 1, 2 or 3 comparison/substractions are left.
1932:	cmn	\order, #2
194	blt	4f
195	beq	3f
196	cmp	\dividend, \divisor
197	subhs	\dividend, \dividend, \divisor
198	mov	\divisor,  \divisor,  lsr #1
1993:	cmp	\dividend, \divisor
200	subhs	\dividend, \dividend, \divisor
201	mov	\divisor,  \divisor,  lsr #1
2024:	cmp	\dividend, \divisor
203	subhs	\dividend, \dividend, \divisor
2045:
205.endm
206
207
208ENTRY(__udivsi3)
209ENTRY(__aeabi_uidiv)
210UNWIND(.fnstart)
211
212	subs	r2, r1, #1
213	reteq	lr
214	bcc	Ldiv0
215	cmp	r0, r1
216	bls	11f
217	tst	r1, r2
218	beq	12f
219
220	ARM_DIV_BODY r0, r1, r2, r3
221
222	mov	r0, r2
223	ret	lr
224
22511:	moveq	r0, #1
226	movne	r0, #0
227	ret	lr
228
22912:	ARM_DIV2_ORDER r1, r2
230
231	mov	r0, r0, lsr r2
232	ret	lr
233
234UNWIND(.fnend)
235ENDPROC(__udivsi3)
236ENDPROC(__aeabi_uidiv)
237
238ENTRY(__umodsi3)
239UNWIND(.fnstart)
240
241	subs	r2, r1, #1			@ compare divisor with 1
242	bcc	Ldiv0
243	cmpne	r0, r1				@ compare dividend with divisor
244	moveq   r0, #0
245	tsthi	r1, r2				@ see if divisor is power of 2
246	andeq	r0, r0, r2
247	retls	lr
248
249	ARM_MOD_BODY r0, r1, r2, r3
250
251	ret	lr
252
253UNWIND(.fnend)
254ENDPROC(__umodsi3)
255
256ENTRY(__divsi3)
257ENTRY(__aeabi_idiv)
258UNWIND(.fnstart)
259
260	cmp	r1, #0
261	eor	ip, r0, r1			@ save the sign of the result.
262	beq	Ldiv0
263	rsbmi	r1, r1, #0			@ loops below use unsigned.
264	subs	r2, r1, #1			@ division by 1 or -1 ?
265	beq	10f
266	movs	r3, r0
267	rsbmi	r3, r0, #0			@ positive dividend value
268	cmp	r3, r1
269	bls	11f
270	tst	r1, r2				@ divisor is power of 2 ?
271	beq	12f
272
273	ARM_DIV_BODY r3, r1, r0, r2
274
275	cmp	ip, #0
276	rsbmi	r0, r0, #0
277	ret	lr
278
27910:	teq	ip, r0				@ same sign ?
280	rsbmi	r0, r0, #0
281	ret	lr
282
28311:	movlo	r0, #0
284	moveq	r0, ip, asr #31
285	orreq	r0, r0, #1
286	ret	lr
287
28812:	ARM_DIV2_ORDER r1, r2
289
290	cmp	ip, #0
291	mov	r0, r3, lsr r2
292	rsbmi	r0, r0, #0
293	ret	lr
294
295UNWIND(.fnend)
296ENDPROC(__divsi3)
297ENDPROC(__aeabi_idiv)
298
299ENTRY(__modsi3)
300UNWIND(.fnstart)
301
302	cmp	r1, #0
303	beq	Ldiv0
304	rsbmi	r1, r1, #0			@ loops below use unsigned.
305	movs	ip, r0				@ preserve sign of dividend
306	rsbmi	r0, r0, #0			@ if negative make positive
307	subs	r2, r1, #1			@ compare divisor with 1
308	cmpne	r0, r1				@ compare dividend with divisor
309	moveq	r0, #0
310	tsthi	r1, r2				@ see if divisor is power of 2
311	andeq	r0, r0, r2
312	bls	10f
313
314	ARM_MOD_BODY r0, r1, r2, r3
315
31610:	cmp	ip, #0
317	rsbmi	r0, r0, #0
318	ret	lr
319
320UNWIND(.fnend)
321ENDPROC(__modsi3)
322
323#ifdef CONFIG_AEABI
324
325ENTRY(__aeabi_uidivmod)
326UNWIND(.fnstart)
327UNWIND(.save {r0, r1, ip, lr}	)
328
329	stmfd	sp!, {r0, r1, ip, lr}
330	bl	__aeabi_uidiv
331	ldmfd	sp!, {r1, r2, ip, lr}
332	mul	r3, r0, r2
333	sub	r1, r1, r3
334	ret	lr
335
336UNWIND(.fnend)
337ENDPROC(__aeabi_uidivmod)
338
339ENTRY(__aeabi_idivmod)
340UNWIND(.fnstart)
341UNWIND(.save {r0, r1, ip, lr}	)
342	stmfd	sp!, {r0, r1, ip, lr}
343	bl	__aeabi_idiv
344	ldmfd	sp!, {r1, r2, ip, lr}
345	mul	r3, r0, r2
346	sub	r1, r1, r3
347	ret	lr
348
349UNWIND(.fnend)
350ENDPROC(__aeabi_idivmod)
351
352#endif
353
354Ldiv0:
355UNWIND(.fnstart)
356UNWIND(.pad #4)
357UNWIND(.save {lr})
358	str	lr, [sp, #-8]!
359	bl	__div0
360	mov	r0, #0			@ About as wrong as it could be.
361	ldr	pc, [sp], #8
362UNWIND(.fnend)
363ENDPROC(Ldiv0)
364