aboutsummaryrefslogtreecommitdiffstats
path: root/arch/powerpc/include/asm/sfp-machine.h
diff options
context:
space:
mode:
authorKumar Gala <galak@kernel.crashing.org>2008-06-04 03:59:29 -0400
committerKumar Gala <galak@kernel.crashing.org>2008-10-01 09:40:07 -0400
commitd2b194ed820880eb19c43b9c10d9f5f30026ee54 (patch)
tree1ac21746a8c4395c7e7fd73a60202db892fe4d76 /arch/powerpc/include/asm/sfp-machine.h
parenta969e76a7101bf5f3d369563df1ca1253dd6131b (diff)
powerpc/math-emu: Use kernel generic math-emu code
The math emulation code is centered around a set of generic macros that provide the core of the emulation that are shared by the various architectures and other projects (like glibc). Each arch implements its own sfp-machine.h to specific various arch specific details. For historic reasons that are now lost the powerpc math-emu code had its own version of the common headers. This moves us to using the kernel generic version and thus getting fixes when those are updated. Also cleaned up exception/error reporting from the FP emulation functions. Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
Diffstat (limited to 'arch/powerpc/include/asm/sfp-machine.h')
-rw-r--r--arch/powerpc/include/asm/sfp-machine.h353
1 files changed, 353 insertions, 0 deletions
diff --git a/arch/powerpc/include/asm/sfp-machine.h b/arch/powerpc/include/asm/sfp-machine.h
new file mode 100644
index 000000000000..ced34f1dc8f8
--- /dev/null
+++ b/arch/powerpc/include/asm/sfp-machine.h
@@ -0,0 +1,353 @@
1/* Machine-dependent software floating-point definitions. PPC version.
2 Copyright (C) 1997 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB. If
17 not, write to the Free Software Foundation, Inc.,
18 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20 Actually, this is a PPC (32bit) version, written based on the
21 i386, sparc, and sparc64 versions, by me,
22 Peter Maydell (pmaydell@chiark.greenend.org.uk).
23 Comments are by and large also mine, although they may be inaccurate.
24
25 In picking out asm fragments I've gone with the lowest common
26 denominator, which also happens to be the hardware I have :->
27 That is, a SPARC without hardware multiply and divide.
28 */
29
30/* basic word size definitions */
31#define _FP_W_TYPE_SIZE 32
32#define _FP_W_TYPE unsigned long
33#define _FP_WS_TYPE signed long
34#define _FP_I_TYPE long
35
36#define __ll_B ((UWtype) 1 << (W_TYPE_SIZE / 2))
37#define __ll_lowpart(t) ((UWtype) (t) & (__ll_B - 1))
38#define __ll_highpart(t) ((UWtype) (t) >> (W_TYPE_SIZE / 2))
39
40/* You can optionally code some things like addition in asm. For
41 * example, i386 defines __FP_FRAC_ADD_2 as asm. If you don't
42 * then you get a fragment of C code [if you change an #ifdef 0
43 * in op-2.h] or a call to add_ssaaaa (see below).
44 * Good places to look for asm fragments to use are gcc and glibc.
45 * gcc's longlong.h is useful.
46 */
47
48/* We need to know how to multiply and divide. If the host word size
49 * is >= 2*fracbits you can use FP_MUL_MEAT_n_imm(t,R,X,Y) which
50 * codes the multiply with whatever gcc does to 'a * b'.
51 * _FP_MUL_MEAT_n_wide(t,R,X,Y,f) is used when you have an asm
52 * function that can multiply two 1W values and get a 2W result.
53 * Otherwise you're stuck with _FP_MUL_MEAT_n_hard(t,R,X,Y) which
54 * does bitshifting to avoid overflow.
55 * For division there is FP_DIV_MEAT_n_imm(t,R,X,Y,f) for word size
56 * >= 2*fracbits, where f is either _FP_DIV_HELP_imm or
57 * _FP_DIV_HELP_ldiv (see op-1.h).
58 * _FP_DIV_MEAT_udiv() is if you have asm to do 2W/1W => (1W, 1W).
59 * [GCC and glibc have longlong.h which has the asm macro udiv_qrnnd
60 * to do this.]
61 * In general, 'n' is the number of words required to hold the type,
62 * and 't' is either S, D or Q for single/double/quad.
63 * -- PMM
64 */
65/* Example: SPARC64:
66 * #define _FP_MUL_MEAT_S(R,X,Y) _FP_MUL_MEAT_1_imm(S,R,X,Y)
67 * #define _FP_MUL_MEAT_D(R,X,Y) _FP_MUL_MEAT_1_wide(D,R,X,Y,umul_ppmm)
68 * #define _FP_MUL_MEAT_Q(R,X,Y) _FP_MUL_MEAT_2_wide(Q,R,X,Y,umul_ppmm)
69 *
70 * #define _FP_DIV_MEAT_S(R,X,Y) _FP_DIV_MEAT_1_imm(S,R,X,Y,_FP_DIV_HELP_imm)
71 * #define _FP_DIV_MEAT_D(R,X,Y) _FP_DIV_MEAT_1_udiv(D,R,X,Y)
72 * #define _FP_DIV_MEAT_Q(R,X,Y) _FP_DIV_MEAT_2_udiv_64(Q,R,X,Y)
73 *
74 * Example: i386:
75 * #define _FP_MUL_MEAT_S(R,X,Y) _FP_MUL_MEAT_1_wide(S,R,X,Y,_i386_mul_32_64)
76 * #define _FP_MUL_MEAT_D(R,X,Y) _FP_MUL_MEAT_2_wide(D,R,X,Y,_i386_mul_32_64)
77 *
78 * #define _FP_DIV_MEAT_S(R,X,Y) _FP_DIV_MEAT_1_udiv(S,R,X,Y,_i386_div_64_32)
79 * #define _FP_DIV_MEAT_D(R,X,Y) _FP_DIV_MEAT_2_udiv_64(D,R,X,Y)
80 */
81
82#define _FP_MUL_MEAT_S(R,X,Y) _FP_MUL_MEAT_1_wide(_FP_WFRACBITS_S,R,X,Y,umul_ppmm)
83#define _FP_MUL_MEAT_D(R,X,Y) _FP_MUL_MEAT_2_wide(_FP_WFRACBITS_D,R,X,Y,umul_ppmm)
84
85#define _FP_DIV_MEAT_S(R,X,Y) _FP_DIV_MEAT_1_udiv(S,R,X,Y)
86#define _FP_DIV_MEAT_D(R,X,Y) _FP_DIV_MEAT_2_udiv(D,R,X,Y)
87
88/* These macros define what NaN looks like. They're supposed to expand to
89 * a comma-separated set of 32bit unsigned ints that encode NaN.
90 */
91#define _FP_NANFRAC_S ((_FP_QNANBIT_S << 1) - 1)
92#define _FP_NANFRAC_D ((_FP_QNANBIT_D << 1) - 1), -1
93#define _FP_NANFRAC_Q ((_FP_QNANBIT_Q << 1) - 1), -1, -1, -1
94#define _FP_NANSIGN_S 0
95#define _FP_NANSIGN_D 0
96#define _FP_NANSIGN_Q 0
97
98#define _FP_KEEPNANFRACP 1
99
100/* Exception flags. We use the bit positions of the appropriate bits
101 in the FPSCR, which also correspond to the FE_* bits. This makes
102 everything easier ;-). */
103#define FP_EX_INVALID (1 << (31 - 2))
104#define FP_EX_INVALID_SNAN EFLAG_VXSNAN
105#define FP_EX_INVALID_ISI EFLAG_VXISI
106#define FP_EX_INVALID_IDI EFLAG_VXIDI
107#define FP_EX_INVALID_ZDZ EFLAG_VXZDZ
108#define FP_EX_INVALID_IMZ EFLAG_VXIMZ
109#define FP_EX_OVERFLOW (1 << (31 - 3))
110#define FP_EX_UNDERFLOW (1 << (31 - 4))
111#define FP_EX_DIVZERO (1 << (31 - 5))
112#define FP_EX_INEXACT (1 << (31 - 6))
113
114/* This macro appears to be called when both X and Y are NaNs, and
115 * has to choose one and copy it to R. i386 goes for the larger of the
116 * two, sparc64 just picks Y. I don't understand this at all so I'll
117 * go with sparc64 because it's shorter :-> -- PMM
118 */
119#define _FP_CHOOSENAN(fs, wc, R, X, Y, OP) \
120 do { \
121 R##_s = Y##_s; \
122 _FP_FRAC_COPY_##wc(R,Y); \
123 R##_c = FP_CLS_NAN; \
124 } while (0)
125
126
127#include <linux/kernel.h>
128#include <linux/sched.h>
129
130#define __FPU_FPSCR (current->thread.fpscr.val)
131
132/* We only actually write to the destination register
133 * if exceptions signalled (if any) will not trap.
134 */
135#define __FPU_ENABLED_EXC \
136({ \
137 (__FPU_FPSCR >> 3) & 0x1f; \
138})
139
140#define __FPU_TRAP_P(bits) \
141 ((__FPU_ENABLED_EXC & (bits)) != 0)
142
143#define __FP_PACK_S(val,X) \
144({ int __exc = _FP_PACK_CANONICAL(S,1,X); \
145 if(!__exc || !__FPU_TRAP_P(__exc)) \
146 _FP_PACK_RAW_1_P(S,val,X); \
147 __exc; \
148})
149
150#define __FP_PACK_D(val,X) \
151 do { \
152 _FP_PACK_CANONICAL(D, 2, X); \
153 if (!FP_CUR_EXCEPTIONS || !__FPU_TRAP_P(FP_CUR_EXCEPTIONS)) \
154 _FP_PACK_RAW_2_P(D, val, X); \
155 } while (0)
156
157#define __FP_PACK_DS(val,X) \
158 do { \
159 FP_DECL_S(__X); \
160 FP_CONV(S, D, 1, 2, __X, X); \
161 _FP_PACK_CANONICAL(S, 1, __X); \
162 if (!FP_CUR_EXCEPTIONS || !__FPU_TRAP_P(FP_CUR_EXCEPTIONS)) { \
163 _FP_UNPACK_CANONICAL(S, 1, __X); \
164 FP_CONV(D, S, 2, 1, X, __X); \
165 _FP_PACK_CANONICAL(D, 2, X); \
166 if (!FP_CUR_EXCEPTIONS || !__FPU_TRAP_P(FP_CUR_EXCEPTIONS)) \
167 _FP_PACK_RAW_2_P(D, val, X); \
168 } \
169 } while (0)
170
171/* Obtain the current rounding mode. */
172#define FP_ROUNDMODE \
173({ \
174 __FPU_FPSCR & 0x3; \
175})
176
177/* the asm fragments go here: all these are taken from glibc-2.0.5's
178 * stdlib/longlong.h
179 */
180
181#include <linux/types.h>
182#include <asm/byteorder.h>
183
184/* add_ssaaaa is used in op-2.h and should be equivalent to
185 * #define add_ssaaaa(sh,sl,ah,al,bh,bl) (sh = ah+bh+ (( sl = al+bl) < al))
186 * add_ssaaaa(high_sum, low_sum, high_addend_1, low_addend_1,
187 * high_addend_2, low_addend_2) adds two UWtype integers, composed by
188 * HIGH_ADDEND_1 and LOW_ADDEND_1, and HIGH_ADDEND_2 and LOW_ADDEND_2
189 * respectively. The result is placed in HIGH_SUM and LOW_SUM. Overflow
190 * (i.e. carry out) is not stored anywhere, and is lost.
191 */
192#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
193 do { \
194 if (__builtin_constant_p (bh) && (bh) == 0) \
195 __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2" \
196 : "=r" ((USItype)(sh)), \
197 "=&r" ((USItype)(sl)) \
198 : "%r" ((USItype)(ah)), \
199 "%r" ((USItype)(al)), \
200 "rI" ((USItype)(bl))); \
201 else if (__builtin_constant_p (bh) && (bh) ==~(USItype) 0) \
202 __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2" \
203 : "=r" ((USItype)(sh)), \
204 "=&r" ((USItype)(sl)) \
205 : "%r" ((USItype)(ah)), \
206 "%r" ((USItype)(al)), \
207 "rI" ((USItype)(bl))); \
208 else \
209 __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3" \
210 : "=r" ((USItype)(sh)), \
211 "=&r" ((USItype)(sl)) \
212 : "%r" ((USItype)(ah)), \
213 "r" ((USItype)(bh)), \
214 "%r" ((USItype)(al)), \
215 "rI" ((USItype)(bl))); \
216 } while (0)
217
218/* sub_ddmmss is used in op-2.h and udivmodti4.c and should be equivalent to
219 * #define sub_ddmmss(sh, sl, ah, al, bh, bl) (sh = ah-bh - ((sl = al-bl) > al))
220 * sub_ddmmss(high_difference, low_difference, high_minuend, low_minuend,
221 * high_subtrahend, low_subtrahend) subtracts two two-word UWtype integers,
222 * composed by HIGH_MINUEND_1 and LOW_MINUEND_1, and HIGH_SUBTRAHEND_2 and
223 * LOW_SUBTRAHEND_2 respectively. The result is placed in HIGH_DIFFERENCE
224 * and LOW_DIFFERENCE. Overflow (i.e. carry out) is not stored anywhere,
225 * and is lost.
226 */
227#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
228 do { \
229 if (__builtin_constant_p (ah) && (ah) == 0) \
230 __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfze|subfze} %0,%2" \
231 : "=r" ((USItype)(sh)), \
232 "=&r" ((USItype)(sl)) \
233 : "r" ((USItype)(bh)), \
234 "rI" ((USItype)(al)), \
235 "r" ((USItype)(bl))); \
236 else if (__builtin_constant_p (ah) && (ah) ==~(USItype) 0) \
237 __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfme|subfme} %0,%2" \
238 : "=r" ((USItype)(sh)), \
239 "=&r" ((USItype)(sl)) \
240 : "r" ((USItype)(bh)), \
241 "rI" ((USItype)(al)), \
242 "r" ((USItype)(bl))); \
243 else if (__builtin_constant_p (bh) && (bh) == 0) \
244 __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{ame|addme} %0,%2" \
245 : "=r" ((USItype)(sh)), \
246 "=&r" ((USItype)(sl)) \
247 : "r" ((USItype)(ah)), \
248 "rI" ((USItype)(al)), \
249 "r" ((USItype)(bl))); \
250 else if (__builtin_constant_p (bh) && (bh) ==~(USItype) 0) \
251 __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{aze|addze} %0,%2" \
252 : "=r" ((USItype)(sh)), \
253 "=&r" ((USItype)(sl)) \
254 : "r" ((USItype)(ah)), \
255 "rI" ((USItype)(al)), \
256 "r" ((USItype)(bl))); \
257 else \
258 __asm__ ("{sf%I4|subf%I4c} %1,%5,%4\n\t{sfe|subfe} %0,%3,%2" \
259 : "=r" ((USItype)(sh)), \
260 "=&r" ((USItype)(sl)) \
261 : "r" ((USItype)(ah)), \
262 "r" ((USItype)(bh)), \
263 "rI" ((USItype)(al)), \
264 "r" ((USItype)(bl))); \
265 } while (0)
266
267/* asm fragments for mul and div */
268
269/* umul_ppmm(high_prod, low_prod, multipler, multiplicand) multiplies two
270 * UWtype integers MULTIPLER and MULTIPLICAND, and generates a two UWtype
271 * word product in HIGH_PROD and LOW_PROD.
272 */
273#define umul_ppmm(ph, pl, m0, m1) \
274 do { \
275 USItype __m0 = (m0), __m1 = (m1); \
276 __asm__ ("mulhwu %0,%1,%2" \
277 : "=r" ((USItype)(ph)) \
278 : "%r" (__m0), \
279 "r" (__m1)); \
280 (pl) = __m0 * __m1; \
281 } while (0)
282
283/* udiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
284 * denominator) divides a UDWtype, composed by the UWtype integers
285 * HIGH_NUMERATOR and LOW_NUMERATOR, by DENOMINATOR and places the quotient
286 * in QUOTIENT and the remainder in REMAINDER. HIGH_NUMERATOR must be less
287 * than DENOMINATOR for correct operation. If, in addition, the most
288 * significant bit of DENOMINATOR must be 1, then the pre-processor symbol
289 * UDIV_NEEDS_NORMALIZATION is defined to 1.
290 */
291#define udiv_qrnnd(q, r, n1, n0, d) \
292 do { \
293 UWtype __d1, __d0, __q1, __q0, __r1, __r0, __m; \
294 __d1 = __ll_highpart (d); \
295 __d0 = __ll_lowpart (d); \
296 \
297 __r1 = (n1) % __d1; \
298 __q1 = (n1) / __d1; \
299 __m = (UWtype) __q1 * __d0; \
300 __r1 = __r1 * __ll_B | __ll_highpart (n0); \
301 if (__r1 < __m) \
302 { \
303 __q1--, __r1 += (d); \
304 if (__r1 >= (d)) /* we didn't get carry when adding to __r1 */ \
305 if (__r1 < __m) \
306 __q1--, __r1 += (d); \
307 } \
308 __r1 -= __m; \
309 \
310 __r0 = __r1 % __d1; \
311 __q0 = __r1 / __d1; \
312 __m = (UWtype) __q0 * __d0; \
313 __r0 = __r0 * __ll_B | __ll_lowpart (n0); \
314 if (__r0 < __m) \
315 { \
316 __q0--, __r0 += (d); \
317 if (__r0 >= (d)) \
318 if (__r0 < __m) \
319 __q0--, __r0 += (d); \
320 } \
321 __r0 -= __m; \
322 \
323 (q) = (UWtype) __q1 * __ll_B | __q0; \
324 (r) = __r0; \
325 } while (0)
326
327#define UDIV_NEEDS_NORMALIZATION 1
328
329#define abort() \
330 return 0
331
332#ifdef __BIG_ENDIAN
333#define __BYTE_ORDER __BIG_ENDIAN
334#else
335#define __BYTE_ORDER __LITTLE_ENDIAN
336#endif
337
338/* Exception flags. */
339#define EFLAG_INVALID (1 << (31 - 2))
340#define EFLAG_OVERFLOW (1 << (31 - 3))
341#define EFLAG_UNDERFLOW (1 << (31 - 4))
342#define EFLAG_DIVZERO (1 << (31 - 5))
343#define EFLAG_INEXACT (1 << (31 - 6))
344
345#define EFLAG_VXSNAN (1 << (31 - 7))
346#define EFLAG_VXISI (1 << (31 - 8))
347#define EFLAG_VXIDI (1 << (31 - 9))
348#define EFLAG_VXZDZ (1 << (31 - 10))
349#define EFLAG_VXIMZ (1 << (31 - 11))
350#define EFLAG_VXVC (1 << (31 - 12))
351#define EFLAG_VXSOFT (1 << (31 - 21))
352#define EFLAG_VXSQRT (1 << (31 - 22))
353#define EFLAG_VXCVI (1 << (31 - 23))
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-27 13:05:01 -0500