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