Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 : /* This Source Code Form is subject to the terms of the Mozilla Public
3 : * License, v. 2.0. If a copy of the MPL was not distributed with this
4 : * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5 :
6 : /*
7 : ** File: prlong.h
8 : ** Description: Portable access to 64 bit numerics
9 : **
10 : ** Long-long (64-bit signed integer type) support. Some C compilers
11 : ** don't support 64 bit integers yet, so we use these macros to
12 : ** support both machines that do and don't.
13 : **/
14 : #ifndef prlong_h___
15 : #define prlong_h___
16 :
17 : #include "prtypes.h"
18 :
19 : PR_BEGIN_EXTERN_C
20 :
21 : /***********************************************************************
22 : ** DEFINES: LL_MaxInt
23 : ** LL_MinInt
24 : ** LL_Zero
25 : ** LL_MaxUint
26 : ** DESCRIPTION:
27 : ** Various interesting constants and static variable
28 : ** initializer
29 : ***********************************************************************/
30 0 : NSPR_API(PRInt64) LL_MaxInt(void);
31 0 : NSPR_API(PRInt64) LL_MinInt(void);
32 0 : NSPR_API(PRInt64) LL_Zero(void);
33 0 : NSPR_API(PRUint64) LL_MaxUint(void);
34 :
35 : #if defined(HAVE_LONG_LONG)
36 :
37 : /* Keep this in sync with prtypes.h. */
38 : #if PR_BYTES_PER_LONG == 8 && !defined(PR_ALTERNATE_INT64_TYPEDEF)
39 : #define LL_MAXINT 9223372036854775807L
40 : #define LL_MININT (-LL_MAXINT - 1L)
41 : #define LL_ZERO 0L
42 : #define LL_MAXUINT 18446744073709551615UL
43 : #define LL_INIT(hi, lo) ((hi ## L << 32) + lo ## L)
44 : #elif defined(WIN32) && !defined(__GNUC__)
45 : #define LL_MAXINT 9223372036854775807i64
46 : #define LL_MININT (-LL_MAXINT - 1i64)
47 : #define LL_ZERO 0i64
48 : #define LL_MAXUINT 18446744073709551615ui64
49 : #define LL_INIT(hi, lo) ((hi ## i64 << 32) + lo ## i64)
50 : #else
51 : #define LL_MAXINT 9223372036854775807LL
52 : #define LL_MININT (-LL_MAXINT - 1LL)
53 : #define LL_ZERO 0LL
54 : #define LL_MAXUINT 18446744073709551615ULL
55 : #define LL_INIT(hi, lo) ((hi ## LL << 32) + lo ## LL)
56 : #endif
57 :
58 : /***********************************************************************
59 : ** MACROS: LL_*
60 : ** DESCRIPTION:
61 : ** The following macros define portable access to the 64 bit
62 : ** math facilities.
63 : **
64 : ***********************************************************************/
65 :
66 : /***********************************************************************
67 : ** MACROS: LL_<relational operators>
68 : **
69 : ** LL_IS_ZERO Test for zero
70 : ** LL_EQ Test for equality
71 : ** LL_NE Test for inequality
72 : ** LL_GE_ZERO Test for zero or positive
73 : ** LL_CMP Compare two values
74 : ***********************************************************************/
75 : #define LL_IS_ZERO(a) ((a) == 0)
76 : #define LL_EQ(a, b) ((a) == (b))
77 : #define LL_NE(a, b) ((a) != (b))
78 : #define LL_GE_ZERO(a) ((a) >= 0)
79 : #define LL_CMP(a, op, b) ((PRInt64)(a) op (PRInt64)(b))
80 : #define LL_UCMP(a, op, b) ((PRUint64)(a) op (PRUint64)(b))
81 :
82 : /***********************************************************************
83 : ** MACROS: LL_<logical operators>
84 : **
85 : ** LL_AND Logical and
86 : ** LL_OR Logical or
87 : ** LL_XOR Logical exclusion
88 : ** LL_OR2 A disgusting deviation
89 : ** LL_NOT Negation (one's complement)
90 : ***********************************************************************/
91 : #define LL_AND(r, a, b) ((r) = (a) & (b))
92 : #define LL_OR(r, a, b) ((r) = (a) | (b))
93 : #define LL_XOR(r, a, b) ((r) = (a) ^ (b))
94 : #define LL_OR2(r, a) ((r) = (r) | (a))
95 : #define LL_NOT(r, a) ((r) = ~(a))
96 :
97 : /***********************************************************************
98 : ** MACROS: LL_<mathematical operators>
99 : **
100 : ** LL_NEG Negation (two's complement)
101 : ** LL_ADD Summation (two's complement)
102 : ** LL_SUB Difference (two's complement)
103 : ***********************************************************************/
104 : #define LL_NEG(r, a) ((r) = -(a))
105 : #define LL_ADD(r, a, b) ((r) = (a) + (b))
106 : #define LL_SUB(r, a, b) ((r) = (a) - (b))
107 :
108 : /***********************************************************************
109 : ** MACROS: LL_<mathematical operators>
110 : **
111 : ** LL_MUL Product (two's complement)
112 : ** LL_DIV Quotient (two's complement)
113 : ** LL_MOD Modulus (two's complement)
114 : ***********************************************************************/
115 : #define LL_MUL(r, a, b) ((r) = (a) * (b))
116 : #define LL_DIV(r, a, b) ((r) = (a) / (b))
117 : #define LL_MOD(r, a, b) ((r) = (a) % (b))
118 :
119 : /***********************************************************************
120 : ** MACROS: LL_<shifting operators>
121 : **
122 : ** LL_SHL Shift left [0..64] bits
123 : ** LL_SHR Shift right [0..64] bits with sign extension
124 : ** LL_USHR Unsigned shift right [0..64] bits
125 : ** LL_ISHL Signed shift left [0..64] bits
126 : ***********************************************************************/
127 : #define LL_SHL(r, a, b) ((r) = (PRInt64)(a) << (b))
128 : #define LL_SHR(r, a, b) ((r) = (PRInt64)(a) >> (b))
129 : #define LL_USHR(r, a, b) ((r) = (PRUint64)(a) >> (b))
130 : #define LL_ISHL(r, a, b) ((r) = (PRInt64)(a) << (b))
131 :
132 : /***********************************************************************
133 : ** MACROS: LL_<conversion operators>
134 : **
135 : ** LL_L2I Convert to signed 32 bit
136 : ** LL_L2UI Convert to unsigned 32 bit
137 : ** LL_L2F Convert to floating point
138 : ** LL_L2D Convert to floating point
139 : ** LL_I2L Convert signed to 64 bit
140 : ** LL_UI2L Convert unsigned to 64 bit
141 : ** LL_F2L Convert float to 64 bit
142 : ** LL_D2L Convert float to 64 bit
143 : ***********************************************************************/
144 : #define LL_L2I(i, l) ((i) = (PRInt32)(l))
145 : #define LL_L2UI(ui, l) ((ui) = (PRUint32)(l))
146 : #define LL_L2F(f, l) ((f) = (PRFloat64)(l))
147 : #define LL_L2D(d, l) ((d) = (PRFloat64)(l))
148 :
149 : #define LL_I2L(l, i) ((l) = (PRInt64)(i))
150 : #define LL_UI2L(l, ui) ((l) = (PRInt64)(ui))
151 : #define LL_F2L(l, f) ((l) = (PRInt64)(f))
152 : #define LL_D2L(l, d) ((l) = (PRInt64)(d))
153 :
154 : /***********************************************************************
155 : ** MACROS: LL_UDIVMOD
156 : ** DESCRIPTION:
157 : ** Produce both a quotient and a remainder given an unsigned
158 : ** INPUTS: PRUint64 a: The dividend of the operation
159 : ** PRUint64 b: The quotient of the operation
160 : ** OUTPUTS: PRUint64 *qp: pointer to quotient
161 : ** PRUint64 *rp: pointer to remainder
162 : ***********************************************************************/
163 : #define LL_UDIVMOD(qp, rp, a, b) \
164 : (*(qp) = ((PRUint64)(a) / (b)), \
165 : *(rp) = ((PRUint64)(a) % (b)))
166 :
167 : #else /* !HAVE_LONG_LONG */
168 :
169 : #define LL_MAXINT LL_MaxInt()
170 : #define LL_MININT LL_MinInt()
171 : #define LL_ZERO LL_Zero()
172 : #define LL_MAXUINT LL_MaxUint()
173 :
174 : #ifdef IS_LITTLE_ENDIAN
175 : #define LL_INIT(hi, lo) {PR_UINT32(lo), PR_UINT32(hi)}
176 : #else
177 : #define LL_INIT(hi, lo) {PR_UINT32(hi), PR_UINT32(lo)}
178 : #endif
179 :
180 : #define LL_IS_ZERO(a) (((a).hi == 0) && ((a).lo == 0))
181 : #define LL_EQ(a, b) (((a).hi == (b).hi) && ((a).lo == (b).lo))
182 : #define LL_NE(a, b) (((a).hi != (b).hi) || ((a).lo != (b).lo))
183 : #define LL_GE_ZERO(a) (((a).hi >> 31) == 0)
184 :
185 : #define LL_CMP(a, op, b) (((a).hi == (b).hi) ? ((a).lo op (b).lo) : \
186 : ((PRInt32)(a).hi op (PRInt32)(b).hi))
187 : #define LL_UCMP(a, op, b) (((a).hi == (b).hi) ? ((a).lo op (b).lo) : \
188 : ((a).hi op (b).hi))
189 :
190 : #define LL_AND(r, a, b) ((r).lo = (a).lo & (b).lo, \
191 : (r).hi = (a).hi & (b).hi)
192 : #define LL_OR(r, a, b) ((r).lo = (a).lo | (b).lo, \
193 : (r).hi = (a).hi | (b).hi)
194 : #define LL_XOR(r, a, b) ((r).lo = (a).lo ^ (b).lo, \
195 : (r).hi = (a).hi ^ (b).hi)
196 : #define LL_OR2(r, a) ((r).lo = (r).lo | (a).lo, \
197 : (r).hi = (r).hi | (a).hi)
198 : #define LL_NOT(r, a) ((r).lo = ~(a).lo, \
199 : (r).hi = ~(a).hi)
200 :
201 : #define LL_NEG(r, a) ((r).lo = -(PRInt32)(a).lo, \
202 : (r).hi = -(PRInt32)(a).hi - ((r).lo != 0))
203 : #define LL_ADD(r, a, b) { \
204 : PRInt64 _a, _b; \
205 : _a = a; _b = b; \
206 : (r).lo = _a.lo + _b.lo; \
207 : (r).hi = _a.hi + _b.hi + ((r).lo < _b.lo); \
208 : }
209 :
210 : #define LL_SUB(r, a, b) { \
211 : PRInt64 _a, _b; \
212 : _a = a; _b = b; \
213 : (r).lo = _a.lo - _b.lo; \
214 : (r).hi = _a.hi - _b.hi - (_a.lo < _b.lo); \
215 : }
216 :
217 : #define LL_MUL(r, a, b) { \
218 : PRInt64 _a, _b; \
219 : _a = a; _b = b; \
220 : LL_MUL32(r, _a.lo, _b.lo); \
221 : (r).hi += _a.hi * _b.lo + _a.lo * _b.hi; \
222 : }
223 :
224 : #define _lo16(a) ((a) & PR_BITMASK(16))
225 : #define _hi16(a) ((a) >> 16)
226 :
227 : #define LL_MUL32(r, a, b) { \
228 : PRUint32 _a1, _a0, _b1, _b0, _y0, _y1, _y2, _y3; \
229 : _a1 = _hi16(a), _a0 = _lo16(a); \
230 : _b1 = _hi16(b), _b0 = _lo16(b); \
231 : _y0 = _a0 * _b0; \
232 : _y1 = _a0 * _b1; \
233 : _y2 = _a1 * _b0; \
234 : _y3 = _a1 * _b1; \
235 : _y1 += _hi16(_y0); /* can't carry */ \
236 : _y1 += _y2; /* might carry */ \
237 : if (_y1 < _y2) \
238 : _y3 += (PRUint32)(PR_BIT(16)); /* propagate */ \
239 : (r).lo = (_lo16(_y1) << 16) + _lo16(_y0); \
240 : (r).hi = _y3 + _hi16(_y1); \
241 : }
242 :
243 : #define LL_UDIVMOD(qp, rp, a, b) ll_udivmod(qp, rp, a, b)
244 :
245 : NSPR_API(void) ll_udivmod(PRUint64 *qp, PRUint64 *rp, PRUint64 a, PRUint64 b);
246 :
247 : #define LL_DIV(r, a, b) { \
248 : PRInt64 _a, _b; \
249 : PRUint32 _negative = (PRInt32)(a).hi < 0; \
250 : if (_negative) { \
251 : LL_NEG(_a, a); \
252 : } else { \
253 : _a = a; \
254 : } \
255 : if ((PRInt32)(b).hi < 0) { \
256 : _negative ^= 1; \
257 : LL_NEG(_b, b); \
258 : } else { \
259 : _b = b; \
260 : } \
261 : LL_UDIVMOD(&(r), 0, _a, _b); \
262 : if (_negative) \
263 : LL_NEG(r, r); \
264 : }
265 :
266 : #define LL_MOD(r, a, b) { \
267 : PRInt64 _a, _b; \
268 : PRUint32 _negative = (PRInt32)(a).hi < 0; \
269 : if (_negative) { \
270 : LL_NEG(_a, a); \
271 : } else { \
272 : _a = a; \
273 : } \
274 : if ((PRInt32)(b).hi < 0) { \
275 : LL_NEG(_b, b); \
276 : } else { \
277 : _b = b; \
278 : } \
279 : LL_UDIVMOD(0, &(r), _a, _b); \
280 : if (_negative) \
281 : LL_NEG(r, r); \
282 : }
283 :
284 : #define LL_SHL(r, a, b) { \
285 : if (b) { \
286 : PRInt64 _a; \
287 : _a = a; \
288 : if ((b) < 32) { \
289 : (r).lo = _a.lo << ((b) & 31); \
290 : (r).hi = (_a.hi << ((b) & 31)) | (_a.lo >> (32 - (b))); \
291 : } else { \
292 : (r).lo = 0; \
293 : (r).hi = _a.lo << ((b) & 31); \
294 : } \
295 : } else { \
296 : (r) = (a); \
297 : } \
298 : }
299 :
300 : /* a is an PRInt32, b is PRInt32, r is PRInt64 */
301 : #define LL_ISHL(r, a, b) { \
302 : if (b) { \
303 : PRInt64 _a; \
304 : _a.lo = (a); \
305 : _a.hi = 0; \
306 : if ((b) < 32) { \
307 : (r).lo = (a) << ((b) & 31); \
308 : (r).hi = ((a) >> (32 - (b))); \
309 : } else { \
310 : (r).lo = 0; \
311 : (r).hi = (a) << ((b) & 31); \
312 : } \
313 : } else { \
314 : (r).lo = (a); \
315 : (r).hi = 0; \
316 : } \
317 : }
318 :
319 : #define LL_SHR(r, a, b) { \
320 : if (b) { \
321 : PRInt64 _a; \
322 : _a = a; \
323 : if ((b) < 32) { \
324 : (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> ((b) & 31)); \
325 : (r).hi = (PRInt32)_a.hi >> ((b) & 31); \
326 : } else { \
327 : (r).lo = (PRInt32)_a.hi >> ((b) & 31); \
328 : (r).hi = (PRInt32)_a.hi >> 31; \
329 : } \
330 : } else { \
331 : (r) = (a); \
332 : } \
333 : }
334 :
335 : #define LL_USHR(r, a, b) { \
336 : if (b) { \
337 : PRInt64 _a; \
338 : _a = a; \
339 : if ((b) < 32) { \
340 : (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> ((b) & 31)); \
341 : (r).hi = _a.hi >> ((b) & 31); \
342 : } else { \
343 : (r).lo = _a.hi >> ((b) & 31); \
344 : (r).hi = 0; \
345 : } \
346 : } else { \
347 : (r) = (a); \
348 : } \
349 : }
350 :
351 : #define LL_L2I(i, l) ((i) = (l).lo)
352 : #define LL_L2UI(ui, l) ((ui) = (l).lo)
353 : #define LL_L2F(f, l) { double _d; LL_L2D(_d, l); (f) = (PRFloat64)_d; }
354 :
355 : #define LL_L2D(d, l) { \
356 : int _negative; \
357 : PRInt64 _absval; \
358 : \
359 : _negative = (l).hi >> 31; \
360 : if (_negative) { \
361 : LL_NEG(_absval, l); \
362 : } else { \
363 : _absval = l; \
364 : } \
365 : (d) = (double)_absval.hi * 4.294967296e9 + _absval.lo; \
366 : if (_negative) \
367 : (d) = -(d); \
368 : }
369 :
370 : #define LL_I2L(l, i) { PRInt32 _i = ((PRInt32)(i)) >> 31; (l).lo = (i); (l).hi = _i; }
371 : #define LL_UI2L(l, ui) ((l).lo = (ui), (l).hi = 0)
372 : #define LL_F2L(l, f) { double _d = (double)f; LL_D2L(l, _d); }
373 :
374 : #define LL_D2L(l, d) { \
375 : int _negative; \
376 : double _absval, _d_hi; \
377 : PRInt64 _lo_d; \
378 : \
379 : _negative = ((d) < 0); \
380 : _absval = _negative ? -(d) : (d); \
381 : \
382 : (l).hi = _absval / 4.294967296e9; \
383 : (l).lo = 0; \
384 : LL_L2D(_d_hi, l); \
385 : _absval -= _d_hi; \
386 : _lo_d.hi = 0; \
387 : if (_absval < 0) { \
388 : _lo_d.lo = -_absval; \
389 : LL_SUB(l, l, _lo_d); \
390 : } else { \
391 : _lo_d.lo = _absval; \
392 : LL_ADD(l, l, _lo_d); \
393 : } \
394 : \
395 : if (_negative) \
396 : LL_NEG(l, l); \
397 : }
398 :
399 : #endif /* !HAVE_LONG_LONG */
400 :
401 : PR_END_EXTERN_C
402 :
403 : #endif /* prlong_h___ */
|
