annotate src/share/vm/utilities/globalDefinitions_sparcWorks.hpp @ 1941:79d04223b8a5

Added caching for resolved types and resolved fields. This is crucial, because the local load elimination will lead to wrong results, if field equality (of two RiField objects with the same object and the same RiType) is not given. The caching makes sure that the default equals implementation is sufficient.
author Thomas Wuerthinger <wuerthinger@ssw.jku.at>
date Tue, 28 Dec 2010 18:33:26 +0100
parents c18cbe5936b8
children f95d63e2154a
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 579
diff changeset
2 * Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 579
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 579
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 579
diff changeset
21 * questions.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
a61af66fc99e Initial load
duke
parents:
diff changeset
25 // This file holds compiler-dependent includes,
a61af66fc99e Initial load
duke
parents:
diff changeset
26 // globally used constants & types, class (forward)
a61af66fc99e Initial load
duke
parents:
diff changeset
27 // declarations and a few frequently used utility functions.
a61af66fc99e Initial load
duke
parents:
diff changeset
28
a61af66fc99e Initial load
duke
parents:
diff changeset
29
a61af66fc99e Initial load
duke
parents:
diff changeset
30 # include <ctype.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
31 # include <dirent.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
32 # include <string.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
33 # include <strings.h> // for bsd'isms
a61af66fc99e Initial load
duke
parents:
diff changeset
34 # include <stdarg.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
35 # include <stddef.h> // for offsetof
a61af66fc99e Initial load
duke
parents:
diff changeset
36 # include <stdio.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
37 # include <stdlib.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
38 # include <wchar.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
39 # include <stdarg.h>
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
40 #ifdef SOLARIS
0
a61af66fc99e Initial load
duke
parents:
diff changeset
41 # include <ieeefp.h>
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
42 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
43 # include <math.h>
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
44 #ifdef LINUX
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
45 #ifndef FP_PZERO
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
46 // Linux doesn't have positive/negative zero
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
47 #define FP_PZERO FP_ZERO
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
48 #endif
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
49 #ifndef fpclass
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
50 #define fpclass fpclassify
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
51 #endif
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
52 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
53 # include <time.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
54 # include <fcntl.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
55 # include <dlfcn.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
56 # include <pthread.h>
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
57 #ifdef SOLARIS
0
a61af66fc99e Initial load
duke
parents:
diff changeset
58 # include <thread.h>
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
59 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
60 # include <limits.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
61 # include <errno.h>
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
62 #ifdef SOLARIS
0
a61af66fc99e Initial load
duke
parents:
diff changeset
63 # include <sys/trap.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
64 # include <sys/regset.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
65 # include <sys/procset.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
66 # include <ucontext.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
67 # include <setjmp.h>
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
68 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
69 # ifdef SOLARIS_MUTATOR_LIBTHREAD
a61af66fc99e Initial load
duke
parents:
diff changeset
70 # include <sys/procfs.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
71 # endif
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
72 #ifdef LINUX
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
73 # include <inttypes.h>
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
74 # include <signal.h>
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
75 # include <ucontext.h>
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
76 # include <sys/time.h>
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
77 #endif
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
78
0
a61af66fc99e Initial load
duke
parents:
diff changeset
79
a61af66fc99e Initial load
duke
parents:
diff changeset
80 // 4810578: varargs unsafe on 32-bit integer/64-bit pointer architectures
a61af66fc99e Initial load
duke
parents:
diff changeset
81 // When __cplusplus is defined, NULL is defined as 0 (32-bit constant) in
a61af66fc99e Initial load
duke
parents:
diff changeset
82 // system header files. On 32-bit architectures, there is no problem.
a61af66fc99e Initial load
duke
parents:
diff changeset
83 // On 64-bit architectures, defining NULL as a 32-bit constant can cause
a61af66fc99e Initial load
duke
parents:
diff changeset
84 // problems with varargs functions: C++ integral promotion rules say for
a61af66fc99e Initial load
duke
parents:
diff changeset
85 // varargs, we pass the argument 0 as an int. So, if NULL was passed to a
a61af66fc99e Initial load
duke
parents:
diff changeset
86 // varargs function it will remain 32-bits. Depending on the calling
a61af66fc99e Initial load
duke
parents:
diff changeset
87 // convention of the machine, if the argument is passed on the stack then
a61af66fc99e Initial load
duke
parents:
diff changeset
88 // only 32-bits of the "NULL" pointer may be initialized to zero. The
a61af66fc99e Initial load
duke
parents:
diff changeset
89 // other 32-bits will be garbage. If the varargs function is expecting a
a61af66fc99e Initial load
duke
parents:
diff changeset
90 // pointer when it extracts the argument, then we have a problem.
a61af66fc99e Initial load
duke
parents:
diff changeset
91 //
a61af66fc99e Initial load
duke
parents:
diff changeset
92 // Solution: For 64-bit architectures, redefine NULL as 64-bit constant 0.
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
93 //
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
94 // Note: this fix doesn't work well on Linux because NULL will be overwritten
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
95 // whenever a system header file is included. Linux handles NULL correctly
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
96 // through a special type '__null'.
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
97 #ifdef SOLARIS
0
a61af66fc99e Initial load
duke
parents:
diff changeset
98 #ifdef _LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
99 #undef NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
100 #define NULL 0L
a61af66fc99e Initial load
duke
parents:
diff changeset
101 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
102 #ifndef NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
103 #define NULL 0
a61af66fc99e Initial load
duke
parents:
diff changeset
104 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
105 #endif
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
106 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
107
a61af66fc99e Initial load
duke
parents:
diff changeset
108 // NULL vs NULL_WORD:
a61af66fc99e Initial load
duke
parents:
diff changeset
109 // On Linux NULL is defined as a special type '__null'. Assigning __null to
a61af66fc99e Initial load
duke
parents:
diff changeset
110 // integer variable will cause gcc warning. Use NULL_WORD in places where a
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
111 // pointer is stored as integer value. On some platforms, sizeof(intptr_t) >
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
112 // sizeof(void*), so here we want something which is integer type, but has the
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
113 // same size as a pointer.
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
114 #ifdef LINUX
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
115 #ifdef _LP64
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
116 #define NULL_WORD 0L
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
117 #else
512
db4caa99ef11 6787106: Hotspot 32 bit build fails on platforms having different definitions for intptr_t & int32_t
xlu
parents: 196
diff changeset
118 // Cast 0 to intptr_t rather than int32_t since they are not the same type
db4caa99ef11 6787106: Hotspot 32 bit build fails on platforms having different definitions for intptr_t & int32_t
xlu
parents: 196
diff changeset
119 // on some platforms.
db4caa99ef11 6787106: Hotspot 32 bit build fails on platforms having different definitions for intptr_t & int32_t
xlu
parents: 196
diff changeset
120 #define NULL_WORD ((intptr_t)0)
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
121 #endif
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
122 #else
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
123 #define NULL_WORD NULL
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
124 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
125
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
126 #ifndef LINUX
0
a61af66fc99e Initial load
duke
parents:
diff changeset
127 // Compiler-specific primitive types
a61af66fc99e Initial load
duke
parents:
diff changeset
128 typedef unsigned short uint16_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
129 #ifndef _UINT32_T
a61af66fc99e Initial load
duke
parents:
diff changeset
130 #define _UINT32_T
a61af66fc99e Initial load
duke
parents:
diff changeset
131 typedef unsigned int uint32_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
132 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
133 #if !defined(_SYS_INT_TYPES_H)
a61af66fc99e Initial load
duke
parents:
diff changeset
134 #ifndef _UINT64_T
a61af66fc99e Initial load
duke
parents:
diff changeset
135 #define _UINT64_T
a61af66fc99e Initial load
duke
parents:
diff changeset
136 typedef unsigned long long uint64_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
137 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
138 // %%%% how to access definition of intptr_t portably in 5.5 onward?
a61af66fc99e Initial load
duke
parents:
diff changeset
139 typedef int intptr_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
140 typedef unsigned int uintptr_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
141 // If this gets an error, figure out a symbol XXX that implies the
a61af66fc99e Initial load
duke
parents:
diff changeset
142 // prior definition of intptr_t, and add "&& !defined(XXX)" above.
a61af66fc99e Initial load
duke
parents:
diff changeset
143 #endif
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
144 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
145
a61af66fc99e Initial load
duke
parents:
diff changeset
146 // Additional Java basic types
a61af66fc99e Initial load
duke
parents:
diff changeset
147
a61af66fc99e Initial load
duke
parents:
diff changeset
148 typedef unsigned char jubyte;
a61af66fc99e Initial load
duke
parents:
diff changeset
149 typedef unsigned short jushort;
a61af66fc99e Initial load
duke
parents:
diff changeset
150 typedef unsigned int juint;
a61af66fc99e Initial load
duke
parents:
diff changeset
151 typedef unsigned long long julong;
a61af66fc99e Initial load
duke
parents:
diff changeset
152
a61af66fc99e Initial load
duke
parents:
diff changeset
153 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
154 // Special (possibly not-portable) casts
a61af66fc99e Initial load
duke
parents:
diff changeset
155 // Cast floats into same-size integers and vice-versa w/o changing bit-pattern
a61af66fc99e Initial load
duke
parents:
diff changeset
156
a61af66fc99e Initial load
duke
parents:
diff changeset
157 inline jint jint_cast (jfloat x) { return *(jint* )&x; }
a61af66fc99e Initial load
duke
parents:
diff changeset
158 inline jlong jlong_cast (jdouble x) { return *(jlong* )&x; }
a61af66fc99e Initial load
duke
parents:
diff changeset
159
a61af66fc99e Initial load
duke
parents:
diff changeset
160 inline jfloat jfloat_cast (jint x) { return *(jfloat* )&x; }
a61af66fc99e Initial load
duke
parents:
diff changeset
161 inline jdouble jdouble_cast(jlong x) { return *(jdouble*)&x; }
a61af66fc99e Initial load
duke
parents:
diff changeset
162
a61af66fc99e Initial load
duke
parents:
diff changeset
163 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
164 // Constant for jlong (specifying an long long constant is C++ compiler specific)
a61af66fc99e Initial load
duke
parents:
diff changeset
165
a61af66fc99e Initial load
duke
parents:
diff changeset
166 // Build a 64bit integer constant
a61af66fc99e Initial load
duke
parents:
diff changeset
167 #define CONST64(x) (x ## LL)
a61af66fc99e Initial load
duke
parents:
diff changeset
168 #define UCONST64(x) (x ## ULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
169
a61af66fc99e Initial load
duke
parents:
diff changeset
170 const jlong min_jlong = CONST64(0x8000000000000000);
a61af66fc99e Initial load
duke
parents:
diff changeset
171 const jlong max_jlong = CONST64(0x7fffffffffffffff);
a61af66fc99e Initial load
duke
parents:
diff changeset
172
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
173 #ifdef SOLARIS
0
a61af66fc99e Initial load
duke
parents:
diff changeset
174 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
175 // ANSI C++ fixes
a61af66fc99e Initial load
duke
parents:
diff changeset
176 // NOTE:In the ANSI committee's continuing attempt to make each version
a61af66fc99e Initial load
duke
parents:
diff changeset
177 // of C++ incompatible with the previous version, you can no longer cast
a61af66fc99e Initial load
duke
parents:
diff changeset
178 // pointers to functions without specifying linkage unless you want to get
a61af66fc99e Initial load
duke
parents:
diff changeset
179 // warnings.
a61af66fc99e Initial load
duke
parents:
diff changeset
180 //
a61af66fc99e Initial load
duke
parents:
diff changeset
181 // This also means that pointers to functions can no longer be "hidden"
a61af66fc99e Initial load
duke
parents:
diff changeset
182 // in opaque types like void * because at the invokation point warnings
a61af66fc99e Initial load
duke
parents:
diff changeset
183 // will be generated. While this makes perfect sense from a type safety
a61af66fc99e Initial load
duke
parents:
diff changeset
184 // point of view it causes a lot of warnings on old code using C header
a61af66fc99e Initial load
duke
parents:
diff changeset
185 // files. Here are some typedefs to make the job of silencing warnings
a61af66fc99e Initial load
duke
parents:
diff changeset
186 // a bit easier.
a61af66fc99e Initial load
duke
parents:
diff changeset
187 //
a61af66fc99e Initial load
duke
parents:
diff changeset
188 // The final kick in the teeth is that you can only have extern "C" linkage
a61af66fc99e Initial load
duke
parents:
diff changeset
189 // specified at file scope. So these typedefs are here rather than in the
a61af66fc99e Initial load
duke
parents:
diff changeset
190 // .hpp for the class (os:Solaris usually) that needs them.
a61af66fc99e Initial load
duke
parents:
diff changeset
191
a61af66fc99e Initial load
duke
parents:
diff changeset
192 extern "C" {
a61af66fc99e Initial load
duke
parents:
diff changeset
193 typedef int (*int_fnP_thread_t_iP_uP_stack_tP_gregset_t)(thread_t, int*, unsigned *, stack_t*, gregset_t);
a61af66fc99e Initial load
duke
parents:
diff changeset
194 typedef int (*int_fnP_thread_t_i_gregset_t)(thread_t, int, gregset_t);
a61af66fc99e Initial load
duke
parents:
diff changeset
195 typedef int (*int_fnP_thread_t_i)(thread_t, int);
a61af66fc99e Initial load
duke
parents:
diff changeset
196 typedef int (*int_fnP_thread_t)(thread_t);
a61af66fc99e Initial load
duke
parents:
diff changeset
197
a61af66fc99e Initial load
duke
parents:
diff changeset
198 typedef int (*int_fnP_cond_tP_mutex_tP_timestruc_tP)(cond_t *cv, mutex_t *mx, timestruc_t *abst);
a61af66fc99e Initial load
duke
parents:
diff changeset
199 typedef int (*int_fnP_cond_tP_mutex_tP)(cond_t *cv, mutex_t *mx);
a61af66fc99e Initial load
duke
parents:
diff changeset
200
a61af66fc99e Initial load
duke
parents:
diff changeset
201 // typedef for missing API in libc
a61af66fc99e Initial load
duke
parents:
diff changeset
202 typedef int (*int_fnP_mutex_tP_i_vP)(mutex_t *, int, void *);
a61af66fc99e Initial load
duke
parents:
diff changeset
203 typedef int (*int_fnP_mutex_tP)(mutex_t *);
a61af66fc99e Initial load
duke
parents:
diff changeset
204 typedef int (*int_fnP_cond_tP_i_vP)(cond_t *cv, int scope, void *arg);
a61af66fc99e Initial load
duke
parents:
diff changeset
205 typedef int (*int_fnP_cond_tP)(cond_t *cv);
a61af66fc99e Initial load
duke
parents:
diff changeset
206 };
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
207 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
208
a61af66fc99e Initial load
duke
parents:
diff changeset
209 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
210 // Debugging
a61af66fc99e Initial load
duke
parents:
diff changeset
211
a61af66fc99e Initial load
duke
parents:
diff changeset
212 #define DEBUG_EXCEPTION ::abort();
a61af66fc99e Initial load
duke
parents:
diff changeset
213
a61af66fc99e Initial load
duke
parents:
diff changeset
214 extern "C" void breakpoint();
a61af66fc99e Initial load
duke
parents:
diff changeset
215 #define BREAKPOINT ::breakpoint()
a61af66fc99e Initial load
duke
parents:
diff changeset
216
a61af66fc99e Initial load
duke
parents:
diff changeset
217 // checking for nanness
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
218 #ifdef SOLARIS
0
a61af66fc99e Initial load
duke
parents:
diff changeset
219 #ifdef SPARC
a61af66fc99e Initial load
duke
parents:
diff changeset
220 inline int g_isnan(float f) { return isnanf(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
221 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
222 // isnanf() broken on Intel Solaris use isnand()
a61af66fc99e Initial load
duke
parents:
diff changeset
223 inline int g_isnan(float f) { return isnand(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
224 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
225
a61af66fc99e Initial load
duke
parents:
diff changeset
226 inline int g_isnan(double f) { return isnand(f); }
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
227 #elif LINUX
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
228 inline int g_isnan(float f) { return isnanf(f); }
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
229 inline int g_isnan(double f) { return isnan(f); }
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
230 #else
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
231 #error "missing platform-specific definition here"
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
232 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
233
a61af66fc99e Initial load
duke
parents:
diff changeset
234 // Checking for finiteness
a61af66fc99e Initial load
duke
parents:
diff changeset
235
a61af66fc99e Initial load
duke
parents:
diff changeset
236 inline int g_isfinite(jfloat f) { return finite(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
237 inline int g_isfinite(jdouble f) { return finite(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
238
a61af66fc99e Initial load
duke
parents:
diff changeset
239
a61af66fc99e Initial load
duke
parents:
diff changeset
240 // Wide characters
a61af66fc99e Initial load
duke
parents:
diff changeset
241
a61af66fc99e Initial load
duke
parents:
diff changeset
242 inline int wcslen(const jchar* x) { return wcslen((const wchar_t*)x); }
a61af66fc99e Initial load
duke
parents:
diff changeset
243
a61af66fc99e Initial load
duke
parents:
diff changeset
244
a61af66fc99e Initial load
duke
parents:
diff changeset
245 // Misc
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
246 // NOTE: This one leads to an infinite recursion on Linux
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
247 #ifndef LINUX
0
a61af66fc99e Initial load
duke
parents:
diff changeset
248 int local_vsnprintf(char* buf, size_t count, const char* fmt, va_list argptr);
a61af66fc99e Initial load
duke
parents:
diff changeset
249 #define vsnprintf local_vsnprintf
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
250 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
251
a61af66fc99e Initial load
duke
parents:
diff changeset
252 // Portability macros
a61af66fc99e Initial load
duke
parents:
diff changeset
253 #define PRAGMA_INTERFACE
a61af66fc99e Initial load
duke
parents:
diff changeset
254 #define PRAGMA_IMPLEMENTATION
a61af66fc99e Initial load
duke
parents:
diff changeset
255 #define PRAGMA_IMPLEMENTATION_(arg)
a61af66fc99e Initial load
duke
parents:
diff changeset
256 #define VALUE_OBJ_CLASS_SPEC : public _ValueObj
a61af66fc99e Initial load
duke
parents:
diff changeset
257
a61af66fc99e Initial load
duke
parents:
diff changeset
258 // Formatting.
a61af66fc99e Initial load
duke
parents:
diff changeset
259 #ifdef _LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
260 #define FORMAT64_MODIFIER "l"
a61af66fc99e Initial load
duke
parents:
diff changeset
261 #else // !_LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
262 #define FORMAT64_MODIFIER "ll"
a61af66fc99e Initial load
duke
parents:
diff changeset
263 #endif // _LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
264
a61af66fc99e Initial load
duke
parents:
diff changeset
265 #define offset_of(klass,field) offsetof(klass,field)