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
19PR_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***********************************************************************/
30NSPR_API(PRInt64) LL_MaxInt(void);
31NSPR_API(PRInt64) LL_MinInt(void);
32NSPR_API(PRInt64) LL_Zero(void);
33NSPR_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
245NSPR_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
401PR_END_EXTERN_C
402
403#endif /* prlong_h___ */
404

source code of include/nspr/prlong.h