xref: /openbmc/linux/arch/x86/math-emu/wm_sqrt.S (revision 81e96851)
1/* SPDX-License-Identifier: GPL-2.0 */
2	.file	"wm_sqrt.S"
3/*---------------------------------------------------------------------------+
4 |  wm_sqrt.S                                                                |
5 |                                                                           |
6 | Fixed point arithmetic square root evaluation.                            |
7 |                                                                           |
8 | Copyright (C) 1992,1993,1995,1997                                         |
9 |                       W. Metzenthen, 22 Parker St, Ormond, Vic 3163,      |
10 |                       Australia.  E-mail billm@suburbia.net               |
11 |                                                                           |
12 | Call from C as:                                                           |
13 |    int wm_sqrt(FPU_REG *n, unsigned int control_word)                     |
14 |                                                                           |
15 +---------------------------------------------------------------------------*/
16
17/*---------------------------------------------------------------------------+
18 |  wm_sqrt(FPU_REG *n, unsigned int control_word)                           |
19 |    returns the square root of n in n.                                     |
20 |                                                                           |
21 |  Use Newton's method to compute the square root of a number, which must   |
22 |  be in the range  [1.0 .. 4.0),  to 64 bits accuracy.                     |
23 |  Does not check the sign or tag of the argument.                          |
24 |  Sets the exponent, but not the sign or tag of the result.                |
25 |                                                                           |
26 |  The guess is kept in %esi:%edi                                           |
27 +---------------------------------------------------------------------------*/
28
29#include "exception.h"
30#include "fpu_emu.h"
31
32
33#ifndef NON_REENTRANT_FPU
34/*	Local storage on the stack: */
35#define FPU_accum_3	-4(%ebp)	/* ms word */
36#define FPU_accum_2	-8(%ebp)
37#define FPU_accum_1	-12(%ebp)
38#define FPU_accum_0	-16(%ebp)
39
40/*
41 * The de-normalised argument:
42 *                  sq_2                  sq_1              sq_0
43 *        b b b b b b b ... b b b   b b b .... b b b   b 0 0 0 ... 0
44 *           ^ binary point here
45 */
46#define FPU_fsqrt_arg_2	-20(%ebp)	/* ms word */
47#define FPU_fsqrt_arg_1	-24(%ebp)
48#define FPU_fsqrt_arg_0	-28(%ebp)	/* ls word, at most the ms bit is set */
49
50#else
51/*	Local storage in a static area: */
52.data
53	.align 4,0
54FPU_accum_3:
55	.long	0		/* ms word */
56FPU_accum_2:
57	.long	0
58FPU_accum_1:
59	.long	0
60FPU_accum_0:
61	.long	0
62
63/* The de-normalised argument:
64                    sq_2                  sq_1              sq_0
65          b b b b b b b ... b b b   b b b .... b b b   b 0 0 0 ... 0
66             ^ binary point here
67 */
68FPU_fsqrt_arg_2:
69	.long	0		/* ms word */
70FPU_fsqrt_arg_1:
71	.long	0
72FPU_fsqrt_arg_0:
73	.long	0		/* ls word, at most the ms bit is set */
74#endif /* NON_REENTRANT_FPU */
75
76
77.text
78SYM_FUNC_START(wm_sqrt)
79	pushl	%ebp
80	movl	%esp,%ebp
81#ifndef NON_REENTRANT_FPU
82	subl	$28,%esp
83#endif /* NON_REENTRANT_FPU */
84	pushl	%esi
85	pushl	%edi
86	pushl	%ebx
87
88	movl	PARAM1,%esi
89
90	movl	SIGH(%esi),%eax
91	movl	SIGL(%esi),%ecx
92	xorl	%edx,%edx
93
94/* We use a rough linear estimate for the first guess.. */
95
96	cmpw	EXP_BIAS,EXP(%esi)
97	jnz	sqrt_arg_ge_2
98
99	shrl	$1,%eax			/* arg is in the range  [1.0 .. 2.0) */
100	rcrl	$1,%ecx
101	rcrl	$1,%edx
102
103sqrt_arg_ge_2:
104/* From here on, n is never accessed directly again until it is
105   replaced by the answer. */
106
107	movl	%eax,FPU_fsqrt_arg_2		/* ms word of n */
108	movl	%ecx,FPU_fsqrt_arg_1
109	movl	%edx,FPU_fsqrt_arg_0
110
111/* Make a linear first estimate */
112	shrl	$1,%eax
113	addl	$0x40000000,%eax
114	movl	$0xaaaaaaaa,%ecx
115	mull	%ecx
116	shll	%edx			/* max result was 7fff... */
117	testl	$0x80000000,%edx	/* but min was 3fff... */
118	jnz	sqrt_prelim_no_adjust
119
120	movl	$0x80000000,%edx	/* round up */
121
122sqrt_prelim_no_adjust:
123	movl	%edx,%esi	/* Our first guess */
124
125/* We have now computed (approx)   (2 + x) / 3, which forms the basis
126   for a few iterations of Newton's method */
127
128	movl	FPU_fsqrt_arg_2,%ecx	/* ms word */
129
130/*
131 * From our initial estimate, three iterations are enough to get us
132 * to 30 bits or so. This will then allow two iterations at better
133 * precision to complete the process.
134 */
135
136/* Compute  (g + n/g)/2  at each iteration (g is the guess). */
137	shrl	%ecx		/* Doing this first will prevent a divide */
138				/* overflow later. */
139
140	movl	%ecx,%edx	/* msw of the arg / 2 */
141	divl	%esi		/* current estimate */
142	shrl	%esi		/* divide by 2 */
143	addl	%eax,%esi	/* the new estimate */
144
145	movl	%ecx,%edx
146	divl	%esi
147	shrl	%esi
148	addl	%eax,%esi
149
150	movl	%ecx,%edx
151	divl	%esi
152	shrl	%esi
153	addl	%eax,%esi
154
155/*
156 * Now that an estimate accurate to about 30 bits has been obtained (in %esi),
157 * we improve it to 60 bits or so.
158 *
159 * The strategy from now on is to compute new estimates from
160 *      guess := guess + (n - guess^2) / (2 * guess)
161 */
162
163/* First, find the square of the guess */
164	movl	%esi,%eax
165	mull	%esi
166/* guess^2 now in %edx:%eax */
167
168	movl	FPU_fsqrt_arg_1,%ecx
169	subl	%ecx,%eax
170	movl	FPU_fsqrt_arg_2,%ecx	/* ms word of normalized n */
171	sbbl	%ecx,%edx
172	jnc	sqrt_stage_2_positive
173
174/* Subtraction gives a negative result,
175   negate the result before division. */
176	notl	%edx
177	notl	%eax
178	addl	$1,%eax
179	adcl	$0,%edx
180
181	divl	%esi
182	movl	%eax,%ecx
183
184	movl	%edx,%eax
185	divl	%esi
186	jmp	sqrt_stage_2_finish
187
188sqrt_stage_2_positive:
189	divl	%esi
190	movl	%eax,%ecx
191
192	movl	%edx,%eax
193	divl	%esi
194
195	notl	%ecx
196	notl	%eax
197	addl	$1,%eax
198	adcl	$0,%ecx
199
200sqrt_stage_2_finish:
201	sarl	$1,%ecx		/* divide by 2 */
202	rcrl	$1,%eax
203
204	/* Form the new estimate in %esi:%edi */
205	movl	%eax,%edi
206	addl	%ecx,%esi
207
208	jnz	sqrt_stage_2_done	/* result should be [1..2) */
209
210#ifdef PARANOID
211/* It should be possible to get here only if the arg is ffff....ffff */
212	cmpl	$0xffffffff,FPU_fsqrt_arg_1
213	jnz	sqrt_stage_2_error
214#endif /* PARANOID */
215
216/* The best rounded result. */
217	xorl	%eax,%eax
218	decl	%eax
219	movl	%eax,%edi
220	movl	%eax,%esi
221	movl	$0x7fffffff,%eax
222	jmp	sqrt_round_result
223
224#ifdef PARANOID
225sqrt_stage_2_error:
226	pushl	EX_INTERNAL|0x213
227	call	EXCEPTION
228#endif /* PARANOID */
229
230sqrt_stage_2_done:
231
232/* Now the square root has been computed to better than 60 bits. */
233
234/* Find the square of the guess. */
235	movl	%edi,%eax		/* ls word of guess */
236	mull	%edi
237	movl	%edx,FPU_accum_1
238
239	movl	%esi,%eax
240	mull	%esi
241	movl	%edx,FPU_accum_3
242	movl	%eax,FPU_accum_2
243
244	movl	%edi,%eax
245	mull	%esi
246	addl	%eax,FPU_accum_1
247	adcl	%edx,FPU_accum_2
248	adcl	$0,FPU_accum_3
249
250/*	movl	%esi,%eax */
251/*	mull	%edi */
252	addl	%eax,FPU_accum_1
253	adcl	%edx,FPU_accum_2
254	adcl	$0,FPU_accum_3
255
256/* guess^2 now in FPU_accum_3:FPU_accum_2:FPU_accum_1 */
257
258	movl	FPU_fsqrt_arg_0,%eax		/* get normalized n */
259	subl	%eax,FPU_accum_1
260	movl	FPU_fsqrt_arg_1,%eax
261	sbbl	%eax,FPU_accum_2
262	movl	FPU_fsqrt_arg_2,%eax		/* ms word of normalized n */
263	sbbl	%eax,FPU_accum_3
264	jnc	sqrt_stage_3_positive
265
266/* Subtraction gives a negative result,
267   negate the result before division */
268	notl	FPU_accum_1
269	notl	FPU_accum_2
270	notl	FPU_accum_3
271	addl	$1,FPU_accum_1
272	adcl	$0,FPU_accum_2
273
274#ifdef PARANOID
275	adcl	$0,FPU_accum_3	/* This must be zero */
276	jz	sqrt_stage_3_no_error
277
278sqrt_stage_3_error:
279	pushl	EX_INTERNAL|0x207
280	call	EXCEPTION
281
282sqrt_stage_3_no_error:
283#endif /* PARANOID */
284
285	movl	FPU_accum_2,%edx
286	movl	FPU_accum_1,%eax
287	divl	%esi
288	movl	%eax,%ecx
289
290	movl	%edx,%eax
291	divl	%esi
292
293	sarl	$1,%ecx		/* divide by 2 */
294	rcrl	$1,%eax
295
296	/* prepare to round the result */
297
298	addl	%ecx,%edi
299	adcl	$0,%esi
300
301	jmp	sqrt_stage_3_finished
302
303sqrt_stage_3_positive:
304	movl	FPU_accum_2,%edx
305	movl	FPU_accum_1,%eax
306	divl	%esi
307	movl	%eax,%ecx
308
309	movl	%edx,%eax
310	divl	%esi
311
312	sarl	$1,%ecx		/* divide by 2 */
313	rcrl	$1,%eax
314
315	/* prepare to round the result */
316
317	notl	%eax		/* Negate the correction term */
318	notl	%ecx
319	addl	$1,%eax
320	adcl	$0,%ecx		/* carry here ==> correction == 0 */
321	adcl	$0xffffffff,%esi
322
323	addl	%ecx,%edi
324	adcl	$0,%esi
325
326sqrt_stage_3_finished:
327
328/*
329 * The result in %esi:%edi:%esi should be good to about 90 bits here,
330 * and the rounding information here does not have sufficient accuracy
331 * in a few rare cases.
332 */
333	cmpl	$0xffffffe0,%eax
334	ja	sqrt_near_exact_x
335
336	cmpl	$0x00000020,%eax
337	jb	sqrt_near_exact
338
339	cmpl	$0x7fffffe0,%eax
340	jb	sqrt_round_result
341
342	cmpl	$0x80000020,%eax
343	jb	sqrt_get_more_precision
344
345sqrt_round_result:
346/* Set up for rounding operations */
347	movl	%eax,%edx
348	movl	%esi,%eax
349	movl	%edi,%ebx
350	movl	PARAM1,%edi
351	movw	EXP_BIAS,EXP(%edi)	/* Result is in  [1.0 .. 2.0) */
352	jmp	fpu_reg_round
353
354
355sqrt_near_exact_x:
356/* First, the estimate must be rounded up. */
357	addl	$1,%edi
358	adcl	$0,%esi
359
360sqrt_near_exact:
361/*
362 * This is an easy case because x^1/2 is monotonic.
363 * We need just find the square of our estimate, compare it
364 * with the argument, and deduce whether our estimate is
365 * above, below, or exact. We use the fact that the estimate
366 * is known to be accurate to about 90 bits.
367 */
368	movl	%edi,%eax		/* ls word of guess */
369	mull	%edi
370	movl	%edx,%ebx		/* 2nd ls word of square */
371	movl	%eax,%ecx		/* ls word of square */
372
373	movl	%edi,%eax
374	mull	%esi
375	addl	%eax,%ebx
376	addl	%eax,%ebx
377
378#ifdef PARANOID
379	cmp	$0xffffffb0,%ebx
380	jb	sqrt_near_exact_ok
381
382	cmp	$0x00000050,%ebx
383	ja	sqrt_near_exact_ok
384
385	pushl	EX_INTERNAL|0x214
386	call	EXCEPTION
387
388sqrt_near_exact_ok:
389#endif /* PARANOID */
390
391	or	%ebx,%ebx
392	js	sqrt_near_exact_small
393
394	jnz	sqrt_near_exact_large
395
396	or	%ebx,%edx
397	jnz	sqrt_near_exact_large
398
399/* Our estimate is exactly the right answer */
400	xorl	%eax,%eax
401	jmp	sqrt_round_result
402
403sqrt_near_exact_small:
404/* Our estimate is too small */
405	movl	$0x000000ff,%eax
406	jmp	sqrt_round_result
407
408sqrt_near_exact_large:
409/* Our estimate is too large, we need to decrement it */
410	subl	$1,%edi
411	sbbl	$0,%esi
412	movl	$0xffffff00,%eax
413	jmp	sqrt_round_result
414
415
416sqrt_get_more_precision:
417/* This case is almost the same as the above, except we start
418   with an extra bit of precision in the estimate. */
419	stc			/* The extra bit. */
420	rcll	$1,%edi		/* Shift the estimate left one bit */
421	rcll	$1,%esi
422
423	movl	%edi,%eax		/* ls word of guess */
424	mull	%edi
425	movl	%edx,%ebx		/* 2nd ls word of square */
426	movl	%eax,%ecx		/* ls word of square */
427
428	movl	%edi,%eax
429	mull	%esi
430	addl	%eax,%ebx
431	addl	%eax,%ebx
432
433/* Put our estimate back to its original value */
434	stc			/* The ms bit. */
435	rcrl	$1,%esi		/* Shift the estimate left one bit */
436	rcrl	$1,%edi
437
438#ifdef PARANOID
439	cmp	$0xffffff60,%ebx
440	jb	sqrt_more_prec_ok
441
442	cmp	$0x000000a0,%ebx
443	ja	sqrt_more_prec_ok
444
445	pushl	EX_INTERNAL|0x215
446	call	EXCEPTION
447
448sqrt_more_prec_ok:
449#endif /* PARANOID */
450
451	or	%ebx,%ebx
452	js	sqrt_more_prec_small
453
454	jnz	sqrt_more_prec_large
455
456	or	%ebx,%ecx
457	jnz	sqrt_more_prec_large
458
459/* Our estimate is exactly the right answer */
460	movl	$0x80000000,%eax
461	jmp	sqrt_round_result
462
463sqrt_more_prec_small:
464/* Our estimate is too small */
465	movl	$0x800000ff,%eax
466	jmp	sqrt_round_result
467
468sqrt_more_prec_large:
469/* Our estimate is too large */
470	movl	$0x7fffff00,%eax
471	jmp	sqrt_round_result
472SYM_FUNC_END(wm_sqrt)
473