longlong.h 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250
  1. /* SPDX-License-Identifier: GPL-2.0+ */
  2. /* longlong.h -- definitions for mixed size 32/64 bit arithmetic.
  3. Copyright (C) 1991, 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2004,
  4. 2005 Free Software Foundation, Inc.
  5. */
  6. /* You have to define the following before including this file:
  7. UWtype -- An unsigned type, default type for operations (typically a "word")
  8. UHWtype -- An unsigned type, at least half the size of UWtype.
  9. UDWtype -- An unsigned type, at least twice as large a UWtype
  10. W_TYPE_SIZE -- size in bits of UWtype
  11. UQItype -- Unsigned 8 bit type.
  12. SItype, USItype -- Signed and unsigned 32 bit types.
  13. DItype, UDItype -- Signed and unsigned 64 bit types.
  14. On a 32 bit machine UWtype should typically be USItype;
  15. on a 64 bit machine, UWtype should typically be UDItype. */
  16. #define __BITS4 (W_TYPE_SIZE / 4)
  17. #define __ll_B ((UWtype) 1 << (W_TYPE_SIZE / 2))
  18. #define __ll_lowpart(t) ((UWtype) (t) & (__ll_B - 1))
  19. #define __ll_highpart(t) ((UWtype) (t) >> (W_TYPE_SIZE / 2))
  20. #ifndef W_TYPE_SIZE
  21. #define W_TYPE_SIZE 32
  22. #define UWtype USItype
  23. #define UHWtype USItype
  24. #define UDWtype UDItype
  25. #endif
  26. extern const UQItype __clz_tab[256];
  27. /* Define auxiliary asm macros.
  28. 1) umul_ppmm(high_prod, low_prod, multiplier, multiplicand) multiplies two
  29. UWtype integers MULTIPLIER and MULTIPLICAND, and generates a two UWtype
  30. word product in HIGH_PROD and LOW_PROD.
  31. 2) __umulsidi3(a,b) multiplies two UWtype integers A and B, and returns a
  32. UDWtype product. This is just a variant of umul_ppmm.
  33. 3) udiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
  34. denominator) divides a UDWtype, composed by the UWtype integers
  35. HIGH_NUMERATOR and LOW_NUMERATOR, by DENOMINATOR and places the quotient
  36. in QUOTIENT and the remainder in REMAINDER. HIGH_NUMERATOR must be less
  37. than DENOMINATOR for correct operation. If, in addition, the most
  38. significant bit of DENOMINATOR must be 1, then the pre-processor symbol
  39. UDIV_NEEDS_NORMALIZATION is defined to 1.
  40. 4) sdiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
  41. denominator). Like udiv_qrnnd but the numbers are signed. The quotient
  42. is rounded towards 0.
  43. 5) count_leading_zeros(count, x) counts the number of zero-bits from the
  44. msb to the first nonzero bit in the UWtype X. This is the number of
  45. steps X needs to be shifted left to set the msb. Undefined for X == 0,
  46. unless the symbol COUNT_LEADING_ZEROS_0 is defined to some value.
  47. 6) count_trailing_zeros(count, x) like count_leading_zeros, but counts
  48. from the least significant end.
  49. 7) add_ssaaaa(high_sum, low_sum, high_addend_1, low_addend_1,
  50. high_addend_2, low_addend_2) adds two UWtype integers, composed by
  51. HIGH_ADDEND_1 and LOW_ADDEND_1, and HIGH_ADDEND_2 and LOW_ADDEND_2
  52. respectively. The result is placed in HIGH_SUM and LOW_SUM. Overflow
  53. (i.e. carry out) is not stored anywhere, and is lost.
  54. 8) sub_ddmmss(high_difference, low_difference, high_minuend, low_minuend,
  55. high_subtrahend, low_subtrahend) subtracts two two-word UWtype integers,
  56. composed by HIGH_MINUEND_1 and LOW_MINUEND_1, and HIGH_SUBTRAHEND_2 and
  57. LOW_SUBTRAHEND_2 respectively. The result is placed in HIGH_DIFFERENCE
  58. and LOW_DIFFERENCE. Overflow (i.e. carry out) is not stored anywhere,
  59. and is lost.
  60. If any of these macros are left undefined for a particular CPU,
  61. C macros are used. */
  62. /* The CPUs come in alphabetical order below.
  63. Please add support for more CPUs here, or improve the current support
  64. for the CPUs below!
  65. (E.g. WE32100, IBM360.) */
  66. /* Snipped per CPU support */
  67. /* If this machine has no inline assembler, use C macros. */
  68. #if !defined (add_ssaaaa)
  69. #define add_ssaaaa(sh, sl, ah, al, bh, bl) \
  70. do { \
  71. UWtype __x; \
  72. __x = (al) + (bl); \
  73. (sh) = (ah) + (bh) + (__x < (al)); \
  74. (sl) = __x; \
  75. } while (0)
  76. #endif
  77. #if !defined (sub_ddmmss)
  78. #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
  79. do { \
  80. UWtype __x; \
  81. __x = (al) - (bl); \
  82. (sh) = (ah) - (bh) - (__x > (al)); \
  83. (sl) = __x; \
  84. } while (0)
  85. #endif
  86. /* If we lack umul_ppmm but have smul_ppmm, define umul_ppmm in terms of
  87. smul_ppmm. */
  88. #if !defined (umul_ppmm) && defined (smul_ppmm)
  89. #define umul_ppmm(w1, w0, u, v) \
  90. do { \
  91. UWtype __w1; \
  92. UWtype __xm0 = (u), __xm1 = (v); \
  93. smul_ppmm (__w1, w0, __xm0, __xm1); \
  94. (w1) = __w1 + (-(__xm0 >> (W_TYPE_SIZE - 1)) & __xm1) \
  95. + (-(__xm1 >> (W_TYPE_SIZE - 1)) & __xm0); \
  96. } while (0)
  97. #endif
  98. /* If we still don't have umul_ppmm, define it using plain C. */
  99. #if !defined (umul_ppmm)
  100. #define umul_ppmm(w1, w0, u, v) \
  101. do { \
  102. UWtype __x0, __x1, __x2, __x3; \
  103. UHWtype __ul, __vl, __uh, __vh; \
  104. \
  105. __ul = __ll_lowpart (u); \
  106. __uh = __ll_highpart (u); \
  107. __vl = __ll_lowpart (v); \
  108. __vh = __ll_highpart (v); \
  109. \
  110. __x0 = (UWtype) __ul * __vl; \
  111. __x1 = (UWtype) __ul * __vh; \
  112. __x2 = (UWtype) __uh * __vl; \
  113. __x3 = (UWtype) __uh * __vh; \
  114. \
  115. __x1 += __ll_highpart (__x0);/* this can't give carry */ \
  116. __x1 += __x2; /* but this indeed can */ \
  117. if (__x1 < __x2) /* did we get it? */ \
  118. __x3 += __ll_B; /* yes, add it in the proper pos. */ \
  119. \
  120. (w1) = __x3 + __ll_highpart (__x1); \
  121. (w0) = __ll_lowpart (__x1) * __ll_B + __ll_lowpart (__x0); \
  122. } while (0)
  123. #endif
  124. #if !defined (__umulsidi3)
  125. #define __umulsidi3(u, v) \
  126. ({DWunion __w; \
  127. umul_ppmm (__w.s.high, __w.s.low, u, v); \
  128. __w.ll; })
  129. #endif
  130. /* Define this unconditionally, so it can be used for debugging. */
  131. #define __udiv_qrnnd_c(q, r, n1, n0, d) \
  132. do { \
  133. UWtype __d1, __d0, __q1, __q0; \
  134. UWtype __r1, __r0, __m; \
  135. __d1 = __ll_highpart (d); \
  136. __d0 = __ll_lowpart (d); \
  137. \
  138. __r1 = (n1) % __d1; \
  139. __q1 = (n1) / __d1; \
  140. __m = (UWtype) __q1 * __d0; \
  141. __r1 = __r1 * __ll_B | __ll_highpart (n0); \
  142. if (__r1 < __m) \
  143. { \
  144. __q1--, __r1 += (d); \
  145. if (__r1 >= (d)) /* i.e. we didn't get carry when adding to __r1 */\
  146. if (__r1 < __m) \
  147. __q1--, __r1 += (d); \
  148. } \
  149. __r1 -= __m; \
  150. \
  151. __r0 = __r1 % __d1; \
  152. __q0 = __r1 / __d1; \
  153. __m = (UWtype) __q0 * __d0; \
  154. __r0 = __r0 * __ll_B | __ll_lowpart (n0); \
  155. if (__r0 < __m) \
  156. { \
  157. __q0--, __r0 += (d); \
  158. if (__r0 >= (d)) \
  159. if (__r0 < __m) \
  160. __q0--, __r0 += (d); \
  161. } \
  162. __r0 -= __m; \
  163. \
  164. (q) = (UWtype) __q1 * __ll_B | __q0; \
  165. (r) = __r0; \
  166. } while (0)
  167. /* If the processor has no udiv_qrnnd but sdiv_qrnnd, go through
  168. __udiv_w_sdiv (defined in libgcc or elsewhere). */
  169. #if !defined (udiv_qrnnd) && defined (sdiv_qrnnd)
  170. #define udiv_qrnnd(q, r, nh, nl, d) \
  171. do { \
  172. USItype __r; \
  173. (q) = __udiv_w_sdiv (&__r, nh, nl, d); \
  174. (r) = __r; \
  175. } while (0)
  176. #endif
  177. /* If udiv_qrnnd was not defined for this processor, use __udiv_qrnnd_c. */
  178. #if !defined (udiv_qrnnd)
  179. #define UDIV_NEEDS_NORMALIZATION 1
  180. #define udiv_qrnnd __udiv_qrnnd_c
  181. #endif
  182. #if !defined (count_leading_zeros)
  183. #define count_leading_zeros(count, x) \
  184. do { \
  185. UWtype __xr = (x); \
  186. UWtype __a; \
  187. \
  188. if (W_TYPE_SIZE <= 32) \
  189. { \
  190. __a = __xr < ((UWtype)1<<2*__BITS4) \
  191. ? (__xr < ((UWtype)1<<__BITS4) ? 0 : __BITS4) \
  192. : (__xr < ((UWtype)1<<3*__BITS4) ? 2*__BITS4 : 3*__BITS4); \
  193. } \
  194. else \
  195. { \
  196. for (__a = W_TYPE_SIZE - 8; __a > 0; __a -= 8) \
  197. if (((__xr >> __a) & 0xff) != 0) \
  198. break; \
  199. } \
  200. \
  201. (count) = W_TYPE_SIZE - (__clz_tab[__xr >> __a] + __a); \
  202. } while (0)
  203. #define COUNT_LEADING_ZEROS_0 W_TYPE_SIZE
  204. #endif
  205. #if !defined (count_trailing_zeros)
  206. /* Define count_trailing_zeros using count_leading_zeros. The latter might be
  207. defined in asm, but if it is not, the C version above is good enough. */
  208. #define count_trailing_zeros(count, x) \
  209. do { \
  210. UWtype __ctz_x = (x); \
  211. UWtype __ctz_c; \
  212. count_leading_zeros (__ctz_c, __ctz_x & -__ctz_x); \
  213. (count) = W_TYPE_SIZE - 1 - __ctz_c; \
  214. } while (0)
  215. #endif
  216. #ifndef UDIV_NEEDS_NORMALIZATION
  217. #define UDIV_NEEDS_NORMALIZATION 0
  218. #endif