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