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
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/
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
15 * The Original Code is mozilla.org code.
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.
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.
36 * ***** END LICENSE BLOCK ***** */
38 /*******************************************************************************
39 * Java Runtime Interface - Machine Dependent Types
40 ******************************************************************************/
46 #include "prtypes.h" /* Needed for HAS_LONG_LONG ifdefs */
52 /*******************************************************************************
53 * WHAT'S UP WITH THIS FILE?
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
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 ******************************************************************************/
69 /* DLL Entry modifiers... */
74 # define JRI_PUBLIC_API(ResultType) ResultType _Optlink
75 # define JRI_PUBLIC_VAR(VarType) VarType
78 # define JRI_PUBLIC_API(ResultType) ResultType
79 # define JRI_PUBLIC_VAR(VarType) VarType
82 #elif defined(XP_WIN) || defined(_WINDOWS) || defined(WIN32) || defined(_WIN32)
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
94 # define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export __loadds
95 # define JRI_PUBLIC_VAR(VarType) VarType
96 # define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType)
97 # define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType)
98 # define JRI_NATIVE_STUB(ResultType) ResultType __cdecl __loadds
99 # define JRI_CALLBACK __loadds
101 # define JRI_PUBLIC_API(ResultType) ResultType __cdecl __export
102 # define JRI_PUBLIC_VAR(VarType) VarType
103 # define JRI_PUBLIC_VAR_EXP(VarType) JRI_PUBLIC_VAR(VarType)
104 # define JRI_PUBLIC_VAR_IMP(VarType) JRI_PUBLIC_VAR(VarType)
105 # define JRI_NATIVE_STUB(ResultType) ResultType __cdecl __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 ResultType
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 ResultType
116 # define JRI_CALLBACK
118 # define JRI_PUBLIC_API(ResultType) ResultType _cdecl _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 _cdecl _loadds
123 # define JRI_CALLBACK _loadds
126 # error Unsupported PC development environment.
128 # ifndef IS_LITTLE_ENDIAN
129 # define IS_LITTLE_ENDIAN
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 project.
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.
142 # endif /* !GENERATINGCFM */
143 # define JRI_PUBLIC_API(ResultType) __declspec(export) ResultType
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(ResultType)
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).
153 # error Unsupported Mac development environment.
155 # define JRI_CALLBACK
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
167 #ifndef FAR /* for non-Win16 */
171 /******************************************************************************/
173 /* Java Scalar Types */
175 #if 0 /* now in jni.h */
177 typedef short jshort;
178 typedef float jfloat;
179 typedef double jdouble;
183 /* moved from jni.h -- Sun's new jni.h doesn't have this anymore */
185 typedef class _jobject *jref;
187 typedef struct _jobject *jref;
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;
196 typedef unsigned long juint;
200 /*******************************************************************************
201 * jlong : long long (64-bit signed integer type) support.
202 ******************************************************************************/
205 ** Bit masking macros. (n must be <= 31 to be portable)
207 #define JRI_BIT(n) ((juint)1 << (n))
208 #define JRI_BITMASK(n) (JRI_BIT(n) - 1)
210 #ifdef HAVE_LONG_LONG
214 /* long is default 64-bit on OSF1, -std1 does not allow long long */
216 typedef unsigned long julong;
217 #define jlong_MAXINT 0x7fffffffffffffffL
218 #define jlong_MININT 0x8000000000000000L
219 #define jlong_ZERO 0x0L
221 #elif (defined(WIN32) || defined(_WIN32))
223 typedef LONGLONG jlong;
224 typedef DWORDLONG julong;
225 #define jlong_MAXINT 0x7fffffffffffffffi64
226 #define jlong_MININT 0x8000000000000000i64
227 #define jlong_ZERO 0x0i64
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
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))
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))
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))
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))
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))
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))
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))
274 #define jlong_UDIVMOD(qp, rp, a, b) \
275 (*(qp) = ((julong)(a) / (b)), \
276 *(rp) = ((julong)(a) % (b)))
278 #else /* !HAVE_LONG_LONG */
281 #ifdef IS_LITTLE_ENDIAN
287 typedef jlong julong;
289 extern jlong jlong_MAXINT, jlong_MININT, jlong_ZERO;
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)
297 * NB: jlong_CMP and jlong_UCMP work only for strict relationals (<, >).
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)))
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, \
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) { \
320 (r).lo = _a.lo + _b.lo; \
321 (r).hi = _a.hi + _b.hi + ((r).lo < _b.lo); \
324 #define jlong_SUB(r, a, b) { \
327 (r).lo = _a.lo - _b.lo; \
328 (r).hi = _a.hi - _b.hi - (_a.lo < _b.lo); \
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.
336 #define jlong_MUL(r, a, b) { \
339 jlong_MUL32(r, _a.lo, _b.lo); \
340 (r).hi += _a.hi * _b.lo + _a.lo * _b.hi; \
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)
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).
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); \
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); \
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.
371 #define jlong_UDIVMOD(qp, rp, a, b) jlong_udivmod(qp, rp, a, b)
373 extern JRI_PUBLIC_API(void)
374 jlong_udivmod(julong *qp, julong *rp, julong a, julong b);
376 #define jlong_DIV(r, a, b) { \
378 juint _negative = (int32)(a).hi < 0; \
384 if ((int32)(b).hi < 0) { \
390 jlong_UDIVMOD(&(r), 0, _a, _b); \
395 #define jlong_MOD(r, a, b) { \
397 juint _negative = (int32)(a).hi < 0; \
403 if ((int32)(b).hi < 0) { \
408 jlong_UDIVMOD(0, &(r), _a, _b); \
414 * NB: b is a juint, not jlong or julong, for the shift ops.
416 #define jlong_SHL(r, a, b) { \
421 (r).lo = _a.lo << (b); \
422 (r).hi = (_a.hi << (b)) | (_a.lo >> (32 - (b))); \
425 (r).hi = _a.lo << ((b) & 31); \
432 /* a is an int32, b is int32, r is jlong */
433 #define jlong_ISHL(r, a, b) { \
439 (r).lo = (a) << (b); \
440 (r).hi = ((a) >> (32 - (b))); \
443 (r).hi = (a) << ((b) & 31); \
451 #define jlong_SHR(r, a, b) { \
456 (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b)); \
457 (r).hi = (int32)_a.hi >> (b); \
459 (r).lo = (int32)_a.hi >> ((b) & 31); \
460 (r).hi = (int32)_a.hi >> 31; \
467 #define jlong_USHR(r, a, b) { \
472 (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b)); \
473 (r).hi = _a.hi >> (b); \
475 (r).lo = _a.hi >> ((b) & 31); \
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; }
487 #define jlong_L2D(d, l) { \
491 _negative = (l).hi >> 31; \
493 jlong_NEG(_absval, l); \
497 (d) = (double)_absval.hi * 4.294967296e9 + _absval.lo; \
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); }
506 #define jlong_D2L(l, d) { \
508 double _absval, _d_hi; \
511 _negative = ((d) < 0); \
512 _absval = _negative ? -(d) : (d); \
514 (l).hi = (juint)(_absval / 4.294967296e9); \
516 jlong_L2D(_d_hi, l); \
520 _lo_d.lo = (juint) -_absval; \
521 jlong_SUB(l, l, _lo_d); \
523 _lo_d.lo = (juint) _absval; \
524 jlong_ADD(l, l, _lo_d); \
531 #endif /* !HAVE_LONG_LONG */
533 /******************************************************************************/
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]), \
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] )
543 #define JRI_GET_INT64(_t,_addr) (*(jlong*)(_addr))
544 #define JRI_SET_INT64(_t, _addr, _v) (*(jlong*)(_addr) = (_v))
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]), \
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] )
556 #define JRI_GET_DOUBLE(_t,_addr) (*(jdouble*)(_addr))
557 #define JRI_SET_DOUBLE(_t, _addr, _v) (*(jdouble*)(_addr) = (_v))
560 /******************************************************************************/
564 #endif /* JRI_MD_H */
565 /******************************************************************************/