![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to longlong.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to longlong.h CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* longlong.h -- definitions for mixed size 32/64 bit arithmetic.
1.1.1.3 root 2: Copyright (C) 1991, 1992 Free Software Foundation, Inc.
1.1 root 3:
4: This definition file is free software; you can redistribute it
5: and/or modify it under the terms of the GNU General Public
6: License as published by the Free Software Foundation; either
7: version 2, or (at your option) any later version.
8:
9: This definition file is distributed in the hope that it will be
10: useful, but WITHOUT ANY WARRANTY; without even the implied
11: warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12: See the GNU General Public License for more details.
13:
14: You should have received a copy of the GNU General Public License
15: along with this program; if not, write to the Free Software
16: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
17:
1.1.1.4 ! root 18: #ifndef SI_TYPE_SIZE
! 19: #define SI_TYPE_SIZE 32
1.1 root 20: #endif
21:
1.1.1.4 ! root 22: #define __BITS4 (SI_TYPE_SIZE / 4)
! 23: #define __ll_B (1L << (SI_TYPE_SIZE / 2))
! 24: #define __ll_lowpart(t) ((USItype) (t) % __ll_B)
! 25: #define __ll_highpart(t) ((USItype) (t) / __ll_B)
1.1 root 26:
1.1.1.2 root 27: /* Define auxiliary asm macros.
1.1 root 28:
29: 1) umul_ppmm(high_prod, low_prod, multipler, multiplicand)
1.1.1.4 ! root 30: multiplies two USItype integers MULTIPLER and MULTIPLICAND,
! 31: and generates a two-part USItype product in HIGH_PROD and
1.1 root 32: LOW_PROD.
33:
1.1.1.4 ! root 34: 2) __umulsidi3(a,b) multiplies two USItype integers A and B,
! 35: and returns a UDItype product. This is just a variant of umul_ppmm.
1.1 root 36:
37: 3) udiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
38: denominator) divides a two-word unsigned integer, composed by the
39: integers HIGH_NUMERATOR and LOW_NUMERATOR, by DENOMINATOR and
40: places the quotient in QUOTIENT and the remainder in REMAINDER.
41: HIGH_NUMERATOR must be less than DENOMINATOR for correct operation.
42: If, in addition, the most significant bit of DENOMINATOR must be 1,
43: then the pre-processor symbol UDIV_NEEDS_NORMALIZATION is defined to 1.
44:
1.1.1.4 ! root 45: 4) sdiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
! 46: denominator). Like udiv_qrnnd but the numbers are signed. The
! 47: quotient is rounded towards 0.
! 48:
! 49: 5) count_leading_zeros(count, x) counts the number of zero-bits from
1.1 root 50: the msb to the first non-zero bit. This is the number of steps X
51: needs to be shifted left to set the msb. Undefined for X == 0.
52:
1.1.1.4 ! root 53: 6) add_ssaaaa(high_sum, low_sum, high_addend_1, low_addend_1,
1.1 root 54: high_addend_2, low_addend_2) adds two two-word unsigned integers,
55: composed by HIGH_ADDEND_1 and LOW_ADDEND_1, and HIGH_ADDEND_2 and
56: LOW_ADDEND_2 respectively. The result is placed in HIGH_SUM and
57: LOW_SUM. Overflow (i.e. carry out) is not stored anywhere, and is
58: lost.
59:
1.1.1.4 ! root 60: 7) sub_ddmmss(high_difference, low_difference, high_minuend,
1.1 root 61: low_minuend, high_subtrahend, low_subtrahend) subtracts two
62: two-word unsigned integers, composed by HIGH_MINUEND_1 and
63: LOW_MINUEND_1, and HIGH_SUBTRAHEND_2 and LOW_SUBTRAHEND_2
64: respectively. The result is placed in HIGH_DIFFERENCE and
65: LOW_DIFFERENCE. Overflow (i.e. carry out) is not stored anywhere,
66: and is lost.
67:
68: If any of these macros are left undefined for a particular CPU,
69: C macros are used. */
70:
71: /* The CPUs come in alphabetical order below.
72:
73: Please add support for more CPUs here, or improve the current support
74: for the CPUs below!
1.1.1.3 root 75: (E.g. WE32100, i960, IBM360.) */
1.1 root 76:
77: #if defined (__GNUC__) && !defined (NO_ASM)
78:
1.1.1.3 root 79: /* We sometimes need to clobber "cc" with gcc2, but that would not be
80: understood by gcc1. Use cpp to avoid major code duplication. */
81: #if __GNUC__ < 2
82: #define __CLOBBER_CC
83: #define __AND_CLOBBER_CC
84: #else /* __GNUC__ >= 2 */
85: #define __CLOBBER_CC : "cc"
86: #define __AND_CLOBBER_CC , "cc"
87: #endif /* __GNUC__ < 2 */
88:
1.1 root 89: #if defined (__a29k__) || defined (___AM29K__)
90: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
91: __asm__ ("add %1,%4,%5
92: addc %0,%2,%3" \
1.1.1.4 ! root 93: : "=r" ((USItype)(sh)), \
! 94: "=&r" ((USItype)(sl)) \
! 95: : "%r" ((USItype)(ah)), \
! 96: "rI" ((USItype)(bh)), \
! 97: "%r" ((USItype)(al)), \
! 98: "rI" ((USItype)(bl)))
1.1 root 99: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
100: __asm__ ("sub %1,%4,%5
101: subc %0,%2,%3" \
1.1.1.4 ! root 102: : "=r" ((USItype)(sh)), \
! 103: "=&r" ((USItype)(sl)) \
! 104: : "r" ((USItype)(ah)), \
! 105: "rI" ((USItype)(bh)), \
! 106: "r" ((USItype)(al)), \
! 107: "rI" ((USItype)(bl)))
1.1 root 108: #define umul_ppmm(xh, xl, m0, m1) \
109: do { \
1.1.1.4 ! root 110: USItype __m0 = (m0), __m1 = (m1); \
1.1.1.3 root 111: __asm__ ("multiplu %0,%1,%2" \
1.1.1.4 ! root 112: : "=r" ((USItype)(xl)) \
1.1.1.3 root 113: : "r" (__m0), \
114: "r" (__m1)); \
115: __asm__ ("multmu %0,%1,%2" \
1.1.1.4 ! root 116: : "=r" ((USItype)(xh)) \
1.1.1.3 root 117: : "r" (__m0), \
118: "r" (__m1)); \
1.1 root 119: } while (0)
120: #define udiv_qrnnd(q, r, n1, n0, d) \
121: __asm__ ("dividu %0,%3,%4" \
1.1.1.4 ! root 122: : "=r" ((USItype)(q)), \
! 123: "=q" ((USItype)(r)) \
! 124: : "1" ((USItype)(n1)), \
! 125: "r" ((USItype)(n0)), \
! 126: "r" ((USItype)(d)))
1.1 root 127: #define count_leading_zeros(count, x) \
1.1.1.3 root 128: __asm__ ("clz %0,%1" \
1.1.1.4 ! root 129: : "=r" ((USItype)(count)) \
! 130: : "r" ((USItype)(x)))
1.1 root 131: #endif /* __a29k__ */
132:
133: #if defined (__arm__)
134: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
135: __asm__ ("adds %1,%4,%5
136: adc %0,%2,%3" \
1.1.1.4 ! root 137: : "=r" ((USItype)(sh)), \
! 138: "=&r" ((USItype)(sl)) \
! 139: : "%r" ((USItype)(ah)), \
! 140: "rI" ((USItype)(bh)), \
! 141: "%r" ((USItype)(al)), \
! 142: "rI" ((USItype)(bl)))
1.1 root 143: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
144: __asm__ ("subs %1,%4,%5
145: sbc %0,%2,%3" \
1.1.1.4 ! root 146: : "=r" ((USItype)(sh)), \
! 147: "=&r" ((USItype)(sl)) \
! 148: : "r" ((USItype)(ah)), \
! 149: "rI" ((USItype)(bh)), \
! 150: "r" ((USItype)(al)), \
! 151: "rI" ((USItype)(bl)))
1.1 root 152: #endif /* __arm__ */
153:
154: #if defined (__gmicro__)
155: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
156: __asm__ ("add.w %5,%1
157: addx %3,%0" \
1.1.1.4 ! root 158: : "=g" ((USItype)(sh)), \
! 159: "=&g" ((USItype)(sl)) \
! 160: : "%0" ((USItype)(ah)), \
! 161: "g" ((USItype)(bh)), \
! 162: "%1" ((USItype)(al)), \
! 163: "g" ((USItype)(bl)))
1.1 root 164: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
165: __asm__ ("sub.w %5,%1
166: subx %3,%0" \
1.1.1.4 ! root 167: : "=g" ((USItype)(sh)), \
! 168: "=&g" ((USItype)(sl)) \
! 169: : "0" ((USItype)(ah)), \
! 170: "g" ((USItype)(bh)), \
! 171: "1" ((USItype)(al)), \
! 172: "g" ((USItype)(bl)))
1.1 root 173: #define umul_ppmm(ph, pl, m0, m1) \
174: __asm__ ("mulx %3,%0,%1" \
1.1.1.4 ! root 175: : "=g" ((USItype)(ph)), \
! 176: "=r" ((USItype)(pl)) \
! 177: : "%0" ((USItype)(m0)), \
! 178: "g" ((USItype)(m1)))
1.1 root 179: #define udiv_qrnnd(q, r, nh, nl, d) \
180: __asm__ ("divx %4,%0,%1" \
1.1.1.4 ! root 181: : "=g" ((USItype)(q)), \
! 182: "=r" ((USItype)(r)) \
! 183: : "1" ((USItype)(nh)), \
! 184: "0" ((USItype)(nl)), \
! 185: "g" ((USItype)(d)))
1.1 root 186: #define count_leading_zeros(count, x) \
187: __asm__ ("bsch/1 %1,%0" \
1.1.1.3 root 188: : "=g" (count) \
1.1.1.4 ! root 189: : "g" ((USItype)(x)), \
! 190: "0" ((USItype)0))
1.1 root 191: #endif
192:
193: #if defined (__hppa)
194: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
195: __asm__ ("add %4,%5,%1
196: addc %2,%3,%0" \
1.1.1.4 ! root 197: : "=r" ((USItype)(sh)), \
! 198: "=&r" ((USItype)(sl)) \
! 199: : "%rM" ((USItype)(ah)), \
! 200: "rM" ((USItype)(bh)), \
! 201: "%rM" ((USItype)(al)), \
! 202: "rM" ((USItype)(bl)))
! 203: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
! 204: __asm__ ("sub %4,%5,%1
! 205: subb %2,%3,%0" \
! 206: : "=r" ((USItype)(sh)), \
! 207: "=&r" ((USItype)(sl)) \
! 208: : "rM" ((USItype)(ah)), \
! 209: "rM" ((USItype)(bh)), \
! 210: "rM" ((USItype)(al)), \
! 211: "rM" ((USItype)(bl)))
1.1.1.3 root 212: #if defined (_PA_RISC1_1)
213: #define umul_ppmm(w1, w0, u, v) \
214: do { \
215: union \
216: { \
1.1.1.4 ! root 217: UDItype __f; \
! 218: struct {USItype __w1, __w0;} __w1w0; \
1.1.1.3 root 219: } __t; \
220: __asm__ ("xmpyu %1,%2,%0" \
221: : "=x" (__t.__f) \
1.1.1.4 ! root 222: : "x" ((USItype)(u)), \
! 223: "x" ((USItype)(v))); \
1.1.1.3 root 224: (w1) = __t.__w1w0.__w1; \
225: (w0) = __t.__w1w0.__w0; \
226: } while (0)
227: #define UMUL_TIME 8
228: #else
229: #define UMUL_TIME 30
230: #endif
231: #define UDIV_TIME 40
1.1 root 232: #endif
233:
234: #if defined (__i386__) || defined (__i486__)
235: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
236: __asm__ ("addl %5,%1
237: adcl %3,%0" \
1.1.1.4 ! root 238: : "=r" ((USItype)(sh)), \
! 239: "=&r" ((USItype)(sl)) \
! 240: : "%0" ((USItype)(ah)), \
! 241: "g" ((USItype)(bh)), \
! 242: "%1" ((USItype)(al)), \
! 243: "g" ((USItype)(bl)))
1.1 root 244: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
245: __asm__ ("subl %5,%1
246: sbbl %3,%0" \
1.1.1.4 ! root 247: : "=r" ((USItype)(sh)), \
! 248: "=&r" ((USItype)(sl)) \
! 249: : "0" ((USItype)(ah)), \
! 250: "g" ((USItype)(bh)), \
! 251: "1" ((USItype)(al)), \
! 252: "g" ((USItype)(bl)))
1.1 root 253: #define umul_ppmm(w1, w0, u, v) \
254: __asm__ ("mull %3" \
1.1.1.4 ! root 255: : "=a" ((USItype)(w0)), \
! 256: "=d" ((USItype)(w1)) \
! 257: : "%0" ((USItype)(u)), \
! 258: "rm" ((USItype)(v)))
1.1 root 259: #define udiv_qrnnd(q, r, n1, n0, d) \
260: __asm__ ("divl %4" \
1.1.1.4 ! root 261: : "=a" ((USItype)(q)), \
! 262: "=d" ((USItype)(r)) \
! 263: : "0" ((USItype)(n0)), \
! 264: "1" ((USItype)(n1)), \
! 265: "rm" ((USItype)(d)))
1.1 root 266: #define count_leading_zeros(count, x) \
267: do { \
1.1.1.4 ! root 268: USItype __cbtmp; \
1.1 root 269: __asm__ ("bsrl %1,%0" \
1.1.1.4 ! root 270: : "=r" (__cbtmp) : "rm" ((USItype)(x))); \
1.1 root 271: (count) = __cbtmp ^ 31; \
272: } while (0)
1.1.1.3 root 273: #define UMUL_TIME 40
274: #define UDIV_TIME 40
1.1 root 275: #endif /* 80x86 */
276:
277: #if defined (__i860__)
278: #if 0
279: /* Make sure these patterns really improve the code before
280: switching them on. */
281: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
282: do { \
283: union \
284: { \
1.1.1.4 ! root 285: DItype __ll; \
! 286: struct {USItype __l, __h;} __i; \
1.1 root 287: } __a, __b, __s; \
1.1.1.4 ! root 288: __a.__i.__l = (al); \
! 289: __a.__i.__h = (ah); \
! 290: __b.__i.__l = (bl); \
! 291: __b.__i.__h = (bh); \
1.1 root 292: __asm__ ("fiadd.dd %1,%2,%0" \
1.1.1.4 ! root 293: : "=f" (__s.__ll) \
! 294: : "%f" (__a.__ll), "f" (__b.__ll)); \
! 295: (sh) = __s.__i.__h; \
! 296: (sl) = __s.__i.__l; \
1.1 root 297: } while (0)
298: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
299: do { \
300: union \
301: { \
1.1.1.4 ! root 302: DItype __ll; \
! 303: struct {USItype __l, __h;} __i; \
1.1 root 304: } __a, __b, __s; \
1.1.1.4 ! root 305: __a.__i.__l = (al); \
! 306: __a.__i.__h = (ah); \
! 307: __b.__i.__l = (bl); \
! 308: __b.__i.__h = (bh); \
1.1 root 309: __asm__ ("fisub.dd %1,%2,%0" \
1.1.1.4 ! root 310: : "=f" (__s.__ll) \
! 311: : "%f" (__a.__ll), "f" (__b.__ll)); \
! 312: (sh) = __s.__i.__h; \
! 313: (sl) = __s.__i.__l; \
1.1 root 314: } while (0)
315: #endif
316: #endif /* __i860__ */
317:
318: #if defined (___IBMR2__) /* IBM RS6000 */
319: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
1.1.1.3 root 320: __asm__ ("a%I5 %1,%4,%5
1.1 root 321: ae %0,%2,%3" \
1.1.1.4 ! root 322: : "=r" ((USItype)(sh)), \
! 323: "=&r" ((USItype)(sl)) \
! 324: : "%r" ((USItype)(ah)), \
! 325: "r" ((USItype)(bh)), \
! 326: "%r" ((USItype)(al)), \
! 327: "rI" ((USItype)(bl)))
1.1 root 328: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
1.1.1.3 root 329: __asm__ ("sf%I4 %1,%5,%4
1.1 root 330: sfe %0,%3,%2" \
1.1.1.4 ! root 331: : "=r" ((USItype)(sh)), \
! 332: "=&r" ((USItype)(sl)) \
! 333: : "r" ((USItype)(ah)), \
! 334: "r" ((USItype)(bh)), \
! 335: "rI" ((USItype)(al)), \
! 336: "r" ((USItype)(bl)))
1.1 root 337: #define umul_ppmm(xh, xl, m0, m1) \
338: do { \
1.1.1.4 ! root 339: USItype __m0 = (m0), __m1 = (m1); \
1.1 root 340: __asm__ ("mul %0,%2,%3" \
1.1.1.4 ! root 341: : "=r" ((USItype)(xh)), \
! 342: "=q" ((USItype)(xl)) \
1.1.1.3 root 343: : "r" (__m0), \
344: "r" (__m1)); \
1.1.1.4 ! root 345: (xh) += ((((SItype) __m0 >> 31) & __m1) \
! 346: + (((SItype) __m1 >> 31) & __m0)); \
1.1 root 347: } while (0)
1.1.1.3 root 348: #define smul_ppmm(xh, xl, m0, m1) \
349: __asm__ ("mul %0,%2,%3" \
1.1.1.4 ! root 350: : "=r" ((USItype)(xh)), \
! 351: "=q" ((USItype)(xl)) \
! 352: : "r" ((USItype)(m0)), \
! 353: "r" ((USItype)(m1)))
1.1 root 354: #define UMUL_TIME 8
1.1.1.3 root 355: #define sdiv_qrnnd(q, r, nh, nl, d) \
356: __asm__ ("div %0,%2,%4" \
1.1.1.4 ! root 357: : "=r" ((USItype)(q)), "=q" ((USItype)(r)) \
! 358: : "r" ((USItype)(nh)), "1" ((USItype)(nl)), "r" ((USItype)(d)))
1.1 root 359: #define UDIV_TIME 40
360: #define UDIV_NEEDS_NORMALIZATION 1
361: #define count_leading_zeros(count, x) \
362: __asm__ ("cntlz %0,%1" \
1.1.1.4 ! root 363: : "=r" ((USItype)(count)) \
! 364: : "r" ((USItype)(x)))
1.1 root 365: #endif /* ___IBMR2__ */
366:
367: #if defined (__mc68000__)
368: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
369: __asm__ ("add%.l %5,%1
370: addx%.l %3,%0" \
1.1.1.4 ! root 371: : "=d" ((USItype)(sh)), \
! 372: "=&d" ((USItype)(sl)) \
! 373: : "%0" ((USItype)(ah)), \
! 374: "d" ((USItype)(bh)), \
! 375: "%1" ((USItype)(al)), \
! 376: "g" ((USItype)(bl)))
1.1 root 377: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
378: __asm__ ("sub%.l %5,%1
379: subx%.l %3,%0" \
1.1.1.4 ! root 380: : "=d" ((USItype)(sh)), \
! 381: "=&d" ((USItype)(sl)) \
! 382: : "0" ((USItype)(ah)), \
! 383: "d" ((USItype)(bh)), \
! 384: "1" ((USItype)(al)), \
! 385: "g" ((USItype)(bl)))
1.1 root 386: #if defined (__mc68020__) || defined (__NeXT__) || defined(mc68020)
387: #define umul_ppmm(w1, w0, u, v) \
388: __asm__ ("mulu%.l %3,%1:%0" \
1.1.1.4 ! root 389: : "=d" ((USItype)(w0)), \
! 390: "=d" ((USItype)(w1)) \
! 391: : "%0" ((USItype)(u)), \
! 392: "dmi" ((USItype)(v)))
1.1.1.3 root 393: #define UMUL_TIME 45
1.1 root 394: #define udiv_qrnnd(q, r, n1, n0, d) \
395: __asm__ ("divu%.l %4,%1:%0" \
1.1.1.4 ! root 396: : "=d" ((USItype)(q)), \
! 397: "=d" ((USItype)(r)) \
! 398: : "0" ((USItype)(n0)), \
! 399: "1" ((USItype)(n1)), \
! 400: "dmi" ((USItype)(d)))
1.1.1.3 root 401: #define UDIV_TIME 90
402: #define sdiv_qrnnd(q, r, n1, n0, d) \
403: __asm__ ("divs%.l %4,%1:%0" \
1.1.1.4 ! root 404: : "=d" ((USItype)(q)), \
! 405: "=d" ((USItype)(r)) \
! 406: : "0" ((USItype)(n0)), \
! 407: "1" ((USItype)(n1)), \
! 408: "dmi" ((USItype)(d)))
1.1 root 409: #define count_leading_zeros(count, x) \
410: __asm__ ("bfffo %1{%b2:%b2},%0" \
1.1.1.4 ! root 411: : "=d" ((USItype)(count)) \
! 412: : "od" ((USItype)(x)), "n" (0))
1.1 root 413: #else /* not mc68020 */
414: #define umul_ppmm(xh, xl, a, b) \
415: __asm__ ("| Inlined umul_ppmm
416: movel %2,d0
417: movel %3,d1
418: movel d0,d2
419: swap d0
420: movel d1,d3
421: swap d1
422: movew d2,d4
423: mulu d3,d4
424: mulu d1,d2
425: mulu d0,d3
426: mulu d0,d1
427: movel d4,d0
428: eorw d0,d0
429: swap d0
430: addl d0,d2
431: addl d3,d2
432: jcc 1f
433: addl #65536,d1
434: 1: swap d2
435: moveq #0,d0
436: movew d2,d0
437: movew d4,d2
438: movel d2,%1
439: addl d1,d0
440: movel d0,%0" \
1.1.1.4 ! root 441: : "=g" ((USItype)(xh)), \
! 442: "=g" ((USItype)(xl)) \
! 443: : "g" ((USItype)(a)), \
! 444: "g" ((USItype)(b)) \
1.1.1.3 root 445: : "d0", "d1", "d2", "d3", "d4")
446: #define UMUL_TIME 100
447: #define UDIV_TIME 400
1.1 root 448: #endif /* not mc68020 */
449: #endif /* mc68000 */
450:
451: #if defined (__m88000__)
452: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
453: __asm__ ("addu.co %1,%r4,%r5
454: addu.ci %0,%r2,%r3" \
1.1.1.4 ! root 455: : "=r" ((USItype)(sh)), \
! 456: "=&r" ((USItype)(sl)) \
! 457: : "%rJ" ((USItype)(ah)), \
! 458: "rJ" ((USItype)(bh)), \
! 459: "%rJ" ((USItype)(al)), \
! 460: "rJ" ((USItype)(bl)))
1.1 root 461: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
462: __asm__ ("subu.co %1,%r4,%r5
463: subu.ci %0,%r2,%r3" \
1.1.1.4 ! root 464: : "=r" ((USItype)(sh)), \
! 465: "=&r" ((USItype)(sl)) \
! 466: : "rJ" ((USItype)(ah)), \
! 467: "rJ" ((USItype)(bh)), \
! 468: "rJ" ((USItype)(al)), \
! 469: "rJ" ((USItype)(bl)))
1.1 root 470: #define UMUL_TIME 17
471: #define UDIV_TIME 150
472: #define count_leading_zeros(count, x) \
473: do { \
1.1.1.4 ! root 474: USItype __cbtmp; \
1.1 root 475: __asm__ ("ff1 %0,%1" \
1.1.1.3 root 476: : "=r" (__cbtmp) \
1.1.1.4 ! root 477: : "r" ((USItype)(x))); \
1.1 root 478: (count) = __cbtmp ^ 31; \
479: } while (0)
1.1.1.3 root 480: #if defined (__mc88110__)
481: #define umul_ppmm(w1, w0, u, v) \
482: __asm__ ("mulu.d r10,%2,%3
483: or %0,r10,0
484: or %1,r11,0" \
485: : "=r" (w1), \
486: "=r" (w0) \
1.1.1.4 ! root 487: : "r" ((USItype)(u)), \
! 488: "r" ((USItype)(v)) \
1.1.1.3 root 489: : "r10", "r11")
490: #define udiv_qrnnd(q, r, n1, n0, d) \
491: __asm__ ("or r10,%2,0
492: or r11,%3,0
493: divu.d r10,r10,%4
494: mulu %1,%4,r11
495: subu %1,%3,%1
496: or %0,r11,0" \
497: : "=r" (q), \
498: "=&r" (r) \
1.1.1.4 ! root 499: : "r" ((USItype)(n1)), \
! 500: "r" ((USItype)(n0)), \
! 501: "r" ((USItype)(d)) \
1.1.1.3 root 502: : "r10", "r11")
503: #endif
1.1 root 504: #endif /* __m88000__ */
505:
506: #if defined (__mips__)
507: #define umul_ppmm(w1, w0, u, v) \
508: __asm__ ("multu %2,%3
509: mflo %0
510: mfhi %1" \
1.1.1.4 ! root 511: : "=d" ((USItype)(w0)), \
! 512: "=d" ((USItype)(w1)) \
! 513: : "d" ((USItype)(u)), \
! 514: "d" ((USItype)(v)))
1.1 root 515: #define UMUL_TIME 5
516: #define UDIV_TIME 100
517: #endif /* __mips__ */
518:
519: #if defined (__ns32000__)
520: #define __umulsidi3(u, v) \
1.1.1.4 ! root 521: ({UDItype __w; \
1.1.1.3 root 522: __asm__ ("meid %2,%0" \
523: : "=g" (__w) \
1.1.1.4 ! root 524: : "%0" ((USItype)(u)), \
! 525: "g" ((USItype)(v))); \
1.1.1.3 root 526: __w; })
1.1 root 527: #define div_qrnnd(q, r, n1, n0, d) \
528: __asm__ ("movd %2,r0
529: movd %3,r1
530: deid %4,r0
531: movd r1,%0
532: movd r0,%1" \
1.1.1.4 ! root 533: : "=g" ((USItype)(q)), \
! 534: "=g" ((USItype)(r)) \
! 535: : "g" ((USItype)(n0)), \
! 536: "g" ((USItype)(n1)), \
! 537: "g" ((USItype)(d)) \
1.1.1.3 root 538: : "r0", "r1")
1.1 root 539: #endif /* __ns32000__ */
540:
541: #if defined (__pyr__)
542: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
543: __asm__ ("addw %5,%1
544: addwc %3,%0" \
1.1.1.4 ! root 545: : "=r" ((USItype)(sh)), \
! 546: "=&r" ((USItype)(sl)) \
! 547: : "%0" ((USItype)(ah)), \
! 548: "g" ((USItype)(bh)), \
! 549: "%1" ((USItype)(al)), \
! 550: "g" ((USItype)(bl)))
1.1 root 551: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
552: __asm__ ("subw %5,%1
553: subwb %3,%0" \
1.1.1.4 ! root 554: : "=r" ((USItype)(sh)), \
! 555: "=&r" ((USItype)(sl)) \
! 556: : "0" ((USItype)(ah)), \
! 557: "g" ((USItype)(bh)), \
! 558: "1" ((USItype)(al)), \
! 559: "g" ((USItype)(bl)))
1.1 root 560: /* This insn doesn't work on ancient pyramids. */
561: #define umul_ppmm(w1, w0, u, v) \
1.1.1.4 ! root 562: ({union { \
! 563: UDItype __ll; \
! 564: struct {USItype __h, __l;} __i; \
! 565: } __xx; \
! 566: __xx.__i.__l = u; \
1.1.1.3 root 567: __asm__ ("uemul %3,%0" \
1.1.1.4 ! root 568: : "=r" (__xx.__i.__h), \
! 569: "=r" (__xx.__i.__l) \
! 570: : "1" (__xx.__i.__l), \
! 571: "g" ((UDItype)(v))); \
! 572: (w1) = __xx.__i.__h; \
! 573: (w0) = __xx.__i.__l;})
1.1 root 574: #endif /* __pyr__ */
575:
576: #if defined (__ibm032__) /* RT/ROMP */
577: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
578: __asm__ ("a %1,%5
579: ae %0,%3" \
1.1.1.4 ! root 580: : "=r" ((USItype)(sh)), \
! 581: "=&r" ((USItype)(sl)) \
! 582: : "%0" ((USItype)(ah)), \
! 583: "r" ((USItype)(bh)), \
! 584: "%1" ((USItype)(al)), \
! 585: "r" ((USItype)(bl)))
1.1 root 586: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
587: __asm__ ("s %1,%5
588: se %0,%3" \
1.1.1.4 ! root 589: : "=r" ((USItype)(sh)), \
! 590: "=&r" ((USItype)(sl)) \
! 591: : "0" ((USItype)(ah)), \
! 592: "r" ((USItype)(bh)), \
! 593: "1" ((USItype)(al)), \
! 594: "r" ((USItype)(bl)))
1.1 root 595: #define umul_ppmm(ph, pl, m0, m1) \
596: do { \
1.1.1.4 ! root 597: USItype __m0 = (m0), __m1 = (m1); \
1.1 root 598: __asm__ ( \
599: "s r2,r2
600: mts r10,%2
601: m r2,%3
602: m r2,%3
603: m r2,%3
604: m r2,%3
605: m r2,%3
606: m r2,%3
607: m r2,%3
608: m r2,%3
609: m r2,%3
610: m r2,%3
611: m r2,%3
612: m r2,%3
613: m r2,%3
614: m r2,%3
615: m r2,%3
616: m r2,%3
617: cas %0,r2,r0
618: mfs r10,%1" \
1.1.1.4 ! root 619: : "=r" ((USItype)(ph)), \
! 620: "=r" ((USItype)(pl)) \
1.1.1.3 root 621: : "%r" (__m0), \
622: "r" (__m1) \
623: : "r2"); \
1.1.1.4 ! root 624: (ph) += ((((SItype) __m0 >> 31) & __m1) \
! 625: + (((SItype) __m1 >> 31) & __m0)); \
1.1 root 626: } while (0)
1.1.1.3 root 627: #define UMUL_TIME 20
628: #define UDIV_TIME 200
1.1 root 629: #define count_leading_zeros(count, x) \
630: do { \
631: if ((x) >= 0x10000) \
632: __asm__ ("clz %0,%1" \
1.1.1.4 ! root 633: : "=r" ((USItype)(count)) \
! 634: : "r" ((USItype)(x) >> 16)); \
1.1 root 635: else \
636: { \
637: __asm__ ("clz %0,%1" \
1.1.1.4 ! root 638: : "=r" ((USItype)(count)) \
! 639: : "r" ((USItype)(x))); \
1.1 root 640: (count) += 16; \
641: } \
642: } while (0)
643: #endif
644:
645: #if defined (__sparc__)
646: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
647: __asm__ ("addcc %4,%5,%1
648: addx %2,%3,%0" \
1.1.1.4 ! root 649: : "=r" ((USItype)(sh)), \
! 650: "=&r" ((USItype)(sl)) \
! 651: : "%r" ((USItype)(ah)), \
! 652: "rI" ((USItype)(bh)), \
! 653: "%r" ((USItype)(al)), \
! 654: "rI" ((USItype)(bl)) \
1.1.1.3 root 655: __CLOBBER_CC)
1.1 root 656: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
657: __asm__ ("subcc %4,%5,%1
658: subx %2,%3,%0" \
1.1.1.4 ! root 659: : "=r" ((USItype)(sh)), \
! 660: "=&r" ((USItype)(sl)) \
! 661: : "r" ((USItype)(ah)), \
! 662: "rI" ((USItype)(bh)), \
! 663: "r" ((USItype)(al)), \
! 664: "rI" ((USItype)(bl)) \
1.1.1.3 root 665: __CLOBBER_CC)
1.1.1.4 ! root 666: #if defined (__sparc_v8__)
1.1 root 667: #define umul_ppmm(w1, w0, u, v) \
668: __asm__ ("umul %2,%3,%1;rd %%y,%0" \
1.1.1.4 ! root 669: : "=r" ((USItype)(w1)), \
! 670: "=r" ((USItype)(w0)) \
! 671: : "r" ((USItype)(u)), \
! 672: "r" ((USItype)(v)))
1.1 root 673: #define udiv_qrnnd(q, r, n1, n0, d) \
674: __asm__ ("mov %2,%%y;nop;nop;nop;udiv %3,%4,%0;umul %0,%4,%1;sub %3,%1,%1"\
1.1.1.4 ! root 675: : "=&r" ((USItype)(q)), \
! 676: "=&r" ((USItype)(r)) \
! 677: : "r" ((USItype)(n1)), \
! 678: "r" ((USItype)(n0)), \
! 679: "r" ((USItype)(d)))
! 680: #else
! 681: #if defined (__sparclite__)
! 682: /* This has hardware multiply but not divide. It also has two additional
! 683: instructions scan (ffs from high bit) and divscc. */
! 684: #define umul_ppmm(w1, w0, u, v) \
! 685: __asm__ ("umul %2,%3,%1;rd %%y,%0" \
! 686: : "=r" ((USItype)(w1)), \
! 687: "=r" ((USItype)(w0)) \
! 688: : "r" ((USItype)(u)), \
! 689: "r" ((USItype)(v)))
! 690: #define udiv_qrnnd(q, r, n1, n0, d) \
! 691: __asm__ ("! Inlined udiv_qrnnd
! 692: wr %%g0,%2,%%y ! Not a delayed write for sparclite
! 693: tst %%g0
! 694: divscc %3,%4,%%g1
! 695: divscc %%g1,%4,%%g1
! 696: divscc %%g1,%4,%%g1
! 697: divscc %%g1,%4,%%g1
! 698: divscc %%g1,%4,%%g1
! 699: divscc %%g1,%4,%%g1
! 700: divscc %%g1,%4,%%g1
! 701: divscc %%g1,%4,%%g1
! 702: divscc %%g1,%4,%%g1
! 703: divscc %%g1,%4,%%g1
! 704: divscc %%g1,%4,%%g1
! 705: divscc %%g1,%4,%%g1
! 706: divscc %%g1,%4,%%g1
! 707: divscc %%g1,%4,%%g1
! 708: divscc %%g1,%4,%%g1
! 709: divscc %%g1,%4,%%g1
! 710: divscc %%g1,%4,%%g1
! 711: divscc %%g1,%4,%%g1
! 712: divscc %%g1,%4,%%g1
! 713: divscc %%g1,%4,%%g1
! 714: divscc %%g1,%4,%%g1
! 715: divscc %%g1,%4,%%g1
! 716: divscc %%g1,%4,%%g1
! 717: divscc %%g1,%4,%%g1
! 718: divscc %%g1,%4,%%g1
! 719: divscc %%g1,%4,%%g1
! 720: divscc %%g1,%4,%%g1
! 721: divscc %%g1,%4,%%g1
! 722: divscc %%g1,%4,%%g1
! 723: divscc %%g1,%4,%%g1
! 724: divscc %%g1,%4,%%g1
! 725: divscc %%g1,%4,%0
! 726: rd %%y,%1
! 727: bl,a 1f
! 728: add %1,%4,%1
! 729: 1: ! End of inline udiv_qrnnd" \
! 730: : "=r" ((USItype)(q)), \
! 731: "=r" ((USItype)(r)) \
! 732: : "r" ((USItype)(n1)), \
! 733: "r" ((USItype)(n0)), \
! 734: "rI" ((USItype)(d)) \
! 735: : "%g1" __AND_CLOBBER_CC)
! 736: #define UDIV_TIME 37
! 737: #define count_leading_zeros(count, x) \
! 738: __asm__ ("scan %1,0,%0" \
! 739: : "=r" ((USItype)(x)) \
! 740: : "r" ((USItype)(count)))
1.1 root 741: #else
742: /* SPARC without integer multiplication and divide instructions.
743: (i.e. at least Sun4/20,40,60,65,75,110,260,280,330,360,380,470,490) */
744: #define umul_ppmm(w1, w0, u, v) \
745: __asm__ ("! Inlined umul_ppmm
746: wr %%g0,%2,%%y ! SPARC has 0-3 delay insn after a wr
747: sra %3,31,%%g2 ! Don't move this insn
748: and %2,%%g2,%%g2 ! Don't move this insn
749: andcc %%g0,0,%%g1 ! Don't move this insn
750: mulscc %%g1,%3,%%g1
751: mulscc %%g1,%3,%%g1
752: mulscc %%g1,%3,%%g1
753: mulscc %%g1,%3,%%g1
754: mulscc %%g1,%3,%%g1
755: mulscc %%g1,%3,%%g1
756: mulscc %%g1,%3,%%g1
757: mulscc %%g1,%3,%%g1
758: mulscc %%g1,%3,%%g1
759: mulscc %%g1,%3,%%g1
760: mulscc %%g1,%3,%%g1
761: mulscc %%g1,%3,%%g1
762: mulscc %%g1,%3,%%g1
763: mulscc %%g1,%3,%%g1
764: mulscc %%g1,%3,%%g1
765: mulscc %%g1,%3,%%g1
766: mulscc %%g1,%3,%%g1
767: mulscc %%g1,%3,%%g1
768: mulscc %%g1,%3,%%g1
769: mulscc %%g1,%3,%%g1
770: mulscc %%g1,%3,%%g1
771: mulscc %%g1,%3,%%g1
772: mulscc %%g1,%3,%%g1
773: mulscc %%g1,%3,%%g1
774: mulscc %%g1,%3,%%g1
775: mulscc %%g1,%3,%%g1
776: mulscc %%g1,%3,%%g1
777: mulscc %%g1,%3,%%g1
778: mulscc %%g1,%3,%%g1
779: mulscc %%g1,%3,%%g1
780: mulscc %%g1,%3,%%g1
781: mulscc %%g1,%3,%%g1
782: mulscc %%g1,0,%%g1
783: add %%g1,%%g2,%0
784: rd %%y,%1" \
1.1.1.4 ! root 785: : "=r" ((USItype)(w1)), \
! 786: "=r" ((USItype)(w0)) \
! 787: : "%rI" ((USItype)(u)), \
! 788: "r" ((USItype)(v)) \
1.1.1.3 root 789: : "%g1", "%g2" __AND_CLOBBER_CC)
1.1 root 790: #define UMUL_TIME 39 /* 39 instructions */
791: /* It's quite necessary to add this much assembler for the sparc.
792: The default udiv_qrnnd (in C) is more than 10 times slower! */
793: #define udiv_qrnnd(q, r, n1, n0, d) \
794: __asm__ ("! Inlined udiv_qrnnd
795: mov 32,%%g1
796: subcc %1,%2,%%g0
797: 1: bcs 5f
798: addxcc %0,%0,%0 ! shift n1n0 and a q-bit in lsb
799: sub %1,%2,%1 ! this kills msb of n
800: addx %1,%1,%1 ! so this can't give carry
801: subcc %%g1,1,%%g1
802: 2: bne 1b
803: subcc %1,%2,%%g0
804: bcs 3f
805: addxcc %0,%0,%0 ! shift n1n0 and a q-bit in lsb
806: b 3f
807: sub %1,%2,%1 ! this kills msb of n
808: 4: sub %1,%2,%1
809: 5: addxcc %1,%1,%1
810: bcc 2b
811: subcc %%g1,1,%%g1
812: ! Got carry from n. Subtract next step to cancel this carry.
813: bne 4b
814: addcc %0,%0,%0 ! shift n1n0 and a 0-bit in lsb
815: sub %1,%2,%1
816: 3: xnor %0,0,%0
817: ! End of inline udiv_qrnnd" \
1.1.1.4 ! root 818: : "=&r" ((USItype)(q)), \
! 819: "=&r" ((USItype)(r)) \
! 820: : "r" ((USItype)(d)), \
! 821: "1" ((USItype)(n1)), \
! 822: "0" ((USItype)(n0)) : "%g1" __AND_CLOBBER_CC)
1.1 root 823: #define UDIV_TIME (3+7*32) /* 7 instructions/iteration. 32 iterations. */
1.1.1.4 ! root 824: #endif /* __sparclite__ */
! 825: #endif /* __sparc_v8__ */
1.1.1.3 root 826: #endif /* __sparc__ */
1.1 root 827:
828: #if defined (__vax__)
829: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
830: __asm__ ("addl2 %5,%1
831: adwc %3,%0" \
1.1.1.4 ! root 832: : "=g" ((USItype)(sh)), \
! 833: "=&g" ((USItype)(sl)) \
! 834: : "%0" ((USItype)(ah)), \
! 835: "g" ((USItype)(bh)), \
! 836: "%1" ((USItype)(al)), \
! 837: "g" ((USItype)(bl)))
1.1 root 838: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
839: __asm__ ("subl2 %5,%1
840: sbwc %3,%0" \
1.1.1.4 ! root 841: : "=g" ((USItype)(sh)), \
! 842: "=&g" ((USItype)(sl)) \
! 843: : "0" ((USItype)(ah)), \
! 844: "g" ((USItype)(bh)), \
! 845: "1" ((USItype)(al)), \
! 846: "g" ((USItype)(bl)))
1.1 root 847: #define umul_ppmm(xh, xl, m0, m1) \
848: do { \
1.1.1.4 ! root 849: union { \
! 850: UDItype __ll; \
! 851: struct {USItype __l, __h;} __i; \
! 852: } __xx; \
! 853: USItype __m0 = (m0), __m1 = (m1); \
1.1 root 854: __asm__ ("emul %1,%2,$0,%0" \
1.1.1.4 ! root 855: : "=r" (__xx.__ll) \
1.1.1.3 root 856: : "g" (__m0), \
857: "g" (__m1)); \
1.1.1.4 ! root 858: (xh) = __xx.__i.__h; \
! 859: (xl) = __xx.__i.__l; \
! 860: (xh) += ((((SItype) __m0 >> 31) & __m1) \
! 861: + (((SItype) __m1 >> 31) & __m0)); \
1.1 root 862: } while (0)
863: #endif /* __vax__ */
864:
865: #endif /* __GNUC__ */
866:
867: /* If this machine has no inline assembler, use C macros. */
868:
869: #if !defined (add_ssaaaa)
870: #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
871: do { \
1.1.1.4 ! root 872: USItype __x; \
1.1 root 873: __x = (al) + (bl); \
874: (sh) = (ah) + (bh) + (__x < (al)); \
875: (sl) = __x; \
876: } while (0)
877: #endif
878:
879: #if !defined (sub_ddmmss)
880: #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
881: do { \
1.1.1.4 ! root 882: USItype __x; \
1.1 root 883: __x = (al) - (bl); \
884: (sh) = (ah) - (bh) - (__x > (al)); \
885: (sl) = __x; \
886: } while (0)
887: #endif
888:
889: #if !defined (umul_ppmm)
890: #define umul_ppmm(w1, w0, u, v) \
891: do { \
1.1.1.4 ! root 892: USItype __x0, __x1, __x2, __x3; \
! 893: USItype __ul, __vl, __uh, __vh; \
1.1 root 894: \
895: __ul = __ll_lowpart (u); \
896: __uh = __ll_highpart (u); \
897: __vl = __ll_lowpart (v); \
898: __vh = __ll_highpart (v); \
899: \
1.1.1.4 ! root 900: __x0 = (USItype) __ul * __vl; \
! 901: __x1 = (USItype) __ul * __vh; \
! 902: __x2 = (USItype) __uh * __vl; \
! 903: __x3 = (USItype) __uh * __vh; \
1.1 root 904: \
905: __x1 += __ll_highpart (__x0);/* this can't give carry */ \
906: __x1 += __x2; /* but this indeed can */ \
907: if (__x1 < __x2) /* did we get it? */ \
908: __x3 += __ll_B; /* yes, add it in the proper pos. */ \
909: \
910: (w1) = __x3 + __ll_highpart (__x1); \
911: (w0) = __ll_lowpart (__x1) * __ll_B + __ll_lowpart (__x0); \
912: } while (0)
913: #endif
914:
915: #if !defined (__umulsidi3)
916: #define __umulsidi3(u, v) \
1.1.1.4 ! root 917: ({DIunion __w; \
1.1 root 918: umul_ppmm (__w.s.high, __w.s.low, u, v); \
919: __w.ll; })
920: #endif
921:
1.1.1.3 root 922: /* Define this unconditionally, so it can be used for debugging. */
923: #define __udiv_qrnnd_c(q, r, n1, n0, d) \
1.1 root 924: do { \
1.1.1.4 ! root 925: USItype __d1, __d0, __q1, __q0; \
! 926: USItype __r1, __r0, __m; \
1.1 root 927: __d1 = __ll_highpart (d); \
928: __d0 = __ll_lowpart (d); \
929: \
930: __r1 = (n1) % __d1; \
931: __q1 = (n1) / __d1; \
1.1.1.4 ! root 932: __m = (USItype) __q1 * __d0; \
1.1 root 933: __r1 = __r1 * __ll_B | __ll_highpart (n0); \
934: if (__r1 < __m) \
935: { \
936: __q1--, __r1 += (d); \
937: if (__r1 >= (d)) /* i.e. we didn't get carry when adding to __r1 */\
938: if (__r1 < __m) \
939: __q1--, __r1 += (d); \
940: } \
941: __r1 -= __m; \
942: \
943: __r0 = __r1 % __d1; \
944: __q0 = __r1 / __d1; \
1.1.1.4 ! root 945: __m = (USItype) __q0 * __d0; \
1.1 root 946: __r0 = __r0 * __ll_B | __ll_lowpart (n0); \
947: if (__r0 < __m) \
948: { \
949: __q0--, __r0 += (d); \
950: if (__r0 >= (d)) \
951: if (__r0 < __m) \
952: __q0--, __r0 += (d); \
953: } \
954: __r0 -= __m; \
955: \
1.1.1.4 ! root 956: (q) = (USItype) __q1 * __ll_B | __q0; \
1.1 root 957: (r) = __r0; \
958: } while (0)
1.1.1.4 ! root 959:
! 960: /* If the processor has no udiv_qrnnd but sdiv_qrnnd, go through
! 961: __udiv_w_sdiv (defined in libgcc or elsewhere). */
! 962: #if !defined (udiv_qrnnd) && defined (sdiv_qrnnd)
! 963: #define udiv_qrnnd(q, r, nh, nl, d) \
! 964: do { \
! 965: USItype __r; \
! 966: (q) = __udiv_w_sdiv (&__r, nh, nl, d); \
! 967: (r) = __r; \
! 968: } while (0)
! 969: #endif
! 970:
1.1.1.3 root 971: /* If udiv_qrnnd was not defined for this processor, use __udiv_qrnnd_c. */
972: #if !defined (udiv_qrnnd)
973: #define UDIV_NEEDS_NORMALIZATION 1
974: #define udiv_qrnnd __udiv_qrnnd_c
1.1 root 975: #endif
976:
977: #if !defined (count_leading_zeros)
1.1.1.4 ! root 978: extern const UQItype __clz_tab[];
1.1 root 979: #define count_leading_zeros(count, x) \
980: do { \
1.1.1.4 ! root 981: USItype __xr = (x); \
! 982: USItype __a; \
1.1 root 983: \
1.1.1.4 ! root 984: if (SI_TYPE_SIZE <= 32) \
1.1.1.3 root 985: { \
986: __a = __xr < (1<<2*__BITS4) \
987: ? (__xr < (1<<__BITS4) ? 0 : __BITS4) \
988: : (__xr < (1<<3*__BITS4) ? 2*__BITS4 : 3*__BITS4); \
989: } \
990: else \
991: { \
1.1.1.4 ! root 992: for (__a = SI_TYPE_SIZE - 8; __a > 0; __a -= 8) \
1.1.1.3 root 993: if (((__xr >> __a) & 0xff) != 0) \
994: break; \
995: } \
1.1 root 996: \
1.1.1.4 ! root 997: (count) = SI_TYPE_SIZE - (__clz_tab[__xr >> __a] + __a); \
1.1 root 998: } while (0)
999: #endif
1000:
1001: #ifndef UDIV_NEEDS_NORMALIZATION
1002: #define UDIV_NEEDS_NORMALIZATION 0
1003: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.