1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ |
|
2 /* ***** BEGIN LICENSE BLOCK ***** |
|
3 * Version: MPL 1.1/GPL 2.0/LGPL 2.1 |
|
4 * |
|
5 * The contents of this file are subject to the Mozilla Public License Version |
|
6 * 1.1 (the "License"); you may not use this file except in compliance with |
|
7 * the License. You may obtain a copy of the License at |
|
8 * http://www.mozilla.org/MPL/ |
|
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 MPL, 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 MPL, 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 aligned |
|
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 /* Windows */ |
|
72 #if defined(XP_WIN) || defined(_WINDOWS) || defined(WIN32) || defined(_WIN32) |
|
73 # include <windows.h> |
|
74 # if defined(_MSC_VER) || defined(__GNUC__) |
|
75 # if defined(WIN32) || defined(_WIN32) |
|
76 # define JRI_PUBLIC_API(ResultType) __declspec(dllexport) ResultType |
|
77 # define JRI_PUBLIC_VAR(VarType) VarType |
|
78 # define JRI_PUBLIC_VAR_EXP(VarType) __declspec(dllexport) VarType |
|
79 # define JRI_PUBLIC_VAR_IMP(VarType) __declspec(dllimport) VarType |
|
80 # define JRI_NATIVE_STUB(ResultType) __declspec(dllexport) ResultType |
|
81 # define JRI_CALLBACK |
|
82 # else /* !_WIN32 */ |
|
83 # if defined(_WINDLL) |
|
84 # define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export __loadds |
|
85 # define JRI_PUBLIC_VAR(VarType) VarType |
|
86 # define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) |
|
87 # define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) |
|
88 # define JRI_NATIVE_STUB(ResultType) ResultType __cdecl __loadds |
|
89 # define JRI_CALLBACK __loadds |
|
90 # else /* !WINDLL */ |
|
91 # define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export |
|
92 # define JRI_PUBLIC_VAR(VarType) VarType |
|
93 # define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) |
|
94 # define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) |
|
95 # define JRI_NATIVE_STUB(ResultType) ResultType __cdecl __export |
|
96 # define JRI_CALLBACK __export |
|
97 # endif /* !WINDLL */ |
|
98 # endif /* !_WIN32 */ |
|
99 # elif defined(__BORLANDC__) |
|
100 # if defined(WIN32) || defined(_WIN32) |
|
101 # define JRI_PUBLIC_API(ResultType) __export ResultType |
|
102 # define JRI_PUBLIC_VAR(VarType) VarType |
|
103 # define JRI_PUBLIC_VAR_EXP(VarType) __export VarType |
|
104 # define JRI_PUBLIC_VAR_IMP(VarType) __import VarType |
|
105 # define JRI_NATIVE_STUB(ResultType) __export ResultType |
|
106 # define JRI_CALLBACK |
|
107 # else /* !_WIN32 */ |
|
108 # define JRI_PUBLIC_API(ResultType) ResultType _cdecl _export _loadds |
|
109 # define JRI_PUBLIC_VAR(VarType) VarType |
|
110 # define JRI_PUBLIC_VAR_EXP(VarType) __cdecl __export VarType |
|
111 # define JRI_PUBLIC_VAR_IMP(VarType) __cdecl __import VarType |
|
112 # define JRI_NATIVE_STUB(ResultType) ResultType _cdecl _loadds |
|
113 # define JRI_CALLBACK _loadds |
|
114 # endif |
|
115 # else |
|
116 # error Unsupported PC development environment. |
|
117 # endif |
|
118 # ifndef IS_LITTLE_ENDIAN |
|
119 # define IS_LITTLE_ENDIAN |
|
120 # endif |
|
121 |
|
122 /* OS/2 */ |
|
123 #elif defined(XP_OS2) |
|
124 # ifdef XP_OS2_VACPP |
|
125 # define JRI_PUBLIC_API(ResultType) ResultType _Optlink |
|
126 # define JRI_PUBLIC_VAR(VarType) VarType |
|
127 # define JRI_CALLBACK |
|
128 # elif defined(__declspec) |
|
129 # define JRI_PUBLIC_API(ResultType) __declspec(dllexport) ResultType |
|
130 # define JRI_PUBLIC_VAR(VarType) VarType |
|
131 # define JRI_PUBLIC_VAR_EXP(VarType) __declspec(dllexport) VarType |
|
132 # define JRI_PUBLIC_VAR_IMP(VarType) __declspec(dllimport) VarType |
|
133 # define JRI_NATIVE_STUB(ResultType) __declspec(dllexport) ResultType |
|
134 # define JRI_CALLBACK |
|
135 # else |
|
136 # define JRI_PUBLIC_API(ResultType) ResultType |
|
137 # define JRI_PUBLIC_VAR(VarType) VarType |
|
138 # define JRI_CALLBACK |
|
139 # endif |
|
140 |
|
141 /* Mac */ |
|
142 #elif defined (macintosh) || Macintosh || THINK_C |
|
143 # if defined(__MWERKS__) /* Metrowerks */ |
|
144 # if !__option(enumsalwaysint) |
|
145 # error You need to define 'Enums Always Int' for your project. |
|
146 # endif |
|
147 # if defined(TARGET_CPU_68K) && !TARGET_RT_MAC_CFM |
|
148 # if !__option(fourbyteints) |
|
149 # error You need to define 'Struct Alignment: 68k' for your project. |
|
150 # endif |
|
151 # endif /* !GENERATINGCFM */ |
|
152 # define JRI_PUBLIC_API(ResultType) __declspec(export) ResultType |
|
153 # define JRI_PUBLIC_VAR(VarType) JRI_PUBLIC_API(VarType) |
|
154 # define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_API(VarType) |
|
155 # define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_API(VarType) |
|
156 # define JRI_NATIVE_STUB(ResultType) JRI_PUBLIC_API(ResultType) |
|
157 # elif defined(__SC__) /* Symantec */ |
|
158 # error What are the Symantec defines? (warren@netscape.com) |
|
159 # elif macintosh && applec /* MPW */ |
|
160 # error Please upgrade to the latest MPW compiler (SC). |
|
161 # else |
|
162 # error Unsupported Mac development environment. |
|
163 # endif |
|
164 # define JRI_CALLBACK |
|
165 |
|
166 /* Unix or else */ |
|
167 #else |
|
168 # define JRI_PUBLIC_API(ResultType) ResultType |
|
169 # define JRI_PUBLIC_VAR(VarType) VarType |
|
170 # define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType) |
|
171 # define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType) |
|
172 # define JRI_NATIVE_STUB(ResultType) ResultType |
|
173 # define JRI_CALLBACK |
|
174 #endif |
|
175 |
|
176 #ifndef FAR /* for non-Win16 */ |
|
177 #define FAR |
|
178 #endif |
|
179 |
|
180 /******************************************************************************/ |
|
181 |
|
182 /* Java Scalar Types */ |
|
183 |
|
184 #if 0 /* now in jni.h */ |
|
185 typedef short jchar; |
|
186 typedef short jshort; |
|
187 typedef float jfloat; |
|
188 typedef double jdouble; |
|
189 typedef juint jsize; |
|
190 #endif |
|
191 |
|
192 /* moved from jni.h -- Sun's new jni.h doesn't have this anymore */ |
|
193 #ifdef __cplusplus |
|
194 typedef class _jobject *jref; |
|
195 #else |
|
196 typedef struct _jobject *jref; |
|
197 #endif |
|
198 |
|
199 typedef unsigned char jbool; |
|
200 typedef signed char jbyte; |
|
201 #ifdef IS_64 /* XXX ok for alpha, but not right on all 64-bit architectures */ |
|
202 typedef unsigned int juint; |
|
203 typedef int jint; |
|
204 #else |
|
205 typedef unsigned long juint; |
|
206 typedef long jint; |
|
207 #endif |
|
208 |
|
209 /******************************************************************************* |
|
210 * jlong : long long (64-bit signed integer type) support. |
|
211 ******************************************************************************/ |
|
212 |
|
213 /* |
|
214 ** Bit masking macros. (n must be <= 31 to be portable) |
|
215 */ |
|
216 #define JRI_BIT(n) ((juint)1 << (n)) |
|
217 #define JRI_BITMASK(n) (JRI_BIT(n) - 1) |
|
218 |
|
219 #ifdef HAVE_LONG_LONG |
|
220 |
|
221 #ifdef OSF1 |
|
222 |
|
223 /* long is default 64-bit on OSF1, -std1 does not allow long long */ |
|
224 typedef long jlong; |
|
225 typedef unsigned long julong; |
|
226 #define jlong_MAXINT 0x7fffffffffffffffL |
|
227 #define jlong_MININT 0x8000000000000000L |
|
228 #define jlong_ZERO 0x0L |
|
229 |
|
230 #elif (defined(WIN32) || defined(_WIN32)) |
|
231 |
|
232 typedef LONGLONG jlong; |
|
233 typedef DWORDLONG julong; |
|
234 #define jlong_MAXINT 0x7fffffffffffffffi64 |
|
235 #define jlong_MININT 0x8000000000000000i64 |
|
236 #define jlong_ZERO 0x0i64 |
|
237 |
|
238 #else |
|
239 |
|
240 typedef long long jlong; |
|
241 typedef unsigned long long julong; |
|
242 #define jlong_MAXINT 0x7fffffffffffffffLL |
|
243 #define jlong_MININT 0x8000000000000000LL |
|
244 #define jlong_ZERO 0x0LL |
|
245 |
|
246 #endif |
|
247 |
|
248 #define jlong_IS_ZERO(a) ((a) == 0) |
|
249 #define jlong_EQ(a, b) ((a) == (b)) |
|
250 #define jlong_NE(a, b) ((a) != (b)) |
|
251 #define jlong_GE_ZERO(a) ((a) >= 0) |
|
252 #define jlong_CMP(a, op, b) ((a) op (b)) |
|
253 |
|
254 #define jlong_AND(r, a, b) ((r) = (a) & (b)) |
|
255 #define jlong_OR(r, a, b) ((r) = (a) | (b)) |
|
256 #define jlong_XOR(r, a, b) ((r) = (a) ^ (b)) |
|
257 #define jlong_OR2(r, a) ((r) = (r) | (a)) |
|
258 #define jlong_NOT(r, a) ((r) = ~(a)) |
|
259 |
|
260 #define jlong_NEG(r, a) ((r) = -(a)) |
|
261 #define jlong_ADD(r, a, b) ((r) = (a) + (b)) |
|
262 #define jlong_SUB(r, a, b) ((r) = (a) - (b)) |
|
263 |
|
264 #define jlong_MUL(r, a, b) ((r) = (a) * (b)) |
|
265 #define jlong_DIV(r, a, b) ((r) = (a) / (b)) |
|
266 #define jlong_MOD(r, a, b) ((r) = (a) % (b)) |
|
267 |
|
268 #define jlong_SHL(r, a, b) ((r) = (a) << (b)) |
|
269 #define jlong_SHR(r, a, b) ((r) = (a) >> (b)) |
|
270 #define jlong_USHR(r, a, b) ((r) = (julong)(a) >> (b)) |
|
271 #define jlong_ISHL(r, a, b) ((r) = ((jlong)(a)) << (b)) |
|
272 |
|
273 #define jlong_L2I(i, l) ((i) = (int)(l)) |
|
274 #define jlong_L2UI(ui, l) ((ui) =(unsigned int)(l)) |
|
275 #define jlong_L2F(f, l) ((f) = (l)) |
|
276 #define jlong_L2D(d, l) ((d) = (l)) |
|
277 |
|
278 #define jlong_I2L(l, i) ((l) = (i)) |
|
279 #define jlong_UI2L(l, ui) ((l) = (ui)) |
|
280 #define jlong_F2L(l, f) ((l) = (f)) |
|
281 #define jlong_D2L(l, d) ((l) = (d)) |
|
282 |
|
283 #define jlong_UDIVMOD(qp, rp, a, b) \ |
|
284 (*(qp) = ((julong)(a) / (b)), \ |
|
285 *(rp) = ((julong)(a) % (b))) |
|
286 |
|
287 #else /* !HAVE_LONG_LONG */ |
|
288 |
|
289 typedef struct { |
|
290 #ifdef IS_LITTLE_ENDIAN |
|
291 juint lo, hi; |
|
292 #else |
|
293 juint hi, lo; |
|
294 #endif |
|
295 } jlong; |
|
296 typedef jlong julong; |
|
297 |
|
298 extern jlong jlong_MAXINT, jlong_MININT, jlong_ZERO; |
|
299 |
|
300 #define jlong_IS_ZERO(a) (((a).hi == 0) && ((a).lo == 0)) |
|
301 #define jlong_EQ(a, b) (((a).hi == (b).hi) && ((a).lo == (b).lo)) |
|
302 #define jlong_NE(a, b) (((a).hi != (b).hi) || ((a).lo != (b).lo)) |
|
303 #define jlong_GE_ZERO(a) (((a).hi >> 31) == 0) |
|
304 |
|
305 /* |
|
306 * NB: jlong_CMP and jlong_UCMP work only for strict relationals (<, >). |
|
307 */ |
|
308 #define jlong_CMP(a, op, b) (((int32)(a).hi op (int32)(b).hi) || \ |
|
309 (((a).hi == (b).hi) && ((a).lo op (b).lo))) |
|
310 #define jlong_UCMP(a, op, b) (((a).hi op (b).hi) || \ |
|
311 (((a).hi == (b).hi) && ((a).lo op (b).lo))) |
|
312 |
|
313 #define jlong_AND(r, a, b) ((r).lo = (a).lo & (b).lo, \ |
|
314 (r).hi = (a).hi & (b).hi) |
|
315 #define jlong_OR(r, a, b) ((r).lo = (a).lo | (b).lo, \ |
|
316 (r).hi = (a).hi | (b).hi) |
|
317 #define jlong_XOR(r, a, b) ((r).lo = (a).lo ^ (b).lo, \ |
|
318 (r).hi = (a).hi ^ (b).hi) |
|
319 #define jlong_OR2(r, a) ((r).lo = (r).lo | (a).lo, \ |
|
320 (r).hi = (r).hi | (a).hi) |
|
321 #define jlong_NOT(r, a) ((r).lo = ~(a).lo, \ |
|
322 (r).hi = ~(a).hi) |
|
323 |
|
324 #define jlong_NEG(r, a) ((r).lo = -(int32)(a).lo, \ |
|
325 (r).hi = -(int32)(a).hi - ((r).lo != 0)) |
|
326 #define jlong_ADD(r, a, b) { \ |
|
327 jlong _a, _b; \ |
|
328 _a = a; _b = b; \ |
|
329 (r).lo = _a.lo + _b.lo; \ |
|
330 (r).hi = _a.hi + _b.hi + ((r).lo < _b.lo); \ |
|
331 } |
|
332 |
|
333 #define jlong_SUB(r, a, b) { \ |
|
334 jlong _a, _b; \ |
|
335 _a = a; _b = b; \ |
|
336 (r).lo = _a.lo - _b.lo; \ |
|
337 (r).hi = _a.hi - _b.hi - (_a.lo < _b.lo); \ |
|
338 } \ |
|
339 |
|
340 /* |
|
341 * Multiply 64-bit operands a and b to get 64-bit result r. |
|
342 * First multiply the low 32 bits of a and b to get a 64-bit result in r. |
|
343 * Then add the outer and inner products to r.hi. |
|
344 */ |
|
345 #define jlong_MUL(r, a, b) { \ |
|
346 jlong _a, _b; \ |
|
347 _a = a; _b = b; \ |
|
348 jlong_MUL32(r, _a.lo, _b.lo); \ |
|
349 (r).hi += _a.hi * _b.lo + _a.lo * _b.hi; \ |
|
350 } |
|
351 |
|
352 /* XXX _jlong_lo16(a) = ((a) << 16 >> 16) is better on some archs (not on mips) */ |
|
353 #define _jlong_lo16(a) ((a) & JRI_BITMASK(16)) |
|
354 #define _jlong_hi16(a) ((a) >> 16) |
|
355 |
|
356 /* |
|
357 * Multiply 32-bit operands a and b to get 64-bit result r. |
|
358 * Use polynomial expansion based on primitive field element (1 << 16). |
|
359 */ |
|
360 #define jlong_MUL32(r, a, b) { \ |
|
361 juint _a1, _a0, _b1, _b0, _y0, _y1, _y2, _y3; \ |
|
362 _a1 = _jlong_hi16(a), _a0 = _jlong_lo16(a); \ |
|
363 _b1 = _jlong_hi16(b), _b0 = _jlong_lo16(b); \ |
|
364 _y0 = _a0 * _b0; \ |
|
365 _y1 = _a0 * _b1; \ |
|
366 _y2 = _a1 * _b0; \ |
|
367 _y3 = _a1 * _b1; \ |
|
368 _y1 += _jlong_hi16(_y0); /* can't carry */ \ |
|
369 _y1 += _y2; /* might carry */ \ |
|
370 if (_y1 < _y2) _y3 += 1 << 16; /* propagate */ \ |
|
371 (r).lo = (_jlong_lo16(_y1) << 16) + _jlong_lo16(_y0); \ |
|
372 (r).hi = _y3 + _jlong_hi16(_y1); \ |
|
373 } |
|
374 |
|
375 /* |
|
376 * Divide 64-bit unsigned operand a by 64-bit unsigned operand b, setting *qp |
|
377 * to the 64-bit unsigned quotient, and *rp to the 64-bit unsigned remainder. |
|
378 * Minimize effort if one of qp and rp is null. |
|
379 */ |
|
380 #define jlong_UDIVMOD(qp, rp, a, b) jlong_udivmod(qp, rp, a, b) |
|
381 |
|
382 extern JRI_PUBLIC_API(void) |
|
383 jlong_udivmod(julong *qp, julong *rp, julong a, julong b); |
|
384 |
|
385 #define jlong_DIV(r, a, b) { \ |
|
386 jlong _a, _b; \ |
|
387 juint _negative = (int32)(a).hi < 0; \ |
|
388 if (_negative) { \ |
|
389 jlong_NEG(_a, a); \ |
|
390 } else { \ |
|
391 _a = a; \ |
|
392 } \ |
|
393 if ((int32)(b).hi < 0) { \ |
|
394 _negative ^= 1; \ |
|
395 jlong_NEG(_b, b); \ |
|
396 } else { \ |
|
397 _b = b; \ |
|
398 } \ |
|
399 jlong_UDIVMOD(&(r), 0, _a, _b); \ |
|
400 if (_negative) \ |
|
401 jlong_NEG(r, r); \ |
|
402 } |
|
403 |
|
404 #define jlong_MOD(r, a, b) { \ |
|
405 jlong _a, _b; \ |
|
406 juint _negative = (int32)(a).hi < 0; \ |
|
407 if (_negative) { \ |
|
408 jlong_NEG(_a, a); \ |
|
409 } else { \ |
|
410 _a = a; \ |
|
411 } \ |
|
412 if ((int32)(b).hi < 0) { \ |
|
413 jlong_NEG(_b, b); \ |
|
414 } else { \ |
|
415 _b = b; \ |
|
416 } \ |
|
417 jlong_UDIVMOD(0, &(r), _a, _b); \ |
|
418 if (_negative) \ |
|
419 jlong_NEG(r, r); \ |
|
420 } |
|
421 |
|
422 /* |
|
423 * NB: b is a juint, not jlong or julong, for the shift ops. |
|
424 */ |
|
425 #define jlong_SHL(r, a, b) { \ |
|
426 if (b) { \ |
|
427 jlong _a; \ |
|
428 _a = a; \ |
|
429 if ((b) < 32) { \ |
|
430 (r).lo = _a.lo << (b); \ |
|
431 (r).hi = (_a.hi << (b)) | (_a.lo >> (32 - (b))); \ |
|
432 } else { \ |
|
433 (r).lo = 0; \ |
|
434 (r).hi = _a.lo << ((b) & 31); \ |
|
435 } \ |
|
436 } else { \ |
|
437 (r) = (a); \ |
|
438 } \ |
|
439 } |
|
440 |
|
441 /* a is an int32, b is int32, r is jlong */ |
|
442 #define jlong_ISHL(r, a, b) { \ |
|
443 if (b) { \ |
|
444 jlong _a; \ |
|
445 _a.lo = (a); \ |
|
446 _a.hi = 0; \ |
|
447 if ((b) < 32) { \ |
|
448 (r).lo = (a) << (b); \ |
|
449 (r).hi = ((a) >> (32 - (b))); \ |
|
450 } else { \ |
|
451 (r).lo = 0; \ |
|
452 (r).hi = (a) << ((b) & 31); \ |
|
453 } \ |
|
454 } else { \ |
|
455 (r).lo = (a); \ |
|
456 (r).hi = 0; \ |
|
457 } \ |
|
458 } |
|
459 |
|
460 #define jlong_SHR(r, a, b) { \ |
|
461 if (b) { \ |
|
462 jlong _a; \ |
|
463 _a = a; \ |
|
464 if ((b) < 32) { \ |
|
465 (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b)); \ |
|
466 (r).hi = (int32)_a.hi >> (b); \ |
|
467 } else { \ |
|
468 (r).lo = (int32)_a.hi >> ((b) & 31); \ |
|
469 (r).hi = (int32)_a.hi >> 31; \ |
|
470 } \ |
|
471 } else { \ |
|
472 (r) = (a); \ |
|
473 } \ |
|
474 } |
|
475 |
|
476 #define jlong_USHR(r, a, b) { \ |
|
477 if (b) { \ |
|
478 jlong _a; \ |
|
479 _a = a; \ |
|
480 if ((b) < 32) { \ |
|
481 (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b)); \ |
|
482 (r).hi = _a.hi >> (b); \ |
|
483 } else { \ |
|
484 (r).lo = _a.hi >> ((b) & 31); \ |
|
485 (r).hi = 0; \ |
|
486 } \ |
|
487 } else { \ |
|
488 (r) = (a); \ |
|
489 } \ |
|
490 } |
|
491 |
|
492 #define jlong_L2I(i, l) ((i) = (l).lo) |
|
493 #define jlong_L2UI(ui, l) ((ui) = (l).lo) |
|
494 #define jlong_L2F(f, l) { double _d; jlong_L2D(_d, l); (f) = (float) _d; } |
|
495 |
|
496 #define jlong_L2D(d, l) { \ |
|
497 int32 _negative; \ |
|
498 jlong _absval; \ |
|
499 \ |
|
500 _negative = (l).hi >> 31; \ |
|
501 if (_negative) { \ |
|
502 jlong_NEG(_absval, l); \ |
|
503 } else { \ |
|
504 _absval = l; \ |
|
505 } \ |
|
506 (d) = (double)_absval.hi * 4.294967296e9 + _absval.lo; \ |
|
507 if (_negative) \ |
|
508 (d) = -(d); \ |
|
509 } |
|
510 |
|
511 #define jlong_I2L(l, i) ((l).hi = (i) >> 31, (l).lo = (i)) |
|
512 #define jlong_UI2L(l, ui) ((l).hi = 0, (l).lo = (ui)) |
|
513 #define jlong_F2L(l, f) { double _d = (double) f; jlong_D2L(l, _d); } |
|
514 |
|
515 #define jlong_D2L(l, d) { \ |
|
516 int _negative; \ |
|
517 double _absval, _d_hi; \ |
|
518 jlong _lo_d; \ |
|
519 \ |
|
520 _negative = ((d) < 0); \ |
|
521 _absval = _negative ? -(d) : (d); \ |
|
522 \ |
|
523 (l).hi = (juint)(_absval / 4.294967296e9); \ |
|
524 (l).lo = 0; \ |
|
525 jlong_L2D(_d_hi, l); \ |
|
526 _absval -= _d_hi; \ |
|
527 _lo_d.hi = 0; \ |
|
528 if (_absval < 0) { \ |
|
529 _lo_d.lo = (juint) -_absval; \ |
|
530 jlong_SUB(l, l, _lo_d); \ |
|
531 } else { \ |
|
532 _lo_d.lo = (juint) _absval; \ |
|
533 jlong_ADD(l, l, _lo_d); \ |
|
534 } \ |
|
535 \ |
|
536 if (_negative) \ |
|
537 jlong_NEG(l, l); \ |
|
538 } |
|
539 |
|
540 #endif /* !HAVE_LONG_LONG */ |
|
541 |
|
542 /******************************************************************************/ |
|
543 |
|
544 #ifdef HAVE_ALIGNED_LONGLONGS |
|
545 #define JRI_GET_INT64(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \ |
|
546 ((_t).x[1] = ((jint*)(_addr))[1]), \ |
|
547 (_t).l ) |
|
548 #define JRI_SET_INT64(_t, _addr, _v) ( (_t).l = (_v), \ |
|
549 ((jint*)(_addr))[0] = (_t).x[0], \ |
|
550 ((jint*)(_addr))[1] = (_t).x[1] ) |
|
551 #else |
|
552 #define JRI_GET_INT64(_t,_addr) (*(jlong*)(_addr)) |
|
553 #define JRI_SET_INT64(_t, _addr, _v) (*(jlong*)(_addr) = (_v)) |
|
554 #endif |
|
555 |
|
556 /* If double's must be aligned on doubleword boundaries then define this */ |
|
557 #ifdef HAVE_ALIGNED_DOUBLES |
|
558 #define JRI_GET_DOUBLE(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \ |
|
559 ((_t).x[1] = ((jint*)(_addr))[1]), \ |
|
560 (_t).d ) |
|
561 #define JRI_SET_DOUBLE(_t, _addr, _v) ( (_t).d = (_v), \ |
|
562 ((jint*)(_addr))[0] = (_t).x[0], \ |
|
563 ((jint*)(_addr))[1] = (_t).x[1] ) |
|
564 #else |
|
565 #define JRI_GET_DOUBLE(_t,_addr) (*(jdouble*)(_addr)) |
|
566 #define JRI_SET_DOUBLE(_t, _addr, _v) (*(jdouble*)(_addr) = (_v)) |
|
567 #endif |
|
568 |
|
569 /******************************************************************************/ |
|
570 #ifdef __cplusplus |
|
571 } |
|
572 #endif |
|
573 #endif /* JRI_MD_H */ |
|
574 /******************************************************************************/ |
|