ghc/runtime/gmp/longlong.h

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