|
111
|
1 /* longlong.h -- definitions for mixed size 32/64 bit arithmetic.
|
|
|
2 Copyright (C) 1991-2017 Free Software Foundation, Inc.
|
|
|
3
|
|
|
4 This file is part of the GNU C Library.
|
|
|
5
|
|
|
6 The GNU C Library is free software; you can redistribute it and/or
|
|
|
7 modify it under the terms of the GNU Lesser General Public
|
|
|
8 License as published by the Free Software Foundation; either
|
|
|
9 version 2.1 of the License, or (at your option) any later version.
|
|
|
10
|
|
|
11 In addition to the permissions in the GNU Lesser General Public
|
|
|
12 License, the Free Software Foundation gives you unlimited
|
|
|
13 permission to link the compiled version of this file into
|
|
|
14 combinations with other programs, and to distribute those
|
|
|
15 combinations without any restriction coming from the use of this
|
|
|
16 file. (The Lesser General Public License restrictions do apply in
|
|
|
17 other respects; for example, they cover modification of the file,
|
|
|
18 and distribution when not linked into a combine executable.)
|
|
|
19
|
|
|
20 The GNU C Library is distributed in the hope that it will be useful,
|
|
|
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
23 Lesser General Public License for more details.
|
|
|
24
|
|
|
25 You should have received a copy of the GNU Lesser General Public
|
|
|
26 License along with the GNU C Library; if not, see
|
|
|
27 <http://www.gnu.org/licenses/>. */
|
|
|
28
|
|
|
29 /* You have to define the following before including this file:
|
|
|
30
|
|
|
31 UWtype -- An unsigned type, default type for operations (typically a "word")
|
|
|
32 UHWtype -- An unsigned type, at least half the size of UWtype.
|
|
|
33 UDWtype -- An unsigned type, at least twice as large a UWtype
|
|
|
34 W_TYPE_SIZE -- size in bits of UWtype
|
|
|
35
|
|
|
36 UQItype -- Unsigned 8 bit type.
|
|
|
37 SItype, USItype -- Signed and unsigned 32 bit types.
|
|
|
38 DItype, UDItype -- Signed and unsigned 64 bit types.
|
|
|
39
|
|
|
40 On a 32 bit machine UWtype should typically be USItype;
|
|
|
41 on a 64 bit machine, UWtype should typically be UDItype. */
|
|
|
42
|
|
|
43 #define __BITS4 (W_TYPE_SIZE / 4)
|
|
|
44 #define __ll_B ((UWtype) 1 << (W_TYPE_SIZE / 2))
|
|
|
45 #define __ll_lowpart(t) ((UWtype) (t) & (__ll_B - 1))
|
|
|
46 #define __ll_highpart(t) ((UWtype) (t) >> (W_TYPE_SIZE / 2))
|
|
|
47
|
|
|
48 #ifndef W_TYPE_SIZE
|
|
|
49 #define W_TYPE_SIZE 32
|
|
|
50 #define UWtype USItype
|
|
|
51 #define UHWtype USItype
|
|
|
52 #define UDWtype UDItype
|
|
|
53 #endif
|
|
|
54
|
|
|
55 /* Used in glibc only. */
|
|
|
56 #ifndef attribute_hidden
|
|
|
57 #define attribute_hidden
|
|
|
58 #endif
|
|
|
59
|
|
|
60 extern const UQItype __clz_tab[256] attribute_hidden;
|
|
|
61
|
|
|
62 /* Define auxiliary asm macros.
|
|
|
63
|
|
|
64 1) umul_ppmm(high_prod, low_prod, multiplier, multiplicand) multiplies two
|
|
|
65 UWtype integers MULTIPLIER and MULTIPLICAND, and generates a two UWtype
|
|
|
66 word product in HIGH_PROD and LOW_PROD.
|
|
|
67
|
|
|
68 2) __umulsidi3(a,b) multiplies two UWtype integers A and B, and returns a
|
|
|
69 UDWtype product. This is just a variant of umul_ppmm.
|
|
|
70
|
|
|
71 3) udiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
|
|
|
72 denominator) divides a UDWtype, composed by the UWtype integers
|
|
|
73 HIGH_NUMERATOR and LOW_NUMERATOR, by DENOMINATOR and places the quotient
|
|
|
74 in QUOTIENT and the remainder in REMAINDER. HIGH_NUMERATOR must be less
|
|
|
75 than DENOMINATOR for correct operation. If, in addition, the most
|
|
|
76 significant bit of DENOMINATOR must be 1, then the pre-processor symbol
|
|
|
77 UDIV_NEEDS_NORMALIZATION is defined to 1.
|
|
|
78
|
|
|
79 4) sdiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
|
|
|
80 denominator). Like udiv_qrnnd but the numbers are signed. The quotient
|
|
|
81 is rounded towards 0.
|
|
|
82
|
|
|
83 5) count_leading_zeros(count, x) counts the number of zero-bits from the
|
|
|
84 msb to the first nonzero bit in the UWtype X. This is the number of
|
|
|
85 steps X needs to be shifted left to set the msb. Undefined for X == 0,
|
|
|
86 unless the symbol COUNT_LEADING_ZEROS_0 is defined to some value.
|
|
|
87
|
|
|
88 6) count_trailing_zeros(count, x) like count_leading_zeros, but counts
|
|
|
89 from the least significant end.
|
|
|
90
|
|
|
91 7) add_ssaaaa(high_sum, low_sum, high_addend_1, low_addend_1,
|
|
|
92 high_addend_2, low_addend_2) adds two UWtype integers, composed by
|
|
|
93 HIGH_ADDEND_1 and LOW_ADDEND_1, and HIGH_ADDEND_2 and LOW_ADDEND_2
|
|
|
94 respectively. The result is placed in HIGH_SUM and LOW_SUM. Overflow
|
|
|
95 (i.e. carry out) is not stored anywhere, and is lost.
|
|
|
96
|
|
|
97 8) sub_ddmmss(high_difference, low_difference, high_minuend, low_minuend,
|
|
|
98 high_subtrahend, low_subtrahend) subtracts two two-word UWtype integers,
|
|
|
99 composed by HIGH_MINUEND_1 and LOW_MINUEND_1, and HIGH_SUBTRAHEND_2 and
|
|
|
100 LOW_SUBTRAHEND_2 respectively. The result is placed in HIGH_DIFFERENCE
|
|
|
101 and LOW_DIFFERENCE. Overflow (i.e. carry out) is not stored anywhere,
|
|
|
102 and is lost.
|
|
|
103
|
|
|
104 If any of these macros are left undefined for a particular CPU,
|
|
|
105 C macros are used. */
|
|
|
106
|
|
|
107 /* The CPUs come in alphabetical order below.
|
|
|
108
|
|
|
109 Please add support for more CPUs here, or improve the current support
|
|
|
110 for the CPUs below!
|
|
|
111 (E.g. WE32100, IBM360.) */
|
|
|
112
|
|
|
113 #if defined (__GNUC__) && !defined (NO_ASM)
|
|
|
114
|
|
|
115 /* We sometimes need to clobber "cc" with gcc2, but that would not be
|
|
|
116 understood by gcc1. Use cpp to avoid major code duplication. */
|
|
|
117 #if __GNUC__ < 2
|
|
|
118 #define __CLOBBER_CC
|
|
|
119 #define __AND_CLOBBER_CC
|
|
|
120 #else /* __GNUC__ >= 2 */
|
|
|
121 #define __CLOBBER_CC : "cc"
|
|
|
122 #define __AND_CLOBBER_CC , "cc"
|
|
|
123 #endif /* __GNUC__ < 2 */
|
|
|
124
|
|
|
125 #if defined (__aarch64__)
|
|
|
126
|
|
|
127 #if W_TYPE_SIZE == 32
|
|
|
128 #define count_leading_zeros(COUNT, X) ((COUNT) = __builtin_clz (X))
|
|
|
129 #define count_trailing_zeros(COUNT, X) ((COUNT) = __builtin_ctz (X))
|
|
|
130 #define COUNT_LEADING_ZEROS_0 32
|
|
|
131 #endif /* W_TYPE_SIZE == 32 */
|
|
|
132
|
|
|
133 #if W_TYPE_SIZE == 64
|
|
|
134 #define count_leading_zeros(COUNT, X) ((COUNT) = __builtin_clzll (X))
|
|
|
135 #define count_trailing_zeros(COUNT, X) ((COUNT) = __builtin_ctzll (X))
|
|
|
136 #define COUNT_LEADING_ZEROS_0 64
|
|
|
137 #endif /* W_TYPE_SIZE == 64 */
|
|
|
138
|
|
|
139 #endif /* __aarch64__ */
|
|
|
140
|
|
|
141 #if defined (__alpha) && W_TYPE_SIZE == 64
|
|
|
142 /* There is a bug in g++ before version 5 that
|
|
|
143 errors on __builtin_alpha_umulh. */
|
|
|
144 #if !defined(__cplusplus) || __GNUC__ >= 5
|
|
|
145 #define umul_ppmm(ph, pl, m0, m1) \
|
|
|
146 do { \
|
|
|
147 UDItype __m0 = (m0), __m1 = (m1); \
|
|
|
148 (ph) = __builtin_alpha_umulh (__m0, __m1); \
|
|
|
149 (pl) = __m0 * __m1; \
|
|
|
150 } while (0)
|
|
|
151 #define UMUL_TIME 46
|
|
|
152 #endif /* !c++ */
|
|
|
153 #ifndef LONGLONG_STANDALONE
|
|
|
154 #define udiv_qrnnd(q, r, n1, n0, d) \
|
|
|
155 do { UDItype __r; \
|
|
|
156 (q) = __udiv_qrnnd (&__r, (n1), (n0), (d)); \
|
|
|
157 (r) = __r; \
|
|
|
158 } while (0)
|
|
|
159 extern UDItype __udiv_qrnnd (UDItype *, UDItype, UDItype, UDItype);
|
|
|
160 #define UDIV_TIME 220
|
|
|
161 #endif /* LONGLONG_STANDALONE */
|
|
|
162 #ifdef __alpha_cix__
|
|
|
163 #define count_leading_zeros(COUNT,X) ((COUNT) = __builtin_clzl (X))
|
|
|
164 #define count_trailing_zeros(COUNT,X) ((COUNT) = __builtin_ctzl (X))
|
|
|
165 #define COUNT_LEADING_ZEROS_0 64
|
|
|
166 #else
|
|
|
167 #define count_leading_zeros(COUNT,X) \
|
|
|
168 do { \
|
|
|
169 UDItype __xr = (X), __t, __a; \
|
|
|
170 __t = __builtin_alpha_cmpbge (0, __xr); \
|
|
|
171 __a = __clz_tab[__t ^ 0xff] - 1; \
|
|
|
172 __t = __builtin_alpha_extbl (__xr, __a); \
|
|
|
173 (COUNT) = 64 - (__clz_tab[__t] + __a*8); \
|
|
|
174 } while (0)
|
|
|
175 #define count_trailing_zeros(COUNT,X) \
|
|
|
176 do { \
|
|
|
177 UDItype __xr = (X), __t, __a; \
|
|
|
178 __t = __builtin_alpha_cmpbge (0, __xr); \
|
|
|
179 __t = ~__t & -~__t; \
|
|
|
180 __a = ((__t & 0xCC) != 0) * 2; \
|
|
|
181 __a += ((__t & 0xF0) != 0) * 4; \
|
|
|
182 __a += ((__t & 0xAA) != 0); \
|
|
|
183 __t = __builtin_alpha_extbl (__xr, __a); \
|
|
|
184 __a <<= 3; \
|
|
|
185 __t &= -__t; \
|
|
|
186 __a += ((__t & 0xCC) != 0) * 2; \
|
|
|
187 __a += ((__t & 0xF0) != 0) * 4; \
|
|
|
188 __a += ((__t & 0xAA) != 0); \
|
|
|
189 (COUNT) = __a; \
|
|
|
190 } while (0)
|
|
|
191 #endif /* __alpha_cix__ */
|
|
|
192 #endif /* __alpha */
|
|
|
193
|
|
|
194 #if defined (__arc__) && W_TYPE_SIZE == 32
|
|
|
195 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
196 __asm__ ("add.f %1, %4, %5\n\tadc %0, %2, %3" \
|
|
|
197 : "=r" ((USItype) (sh)), \
|
|
|
198 "=&r" ((USItype) (sl)) \
|
|
|
199 : "%r" ((USItype) (ah)), \
|
|
|
200 "rICal" ((USItype) (bh)), \
|
|
|
201 "%r" ((USItype) (al)), \
|
|
|
202 "rICal" ((USItype) (bl)))
|
|
|
203 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
204 __asm__ ("sub.f %1, %4, %5\n\tsbc %0, %2, %3" \
|
|
|
205 : "=r" ((USItype) (sh)), \
|
|
|
206 "=&r" ((USItype) (sl)) \
|
|
|
207 : "r" ((USItype) (ah)), \
|
|
|
208 "rICal" ((USItype) (bh)), \
|
|
|
209 "r" ((USItype) (al)), \
|
|
|
210 "rICal" ((USItype) (bl)))
|
|
|
211
|
|
|
212 #define __umulsidi3(u,v) ((UDItype)(USItype)u*(USItype)v)
|
|
|
213 #ifdef __ARC_NORM__
|
|
|
214 #define count_leading_zeros(count, x) \
|
|
|
215 do \
|
|
|
216 { \
|
|
|
217 SItype c_; \
|
|
|
218 \
|
|
|
219 __asm__ ("norm.f\t%0,%1\n\tmov.mi\t%0,-1" : "=r" (c_) : "r" (x) : "cc");\
|
|
|
220 (count) = c_ + 1; \
|
|
|
221 } \
|
|
|
222 while (0)
|
|
|
223 #define COUNT_LEADING_ZEROS_0 32
|
|
|
224 #endif /* __ARC_NORM__ */
|
|
|
225 #endif /* __arc__ */
|
|
|
226
|
|
|
227 #if defined (__arm__) && (defined (__thumb2__) || !defined (__thumb__)) \
|
|
|
228 && W_TYPE_SIZE == 32
|
|
|
229 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
230 __asm__ ("adds %1, %4, %5\n\tadc %0, %2, %3" \
|
|
|
231 : "=r" ((USItype) (sh)), \
|
|
|
232 "=&r" ((USItype) (sl)) \
|
|
|
233 : "%r" ((USItype) (ah)), \
|
|
|
234 "rI" ((USItype) (bh)), \
|
|
|
235 "%r" ((USItype) (al)), \
|
|
|
236 "rI" ((USItype) (bl)) __CLOBBER_CC)
|
|
|
237 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
238 __asm__ ("subs %1, %4, %5\n\tsbc %0, %2, %3" \
|
|
|
239 : "=r" ((USItype) (sh)), \
|
|
|
240 "=&r" ((USItype) (sl)) \
|
|
|
241 : "r" ((USItype) (ah)), \
|
|
|
242 "rI" ((USItype) (bh)), \
|
|
|
243 "r" ((USItype) (al)), \
|
|
|
244 "rI" ((USItype) (bl)) __CLOBBER_CC)
|
|
|
245 # if defined(__ARM_ARCH_2__) || defined(__ARM_ARCH_2A__) \
|
|
|
246 || defined(__ARM_ARCH_3__)
|
|
|
247 # define umul_ppmm(xh, xl, a, b) \
|
|
|
248 do { \
|
|
|
249 register USItype __t0, __t1, __t2; \
|
|
|
250 __asm__ ("%@ Inlined umul_ppmm\n" \
|
|
|
251 " mov %2, %5, lsr #16\n" \
|
|
|
252 " mov %0, %6, lsr #16\n" \
|
|
|
253 " bic %3, %5, %2, lsl #16\n" \
|
|
|
254 " bic %4, %6, %0, lsl #16\n" \
|
|
|
255 " mul %1, %3, %4\n" \
|
|
|
256 " mul %4, %2, %4\n" \
|
|
|
257 " mul %3, %0, %3\n" \
|
|
|
258 " mul %0, %2, %0\n" \
|
|
|
259 " adds %3, %4, %3\n" \
|
|
|
260 " addcs %0, %0, #65536\n" \
|
|
|
261 " adds %1, %1, %3, lsl #16\n" \
|
|
|
262 " adc %0, %0, %3, lsr #16" \
|
|
|
263 : "=&r" ((USItype) (xh)), \
|
|
|
264 "=r" ((USItype) (xl)), \
|
|
|
265 "=&r" (__t0), "=&r" (__t1), "=r" (__t2) \
|
|
|
266 : "r" ((USItype) (a)), \
|
|
|
267 "r" ((USItype) (b)) __CLOBBER_CC ); \
|
|
|
268 } while (0)
|
|
|
269 # define UMUL_TIME 20
|
|
|
270 # else
|
|
|
271 # define umul_ppmm(xh, xl, a, b) \
|
|
|
272 do { \
|
|
|
273 /* Generate umull, under compiler control. */ \
|
|
|
274 register UDItype __t0 = (UDItype)(USItype)(a) * (USItype)(b); \
|
|
|
275 (xl) = (USItype)__t0; \
|
|
|
276 (xh) = (USItype)(__t0 >> 32); \
|
|
|
277 } while (0)
|
|
|
278 # define UMUL_TIME 3
|
|
|
279 # endif
|
|
|
280 # define UDIV_TIME 100
|
|
|
281 #endif /* __arm__ */
|
|
|
282
|
|
|
283 #if defined(__arm__)
|
|
|
284 /* Let gcc decide how best to implement count_leading_zeros. */
|
|
|
285 #define count_leading_zeros(COUNT,X) ((COUNT) = __builtin_clz (X))
|
|
|
286 #define count_trailing_zeros(COUNT,X) ((COUNT) = __builtin_ctz (X))
|
|
|
287 #define COUNT_LEADING_ZEROS_0 32
|
|
|
288 #endif
|
|
|
289
|
|
|
290 #if defined (__AVR__)
|
|
|
291
|
|
|
292 #if W_TYPE_SIZE == 16
|
|
|
293 #define count_leading_zeros(COUNT,X) ((COUNT) = __builtin_clz (X))
|
|
|
294 #define count_trailing_zeros(COUNT,X) ((COUNT) = __builtin_ctz (X))
|
|
|
295 #define COUNT_LEADING_ZEROS_0 16
|
|
|
296 #endif /* W_TYPE_SIZE == 16 */
|
|
|
297
|
|
|
298 #if W_TYPE_SIZE == 32
|
|
|
299 #define count_leading_zeros(COUNT,X) ((COUNT) = __builtin_clzl (X))
|
|
|
300 #define count_trailing_zeros(COUNT,X) ((COUNT) = __builtin_ctzl (X))
|
|
|
301 #define COUNT_LEADING_ZEROS_0 32
|
|
|
302 #endif /* W_TYPE_SIZE == 32 */
|
|
|
303
|
|
|
304 #if W_TYPE_SIZE == 64
|
|
|
305 #define count_leading_zeros(COUNT,X) ((COUNT) = __builtin_clzll (X))
|
|
|
306 #define count_trailing_zeros(COUNT,X) ((COUNT) = __builtin_ctzll (X))
|
|
|
307 #define COUNT_LEADING_ZEROS_0 64
|
|
|
308 #endif /* W_TYPE_SIZE == 64 */
|
|
|
309
|
|
|
310 #endif /* defined (__AVR__) */
|
|
|
311
|
|
|
312 #if defined (__CRIS__)
|
|
|
313
|
|
|
314 #if __CRIS_arch_version >= 3
|
|
|
315 #define count_leading_zeros(COUNT, X) ((COUNT) = __builtin_clz (X))
|
|
|
316 #define COUNT_LEADING_ZEROS_0 32
|
|
|
317 #endif /* __CRIS_arch_version >= 3 */
|
|
|
318
|
|
|
319 #if __CRIS_arch_version >= 8
|
|
|
320 #define count_trailing_zeros(COUNT, X) ((COUNT) = __builtin_ctz (X))
|
|
|
321 #endif /* __CRIS_arch_version >= 8 */
|
|
|
322
|
|
|
323 #if __CRIS_arch_version >= 10
|
|
|
324 #define __umulsidi3(u,v) ((UDItype)(USItype) (u) * (UDItype)(USItype) (v))
|
|
|
325 #else
|
|
|
326 #define __umulsidi3 __umulsidi3
|
|
|
327 extern UDItype __umulsidi3 (USItype, USItype);
|
|
|
328 #endif /* __CRIS_arch_version >= 10 */
|
|
|
329
|
|
|
330 #define umul_ppmm(w1, w0, u, v) \
|
|
|
331 do { \
|
|
|
332 UDItype __x = __umulsidi3 (u, v); \
|
|
|
333 (w0) = (USItype) (__x); \
|
|
|
334 (w1) = (USItype) (__x >> 32); \
|
|
|
335 } while (0)
|
|
|
336
|
|
|
337 /* FIXME: defining add_ssaaaa and sub_ddmmss should be advantageous for
|
|
|
338 DFmode ("double" intrinsics, avoiding two of the three insns handling
|
|
|
339 carry), but defining them as open-code C composing and doing the
|
|
|
340 operation in DImode (UDImode) shows that the DImode needs work:
|
|
|
341 register pressure from requiring neighboring registers and the
|
|
|
342 traffic to and from them come to dominate, in the 4.7 series. */
|
|
|
343
|
|
|
344 #endif /* defined (__CRIS__) */
|
|
|
345
|
|
|
346 #if defined (__hppa) && W_TYPE_SIZE == 32
|
|
|
347 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
348 __asm__ ("add %4,%5,%1\n\taddc %2,%3,%0" \
|
|
|
349 : "=r" ((USItype) (sh)), \
|
|
|
350 "=&r" ((USItype) (sl)) \
|
|
|
351 : "%rM" ((USItype) (ah)), \
|
|
|
352 "rM" ((USItype) (bh)), \
|
|
|
353 "%rM" ((USItype) (al)), \
|
|
|
354 "rM" ((USItype) (bl)))
|
|
|
355 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
356 __asm__ ("sub %4,%5,%1\n\tsubb %2,%3,%0" \
|
|
|
357 : "=r" ((USItype) (sh)), \
|
|
|
358 "=&r" ((USItype) (sl)) \
|
|
|
359 : "rM" ((USItype) (ah)), \
|
|
|
360 "rM" ((USItype) (bh)), \
|
|
|
361 "rM" ((USItype) (al)), \
|
|
|
362 "rM" ((USItype) (bl)))
|
|
|
363 #if defined (_PA_RISC1_1)
|
|
|
364 #define umul_ppmm(w1, w0, u, v) \
|
|
|
365 do { \
|
|
|
366 union \
|
|
|
367 { \
|
|
|
368 UDItype __f; \
|
|
|
369 struct {USItype __w1, __w0;} __w1w0; \
|
|
|
370 } __t; \
|
|
|
371 __asm__ ("xmpyu %1,%2,%0" \
|
|
|
372 : "=x" (__t.__f) \
|
|
|
373 : "x" ((USItype) (u)), \
|
|
|
374 "x" ((USItype) (v))); \
|
|
|
375 (w1) = __t.__w1w0.__w1; \
|
|
|
376 (w0) = __t.__w1w0.__w0; \
|
|
|
377 } while (0)
|
|
|
378 #define UMUL_TIME 8
|
|
|
379 #else
|
|
|
380 #define UMUL_TIME 30
|
|
|
381 #endif
|
|
|
382 #define UDIV_TIME 40
|
|
|
383 #define count_leading_zeros(count, x) \
|
|
|
384 do { \
|
|
|
385 USItype __tmp; \
|
|
|
386 __asm__ ( \
|
|
|
387 "ldi 1,%0\n" \
|
|
|
388 " extru,= %1,15,16,%%r0 ; Bits 31..16 zero?\n" \
|
|
|
389 " extru,tr %1,15,16,%1 ; No. Shift down, skip add.\n"\
|
|
|
390 " ldo 16(%0),%0 ; Yes. Perform add.\n" \
|
|
|
391 " extru,= %1,23,8,%%r0 ; Bits 15..8 zero?\n" \
|
|
|
392 " extru,tr %1,23,8,%1 ; No. Shift down, skip add.\n"\
|
|
|
393 " ldo 8(%0),%0 ; Yes. Perform add.\n" \
|
|
|
394 " extru,= %1,27,4,%%r0 ; Bits 7..4 zero?\n" \
|
|
|
395 " extru,tr %1,27,4,%1 ; No. Shift down, skip add.\n"\
|
|
|
396 " ldo 4(%0),%0 ; Yes. Perform add.\n" \
|
|
|
397 " extru,= %1,29,2,%%r0 ; Bits 3..2 zero?\n" \
|
|
|
398 " extru,tr %1,29,2,%1 ; No. Shift down, skip add.\n"\
|
|
|
399 " ldo 2(%0),%0 ; Yes. Perform add.\n" \
|
|
|
400 " extru %1,30,1,%1 ; Extract bit 1.\n" \
|
|
|
401 " sub %0,%1,%0 ; Subtract it.\n" \
|
|
|
402 : "=r" (count), "=r" (__tmp) : "1" (x)); \
|
|
|
403 } while (0)
|
|
|
404 #endif
|
|
|
405
|
|
|
406 #if (defined (__i370__) || defined (__s390__) || defined (__mvs__)) && W_TYPE_SIZE == 32
|
|
|
407 #if !defined (__zarch__)
|
|
|
408 #define smul_ppmm(xh, xl, m0, m1) \
|
|
|
409 do { \
|
|
|
410 union {DItype __ll; \
|
|
|
411 struct {USItype __h, __l;} __i; \
|
|
|
412 } __x; \
|
|
|
413 __asm__ ("lr %N0,%1\n\tmr %0,%2" \
|
|
|
414 : "=&r" (__x.__ll) \
|
|
|
415 : "r" (m0), "r" (m1)); \
|
|
|
416 (xh) = __x.__i.__h; (xl) = __x.__i.__l; \
|
|
|
417 } while (0)
|
|
|
418 #define sdiv_qrnnd(q, r, n1, n0, d) \
|
|
|
419 do { \
|
|
|
420 union {DItype __ll; \
|
|
|
421 struct {USItype __h, __l;} __i; \
|
|
|
422 } __x; \
|
|
|
423 __x.__i.__h = n1; __x.__i.__l = n0; \
|
|
|
424 __asm__ ("dr %0,%2" \
|
|
|
425 : "=r" (__x.__ll) \
|
|
|
426 : "0" (__x.__ll), "r" (d)); \
|
|
|
427 (q) = __x.__i.__l; (r) = __x.__i.__h; \
|
|
|
428 } while (0)
|
|
|
429 #else
|
|
|
430 #define smul_ppmm(xh, xl, m0, m1) \
|
|
|
431 do { \
|
|
|
432 register SItype __r0 __asm__ ("0"); \
|
|
|
433 register SItype __r1 __asm__ ("1") = (m0); \
|
|
|
434 \
|
|
|
435 __asm__ ("mr\t%%r0,%3" \
|
|
|
436 : "=r" (__r0), "=r" (__r1) \
|
|
|
437 : "r" (__r1), "r" (m1)); \
|
|
|
438 (xh) = __r0; (xl) = __r1; \
|
|
|
439 } while (0)
|
|
|
440
|
|
|
441 #define sdiv_qrnnd(q, r, n1, n0, d) \
|
|
|
442 do { \
|
|
|
443 register SItype __r0 __asm__ ("0") = (n1); \
|
|
|
444 register SItype __r1 __asm__ ("1") = (n0); \
|
|
|
445 \
|
|
|
446 __asm__ ("dr\t%%r0,%4" \
|
|
|
447 : "=r" (__r0), "=r" (__r1) \
|
|
|
448 : "r" (__r0), "r" (__r1), "r" (d)); \
|
|
|
449 (q) = __r1; (r) = __r0; \
|
|
|
450 } while (0)
|
|
|
451 #endif /* __zarch__ */
|
|
|
452 #endif
|
|
|
453
|
|
|
454 #if (defined (__i386__) || defined (__i486__)) && W_TYPE_SIZE == 32
|
|
|
455 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
456 __asm__ ("add{l} {%5,%1|%1,%5}\n\tadc{l} {%3,%0|%0,%3}" \
|
|
|
457 : "=r" ((USItype) (sh)), \
|
|
|
458 "=&r" ((USItype) (sl)) \
|
|
|
459 : "%0" ((USItype) (ah)), \
|
|
|
460 "g" ((USItype) (bh)), \
|
|
|
461 "%1" ((USItype) (al)), \
|
|
|
462 "g" ((USItype) (bl)))
|
|
|
463 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
464 __asm__ ("sub{l} {%5,%1|%1,%5}\n\tsbb{l} {%3,%0|%0,%3}" \
|
|
|
465 : "=r" ((USItype) (sh)), \
|
|
|
466 "=&r" ((USItype) (sl)) \
|
|
|
467 : "0" ((USItype) (ah)), \
|
|
|
468 "g" ((USItype) (bh)), \
|
|
|
469 "1" ((USItype) (al)), \
|
|
|
470 "g" ((USItype) (bl)))
|
|
|
471 #define umul_ppmm(w1, w0, u, v) \
|
|
|
472 __asm__ ("mul{l} %3" \
|
|
|
473 : "=a" ((USItype) (w0)), \
|
|
|
474 "=d" ((USItype) (w1)) \
|
|
|
475 : "%0" ((USItype) (u)), \
|
|
|
476 "rm" ((USItype) (v)))
|
|
|
477 #define udiv_qrnnd(q, r, n1, n0, dv) \
|
|
|
478 __asm__ ("div{l} %4" \
|
|
|
479 : "=a" ((USItype) (q)), \
|
|
|
480 "=d" ((USItype) (r)) \
|
|
|
481 : "0" ((USItype) (n0)), \
|
|
|
482 "1" ((USItype) (n1)), \
|
|
|
483 "rm" ((USItype) (dv)))
|
|
|
484 #define count_leading_zeros(count, x) ((count) = __builtin_clz (x))
|
|
|
485 #define count_trailing_zeros(count, x) ((count) = __builtin_ctz (x))
|
|
|
486 #define UMUL_TIME 40
|
|
|
487 #define UDIV_TIME 40
|
|
|
488 #endif /* 80x86 */
|
|
|
489
|
|
|
490 #if defined (__x86_64__) && W_TYPE_SIZE == 64
|
|
|
491 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
492 __asm__ ("add{q} {%5,%1|%1,%5}\n\tadc{q} {%3,%0|%0,%3}" \
|
|
|
493 : "=r" ((UDItype) (sh)), \
|
|
|
494 "=&r" ((UDItype) (sl)) \
|
|
|
495 : "%0" ((UDItype) (ah)), \
|
|
|
496 "rme" ((UDItype) (bh)), \
|
|
|
497 "%1" ((UDItype) (al)), \
|
|
|
498 "rme" ((UDItype) (bl)))
|
|
|
499 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
500 __asm__ ("sub{q} {%5,%1|%1,%5}\n\tsbb{q} {%3,%0|%0,%3}" \
|
|
|
501 : "=r" ((UDItype) (sh)), \
|
|
|
502 "=&r" ((UDItype) (sl)) \
|
|
|
503 : "0" ((UDItype) (ah)), \
|
|
|
504 "rme" ((UDItype) (bh)), \
|
|
|
505 "1" ((UDItype) (al)), \
|
|
|
506 "rme" ((UDItype) (bl)))
|
|
|
507 #define umul_ppmm(w1, w0, u, v) \
|
|
|
508 __asm__ ("mul{q} %3" \
|
|
|
509 : "=a" ((UDItype) (w0)), \
|
|
|
510 "=d" ((UDItype) (w1)) \
|
|
|
511 : "%0" ((UDItype) (u)), \
|
|
|
512 "rm" ((UDItype) (v)))
|
|
|
513 #define udiv_qrnnd(q, r, n1, n0, dv) \
|
|
|
514 __asm__ ("div{q} %4" \
|
|
|
515 : "=a" ((UDItype) (q)), \
|
|
|
516 "=d" ((UDItype) (r)) \
|
|
|
517 : "0" ((UDItype) (n0)), \
|
|
|
518 "1" ((UDItype) (n1)), \
|
|
|
519 "rm" ((UDItype) (dv)))
|
|
|
520 #define count_leading_zeros(count, x) ((count) = __builtin_clzll (x))
|
|
|
521 #define count_trailing_zeros(count, x) ((count) = __builtin_ctzll (x))
|
|
|
522 #define UMUL_TIME 40
|
|
|
523 #define UDIV_TIME 40
|
|
|
524 #endif /* x86_64 */
|
|
|
525
|
|
|
526 #if defined (__i960__) && W_TYPE_SIZE == 32
|
|
|
527 #define umul_ppmm(w1, w0, u, v) \
|
|
|
528 ({union {UDItype __ll; \
|
|
|
529 struct {USItype __l, __h;} __i; \
|
|
|
530 } __xx; \
|
|
|
531 __asm__ ("emul %2,%1,%0" \
|
|
|
532 : "=d" (__xx.__ll) \
|
|
|
533 : "%dI" ((USItype) (u)), \
|
|
|
534 "dI" ((USItype) (v))); \
|
|
|
535 (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})
|
|
|
536 #define __umulsidi3(u, v) \
|
|
|
537 ({UDItype __w; \
|
|
|
538 __asm__ ("emul %2,%1,%0" \
|
|
|
539 : "=d" (__w) \
|
|
|
540 : "%dI" ((USItype) (u)), \
|
|
|
541 "dI" ((USItype) (v))); \
|
|
|
542 __w; })
|
|
|
543 #endif /* __i960__ */
|
|
|
544
|
|
|
545 #if defined (__ia64) && W_TYPE_SIZE == 64
|
|
|
546 /* This form encourages gcc (pre-release 3.4 at least) to emit predicated
|
|
|
547 "sub r=r,r" and "sub r=r,r,1", giving a 2 cycle latency. The generic
|
|
|
548 code using "al<bl" arithmetically comes out making an actual 0 or 1 in a
|
|
|
549 register, which takes an extra cycle. */
|
|
|
550 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
551 do { \
|
|
|
552 UWtype __x; \
|
|
|
553 __x = (al) - (bl); \
|
|
|
554 if ((al) < (bl)) \
|
|
|
555 (sh) = (ah) - (bh) - 1; \
|
|
|
556 else \
|
|
|
557 (sh) = (ah) - (bh); \
|
|
|
558 (sl) = __x; \
|
|
|
559 } while (0)
|
|
|
560
|
|
|
561 /* Do both product parts in assembly, since that gives better code with
|
|
|
562 all gcc versions. Some callers will just use the upper part, and in
|
|
|
563 that situation we waste an instruction, but not any cycles. */
|
|
|
564 #define umul_ppmm(ph, pl, m0, m1) \
|
|
|
565 __asm__ ("xma.hu %0 = %2, %3, f0\n\txma.l %1 = %2, %3, f0" \
|
|
|
566 : "=&f" (ph), "=f" (pl) \
|
|
|
567 : "f" (m0), "f" (m1))
|
|
|
568 #define count_leading_zeros(count, x) \
|
|
|
569 do { \
|
|
|
570 UWtype _x = (x), _y, _a, _c; \
|
|
|
571 __asm__ ("mux1 %0 = %1, @rev" : "=r" (_y) : "r" (_x)); \
|
|
|
572 __asm__ ("czx1.l %0 = %1" : "=r" (_a) : "r" (-_y | _y)); \
|
|
|
573 _c = (_a - 1) << 3; \
|
|
|
574 _x >>= _c; \
|
|
|
575 if (_x >= 1 << 4) \
|
|
|
576 _x >>= 4, _c += 4; \
|
|
|
577 if (_x >= 1 << 2) \
|
|
|
578 _x >>= 2, _c += 2; \
|
|
|
579 _c += _x >> 1; \
|
|
|
580 (count) = W_TYPE_SIZE - 1 - _c; \
|
|
|
581 } while (0)
|
|
|
582 /* similar to what gcc does for __builtin_ffs, but 0 based rather than 1
|
|
|
583 based, and we don't need a special case for x==0 here */
|
|
|
584 #define count_trailing_zeros(count, x) \
|
|
|
585 do { \
|
|
|
586 UWtype __ctz_x = (x); \
|
|
|
587 __asm__ ("popcnt %0 = %1" \
|
|
|
588 : "=r" (count) \
|
|
|
589 : "r" ((__ctz_x-1) & ~__ctz_x)); \
|
|
|
590 } while (0)
|
|
|
591 #define UMUL_TIME 14
|
|
|
592 #endif
|
|
|
593
|
|
|
594 #if defined (__M32R__) && W_TYPE_SIZE == 32
|
|
|
595 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
596 /* The cmp clears the condition bit. */ \
|
|
|
597 __asm__ ("cmp %0,%0\n\taddx %1,%5\n\taddx %0,%3" \
|
|
|
598 : "=r" ((USItype) (sh)), \
|
|
|
599 "=&r" ((USItype) (sl)) \
|
|
|
600 : "0" ((USItype) (ah)), \
|
|
|
601 "r" ((USItype) (bh)), \
|
|
|
602 "1" ((USItype) (al)), \
|
|
|
603 "r" ((USItype) (bl)) \
|
|
|
604 : "cbit")
|
|
|
605 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
606 /* The cmp clears the condition bit. */ \
|
|
|
607 __asm__ ("cmp %0,%0\n\tsubx %1,%5\n\tsubx %0,%3" \
|
|
|
608 : "=r" ((USItype) (sh)), \
|
|
|
609 "=&r" ((USItype) (sl)) \
|
|
|
610 : "0" ((USItype) (ah)), \
|
|
|
611 "r" ((USItype) (bh)), \
|
|
|
612 "1" ((USItype) (al)), \
|
|
|
613 "r" ((USItype) (bl)) \
|
|
|
614 : "cbit")
|
|
|
615 #endif /* __M32R__ */
|
|
|
616
|
|
|
617 #if defined (__mc68000__) && W_TYPE_SIZE == 32
|
|
|
618 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
619 __asm__ ("add%.l %5,%1\n\taddx%.l %3,%0" \
|
|
|
620 : "=d" ((USItype) (sh)), \
|
|
|
621 "=&d" ((USItype) (sl)) \
|
|
|
622 : "%0" ((USItype) (ah)), \
|
|
|
623 "d" ((USItype) (bh)), \
|
|
|
624 "%1" ((USItype) (al)), \
|
|
|
625 "g" ((USItype) (bl)))
|
|
|
626 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
627 __asm__ ("sub%.l %5,%1\n\tsubx%.l %3,%0" \
|
|
|
628 : "=d" ((USItype) (sh)), \
|
|
|
629 "=&d" ((USItype) (sl)) \
|
|
|
630 : "0" ((USItype) (ah)), \
|
|
|
631 "d" ((USItype) (bh)), \
|
|
|
632 "1" ((USItype) (al)), \
|
|
|
633 "g" ((USItype) (bl)))
|
|
|
634
|
|
|
635 /* The '020, '030, '040, '060 and CPU32 have 32x32->64 and 64/32->32q-32r. */
|
|
|
636 #if (defined (__mc68020__) && !defined (__mc68060__))
|
|
|
637 #define umul_ppmm(w1, w0, u, v) \
|
|
|
638 __asm__ ("mulu%.l %3,%1:%0" \
|
|
|
639 : "=d" ((USItype) (w0)), \
|
|
|
640 "=d" ((USItype) (w1)) \
|
|
|
641 : "%0" ((USItype) (u)), \
|
|
|
642 "dmi" ((USItype) (v)))
|
|
|
643 #define UMUL_TIME 45
|
|
|
644 #define udiv_qrnnd(q, r, n1, n0, d) \
|
|
|
645 __asm__ ("divu%.l %4,%1:%0" \
|
|
|
646 : "=d" ((USItype) (q)), \
|
|
|
647 "=d" ((USItype) (r)) \
|
|
|
648 : "0" ((USItype) (n0)), \
|
|
|
649 "1" ((USItype) (n1)), \
|
|
|
650 "dmi" ((USItype) (d)))
|
|
|
651 #define UDIV_TIME 90
|
|
|
652 #define sdiv_qrnnd(q, r, n1, n0, d) \
|
|
|
653 __asm__ ("divs%.l %4,%1:%0" \
|
|
|
654 : "=d" ((USItype) (q)), \
|
|
|
655 "=d" ((USItype) (r)) \
|
|
|
656 : "0" ((USItype) (n0)), \
|
|
|
657 "1" ((USItype) (n1)), \
|
|
|
658 "dmi" ((USItype) (d)))
|
|
|
659
|
|
|
660 #elif defined (__mcoldfire__) /* not mc68020 */
|
|
|
661
|
|
|
662 #define umul_ppmm(xh, xl, a, b) \
|
|
|
663 __asm__ ("| Inlined umul_ppmm\n" \
|
|
|
664 " move%.l %2,%/d0\n" \
|
|
|
665 " move%.l %3,%/d1\n" \
|
|
|
666 " move%.l %/d0,%/d2\n" \
|
|
|
667 " swap %/d0\n" \
|
|
|
668 " move%.l %/d1,%/d3\n" \
|
|
|
669 " swap %/d1\n" \
|
|
|
670 " move%.w %/d2,%/d4\n" \
|
|
|
671 " mulu %/d3,%/d4\n" \
|
|
|
672 " mulu %/d1,%/d2\n" \
|
|
|
673 " mulu %/d0,%/d3\n" \
|
|
|
674 " mulu %/d0,%/d1\n" \
|
|
|
675 " move%.l %/d4,%/d0\n" \
|
|
|
676 " clr%.w %/d0\n" \
|
|
|
677 " swap %/d0\n" \
|
|
|
678 " add%.l %/d0,%/d2\n" \
|
|
|
679 " add%.l %/d3,%/d2\n" \
|
|
|
680 " jcc 1f\n" \
|
|
|
681 " add%.l %#65536,%/d1\n" \
|
|
|
682 "1: swap %/d2\n" \
|
|
|
683 " moveq %#0,%/d0\n" \
|
|
|
684 " move%.w %/d2,%/d0\n" \
|
|
|
685 " move%.w %/d4,%/d2\n" \
|
|
|
686 " move%.l %/d2,%1\n" \
|
|
|
687 " add%.l %/d1,%/d0\n" \
|
|
|
688 " move%.l %/d0,%0" \
|
|
|
689 : "=g" ((USItype) (xh)), \
|
|
|
690 "=g" ((USItype) (xl)) \
|
|
|
691 : "g" ((USItype) (a)), \
|
|
|
692 "g" ((USItype) (b)) \
|
|
|
693 : "d0", "d1", "d2", "d3", "d4")
|
|
|
694 #define UMUL_TIME 100
|
|
|
695 #define UDIV_TIME 400
|
|
|
696 #else /* not ColdFire */
|
|
|
697 /* %/ inserts REGISTER_PREFIX, %# inserts IMMEDIATE_PREFIX. */
|
|
|
698 #define umul_ppmm(xh, xl, a, b) \
|
|
|
699 __asm__ ("| Inlined umul_ppmm\n" \
|
|
|
700 " move%.l %2,%/d0\n" \
|
|
|
701 " move%.l %3,%/d1\n" \
|
|
|
702 " move%.l %/d0,%/d2\n" \
|
|
|
703 " swap %/d0\n" \
|
|
|
704 " move%.l %/d1,%/d3\n" \
|
|
|
705 " swap %/d1\n" \
|
|
|
706 " move%.w %/d2,%/d4\n" \
|
|
|
707 " mulu %/d3,%/d4\n" \
|
|
|
708 " mulu %/d1,%/d2\n" \
|
|
|
709 " mulu %/d0,%/d3\n" \
|
|
|
710 " mulu %/d0,%/d1\n" \
|
|
|
711 " move%.l %/d4,%/d0\n" \
|
|
|
712 " eor%.w %/d0,%/d0\n" \
|
|
|
713 " swap %/d0\n" \
|
|
|
714 " add%.l %/d0,%/d2\n" \
|
|
|
715 " add%.l %/d3,%/d2\n" \
|
|
|
716 " jcc 1f\n" \
|
|
|
717 " add%.l %#65536,%/d1\n" \
|
|
|
718 "1: swap %/d2\n" \
|
|
|
719 " moveq %#0,%/d0\n" \
|
|
|
720 " move%.w %/d2,%/d0\n" \
|
|
|
721 " move%.w %/d4,%/d2\n" \
|
|
|
722 " move%.l %/d2,%1\n" \
|
|
|
723 " add%.l %/d1,%/d0\n" \
|
|
|
724 " move%.l %/d0,%0" \
|
|
|
725 : "=g" ((USItype) (xh)), \
|
|
|
726 "=g" ((USItype) (xl)) \
|
|
|
727 : "g" ((USItype) (a)), \
|
|
|
728 "g" ((USItype) (b)) \
|
|
|
729 : "d0", "d1", "d2", "d3", "d4")
|
|
|
730 #define UMUL_TIME 100
|
|
|
731 #define UDIV_TIME 400
|
|
|
732
|
|
|
733 #endif /* not mc68020 */
|
|
|
734
|
|
|
735 /* The '020, '030, '040 and '060 have bitfield insns.
|
|
|
736 cpu32 disguises as a 68020, but lacks them. */
|
|
|
737 #if defined (__mc68020__) && !defined (__mcpu32__)
|
|
|
738 #define count_leading_zeros(count, x) \
|
|
|
739 __asm__ ("bfffo %1{%b2:%b2},%0" \
|
|
|
740 : "=d" ((USItype) (count)) \
|
|
|
741 : "od" ((USItype) (x)), "n" (0))
|
|
|
742 /* Some ColdFire architectures have a ff1 instruction supported via
|
|
|
743 __builtin_clz. */
|
|
|
744 #elif defined (__mcfisaaplus__) || defined (__mcfisac__)
|
|
|
745 #define count_leading_zeros(count,x) ((count) = __builtin_clz (x))
|
|
|
746 #define COUNT_LEADING_ZEROS_0 32
|
|
|
747 #endif
|
|
|
748 #endif /* mc68000 */
|
|
|
749
|
|
|
750 #if defined (__m88000__) && W_TYPE_SIZE == 32
|
|
|
751 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
752 __asm__ ("addu.co %1,%r4,%r5\n\taddu.ci %0,%r2,%r3" \
|
|
|
753 : "=r" ((USItype) (sh)), \
|
|
|
754 "=&r" ((USItype) (sl)) \
|
|
|
755 : "%rJ" ((USItype) (ah)), \
|
|
|
756 "rJ" ((USItype) (bh)), \
|
|
|
757 "%rJ" ((USItype) (al)), \
|
|
|
758 "rJ" ((USItype) (bl)))
|
|
|
759 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
760 __asm__ ("subu.co %1,%r4,%r5\n\tsubu.ci %0,%r2,%r3" \
|
|
|
761 : "=r" ((USItype) (sh)), \
|
|
|
762 "=&r" ((USItype) (sl)) \
|
|
|
763 : "rJ" ((USItype) (ah)), \
|
|
|
764 "rJ" ((USItype) (bh)), \
|
|
|
765 "rJ" ((USItype) (al)), \
|
|
|
766 "rJ" ((USItype) (bl)))
|
|
|
767 #define count_leading_zeros(count, x) \
|
|
|
768 do { \
|
|
|
769 USItype __cbtmp; \
|
|
|
770 __asm__ ("ff1 %0,%1" \
|
|
|
771 : "=r" (__cbtmp) \
|
|
|
772 : "r" ((USItype) (x))); \
|
|
|
773 (count) = __cbtmp ^ 31; \
|
|
|
774 } while (0)
|
|
|
775 #define COUNT_LEADING_ZEROS_0 63 /* sic */
|
|
|
776 #if defined (__mc88110__)
|
|
|
777 #define umul_ppmm(wh, wl, u, v) \
|
|
|
778 do { \
|
|
|
779 union {UDItype __ll; \
|
|
|
780 struct {USItype __h, __l;} __i; \
|
|
|
781 } __xx; \
|
|
|
782 __asm__ ("mulu.d %0,%1,%2" \
|
|
|
783 : "=r" (__xx.__ll) \
|
|
|
784 : "r" ((USItype) (u)), \
|
|
|
785 "r" ((USItype) (v))); \
|
|
|
786 (wh) = __xx.__i.__h; \
|
|
|
787 (wl) = __xx.__i.__l; \
|
|
|
788 } while (0)
|
|
|
789 #define udiv_qrnnd(q, r, n1, n0, d) \
|
|
|
790 ({union {UDItype __ll; \
|
|
|
791 struct {USItype __h, __l;} __i; \
|
|
|
792 } __xx; \
|
|
|
793 USItype __q; \
|
|
|
794 __xx.__i.__h = (n1); __xx.__i.__l = (n0); \
|
|
|
795 __asm__ ("divu.d %0,%1,%2" \
|
|
|
796 : "=r" (__q) \
|
|
|
797 : "r" (__xx.__ll), \
|
|
|
798 "r" ((USItype) (d))); \
|
|
|
799 (r) = (n0) - __q * (d); (q) = __q; })
|
|
|
800 #define UMUL_TIME 5
|
|
|
801 #define UDIV_TIME 25
|
|
|
802 #else
|
|
|
803 #define UMUL_TIME 17
|
|
|
804 #define UDIV_TIME 150
|
|
|
805 #endif /* __mc88110__ */
|
|
|
806 #endif /* __m88000__ */
|
|
|
807
|
|
|
808 #if defined (__mn10300__)
|
|
|
809 # if defined (__AM33__)
|
|
|
810 # define count_leading_zeros(COUNT,X) ((COUNT) = __builtin_clz (X))
|
|
|
811 # define umul_ppmm(w1, w0, u, v) \
|
|
|
812 asm("mulu %3,%2,%1,%0" : "=r"(w0), "=r"(w1) : "r"(u), "r"(v))
|
|
|
813 # define smul_ppmm(w1, w0, u, v) \
|
|
|
814 asm("mul %3,%2,%1,%0" : "=r"(w0), "=r"(w1) : "r"(u), "r"(v))
|
|
|
815 # else
|
|
|
816 # define umul_ppmm(w1, w0, u, v) \
|
|
|
817 asm("nop; nop; mulu %3,%0" : "=d"(w0), "=z"(w1) : "%0"(u), "d"(v))
|
|
|
818 # define smul_ppmm(w1, w0, u, v) \
|
|
|
819 asm("nop; nop; mul %3,%0" : "=d"(w0), "=z"(w1) : "%0"(u), "d"(v))
|
|
|
820 # endif
|
|
|
821 # define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
822 do { \
|
|
|
823 DWunion __s, __a, __b; \
|
|
|
824 __a.s.low = (al); __a.s.high = (ah); \
|
|
|
825 __b.s.low = (bl); __b.s.high = (bh); \
|
|
|
826 __s.ll = __a.ll + __b.ll; \
|
|
|
827 (sl) = __s.s.low; (sh) = __s.s.high; \
|
|
|
828 } while (0)
|
|
|
829 # define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
830 do { \
|
|
|
831 DWunion __s, __a, __b; \
|
|
|
832 __a.s.low = (al); __a.s.high = (ah); \
|
|
|
833 __b.s.low = (bl); __b.s.high = (bh); \
|
|
|
834 __s.ll = __a.ll - __b.ll; \
|
|
|
835 (sl) = __s.s.low; (sh) = __s.s.high; \
|
|
|
836 } while (0)
|
|
|
837 # define udiv_qrnnd(q, r, nh, nl, d) \
|
|
|
838 asm("divu %2,%0" : "=D"(q), "=z"(r) : "D"(d), "0"(nl), "1"(nh))
|
|
|
839 # define sdiv_qrnnd(q, r, nh, nl, d) \
|
|
|
840 asm("div %2,%0" : "=D"(q), "=z"(r) : "D"(d), "0"(nl), "1"(nh))
|
|
|
841 # define UMUL_TIME 3
|
|
|
842 # define UDIV_TIME 38
|
|
|
843 #endif
|
|
|
844
|
|
|
845 #if defined (__mips__) && W_TYPE_SIZE == 32
|
|
|
846 #define umul_ppmm(w1, w0, u, v) \
|
|
|
847 do { \
|
|
|
848 UDItype __x = (UDItype) (USItype) (u) * (USItype) (v); \
|
|
|
849 (w1) = (USItype) (__x >> 32); \
|
|
|
850 (w0) = (USItype) (__x); \
|
|
|
851 } while (0)
|
|
|
852 #define UMUL_TIME 10
|
|
|
853 #define UDIV_TIME 100
|
|
|
854
|
|
|
855 #if (__mips == 32 || __mips == 64) && ! defined (__mips16)
|
|
|
856 #define count_leading_zeros(COUNT,X) ((COUNT) = __builtin_clz (X))
|
|
|
857 #define COUNT_LEADING_ZEROS_0 32
|
|
|
858 #endif
|
|
|
859 #endif /* __mips__ */
|
|
|
860
|
|
|
861 /* FIXME: We should test _IBMR2 here when we add assembly support for the
|
|
|
862 system vendor compilers.
|
|
|
863 FIXME: What's needed for gcc PowerPC VxWorks? __vxworks__ is not good
|
|
|
864 enough, since that hits ARM and m68k too. */
|
|
|
865 #if (defined (_ARCH_PPC) /* AIX */ \
|
|
|
866 || defined (__powerpc__) /* gcc */ \
|
|
|
867 || defined (__POWERPC__) /* BEOS */ \
|
|
|
868 || defined (__ppc__) /* Darwin */ \
|
|
|
869 || (defined (PPC) && ! defined (CPU_FAMILY)) /* gcc 2.7.x GNU&SysV */ \
|
|
|
870 || (defined (PPC) && defined (CPU_FAMILY) /* VxWorks */ \
|
|
|
871 && CPU_FAMILY == PPC) \
|
|
|
872 ) && W_TYPE_SIZE == 32
|
|
|
873 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
874 do { \
|
|
|
875 if (__builtin_constant_p (bh) && (bh) == 0) \
|
|
|
876 __asm__ ("add%I4c %1,%3,%4\n\taddze %0,%2" \
|
|
|
877 : "=r" (sh), "=&r" (sl) : "r" (ah), "%r" (al), "rI" (bl));\
|
|
|
878 else if (__builtin_constant_p (bh) && (bh) == ~(USItype) 0) \
|
|
|
879 __asm__ ("add%I4c %1,%3,%4\n\taddme %0,%2" \
|
|
|
880 : "=r" (sh), "=&r" (sl) : "r" (ah), "%r" (al), "rI" (bl));\
|
|
|
881 else \
|
|
|
882 __asm__ ("add%I5c %1,%4,%5\n\tadde %0,%2,%3" \
|
|
|
883 : "=r" (sh), "=&r" (sl) \
|
|
|
884 : "%r" (ah), "r" (bh), "%r" (al), "rI" (bl)); \
|
|
|
885 } while (0)
|
|
|
886 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
887 do { \
|
|
|
888 if (__builtin_constant_p (ah) && (ah) == 0) \
|
|
|
889 __asm__ ("subf%I3c %1,%4,%3\n\tsubfze %0,%2" \
|
|
|
890 : "=r" (sh), "=&r" (sl) : "r" (bh), "rI" (al), "r" (bl));\
|
|
|
891 else if (__builtin_constant_p (ah) && (ah) == ~(USItype) 0) \
|
|
|
892 __asm__ ("subf%I3c %1,%4,%3\n\tsubfme %0,%2" \
|
|
|
893 : "=r" (sh), "=&r" (sl) : "r" (bh), "rI" (al), "r" (bl));\
|
|
|
894 else if (__builtin_constant_p (bh) && (bh) == 0) \
|
|
|
895 __asm__ ("subf%I3c %1,%4,%3\n\taddme %0,%2" \
|
|
|
896 : "=r" (sh), "=&r" (sl) : "r" (ah), "rI" (al), "r" (bl));\
|
|
|
897 else if (__builtin_constant_p (bh) && (bh) == ~(USItype) 0) \
|
|
|
898 __asm__ ("subf%I3c %1,%4,%3\n\taddze %0,%2" \
|
|
|
899 : "=r" (sh), "=&r" (sl) : "r" (ah), "rI" (al), "r" (bl));\
|
|
|
900 else \
|
|
|
901 __asm__ ("subf%I4c %1,%5,%4\n\tsubfe %0,%3,%2" \
|
|
|
902 : "=r" (sh), "=&r" (sl) \
|
|
|
903 : "r" (ah), "r" (bh), "rI" (al), "r" (bl)); \
|
|
|
904 } while (0)
|
|
|
905 #define count_leading_zeros(count, x) \
|
|
|
906 __asm__ ("cntlzw %0,%1" : "=r" (count) : "r" (x))
|
|
|
907 #define COUNT_LEADING_ZEROS_0 32
|
|
|
908 #if defined (_ARCH_PPC) || defined (__powerpc__) || defined (__POWERPC__) \
|
|
|
909 || defined (__ppc__) \
|
|
|
910 || (defined (PPC) && ! defined (CPU_FAMILY)) /* gcc 2.7.x GNU&SysV */ \
|
|
|
911 || (defined (PPC) && defined (CPU_FAMILY) /* VxWorks */ \
|
|
|
912 && CPU_FAMILY == PPC)
|
|
|
913 #define umul_ppmm(ph, pl, m0, m1) \
|
|
|
914 do { \
|
|
|
915 USItype __m0 = (m0), __m1 = (m1); \
|
|
|
916 __asm__ ("mulhwu %0,%1,%2" : "=r" (ph) : "%r" (m0), "r" (m1)); \
|
|
|
917 (pl) = __m0 * __m1; \
|
|
|
918 } while (0)
|
|
|
919 #define UMUL_TIME 15
|
|
|
920 #define smul_ppmm(ph, pl, m0, m1) \
|
|
|
921 do { \
|
|
|
922 SItype __m0 = (m0), __m1 = (m1); \
|
|
|
923 __asm__ ("mulhw %0,%1,%2" : "=r" (ph) : "%r" (m0), "r" (m1)); \
|
|
|
924 (pl) = __m0 * __m1; \
|
|
|
925 } while (0)
|
|
|
926 #define SMUL_TIME 14
|
|
|
927 #define UDIV_TIME 120
|
|
|
928 #endif
|
|
|
929 #endif /* 32-bit POWER architecture variants. */
|
|
|
930
|
|
|
931 /* We should test _IBMR2 here when we add assembly support for the system
|
|
|
932 vendor compilers. */
|
|
|
933 #if (defined (_ARCH_PPC64) || defined (__powerpc64__)) && W_TYPE_SIZE == 64
|
|
|
934 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
935 do { \
|
|
|
936 if (__builtin_constant_p (bh) && (bh) == 0) \
|
|
|
937 __asm__ ("add%I4c %1,%3,%4\n\taddze %0,%2" \
|
|
|
938 : "=r" (sh), "=&r" (sl) : "r" (ah), "%r" (al), "rI" (bl));\
|
|
|
939 else if (__builtin_constant_p (bh) && (bh) == ~(UDItype) 0) \
|
|
|
940 __asm__ ("add%I4c %1,%3,%4\n\taddme %0,%2" \
|
|
|
941 : "=r" (sh), "=&r" (sl) : "r" (ah), "%r" (al), "rI" (bl));\
|
|
|
942 else \
|
|
|
943 __asm__ ("add%I5c %1,%4,%5\n\tadde %0,%2,%3" \
|
|
|
944 : "=r" (sh), "=&r" (sl) \
|
|
|
945 : "%r" (ah), "r" (bh), "%r" (al), "rI" (bl)); \
|
|
|
946 } while (0)
|
|
|
947 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
948 do { \
|
|
|
949 if (__builtin_constant_p (ah) && (ah) == 0) \
|
|
|
950 __asm__ ("subf%I3c %1,%4,%3\n\tsubfze %0,%2" \
|
|
|
951 : "=r" (sh), "=&r" (sl) : "r" (bh), "rI" (al), "r" (bl));\
|
|
|
952 else if (__builtin_constant_p (ah) && (ah) == ~(UDItype) 0) \
|
|
|
953 __asm__ ("subf%I3c %1,%4,%3\n\tsubfme %0,%2" \
|
|
|
954 : "=r" (sh), "=&r" (sl) : "r" (bh), "rI" (al), "r" (bl));\
|
|
|
955 else if (__builtin_constant_p (bh) && (bh) == 0) \
|
|
|
956 __asm__ ("subf%I3c %1,%4,%3\n\taddme %0,%2" \
|
|
|
957 : "=r" (sh), "=&r" (sl) : "r" (ah), "rI" (al), "r" (bl));\
|
|
|
958 else if (__builtin_constant_p (bh) && (bh) == ~(UDItype) 0) \
|
|
|
959 __asm__ ("subf%I3c %1,%4,%3\n\taddze %0,%2" \
|
|
|
960 : "=r" (sh), "=&r" (sl) : "r" (ah), "rI" (al), "r" (bl));\
|
|
|
961 else \
|
|
|
962 __asm__ ("subf%I4c %1,%5,%4\n\tsubfe %0,%3,%2" \
|
|
|
963 : "=r" (sh), "=&r" (sl) \
|
|
|
964 : "r" (ah), "r" (bh), "rI" (al), "r" (bl)); \
|
|
|
965 } while (0)
|
|
|
966 #define count_leading_zeros(count, x) \
|
|
|
967 __asm__ ("cntlzd %0,%1" : "=r" (count) : "r" (x))
|
|
|
968 #define COUNT_LEADING_ZEROS_0 64
|
|
|
969 #define umul_ppmm(ph, pl, m0, m1) \
|
|
|
970 do { \
|
|
|
971 UDItype __m0 = (m0), __m1 = (m1); \
|
|
|
972 __asm__ ("mulhdu %0,%1,%2" : "=r" (ph) : "%r" (m0), "r" (m1)); \
|
|
|
973 (pl) = __m0 * __m1; \
|
|
|
974 } while (0)
|
|
|
975 #define UMUL_TIME 15
|
|
|
976 #define smul_ppmm(ph, pl, m0, m1) \
|
|
|
977 do { \
|
|
|
978 DItype __m0 = (m0), __m1 = (m1); \
|
|
|
979 __asm__ ("mulhd %0,%1,%2" : "=r" (ph) : "%r" (m0), "r" (m1)); \
|
|
|
980 (pl) = __m0 * __m1; \
|
|
|
981 } while (0)
|
|
|
982 #define SMUL_TIME 14 /* ??? */
|
|
|
983 #define UDIV_TIME 120 /* ??? */
|
|
|
984 #endif /* 64-bit PowerPC. */
|
|
|
985
|
|
|
986 #if defined (__ibm032__) /* RT/ROMP */ && W_TYPE_SIZE == 32
|
|
|
987 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
988 __asm__ ("a %1,%5\n\tae %0,%3" \
|
|
|
989 : "=r" ((USItype) (sh)), \
|
|
|
990 "=&r" ((USItype) (sl)) \
|
|
|
991 : "%0" ((USItype) (ah)), \
|
|
|
992 "r" ((USItype) (bh)), \
|
|
|
993 "%1" ((USItype) (al)), \
|
|
|
994 "r" ((USItype) (bl)))
|
|
|
995 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
996 __asm__ ("s %1,%5\n\tse %0,%3" \
|
|
|
997 : "=r" ((USItype) (sh)), \
|
|
|
998 "=&r" ((USItype) (sl)) \
|
|
|
999 : "0" ((USItype) (ah)), \
|
|
|
1000 "r" ((USItype) (bh)), \
|
|
|
1001 "1" ((USItype) (al)), \
|
|
|
1002 "r" ((USItype) (bl)))
|
|
|
1003 #define umul_ppmm(ph, pl, m0, m1) \
|
|
|
1004 do { \
|
|
|
1005 USItype __m0 = (m0), __m1 = (m1); \
|
|
|
1006 __asm__ ( \
|
|
|
1007 "s r2,r2\n" \
|
|
|
1008 " mts r10,%2\n" \
|
|
|
1009 " m r2,%3\n" \
|
|
|
1010 " m r2,%3\n" \
|
|
|
1011 " m r2,%3\n" \
|
|
|
1012 " m r2,%3\n" \
|
|
|
1013 " m r2,%3\n" \
|
|
|
1014 " m r2,%3\n" \
|
|
|
1015 " m r2,%3\n" \
|
|
|
1016 " m r2,%3\n" \
|
|
|
1017 " m r2,%3\n" \
|
|
|
1018 " m r2,%3\n" \
|
|
|
1019 " m r2,%3\n" \
|
|
|
1020 " m r2,%3\n" \
|
|
|
1021 " m r2,%3\n" \
|
|
|
1022 " m r2,%3\n" \
|
|
|
1023 " m r2,%3\n" \
|
|
|
1024 " m r2,%3\n" \
|
|
|
1025 " cas %0,r2,r0\n" \
|
|
|
1026 " mfs r10,%1" \
|
|
|
1027 : "=r" ((USItype) (ph)), \
|
|
|
1028 "=r" ((USItype) (pl)) \
|
|
|
1029 : "%r" (__m0), \
|
|
|
1030 "r" (__m1) \
|
|
|
1031 : "r2"); \
|
|
|
1032 (ph) += ((((SItype) __m0 >> 31) & __m1) \
|
|
|
1033 + (((SItype) __m1 >> 31) & __m0)); \
|
|
|
1034 } while (0)
|
|
|
1035 #define UMUL_TIME 20
|
|
|
1036 #define UDIV_TIME 200
|
|
|
1037 #define count_leading_zeros(count, x) \
|
|
|
1038 do { \
|
|
|
1039 if ((x) >= 0x10000) \
|
|
|
1040 __asm__ ("clz %0,%1" \
|
|
|
1041 : "=r" ((USItype) (count)) \
|
|
|
1042 : "r" ((USItype) (x) >> 16)); \
|
|
|
1043 else \
|
|
|
1044 { \
|
|
|
1045 __asm__ ("clz %0,%1" \
|
|
|
1046 : "=r" ((USItype) (count)) \
|
|
|
1047 : "r" ((USItype) (x))); \
|
|
|
1048 (count) += 16; \
|
|
|
1049 } \
|
|
|
1050 } while (0)
|
|
|
1051 #endif
|
|
|
1052
|
|
|
1053 #if defined(__sh__) && W_TYPE_SIZE == 32
|
|
|
1054 #ifndef __sh1__
|
|
|
1055 #define umul_ppmm(w1, w0, u, v) \
|
|
|
1056 __asm__ ( \
|
|
|
1057 "dmulu.l %2,%3\n\tsts%M1 macl,%1\n\tsts%M0 mach,%0" \
|
|
|
1058 : "=r<" ((USItype)(w1)), \
|
|
|
1059 "=r<" ((USItype)(w0)) \
|
|
|
1060 : "r" ((USItype)(u)), \
|
|
|
1061 "r" ((USItype)(v)) \
|
|
|
1062 : "macl", "mach")
|
|
|
1063 #define UMUL_TIME 5
|
|
|
1064 #endif
|
|
|
1065
|
|
|
1066 /* This is the same algorithm as __udiv_qrnnd_c. */
|
|
|
1067 #define UDIV_NEEDS_NORMALIZATION 1
|
|
|
1068
|
|
|
1069 #ifdef __FDPIC__
|
|
|
1070 /* FDPIC needs a special version of the asm fragment to extract the
|
|
|
1071 code address from the function descriptor. __udiv_qrnnd_16 is
|
|
|
1072 assumed to be local and not to use the GOT, so loading r12 is
|
|
|
1073 not needed. */
|
|
|
1074 #define udiv_qrnnd(q, r, n1, n0, d) \
|
|
|
1075 do { \
|
|
|
1076 extern UWtype __udiv_qrnnd_16 (UWtype, UWtype) \
|
|
|
1077 __attribute__ ((visibility ("hidden"))); \
|
|
|
1078 /* r0: rn r1: qn */ /* r0: n1 r4: n0 r5: d r6: d1 */ /* r2: __m */ \
|
|
|
1079 __asm__ ( \
|
|
|
1080 "mov%M4 %4,r5\n" \
|
|
|
1081 " swap.w %3,r4\n" \
|
|
|
1082 " swap.w r5,r6\n" \
|
|
|
1083 " mov.l @%5,r2\n" \
|
|
|
1084 " jsr @r2\n" \
|
|
|
1085 " shll16 r6\n" \
|
|
|
1086 " swap.w r4,r4\n" \
|
|
|
1087 " mov.l @%5,r2\n" \
|
|
|
1088 " jsr @r2\n" \
|
|
|
1089 " swap.w r1,%0\n" \
|
|
|
1090 " or r1,%0" \
|
|
|
1091 : "=r" (q), "=&z" (r) \
|
|
|
1092 : "1" (n1), "r" (n0), "rm" (d), "r" (&__udiv_qrnnd_16) \
|
|
|
1093 : "r1", "r2", "r4", "r5", "r6", "pr", "t"); \
|
|
|
1094 } while (0)
|
|
|
1095 #else
|
|
|
1096 #define udiv_qrnnd(q, r, n1, n0, d) \
|
|
|
1097 do { \
|
|
|
1098 extern UWtype __udiv_qrnnd_16 (UWtype, UWtype) \
|
|
|
1099 __attribute__ ((visibility ("hidden"))); \
|
|
|
1100 /* r0: rn r1: qn */ /* r0: n1 r4: n0 r5: d r6: d1 */ /* r2: __m */ \
|
|
|
1101 __asm__ ( \
|
|
|
1102 "mov%M4 %4,r5\n" \
|
|
|
1103 " swap.w %3,r4\n" \
|
|
|
1104 " swap.w r5,r6\n" \
|
|
|
1105 " jsr @%5\n" \
|
|
|
1106 " shll16 r6\n" \
|
|
|
1107 " swap.w r4,r4\n" \
|
|
|
1108 " jsr @%5\n" \
|
|
|
1109 " swap.w r1,%0\n" \
|
|
|
1110 " or r1,%0" \
|
|
|
1111 : "=r" (q), "=&z" (r) \
|
|
|
1112 : "1" (n1), "r" (n0), "rm" (d), "r" (&__udiv_qrnnd_16) \
|
|
|
1113 : "r1", "r2", "r4", "r5", "r6", "pr", "t"); \
|
|
|
1114 } while (0)
|
|
|
1115 #endif /* __FDPIC__ */
|
|
|
1116
|
|
|
1117 #define UDIV_TIME 80
|
|
|
1118
|
|
|
1119 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
1120 __asm__ ("clrt;subc %5,%1; subc %4,%0" \
|
|
|
1121 : "=r" (sh), "=r" (sl) \
|
|
|
1122 : "0" (ah), "1" (al), "r" (bh), "r" (bl) : "t")
|
|
|
1123
|
|
|
1124 #endif /* __sh__ */
|
|
|
1125
|
|
|
1126 #if defined (__sparc__) && !defined (__arch64__) && !defined (__sparcv9) \
|
|
|
1127 && W_TYPE_SIZE == 32
|
|
|
1128 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
1129 __asm__ ("addcc %r4,%5,%1\n\taddx %r2,%3,%0" \
|
|
|
1130 : "=r" ((USItype) (sh)), \
|
|
|
1131 "=&r" ((USItype) (sl)) \
|
|
|
1132 : "%rJ" ((USItype) (ah)), \
|
|
|
1133 "rI" ((USItype) (bh)), \
|
|
|
1134 "%rJ" ((USItype) (al)), \
|
|
|
1135 "rI" ((USItype) (bl)) \
|
|
|
1136 __CLOBBER_CC)
|
|
|
1137 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
1138 __asm__ ("subcc %r4,%5,%1\n\tsubx %r2,%3,%0" \
|
|
|
1139 : "=r" ((USItype) (sh)), \
|
|
|
1140 "=&r" ((USItype) (sl)) \
|
|
|
1141 : "rJ" ((USItype) (ah)), \
|
|
|
1142 "rI" ((USItype) (bh)), \
|
|
|
1143 "rJ" ((USItype) (al)), \
|
|
|
1144 "rI" ((USItype) (bl)) \
|
|
|
1145 __CLOBBER_CC)
|
|
|
1146 #if defined (__sparc_v9__)
|
|
|
1147 #define umul_ppmm(w1, w0, u, v) \
|
|
|
1148 do { \
|
|
|
1149 register USItype __g1 asm ("g1"); \
|
|
|
1150 __asm__ ("umul\t%2,%3,%1\n\t" \
|
|
|
1151 "srlx\t%1, 32, %0" \
|
|
|
1152 : "=r" ((USItype) (w1)), \
|
|
|
1153 "=r" (__g1) \
|
|
|
1154 : "r" ((USItype) (u)), \
|
|
|
1155 "r" ((USItype) (v))); \
|
|
|
1156 (w0) = __g1; \
|
|
|
1157 } while (0)
|
|
|
1158 #define udiv_qrnnd(__q, __r, __n1, __n0, __d) \
|
|
|
1159 __asm__ ("mov\t%2,%%y\n\t" \
|
|
|
1160 "udiv\t%3,%4,%0\n\t" \
|
|
|
1161 "umul\t%0,%4,%1\n\t" \
|
|
|
1162 "sub\t%3,%1,%1" \
|
|
|
1163 : "=&r" ((USItype) (__q)), \
|
|
|
1164 "=&r" ((USItype) (__r)) \
|
|
|
1165 : "r" ((USItype) (__n1)), \
|
|
|
1166 "r" ((USItype) (__n0)), \
|
|
|
1167 "r" ((USItype) (__d)))
|
|
|
1168 #else
|
|
|
1169 #if defined (__sparc_v8__)
|
|
|
1170 #define umul_ppmm(w1, w0, u, v) \
|
|
|
1171 __asm__ ("umul %2,%3,%1;rd %%y,%0" \
|
|
|
1172 : "=r" ((USItype) (w1)), \
|
|
|
1173 "=r" ((USItype) (w0)) \
|
|
|
1174 : "r" ((USItype) (u)), \
|
|
|
1175 "r" ((USItype) (v)))
|
|
|
1176 #define udiv_qrnnd(__q, __r, __n1, __n0, __d) \
|
|
|
1177 __asm__ ("mov %2,%%y;nop;nop;nop;udiv %3,%4,%0;umul %0,%4,%1;sub %3,%1,%1"\
|
|
|
1178 : "=&r" ((USItype) (__q)), \
|
|
|
1179 "=&r" ((USItype) (__r)) \
|
|
|
1180 : "r" ((USItype) (__n1)), \
|
|
|
1181 "r" ((USItype) (__n0)), \
|
|
|
1182 "r" ((USItype) (__d)))
|
|
|
1183 #else
|
|
|
1184 #if defined (__sparclite__)
|
|
|
1185 /* This has hardware multiply but not divide. It also has two additional
|
|
|
1186 instructions scan (ffs from high bit) and divscc. */
|
|
|
1187 #define umul_ppmm(w1, w0, u, v) \
|
|
|
1188 __asm__ ("umul %2,%3,%1;rd %%y,%0" \
|
|
|
1189 : "=r" ((USItype) (w1)), \
|
|
|
1190 "=r" ((USItype) (w0)) \
|
|
|
1191 : "r" ((USItype) (u)), \
|
|
|
1192 "r" ((USItype) (v)))
|
|
|
1193 #define udiv_qrnnd(q, r, n1, n0, d) \
|
|
|
1194 __asm__ ("! Inlined udiv_qrnnd\n" \
|
|
|
1195 " wr %%g0,%2,%%y ! Not a delayed write for sparclite\n" \
|
|
|
1196 " tst %%g0\n" \
|
|
|
1197 " divscc %3,%4,%%g1\n" \
|
|
|
1198 " divscc %%g1,%4,%%g1\n" \
|
|
|
1199 " divscc %%g1,%4,%%g1\n" \
|
|
|
1200 " divscc %%g1,%4,%%g1\n" \
|
|
|
1201 " divscc %%g1,%4,%%g1\n" \
|
|
|
1202 " divscc %%g1,%4,%%g1\n" \
|
|
|
1203 " divscc %%g1,%4,%%g1\n" \
|
|
|
1204 " divscc %%g1,%4,%%g1\n" \
|
|
|
1205 " divscc %%g1,%4,%%g1\n" \
|
|
|
1206 " divscc %%g1,%4,%%g1\n" \
|
|
|
1207 " divscc %%g1,%4,%%g1\n" \
|
|
|
1208 " divscc %%g1,%4,%%g1\n" \
|
|
|
1209 " divscc %%g1,%4,%%g1\n" \
|
|
|
1210 " divscc %%g1,%4,%%g1\n" \
|
|
|
1211 " divscc %%g1,%4,%%g1\n" \
|
|
|
1212 " divscc %%g1,%4,%%g1\n" \
|
|
|
1213 " divscc %%g1,%4,%%g1\n" \
|
|
|
1214 " divscc %%g1,%4,%%g1\n" \
|
|
|
1215 " divscc %%g1,%4,%%g1\n" \
|
|
|
1216 " divscc %%g1,%4,%%g1\n" \
|
|
|
1217 " divscc %%g1,%4,%%g1\n" \
|
|
|
1218 " divscc %%g1,%4,%%g1\n" \
|
|
|
1219 " divscc %%g1,%4,%%g1\n" \
|
|
|
1220 " divscc %%g1,%4,%%g1\n" \
|
|
|
1221 " divscc %%g1,%4,%%g1\n" \
|
|
|
1222 " divscc %%g1,%4,%%g1\n" \
|
|
|
1223 " divscc %%g1,%4,%%g1\n" \
|
|
|
1224 " divscc %%g1,%4,%%g1\n" \
|
|
|
1225 " divscc %%g1,%4,%%g1\n" \
|
|
|
1226 " divscc %%g1,%4,%%g1\n" \
|
|
|
1227 " divscc %%g1,%4,%%g1\n" \
|
|
|
1228 " divscc %%g1,%4,%0\n" \
|
|
|
1229 " rd %%y,%1\n" \
|
|
|
1230 " bl,a 1f\n" \
|
|
|
1231 " add %1,%4,%1\n" \
|
|
|
1232 "1: ! End of inline udiv_qrnnd" \
|
|
|
1233 : "=r" ((USItype) (q)), \
|
|
|
1234 "=r" ((USItype) (r)) \
|
|
|
1235 : "r" ((USItype) (n1)), \
|
|
|
1236 "r" ((USItype) (n0)), \
|
|
|
1237 "rI" ((USItype) (d)) \
|
|
|
1238 : "g1" __AND_CLOBBER_CC)
|
|
|
1239 #define UDIV_TIME 37
|
|
|
1240 #define count_leading_zeros(count, x) \
|
|
|
1241 do { \
|
|
|
1242 __asm__ ("scan %1,1,%0" \
|
|
|
1243 : "=r" ((USItype) (count)) \
|
|
|
1244 : "r" ((USItype) (x))); \
|
|
|
1245 } while (0)
|
|
|
1246 /* Early sparclites return 63 for an argument of 0, but they warn that future
|
|
|
1247 implementations might change this. Therefore, leave COUNT_LEADING_ZEROS_0
|
|
|
1248 undefined. */
|
|
|
1249 #else
|
|
|
1250 /* SPARC without integer multiplication and divide instructions.
|
|
|
1251 (i.e. at least Sun4/20,40,60,65,75,110,260,280,330,360,380,470,490) */
|
|
|
1252 #define umul_ppmm(w1, w0, u, v) \
|
|
|
1253 __asm__ ("! Inlined umul_ppmm\n" \
|
|
|
1254 " wr %%g0,%2,%%y ! SPARC has 0-3 delay insn after a wr\n"\
|
|
|
1255 " sra %3,31,%%o5 ! Don't move this insn\n" \
|
|
|
1256 " and %2,%%o5,%%o5 ! Don't move this insn\n" \
|
|
|
1257 " andcc %%g0,0,%%g1 ! Don't move this insn\n" \
|
|
|
1258 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1259 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1260 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1261 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1262 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1263 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1264 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1265 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1266 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1267 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1268 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1269 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1270 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1271 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1272 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1273 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1274 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1275 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1276 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1277 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1278 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1279 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1280 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1281 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1282 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1283 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1284 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1285 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1286 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1287 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1288 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1289 " mulscc %%g1,%3,%%g1\n" \
|
|
|
1290 " mulscc %%g1,0,%%g1\n" \
|
|
|
1291 " add %%g1,%%o5,%0\n" \
|
|
|
1292 " rd %%y,%1" \
|
|
|
1293 : "=r" ((USItype) (w1)), \
|
|
|
1294 "=r" ((USItype) (w0)) \
|
|
|
1295 : "%rI" ((USItype) (u)), \
|
|
|
1296 "r" ((USItype) (v)) \
|
|
|
1297 : "g1", "o5" __AND_CLOBBER_CC)
|
|
|
1298 #define UMUL_TIME 39 /* 39 instructions */
|
|
|
1299 /* It's quite necessary to add this much assembler for the sparc.
|
|
|
1300 The default udiv_qrnnd (in C) is more than 10 times slower! */
|
|
|
1301 #define udiv_qrnnd(__q, __r, __n1, __n0, __d) \
|
|
|
1302 __asm__ ("! Inlined udiv_qrnnd\n" \
|
|
|
1303 " mov 32,%%g1\n" \
|
|
|
1304 " subcc %1,%2,%%g0\n" \
|
|
|
1305 "1: bcs 5f\n" \
|
|
|
1306 " addxcc %0,%0,%0 ! shift n1n0 and a q-bit in lsb\n" \
|
|
|
1307 " sub %1,%2,%1 ! this kills msb of n\n" \
|
|
|
1308 " addx %1,%1,%1 ! so this can't give carry\n" \
|
|
|
1309 " subcc %%g1,1,%%g1\n" \
|
|
|
1310 "2: bne 1b\n" \
|
|
|
1311 " subcc %1,%2,%%g0\n" \
|
|
|
1312 " bcs 3f\n" \
|
|
|
1313 " addxcc %0,%0,%0 ! shift n1n0 and a q-bit in lsb\n" \
|
|
|
1314 " b 3f\n" \
|
|
|
1315 " sub %1,%2,%1 ! this kills msb of n\n" \
|
|
|
1316 "4: sub %1,%2,%1\n" \
|
|
|
1317 "5: addxcc %1,%1,%1\n" \
|
|
|
1318 " bcc 2b\n" \
|
|
|
1319 " subcc %%g1,1,%%g1\n" \
|
|
|
1320 "! Got carry from n. Subtract next step to cancel this carry.\n" \
|
|
|
1321 " bne 4b\n" \
|
|
|
1322 " addcc %0,%0,%0 ! shift n1n0 and a 0-bit in lsb\n" \
|
|
|
1323 " sub %1,%2,%1\n" \
|
|
|
1324 "3: xnor %0,0,%0\n" \
|
|
|
1325 " ! End of inline udiv_qrnnd" \
|
|
|
1326 : "=&r" ((USItype) (__q)), \
|
|
|
1327 "=&r" ((USItype) (__r)) \
|
|
|
1328 : "r" ((USItype) (__d)), \
|
|
|
1329 "1" ((USItype) (__n1)), \
|
|
|
1330 "0" ((USItype) (__n0)) : "g1" __AND_CLOBBER_CC)
|
|
|
1331 #define UDIV_TIME (3+7*32) /* 7 instructions/iteration. 32 iterations. */
|
|
|
1332 #endif /* __sparclite__ */
|
|
|
1333 #endif /* __sparc_v8__ */
|
|
|
1334 #endif /* __sparc_v9__ */
|
|
|
1335 #endif /* sparc32 */
|
|
|
1336
|
|
|
1337 #if ((defined (__sparc__) && defined (__arch64__)) || defined (__sparcv9)) \
|
|
|
1338 && W_TYPE_SIZE == 64
|
|
|
1339 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
1340 do { \
|
|
|
1341 UDItype __carry = 0; \
|
|
|
1342 __asm__ ("addcc\t%r5,%6,%1\n\t" \
|
|
|
1343 "add\t%r3,%4,%0\n\t" \
|
|
|
1344 "movcs\t%%xcc, 1, %2\n\t" \
|
|
|
1345 "add\t%0, %2, %0" \
|
|
|
1346 : "=r" ((UDItype)(sh)), \
|
|
|
1347 "=&r" ((UDItype)(sl)), \
|
|
|
1348 "+r" (__carry) \
|
|
|
1349 : "%rJ" ((UDItype)(ah)), \
|
|
|
1350 "rI" ((UDItype)(bh)), \
|
|
|
1351 "%rJ" ((UDItype)(al)), \
|
|
|
1352 "rI" ((UDItype)(bl)) \
|
|
|
1353 __CLOBBER_CC); \
|
|
|
1354 } while (0)
|
|
|
1355
|
|
|
1356 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
1357 do { \
|
|
|
1358 UDItype __carry = 0; \
|
|
|
1359 __asm__ ("subcc\t%r5,%6,%1\n\t" \
|
|
|
1360 "sub\t%r3,%4,%0\n\t" \
|
|
|
1361 "movcs\t%%xcc, 1, %2\n\t" \
|
|
|
1362 "sub\t%0, %2, %0" \
|
|
|
1363 : "=r" ((UDItype)(sh)), \
|
|
|
1364 "=&r" ((UDItype)(sl)), \
|
|
|
1365 "+r" (__carry) \
|
|
|
1366 : "%rJ" ((UDItype)(ah)), \
|
|
|
1367 "rI" ((UDItype)(bh)), \
|
|
|
1368 "%rJ" ((UDItype)(al)), \
|
|
|
1369 "rI" ((UDItype)(bl)) \
|
|
|
1370 __CLOBBER_CC); \
|
|
|
1371 } while (0)
|
|
|
1372
|
|
|
1373 #define umul_ppmm(wh, wl, u, v) \
|
|
|
1374 do { \
|
|
|
1375 UDItype tmp1, tmp2, tmp3, tmp4; \
|
|
|
1376 __asm__ __volatile__ ( \
|
|
|
1377 "srl %7,0,%3\n\t" \
|
|
|
1378 "mulx %3,%6,%1\n\t" \
|
|
|
1379 "srlx %6,32,%2\n\t" \
|
|
|
1380 "mulx %2,%3,%4\n\t" \
|
|
|
1381 "sllx %4,32,%5\n\t" \
|
|
|
1382 "srl %6,0,%3\n\t" \
|
|
|
1383 "sub %1,%5,%5\n\t" \
|
|
|
1384 "srlx %5,32,%5\n\t" \
|
|
|
1385 "addcc %4,%5,%4\n\t" \
|
|
|
1386 "srlx %7,32,%5\n\t" \
|
|
|
1387 "mulx %3,%5,%3\n\t" \
|
|
|
1388 "mulx %2,%5,%5\n\t" \
|
|
|
1389 "sethi %%hi(0x80000000),%2\n\t" \
|
|
|
1390 "addcc %4,%3,%4\n\t" \
|
|
|
1391 "srlx %4,32,%4\n\t" \
|
|
|
1392 "add %2,%2,%2\n\t" \
|
|
|
1393 "movcc %%xcc,%%g0,%2\n\t" \
|
|
|
1394 "addcc %5,%4,%5\n\t" \
|
|
|
1395 "sllx %3,32,%3\n\t" \
|
|
|
1396 "add %1,%3,%1\n\t" \
|
|
|
1397 "add %5,%2,%0" \
|
|
|
1398 : "=r" ((UDItype)(wh)), \
|
|
|
1399 "=&r" ((UDItype)(wl)), \
|
|
|
1400 "=&r" (tmp1), "=&r" (tmp2), "=&r" (tmp3), "=&r" (tmp4) \
|
|
|
1401 : "r" ((UDItype)(u)), \
|
|
|
1402 "r" ((UDItype)(v)) \
|
|
|
1403 __CLOBBER_CC); \
|
|
|
1404 } while (0)
|
|
|
1405 #define UMUL_TIME 96
|
|
|
1406 #define UDIV_TIME 230
|
|
|
1407 #endif /* sparc64 */
|
|
|
1408
|
|
|
1409 #if defined (__vax__) && W_TYPE_SIZE == 32
|
|
|
1410 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
1411 __asm__ ("addl2 %5,%1\n\tadwc %3,%0" \
|
|
|
1412 : "=g" ((USItype) (sh)), \
|
|
|
1413 "=&g" ((USItype) (sl)) \
|
|
|
1414 : "%0" ((USItype) (ah)), \
|
|
|
1415 "g" ((USItype) (bh)), \
|
|
|
1416 "%1" ((USItype) (al)), \
|
|
|
1417 "g" ((USItype) (bl)))
|
|
|
1418 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
1419 __asm__ ("subl2 %5,%1\n\tsbwc %3,%0" \
|
|
|
1420 : "=g" ((USItype) (sh)), \
|
|
|
1421 "=&g" ((USItype) (sl)) \
|
|
|
1422 : "0" ((USItype) (ah)), \
|
|
|
1423 "g" ((USItype) (bh)), \
|
|
|
1424 "1" ((USItype) (al)), \
|
|
|
1425 "g" ((USItype) (bl)))
|
|
|
1426 #define umul_ppmm(xh, xl, m0, m1) \
|
|
|
1427 do { \
|
|
|
1428 union { \
|
|
|
1429 UDItype __ll; \
|
|
|
1430 struct {USItype __l, __h;} __i; \
|
|
|
1431 } __xx; \
|
|
|
1432 USItype __m0 = (m0), __m1 = (m1); \
|
|
|
1433 __asm__ ("emul %1,%2,$0,%0" \
|
|
|
1434 : "=r" (__xx.__ll) \
|
|
|
1435 : "g" (__m0), \
|
|
|
1436 "g" (__m1)); \
|
|
|
1437 (xh) = __xx.__i.__h; \
|
|
|
1438 (xl) = __xx.__i.__l; \
|
|
|
1439 (xh) += ((((SItype) __m0 >> 31) & __m1) \
|
|
|
1440 + (((SItype) __m1 >> 31) & __m0)); \
|
|
|
1441 } while (0)
|
|
|
1442 #define sdiv_qrnnd(q, r, n1, n0, d) \
|
|
|
1443 do { \
|
|
|
1444 union {DItype __ll; \
|
|
|
1445 struct {SItype __l, __h;} __i; \
|
|
|
1446 } __xx; \
|
|
|
1447 __xx.__i.__h = n1; __xx.__i.__l = n0; \
|
|
|
1448 __asm__ ("ediv %3,%2,%0,%1" \
|
|
|
1449 : "=g" (q), "=g" (r) \
|
|
|
1450 : "g" (__xx.__ll), "g" (d)); \
|
|
|
1451 } while (0)
|
|
|
1452 #endif /* __vax__ */
|
|
|
1453
|
|
|
1454 #ifdef _TMS320C6X
|
|
|
1455 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
1456 do \
|
|
|
1457 { \
|
|
|
1458 UDItype __ll; \
|
|
|
1459 __asm__ ("addu .l1 %1, %2, %0" \
|
|
|
1460 : "=a" (__ll) : "a" (al), "a" (bl)); \
|
|
|
1461 (sl) = (USItype)__ll; \
|
|
|
1462 (sh) = ((USItype)(__ll >> 32)) + (ah) + (bh); \
|
|
|
1463 } \
|
|
|
1464 while (0)
|
|
|
1465
|
|
|
1466 #ifdef _TMS320C6400_PLUS
|
|
|
1467 #define __umulsidi3(u,v) ((UDItype)(USItype)u*(USItype)v)
|
|
|
1468 #define umul_ppmm(w1, w0, u, v) \
|
|
|
1469 do { \
|
|
|
1470 UDItype __x = (UDItype) (USItype) (u) * (USItype) (v); \
|
|
|
1471 (w1) = (USItype) (__x >> 32); \
|
|
|
1472 (w0) = (USItype) (__x); \
|
|
|
1473 } while (0)
|
|
|
1474 #endif /* _TMS320C6400_PLUS */
|
|
|
1475
|
|
|
1476 #define count_leading_zeros(count, x) ((count) = __builtin_clz (x))
|
|
|
1477 #ifdef _TMS320C6400
|
|
|
1478 #define count_trailing_zeros(count, x) ((count) = __builtin_ctz (x))
|
|
|
1479 #endif
|
|
|
1480 #define UMUL_TIME 4
|
|
|
1481 #define UDIV_TIME 40
|
|
|
1482 #endif /* _TMS320C6X */
|
|
|
1483
|
|
|
1484 #if defined (__xtensa__) && W_TYPE_SIZE == 32
|
|
|
1485 /* This code is not Xtensa-configuration-specific, so rely on the compiler
|
|
|
1486 to expand builtin functions depending on what configuration features
|
|
|
1487 are available. This avoids library calls when the operation can be
|
|
|
1488 performed in-line. */
|
|
|
1489 #define umul_ppmm(w1, w0, u, v) \
|
|
|
1490 do { \
|
|
|
1491 DWunion __w; \
|
|
|
1492 __w.ll = __builtin_umulsidi3 (u, v); \
|
|
|
1493 w1 = __w.s.high; \
|
|
|
1494 w0 = __w.s.low; \
|
|
|
1495 } while (0)
|
|
|
1496 #define __umulsidi3(u, v) __builtin_umulsidi3 (u, v)
|
|
|
1497 #define count_leading_zeros(COUNT, X) ((COUNT) = __builtin_clz (X))
|
|
|
1498 #define count_trailing_zeros(COUNT, X) ((COUNT) = __builtin_ctz (X))
|
|
|
1499 #endif /* __xtensa__ */
|
|
|
1500
|
|
|
1501 #if defined xstormy16
|
|
|
1502 extern UHItype __stormy16_count_leading_zeros (UHItype);
|
|
|
1503 #define count_leading_zeros(count, x) \
|
|
|
1504 do \
|
|
|
1505 { \
|
|
|
1506 UHItype size; \
|
|
|
1507 \
|
|
|
1508 /* We assume that W_TYPE_SIZE is a multiple of 16... */ \
|
|
|
1509 for ((count) = 0, size = W_TYPE_SIZE; size; size -= 16) \
|
|
|
1510 { \
|
|
|
1511 UHItype c; \
|
|
|
1512 \
|
|
|
1513 c = __clzhi2 ((x) >> (size - 16)); \
|
|
|
1514 (count) += c; \
|
|
|
1515 if (c != 16) \
|
|
|
1516 break; \
|
|
|
1517 } \
|
|
|
1518 } \
|
|
|
1519 while (0)
|
|
|
1520 #define COUNT_LEADING_ZEROS_0 W_TYPE_SIZE
|
|
|
1521 #endif
|
|
|
1522
|
|
|
1523 #if defined (__z8000__) && W_TYPE_SIZE == 16
|
|
|
1524 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
1525 __asm__ ("add %H1,%H5\n\tadc %H0,%H3" \
|
|
|
1526 : "=r" ((unsigned int)(sh)), \
|
|
|
1527 "=&r" ((unsigned int)(sl)) \
|
|
|
1528 : "%0" ((unsigned int)(ah)), \
|
|
|
1529 "r" ((unsigned int)(bh)), \
|
|
|
1530 "%1" ((unsigned int)(al)), \
|
|
|
1531 "rQR" ((unsigned int)(bl)))
|
|
|
1532 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
1533 __asm__ ("sub %H1,%H5\n\tsbc %H0,%H3" \
|
|
|
1534 : "=r" ((unsigned int)(sh)), \
|
|
|
1535 "=&r" ((unsigned int)(sl)) \
|
|
|
1536 : "0" ((unsigned int)(ah)), \
|
|
|
1537 "r" ((unsigned int)(bh)), \
|
|
|
1538 "1" ((unsigned int)(al)), \
|
|
|
1539 "rQR" ((unsigned int)(bl)))
|
|
|
1540 #define umul_ppmm(xh, xl, m0, m1) \
|
|
|
1541 do { \
|
|
|
1542 union {long int __ll; \
|
|
|
1543 struct {unsigned int __h, __l;} __i; \
|
|
|
1544 } __xx; \
|
|
|
1545 unsigned int __m0 = (m0), __m1 = (m1); \
|
|
|
1546 __asm__ ("mult %S0,%H3" \
|
|
|
1547 : "=r" (__xx.__i.__h), \
|
|
|
1548 "=r" (__xx.__i.__l) \
|
|
|
1549 : "%1" (__m0), \
|
|
|
1550 "rQR" (__m1)); \
|
|
|
1551 (xh) = __xx.__i.__h; (xl) = __xx.__i.__l; \
|
|
|
1552 (xh) += ((((signed int) __m0 >> 15) & __m1) \
|
|
|
1553 + (((signed int) __m1 >> 15) & __m0)); \
|
|
|
1554 } while (0)
|
|
|
1555 #endif /* __z8000__ */
|
|
|
1556
|
|
|
1557 #endif /* __GNUC__ */
|
|
|
1558
|
|
|
1559 /* If this machine has no inline assembler, use C macros. */
|
|
|
1560
|
|
|
1561 #if !defined (add_ssaaaa)
|
|
|
1562 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
|
|
|
1563 do { \
|
|
|
1564 UWtype __x; \
|
|
|
1565 __x = (al) + (bl); \
|
|
|
1566 (sh) = (ah) + (bh) + (__x < (al)); \
|
|
|
1567 (sl) = __x; \
|
|
|
1568 } while (0)
|
|
|
1569 #endif
|
|
|
1570
|
|
|
1571 #if !defined (sub_ddmmss)
|
|
|
1572 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
|
|
|
1573 do { \
|
|
|
1574 UWtype __x; \
|
|
|
1575 __x = (al) - (bl); \
|
|
|
1576 (sh) = (ah) - (bh) - (__x > (al)); \
|
|
|
1577 (sl) = __x; \
|
|
|
1578 } while (0)
|
|
|
1579 #endif
|
|
|
1580
|
|
|
1581 /* If we lack umul_ppmm but have smul_ppmm, define umul_ppmm in terms of
|
|
|
1582 smul_ppmm. */
|
|
|
1583 #if !defined (umul_ppmm) && defined (smul_ppmm)
|
|
|
1584 #define umul_ppmm(w1, w0, u, v) \
|
|
|
1585 do { \
|
|
|
1586 UWtype __w1; \
|
|
|
1587 UWtype __xm0 = (u), __xm1 = (v); \
|
|
|
1588 smul_ppmm (__w1, w0, __xm0, __xm1); \
|
|
|
1589 (w1) = __w1 + (-(__xm0 >> (W_TYPE_SIZE - 1)) & __xm1) \
|
|
|
1590 + (-(__xm1 >> (W_TYPE_SIZE - 1)) & __xm0); \
|
|
|
1591 } while (0)
|
|
|
1592 #endif
|
|
|
1593
|
|
|
1594 /* If we still don't have umul_ppmm, define it using plain C. */
|
|
|
1595 #if !defined (umul_ppmm)
|
|
|
1596 #define umul_ppmm(w1, w0, u, v) \
|
|
|
1597 do { \
|
|
|
1598 UWtype __x0, __x1, __x2, __x3; \
|
|
|
1599 UHWtype __ul, __vl, __uh, __vh; \
|
|
|
1600 \
|
|
|
1601 __ul = __ll_lowpart (u); \
|
|
|
1602 __uh = __ll_highpart (u); \
|
|
|
1603 __vl = __ll_lowpart (v); \
|
|
|
1604 __vh = __ll_highpart (v); \
|
|
|
1605 \
|
|
|
1606 __x0 = (UWtype) __ul * __vl; \
|
|
|
1607 __x1 = (UWtype) __ul * __vh; \
|
|
|
1608 __x2 = (UWtype) __uh * __vl; \
|
|
|
1609 __x3 = (UWtype) __uh * __vh; \
|
|
|
1610 \
|
|
|
1611 __x1 += __ll_highpart (__x0);/* this can't give carry */ \
|
|
|
1612 __x1 += __x2; /* but this indeed can */ \
|
|
|
1613 if (__x1 < __x2) /* did we get it? */ \
|
|
|
1614 __x3 += __ll_B; /* yes, add it in the proper pos. */ \
|
|
|
1615 \
|
|
|
1616 (w1) = __x3 + __ll_highpart (__x1); \
|
|
|
1617 (w0) = __ll_lowpart (__x1) * __ll_B + __ll_lowpart (__x0); \
|
|
|
1618 } while (0)
|
|
|
1619 #endif
|
|
|
1620
|
|
|
1621 #if !defined (__umulsidi3)
|
|
|
1622 #define __umulsidi3(u, v) \
|
|
|
1623 ({DWunion __w; \
|
|
|
1624 umul_ppmm (__w.s.high, __w.s.low, u, v); \
|
|
|
1625 __w.ll; })
|
|
|
1626 #endif
|
|
|
1627
|
|
|
1628 /* Define this unconditionally, so it can be used for debugging. */
|
|
|
1629 #define __udiv_qrnnd_c(q, r, n1, n0, d) \
|
|
|
1630 do { \
|
|
|
1631 UWtype __d1, __d0, __q1, __q0; \
|
|
|
1632 UWtype __r1, __r0, __m; \
|
|
|
1633 __d1 = __ll_highpart (d); \
|
|
|
1634 __d0 = __ll_lowpart (d); \
|
|
|
1635 \
|
|
|
1636 __r1 = (n1) % __d1; \
|
|
|
1637 __q1 = (n1) / __d1; \
|
|
|
1638 __m = (UWtype) __q1 * __d0; \
|
|
|
1639 __r1 = __r1 * __ll_B | __ll_highpart (n0); \
|
|
|
1640 if (__r1 < __m) \
|
|
|
1641 { \
|
|
|
1642 __q1--, __r1 += (d); \
|
|
|
1643 if (__r1 >= (d)) /* i.e. we didn't get carry when adding to __r1 */\
|
|
|
1644 if (__r1 < __m) \
|
|
|
1645 __q1--, __r1 += (d); \
|
|
|
1646 } \
|
|
|
1647 __r1 -= __m; \
|
|
|
1648 \
|
|
|
1649 __r0 = __r1 % __d1; \
|
|
|
1650 __q0 = __r1 / __d1; \
|
|
|
1651 __m = (UWtype) __q0 * __d0; \
|
|
|
1652 __r0 = __r0 * __ll_B | __ll_lowpart (n0); \
|
|
|
1653 if (__r0 < __m) \
|
|
|
1654 { \
|
|
|
1655 __q0--, __r0 += (d); \
|
|
|
1656 if (__r0 >= (d)) \
|
|
|
1657 if (__r0 < __m) \
|
|
|
1658 __q0--, __r0 += (d); \
|
|
|
1659 } \
|
|
|
1660 __r0 -= __m; \
|
|
|
1661 \
|
|
|
1662 (q) = (UWtype) __q1 * __ll_B | __q0; \
|
|
|
1663 (r) = __r0; \
|
|
|
1664 } while (0)
|
|
|
1665
|
|
|
1666 /* If the processor has no udiv_qrnnd but sdiv_qrnnd, go through
|
|
|
1667 __udiv_w_sdiv (defined in libgcc or elsewhere). */
|
|
|
1668 #if !defined (udiv_qrnnd) && defined (sdiv_qrnnd)
|
|
|
1669 #define udiv_qrnnd(q, r, nh, nl, d) \
|
|
|
1670 do { \
|
|
|
1671 extern UWtype __udiv_w_sdiv (UWtype *, UWtype, UWtype, UWtype); \
|
|
|
1672 UWtype __r; \
|
|
|
1673 (q) = __udiv_w_sdiv (&__r, nh, nl, d); \
|
|
|
1674 (r) = __r; \
|
|
|
1675 } while (0)
|
|
|
1676 #endif
|
|
|
1677
|
|
|
1678 /* If udiv_qrnnd was not defined for this processor, use __udiv_qrnnd_c. */
|
|
|
1679 #if !defined (udiv_qrnnd)
|
|
|
1680 #define UDIV_NEEDS_NORMALIZATION 1
|
|
|
1681 #define udiv_qrnnd __udiv_qrnnd_c
|
|
|
1682 #endif
|
|
|
1683
|
|
|
1684 #if !defined (count_leading_zeros)
|
|
|
1685 #define count_leading_zeros(count, x) \
|
|
|
1686 do { \
|
|
|
1687 UWtype __xr = (x); \
|
|
|
1688 UWtype __a; \
|
|
|
1689 \
|
|
|
1690 if (W_TYPE_SIZE <= 32) \
|
|
|
1691 { \
|
|
|
1692 __a = __xr < ((UWtype)1<<2*__BITS4) \
|
|
|
1693 ? (__xr < ((UWtype)1<<__BITS4) ? 0 : __BITS4) \
|
|
|
1694 : (__xr < ((UWtype)1<<3*__BITS4) ? 2*__BITS4 : 3*__BITS4); \
|
|
|
1695 } \
|
|
|
1696 else \
|
|
|
1697 { \
|
|
|
1698 for (__a = W_TYPE_SIZE - 8; __a > 0; __a -= 8) \
|
|
|
1699 if (((__xr >> __a) & 0xff) != 0) \
|
|
|
1700 break; \
|
|
|
1701 } \
|
|
|
1702 \
|
|
|
1703 (count) = W_TYPE_SIZE - (__clz_tab[__xr >> __a] + __a); \
|
|
|
1704 } while (0)
|
|
|
1705 #define COUNT_LEADING_ZEROS_0 W_TYPE_SIZE
|
|
|
1706 #endif
|
|
|
1707
|
|
|
1708 #if !defined (count_trailing_zeros)
|
|
|
1709 /* Define count_trailing_zeros using count_leading_zeros. The latter might be
|
|
|
1710 defined in asm, but if it is not, the C version above is good enough. */
|
|
|
1711 #define count_trailing_zeros(count, x) \
|
|
|
1712 do { \
|
|
|
1713 UWtype __ctz_x = (x); \
|
|
|
1714 UWtype __ctz_c; \
|
|
|
1715 count_leading_zeros (__ctz_c, __ctz_x & -__ctz_x); \
|
|
|
1716 (count) = W_TYPE_SIZE - 1 - __ctz_c; \
|
|
|
1717 } while (0)
|
|
|
1718 #endif
|
|
|
1719
|
|
|
1720 #ifndef UDIV_NEEDS_NORMALIZATION
|
|
|
1721 #define UDIV_NEEDS_NORMALIZATION 0
|
|
|
1722 #endif
|
