| OLD | NEW |
|---|
| (Empty) |
| 1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ | |
| 2 /* ***** BEGIN LICENSE BLOCK ***** | |
| 3 * Version: NPL 1.1/GPL 2.0/LGPL 2.1 | |
| 4 * | |
| 5 * The contents of this file are subject to the Netscape Public License | |
| 6 * Version 1.1 (the "License"); you may not use this file except in | |
| 7 * compliance with the License. You may obtain a copy of the License at | |
| 8 * http://www.mozilla.org/NPL/ | |
| 9 * | |
| 10 * Software distributed under the License is distributed on an "AS IS" basis, | |
| 11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License | |
| 12 * for the specific language governing rights and limitations under the | |
| 13 * License. | |
| 14 * | |
| 15 * The Original Code is mozilla.org code. | |
| 16 * | |
| 17 * The Initial Developer of the Original Code is | |
| 18 * Netscape Communications Corporation. | |
| 19 * Portions created by the Initial Developer are Copyright (C) 1998 | |
| 20 * the Initial Developer. All Rights Reserved. | |
| 21 * | |
| 22 * Contributor(s): | |
| 23 * | |
| 24 * Alternatively, the contents of this file may be used under the terms of | |
| 25 * either the GNU General Public License Version 2 or later (the "GPL"), or | |
| 26 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), | |
| 27 * in which case the provisions of the GPL or the LGPL are applicable instead | |
| 28 * of those above. If you wish to allow use of your version of this file only | |
| 29 * under the terms of either the GPL or the LGPL, and not to allow others to | |
| 30 * use your version of this file under the terms of the NPL, indicate your | |
| 31 * decision by deleting the provisions above and replace them with the notice | |
| 32 * and other provisions required by the GPL or the LGPL. If you do not delete | |
| 33 * the provisions above, a recipient may use your version of this file under | |
| 34 * the terms of any one of the NPL, the GPL or the LGPL. | |
| 35 * | |
| 36 * ***** END LICENSE BLOCK ***** */ | |
| 37 | |
| 38 /******************************************************************************* | |
| 39 * Java Runtime Interface - Machine Dependent Types | |
| 40 ******************************************************************************/ | |
| 41 | |
| 42 #ifndef JRI_MD_H | |
| 43 #define JRI_MD_H | |
| 44 | |
| 45 #include <assert.h> | |
| 46 #include "prtypes.h" /* Needed for HAS_LONG_LONG ifdefs */ | |
| 47 | |
| 48 #ifdef __cplusplus | |
| 49 extern "C" { | |
| 50 #endif | |
| 51 | |
| 52 /******************************************************************************* | |
| 53 * WHAT'S UP WITH THIS FILE? | |
| 54 * | |
| 55 * This is where we define the mystical JRI_PUBLIC_API macro that works on all | |
| 56 * platforms. If you're running with Visual C++, Symantec C, or Borland's | |
| 57 * development environment on the PC, you're all set. Or if you're on the Mac | |
| 58 * with Metrowerks, Symantec or MPW with SC you're ok too. For UNIX it shouldn't | |
| 59 * matter. | |
| 60 * | |
| 61 * On UNIX though you probably care about a couple of other symbols though: | |
| 62 * IS_LITTLE_ENDIAN must be defined for little-endian systems | |
| 63 * HAVE_LONG_LONG must be defined on systems that have 'long long' integers | |
| 64 * HAVE_ALIGNED_LONGLONGS must be defined if long-longs must be 8 byte alig
ned | |
| 65 * HAVE_ALIGNED_DOUBLES must be defined if doubles must be 8 byte aligned | |
| 66 * IS_64 must be defined on 64-bit machines (like Dec Alpha) | |
| 67 ******************************************************************************/ | |
| 68 | |
| 69 /* DLL Entry modifiers... */ | |
| 70 | |
| 71 /* PC */ | |
| 72 #if defined(XP_OS2) | |
| 73 # ifdef XP_OS2_VACPP | |
| 74 # define JRI_PUBLIC_API(ResultType) ResultType _Optlink | |
| 75 # define JRI_PUBLIC_VAR(VarType) VarType | |
| 76 # define JRI_CALLBACK | |
| 77 # else | |
| 78 # define JRI_PUBLIC_API(ResultType) ResultType | |
| 79 # define JRI_PUBLIC_VAR(VarType) VarType | |
| 80 # define JRI_CALLBACK | |
| 81 # endif | |
| 82 #elif defined(XP_WIN) || defined(_WINDOWS) || defined(WIN32) || defined(_WIN32) | |
| 83 # include <windows.h> | |
| 84 # if defined(_MSC_VER) || defined(__GNUC__) | |
| 85 # if defined(WIN32) || defined(_WIN32) | |
| 86 # define JRI_PUBLIC_API(ResultType) __declspec(dllexport)
ResultType | |
| 87 # define JRI_PUBLIC_VAR(VarType) VarType | |
| 88 # define JRI_PUBLIC_VAR_EXP(VarType) __declspec(dllexport)
VarType | |
| 89 # define JRI_PUBLIC_VAR_IMP(VarType) __declspec(dllimport)
VarType | |
| 90 # define JRI_NATIVE_STUB(ResultType) __declspec(dllexport)
ResultType | |
| 91 # define JRI_CALLBACK | |
| 92 # else /* !_WIN32 */ | |
| 93 # if defined(_WINDLL) | |
| 94 # define JRI_PUBLIC_API(ResultType) ResultType __cde
cl __export __loadds | |
| 95 # define JRI_PUBLIC_VAR(VarType) VarType | |
| 96 # define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(V
arType) | |
| 97 # define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(V
arType) | |
| 98 # define JRI_NATIVE_STUB(ResultType) ResultType __cde
cl __loadds | |
| 99 # define JRI_CALLBACK __loadds | |
| 100 # else /* !WINDLL */ | |
| 101 # define JRI_PUBLIC_API(ResultType) ResultType __cde
cl __export | |
| 102 # define JRI_PUBLIC_VAR(VarType) VarType | |
| 103 # define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(V
arType) | |
| 104 # define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(V
arType) | |
| 105 # define JRI_NATIVE_STUB(ResultType) ResultType __cde
cl __export | |
| 106 # define JRI_CALLBACK __export | |
| 107 # endif /* !WINDLL */ | |
| 108 # endif /* !_WIN32 */ | |
| 109 # elif defined(__BORLANDC__) | |
| 110 # if defined(WIN32) || defined(_WIN32) | |
| 111 # define JRI_PUBLIC_API(ResultType) __export ResultT
ype | |
| 112 # define JRI_PUBLIC_VAR(VarType) VarType | |
| 113 # define JRI_PUBLIC_VAR_EXP(VarType) __export VarType | |
| 114 # define JRI_PUBLIC_VAR_IMP(VarType) __import VarType | |
| 115 # define JRI_NATIVE_STUB(ResultType) __export Result
Type | |
| 116 # define JRI_CALLBACK | |
| 117 # else /* !_WIN32 */ | |
| 118 # define JRI_PUBLIC_API(ResultType) ResultType _cdec
l _export _loadds | |
| 119 # define JRI_PUBLIC_VAR(VarType) VarType | |
| 120 # define JRI_PUBLIC_VAR_EXP(VarType) __cdecl __export
VarType | |
| 121 # define JRI_PUBLIC_VAR_IMP(VarType) __cdecl __import
VarType | |
| 122 # define JRI_NATIVE_STUB(ResultType) ResultType _cdec
l _loadds | |
| 123 # define JRI_CALLBACK _loadds | |
| 124 # endif | |
| 125 # else | |
| 126 # error Unsupported PC development environment. | |
| 127 # endif | |
| 128 # ifndef IS_LITTLE_ENDIAN | |
| 129 # define IS_LITTLE_ENDIAN | |
| 130 # endif | |
| 131 | |
| 132 /* Mac */ | |
| 133 #elif defined (macintosh) || Macintosh || THINK_C | |
| 134 # if defined(__MWERKS__) /* Metrowerks */ | |
| 135 # if !__option(enumsalwaysint) | |
| 136 # error You need to define 'Enums Always Int' for your pro
ject. | |
| 137 # endif | |
| 138 # if defined(TARGET_CPU_68K) && !TARGET_RT_MAC_CFM | |
| 139 # if !__option(fourbyteints) | |
| 140 # error You need to define 'Struct Alignment: 68k'
for your project. | |
| 141 # endif | |
| 142 # endif /* !GENERATINGCFM */ | |
| 143 # define JRI_PUBLIC_API(ResultType) __declspec(export) Resul
tType | |
| 144 # define JRI_PUBLIC_VAR(VarType) JRI_PUBLIC_API(VarType) | |
| 145 # define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_API(VarType) | |
| 146 # define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_API(VarType) | |
| 147 # define JRI_NATIVE_STUB(ResultType) JRI_PUBLIC_API(ResultTyp
e) | |
| 148 # elif defined(__SC__) /* Symantec */ | |
| 149 # error What are the Symantec defines? (warren@netscape.com) | |
| 150 # elif macintosh && applec /* MPW */ | |
| 151 # error Please upgrade to the latest MPW compiler (SC). | |
| 152 # else | |
| 153 # error Unsupported Mac development environment. | |
| 154 # endif | |
| 155 # define JRI_CALLBACK | |
| 156 | |
| 157 /* Unix or else */ | |
| 158 #else | |
| 159 # define JRI_PUBLIC_API(ResultType) ResultType | |
| 160 # define JRI_PUBLIC_VAR(VarType) VarType | |
| 161 # define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) | |
| 162 # define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) | |
| 163 # define JRI_NATIVE_STUB(ResultType) ResultType | |
| 164 # define JRI_CALLBACK | |
| 165 #endif | |
| 166 | |
| 167 #ifndef FAR /* for non-Win16 */ | |
| 168 #define FAR | |
| 169 #endif | |
| 170 | |
| 171 /******************************************************************************/ | |
| 172 | |
| 173 /* Java Scalar Types */ | |
| 174 | |
| 175 #if 0 /* now in jni.h */ | |
| 176 typedef short jchar; | |
| 177 typedef short jshort; | |
| 178 typedef float jfloat; | |
| 179 typedef double jdouble; | |
| 180 typedef juint jsize; | |
| 181 #endif | |
| 182 | |
| 183 /* moved from jni.h -- Sun's new jni.h doesn't have this anymore */ | |
| 184 #ifdef __cplusplus | |
| 185 typedef class _jobject *jref; | |
| 186 #else | |
| 187 typedef struct _jobject *jref; | |
| 188 #endif | |
| 189 | |
| 190 typedef unsigned char jbool; | |
| 191 typedef signed char jbyte; | |
| 192 #ifdef IS_64 /* XXX ok for alpha, but not right on all 64-bit architectures */ | |
| 193 typedef unsigned int juint; | |
| 194 typedef int jint; | |
| 195 #else | |
| 196 typedef unsigned long juint; | |
| 197 typedef long jint; | |
| 198 #endif | |
| 199 | |
| 200 /******************************************************************************* | |
| 201 * jlong : long long (64-bit signed integer type) support. | |
| 202 ******************************************************************************/ | |
| 203 | |
| 204 /* | |
| 205 ** Bit masking macros. (n must be <= 31 to be portable) | |
| 206 */ | |
| 207 #define JRI_BIT(n) ((juint)1 << (n)) | |
| 208 #define JRI_BITMASK(n) (JRI_BIT(n) - 1) | |
| 209 | |
| 210 #ifdef HAVE_LONG_LONG | |
| 211 | |
| 212 #ifdef OSF1 | |
| 213 | |
| 214 /* long is default 64-bit on OSF1, -std1 does not allow long long */ | |
| 215 typedef long jlong; | |
| 216 typedef unsigned long julong; | |
| 217 #define jlong_MAXINT 0x7fffffffffffffffL | |
| 218 #define jlong_MININT 0x8000000000000000L | |
| 219 #define jlong_ZERO 0x0L | |
| 220 | |
| 221 #elif (defined(WIN32) || defined(_WIN32)) | |
| 222 | |
| 223 typedef LONGLONG jlong; | |
| 224 typedef DWORDLONG julong; | |
| 225 #define jlong_MAXINT 0x7fffffffffffffffi64 | |
| 226 #define jlong_MININT 0x8000000000000000i64 | |
| 227 #define jlong_ZERO 0x0i64 | |
| 228 | |
| 229 #else | |
| 230 | |
| 231 typedef long long jlong; | |
| 232 typedef unsigned long long julong; | |
| 233 #define jlong_MAXINT 0x7fffffffffffffffLL | |
| 234 #define jlong_MININT 0x8000000000000000LL | |
| 235 #define jlong_ZERO 0x0LL | |
| 236 | |
| 237 #endif | |
| 238 | |
| 239 #define jlong_IS_ZERO(a) ((a) == 0) | |
| 240 #define jlong_EQ(a, b) ((a) == (b)) | |
| 241 #define jlong_NE(a, b) ((a) != (b)) | |
| 242 #define jlong_GE_ZERO(a) ((a) >= 0) | |
| 243 #define jlong_CMP(a, op, b) ((a) op (b)) | |
| 244 | |
| 245 #define jlong_AND(r, a, b) ((r) = (a) & (b)) | |
| 246 #define jlong_OR(r, a, b) ((r) = (a) | (b)) | |
| 247 #define jlong_XOR(r, a, b) ((r) = (a) ^ (b)) | |
| 248 #define jlong_OR2(r, a) ((r) = (r) | (a)) | |
| 249 #define jlong_NOT(r, a) ((r) = ~(a)) | |
| 250 | |
| 251 #define jlong_NEG(r, a) ((r) = -(a)) | |
| 252 #define jlong_ADD(r, a, b) ((r) = (a) + (b)) | |
| 253 #define jlong_SUB(r, a, b) ((r) = (a) - (b)) | |
| 254 | |
| 255 #define jlong_MUL(r, a, b) ((r) = (a) * (b)) | |
| 256 #define jlong_DIV(r, a, b) ((r) = (a) / (b)) | |
| 257 #define jlong_MOD(r, a, b) ((r) = (a) % (b)) | |
| 258 | |
| 259 #define jlong_SHL(r, a, b) ((r) = (a) << (b)) | |
| 260 #define jlong_SHR(r, a, b) ((r) = (a) >> (b)) | |
| 261 #define jlong_USHR(r, a, b) ((r) = (julong)(a) >> (b)) | |
| 262 #define jlong_ISHL(r, a, b) ((r) = ((jlong)(a)) << (b)) | |
| 263 | |
| 264 #define jlong_L2I(i, l) ((i) = (int)(l)) | |
| 265 #define jlong_L2UI(ui, l) ((ui) =(unsigned int)(l)) | |
| 266 #define jlong_L2F(f, l) ((f) = (l)) | |
| 267 #define jlong_L2D(d, l) ((d) = (l)) | |
| 268 | |
| 269 #define jlong_I2L(l, i) ((l) = (i)) | |
| 270 #define jlong_UI2L(l, ui) ((l) = (ui)) | |
| 271 #define jlong_F2L(l, f) ((l) = (f)) | |
| 272 #define jlong_D2L(l, d) ((l) = (d)) | |
| 273 | |
| 274 #define jlong_UDIVMOD(qp, rp, a, b) \ | |
| 275 (*(qp) = ((julong)(a) / (b)), \ | |
| 276 *(rp) = ((julong)(a) % (b))) | |
| 277 | |
| 278 #else /* !HAVE_LONG_LONG */ | |
| 279 | |
| 280 typedef struct { | |
| 281 #ifdef IS_LITTLE_ENDIAN | |
| 282 juint lo, hi; | |
| 283 #else | |
| 284 juint hi, lo; | |
| 285 #endif | |
| 286 } jlong; | |
| 287 typedef jlong julong; | |
| 288 | |
| 289 extern jlong jlong_MAXINT, jlong_MININT, jlong_ZERO; | |
| 290 | |
| 291 #define jlong_IS_ZERO(a) (((a).hi == 0) && ((a).lo == 0)) | |
| 292 #define jlong_EQ(a, b) (((a).hi == (b).hi) && ((a).lo == (b).lo)) | |
| 293 #define jlong_NE(a, b) (((a).hi != (b).hi) || ((a).lo != (b).lo)) | |
| 294 #define jlong_GE_ZERO(a) (((a).hi >> 31) == 0) | |
| 295 | |
| 296 /* | |
| 297 * NB: jlong_CMP and jlong_UCMP work only for strict relationals (<, >). | |
| 298 */ | |
| 299 #define jlong_CMP(a, op, b) (((int32)(a).hi op (int32)(b).hi) || \ | |
| 300 (((a).hi == (b).hi) && ((a).lo op (b).lo))) | |
| 301 #define jlong_UCMP(a, op, b) (((a).hi op (b).hi) || \ | |
| 302 (((a).hi == (b).hi) && ((a).lo op (b).lo))) | |
| 303 | |
| 304 #define jlong_AND(r, a, b) ((r).lo = (a).lo & (b).lo, \ | |
| 305 (r).hi = (a).hi & (b).hi) | |
| 306 #define jlong_OR(r, a, b) ((r).lo = (a).lo | (b).lo, \ | |
| 307 (r).hi = (a).hi | (b).hi) | |
| 308 #define jlong_XOR(r, a, b) ((r).lo = (a).lo ^ (b).lo, \ | |
| 309 (r).hi = (a).hi ^ (b).hi) | |
| 310 #define jlong_OR2(r, a) ((r).lo = (r).lo | (a).lo, \ | |
| 311 (r).hi = (r).hi | (a).hi) | |
| 312 #define jlong_NOT(r, a) ((r).lo = ~(a).lo,
\ | |
| 313 (r).hi = ~(a).hi) | |
| 314 | |
| 315 #define jlong_NEG(r, a) ((r).lo = -(int32)(a).lo, \ | |
| 316 (r).hi = -(int32)(a).hi - ((r).lo != 0)) | |
| 317 #define jlong_ADD(r, a, b) { \ | |
| 318 jlong _a, _b; \ | |
| 319 _a = a; _b = b; \ | |
| 320 (r).lo = _a.lo + _b.lo; \ | |
| 321 (r).hi = _a.hi + _b.hi + ((r).lo < _b.lo); \ | |
| 322 } | |
| 323 | |
| 324 #define jlong_SUB(r, a, b) { \ | |
| 325 jlong _a, _b; \ | |
| 326 _a = a; _b = b; \ | |
| 327 (r).lo = _a.lo - _b.lo; \ | |
| 328 (r).hi = _a.hi - _b.hi - (_a.lo < _b.lo); \ | |
| 329 } \ | |
| 330 | |
| 331 /* | |
| 332 * Multiply 64-bit operands a and b to get 64-bit result r. | |
| 333 * First multiply the low 32 bits of a and b to get a 64-bit result in r. | |
| 334 * Then add the outer and inner products to r.hi. | |
| 335 */ | |
| 336 #define jlong_MUL(r, a, b) { \ | |
| 337 jlong _a, _b; \ | |
| 338 _a = a; _b = b; \ | |
| 339 jlong_MUL32(r, _a.lo, _b.lo); \ | |
| 340 (r).hi += _a.hi * _b.lo + _a.lo * _b.hi; \ | |
| 341 } | |
| 342 | |
| 343 /* XXX _jlong_lo16(a) = ((a) << 16 >> 16) is better on some archs (not on mips)
*/ | |
| 344 #define _jlong_lo16(a) ((a) & JRI_BITMASK(16)) | |
| 345 #define _jlong_hi16(a) ((a) >> 16) | |
| 346 | |
| 347 /* | |
| 348 * Multiply 32-bit operands a and b to get 64-bit result r. | |
| 349 * Use polynomial expansion based on primitive field element (1 << 16). | |
| 350 */ | |
| 351 #define jlong_MUL32(r, a, b) { \ | |
| 352 juint _a1, _a0, _b1, _b0, _y0, _y1, _y2, _y3; \ | |
| 353 _a1 = _jlong_hi16(a), _a0 = _jlong_lo16(a); \ | |
| 354 _b1 = _jlong_hi16(b), _b0 = _jlong_lo16(b); \ | |
| 355 _y0 = _a0 * _b0; \ | |
| 356 _y1 = _a0 * _b1; \ | |
| 357 _y2 = _a1 * _b0; \ | |
| 358 _y3 = _a1 * _b1; \ | |
| 359 _y1 += _jlong_hi16(_y0); /* can't carry */ \ | |
| 360 _y1 += _y2; /* might carry */ \ | |
| 361 if (_y1 < _y2) _y3 += 1 << 16; /* propagate */ \ | |
| 362 (r).lo = (_jlong_lo16(_y1) << 16) + _jlong_lo16(_y0); \ | |
| 363 (r).hi = _y3 + _jlong_hi16(_y1); \ | |
| 364 } | |
| 365 | |
| 366 /* | |
| 367 * Divide 64-bit unsigned operand a by 64-bit unsigned operand b, setting *qp | |
| 368 * to the 64-bit unsigned quotient, and *rp to the 64-bit unsigned remainder. | |
| 369 * Minimize effort if one of qp and rp is null. | |
| 370 */ | |
| 371 #define jlong_UDIVMOD(qp, rp, a, b) jlong_udivmod(qp, rp, a, b) | |
| 372 | |
| 373 extern JRI_PUBLIC_API(void) | |
| 374 jlong_udivmod(julong *qp, julong *rp, julong a, julong b); | |
| 375 | |
| 376 #define jlong_DIV(r, a, b) { \ | |
| 377 jlong _a, _b; \ | |
| 378 juint _negative = (int32)(a).hi < 0; \ | |
| 379 if (_negative) { \ | |
| 380 jlong_NEG(_a, a); \ | |
| 381 } else { \ | |
| 382 _a = a; \ | |
| 383 } \ | |
| 384 if ((int32)(b).hi < 0) { \ | |
| 385 _negative ^= 1; \ | |
| 386 jlong_NEG(_b, b); \ | |
| 387 } else { \ | |
| 388 _b = b; \ | |
| 389 } \ | |
| 390 jlong_UDIVMOD(&(r), 0, _a, _b); \ | |
| 391 if (_negative) \ | |
| 392 jlong_NEG(r, r); \ | |
| 393 } | |
| 394 | |
| 395 #define jlong_MOD(r, a, b) { \ | |
| 396 jlong _a, _b; \ | |
| 397 juint _negative = (int32)(a).hi < 0; \ | |
| 398 if (_negative) { \ | |
| 399 jlong_NEG(_a, a); \ | |
| 400 } else { \ | |
| 401 _a = a; \ | |
| 402 } \ | |
| 403 if ((int32)(b).hi < 0) { \ | |
| 404 jlong_NEG(_b, b); \ | |
| 405 } else { \ | |
| 406 _b = b; \ | |
| 407 } \ | |
| 408 jlong_UDIVMOD(0, &(r), _a, _b); \ | |
| 409 if (_negative) \ | |
| 410 jlong_NEG(r, r); \ | |
| 411 } | |
| 412 | |
| 413 /* | |
| 414 * NB: b is a juint, not jlong or julong, for the shift ops. | |
| 415 */ | |
| 416 #define jlong_SHL(r, a, b) { \ | |
| 417 if (b) { \ | |
| 418 jlong _a; \ | |
| 419 _a = a; \ | |
| 420 if ((b) < 32) { \ | |
| 421 (r).lo = _a.lo << (b); \ | |
| 422 (r).hi = (_a.hi << (b)) | (_a.lo >> (32 - (b))); \ | |
| 423 } else { \ | |
| 424 (r).lo = 0; \ | |
| 425 (r).hi = _a.lo << ((b) & 31); \ | |
| 426 } \ | |
| 427 } else { \ | |
| 428 (r) = (a); \ | |
| 429 } \ | |
| 430 } | |
| 431 | |
| 432 /* a is an int32, b is int32, r is jlong */ | |
| 433 #define jlong_ISHL(r, a, b) { \ | |
| 434 if (b) { \ | |
| 435 jlong _a; \ | |
| 436 _a.lo = (a); \ | |
| 437 _a.hi = 0; \ | |
| 438 if ((b) < 32) { \ | |
| 439 (r).lo = (a) << (b); \ | |
| 440 (r).hi = ((a) >> (32 - (b))); \ | |
| 441 } else { \ | |
| 442 (r).lo = 0; \ | |
| 443 (r).hi = (a) << ((b) & 31); \ | |
| 444 } \ | |
| 445 } else { \ | |
| 446 (r).lo = (a); \ | |
| 447 (r).hi = 0; \ | |
| 448 } \ | |
| 449 } | |
| 450 | |
| 451 #define jlong_SHR(r, a, b) { \ | |
| 452 if (b) { \ | |
| 453 jlong _a; \ | |
| 454 _a = a; \ | |
| 455 if ((b) < 32) { \ | |
| 456 (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b)); \ | |
| 457 (r).hi = (int32)_a.hi >> (b); \ | |
| 458 } else { \ | |
| 459 (r).lo = (int32)_a.hi >> ((b) & 31); \ | |
| 460 (r).hi = (int32)_a.hi >> 31; \ | |
| 461 } \ | |
| 462 } else { \ | |
| 463 (r) = (a); \ | |
| 464 } \ | |
| 465 } | |
| 466 | |
| 467 #define jlong_USHR(r, a, b) { \ | |
| 468 if (b) { \ | |
| 469 jlong _a; \ | |
| 470 _a = a; \ | |
| 471 if ((b) < 32) { \ | |
| 472 (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b)); \ | |
| 473 (r).hi = _a.hi >> (b); \ | |
| 474 } else { \ | |
| 475 (r).lo = _a.hi >> ((b) & 31); \ | |
| 476 (r).hi = 0; \ | |
| 477 } \ | |
| 478 } else { \ | |
| 479 (r) = (a); \ | |
| 480 } \ | |
| 481 } | |
| 482 | |
| 483 #define jlong_L2I(i, l) ((i) = (l).lo) | |
| 484 #define jlong_L2UI(ui, l) ((ui) = (l).lo) | |
| 485 #define jlong_L2F(f, l) { double _d; jlong_L2D(_d, l); (f) = (float) _d;
} | |
| 486 | |
| 487 #define jlong_L2D(d, l) { \ | |
| 488 int32 _negative; \ | |
| 489 jlong _absval; \ | |
| 490 \ | |
| 491 _negative = (l).hi >> 31; \ | |
| 492 if (_negative) { \ | |
| 493 jlong_NEG(_absval, l); \ | |
| 494 } else { \ | |
| 495 _absval = l; \ | |
| 496 } \ | |
| 497 (d) = (double)_absval.hi * 4.294967296e9 + _absval.lo; \ | |
| 498 if (_negative) \ | |
| 499 (d) = -(d); \ | |
| 500 } | |
| 501 | |
| 502 #define jlong_I2L(l, i) ((l).hi = (i) >> 31, (l).lo = (i)) | |
| 503 #define jlong_UI2L(l, ui) ((l).hi = 0, (l).lo = (ui)) | |
| 504 #define jlong_F2L(l, f) { double _d = (double) f; jlong_D2L(l, _d); } | |
| 505 | |
| 506 #define jlong_D2L(l, d) { \ | |
| 507 int _negative; \ | |
| 508 double _absval, _d_hi; \ | |
| 509 jlong _lo_d; \ | |
| 510 \ | |
| 511 _negative = ((d) < 0); \ | |
| 512 _absval = _negative ? -(d) : (d); \ | |
| 513 \ | |
| 514 (l).hi = (juint)(_absval / 4.294967296e9); \ | |
| 515 (l).lo = 0; \ | |
| 516 jlong_L2D(_d_hi, l); \ | |
| 517 _absval -= _d_hi; \ | |
| 518 _lo_d.hi = 0; \ | |
| 519 if (_absval < 0) { \ | |
| 520 _lo_d.lo = (juint) -_absval; \ | |
| 521 jlong_SUB(l, l, _lo_d); \ | |
| 522 } else { \ | |
| 523 _lo_d.lo = (juint) _absval; \ | |
| 524 jlong_ADD(l, l, _lo_d); \ | |
| 525 } \ | |
| 526 \ | |
| 527 if (_negative) \ | |
| 528 jlong_NEG(l, l); \ | |
| 529 } | |
| 530 | |
| 531 #endif /* !HAVE_LONG_LONG */ | |
| 532 | |
| 533 /******************************************************************************/ | |
| 534 | |
| 535 #ifdef HAVE_ALIGNED_LONGLONGS | |
| 536 #define JRI_GET_INT64(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \ | |
| 537 ((_t).x[1] = ((jint*)(_addr))[1]), \ | |
| 538 (_t).l ) | |
| 539 #define JRI_SET_INT64(_t, _addr, _v) ( (_t).l = (_v), \ | |
| 540 ((jint*)(_addr))[0] = (_t).x[0], \ | |
| 541 ((jint*)(_addr))[1] = (_t).x[1] ) | |
| 542 #else | |
| 543 #define JRI_GET_INT64(_t,_addr) (*(jlong*)(_addr)) | |
| 544 #define JRI_SET_INT64(_t, _addr, _v) (*(jlong*)(_addr) = (_v)) | |
| 545 #endif | |
| 546 | |
| 547 /* If double's must be aligned on doubleword boundaries then define this */ | |
| 548 #ifdef HAVE_ALIGNED_DOUBLES | |
| 549 #define JRI_GET_DOUBLE(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \ | |
| 550 ((_t).x[1] = ((jint*)(_addr))[1]), \ | |
| 551 (_t).d ) | |
| 552 #define JRI_SET_DOUBLE(_t, _addr, _v) ( (_t).d = (_v), \ | |
| 553 ((jint*)(_addr))[0] = (_t).x[0], \ | |
| 554 ((jint*)(_addr))[1] = (_t).x[1] ) | |
| 555 #else | |
| 556 #define JRI_GET_DOUBLE(_t,_addr) (*(jdouble*)(_addr)) | |
| 557 #define JRI_SET_DOUBLE(_t, _addr, _v) (*(jdouble*)(_addr) = (_v)) | |
| 558 #endif | |
| 559 | |
| 560 /******************************************************************************/ | |
| 561 #ifdef __cplusplus | |
| 562 } | |
| 563 #endif | |
| 564 #endif /* JRI_MD_H */ | |
| 565 /******************************************************************************/ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 665543002:
Remove third_party/npapi/npspy. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master