annotate src/share/vm/utilities/globalDefinitions_sparcWorks.hpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso
author tschatzl
date Fri, 10 Oct 2014 15:51:58 +0200
parents b6a8cc1e0d92
children 17caeb034a63
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
2426
1d1603768966 7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents: 2307
diff changeset
2 * Copyright (c) 1997, 2011, 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: 1552
diff changeset
25 #ifndef SHARE_VM_UTILITIES_GLOBALDEFINITIONS_SPARCWORKS_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
26 #define SHARE_VM_UTILITIES_GLOBALDEFINITIONS_SPARCWORKS_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
27
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
28 #include "prims/jni.h"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
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
a61af66fc99e Initial load
duke
parents:
diff changeset
35 # include <ctype.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
36 # include <dirent.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
37 # include <string.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
38 # include <strings.h> // for bsd'isms
a61af66fc99e Initial load
duke
parents:
diff changeset
39 # include <stdarg.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
40 # include <stddef.h> // for offsetof
a61af66fc99e Initial load
duke
parents:
diff changeset
41 # include <stdio.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
42 # include <stdlib.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
43 # include <wchar.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
44 # include <stdarg.h>
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
45 #ifdef SOLARIS
0
a61af66fc99e Initial load
duke
parents:
diff changeset
46 # include <ieeefp.h>
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
47 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
48 # include <math.h>
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
49 #ifdef LINUX
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
50 #ifndef FP_PZERO
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
51 // 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
52 #define FP_PZERO FP_ZERO
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
53 #endif
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
54 #ifndef fpclass
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
55 #define fpclass fpclassify
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
56 #endif
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
57 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
58 # include <time.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
59 # include <fcntl.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
60 # include <dlfcn.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
61 # include <pthread.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 <thread.h>
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
64 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
65 # include <limits.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
66 # include <errno.h>
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
67 #ifdef SOLARIS
0
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>
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
73 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
74 # ifdef SOLARIS_MUTATOR_LIBTHREAD
a61af66fc99e Initial load
duke
parents:
diff changeset
75 # include <sys/procfs.h>
a61af66fc99e Initial load
duke
parents:
diff changeset
76 # endif
3960
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
77
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
78 #include <inttypes.h>
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
79
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
80 // Solaris 8 doesn't provide definitions of these
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
81 #ifdef SOLARIS
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
82 #ifndef PRIdPTR
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
83 #if defined(_LP64)
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
84 #define PRIdPTR "ld"
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
85 #define PRIuPTR "lu"
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
86 #define PRIxPTR "lx"
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
87 #else
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
88 #define PRIdPTR "d"
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
89 #define PRIuPTR "u"
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
90 #define PRIxPTR "x"
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
91 #endif
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
92 #endif
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
93 #endif
f08d439fab8c 7089790: integrate bsd-port changes
never
parents: 2426
diff changeset
94
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
95 #ifdef LINUX
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
96 # include <signal.h>
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
97 # include <ucontext.h>
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
98 # include <sys/time.h>
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
99 #endif
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
100
0
a61af66fc99e Initial load
duke
parents:
diff changeset
101
a61af66fc99e Initial load
duke
parents:
diff changeset
102 // 4810578: varargs unsafe on 32-bit integer/64-bit pointer architectures
a61af66fc99e Initial load
duke
parents:
diff changeset
103 // When __cplusplus is defined, NULL is defined as 0 (32-bit constant) in
a61af66fc99e Initial load
duke
parents:
diff changeset
104 // system header files. On 32-bit architectures, there is no problem.
a61af66fc99e Initial load
duke
parents:
diff changeset
105 // On 64-bit architectures, defining NULL as a 32-bit constant can cause
a61af66fc99e Initial load
duke
parents:
diff changeset
106 // problems with varargs functions: C++ integral promotion rules say for
a61af66fc99e Initial load
duke
parents:
diff changeset
107 // varargs, we pass the argument 0 as an int. So, if NULL was passed to a
a61af66fc99e Initial load
duke
parents:
diff changeset
108 // varargs function it will remain 32-bits. Depending on the calling
a61af66fc99e Initial load
duke
parents:
diff changeset
109 // convention of the machine, if the argument is passed on the stack then
a61af66fc99e Initial load
duke
parents:
diff changeset
110 // only 32-bits of the "NULL" pointer may be initialized to zero. The
a61af66fc99e Initial load
duke
parents:
diff changeset
111 // other 32-bits will be garbage. If the varargs function is expecting a
a61af66fc99e Initial load
duke
parents:
diff changeset
112 // pointer when it extracts the argument, then we have a problem.
a61af66fc99e Initial load
duke
parents:
diff changeset
113 //
a61af66fc99e Initial load
duke
parents:
diff changeset
114 // 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
115 //
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
116 // 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
117 // 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
118 // through a special type '__null'.
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
119 #ifdef SOLARIS
0
a61af66fc99e Initial load
duke
parents:
diff changeset
120 #ifdef _LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
121 #undef NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
122 #define NULL 0L
a61af66fc99e Initial load
duke
parents:
diff changeset
123 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
124 #ifndef NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
125 #define NULL 0
a61af66fc99e Initial load
duke
parents:
diff changeset
126 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
127 #endif
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
128 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
129
a61af66fc99e Initial load
duke
parents:
diff changeset
130 // NULL vs NULL_WORD:
a61af66fc99e Initial load
duke
parents:
diff changeset
131 // On Linux NULL is defined as a special type '__null'. Assigning __null to
a61af66fc99e Initial load
duke
parents:
diff changeset
132 // 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
133 // 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
134 // 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
135 // same size as a pointer.
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
136 #ifdef LINUX
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
137 #ifdef _LP64
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
138 #define NULL_WORD 0L
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
139 #else
512
db4caa99ef11 6787106: Hotspot 32 bit build fails on platforms having different definitions for intptr_t & int32_t
xlu
parents: 196
diff changeset
140 // 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
141 // 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
142 #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
143 #endif
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
144 #else
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
145 #define NULL_WORD NULL
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
146 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
147
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
148 #ifndef LINUX
0
a61af66fc99e Initial load
duke
parents:
diff changeset
149 // Compiler-specific primitive types
a61af66fc99e Initial load
duke
parents:
diff changeset
150 typedef unsigned short uint16_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
151 #ifndef _UINT32_T
a61af66fc99e Initial load
duke
parents:
diff changeset
152 #define _UINT32_T
a61af66fc99e Initial load
duke
parents:
diff changeset
153 typedef unsigned int uint32_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
154 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
155 #if !defined(_SYS_INT_TYPES_H)
a61af66fc99e Initial load
duke
parents:
diff changeset
156 #ifndef _UINT64_T
a61af66fc99e Initial load
duke
parents:
diff changeset
157 #define _UINT64_T
a61af66fc99e Initial load
duke
parents:
diff changeset
158 typedef unsigned long long uint64_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
159 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
160 // %%%% how to access definition of intptr_t portably in 5.5 onward?
a61af66fc99e Initial load
duke
parents:
diff changeset
161 typedef int intptr_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
162 typedef unsigned int uintptr_t;
a61af66fc99e Initial load
duke
parents:
diff changeset
163 // If this gets an error, figure out a symbol XXX that implies the
a61af66fc99e Initial load
duke
parents:
diff changeset
164 // prior definition of intptr_t, and add "&& !defined(XXX)" above.
a61af66fc99e Initial load
duke
parents:
diff changeset
165 #endif
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
166 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
167
2307
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents: 1972
diff changeset
168 // On solaris 8, UINTPTR_MAX is defined as empty.
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents: 1972
diff changeset
169 // Everywhere else it's an actual value.
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents: 1972
diff changeset
170 #if UINTPTR_MAX - 1 == -1
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents: 1972
diff changeset
171 #undef UINTPTR_MAX
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents: 1972
diff changeset
172 #ifdef _LP64
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents: 1972
diff changeset
173 #define UINTPTR_MAX UINT64_MAX
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents: 1972
diff changeset
174 #else
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents: 1972
diff changeset
175 #define UINTPTR_MAX UINT32_MAX
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents: 1972
diff changeset
176 #endif /* ifdef _LP64 */
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents: 1972
diff changeset
177 #endif
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents: 1972
diff changeset
178
0
a61af66fc99e Initial load
duke
parents:
diff changeset
179 // Additional Java basic types
a61af66fc99e Initial load
duke
parents:
diff changeset
180
a61af66fc99e Initial load
duke
parents:
diff changeset
181 typedef unsigned char jubyte;
a61af66fc99e Initial load
duke
parents:
diff changeset
182 typedef unsigned short jushort;
a61af66fc99e Initial load
duke
parents:
diff changeset
183 typedef unsigned int juint;
a61af66fc99e Initial load
duke
parents:
diff changeset
184 typedef unsigned long long julong;
a61af66fc99e Initial load
duke
parents:
diff changeset
185
a61af66fc99e Initial load
duke
parents:
diff changeset
186
a61af66fc99e Initial load
duke
parents:
diff changeset
187 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
188 // Constant for jlong (specifying an long long constant is C++ compiler specific)
a61af66fc99e Initial load
duke
parents:
diff changeset
189
a61af66fc99e Initial load
duke
parents:
diff changeset
190 // Build a 64bit integer constant
a61af66fc99e Initial load
duke
parents:
diff changeset
191 #define CONST64(x) (x ## LL)
a61af66fc99e Initial load
duke
parents:
diff changeset
192 #define UCONST64(x) (x ## ULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
193
a61af66fc99e Initial load
duke
parents:
diff changeset
194 const jlong min_jlong = CONST64(0x8000000000000000);
a61af66fc99e Initial load
duke
parents:
diff changeset
195 const jlong max_jlong = CONST64(0x7fffffffffffffff);
a61af66fc99e Initial load
duke
parents:
diff changeset
196
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
197 #ifdef SOLARIS
0
a61af66fc99e Initial load
duke
parents:
diff changeset
198 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
199 // ANSI C++ fixes
a61af66fc99e Initial load
duke
parents:
diff changeset
200 // NOTE:In the ANSI committee's continuing attempt to make each version
a61af66fc99e Initial load
duke
parents:
diff changeset
201 // of C++ incompatible with the previous version, you can no longer cast
a61af66fc99e Initial load
duke
parents:
diff changeset
202 // pointers to functions without specifying linkage unless you want to get
a61af66fc99e Initial load
duke
parents:
diff changeset
203 // warnings.
a61af66fc99e Initial load
duke
parents:
diff changeset
204 //
a61af66fc99e Initial load
duke
parents:
diff changeset
205 // This also means that pointers to functions can no longer be "hidden"
a61af66fc99e Initial load
duke
parents:
diff changeset
206 // in opaque types like void * because at the invokation point warnings
a61af66fc99e Initial load
duke
parents:
diff changeset
207 // will be generated. While this makes perfect sense from a type safety
a61af66fc99e Initial load
duke
parents:
diff changeset
208 // point of view it causes a lot of warnings on old code using C header
a61af66fc99e Initial load
duke
parents:
diff changeset
209 // files. Here are some typedefs to make the job of silencing warnings
a61af66fc99e Initial load
duke
parents:
diff changeset
210 // a bit easier.
a61af66fc99e Initial load
duke
parents:
diff changeset
211 //
a61af66fc99e Initial load
duke
parents:
diff changeset
212 // The final kick in the teeth is that you can only have extern "C" linkage
a61af66fc99e Initial load
duke
parents:
diff changeset
213 // specified at file scope. So these typedefs are here rather than in the
a61af66fc99e Initial load
duke
parents:
diff changeset
214 // .hpp for the class (os:Solaris usually) that needs them.
a61af66fc99e Initial load
duke
parents:
diff changeset
215
a61af66fc99e Initial load
duke
parents:
diff changeset
216 extern "C" {
a61af66fc99e Initial load
duke
parents:
diff changeset
217 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
218 typedef int (*int_fnP_thread_t_i_gregset_t)(thread_t, int, gregset_t);
a61af66fc99e Initial load
duke
parents:
diff changeset
219 typedef int (*int_fnP_thread_t_i)(thread_t, int);
a61af66fc99e Initial load
duke
parents:
diff changeset
220 typedef int (*int_fnP_thread_t)(thread_t);
a61af66fc99e Initial load
duke
parents:
diff changeset
221
a61af66fc99e Initial load
duke
parents:
diff changeset
222 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
223 typedef int (*int_fnP_cond_tP_mutex_tP)(cond_t *cv, mutex_t *mx);
a61af66fc99e Initial load
duke
parents:
diff changeset
224
a61af66fc99e Initial load
duke
parents:
diff changeset
225 // typedef for missing API in libc
a61af66fc99e Initial load
duke
parents:
diff changeset
226 typedef int (*int_fnP_mutex_tP_i_vP)(mutex_t *, int, void *);
a61af66fc99e Initial load
duke
parents:
diff changeset
227 typedef int (*int_fnP_mutex_tP)(mutex_t *);
a61af66fc99e Initial load
duke
parents:
diff changeset
228 typedef int (*int_fnP_cond_tP_i_vP)(cond_t *cv, int scope, void *arg);
a61af66fc99e Initial load
duke
parents:
diff changeset
229 typedef int (*int_fnP_cond_tP)(cond_t *cv);
a61af66fc99e Initial load
duke
parents:
diff changeset
230 };
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
231 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
232
a61af66fc99e Initial load
duke
parents:
diff changeset
233 //----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
234 // Debugging
a61af66fc99e Initial load
duke
parents:
diff changeset
235
a61af66fc99e Initial load
duke
parents:
diff changeset
236 #define DEBUG_EXCEPTION ::abort();
a61af66fc99e Initial load
duke
parents:
diff changeset
237
a61af66fc99e Initial load
duke
parents:
diff changeset
238 extern "C" void breakpoint();
a61af66fc99e Initial load
duke
parents:
diff changeset
239 #define BREAKPOINT ::breakpoint()
a61af66fc99e Initial load
duke
parents:
diff changeset
240
a61af66fc99e Initial load
duke
parents:
diff changeset
241 // checking for nanness
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
242 #ifdef SOLARIS
0
a61af66fc99e Initial load
duke
parents:
diff changeset
243 #ifdef SPARC
a61af66fc99e Initial load
duke
parents:
diff changeset
244 inline int g_isnan(float f) { return isnanf(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
245 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
246 // isnanf() broken on Intel Solaris use isnand()
a61af66fc99e Initial load
duke
parents:
diff changeset
247 inline int g_isnan(float f) { return isnand(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
248 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
249
a61af66fc99e Initial load
duke
parents:
diff changeset
250 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
251 #elif LINUX
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
252 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
253 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
254 #else
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
255 #error "missing platform-specific definition here"
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
256 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
257
a61af66fc99e Initial load
duke
parents:
diff changeset
258 // Checking for finiteness
a61af66fc99e Initial load
duke
parents:
diff changeset
259
a61af66fc99e Initial load
duke
parents:
diff changeset
260 inline int g_isfinite(jfloat f) { return finite(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
261 inline int g_isfinite(jdouble f) { return finite(f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
262
a61af66fc99e Initial load
duke
parents:
diff changeset
263
a61af66fc99e Initial load
duke
parents:
diff changeset
264 // Wide characters
a61af66fc99e Initial load
duke
parents:
diff changeset
265
a61af66fc99e Initial load
duke
parents:
diff changeset
266 inline int wcslen(const jchar* x) { return wcslen((const wchar_t*)x); }
a61af66fc99e Initial load
duke
parents:
diff changeset
267
a61af66fc99e Initial load
duke
parents:
diff changeset
268
a61af66fc99e Initial load
duke
parents:
diff changeset
269 // Misc
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
270 // 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
271 #ifndef LINUX
0
a61af66fc99e Initial load
duke
parents:
diff changeset
272 int local_vsnprintf(char* buf, size_t count, const char* fmt, va_list argptr);
a61af66fc99e Initial load
duke
parents:
diff changeset
273 #define vsnprintf local_vsnprintf
50
485d403e94e1 6452081: 3/4 Allow for Linux builds with Sun Studio Linux compilers
dcubed
parents: 0
diff changeset
274 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
275
a61af66fc99e Initial load
duke
parents:
diff changeset
276 // Portability macros
a61af66fc99e Initial load
duke
parents:
diff changeset
277 #define PRAGMA_INTERFACE
a61af66fc99e Initial load
duke
parents:
diff changeset
278 #define PRAGMA_IMPLEMENTATION
a61af66fc99e Initial load
duke
parents:
diff changeset
279 #define PRAGMA_IMPLEMENTATION_(arg)
a61af66fc99e Initial load
duke
parents:
diff changeset
280 #define VALUE_OBJ_CLASS_SPEC : public _ValueObj
a61af66fc99e Initial load
duke
parents:
diff changeset
281
a61af66fc99e Initial load
duke
parents:
diff changeset
282 // Formatting.
a61af66fc99e Initial load
duke
parents:
diff changeset
283 #ifdef _LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
284 #define FORMAT64_MODIFIER "l"
a61af66fc99e Initial load
duke
parents:
diff changeset
285 #else // !_LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
286 #define FORMAT64_MODIFIER "ll"
a61af66fc99e Initial load
duke
parents:
diff changeset
287 #endif // _LP64
a61af66fc99e Initial load
duke
parents:
diff changeset
288
a61af66fc99e Initial load
duke
parents:
diff changeset
289 #define offset_of(klass,field) offsetof(klass,field)
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
290
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
291 #endif // SHARE_VM_UTILITIES_GLOBALDEFINITIONS_SPARCWORKS_HPP