annotate src/share/vm/utilities/globalDefinitions_gcc.hpp @ 1994:6cd6d394f280

7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed()) 7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages. Reviewed-by: johnc, tonyp
author ysr
date Tue, 07 Dec 2010 21:55:53 -0800
parents f95d63e2154a
children 4a9604cd7c5f
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
2 * Copyright (c) 1998, 2010, 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
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
25 #ifndef SHARE_VM_UTILITIES_GLOBALDEFINITIONS_GCC_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
26 #define SHARE_VM_UTILITIES_GLOBALDEFINITIONS_GCC_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
27
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
28 #include "prims/jni.h"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
29
0
a61af66fc99e Initial load
duke
parents:
diff changeset
30 // This file holds compiler-dependent includes,
a61af66fc99e Initial load
duke
parents:
diff changeset
31 // globally used constants & types, class (forward)
a61af66fc99e Initial load
duke
parents:
diff changeset
32 // declarations and a few frequently used utility functions.
a61af66fc99e Initial load
duke
parents:
diff changeset
33
a61af66fc99e Initial load
duke
parents:
diff changeset
34 #include <ctype.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
35 #include <string.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
36 #include <stdarg.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
37 #include <stddef.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
38 #include <stdio.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
39 #include <stdlib.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
40 #include <wchar.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
41
a61af66fc99e Initial load
duke
parents:
diff changeset
42 #ifdef SOLARIS
a61af66fc99e Initial load
duke
parents:
diff changeset
43 #include <ieeefp.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
44 #endif // SOLARIS
a61af66fc99e Initial load
duke
parents:
diff changeset
45
a61af66fc99e Initial load
duke
parents:
diff changeset
46 #include <math.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
47 #ifndef FP_PZERO
a61af66fc99e Initial load
duke
parents:
diff changeset
48 // Linux doesn't have positive/negative zero
a61af66fc99e Initial load
duke
parents:
diff changeset
49 #define FP_PZERO FP_ZERO
a61af66fc99e Initial load
duke
parents:
diff changeset
50 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
51 #if (!defined fpclass) && ((!defined SPARC) || (!defined SOLARIS))
a61af66fc99e Initial load
duke
parents:
diff changeset
52 #define fpclass fpclassify
a61af66fc99e Initial load
duke
parents:
diff changeset
53 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
54
a61af66fc99e Initial load
duke
parents:
diff changeset
55 #include <time.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
56 #include <fcntl.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
57 #include <dlfcn.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
58 #include <pthread.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
59
a61af66fc99e Initial load
duke
parents:
diff changeset
60 #ifdef SOLARIS
a61af66fc99e Initial load
duke
parents:
diff changeset
61 #include <thread.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
62 #endif // SOLARIS
a61af66fc99e Initial load
duke
parents:
diff changeset
63
a61af66fc99e Initial load
duke
parents:
diff changeset
64 #include <limits.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
65 #include <errno.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
66
a61af66fc99e Initial load
duke
parents:
diff changeset
67 #ifdef SOLARIS
a61af66fc99e Initial load
duke
parents:
diff changeset
68 #include <sys/trap.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
69 #include <sys/regset.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
70 #include <sys/procset.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
71 #include <ucontext.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
72 #include <setjmp.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
73 #endif // SOLARIS
a61af66fc99e Initial load
duke
parents:
diff changeset
74
a61af66fc99e Initial load
duke
parents:
diff changeset
75 # ifdef SOLARIS_MUTATOR_LIBTHREAD
a61af66fc99e Initial load
duke
parents:
diff changeset
76 # include <sys/procfs.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
77 # endif
a61af66fc99e Initial load
duke
parents:
diff changeset
78
a61af66fc99e Initial load
duke
parents:
diff changeset
79 #ifdef LINUX
a61af66fc99e Initial load
duke
parents:
diff changeset
80 #include <inttypes.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
81 #include <signal.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
82 #include <ucontext.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
83 #include <sys/time.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
84 #endif // LINUX
a61af66fc99e Initial load
duke
parents:
diff changeset
85
a61af66fc99e Initial load
duke
parents:
diff changeset
86 // 4810578: varargs unsafe on 32-bit integer/64-bit pointer architectures
a61af66fc99e Initial load
duke
parents:
diff changeset
87 // When __cplusplus is defined, NULL is defined as 0 (32-bit constant) in
a61af66fc99e Initial load
duke
parents:
diff changeset
88 // system header files. On 32-bit architectures, there is no problem.
a61af66fc99e Initial load
duke
parents:
diff changeset
89 // On 64-bit architectures, defining NULL as a 32-bit constant can cause
a61af66fc99e Initial load
duke
parents:
diff changeset
90 // problems with varargs functions: C++ integral promotion rules say for
a61af66fc99e Initial load
duke
parents:
diff changeset
91 // varargs, we pass the argument 0 as an int. So, if NULL was passed to a
a61af66fc99e Initial load
duke
parents:
diff changeset
92 // varargs function it will remain 32-bits. Depending on the calling
a61af66fc99e Initial load
duke
parents:
diff changeset
93 // convention of the machine, if the argument is passed on the stack then
a61af66fc99e Initial load
duke
parents:
diff changeset
94 // only 32-bits of the "NULL" pointer may be initialized to zero. The
a61af66fc99e Initial load
duke
parents:
diff changeset
95 // other 32-bits will be garbage. If the varargs function is expecting a
a61af66fc99e Initial load
duke
parents:
diff changeset
96 // pointer when it extracts the argument, then we have a problem.
a61af66fc99e Initial load
duke
parents:
diff changeset
97 //
a61af66fc99e Initial load
duke
parents:
diff changeset
98 // Solution: For 64-bit architectures, redefine NULL as 64-bit constant 0.
a61af66fc99e Initial load
duke
parents:
diff changeset
99 //
a61af66fc99e Initial load
duke
parents:
diff changeset
100 // Note: this fix doesn't work well on Linux because NULL will be overwritten
a61af66fc99e Initial load
duke
parents:
diff changeset
101 // whenever a system header file is included. Linux handles NULL correctly
a61af66fc99e Initial load
duke
parents:
diff changeset
102 // through a special type '__null'.
a61af66fc99e Initial load
duke
parents:
diff changeset
103 #ifdef SOLARIS
a61af66fc99e Initial load
duke
parents:
diff changeset
104 #ifdef _LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
105 #undef NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
106 #define NULL 0L
a61af66fc99e Initial load
duke
parents:
diff changeset
107 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
108 #ifndef NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
109 #define NULL 0
a61af66fc99e Initial load
duke
parents:
diff changeset
110 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
111 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
112 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
113
a61af66fc99e Initial load
duke
parents:
diff changeset
114 // NULL vs NULL_WORD:
a61af66fc99e Initial load
duke
parents:
diff changeset
115 // On Linux NULL is defined as a special type '__null'. Assigning __null to
a61af66fc99e Initial load
duke
parents:
diff changeset
116 // integer variable will cause gcc warning. Use NULL_WORD in places where a
a61af66fc99e Initial load
duke
parents:
diff changeset
117 // pointer is stored as integer value. On some platforms, sizeof(intptr_t) >
a61af66fc99e Initial load
duke
parents:
diff changeset
118 // sizeof(void*), so here we want something which is integer type, but has the
a61af66fc99e Initial load
duke
parents:
diff changeset
119 // same size as a pointer.
a61af66fc99e Initial load
duke
parents:
diff changeset
120 #ifdef LINUX
a61af66fc99e Initial load
duke
parents:
diff changeset
121 #ifdef _LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
122 #define NULL_WORD 0L
a61af66fc99e Initial load
duke
parents:
diff changeset
123 #else
512
db4caa99ef11 6787106: Hotspot 32 bit build fails on platforms having different definitions for intptr_t & int32_t
xlu
parents: 0
diff changeset
124 // 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: 0
diff changeset
125 // on platforms such as Mac OS X.
db4caa99ef11 6787106: Hotspot 32 bit build fails on platforms having different definitions for intptr_t & int32_t
xlu
parents: 0
diff changeset
126 #define NULL_WORD ((intptr_t)0)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
127 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
128 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
129 #define NULL_WORD NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
130 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
131
a61af66fc99e Initial load
duke
parents:
diff changeset
132 #ifndef LINUX
a61af66fc99e Initial load
duke
parents:
diff changeset
133 // Compiler-specific primitive types
a61af66fc99e Initial load
duke
parents:
diff changeset
134 typedef unsigned short uint16_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
135 #ifndef _UINT32_T
a61af66fc99e Initial load
duke
parents:
diff changeset
136 #define _UINT32_T
a61af66fc99e Initial load
duke
parents:
diff changeset
137 typedef unsigned int uint32_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
138 #endif // _UINT32_T
a61af66fc99e Initial load
duke
parents:
diff changeset
139
a61af66fc99e Initial load
duke
parents:
diff changeset
140 #if !defined(_SYS_INT_TYPES_H)
a61af66fc99e Initial load
duke
parents:
diff changeset
141 #ifndef _UINT64_T
a61af66fc99e Initial load
duke
parents:
diff changeset
142 #define _UINT64_T
a61af66fc99e Initial load
duke
parents:
diff changeset
143 typedef unsigned long long uint64_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
144 #endif // _UINT64_T
a61af66fc99e Initial load
duke
parents:
diff changeset
145 // %%%% how to access definition of intptr_t portably in 5.5 onward?
a61af66fc99e Initial load
duke
parents:
diff changeset
146 typedef int intptr_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
147 typedef unsigned int uintptr_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
148 // If this gets an error, figure out a symbol XXX that implies the
a61af66fc99e Initial load
duke
parents:
diff changeset
149 // prior definition of intptr_t, and add "&& !defined(XXX)" above.
a61af66fc99e Initial load
duke
parents:
diff changeset
150 #endif // _SYS_INT_TYPES_H
a61af66fc99e Initial load
duke
parents:
diff changeset
151
a61af66fc99e Initial load
duke
parents:
diff changeset
152 #endif // !LINUX
a61af66fc99e Initial load
duke
parents:
diff changeset
153
a61af66fc99e Initial load
duke
parents:
diff changeset
154 // Additional Java basic types
a61af66fc99e Initial load
duke
parents:
diff changeset
155
a61af66fc99e Initial load
duke
parents:
diff changeset
156 typedef uint8_t jubyte;
a61af66fc99e Initial load
duke
parents:
diff changeset
157 typedef uint16_t jushort;
a61af66fc99e Initial load
duke
parents:
diff changeset
158 typedef uint32_t juint;
a61af66fc99e Initial load
duke
parents:
diff changeset
159 typedef uint64_t julong;
a61af66fc99e Initial load
duke
parents:
diff changeset
160
a61af66fc99e Initial load
duke
parents:
diff changeset
161 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
162 // Special (possibly not-portable) casts
a61af66fc99e Initial load
duke
parents:
diff changeset
163 // Cast floats into same-size integers and vice-versa w/o changing bit-pattern
a61af66fc99e Initial load
duke
parents:
diff changeset
164 // %%%%%% These seem like standard C++ to me--how about factoring them out? - Ungar
a61af66fc99e Initial load
duke
parents:
diff changeset
165
a61af66fc99e Initial load
duke
parents:
diff changeset
166 inline jint jint_cast (jfloat x) { return *(jint* )&x; }
a61af66fc99e Initial load
duke
parents:
diff changeset
167 inline jlong jlong_cast (jdouble x) { return *(jlong* )&x; }
a61af66fc99e Initial load
duke
parents:
diff changeset
168
a61af66fc99e Initial load
duke
parents:
diff changeset
169 inline jfloat jfloat_cast (jint x) { return *(jfloat* )&x; }
a61af66fc99e Initial load
duke
parents:
diff changeset
170 inline jdouble jdouble_cast(jlong x) { return *(jdouble*)&x; }
a61af66fc99e Initial load
duke
parents:
diff changeset
171
a61af66fc99e Initial load
duke
parents:
diff changeset
172 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
173 // Constant for jlong (specifying an long long canstant is C++ compiler specific)
a61af66fc99e Initial load
duke
parents:
diff changeset
174
a61af66fc99e Initial load
duke
parents:
diff changeset
175 // Build a 64bit integer constant
a61af66fc99e Initial load
duke
parents:
diff changeset
176 #define CONST64(x) (x ## LL)
a61af66fc99e Initial load
duke
parents:
diff changeset
177 #define UCONST64(x) (x ## ULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
178
a61af66fc99e Initial load
duke
parents:
diff changeset
179 const jlong min_jlong = CONST64(0x8000000000000000);
a61af66fc99e Initial load
duke
parents:
diff changeset
180 const jlong max_jlong = CONST64(0x7fffffffffffffff);
a61af66fc99e Initial load
duke
parents:
diff changeset
181
a61af66fc99e Initial load
duke
parents:
diff changeset
182
a61af66fc99e Initial load
duke
parents:
diff changeset
183 #ifdef SOLARIS
a61af66fc99e Initial load
duke
parents:
diff changeset
184 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
185 // ANSI C++ fixes
a61af66fc99e Initial load
duke
parents:
diff changeset
186 // NOTE:In the ANSI committee's continuing attempt to make each version
a61af66fc99e Initial load
duke
parents:
diff changeset
187 // of C++ incompatible with the previous version, you can no longer cast
a61af66fc99e Initial load
duke
parents:
diff changeset
188 // pointers to functions without specifying linkage unless you want to get
a61af66fc99e Initial load
duke
parents:
diff changeset
189 // warnings.
a61af66fc99e Initial load
duke
parents:
diff changeset
190 //
a61af66fc99e Initial load
duke
parents:
diff changeset
191 // This also means that pointers to functions can no longer be "hidden"
a61af66fc99e Initial load
duke
parents:
diff changeset
192 // in opaque types like void * because at the invokation point warnings
a61af66fc99e Initial load
duke
parents:
diff changeset
193 // will be generated. While this makes perfect sense from a type safety
a61af66fc99e Initial load
duke
parents:
diff changeset
194 // point of view it causes a lot of warnings on old code using C header
a61af66fc99e Initial load
duke
parents:
diff changeset
195 // files. Here are some typedefs to make the job of silencing warnings
a61af66fc99e Initial load
duke
parents:
diff changeset
196 // a bit easier.
a61af66fc99e Initial load
duke
parents:
diff changeset
197 //
a61af66fc99e Initial load
duke
parents:
diff changeset
198 // The final kick in the teeth is that you can only have extern "C" linkage
a61af66fc99e Initial load
duke
parents:
diff changeset
199 // specified at file scope. So these typedefs are here rather than in the
a61af66fc99e Initial load
duke
parents:
diff changeset
200 // .hpp for the class (os:Solaris usually) that needs them.
a61af66fc99e Initial load
duke
parents:
diff changeset
201
a61af66fc99e Initial load
duke
parents:
diff changeset
202 extern "C" {
a61af66fc99e Initial load
duke
parents:
diff changeset
203 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
204 typedef int (*int_fnP_thread_t_i_gregset_t)(thread_t, int, gregset_t);
a61af66fc99e Initial load
duke
parents:
diff changeset
205 typedef int (*int_fnP_thread_t_i)(thread_t, int);
a61af66fc99e Initial load
duke
parents:
diff changeset
206 typedef int (*int_fnP_thread_t)(thread_t);
a61af66fc99e Initial load
duke
parents:
diff changeset
207
a61af66fc99e Initial load
duke
parents:
diff changeset
208 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
209 typedef int (*int_fnP_cond_tP_mutex_tP)(cond_t *cv, mutex_t *mx);
a61af66fc99e Initial load
duke
parents:
diff changeset
210
a61af66fc99e Initial load
duke
parents:
diff changeset
211 // typedef for missing API in libc
a61af66fc99e Initial load
duke
parents:
diff changeset
212 typedef int (*int_fnP_mutex_tP_i_vP)(mutex_t *, int, void *);
a61af66fc99e Initial load
duke
parents:
diff changeset
213 typedef int (*int_fnP_mutex_tP)(mutex_t *);
a61af66fc99e Initial load
duke
parents:
diff changeset
214 typedef int (*int_fnP_cond_tP_i_vP)(cond_t *cv, int scope, void *arg);
a61af66fc99e Initial load
duke
parents:
diff changeset
215 typedef int (*int_fnP_cond_tP)(cond_t *cv);
a61af66fc99e Initial load
duke
parents:
diff changeset
216 };
a61af66fc99e Initial load
duke
parents:
diff changeset
217 #endif // SOLARIS
a61af66fc99e Initial load
duke
parents:
diff changeset
218
a61af66fc99e Initial load
duke
parents:
diff changeset
219 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
220 // Debugging
a61af66fc99e Initial load
duke
parents:
diff changeset
221
a61af66fc99e Initial load
duke
parents:
diff changeset
222 #define DEBUG_EXCEPTION ::abort();
a61af66fc99e Initial load
duke
parents:
diff changeset
223
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
224 #ifdef ARM
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
225 #ifdef SOLARIS
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
226 #define BREAKPOINT __asm__ volatile (".long 0xe1200070")
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
227 #else
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
228 #define BREAKPOINT __asm__ volatile (".long 0xe7f001f0")
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
229 #endif
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
230 #else
0
a61af66fc99e Initial load
duke
parents:
diff changeset
231 extern "C" void breakpoint();
a61af66fc99e Initial load
duke
parents:
diff changeset
232 #define BREAKPOINT ::breakpoint()
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
233 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
234
a61af66fc99e Initial load
duke
parents:
diff changeset
235 // checking for nanness
a61af66fc99e Initial load
duke
parents:
diff changeset
236 #ifdef SOLARIS
a61af66fc99e Initial load
duke
parents:
diff changeset
237 #ifdef SPARC
a61af66fc99e Initial load
duke
parents:
diff changeset
238 inline int g_isnan(float f) { return isnanf(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
239 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
240 // isnanf() broken on Intel Solaris use isnand()
a61af66fc99e Initial load
duke
parents:
diff changeset
241 inline int g_isnan(float f) { return isnand(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
242 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
243 inline int g_isnan(double f) { return isnand(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
244 #elif LINUX
a61af66fc99e Initial load
duke
parents:
diff changeset
245 inline int g_isnan(float f) { return isnanf(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
246 inline int g_isnan(double f) { return isnan(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
247 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
248 #error "missing platform-specific definition here"
a61af66fc99e Initial load
duke
parents:
diff changeset
249 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
250
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
251 // GCC 4.3 does not allow 0.0/0.0 to produce a NAN value
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
252 #if (__GNUC__ == 4) && (__GNUC_MINOR__ > 2)
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
253 #define CAN_USE_NAN_DEFINE 1
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
254 #endif
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
255
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
256
0
a61af66fc99e Initial load
duke
parents:
diff changeset
257 // Checking for finiteness
a61af66fc99e Initial load
duke
parents:
diff changeset
258
a61af66fc99e Initial load
duke
parents:
diff changeset
259 inline int g_isfinite(jfloat f) { return finite(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
260 inline int g_isfinite(jdouble f) { return finite(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
261
a61af66fc99e Initial load
duke
parents:
diff changeset
262
a61af66fc99e Initial load
duke
parents:
diff changeset
263 // Wide characters
a61af66fc99e Initial load
duke
parents:
diff changeset
264
a61af66fc99e Initial load
duke
parents:
diff changeset
265 inline int wcslen(const jchar* x) { return wcslen((const wchar_t*)x); }
a61af66fc99e Initial load
duke
parents:
diff changeset
266
a61af66fc99e Initial load
duke
parents:
diff changeset
267
a61af66fc99e Initial load
duke
parents:
diff changeset
268 // Portability macros
a61af66fc99e Initial load
duke
parents:
diff changeset
269 #define PRAGMA_INTERFACE #pragma interface
a61af66fc99e Initial load
duke
parents:
diff changeset
270 #define PRAGMA_IMPLEMENTATION #pragma implementation
a61af66fc99e Initial load
duke
parents:
diff changeset
271 #define VALUE_OBJ_CLASS_SPEC
a61af66fc99e Initial load
duke
parents:
diff changeset
272
a61af66fc99e Initial load
duke
parents:
diff changeset
273 #if (__GNUC__ == 2) && (__GNUC_MINOR__ < 95)
a61af66fc99e Initial load
duke
parents:
diff changeset
274 #define TEMPLATE_TABLE_BUG
a61af66fc99e Initial load
duke
parents:
diff changeset
275 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
276 #if (__GNUC__ == 2) && (__GNUC_MINOR__ >= 96)
a61af66fc99e Initial load
duke
parents:
diff changeset
277 #define CONST_SDM_BUG
a61af66fc99e Initial load
duke
parents:
diff changeset
278 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
279
a61af66fc99e Initial load
duke
parents:
diff changeset
280 // Formatting.
a61af66fc99e Initial load
duke
parents:
diff changeset
281 #ifdef _LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
282 #define FORMAT64_MODIFIER "l"
a61af66fc99e Initial load
duke
parents:
diff changeset
283 #else // !_LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
284 #define FORMAT64_MODIFIER "ll"
a61af66fc99e Initial load
duke
parents:
diff changeset
285 #endif // _LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
286
a61af66fc99e Initial load
duke
parents:
diff changeset
287 // HACK: gcc warns about applying offsetof() to non-POD object or calculating
a61af66fc99e Initial load
duke
parents:
diff changeset
288 // offset directly when base address is NULL. Use 16 to get around the
a61af66fc99e Initial load
duke
parents:
diff changeset
289 // warning. gcc-3.4 has an option -Wno-invalid-offsetof to suppress
a61af66fc99e Initial load
duke
parents:
diff changeset
290 // this warning.
a61af66fc99e Initial load
duke
parents:
diff changeset
291 #define offset_of(klass,field) (size_t)((intx)&(((klass*)16)->field) - 16)
a61af66fc99e Initial load
duke
parents:
diff changeset
292
a61af66fc99e Initial load
duke
parents:
diff changeset
293 #ifdef offsetof
a61af66fc99e Initial load
duke
parents:
diff changeset
294 # undef offsetof
a61af66fc99e Initial load
duke
parents:
diff changeset
295 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
296 #define offsetof(klass,field) offset_of(klass,field)
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
297
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
298 #endif // SHARE_VM_UTILITIES_GLOBALDEFINITIONS_GCC_HPP