Moved from stdio to stdlib
[kopensolaris-gnu/glibc.git] / stdlib / longlong.h
1 /* longlong.h -- definitions for mixed size 32/64 bit arithmetic.
2
3 Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
4
5 This file is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Library General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or (at your
8 option) any later version.
9
10 This file is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12 or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
13 License for more details.
14
15 You should have received a copy of the GNU Library General Public License
16 along with this file; see the file COPYING.LIB.  If not, write to
17 the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
18
19 /* You have to define the following before including this file:
20
21    UWtype -- An unsigned type, default type for operations (typically a "word")
22    UHWtype -- An unsigned type, at least half the size of UWtype.
23    UDWtype -- An unsigned type, at least twice as large a UWtype
24    W_TYPE_SIZE -- size in bits of UWtype
25
26    SItype, USItype -- Signed and unsigned 32 bit types.
27    DItype, UDItype -- Signed and unsigned 64 bit types.
28
29    On a 32 bit machine UWtype should typically be USItype;
30    on a 64 bit machine, UWtype should typically be UDItype.
31 */
32
33 #define __BITS4 (W_TYPE_SIZE / 4)
34 #define __ll_B ((UWtype) 1 << (W_TYPE_SIZE / 2))
35 #define __ll_lowpart(t) ((UWtype) (t) & (__ll_B - 1))
36 #define __ll_highpart(t) ((UWtype) (t) >> (W_TYPE_SIZE / 2))
37
38 /* Define auxiliary asm macros.
39
40    1) umul_ppmm(high_prod, low_prod, multipler, multiplicand) multiplies two
41    UWtype integers MULTIPLER and MULTIPLICAND, and generates a two UWtype
42    word product in HIGH_PROD and LOW_PROD.
43
44    2) __umulsidi3(a,b) multiplies two UWtype integers A and B, and returns a
45    UDWtype product.  This is just a variant of umul_ppmm.
46
47    3) udiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
48    denominator) divides a UDWtype, composed by the UWtype integers
49    HIGH_NUMERATOR and LOW_NUMERATOR, by DENOMINATOR and places the quotient
50    in QUOTIENT and the remainder in REMAINDER.  HIGH_NUMERATOR must be less
51    than DENOMINATOR for correct operation.  If, in addition, the most
52    significant bit of DENOMINATOR must be 1, then the pre-processor symbol
53    UDIV_NEEDS_NORMALIZATION is defined to 1.
54
55    4) sdiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
56    denominator).  Like udiv_qrnnd but the numbers are signed.  The quotient
57    is rounded towards 0.
58
59    5) count_leading_zeros(count, x) counts the number of zero-bits from the
60    msb to the first non-zero bit in the UWtype X.  This is the number of
61    steps X needs to be shifted left to set the msb.  Undefined for X == 0,
62    unless the symbol COUNT_LEADING_ZEROS_0 is defined to some value.
63
64    6) count_trailing_zeros(count, x) like count_leading_zeros, but counts
65    from the least significant end.
66
67    7) add_ssaaaa(high_sum, low_sum, high_addend_1, low_addend_1,
68    high_addend_2, low_addend_2) adds two UWtype integers, composed by
69    HIGH_ADDEND_1 and LOW_ADDEND_1, and HIGH_ADDEND_2 and LOW_ADDEND_2
70    respectively.  The result is placed in HIGH_SUM and LOW_SUM.  Overflow
71    (i.e. carry out) is not stored anywhere, and is lost.
72
73    8) sub_ddmmss(high_difference, low_difference, high_minuend, low_minuend,
74    high_subtrahend, low_subtrahend) subtracts two two-word UWtype integers,
75    composed by HIGH_MINUEND_1 and LOW_MINUEND_1, and HIGH_SUBTRAHEND_2 and
76    LOW_SUBTRAHEND_2 respectively.  The result is placed in HIGH_DIFFERENCE
77    and LOW_DIFFERENCE.  Overflow (i.e. carry out) is not stored anywhere,
78    and is lost.
79
80    If any of these macros are left undefined for a particular CPU,
81    C macros are used.  */
82
83 /* The CPUs come in alphabetical order below.
84
85    Please add support for more CPUs here, or improve the current support
86    for the CPUs below!  */
87
88 #if defined (__GNUC__) && !defined (NO_ASM)
89
90 /* We sometimes need to clobber "cc" with gcc2, but that would not be
91    understood by gcc1.  Use cpp to avoid major code duplication.  */
92 #if __GNUC__ < 2
93 #define __CLOBBER_CC
94 #define __AND_CLOBBER_CC
95 #else /* __GNUC__ >= 2 */
96 #define __CLOBBER_CC : "cc"
97 #define __AND_CLOBBER_CC , "cc"
98 #endif /* __GNUC__ < 2 */
99
100 #if (defined (__a29k__) || defined (___AM29K__)) && W_TYPE_SIZE == 32
101 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
102   __asm__ ("add %1,%4,%5
103         addc %0,%2,%3"                                                  \
104            : "=r" ((USItype)(sh)),                                      \
105             "=&r" ((USItype)(sl))                                       \
106            : "%r" ((USItype)(ah)),                                      \
107              "rI" ((USItype)(bh)),                                      \
108              "%r" ((USItype)(al)),                                      \
109              "rI" ((USItype)(bl)))
110 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
111   __asm__ ("sub %1,%4,%5
112         subc %0,%2,%3"                                                  \
113            : "=r" ((USItype)(sh)),                                      \
114              "=&r" ((USItype)(sl))                                      \
115            : "r" ((USItype)(ah)),                                       \
116              "rI" ((USItype)(bh)),                                      \
117              "r" ((USItype)(al)),                                       \
118              "rI" ((USItype)(bl)))
119 #define umul_ppmm(xh, xl, m0, m1) \
120   do {                                                                  \
121     USItype __m0 = (m0), __m1 = (m1);                                   \
122     __asm__ ("multiplu %0,%1,%2"                                        \
123              : "=r" ((USItype)(xl))                                     \
124              : "r" (__m0),                                              \
125                "r" (__m1));                                             \
126     __asm__ ("multmu %0,%1,%2"                                          \
127              : "=r" ((USItype)(xh))                                     \
128              : "r" (__m0),                                              \
129                "r" (__m1));                                             \
130   } while (0)
131 #define udiv_qrnnd(q, r, n1, n0, d) \
132   __asm__ ("dividu %0,%3,%4"                                            \
133            : "=r" ((USItype)(q)),                                       \
134              "=q" ((USItype)(r))                                        \
135            : "1" ((USItype)(n1)),                                       \
136              "r" ((USItype)(n0)),                                       \
137              "r" ((USItype)(d)))
138 #define count_leading_zeros(count, x) \
139     __asm__ ("clz %0,%1"                                                \
140              : "=r" ((USItype)(count))                                  \
141              : "r" ((USItype)(x)))
142 #endif /* __a29k__ */
143
144 #if defined (__alpha__) && W_TYPE_SIZE == 64
145 #define umul_ppmm(ph, pl, m0, m1) \
146   do {                                                                  \
147     UDItype __m0 = (m0), __m1 = (m1);                                   \
148     __asm__ ("umulh %r1,%2,%0"                                          \
149              : "=r" ((UDItype) ph)                                      \
150              : "%rJ" (__m0),                                            \
151                "rI" (__m1));                                            \
152     (pl) = __m0 * __m1;                                                 \
153   } while (0)
154 #define UMUL_TIME 46
155 #define udiv_qrnnd(q, r, n1, n0, d) \
156   do { UDItype __r;                                                     \
157     (q) = __udiv_qrnnd (&__r, (n1), (n0), (d));                         \
158     (r) = __r;                                                          \
159   } while (0)
160 extern UDItype __udiv_qrnnd ();
161 #define UDIV_TIME 220
162 #endif
163
164 #if defined (__arm__) && W_TYPE_SIZE == 32
165 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
166   __asm__ ("adds %1,%4,%5
167         adc %0,%2,%3"                                                   \
168            : "=r" ((USItype)(sh)),                                      \
169              "=&r" ((USItype)(sl))                                      \
170            : "%r" ((USItype)(ah)),                                      \
171              "rI" ((USItype)(bh)),                                      \
172              "%r" ((USItype)(al)),                                      \
173              "rI" ((USItype)(bl)))
174 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
175   __asm__ ("subs %1,%4,%5
176         sbc %0,%2,%3"                                                   \
177            : "=r" ((USItype)(sh)),                                      \
178              "=&r" ((USItype)(sl))                                      \
179            : "r" ((USItype)(ah)),                                       \
180              "rI" ((USItype)(bh)),                                      \
181              "r" ((USItype)(al)),                                       \
182              "rI" ((USItype)(bl)))
183 #define umul_ppmm(xh, xl, a, b) \
184   __asm__ ("; Inlined umul_ppmm
185         mov     r0,%2 lsr 16
186         mov     r2,%3 lsr 16
187         bic     r1,%2,r0 lsl 16
188         bic     r2,%3,r2 lsl 16
189         mul     %1,r1,r2
190         mul     r2,r0,r2
191         mul     r1,%0,r1
192         mul     %0,r0,%0
193         adds    r1,r2,r1
194         addcs   %0,%0,0x10000
195         adds    %1,%1,r1 lsl 16
196         adc     %0,%0,r1 lsr 16"                                        \
197            : "=&r" ((USItype)(xh)),                                     \
198              "=r" ((USItype)(xl))                                       \
199            : "r" ((USItype)(a)),                                        \
200              "r" ((USItype)(b))                                         \
201            : "r0", "r1", "r2")
202 #define UMUL_TIME 20
203 #define UDIV_TIME 100
204 #endif /* __arm__ */
205
206 #if defined (__clipper__) && W_TYPE_SIZE == 32
207 #define umul_ppmm(w1, w0, u, v) \
208   ({union {UDItype __ll;                                                \
209            struct {USItype __l, __h;} __i;                              \
210           } __xx;                                                       \
211   __asm__ ("mulwux %2,%0"                                               \
212            : "=r" (__xx.__ll)                                           \
213            : "%0" ((USItype)(u)),                                       \
214              "r" ((USItype)(v)));                                       \
215   (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})
216 #define smul_ppmm(w1, w0, u, v) \
217   ({union {DItype __ll;                                                 \
218            struct {SItype __l, __h;} __i;                               \
219           } __xx;                                                       \
220   __asm__ ("mulwx %2,%0"                                                \
221            : "=r" (__xx.__ll)                                           \
222            : "%0" ((SItype)(u)),                                        \
223              "r" ((SItype)(v)));                                        \
224   (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})
225 #define __umulsidi3(u, v) \
226   ({UDItype __w;                                                        \
227     __asm__ ("mulwux %2,%0"                                             \
228              : "=r" (__w)                                               \
229              : "%0" ((USItype)(u)),                                     \
230                "r" ((USItype)(v)));                                     \
231     __w; })
232 #endif /* __clipper__ */
233
234 #if defined (__gmicro__) && W_TYPE_SIZE == 32
235 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
236   __asm__ ("add.w %5,%1
237         addx %3,%0"                                                     \
238            : "=g" ((USItype)(sh)),                                      \
239              "=&g" ((USItype)(sl))                                      \
240            : "%0" ((USItype)(ah)),                                      \
241              "g" ((USItype)(bh)),                                       \
242              "%1" ((USItype)(al)),                                      \
243              "g" ((USItype)(bl)))
244 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
245   __asm__ ("sub.w %5,%1
246         subx %3,%0"                                                     \
247            : "=g" ((USItype)(sh)),                                      \
248              "=&g" ((USItype)(sl))                                      \
249            : "0" ((USItype)(ah)),                                       \
250              "g" ((USItype)(bh)),                                       \
251              "1" ((USItype)(al)),                                       \
252              "g" ((USItype)(bl)))
253 #define umul_ppmm(ph, pl, m0, m1) \
254   __asm__ ("mulx %3,%0,%1"                                              \
255            : "=g" ((USItype)(ph)),                                      \
256              "=r" ((USItype)(pl))                                       \
257            : "%0" ((USItype)(m0)),                                      \
258              "g" ((USItype)(m1)))
259 #define udiv_qrnnd(q, r, nh, nl, d) \
260   __asm__ ("divx %4,%0,%1"                                              \
261            : "=g" ((USItype)(q)),                                       \
262              "=r" ((USItype)(r))                                        \
263            : "1" ((USItype)(nh)),                                       \
264              "0" ((USItype)(nl)),                                       \
265              "g" ((USItype)(d)))
266 #define count_leading_zeros(count, x) \
267   __asm__ ("bsch/1 %1,%0"                                               \
268            : "=g" (count)                                               \
269            : "g" ((USItype)(x)),                                        \
270              "0" ((USItype)0))
271 #endif
272
273 #if defined (__hppa) && W_TYPE_SIZE == 32
274 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
275   __asm__ ("add %4,%5,%1
276         addc %2,%3,%0"                                                  \
277            : "=r" ((USItype)(sh)),                                      \
278              "=&r" ((USItype)(sl))                                      \
279            : "%rM" ((USItype)(ah)),                                     \
280              "rM" ((USItype)(bh)),                                      \
281              "%rM" ((USItype)(al)),                                     \
282              "rM" ((USItype)(bl)))
283 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
284   __asm__ ("sub %4,%5,%1
285         subb %2,%3,%0"                                                  \
286            : "=r" ((USItype)(sh)),                                      \
287              "=&r" ((USItype)(sl))                                      \
288            : "rM" ((USItype)(ah)),                                      \
289              "rM" ((USItype)(bh)),                                      \
290              "rM" ((USItype)(al)),                                      \
291              "rM" ((USItype)(bl)))
292 #if defined (_PA_RISC1_1)
293 #define umul_ppmm(wh, wl, u, v) \
294   do {                                                                  \
295     union {UDItype __ll;                                                \
296            struct {USItype __h, __l;} __i;                              \
297           } __xx;                                                       \
298     __asm__ ("xmpyu %1,%2,%0"                                           \
299              : "=x" (__xx.__ll)                                         \
300              : "x" ((USItype)(u)),                                      \
301                "x" ((USItype)(v)));                                     \
302     (wh) = __xx.__i.__h;                                                \
303     (wl) = __xx.__i.__l;                                                \
304   } while (0)
305 #define UMUL_TIME 8
306 #define UDIV_TIME 60
307 #else
308 #define UMUL_TIME 40
309 #define UDIV_TIME 80
310 #endif
311 #define udiv_qrnnd(q, r, n1, n0, d) \
312   do { USItype __r;                                                     \
313     (q) = __udiv_qrnnd (&__r, (n1), (n0), (d));                         \
314     (r) = __r;                                                          \
315   } while (0)
316 extern USItype __udiv_qrnnd ();
317 #define count_leading_zeros(count, x) \
318   do {                                                                  \
319     USItype __tmp;                                                      \
320     __asm__ (                                                           \
321        "ldi             1,%0
322         extru,=         %1,15,16,%%r0           ; Bits 31..16 zero?
323         extru,tr        %1,15,16,%1             ; No.  Shift down, skip add.
324         ldo             16(%0),%0               ; Yes.  Perform add.
325         extru,=         %1,23,8,%%r0            ; Bits 15..8 zero?
326         extru,tr        %1,23,8,%1              ; No.  Shift down, skip add.
327         ldo             8(%0),%0                ; Yes.  Perform add.
328         extru,=         %1,27,4,%%r0            ; Bits 7..4 zero?
329         extru,tr        %1,27,4,%1              ; No.  Shift down, skip add.
330         ldo             4(%0),%0                ; Yes.  Perform add.
331         extru,=         %1,29,2,%%r0            ; Bits 3..2 zero?
332         extru,tr        %1,29,2,%1              ; No.  Shift down, skip add.
333         ldo             2(%0),%0                ; Yes.  Perform add.
334         extru           %1,30,1,%1              ; Extract bit 1.
335         sub             %0,%1,%0                ; Subtract it.
336         " : "=r" (count), "=r" (__tmp) : "1" (x));                      \
337   } while (0)
338 #endif
339
340 #if (defined (__i370__) || defined (__mvs__)) && W_TYPE_SIZE == 32
341 #define umul_ppmm(xh, xl, m0, m1) \
342   do {                                                                  \
343     union {UDItype __ll;                                                \
344            struct {USItype __h, __l;} __i;                              \
345           } __xx;                                                       \
346     USItype __m0 = (m0), __m1 = (m1);                                   \
347     __asm__ ("mr %0,%3"                                                 \
348              : "=r" (__xx.__i.__h),                                     \
349                "=r" (__xx.__i.__l)                                      \
350              : "%1" (__m0),                                             \
351                "r" (__m1));                                             \
352     (xh) = __xx.__i.__h; (xl) = __xx.__i.__l;                           \
353     (xh) += ((((SItype) __m0 >> 31) & __m1)                             \
354              + (((SItype) __m1 >> 31) & __m0));                         \
355   } while (0)
356 #define smul_ppmm(xh, xl, m0, m1) \
357   do {                                                                  \
358     union {DItype __ll;                                                 \
359            struct {USItype __h, __l;} __i;                              \
360           } __xx;                                                       \
361     __asm__ ("mr %0,%3"                                                 \
362              : "=r" (__xx.__i.__h),                                     \
363                "=r" (__xx.__i.__l)                                      \
364              : "%1" (m0),                                               \
365                "r" (m1));                                               \
366     (xh) = __xx.__i.__h; (xl) = __xx.__i.__l;                           \
367   } while (0)
368 #define sdiv_qrnnd(q, r, n1, n0, d) \
369   do {                                                                  \
370     union {DItype __ll;                                                 \
371            struct {USItype __h, __l;} __i;                              \
372           } __xx;                                                       \
373     __xx.__i.__h = n1; __xx.__i.__l = n0;                               \
374     __asm__ ("dr %0,%2"                                                 \
375              : "=r" (__xx.__ll)                                         \
376              : "0" (__xx.__ll), "r" (d));                               \
377     (q) = __xx.__i.__l; (r) = __xx.__i.__h;                             \
378   } while (0)
379 #endif
380
381 #if (defined (__i386__) || defined (__i486__)) && W_TYPE_SIZE == 32
382 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
383   __asm__ ("addl %5,%1
384         adcl %3,%0"                                                     \
385            : "=r" ((USItype)(sh)),                                      \
386              "=&r" ((USItype)(sl))                                      \
387            : "%0" ((USItype)(ah)),                                      \
388              "g" ((USItype)(bh)),                                       \
389              "%1" ((USItype)(al)),                                      \
390              "g" ((USItype)(bl)))
391 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
392   __asm__ ("subl %5,%1
393         sbbl %3,%0"                                                     \
394            : "=r" ((USItype)(sh)),                                      \
395              "=&r" ((USItype)(sl))                                      \
396            : "0" ((USItype)(ah)),                                       \
397              "g" ((USItype)(bh)),                                       \
398              "1" ((USItype)(al)),                                       \
399              "g" ((USItype)(bl)))
400 #define umul_ppmm(w1, w0, u, v) \
401   __asm__ ("mull %3"                                                    \
402            : "=a" ((USItype)(w0)),                                      \
403              "=d" ((USItype)(w1))                                       \
404            : "%0" ((USItype)(u)),                                       \
405              "rm" ((USItype)(v)))
406 #define udiv_qrnnd(q, r, n1, n0, d) \
407   __asm__ ("divl %4"                                                    \
408            : "=a" ((USItype)(q)),                                       \
409              "=d" ((USItype)(r))                                        \
410            : "0" ((USItype)(n0)),                                       \
411              "1" ((USItype)(n1)),                                       \
412              "rm" ((USItype)(d)))
413 #define count_leading_zeros(count, x) \
414   do {                                                                  \
415     USItype __cbtmp;                                                    \
416     __asm__ ("bsrl %1,%0"                                               \
417              : "=r" (__cbtmp) : "rm" ((USItype)(x)));                   \
418     (count) = __cbtmp ^ 31;                                             \
419   } while (0)
420 #define count_trailing_zeros(count, x) \
421   __asm__ ("bsfl %1,%0" : "=r" (count) : "rm" ((USItype)(x)))
422 #define UMUL_TIME 40
423 #define UDIV_TIME 40
424 #endif /* 80x86 */
425
426 #if defined (__i960__) && W_TYPE_SIZE == 32
427 #define umul_ppmm(w1, w0, u, v) \
428   ({union {UDItype __ll;                                                \
429            struct {USItype __l, __h;} __i;                              \
430           } __xx;                                                       \
431   __asm__ ("emul        %2,%1,%0"                                       \
432            : "=d" (__xx.__ll)                                           \
433            : "%dI" ((USItype)(u)),                                      \
434              "dI" ((USItype)(v)));                                      \
435   (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})
436 #define __umulsidi3(u, v) \
437   ({UDItype __w;                                                        \
438     __asm__ ("emul      %2,%1,%0"                                       \
439              : "=d" (__w)                                               \
440              : "%dI" ((USItype)(u)),                                    \
441                "dI" ((USItype)(v)));                                    \
442     __w; })  
443 #endif /* __i960__ */
444
445 #if defined (__mc68000__) && W_TYPE_SIZE == 32
446 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
447   __asm__ ("add%.l %5,%1
448         addx%.l %3,%0"                                                  \
449            : "=d" ((USItype)(sh)),                                      \
450              "=&d" ((USItype)(sl))                                      \
451            : "%0" ((USItype)(ah)),                                      \
452              "d" ((USItype)(bh)),                                       \
453              "%1" ((USItype)(al)),                                      \
454              "g" ((USItype)(bl)))
455 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
456   __asm__ ("sub%.l %5,%1
457         subx%.l %3,%0"                                                  \
458            : "=d" ((USItype)(sh)),                                      \
459              "=&d" ((USItype)(sl))                                      \
460            : "0" ((USItype)(ah)),                                       \
461              "d" ((USItype)(bh)),                                       \
462              "1" ((USItype)(al)),                                       \
463              "g" ((USItype)(bl)))
464 #if (defined (__mc68020__) || defined (__NeXT__) || defined(mc68020)) && W_TYPE_SIZE == 32
465 #define umul_ppmm(w1, w0, u, v) \
466   __asm__ ("mulu%.l %3,%1:%0"                                           \
467            : "=d" ((USItype)(w0)),                                      \
468              "=d" ((USItype)(w1))                                       \
469            : "%0" ((USItype)(u)),                                       \
470              "dmi" ((USItype)(v)))
471 #define UMUL_TIME 45
472 #define udiv_qrnnd(q, r, n1, n0, d) \
473   __asm__ ("divu%.l %4,%1:%0"                                           \
474            : "=d" ((USItype)(q)),                                       \
475              "=d" ((USItype)(r))                                        \
476            : "0" ((USItype)(n0)),                                       \
477              "1" ((USItype)(n1)),                                       \
478              "dmi" ((USItype)(d)))
479 #define UDIV_TIME 90
480 #define sdiv_qrnnd(q, r, n1, n0, d) \
481   __asm__ ("divs%.l %4,%1:%0"                                           \
482            : "=d" ((USItype)(q)),                                       \
483              "=d" ((USItype)(r))                                        \
484            : "0" ((USItype)(n0)),                                       \
485              "1" ((USItype)(n1)),                                       \
486              "dmi" ((USItype)(d)))
487 #define count_leading_zeros(count, x) \
488   __asm__ ("bfffo %1{%b2:%b2},%0"                                       \
489            : "=d" ((USItype)(count))                                    \
490            : "od" ((USItype)(x)), "n" (0))
491 #else /* not mc68020 */
492 #define umul_ppmm(xh, xl, a, b) \
493   __asm__ ("| Inlined umul_ppmm
494         move%.l %2,%/d0
495         move%.l %3,%/d1
496         move%.l %/d0,%/d2
497         swap    %/d0
498         move%.l %/d1,%/d3
499         swap    %/d1
500         move%.w %/d2,%/d4
501         mulu    %/d3,%/d4
502         mulu    %/d1,%/d2
503         mulu    %/d0,%/d3
504         mulu    %/d0,%/d1
505         move%.l %/d4,%/d0
506         eor%.w  %/d0,%/d0
507         swap    %/d0
508         add%.l  %/d0,%/d2
509         add%.l  %/d3,%/d2
510         jcc     1f
511         add%.l  #65536,%/d1
512 1:      swap    %/d2
513         moveq   #0,%/d0
514         move%.w %/d2,%/d0
515         move%.w %/d4,%/d2
516         move%.l %/d2,%1
517         add%.l  %/d1,%/d0
518         move%.l %/d0,%0"                                                \
519            : "=g" ((USItype)(xh)),                                      \
520              "=g" ((USItype)(xl))                                       \
521            : "g" ((USItype)(a)),                                        \
522              "g" ((USItype)(b))                                         \
523            : "d0", "d1", "d2", "d3", "d4")
524 #define UMUL_TIME 100
525 #define UDIV_TIME 400
526 #endif /* not mc68020 */
527 #endif /* mc68000 */
528
529 #if defined (__m88000__) && W_TYPE_SIZE == 32
530 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
531   __asm__ ("addu.co %1,%r4,%r5
532         addu.ci %0,%r2,%r3"                                             \
533            : "=r" ((USItype)(sh)),                                      \
534              "=&r" ((USItype)(sl))                                      \
535            : "%rJ" ((USItype)(ah)),                                     \
536              "rJ" ((USItype)(bh)),                                      \
537              "%rJ" ((USItype)(al)),                                     \
538              "rJ" ((USItype)(bl)))
539 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
540   __asm__ ("subu.co %1,%r4,%r5
541         subu.ci %0,%r2,%r3"                                             \
542            : "=r" ((USItype)(sh)),                                      \
543              "=&r" ((USItype)(sl))                                      \
544            : "rJ" ((USItype)(ah)),                                      \
545              "rJ" ((USItype)(bh)),                                      \
546              "rJ" ((USItype)(al)),                                      \
547              "rJ" ((USItype)(bl)))
548 #define count_leading_zeros(count, x) \
549   do {                                                                  \
550     USItype __cbtmp;                                                    \
551     __asm__ ("ff1 %0,%1"                                                \
552              : "=r" (__cbtmp)                                           \
553              : "r" ((USItype)(x)));                                     \
554     (count) = __cbtmp ^ 31;                                             \
555   } while (0)
556 #if defined (__mc88110__)
557 #define umul_ppmm(wh, wl, u, v) \
558   do {                                                                  \
559     union {UDItype __ll;                                                \
560            struct {USItype __h, __l;} __i;                              \
561           } __xx;                                                       \
562     __asm__ ("mulu.d    %0,%1,%2"                                       \
563              : "=r" (__xx.__ll)                                         \
564              : "r" ((USItype)(u)),                                      \
565                "r" ((USItype)(v)));                                     \
566     (wh) = __xx.__i.__h;                                                \
567     (wl) = __xx.__i.__l;                                                \
568   } while (0)
569 #define udiv_qrnnd(q, r, n1, n0, d) \
570   ({union {UDItype __ll;                                                \
571            struct {USItype __h, __l;} __i;                              \
572           } __xx;                                                       \
573   USItype __q;                                                          \
574   __xx.__i.__h = (n1); __xx.__i.__l = (n0);                             \
575   __asm__ ("divu.d %0,%1,%2"                                            \
576            : "=r" (__q)                                                 \
577            : "r" (__xx.__ll),                                           \
578              "r" ((USItype)(d)));                                       \
579   (r) = (n0) - __q * (d); (q) = __q; })
580 #define UMUL_TIME 5
581 #define UDIV_TIME 25
582 #else
583 #define UMUL_TIME 17
584 #define UDIV_TIME 150
585 #endif /* __mc88110__ */
586 #endif /* __m88000__ */
587
588 #if defined (__mips__) && W_TYPE_SIZE == 32
589 #define umul_ppmm(w1, w0, u, v) \
590   __asm__ ("multu %2,%3
591         mflo %0
592         mfhi %1"                                                        \
593            : "=d" ((USItype)(w0)),                                      \
594              "=d" ((USItype)(w1))                                       \
595            : "d" ((USItype)(u)),                                        \
596              "d" ((USItype)(v)))
597 #define UMUL_TIME 10
598 #define UDIV_TIME 100
599 #endif /* __mips__ */
600
601 #if (defined (__mips) && __mips >= 3) && W_TYPE_SIZE == 64
602 #define umul_ppmm(w1, w0, u, v) \
603   __asm__ ("dmultu %2,%3
604         mflo %0
605         mfhi %1"                                                        \
606            : "=d" ((UDItype)(w0)),                                      \
607              "=d" ((UDItype)(w1))                                       \
608            : "d" ((UDItype)(u)),                                        \
609              "d" ((UDItype)(v)))
610 #define UMUL_TIME 10
611 #define UDIV_TIME 100
612 #endif /* __mips__ */
613
614 #if defined (__ns32000__) && W_TYPE_SIZE == 32
615 #define umul_ppmm(w1, w0, u, v) \
616   ({union {UDItype __ll;                                                \
617            struct {USItype __l, __h;} __i;                              \
618           } __xx;                                                       \
619   __asm__ ("meid %2,%0"                                                 \
620            : "=g" (__xx.__ll)                                           \
621            : "%0" ((USItype)(u)),                                       \
622              "g" ((USItype)(v)));                                       \
623   (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})
624 #define __umulsidi3(u, v) \
625   ({UDItype __w;                                                        \
626     __asm__ ("meid %2,%0"                                               \
627              : "=g" (__w)                                               \
628              : "%0" ((USItype)(u)),                                     \
629                "g" ((USItype)(v)));                                     \
630     __w; })
631 #define udiv_qrnnd(q, r, n1, n0, d) \
632   ({union {UDItype __ll;                                                \
633            struct {USItype __l, __h;} __i;                              \
634           } __xx;                                                       \
635   __xx.__i.__h = (n1); __xx.__i.__l = (n0);                             \
636   __asm__ ("deid %2,%0"                                                 \
637            : "=g" (__xx.__ll)                                           \
638            : "0" (__xx.__ll),                                           \
639              "g" ((USItype)(d)));                                       \
640   (r) = __xx.__i.__l; (q) = __xx.__i.__h; })
641 #define count_trailing_zeros(count,x) \
642   do {
643     __asm__ ("ffsd      %2,%0"                                          \
644              : "=r" ((USItype) (count))                                 \
645              : "0" ((USItype) 0),                                       \
646                "r" ((USItype) (x)));                                    \
647   } while (0)
648 #endif /* __ns32000__ */
649
650 #if (defined (__powerpc__) || defined (___IBMR2__)) && W_TYPE_SIZE == 32
651 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
652   do {                                                                  \
653     if (__builtin_constant_p (bh) && (bh) == 0)                         \
654       __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2"           \
655              : "=r" ((USItype)(sh)),                                    \
656                "=&r" ((USItype)(sl))                                    \
657              : "%r" ((USItype)(ah)),                                    \
658                "%r" ((USItype)(al)),                                    \
659                "rI" ((USItype)(bl)));                                   \
660     else if (__builtin_constant_p (bh) && (bh) ==~(USItype) 0)          \
661       __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2"           \
662              : "=r" ((USItype)(sh)),                                    \
663                "=&r" ((USItype)(sl))                                    \
664              : "%r" ((USItype)(ah)),                                    \
665                "%r" ((USItype)(al)),                                    \
666                "rI" ((USItype)(bl)));                                   \
667     else                                                                \
668       __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3"          \
669              : "=r" ((USItype)(sh)),                                    \
670                "=&r" ((USItype)(sl))                                    \
671              : "%r" ((USItype)(ah)),                                    \
672                "r" ((USItype)(bh)),                                     \
673                "%r" ((USItype)(al)),                                    \
674                "rI" ((USItype)(bl)));                                   \
675   } while (0)
676 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
677   do {                                                                  \
678     if (__builtin_constant_p (ah) && (ah) == 0)                         \
679       __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfze|subfze} %0,%2"               \
680                : "=r" ((USItype)(sh)),                                  \
681                  "=&r" ((USItype)(sl))                                  \
682                : "r" ((USItype)(bh)),                                   \
683                  "rI" ((USItype)(al)),                                  \
684                  "r" ((USItype)(bl)));                                  \
685     else if (__builtin_constant_p (ah) && (ah) ==~(USItype) 0)          \
686       __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfme|subfme} %0,%2"               \
687                : "=r" ((USItype)(sh)),                                  \
688                  "=&r" ((USItype)(sl))                                  \
689                : "r" ((USItype)(bh)),                                   \
690                  "rI" ((USItype)(al)),                                  \
691                  "r" ((USItype)(bl)));                                  \
692     else if (__builtin_constant_p (bh) && (bh) == 0)                    \
693       __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{ame|addme} %0,%2"         \
694                : "=r" ((USItype)(sh)),                                  \
695                  "=&r" ((USItype)(sl))                                  \
696                : "r" ((USItype)(ah)),                                   \
697                  "rI" ((USItype)(al)),                                  \
698                  "r" ((USItype)(bl)));                                  \
699     else if (__builtin_constant_p (bh) && (bh) ==~(USItype) 0)          \
700       __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{aze|addze} %0,%2"         \
701                : "=r" ((USItype)(sh)),                                  \
702                  "=&r" ((USItype)(sl))                                  \
703                : "r" ((USItype)(ah)),                                   \
704                  "rI" ((USItype)(al)),                                  \
705                  "r" ((USItype)(bl)));                                  \
706     else                                                                \
707       __asm__ ("{sf%I4|subf%I4c} %1,%5,%4\n\t{sfe|subfe} %0,%3,%2"      \
708                : "=r" ((USItype)(sh)),                                  \
709                  "=&r" ((USItype)(sl))                                  \
710                : "r" ((USItype)(ah)),                                   \
711                  "r" ((USItype)(bh)),                                   \
712                  "rI" ((USItype)(al)),                                  \
713                  "r" ((USItype)(bl)));                                  \
714   } while (0)
715 #define count_leading_zeros(count, x) \
716   __asm__ ("{cntlz|cntlzw} %0,%1"                                       \
717            : "=r" ((USItype)(count))                                    \
718            : "r" ((USItype)(x)))
719 #if defined (__powerpc__)
720 #define umul_ppmm(ph, pl, m0, m1) \
721   do {                                                                  \
722     USItype __m0 = (m0), __m1 = (m1);                                   \
723     __asm__ ("mulhwu %0,%1,%2"                                          \
724              : "=r" ((USItype) ph)                                      \
725              : "%r" (__m0),                                             \
726                "r" (__m1));                                             \
727     (pl) = __m0 * __m1;                                                 \
728   } while (0)
729 #define UMUL_TIME 15
730 #define smul_ppmm(ph, pl, m0, m1) \
731   do {                                                                  \
732     SItype __m0 = (m0), __m1 = (m1);                                    \
733     __asm__ ("mulhw %0,%1,%2"                                           \
734              : "=r" ((SItype) ph)                                       \
735              : "%r" (__m0),                                             \
736                "r" (__m1));                                             \
737     (pl) = __m0 * __m1;                                                 \
738   } while (0)
739 #define SMUL_TIME 14
740 #define UDIV_TIME 120
741 #else
742 #define umul_ppmm(xh, xl, m0, m1) \
743   do {                                                                  \
744     USItype __m0 = (m0), __m1 = (m1);                                   \
745     __asm__ ("mul %0,%2,%3"                                             \
746              : "=r" ((USItype)(xh)),                                    \
747                "=q" ((USItype)(xl))                                     \
748              : "r" (__m0),                                              \
749                "r" (__m1));                                             \
750     (xh) += ((((SItype) __m0 >> 31) & __m1)                             \
751              + (((SItype) __m1 >> 31) & __m0));                         \
752   } while (0)
753 #define UMUL_TIME 8
754 #define smul_ppmm(xh, xl, m0, m1) \
755   __asm__ ("mul %0,%2,%3"                                               \
756            : "=r" ((SItype)(xh)),                                       \
757              "=q" ((SItype)(xl))                                        \
758            : "r" (m0),                                                  \
759              "r" (m1))
760 #define SMUL_TIME 4
761 #define sdiv_qrnnd(q, r, nh, nl, d) \
762   __asm__ ("div %0,%2,%4"                                               \
763            : "=r" ((SItype)(q)), "=q" ((SItype)(r))                     \
764            : "r" ((SItype)(nh)), "1" ((SItype)(nl)), "r" ((SItype)(d)))
765 #define UDIV_TIME 100
766 #endif
767 #endif /* Power architecture variants.  */
768
769 #if defined (__pyr__) && W_TYPE_SIZE == 32
770 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
771   __asm__ ("addw        %5,%1
772         addwc   %3,%0"                                                  \
773            : "=r" ((USItype)(sh)),                                      \
774              "=&r" ((USItype)(sl))                                      \
775            : "%0" ((USItype)(ah)),                                      \
776              "g" ((USItype)(bh)),                                       \
777              "%1" ((USItype)(al)),                                      \
778              "g" ((USItype)(bl)))
779 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
780   __asm__ ("subw        %5,%1
781         subwb   %3,%0"                                                  \
782            : "=r" ((USItype)(sh)),                                      \
783              "=&r" ((USItype)(sl))                                      \
784            : "0" ((USItype)(ah)),                                       \
785              "g" ((USItype)(bh)),                                       \
786              "1" ((USItype)(al)),                                       \
787              "g" ((USItype)(bl)))
788 /* This insn doesn't work on ancient pyramids.  */
789 #define umul_ppmm(w1, w0, u, v) \
790   ({union {UDItype __ll;                                                \
791            struct {USItype __h, __l;} __i;                              \
792           } __xx;                                                       \
793   __xx.__i.__l = u;                                                     \
794   __asm__ ("uemul %3,%0"                                                \
795            : "=r" (__xx.__i.__h),                                       \
796              "=r" (__xx.__i.__l)                                        \
797            : "1" (__xx.__i.__l),                                        \
798              "g" ((USItype)(v)));                                       \
799   (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})
800 #endif /* __pyr__ */
801
802 #if defined (__ibm032__) /* RT/ROMP */  && W_TYPE_SIZE == 32
803 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
804   __asm__ ("a %1,%5
805         ae %0,%3"                                                       \
806            : "=r" ((USItype)(sh)),                                      \
807              "=&r" ((USItype)(sl))                                      \
808            : "%0" ((USItype)(ah)),                                      \
809              "r" ((USItype)(bh)),                                       \
810              "%1" ((USItype)(al)),                                      \
811              "r" ((USItype)(bl)))
812 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
813   __asm__ ("s %1,%5
814         se %0,%3"                                                       \
815            : "=r" ((USItype)(sh)),                                      \
816              "=&r" ((USItype)(sl))                                      \
817            : "0" ((USItype)(ah)),                                       \
818              "r" ((USItype)(bh)),                                       \
819              "1" ((USItype)(al)),                                       \
820              "r" ((USItype)(bl)))
821 #define umul_ppmm(ph, pl, m0, m1) \
822   do {                                                                  \
823     USItype __m0 = (m0), __m1 = (m1);                                   \
824     __asm__ (                                                           \
825        "s       r2,r2
826         mts     r10,%2
827         m       r2,%3
828         m       r2,%3
829         m       r2,%3
830         m       r2,%3
831         m       r2,%3
832         m       r2,%3
833         m       r2,%3
834         m       r2,%3
835         m       r2,%3
836         m       r2,%3
837         m       r2,%3
838         m       r2,%3
839         m       r2,%3
840         m       r2,%3
841         m       r2,%3
842         m       r2,%3
843         cas     %0,r2,r0
844         mfs     r10,%1"                                                 \
845              : "=r" ((USItype)(ph)),                                    \
846                "=r" ((USItype)(pl))                                     \
847              : "%r" (__m0),                                             \
848                 "r" (__m1)                                              \
849              : "r2");                                                   \
850     (ph) += ((((SItype) __m0 >> 31) & __m1)                             \
851              + (((SItype) __m1 >> 31) & __m0));                         \
852   } while (0)
853 #define UMUL_TIME 20
854 #define UDIV_TIME 200
855 #define count_leading_zeros(count, x) \
856   do {                                                                  \
857     if ((x) >= 0x10000)                                                 \
858       __asm__ ("clz     %0,%1"                                          \
859                : "=r" ((USItype)(count))                                \
860                : "r" ((USItype)(x) >> 16));                             \
861     else                                                                \
862       {                                                                 \
863         __asm__ ("clz   %0,%1"                                          \
864                  : "=r" ((USItype)(count))                              \
865                  : "r" ((USItype)(x)));                                 \
866         (count) += 16;                                                  \
867       }                                                                 \
868   } while (0)
869 #endif
870
871 #if defined (__sparc__) && W_TYPE_SIZE == 32
872 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
873   __asm__ ("addcc %r4,%5,%1
874         addx %r2,%3,%0"                                                 \
875            : "=r" ((USItype)(sh)),                                      \
876              "=&r" ((USItype)(sl))                                      \
877            : "%rJ" ((USItype)(ah)),                                     \
878              "rI" ((USItype)(bh)),                                      \
879              "%rJ" ((USItype)(al)),                                     \
880              "rI" ((USItype)(bl))                                       \
881            __CLOBBER_CC)
882 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
883   __asm__ ("subcc %r4,%5,%1
884         subx %r2,%3,%0"                                                 \
885            : "=r" ((USItype)(sh)),                                      \
886              "=&r" ((USItype)(sl))                                      \
887            : "rJ" ((USItype)(ah)),                                      \
888              "rI" ((USItype)(bh)),                                      \
889              "rJ" ((USItype)(al)),                                      \
890              "rI" ((USItype)(bl))                                       \
891            __CLOBBER_CC)
892 #if defined (__sparc_v8__)
893 /* Don't match immediate range because, 1) it is not often useful,
894    2) the 'I' flag thinks of the range as a 13 bit signed interval,
895    while we want to match a 13 bit interval, sign extended to 32 bits,
896    but INTERPRETED AS UNSIGNED.  */
897 #define umul_ppmm(w1, w0, u, v) \
898   __asm__ ("umul %2,%3,%1;rd %%y,%0"                                    \
899            : "=r" ((USItype)(w1)),                                      \
900              "=r" ((USItype)(w0))                                       \
901            : "r" ((USItype)(u)),                                        \
902              "r" ((USItype)(v)))
903 #define UMUL_TIME 5
904 /* We might want to leave this undefined for `SuperSPARC (tm)' since
905    its implementation is crippled and often traps.  */
906 #define udiv_qrnnd(q, r, n1, n0, d) \
907   __asm__ ("mov %2,%%y;nop;nop;nop;udiv %3,%4,%0;umul %0,%4,%1;sub %3,%1,%1"\
908            : "=&r" ((USItype)(q)),                                      \
909              "=&r" ((USItype)(r))                                       \
910            : "r" ((USItype)(n1)),                                       \
911              "r" ((USItype)(n0)),                                       \
912              "r" ((USItype)(d)))
913 #define UDIV_TIME 25
914 #else
915 #if defined (__sparclite__)
916 /* This has hardware multiply but not divide.  It also has two additional
917    instructions scan (ffs from high bit) and divscc.  */
918 #define umul_ppmm(w1, w0, u, v) \
919   __asm__ ("umul %2,%3,%1;rd %%y,%0"                                    \
920            : "=r" ((USItype)(w1)),                                      \
921              "=r" ((USItype)(w0))                                       \
922            : "r" ((USItype)(u)),                                        \
923              "r" ((USItype)(v)))
924 #define UMUL_TIME 5
925 #define udiv_qrnnd(q, r, n1, n0, d) \
926   __asm__ ("! Inlined udiv_qrnnd
927         wr      %%g0,%2,%%y     ! Not a delayed write for sparclite
928         tst     %%g0
929         divscc  %3,%4,%%g1
930         divscc  %%g1,%4,%%g1
931         divscc  %%g1,%4,%%g1
932         divscc  %%g1,%4,%%g1
933         divscc  %%g1,%4,%%g1
934         divscc  %%g1,%4,%%g1
935         divscc  %%g1,%4,%%g1
936         divscc  %%g1,%4,%%g1
937         divscc  %%g1,%4,%%g1
938         divscc  %%g1,%4,%%g1
939         divscc  %%g1,%4,%%g1
940         divscc  %%g1,%4,%%g1
941         divscc  %%g1,%4,%%g1
942         divscc  %%g1,%4,%%g1
943         divscc  %%g1,%4,%%g1
944         divscc  %%g1,%4,%%g1
945         divscc  %%g1,%4,%%g1
946         divscc  %%g1,%4,%%g1
947         divscc  %%g1,%4,%%g1
948         divscc  %%g1,%4,%%g1
949         divscc  %%g1,%4,%%g1
950         divscc  %%g1,%4,%%g1
951         divscc  %%g1,%4,%%g1
952         divscc  %%g1,%4,%%g1
953         divscc  %%g1,%4,%%g1
954         divscc  %%g1,%4,%%g1
955         divscc  %%g1,%4,%%g1
956         divscc  %%g1,%4,%%g1
957         divscc  %%g1,%4,%%g1
958         divscc  %%g1,%4,%%g1
959         divscc  %%g1,%4,%%g1
960         divscc  %%g1,%4,%0
961         rd      %%y,%1
962         bl,a 1f
963         add     %1,%4,%1
964 1:      ! End of inline udiv_qrnnd"                                     \
965            : "=r" ((USItype)(q)),                                       \
966              "=r" ((USItype)(r))                                        \
967            : "r" ((USItype)(n1)),                                       \
968              "r" ((USItype)(n0)),                                       \
969              "rI" ((USItype)(d))                                        \
970            : "%g1" __AND_CLOBBER_CC)
971 #define UDIV_TIME 37
972 #define count_leading_zeros(count, x) \
973   __asm__ ("scan %1,0,%0"                                               \
974            : "=r" ((USItype)(x))                                        \
975            : "r" ((USItype)(count)))
976 #else
977 /* SPARC without integer multiplication and divide instructions.
978    (i.e. at least Sun4/20,40,60,65,75,110,260,280,330,360,380,470,490) */
979 #define umul_ppmm(w1, w0, u, v) \
980   __asm__ ("! Inlined umul_ppmm
981         wr      %%g0,%2,%%y     ! SPARC has 0-3 delay insn after a wr
982         sra     %3,31,%%g2      ! Don't move this insn
983         and     %2,%%g2,%%g2    ! Don't move this insn
984         andcc   %%g0,0,%%g1     ! Don't move this insn
985         mulscc  %%g1,%3,%%g1
986         mulscc  %%g1,%3,%%g1
987         mulscc  %%g1,%3,%%g1
988         mulscc  %%g1,%3,%%g1
989         mulscc  %%g1,%3,%%g1
990         mulscc  %%g1,%3,%%g1
991         mulscc  %%g1,%3,%%g1
992         mulscc  %%g1,%3,%%g1
993         mulscc  %%g1,%3,%%g1
994         mulscc  %%g1,%3,%%g1
995         mulscc  %%g1,%3,%%g1
996         mulscc  %%g1,%3,%%g1
997         mulscc  %%g1,%3,%%g1
998         mulscc  %%g1,%3,%%g1
999         mulscc  %%g1,%3,%%g1
1000         mulscc  %%g1,%3,%%g1
1001         mulscc  %%g1,%3,%%g1
1002         mulscc  %%g1,%3,%%g1
1003         mulscc  %%g1,%3,%%g1
1004         mulscc  %%g1,%3,%%g1
1005         mulscc  %%g1,%3,%%g1
1006         mulscc  %%g1,%3,%%g1
1007         mulscc  %%g1,%3,%%g1
1008         mulscc  %%g1,%3,%%g1
1009         mulscc  %%g1,%3,%%g1
1010         mulscc  %%g1,%3,%%g1
1011         mulscc  %%g1,%3,%%g1
1012         mulscc  %%g1,%3,%%g1
1013         mulscc  %%g1,%3,%%g1
1014         mulscc  %%g1,%3,%%g1
1015         mulscc  %%g1,%3,%%g1
1016         mulscc  %%g1,%3,%%g1
1017         mulscc  %%g1,0,%%g1
1018         add     %%g1,%%g2,%0
1019         rd      %%y,%1"                                                 \
1020            : "=r" ((USItype)(w1)),                                      \
1021              "=r" ((USItype)(w0))                                       \
1022            : "%rI" ((USItype)(u)),                                      \
1023              "r" ((USItype)(v))                                         \
1024            : "%g1", "%g2" __AND_CLOBBER_CC)
1025 #define UMUL_TIME 39            /* 39 instructions */
1026 #define udiv_qrnnd(q, r, n1, n0, d) \
1027   do { USItype __r;                                                     \
1028     (q) = __udiv_qrnnd (&__r, (n1), (n0), (d));                         \
1029     (r) = __r;                                                          \
1030   } while (0)
1031 extern USItype __udiv_qrnnd ();
1032 #define UDIV_TIME 140
1033 #endif /* __sparclite__ */
1034 #endif /* __sparc_v8__ */
1035 #endif /* __sparc__ */
1036
1037 #if defined (__vax__) && W_TYPE_SIZE == 32
1038 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
1039   __asm__ ("addl2 %5,%1
1040         adwc %3,%0"                                                     \
1041            : "=g" ((USItype)(sh)),                                      \
1042              "=&g" ((USItype)(sl))                                      \
1043            : "%0" ((USItype)(ah)),                                      \
1044              "g" ((USItype)(bh)),                                       \
1045              "%1" ((USItype)(al)),                                      \
1046              "g" ((USItype)(bl)))
1047 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
1048   __asm__ ("subl2 %5,%1
1049         sbwc %3,%0"                                                     \
1050            : "=g" ((USItype)(sh)),                                      \
1051              "=&g" ((USItype)(sl))                                      \
1052            : "0" ((USItype)(ah)),                                       \
1053              "g" ((USItype)(bh)),                                       \
1054              "1" ((USItype)(al)),                                       \
1055              "g" ((USItype)(bl)))
1056 #define umul_ppmm(xh, xl, m0, m1) \
1057   do {                                                                  \
1058     union {UDItype __ll;                                                \
1059            struct {USItype __l, __h;} __i;                              \
1060           } __xx;                                                       \
1061     USItype __m0 = (m0), __m1 = (m1);                                   \
1062     __asm__ ("emul %1,%2,$0,%0"                                         \
1063              : "=g" (__xx.__ll)                                         \
1064              : "g" (__m0),                                              \
1065                "g" (__m1));                                             \
1066     (xh) = __xx.__i.__h; (xl) = __xx.__i.__l;                           \
1067     (xh) += ((((SItype) __m0 >> 31) & __m1)                             \
1068              + (((SItype) __m1 >> 31) & __m0));                         \
1069   } while (0)
1070 #define sdiv_qrnnd(q, r, n1, n0, d) \
1071   do {                                                                  \
1072     union {DItype __ll;                                                 \
1073            struct {SItype __l, __h;} __i;                               \
1074           } __xx;                                                       \
1075     __xx.__i.__h = n1; __xx.__i.__l = n0;                               \
1076     __asm__ ("ediv %3,%2,%0,%1"                                         \
1077              : "=g" (q), "=g" (r)                                       \
1078              : "g" (__n1n0.ll), "g" (d));                               \
1079   } while (0)
1080 #endif /* __vax__ */
1081
1082 #if defined (__z8000__) && W_TYPE_SIZE == 16
1083 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
1084   __asm__ ("add %H1,%H5\n\tadc  %H0,%H3"                                \
1085            : "=r" ((unsigned int)(sh)),                                 \
1086              "=&r" ((unsigned int)(sl))                                 \
1087            : "%0" ((unsigned int)(ah)),                                 \
1088              "r" ((unsigned int)(bh)),                                  \
1089              "%1" ((unsigned int)(al)),                                 \
1090              "rQR" ((unsigned int)(bl)))
1091 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
1092   __asm__ ("sub %H1,%H5\n\tsbc  %H0,%H3"                                \
1093            : "=r" ((unsigned int)(sh)),                                 \
1094              "=&r" ((unsigned int)(sl))                                 \
1095            : "0" ((unsigned int)(ah)),                                  \
1096              "r" ((unsigned int)(bh)),                                  \
1097              "1" ((unsigned int)(al)),                                  \
1098              "rQR" ((unsigned int)(bl)))
1099 #define umul_ppmm(xh, xl, m0, m1) \
1100   do {                                                                  \
1101     union {long int __ll;                                               \
1102            struct {unsigned int __h, __l;} __i;                         \
1103           } __xx;                                                       \
1104     unsigned int __m0 = (m0), __m1 = (m1);                              \
1105     __asm__ ("mult      %S0,%H3"                                        \
1106              : "=r" (__xx.__i.__h),                                     \
1107                "=r" (__xx.__i.__l)                                      \
1108              : "%1" (__m0),                                             \
1109                "rQR" (__m1));                                           \
1110     (xh) = __xx.__i.__h; (xl) = __xx.__i.__l;                           \
1111     (xh) += ((((signed int) __m0 >> 15) & __m1)                         \
1112              + (((signed int) __m1 >> 15) & __m0));                     \
1113   } while (0)
1114 #define umul_ppmm_off(xh, xl, m0, m1) \
1115   do {                                                                  \
1116     union {long int __ll;                                               \
1117            struct {unsigned int __h, __l;} __i;                         \
1118           } __xx;                                                       \
1119     __asm__ ("mult      %S0,%H3"                                        \
1120              : "=r" (__xx.__i.__h),                                     \
1121                "=r" (__xx.__i.__l)                                      \
1122              : "%1" (m0),                                               \
1123                "rQR" (m1));                                             \
1124     (xh) = __xx.__i.__h + ((((signed int) m0 >> 15) & m1)               \
1125                            + (((signed int) m1 >> 15) & m0));           \
1126     (xl) = __xx.__i.__l;                                                \
1127   } while (0)
1128 #endif /* __z8000__ */
1129
1130 #endif /* __GNUC__ */
1131
1132
1133 #if !defined (umul_ppmm) && defined (__umulsidi3)
1134 #define umul_ppmm(ph, pl, m0, m1) \
1135   {                                                                     \
1136     UDWtype __ll = __umulsidi3 (m0, m1);                                \
1137     ph = (UWtype) (__ll >> W_TYPE_SIZE);                                \
1138     pl = (UWtype) __ll;                                                 \
1139   }
1140 #endif
1141
1142 #if !defined (__umulsidi3)
1143 #define __umulsidi3(u, v) \
1144   ({UWtype __hi, __lo;                                                  \
1145     umul_ppmm (__hi, __lo, u, v);                                       \
1146     ((UDWtype) __hi << W_TYPE_SIZE) | __lo; })
1147 #endif
1148
1149 /* If this machine has no inline assembler, use C macros.  */
1150
1151 #if !defined (add_ssaaaa)
1152 #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
1153   do {                                                                  \
1154     UWtype __x;                                                         \
1155     __x = (al) + (bl);                                                  \
1156     (sh) = (ah) + (bh) + (__x < (al));                                  \
1157     (sl) = __x;                                                         \
1158   } while (0)
1159 #endif
1160
1161 #if !defined (sub_ddmmss)
1162 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
1163   do {                                                                  \
1164     UWtype __x;                                                         \
1165     __x = (al) - (bl);                                                  \
1166     (sh) = (ah) - (bh) - (__x > (al));                                  \
1167     (sl) = __x;                                                         \
1168   } while (0)
1169 #endif
1170
1171 #if !defined (umul_ppmm)
1172 #define umul_ppmm(w1, w0, u, v)                                         \
1173   do {                                                                  \
1174     UWtype __x0, __x1, __x2, __x3;                                      \
1175     UHWtype __ul, __vl, __uh, __vh;                                     \
1176                                                                         \
1177     __ul = __ll_lowpart (u);                                            \
1178     __uh = __ll_highpart (u);                                           \
1179     __vl = __ll_lowpart (v);                                            \
1180     __vh = __ll_highpart (v);                                           \
1181                                                                         \
1182     __x0 = (UWtype) __ul * __vl;                                        \
1183     __x1 = (UWtype) __ul * __vh;                                        \
1184     __x2 = (UWtype) __uh * __vl;                                        \
1185     __x3 = (UWtype) __uh * __vh;                                        \
1186                                                                         \
1187     __x1 += __ll_highpart (__x0);/* this can't give carry */            \
1188     __x1 += __x2;               /* but this indeed can */               \
1189     if (__x1 < __x2)            /* did we get it? */                    \
1190       __x3 += __ll_B;           /* yes, add it in the proper pos. */    \
1191                                                                         \
1192     (w1) = __x3 + __ll_highpart (__x1);                                 \
1193     (w0) = (__ll_lowpart (__x1) << W_TYPE_SIZE/2) + __ll_lowpart (__x0);\
1194   } while (0)
1195 #endif
1196
1197 /* Define this unconditionally, so it can be used for debugging.  */
1198 #define __udiv_qrnnd_c(q, r, n1, n0, d) \
1199   do {                                                                  \
1200     UWtype __d1, __d0, __q1, __q0, __r1, __r0, __m;                     \
1201     __d1 = __ll_highpart (d);                                           \
1202     __d0 = __ll_lowpart (d);                                            \
1203                                                                         \
1204     __r1 = (n1) % __d1;                                                 \
1205     __q1 = (n1) / __d1;                                                 \
1206     __m = (UWtype) __q1 * __d0;                                         \
1207     __r1 = __r1 * __ll_B | __ll_highpart (n0);                          \
1208     if (__r1 < __m)                                                     \
1209       {                                                                 \
1210         __q1--, __r1 += (d);                                            \
1211         if (__r1 >= (d)) /* i.e. we didn't get carry when adding to __r1 */\
1212           if (__r1 < __m)                                               \
1213             __q1--, __r1 += (d);                                        \
1214       }                                                                 \
1215     __r1 -= __m;                                                        \
1216                                                                         \
1217     __r0 = __r1 % __d1;                                                 \
1218     __q0 = __r1 / __d1;                                                 \
1219     __m = (UWtype) __q0 * __d0;                                         \
1220     __r0 = __r0 * __ll_B | __ll_lowpart (n0);                           \
1221     if (__r0 < __m)                                                     \
1222       {                                                                 \
1223         __q0--, __r0 += (d);                                            \
1224         if (__r0 >= (d))                                                \
1225           if (__r0 < __m)                                               \
1226             __q0--, __r0 += (d);                                        \
1227       }                                                                 \
1228     __r0 -= __m;                                                        \
1229                                                                         \
1230     (q) = (UWtype) __q1 * __ll_B | __q0;                                \
1231     (r) = __r0;                                                         \
1232   } while (0)
1233
1234 /* If the processor has no udiv_qrnnd but sdiv_qrnnd, go through
1235    __udiv_w_sdiv (defined in libgcc or elsewhere).  */
1236 #if !defined (udiv_qrnnd) && defined (sdiv_qrnnd)
1237 #define udiv_qrnnd(q, r, nh, nl, d) \
1238   do {                                                                  \
1239     UWtype __r;                                                         \
1240     (q) = __udiv_w_sdiv (&__r, nh, nl, d);                              \
1241     (r) = __r;                                                          \
1242   } while (0)
1243 #endif
1244
1245 /* If udiv_qrnnd was not defined for this processor, use __udiv_qrnnd_c.  */
1246 #if !defined (udiv_qrnnd)
1247 #define UDIV_NEEDS_NORMALIZATION 1
1248 #define udiv_qrnnd __udiv_qrnnd_c
1249 #endif
1250
1251 #if !defined (count_leading_zeros)
1252 extern
1253 #ifdef __STDC__
1254 const
1255 #endif
1256 unsigned char __clz_tab[];
1257 #define count_leading_zeros(count, x) \
1258   do {                                                                  \
1259     UWtype __xr = (x);                                                  \
1260     UWtype __a;                                                         \
1261                                                                         \
1262     if (W_TYPE_SIZE <= 32)                                              \
1263       {                                                                 \
1264         __a = __xr < ((UWtype) 1 << 2*__BITS4)                          \
1265           ? (__xr < ((UWtype) 1 << __BITS4) ? 0 : __BITS4)              \
1266           : (__xr < ((UWtype) 1 << 3*__BITS4) ?  2*__BITS4 : 3*__BITS4);\
1267       }                                                                 \
1268     else                                                                \
1269       {                                                                 \
1270         for (__a = W_TYPE_SIZE - 8; __a > 0; __a -= 8)                  \
1271           if (((__xr >> __a) & 0xff) != 0)                              \
1272             break;                                                      \
1273       }                                                                 \
1274                                                                         \
1275     (count) = W_TYPE_SIZE - (__clz_tab[__xr >> __a] + __a);             \
1276   } while (0)
1277 /* This version gives a well-defined value for zero. */
1278 #define COUNT_LEADING_ZEROS_0 W_TYPE_SIZE
1279 #endif
1280
1281 #if !defined (count_trailing_zeros)
1282 /* Define count_trailing_zeros using count_leading_zeros.  The latter might be
1283    defined in asm, but if it is not, the C version above is good enough.  */
1284 #define count_trailing_zeros(count, x) \
1285   do {                                                                  \
1286     UWtype __ctz_x = (x);                                               \
1287     UWtype __ctz_c;                                                     \
1288     count_leading_zeros (__ctz_c, __ctz_x & -__ctz_x);                  \
1289     (count) = W_TYPE_SIZE - 1 - __ctz_c;                                \
1290   } while (0)
1291 #endif
1292
1293 #ifndef UDIV_NEEDS_NORMALIZATION
1294 #define UDIV_NEEDS_NORMALIZATION 0
1295 #endif