Mercurial > hg > truffle
annotate src/share/vm/utilities/globalDefinitions.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 | 7848fc12602b |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1311
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1311
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:
1311
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_UTILITIES_GLOBALDEFINITIONS_HPP |
| 26 #define SHARE_VM_UTILITIES_GLOBALDEFINITIONS_HPP | |
| 27 | |
| 4006 | 28 #ifndef __STDC_FORMAT_MACROS |
| 3960 | 29 #define __STDC_FORMAT_MACROS |
| 4006 | 30 #endif |
| 3960 | 31 |
| 1972 | 32 #ifdef TARGET_COMPILER_gcc |
| 33 # include "utilities/globalDefinitions_gcc.hpp" | |
| 34 #endif | |
| 35 #ifdef TARGET_COMPILER_visCPP | |
| 36 # include "utilities/globalDefinitions_visCPP.hpp" | |
| 37 #endif | |
| 38 #ifdef TARGET_COMPILER_sparcWorks | |
| 39 # include "utilities/globalDefinitions_sparcWorks.hpp" | |
| 40 #endif | |
| 14411 | 41 #ifdef TARGET_COMPILER_xlc |
| 42 # include "utilities/globalDefinitions_xlc.hpp" | |
| 43 #endif | |
| 1972 | 44 |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
45 #ifndef PRAGMA_DIAG_PUSH |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
46 #define PRAGMA_DIAG_PUSH |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
47 #endif |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
48 #ifndef PRAGMA_DIAG_POP |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
49 #define PRAGMA_DIAG_POP |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
50 #endif |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
51 #ifndef PRAGMA_FORMAT_NONLITERAL_IGNORED |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
52 #define PRAGMA_FORMAT_NONLITERAL_IGNORED |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
53 #endif |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
54 #ifndef PRAGMA_FORMAT_IGNORED |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
55 #define PRAGMA_FORMAT_IGNORED |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
56 #endif |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
57 #ifndef PRAGMA_FORMAT_NONLITERAL_IGNORED_INTERNAL |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
58 #define PRAGMA_FORMAT_NONLITERAL_IGNORED_INTERNAL |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
59 #endif |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
60 #ifndef PRAGMA_FORMAT_NONLITERAL_IGNORED_EXTERNAL |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
61 #define PRAGMA_FORMAT_NONLITERAL_IGNORED_EXTERNAL |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
62 #endif |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
63 #ifndef PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
64 #define PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
65 #endif |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
66 #ifndef ATTRIBUTE_PRINTF |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
67 #define ATTRIBUTE_PRINTF(fmt, vargs) |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
68 #endif |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
69 |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
70 |
| 1972 | 71 #include "utilities/macros.hpp" |
| 72 | |
| 0 | 73 // This file holds all globally used constants & types, class (forward) |
| 74 // declarations and a few frequently used utility functions. | |
| 75 | |
| 76 //---------------------------------------------------------------------------------------------------- | |
| 77 // Constants | |
| 78 | |
| 79 const int LogBytesPerShort = 1; | |
| 80 const int LogBytesPerInt = 2; | |
| 81 #ifdef _LP64 | |
| 82 const int LogBytesPerWord = 3; | |
| 83 #else | |
| 84 const int LogBytesPerWord = 2; | |
| 85 #endif | |
| 86 const int LogBytesPerLong = 3; | |
| 87 | |
| 88 const int BytesPerShort = 1 << LogBytesPerShort; | |
| 89 const int BytesPerInt = 1 << LogBytesPerInt; | |
| 90 const int BytesPerWord = 1 << LogBytesPerWord; | |
| 91 const int BytesPerLong = 1 << LogBytesPerLong; | |
| 92 | |
| 93 const int LogBitsPerByte = 3; | |
| 94 const int LogBitsPerShort = LogBitsPerByte + LogBytesPerShort; | |
| 95 const int LogBitsPerInt = LogBitsPerByte + LogBytesPerInt; | |
| 96 const int LogBitsPerWord = LogBitsPerByte + LogBytesPerWord; | |
| 97 const int LogBitsPerLong = LogBitsPerByte + LogBytesPerLong; | |
| 98 | |
| 99 const int BitsPerByte = 1 << LogBitsPerByte; | |
| 100 const int BitsPerShort = 1 << LogBitsPerShort; | |
| 101 const int BitsPerInt = 1 << LogBitsPerInt; | |
| 102 const int BitsPerWord = 1 << LogBitsPerWord; | |
| 103 const int BitsPerLong = 1 << LogBitsPerLong; | |
| 104 | |
| 105 const int WordAlignmentMask = (1 << LogBytesPerWord) - 1; | |
| 106 const int LongAlignmentMask = (1 << LogBytesPerLong) - 1; | |
| 107 | |
| 108 const int WordsPerLong = 2; // Number of stack entries for longs | |
| 109 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
110 const int oopSize = sizeof(char*); // Full-width oop |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
111 extern int heapOopSize; // Oop within a java object |
| 0 | 112 const int wordSize = sizeof(char*); |
| 113 const int longSize = sizeof(jlong); | |
| 114 const int jintSize = sizeof(jint); | |
| 115 const int size_tSize = sizeof(size_t); | |
| 116 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
117 const int BytesPerOop = BytesPerWord; // Full-width oop |
| 0 | 118 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
119 extern int LogBytesPerHeapOop; // Oop within a java object |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
120 extern int LogBitsPerHeapOop; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
121 extern int BytesPerHeapOop; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
122 extern int BitsPerHeapOop; |
| 0 | 123 |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
124 // Oop encoding heap max |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
125 extern uint64_t OopEncodingHeapMax; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
126 |
| 0 | 127 const int BitsPerJavaInteger = 32; |
|
559
7628781568e1
6795362: 32bit server compiler leads to wrong results on solaris-x86
twisti
parents:
361
diff
changeset
|
128 const int BitsPerJavaLong = 64; |
| 0 | 129 const int BitsPerSize_t = size_tSize * BitsPerByte; |
| 130 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
131 // Size of a char[] needed to represent a jint as a string in decimal. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
132 const int jintAsStringSize = 12; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
133 |
| 0 | 134 // In fact this should be |
| 135 // log2_intptr(sizeof(class JavaThread)) - log2_intptr(64); | |
| 136 // see os::set_memory_serialize_page() | |
| 137 #ifdef _LP64 | |
| 138 const int SerializePageShiftCount = 4; | |
| 139 #else | |
| 140 const int SerializePageShiftCount = 3; | |
| 141 #endif | |
| 142 | |
| 143 // An opaque struct of heap-word width, so that HeapWord* can be a generic | |
| 144 // pointer into the heap. We require that object sizes be measured in | |
| 145 // units of heap words, so that that | |
| 146 // HeapWord* hw; | |
| 147 // hw += oop(hw)->foo(); | |
| 148 // works, where foo is a method (like size or scavenge) that returns the | |
| 149 // object size. | |
| 150 class HeapWord { | |
| 151 friend class VMStructs; | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
145
diff
changeset
|
152 private: |
| 0 | 153 char* i; |
|
361
a4f9ef0c0375
6743059: Error in spaceDecorator.cpp "optimized" build.
jmasa
parents:
269
diff
changeset
|
154 #ifndef PRODUCT |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
145
diff
changeset
|
155 public: |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
145
diff
changeset
|
156 char* value() { return i; } |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
145
diff
changeset
|
157 #endif |
| 0 | 158 }; |
| 159 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
160 // Analogous opaque struct for metadata allocated from |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
161 // metaspaces. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
162 class MetaWord { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
163 friend class VMStructs; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
164 private: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
165 char* i; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
166 }; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
167 |
| 0 | 168 // HeapWordSize must be 2^LogHeapWordSize. |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
169 const int HeapWordSize = sizeof(HeapWord); |
| 0 | 170 #ifdef _LP64 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
171 const int LogHeapWordSize = 3; |
| 0 | 172 #else |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
173 const int LogHeapWordSize = 2; |
| 0 | 174 #endif |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
175 const int HeapWordsPerLong = BytesPerLong / HeapWordSize; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
176 const int LogHeapWordsPerLong = LogBytesPerLong - LogHeapWordSize; |
| 0 | 177 |
| 178 // The larger HeapWordSize for 64bit requires larger heaps | |
| 179 // for the same application running in 64bit. See bug 4967770. | |
| 180 // The minimum alignment to a heap word size is done. Other | |
| 181 // parts of the memory system may required additional alignment | |
| 182 // and are responsible for those alignments. | |
| 183 #ifdef _LP64 | |
| 184 #define ScaleForWordSize(x) align_size_down_((x) * 13 / 10, HeapWordSize) | |
| 185 #else | |
| 186 #define ScaleForWordSize(x) (x) | |
| 187 #endif | |
| 188 | |
| 189 // The minimum number of native machine words necessary to contain "byte_size" | |
| 190 // bytes. | |
| 191 inline size_t heap_word_size(size_t byte_size) { | |
| 192 return (byte_size + (HeapWordSize-1)) >> LogHeapWordSize; | |
| 193 } | |
| 194 | |
| 195 | |
| 196 const size_t K = 1024; | |
| 197 const size_t M = K*K; | |
| 198 const size_t G = M*K; | |
| 199 const size_t HWperKB = K / sizeof(HeapWord); | |
| 200 | |
| 201 const jint min_jint = (jint)1 << (sizeof(jint)*BitsPerByte-1); // 0x80000000 == smallest jint | |
| 202 const jint max_jint = (juint)min_jint - 1; // 0x7FFFFFFF == largest jint | |
| 203 | |
| 204 // Constants for converting from a base unit to milli-base units. For | |
| 205 // example from seconds to milliseconds and microseconds | |
| 206 | |
| 207 const int MILLIUNITS = 1000; // milli units per base unit | |
| 208 const int MICROUNITS = 1000000; // micro units per base unit | |
| 209 const int NANOUNITS = 1000000000; // nano units per base unit | |
| 210 | |
|
4712
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4006
diff
changeset
|
211 const jlong NANOSECS_PER_SEC = CONST64(1000000000); |
|
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4006
diff
changeset
|
212 const jint NANOSECS_PER_MILLISEC = 1000000; |
|
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4006
diff
changeset
|
213 |
| 0 | 214 inline const char* proper_unit_for_byte_size(size_t s) { |
|
6063
cdfa5139bd58
7169056: Add gigabyte unit to proper_unit_for_byte_size() and byte_size_in_proper_unit()
brutisso
parents:
6059
diff
changeset
|
215 #ifdef _LP64 |
|
cdfa5139bd58
7169056: Add gigabyte unit to proper_unit_for_byte_size() and byte_size_in_proper_unit()
brutisso
parents:
6059
diff
changeset
|
216 if (s >= 10*G) { |
|
cdfa5139bd58
7169056: Add gigabyte unit to proper_unit_for_byte_size() and byte_size_in_proper_unit()
brutisso
parents:
6059
diff
changeset
|
217 return "G"; |
|
cdfa5139bd58
7169056: Add gigabyte unit to proper_unit_for_byte_size() and byte_size_in_proper_unit()
brutisso
parents:
6059
diff
changeset
|
218 } |
|
cdfa5139bd58
7169056: Add gigabyte unit to proper_unit_for_byte_size() and byte_size_in_proper_unit()
brutisso
parents:
6059
diff
changeset
|
219 #endif |
| 0 | 220 if (s >= 10*M) { |
| 221 return "M"; | |
| 222 } else if (s >= 10*K) { | |
| 223 return "K"; | |
| 224 } else { | |
| 225 return "B"; | |
| 226 } | |
| 227 } | |
| 228 | |
| 6059 | 229 template <class T> |
| 230 inline T byte_size_in_proper_unit(T s) { | |
|
6063
cdfa5139bd58
7169056: Add gigabyte unit to proper_unit_for_byte_size() and byte_size_in_proper_unit()
brutisso
parents:
6059
diff
changeset
|
231 #ifdef _LP64 |
|
cdfa5139bd58
7169056: Add gigabyte unit to proper_unit_for_byte_size() and byte_size_in_proper_unit()
brutisso
parents:
6059
diff
changeset
|
232 if (s >= 10*G) { |
|
cdfa5139bd58
7169056: Add gigabyte unit to proper_unit_for_byte_size() and byte_size_in_proper_unit()
brutisso
parents:
6059
diff
changeset
|
233 return (T)(s/G); |
|
cdfa5139bd58
7169056: Add gigabyte unit to proper_unit_for_byte_size() and byte_size_in_proper_unit()
brutisso
parents:
6059
diff
changeset
|
234 } |
|
cdfa5139bd58
7169056: Add gigabyte unit to proper_unit_for_byte_size() and byte_size_in_proper_unit()
brutisso
parents:
6059
diff
changeset
|
235 #endif |
| 0 | 236 if (s >= 10*M) { |
| 6059 | 237 return (T)(s/M); |
| 0 | 238 } else if (s >= 10*K) { |
| 6059 | 239 return (T)(s/K); |
| 0 | 240 } else { |
| 241 return s; | |
| 242 } | |
| 243 } | |
| 244 | |
| 245 //---------------------------------------------------------------------------------------------------- | |
| 246 // VM type definitions | |
| 247 | |
| 248 // intx and uintx are the 'extended' int and 'extended' unsigned int types; | |
| 249 // they are 32bit wide on a 32-bit platform, and 64bit wide on a 64bit platform. | |
| 250 | |
| 251 typedef intptr_t intx; | |
| 252 typedef uintptr_t uintx; | |
| 253 | |
| 254 const intx min_intx = (intx)1 << (sizeof(intx)*BitsPerByte-1); | |
| 255 const intx max_intx = (uintx)min_intx - 1; | |
| 256 const uintx max_uintx = (uintx)-1; | |
| 257 | |
| 258 // Table of values: | |
| 259 // sizeof intx 4 8 | |
| 260 // min_intx 0x80000000 0x8000000000000000 | |
| 261 // max_intx 0x7FFFFFFF 0x7FFFFFFFFFFFFFFF | |
| 262 // max_uintx 0xFFFFFFFF 0xFFFFFFFFFFFFFFFF | |
| 263 | |
| 264 typedef unsigned int uint; NEEDS_CLEANUP | |
| 265 | |
| 266 | |
| 267 //---------------------------------------------------------------------------------------------------- | |
| 268 // Java type definitions | |
| 269 | |
| 270 // All kinds of 'plain' byte addresses | |
| 271 typedef signed char s_char; | |
| 272 typedef unsigned char u_char; | |
| 273 typedef u_char* address; | |
| 274 typedef uintptr_t address_word; // unsigned integer which will hold a pointer | |
| 275 // except for some implementations of a C++ | |
| 276 // linkage pointer to function. Should never | |
| 277 // need one of those to be placed in this | |
| 278 // type anyway. | |
| 279 | |
| 280 // Utility functions to "portably" (?) bit twiddle pointers | |
| 281 // Where portable means keep ANSI C++ compilers quiet | |
| 282 | |
| 283 inline address set_address_bits(address x, int m) { return address(intptr_t(x) | m); } | |
| 284 inline address clear_address_bits(address x, int m) { return address(intptr_t(x) & ~m); } | |
| 285 | |
| 286 // Utility functions to "portably" make cast to/from function pointers. | |
| 287 | |
| 288 inline address_word mask_address_bits(address x, int m) { return address_word(x) & m; } | |
| 289 inline address_word castable_address(address x) { return address_word(x) ; } | |
| 290 inline address_word castable_address(void* x) { return address_word(x) ; } | |
| 291 | |
| 292 // Pointer subtraction. | |
| 293 // The idea here is to avoid ptrdiff_t, which is signed and so doesn't have | |
| 294 // the range we might need to find differences from one end of the heap | |
| 295 // to the other. | |
| 296 // A typical use might be: | |
| 297 // if (pointer_delta(end(), top()) >= size) { | |
| 298 // // enough room for an object of size | |
| 299 // ... | |
| 300 // and then additions like | |
| 301 // ... top() + size ... | |
| 302 // are safe because we know that top() is at least size below end(). | |
| 303 inline size_t pointer_delta(const void* left, | |
| 304 const void* right, | |
| 305 size_t element_size) { | |
| 306 return (((uintptr_t) left) - ((uintptr_t) right)) / element_size; | |
| 307 } | |
| 308 // A version specialized for HeapWord*'s. | |
| 309 inline size_t pointer_delta(const HeapWord* left, const HeapWord* right) { | |
| 310 return pointer_delta(left, right, sizeof(HeapWord)); | |
| 311 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
312 // A version specialized for MetaWord*'s. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
313 inline size_t pointer_delta(const MetaWord* left, const MetaWord* right) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
314 return pointer_delta(left, right, sizeof(MetaWord)); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
315 } |
| 0 | 316 |
| 317 // | |
| 318 // ANSI C++ does not allow casting from one pointer type to a function pointer | |
| 319 // directly without at best a warning. This macro accomplishes it silently | |
| 320 // In every case that is present at this point the value be cast is a pointer | |
| 321 // to a C linkage function. In somecase the type used for the cast reflects | |
| 322 // that linkage and a picky compiler would not complain. In other cases because | |
| 323 // there is no convenient place to place a typedef with extern C linkage (i.e | |
| 324 // a platform dependent header file) it doesn't. At this point no compiler seems | |
| 325 // picky enough to catch these instances (which are few). It is possible that | |
| 326 // using templates could fix these for all cases. This use of templates is likely | |
| 327 // so far from the middle of the road that it is likely to be problematic in | |
| 328 // many C++ compilers. | |
| 329 // | |
| 330 #define CAST_TO_FN_PTR(func_type, value) ((func_type)(castable_address(value))) | |
| 331 #define CAST_FROM_FN_PTR(new_type, func_ptr) ((new_type)((address_word)(func_ptr))) | |
| 332 | |
| 333 // Unsigned byte types for os and stream.hpp | |
| 334 | |
| 335 // Unsigned one, two, four and eigth byte quantities used for describing | |
| 336 // the .class file format. See JVM book chapter 4. | |
| 337 | |
| 338 typedef jubyte u1; | |
| 339 typedef jushort u2; | |
| 340 typedef juint u4; | |
| 341 typedef julong u8; | |
| 342 | |
| 343 const jubyte max_jubyte = (jubyte)-1; // 0xFF largest jubyte | |
| 344 const jushort max_jushort = (jushort)-1; // 0xFFFF largest jushort | |
| 345 const juint max_juint = (juint)-1; // 0xFFFFFFFF largest juint | |
| 346 const julong max_julong = (julong)-1; // 0xFF....FF largest julong | |
| 347 | |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4712
diff
changeset
|
348 typedef jbyte s1; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4712
diff
changeset
|
349 typedef jshort s2; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4712
diff
changeset
|
350 typedef jint s4; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4712
diff
changeset
|
351 typedef jlong s8; |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
4712
diff
changeset
|
352 |
| 0 | 353 //---------------------------------------------------------------------------------------------------- |
| 354 // JVM spec restrictions | |
| 355 | |
| 356 const int max_method_code_size = 64*K - 1; // JVM spec, 2nd ed. section 4.8.1 (p.134) | |
| 357 | |
| 12837 | 358 // Default ProtectionDomainCacheSize values |
| 359 | |
| 360 const int defaultProtectionDomainCacheSize = NOT_LP64(137) LP64_ONLY(2017); | |
| 0 | 361 |
| 362 //---------------------------------------------------------------------------------------------------- | |
|
10126
63e31ce40bdb
8009928: PSR:PERF Increase default string table size
hseigel
parents:
9085
diff
changeset
|
363 // Default and minimum StringTableSize values |
|
6982
e4f764ddb06a
7122219: Passed StringTableSize value not verified
hseigel
parents:
6848
diff
changeset
|
364 |
|
10126
63e31ce40bdb
8009928: PSR:PERF Increase default string table size
hseigel
parents:
9085
diff
changeset
|
365 const int defaultStringTableSize = NOT_LP64(1009) LP64_ONLY(60013); |
| 12837 | 366 const int minimumStringTableSize = 1009; |
|
6982
e4f764ddb06a
7122219: Passed StringTableSize value not verified
hseigel
parents:
6848
diff
changeset
|
367 |
|
12825
c90e76575b03
8019375: Internal symbol table size should be tunable.
kevinw
parents:
12316
diff
changeset
|
368 const int defaultSymbolTableSize = 20011; |
|
c90e76575b03
8019375: Internal symbol table size should be tunable.
kevinw
parents:
12316
diff
changeset
|
369 const int minimumSymbolTableSize = 1009; |
|
c90e76575b03
8019375: Internal symbol table size should be tunable.
kevinw
parents:
12316
diff
changeset
|
370 |
|
6982
e4f764ddb06a
7122219: Passed StringTableSize value not verified
hseigel
parents:
6848
diff
changeset
|
371 |
|
e4f764ddb06a
7122219: Passed StringTableSize value not verified
hseigel
parents:
6848
diff
changeset
|
372 //---------------------------------------------------------------------------------------------------- |
| 0 | 373 // HotSwap - for JVMTI aka Class File Replacement and PopFrame |
| 374 // | |
| 375 // Determines whether on-the-fly class replacement and frame popping are enabled. | |
| 376 | |
| 377 #define HOTSWAP | |
| 378 | |
| 379 //---------------------------------------------------------------------------------------------------- | |
| 380 // Object alignment, in units of HeapWords. | |
| 381 // | |
| 382 // Minimum is max(BytesPerLong, BytesPerDouble, BytesPerOop) / HeapWordSize, so jlong, jdouble and | |
| 383 // reference fields can be naturally aligned. | |
| 384 | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
385 extern int MinObjAlignment; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
386 extern int MinObjAlignmentInBytes; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
387 extern int MinObjAlignmentInBytesMask; |
| 0 | 388 |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
389 extern int LogMinObjAlignment; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
390 extern int LogMinObjAlignmentInBytes; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
391 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
392 const int LogKlassAlignmentInBytes = 3; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
393 const int LogKlassAlignment = LogKlassAlignmentInBytes - LogHeapWordSize; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
394 const int KlassAlignmentInBytes = 1 << LogKlassAlignmentInBytes; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
395 const int KlassAlignment = KlassAlignmentInBytes / HeapWordSize; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
396 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
397 // Klass encoding metaspace max size |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
398 const uint64_t KlassEncodingMetaspaceMax = (uint64_t(max_juint) + 1) << LogKlassAlignmentInBytes; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
399 |
| 0 | 400 // Machine dependent stuff |
| 401 | |
| 17780 | 402 #if defined(X86) && defined(COMPILER2) && !defined(JAVASE_EMBEDDED) |
| 403 // Include Restricted Transactional Memory lock eliding optimization | |
| 404 #define INCLUDE_RTM_OPT 1 | |
| 405 #define RTM_OPT_ONLY(code) code | |
| 406 #else | |
| 407 #define INCLUDE_RTM_OPT 0 | |
| 408 #define RTM_OPT_ONLY(code) | |
| 409 #endif | |
| 410 // States of Restricted Transactional Memory usage. | |
| 411 enum RTMState { | |
| 412 NoRTM = 0x2, // Don't use RTM | |
| 413 UseRTM = 0x1, // Use RTM | |
| 414 ProfileRTM = 0x0 // Use RTM with abort ratio calculation | |
| 415 }; | |
| 416 | |
| 1972 | 417 #ifdef TARGET_ARCH_x86 |
| 418 # include "globalDefinitions_x86.hpp" | |
| 419 #endif | |
| 420 #ifdef TARGET_ARCH_sparc | |
| 421 # include "globalDefinitions_sparc.hpp" | |
| 422 #endif | |
| 423 #ifdef TARGET_ARCH_zero | |
| 424 # include "globalDefinitions_zero.hpp" | |
| 425 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2152
diff
changeset
|
426 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2152
diff
changeset
|
427 # include "globalDefinitions_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2152
diff
changeset
|
428 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2152
diff
changeset
|
429 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2152
diff
changeset
|
430 # include "globalDefinitions_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2152
diff
changeset
|
431 #endif |
| 1972 | 432 |
|
10355
fb14e9ed1594
8011064: Some tests have failed with SIGSEGV on arm-hflt on build b82
jprovino
parents:
10126
diff
changeset
|
433 /* |
| 11129 | 434 * If a platform does not support native stack walking |
|
10355
fb14e9ed1594
8011064: Some tests have failed with SIGSEGV on arm-hflt on build b82
jprovino
parents:
10126
diff
changeset
|
435 * the platform specific globalDefinitions (above) |
| 11129 | 436 * can set PLATFORM_NATIVE_STACK_WALKING_SUPPORTED to 0 |
|
10355
fb14e9ed1594
8011064: Some tests have failed with SIGSEGV on arm-hflt on build b82
jprovino
parents:
10126
diff
changeset
|
437 */ |
| 11129 | 438 #ifndef PLATFORM_NATIVE_STACK_WALKING_SUPPORTED |
| 439 #define PLATFORM_NATIVE_STACK_WALKING_SUPPORTED 1 | |
|
10355
fb14e9ed1594
8011064: Some tests have failed with SIGSEGV on arm-hflt on build b82
jprovino
parents:
10126
diff
changeset
|
440 #endif |
| 0 | 441 |
|
17794
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
14435
diff
changeset
|
442 // To assure the IRIW property on processors that are not multiple copy |
|
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
14435
diff
changeset
|
443 // atomic, sync instructions must be issued between volatile reads to |
|
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
14435
diff
changeset
|
444 // assure their ordering, instead of after volatile stores. |
|
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
14435
diff
changeset
|
445 // (See "A Tutorial Introduction to the ARM and POWER Relaxed Memory Models" |
|
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
14435
diff
changeset
|
446 // by Luc Maranget, Susmit Sarkar and Peter Sewell, INRIA/Cambridge) |
|
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
14435
diff
changeset
|
447 #ifdef CPU_NOT_MULTIPLE_COPY_ATOMIC |
|
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
14435
diff
changeset
|
448 const bool support_IRIW_for_not_multiple_copy_atomic_cpu = true; |
|
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
14435
diff
changeset
|
449 #else |
|
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
14435
diff
changeset
|
450 const bool support_IRIW_for_not_multiple_copy_atomic_cpu = false; |
|
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
14435
diff
changeset
|
451 #endif |
|
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
14435
diff
changeset
|
452 |
| 0 | 453 // The byte alignment to be used by Arena::Amalloc. See bugid 4169348. |
| 454 // Note: this value must be a power of 2 | |
| 455 | |
| 456 #define ARENA_AMALLOC_ALIGNMENT (2*BytesPerWord) | |
| 457 | |
| 458 // Signed variants of alignment helpers. There are two versions of each, a macro | |
| 459 // for use in places like enum definitions that require compile-time constant | |
| 460 // expressions and a function for all other places so as to get type checking. | |
| 461 | |
| 462 #define align_size_up_(size, alignment) (((size) + ((alignment) - 1)) & ~((alignment) - 1)) | |
| 463 | |
|
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
464 inline bool is_size_aligned(size_t size, size_t alignment) { |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
465 return align_size_up_(size, alignment) == size; |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
466 } |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
467 |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
468 inline bool is_ptr_aligned(void* ptr, size_t alignment) { |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
469 return align_size_up_((intptr_t)ptr, (intptr_t)alignment) == (intptr_t)ptr; |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
470 } |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
471 |
| 0 | 472 inline intptr_t align_size_up(intptr_t size, intptr_t alignment) { |
| 473 return align_size_up_(size, alignment); | |
| 474 } | |
| 475 | |
| 476 #define align_size_down_(size, alignment) ((size) & ~((alignment) - 1)) | |
| 477 | |
| 478 inline intptr_t align_size_down(intptr_t size, intptr_t alignment) { | |
| 479 return align_size_down_(size, alignment); | |
| 480 } | |
| 481 | |
|
12029
9766f73e770d
8022880: False sharing between PSPromotionManager instances
stefank
parents:
11130
diff
changeset
|
482 #define is_size_aligned_(size, alignment) ((size) == (align_size_up_(size, alignment))) |
|
9766f73e770d
8022880: False sharing between PSPromotionManager instances
stefank
parents:
11130
diff
changeset
|
483 |
|
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
484 inline void* align_ptr_up(void* ptr, size_t alignment) { |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
485 return (void*)align_size_up((intptr_t)ptr, (intptr_t)alignment); |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
486 } |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
487 |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
488 inline void* align_ptr_down(void* ptr, size_t alignment) { |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
489 return (void*)align_size_down((intptr_t)ptr, (intptr_t)alignment); |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
490 } |
|
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12061
diff
changeset
|
491 |
| 0 | 492 // Align objects by rounding up their size, in HeapWord units. |
| 493 | |
| 494 #define align_object_size_(size) align_size_up_(size, MinObjAlignment) | |
| 495 | |
| 496 inline intptr_t align_object_size(intptr_t size) { | |
| 497 return align_size_up(size, MinObjAlignment); | |
| 498 } | |
| 499 | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
500 inline bool is_object_aligned(intptr_t addr) { |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
501 return addr == align_object_size(addr); |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
502 } |
| 0 | 503 |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
504 // Pad out certain offsets to jlong alignment, in HeapWord units. |
| 0 | 505 |
| 506 inline intptr_t align_object_offset(intptr_t offset) { | |
| 507 return align_size_up(offset, HeapWordsPerLong); | |
| 508 } | |
| 509 | |
|
12029
9766f73e770d
8022880: False sharing between PSPromotionManager instances
stefank
parents:
11130
diff
changeset
|
510 inline void* align_pointer_up(const void* addr, size_t size) { |
|
9766f73e770d
8022880: False sharing between PSPromotionManager instances
stefank
parents:
11130
diff
changeset
|
511 return (void*) align_size_up_((uintptr_t)addr, size); |
|
9766f73e770d
8022880: False sharing between PSPromotionManager instances
stefank
parents:
11130
diff
changeset
|
512 } |
|
9766f73e770d
8022880: False sharing between PSPromotionManager instances
stefank
parents:
11130
diff
changeset
|
513 |
|
13058
3aee6bc29547
8026852: Use restricted_align_down in collector policy code
jwilhelm
parents:
12840
diff
changeset
|
514 // Align down with a lower bound. If the aligning results in 0, return 'alignment'. |
|
3aee6bc29547
8026852: Use restricted_align_down in collector policy code
jwilhelm
parents:
12840
diff
changeset
|
515 |
|
3aee6bc29547
8026852: Use restricted_align_down in collector policy code
jwilhelm
parents:
12840
diff
changeset
|
516 inline size_t align_size_down_bounded(size_t size, size_t alignment) { |
|
3aee6bc29547
8026852: Use restricted_align_down in collector policy code
jwilhelm
parents:
12840
diff
changeset
|
517 size_t aligned_size = align_size_down_(size, alignment); |
|
3aee6bc29547
8026852: Use restricted_align_down in collector policy code
jwilhelm
parents:
12840
diff
changeset
|
518 return aligned_size > 0 ? aligned_size : alignment; |
|
3aee6bc29547
8026852: Use restricted_align_down in collector policy code
jwilhelm
parents:
12840
diff
changeset
|
519 } |
|
3aee6bc29547
8026852: Use restricted_align_down in collector policy code
jwilhelm
parents:
12840
diff
changeset
|
520 |
|
9060
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
521 // Clamp an address to be within a specific page |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
522 // 1. If addr is on the page it is returned as is |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
523 // 2. If addr is above the page_address the start of the *next* page will be returned |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
524 // 3. Otherwise, if addr is below the page_address the start of the page will be returned |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
525 inline address clamp_address_in_page(address addr, address page_address, intptr_t page_size) { |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
526 if (align_size_down(intptr_t(addr), page_size) == align_size_down(intptr_t(page_address), page_size)) { |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
527 // address is in the specified page, just return it as is |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
528 return addr; |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
529 } else if (addr > page_address) { |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
530 // address is above specified page, return start of next page |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
531 return (address)align_size_down(intptr_t(page_address), page_size) + page_size; |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
532 } else { |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
533 // address is below specified page, return start of page |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
534 return (address)align_size_down(intptr_t(page_address), page_size); |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
535 } |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
536 } |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
537 |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
538 |
| 1665 | 539 // The expected size in bytes of a cache line, used to pad data structures. |
| 540 #define DEFAULT_CACHE_LINE_SIZE 64 | |
| 541 | |
| 0 | 542 |
| 543 //---------------------------------------------------------------------------------------------------- | |
| 544 // Utility macros for compilers | |
| 545 // used to silence compiler warnings | |
| 546 | |
| 547 #define Unused_Variable(var) var | |
| 548 | |
| 549 | |
| 550 //---------------------------------------------------------------------------------------------------- | |
| 551 // Miscellaneous | |
| 552 | |
| 553 // 6302670 Eliminate Hotspot __fabsf dependency | |
| 554 // All fabs() callers should call this function instead, which will implicitly | |
| 555 // convert the operand to double, avoiding a dependency on __fabsf which | |
| 556 // doesn't exist in early versions of Solaris 8. | |
| 557 inline double fabsd(double value) { | |
| 558 return fabs(value); | |
| 559 } | |
| 560 | |
|
20287
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
561 //---------------------------------------------------------------------------------------------------- |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
562 // Special casts |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
563 // Cast floats into same-size integers and vice-versa w/o changing bit-pattern |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
564 typedef union { |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
565 jfloat f; |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
566 jint i; |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
567 } FloatIntConv; |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
568 |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
569 typedef union { |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
570 jdouble d; |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
571 jlong l; |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
572 julong ul; |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
573 } DoubleLongConv; |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
574 |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
575 inline jint jint_cast (jfloat x) { return ((FloatIntConv*)&x)->i; } |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
576 inline jfloat jfloat_cast (jint x) { return ((FloatIntConv*)&x)->f; } |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
577 |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
578 inline jlong jlong_cast (jdouble x) { return ((DoubleLongConv*)&x)->l; } |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
579 inline julong julong_cast (jdouble x) { return ((DoubleLongConv*)&x)->ul; } |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
580 inline jdouble jdouble_cast (jlong x) { return ((DoubleLongConv*)&x)->d; } |
|
b6a8cc1e0d92
8040121: Load variable through a pointer of an incompatible type in src/hotspot/src/share/vm: opto/output.cpp, runtime/sharedRuntimeTrans.cpp, utilities/globalDefinitions_visCPP.hpp
thartmann
parents:
17937
diff
changeset
|
581 |
| 0 | 582 inline jint low (jlong value) { return jint(value); } |
| 583 inline jint high(jlong value) { return jint(value >> 32); } | |
| 584 | |
| 585 // the fancy casts are a hopefully portable way | |
| 586 // to do unsigned 32 to 64 bit type conversion | |
| 587 inline void set_low (jlong* value, jint low ) { *value &= (jlong)0xffffffff << 32; | |
| 588 *value |= (jlong)(julong)(juint)low; } | |
| 589 | |
| 590 inline void set_high(jlong* value, jint high) { *value &= (jlong)(julong)(juint)0xffffffff; | |
| 591 *value |= (jlong)high << 32; } | |
| 592 | |
| 593 inline jlong jlong_from(jint h, jint l) { | |
| 594 jlong result = 0; // initialization to avoid warning | |
| 595 set_high(&result, h); | |
| 596 set_low(&result, l); | |
| 597 return result; | |
| 598 } | |
| 599 | |
| 600 union jlong_accessor { | |
| 601 jint words[2]; | |
| 602 jlong long_value; | |
| 603 }; | |
| 604 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
605 void basic_types_init(); // cannot define here; uses assert |
| 0 | 606 |
| 607 | |
| 608 // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/runtime/BasicType.java | |
| 609 enum BasicType { | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
610 T_BOOLEAN = 4, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
611 T_CHAR = 5, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
612 T_FLOAT = 6, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
613 T_DOUBLE = 7, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
614 T_BYTE = 8, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
615 T_SHORT = 9, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
616 T_INT = 10, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
617 T_LONG = 11, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
618 T_OBJECT = 12, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
619 T_ARRAY = 13, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
620 T_VOID = 14, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
621 T_ADDRESS = 15, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
622 T_NARROWOOP = 16, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
623 T_METADATA = 17, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
624 T_NARROWKLASS = 18, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
625 T_CONFLICT = 19, // for stack value type with conflicting contents |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
626 T_ILLEGAL = 99 |
| 0 | 627 }; |
| 628 | |
|
29
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
629 inline bool is_java_primitive(BasicType t) { |
|
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
630 return T_BOOLEAN <= t && t <= T_LONG; |
|
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
631 } |
|
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
632 |
| 710 | 633 inline bool is_subword_type(BasicType t) { |
| 634 // these guys are processed exactly like T_INT in calling sequences: | |
| 635 return (t == T_BOOLEAN || t == T_CHAR || t == T_BYTE || t == T_SHORT); | |
| 636 } | |
| 637 | |
| 638 inline bool is_signed_subword_type(BasicType t) { | |
| 639 return (t == T_BYTE || t == T_SHORT); | |
| 640 } | |
| 641 | |
| 0 | 642 // Convert a char from a classfile signature to a BasicType |
| 643 inline BasicType char2type(char c) { | |
| 644 switch( c ) { | |
| 645 case 'B': return T_BYTE; | |
| 646 case 'C': return T_CHAR; | |
| 647 case 'D': return T_DOUBLE; | |
| 648 case 'F': return T_FLOAT; | |
| 649 case 'I': return T_INT; | |
| 650 case 'J': return T_LONG; | |
| 651 case 'S': return T_SHORT; | |
| 652 case 'Z': return T_BOOLEAN; | |
| 653 case 'V': return T_VOID; | |
| 654 case 'L': return T_OBJECT; | |
| 655 case '[': return T_ARRAY; | |
| 656 } | |
| 657 return T_ILLEGAL; | |
| 658 } | |
| 659 | |
| 660 extern char type2char_tab[T_CONFLICT+1]; // Map a BasicType to a jchar | |
| 661 inline char type2char(BasicType t) { return (uint)t < T_CONFLICT+1 ? type2char_tab[t] : 0; } | |
| 662 extern int type2size[T_CONFLICT+1]; // Map BasicType to result stack elements | |
| 663 extern const char* type2name_tab[T_CONFLICT+1]; // Map a BasicType to a jchar | |
| 664 inline const char* type2name(BasicType t) { return (uint)t < T_CONFLICT+1 ? type2name_tab[t] : NULL; } | |
| 665 extern BasicType name2type(const char* name); | |
| 666 | |
| 667 // Auxilary math routines | |
| 668 // least common multiple | |
| 669 extern size_t lcm(size_t a, size_t b); | |
| 670 | |
| 671 | |
| 672 // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/runtime/BasicType.java | |
| 673 enum BasicTypeSize { | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
674 T_BOOLEAN_size = 1, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
675 T_CHAR_size = 1, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
676 T_FLOAT_size = 1, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
677 T_DOUBLE_size = 2, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
678 T_BYTE_size = 1, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
679 T_SHORT_size = 1, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
680 T_INT_size = 1, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
681 T_LONG_size = 2, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
682 T_OBJECT_size = 1, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
683 T_ARRAY_size = 1, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
684 T_NARROWOOP_size = 1, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
685 T_NARROWKLASS_size = 1, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
686 T_VOID_size = 0 |
| 0 | 687 }; |
| 688 | |
| 689 | |
| 690 // maps a BasicType to its instance field storage type: | |
| 691 // all sub-word integral types are widened to T_INT | |
| 692 extern BasicType type2field[T_CONFLICT+1]; | |
| 693 extern BasicType type2wfield[T_CONFLICT+1]; | |
| 694 | |
| 695 | |
| 696 // size in bytes | |
| 697 enum ArrayElementSize { | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
698 T_BOOLEAN_aelem_bytes = 1, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
699 T_CHAR_aelem_bytes = 2, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
700 T_FLOAT_aelem_bytes = 4, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
701 T_DOUBLE_aelem_bytes = 8, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
702 T_BYTE_aelem_bytes = 1, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
703 T_SHORT_aelem_bytes = 2, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
704 T_INT_aelem_bytes = 4, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
705 T_LONG_aelem_bytes = 8, |
| 0 | 706 #ifdef _LP64 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
707 T_OBJECT_aelem_bytes = 8, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
708 T_ARRAY_aelem_bytes = 8, |
| 0 | 709 #else |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
710 T_OBJECT_aelem_bytes = 4, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
711 T_ARRAY_aelem_bytes = 4, |
| 0 | 712 #endif |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
713 T_NARROWOOP_aelem_bytes = 4, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
714 T_NARROWKLASS_aelem_bytes = 4, |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6725
diff
changeset
|
715 T_VOID_aelem_bytes = 0 |
| 0 | 716 }; |
| 717 | |
|
29
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
718 extern int _type2aelembytes[T_CONFLICT+1]; // maps a BasicType to nof bytes used by its array element |
|
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
719 #ifdef ASSERT |
|
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
720 extern int type2aelembytes(BasicType t, bool allow_address = false); // asserts |
|
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
721 #else |
| 1763 | 722 inline int type2aelembytes(BasicType t, bool allow_address = false) { return _type2aelembytes[t]; } |
|
29
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
723 #endif |
| 0 | 724 |
| 725 | |
| 726 // JavaValue serves as a container for arbitrary Java values. | |
| 727 | |
| 728 class JavaValue { | |
| 729 | |
| 730 public: | |
| 731 typedef union JavaCallValue { | |
| 732 jfloat f; | |
| 733 jdouble d; | |
| 734 jint i; | |
| 735 jlong l; | |
| 736 jobject h; | |
| 737 } JavaCallValue; | |
| 738 | |
| 739 private: | |
| 740 BasicType _type; | |
| 741 JavaCallValue _value; | |
| 742 | |
| 743 public: | |
| 744 JavaValue(BasicType t = T_ILLEGAL) { _type = t; } | |
| 745 | |
| 746 JavaValue(jfloat value) { | |
| 747 _type = T_FLOAT; | |
| 748 _value.f = value; | |
| 749 } | |
| 750 | |
| 751 JavaValue(jdouble value) { | |
| 752 _type = T_DOUBLE; | |
| 753 _value.d = value; | |
| 754 } | |
| 755 | |
| 756 jfloat get_jfloat() const { return _value.f; } | |
| 757 jdouble get_jdouble() const { return _value.d; } | |
| 758 jint get_jint() const { return _value.i; } | |
| 759 jlong get_jlong() const { return _value.l; } | |
| 760 jobject get_jobject() const { return _value.h; } | |
| 761 JavaCallValue* get_value_addr() { return &_value; } | |
| 762 BasicType get_type() const { return _type; } | |
| 763 | |
| 764 void set_jfloat(jfloat f) { _value.f = f;} | |
| 765 void set_jdouble(jdouble d) { _value.d = d;} | |
| 766 void set_jint(jint i) { _value.i = i;} | |
| 767 void set_jlong(jlong l) { _value.l = l;} | |
| 768 void set_jobject(jobject h) { _value.h = h;} | |
| 769 void set_type(BasicType t) { _type = t; } | |
| 770 | |
| 771 jboolean get_jboolean() const { return (jboolean) (_value.i);} | |
| 772 jbyte get_jbyte() const { return (jbyte) (_value.i);} | |
| 773 jchar get_jchar() const { return (jchar) (_value.i);} | |
| 774 jshort get_jshort() const { return (jshort) (_value.i);} | |
| 775 | |
| 776 }; | |
| 777 | |
| 778 | |
| 779 #define STACK_BIAS 0 | |
| 780 // V9 Sparc CPU's running in 64 Bit mode use a stack bias of 7ff | |
| 781 // in order to extend the reach of the stack pointer. | |
| 782 #if defined(SPARC) && defined(_LP64) | |
| 783 #undef STACK_BIAS | |
| 784 #define STACK_BIAS 0x7ff | |
| 785 #endif | |
| 786 | |
| 787 | |
| 788 // TosState describes the top-of-stack state before and after the execution of | |
| 789 // a bytecode or method. The top-of-stack value may be cached in one or more CPU | |
| 790 // registers. The TosState corresponds to the 'machine represention' of this cached | |
| 791 // value. There's 4 states corresponding to the JAVA types int, long, float & double | |
| 792 // as well as a 5th state in case the top-of-stack value is actually on the top | |
| 793 // of stack (in memory) and thus not cached. The atos state corresponds to the itos | |
| 794 // state when it comes to machine representation but is used separately for (oop) | |
| 795 // type specific operations (e.g. verification code). | |
| 796 | |
| 797 enum TosState { // describes the tos cache contents | |
| 798 btos = 0, // byte, bool tos cached | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
799 ctos = 1, // char tos cached |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
800 stos = 2, // short tos cached |
| 0 | 801 itos = 3, // int tos cached |
| 802 ltos = 4, // long tos cached | |
| 803 ftos = 5, // float tos cached | |
| 804 dtos = 6, // double tos cached | |
| 805 atos = 7, // object cached | |
| 806 vtos = 8, // tos not cached | |
| 807 number_of_states, | |
| 808 ilgl // illegal state: should not occur | |
| 809 }; | |
| 810 | |
| 811 | |
| 812 inline TosState as_TosState(BasicType type) { | |
| 813 switch (type) { | |
| 814 case T_BYTE : return btos; | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
815 case T_BOOLEAN: return btos; // FIXME: Add ztos |
| 0 | 816 case T_CHAR : return ctos; |
| 817 case T_SHORT : return stos; | |
| 818 case T_INT : return itos; | |
| 819 case T_LONG : return ltos; | |
| 820 case T_FLOAT : return ftos; | |
| 821 case T_DOUBLE : return dtos; | |
| 822 case T_VOID : return vtos; | |
| 823 case T_ARRAY : // fall through | |
| 824 case T_OBJECT : return atos; | |
| 825 } | |
| 826 return ilgl; | |
| 827 } | |
| 828 | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
829 inline BasicType as_BasicType(TosState state) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
830 switch (state) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
831 //case ztos: return T_BOOLEAN;//FIXME |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
832 case btos : return T_BYTE; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
833 case ctos : return T_CHAR; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
834 case stos : return T_SHORT; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
835 case itos : return T_INT; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
836 case ltos : return T_LONG; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
837 case ftos : return T_FLOAT; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
838 case dtos : return T_DOUBLE; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
839 case atos : return T_OBJECT; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
840 case vtos : return T_VOID; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
841 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
842 return T_ILLEGAL; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
843 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
844 |
| 0 | 845 |
| 846 // Helper function to convert BasicType info into TosState | |
| 847 // Note: Cannot define here as it uses global constant at the time being. | |
| 848 TosState as_TosState(BasicType type); | |
| 849 | |
| 850 | |
| 851 // JavaThreadState keeps track of which part of the code a thread is executing in. This | |
| 852 // information is needed by the safepoint code. | |
| 853 // | |
| 854 // There are 4 essential states: | |
| 855 // | |
| 856 // _thread_new : Just started, but not executed init. code yet (most likely still in OS init code) | |
| 857 // _thread_in_native : In native code. This is a safepoint region, since all oops will be in jobject handles | |
| 858 // _thread_in_vm : Executing in the vm | |
| 859 // _thread_in_Java : Executing either interpreted or compiled Java code (or could be in a stub) | |
| 860 // | |
| 861 // Each state has an associated xxxx_trans state, which is an intermediate state used when a thread is in | |
| 862 // a transition from one state to another. These extra states makes it possible for the safepoint code to | |
| 863 // handle certain thread_states without having to suspend the thread - making the safepoint code faster. | |
| 864 // | |
| 865 // Given a state, the xxx_trans state can always be found by adding 1. | |
| 866 // | |
| 867 enum JavaThreadState { | |
| 868 _thread_uninitialized = 0, // should never happen (missing initialization) | |
| 869 _thread_new = 2, // just starting up, i.e., in process of being initialized | |
| 870 _thread_new_trans = 3, // corresponding transition state (not used, included for completness) | |
| 871 _thread_in_native = 4, // running in native code | |
| 872 _thread_in_native_trans = 5, // corresponding transition state | |
| 873 _thread_in_vm = 6, // running in VM | |
| 874 _thread_in_vm_trans = 7, // corresponding transition state | |
| 875 _thread_in_Java = 8, // running in Java or in stub code | |
| 876 _thread_in_Java_trans = 9, // corresponding transition state (not used, included for completness) | |
| 877 _thread_blocked = 10, // blocked in vm | |
| 878 _thread_blocked_trans = 11, // corresponding transition state | |
| 879 _thread_max_state = 12 // maximum thread state+1 - used for statistics allocation | |
| 880 }; | |
| 881 | |
| 882 | |
| 883 // Handy constants for deciding which compiler mode to use. | |
| 884 enum MethodCompilation { | |
| 885 InvocationEntryBci = -1, // i.e., not a on-stack replacement compilation | |
| 886 InvalidOSREntryBci = -2 | |
| 887 }; | |
| 888 | |
| 889 // Enumeration to distinguish tiers of compilation | |
| 890 enum CompLevel { | |
| 1783 | 891 CompLevel_any = -1, |
| 892 CompLevel_all = -1, | |
| 893 CompLevel_none = 0, // Interpreter | |
| 894 CompLevel_simple = 1, // C1 | |
| 895 CompLevel_limited_profile = 2, // C1, invocation & backedge counters | |
| 896 CompLevel_full_profile = 3, // C1, invocation & backedge counters + mdo | |
| 2447 | 897 CompLevel_full_optimization = 4, // C2 or Shark |
| 0 | 898 |
| 2447 | 899 #if defined(COMPILER2) || defined(SHARK) |
| 1783 | 900 CompLevel_highest_tier = CompLevel_full_optimization, // pure C2 and tiered |
| 901 #elif defined(COMPILER1) | |
| 902 CompLevel_highest_tier = CompLevel_simple, // pure C1 | |
| 0 | 903 #else |
| 1783 | 904 CompLevel_highest_tier = CompLevel_none, |
| 905 #endif | |
| 906 | |
| 907 #if defined(TIERED) | |
| 908 CompLevel_initial_compile = CompLevel_full_profile // tiered | |
| 909 #elif defined(COMPILER1) | |
| 910 CompLevel_initial_compile = CompLevel_simple // pure C1 | |
| 2447 | 911 #elif defined(COMPILER2) || defined(SHARK) |
| 1783 | 912 CompLevel_initial_compile = CompLevel_full_optimization // pure C2 |
| 913 #else | |
| 914 CompLevel_initial_compile = CompLevel_none | |
| 915 #endif | |
| 0 | 916 }; |
| 917 | |
| 1783 | 918 inline bool is_c1_compile(int comp_level) { |
| 919 return comp_level > CompLevel_none && comp_level < CompLevel_full_optimization; | |
| 0 | 920 } |
| 1783 | 921 |
| 922 inline bool is_c2_compile(int comp_level) { | |
| 0 | 923 return comp_level == CompLevel_full_optimization; |
| 924 } | |
| 1783 | 925 |
| 0 | 926 inline bool is_highest_tier_compile(int comp_level) { |
| 927 return comp_level == CompLevel_highest_tier; | |
| 928 } | |
| 929 | |
|
9080
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
7623
diff
changeset
|
930 inline bool is_compile(int comp_level) { |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
7623
diff
changeset
|
931 return is_c1_compile(comp_level) || is_c2_compile(comp_level); |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
7623
diff
changeset
|
932 } |
|
b84fd7d73702
8007288: Additional WB API for compiler's testing
iignatyev
parents:
7623
diff
changeset
|
933 |
| 0 | 934 //---------------------------------------------------------------------------------------------------- |
| 935 // 'Forward' declarations of frequently used classes | |
| 936 // (in order to reduce interface dependencies & reduce | |
| 937 // number of unnecessary compilations after changes) | |
| 938 | |
| 939 class symbolTable; | |
| 940 class ClassFileStream; | |
| 941 | |
| 942 class Event; | |
| 943 | |
| 944 class Thread; | |
| 945 class VMThread; | |
| 946 class JavaThread; | |
| 947 class Threads; | |
| 948 | |
| 949 class VM_Operation; | |
| 950 class VMOperationQueue; | |
| 951 | |
| 952 class CodeBlob; | |
| 953 class nmethod; | |
| 954 class OSRAdapter; | |
| 955 class I2CAdapter; | |
| 956 class C2IAdapter; | |
| 957 class CompiledIC; | |
| 958 class relocInfo; | |
| 959 class ScopeDesc; | |
| 960 class PcDesc; | |
| 961 | |
| 962 class Recompiler; | |
| 963 class Recompilee; | |
| 964 class RecompilationPolicy; | |
| 965 class RFrame; | |
| 966 class CompiledRFrame; | |
| 967 class InterpretedRFrame; | |
| 968 | |
| 969 class frame; | |
| 970 | |
| 971 class vframe; | |
| 972 class javaVFrame; | |
| 973 class interpretedVFrame; | |
| 974 class compiledVFrame; | |
| 975 class deoptimizedVFrame; | |
| 976 class externalVFrame; | |
| 977 class entryVFrame; | |
| 978 | |
| 979 class RegisterMap; | |
| 980 | |
| 981 class Mutex; | |
| 982 class Monitor; | |
| 983 class BasicLock; | |
| 984 class BasicObjectLock; | |
| 985 | |
| 986 class PeriodicTask; | |
| 987 | |
| 988 class JavaCallWrapper; | |
| 989 | |
| 990 class oopDesc; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
991 class metaDataOopDesc; |
| 0 | 992 |
| 993 class NativeCall; | |
| 994 | |
| 995 class zone; | |
| 996 | |
| 997 class StubQueue; | |
| 998 | |
| 999 class outputStream; | |
| 1000 | |
| 1001 class ResourceArea; | |
| 1002 | |
| 1003 class DebugInformationRecorder; | |
| 1004 class ScopeValue; | |
| 1005 class CompressedStream; | |
| 1006 class DebugInfoReadStream; | |
| 1007 class DebugInfoWriteStream; | |
| 1008 class LocationValue; | |
| 1009 class ConstantValue; | |
| 1010 class IllegalValue; | |
| 1011 | |
| 1012 class PrivilegedElement; | |
| 1013 class MonitorArray; | |
| 1014 | |
| 1015 class MonitorInfo; | |
| 1016 | |
| 1017 class OffsetClosure; | |
| 1018 class OopMapCache; | |
| 1019 class InterpreterOopMap; | |
| 1020 class OopMapCacheEntry; | |
| 1021 class OSThread; | |
| 1022 | |
| 1023 typedef int (*OSThreadStartFunc)(void*); | |
| 1024 | |
| 1025 class Space; | |
| 1026 | |
| 1027 class JavaValue; | |
| 1028 class methodHandle; | |
| 1029 class JavaCallArguments; | |
| 1030 | |
| 1031 // Basic support for errors (general debug facilities not defined at this point fo the include phase) | |
| 1032 | |
| 1033 extern void basic_fatal(const char* msg); | |
| 1034 | |
| 1035 | |
| 1036 //---------------------------------------------------------------------------------------------------- | |
| 1037 // Special constants for debugging | |
| 1038 | |
| 1039 const jint badInt = -3; // generic "bad int" value | |
| 1040 const long badAddressVal = -2; // generic "bad address" value | |
| 1041 const long badOopVal = -1; // generic "bad oop" value | |
| 1042 const intptr_t badHeapOopVal = (intptr_t) CONST64(0x2BAD4B0BBAADBABE); // value used to zap heap after GC | |
| 1043 const int badHandleValue = 0xBC; // value used to zap vm handle area | |
| 1044 const int badResourceValue = 0xAB; // value used to zap resource area | |
| 1045 const int freeBlockPad = 0xBA; // value used to pad freed blocks. | |
| 1046 const int uninitBlockPad = 0xF1; // value used to zap newly malloc'd blocks. | |
| 1047 const intptr_t badJNIHandleVal = (intptr_t) CONST64(0xFEFEFEFEFEFEFEFE); // value used to zap jni handle area | |
| 1048 const juint badHeapWordVal = 0xBAADBABE; // value used to zap heap after GC | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6107
diff
changeset
|
1049 const juint badMetaWordVal = 0xBAADFADE; // value used to zap metadata heap after GC |
| 0 | 1050 const int badCodeHeapNewVal= 0xCC; // value used to zap Code heap at allocation |
| 1051 const int badCodeHeapFreeVal = 0xDD; // value used to zap Code heap at deallocation | |
| 1052 | |
| 1053 | |
| 1054 // (These must be implemented as #defines because C++ compilers are | |
| 1055 // not obligated to inline non-integral constants!) | |
| 1056 #define badAddress ((address)::badAddressVal) | |
|
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
12110
diff
changeset
|
1057 #define badOop (cast_to_oop(::badOopVal)) |
| 0 | 1058 #define badHeapWord (::badHeapWordVal) |
|
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
12110
diff
changeset
|
1059 #define badJNIHandle (cast_to_oop(::badJNIHandleVal)) |
| 0 | 1060 |
|
1311
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
1261
diff
changeset
|
1061 // Default TaskQueue size is 16K (32-bit) or 128K (64-bit) |
|
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
1261
diff
changeset
|
1062 #define TASKQUEUE_SIZE (NOT_LP64(1<<14) LP64_ONLY(1<<17)) |
| 0 | 1063 |
| 1064 //---------------------------------------------------------------------------------------------------- | |
| 1065 // Utility functions for bitfield manipulations | |
| 1066 | |
| 1067 const intptr_t AllBits = ~0; // all bits set in a word | |
| 1068 const intptr_t NoBits = 0; // no bits set in a word | |
| 1069 const jlong NoLongBits = 0; // no bits set in a long | |
| 1070 const intptr_t OneBit = 1; // only right_most bit set in a word | |
| 1071 | |
| 1072 // get a word with the n.th or the right-most or left-most n bits set | |
| 1073 // (note: #define used only so that they can be used in enum constant definitions) | |
| 1074 #define nth_bit(n) (n >= BitsPerWord ? 0 : OneBit << (n)) | |
| 1075 #define right_n_bits(n) (nth_bit(n) - 1) | |
| 1076 #define left_n_bits(n) (right_n_bits(n) << (n >= BitsPerWord ? 0 : (BitsPerWord - n))) | |
| 1077 | |
| 1078 // bit-operations using a mask m | |
| 1079 inline void set_bits (intptr_t& x, intptr_t m) { x |= m; } | |
| 1080 inline void clear_bits (intptr_t& x, intptr_t m) { x &= ~m; } | |
| 1081 inline intptr_t mask_bits (intptr_t x, intptr_t m) { return x & m; } | |
| 1082 inline jlong mask_long_bits (jlong x, jlong m) { return x & m; } | |
| 1083 inline bool mask_bits_are_true (intptr_t flags, intptr_t mask) { return (flags & mask) == mask; } | |
| 1084 | |
| 1085 // bit-operations using the n.th bit | |
| 1086 inline void set_nth_bit(intptr_t& x, int n) { set_bits (x, nth_bit(n)); } | |
| 1087 inline void clear_nth_bit(intptr_t& x, int n) { clear_bits(x, nth_bit(n)); } | |
| 1088 inline bool is_set_nth_bit(intptr_t x, int n) { return mask_bits (x, nth_bit(n)) != NoBits; } | |
| 1089 | |
| 1090 // returns the bitfield of x starting at start_bit_no with length field_length (no sign-extension!) | |
| 1091 inline intptr_t bitfield(intptr_t x, int start_bit_no, int field_length) { | |
| 1092 return mask_bits(x >> start_bit_no, right_n_bits(field_length)); | |
| 1093 } | |
| 1094 | |
| 1095 | |
| 1096 //---------------------------------------------------------------------------------------------------- | |
| 1097 // Utility functions for integers | |
| 1098 | |
| 1099 // Avoid use of global min/max macros which may cause unwanted double | |
| 1100 // evaluation of arguments. | |
| 1101 #ifdef max | |
| 1102 #undef max | |
| 1103 #endif | |
| 1104 | |
| 1105 #ifdef min | |
| 1106 #undef min | |
| 1107 #endif | |
| 1108 | |
| 1109 #define max(a,b) Do_not_use_max_use_MAX2_instead | |
| 1110 #define min(a,b) Do_not_use_min_use_MIN2_instead | |
| 1111 | |
| 1112 // It is necessary to use templates here. Having normal overloaded | |
| 1113 // functions does not work because it is necessary to provide both 32- | |
| 1114 // and 64-bit overloaded functions, which does not work, and having | |
| 1115 // explicitly-typed versions of these routines (i.e., MAX2I, MAX2L) | |
| 1116 // will be even more error-prone than macros. | |
| 1117 template<class T> inline T MAX2(T a, T b) { return (a > b) ? a : b; } | |
| 1118 template<class T> inline T MIN2(T a, T b) { return (a < b) ? a : b; } | |
| 1119 template<class T> inline T MAX3(T a, T b, T c) { return MAX2(MAX2(a, b), c); } | |
| 1120 template<class T> inline T MIN3(T a, T b, T c) { return MIN2(MIN2(a, b), c); } | |
| 1121 template<class T> inline T MAX4(T a, T b, T c, T d) { return MAX2(MAX3(a, b, c), d); } | |
| 1122 template<class T> inline T MIN4(T a, T b, T c, T d) { return MIN2(MIN3(a, b, c), d); } | |
| 1123 | |
| 1124 template<class T> inline T ABS(T x) { return (x > 0) ? x : -x; } | |
| 1125 | |
| 1126 // true if x is a power of 2, false otherwise | |
| 1127 inline bool is_power_of_2(intptr_t x) { | |
| 1128 return ((x != NoBits) && (mask_bits(x, x - 1) == NoBits)); | |
| 1129 } | |
| 1130 | |
| 1131 // long version of is_power_of_2 | |
| 1132 inline bool is_power_of_2_long(jlong x) { | |
| 1133 return ((x != NoLongBits) && (mask_long_bits(x, x - 1) == NoLongBits)); | |
| 1134 } | |
| 1135 | |
| 1136 //* largest i such that 2^i <= x | |
| 1137 // A negative value of 'x' will return '31' | |
| 1138 inline int log2_intptr(intptr_t x) { | |
| 1139 int i = -1; | |
| 1140 uintptr_t p = 1; | |
| 1141 while (p != 0 && p <= (uintptr_t)x) { | |
| 1142 // p = 2^(i+1) && p <= x (i.e., 2^(i+1) <= x) | |
| 1143 i++; p *= 2; | |
| 1144 } | |
| 1145 // p = 2^(i+1) && x < p (i.e., 2^i <= x < 2^(i+1)) | |
| 605 | 1146 // (if p = 0 then overflow occurred and i = 31) |
| 0 | 1147 return i; |
| 1148 } | |
| 1149 | |
| 1150 //* largest i such that 2^i <= x | |
| 1151 // A negative value of 'x' will return '63' | |
| 1152 inline int log2_long(jlong x) { | |
| 1153 int i = -1; | |
| 1154 julong p = 1; | |
| 1155 while (p != 0 && p <= (julong)x) { | |
| 1156 // p = 2^(i+1) && p <= x (i.e., 2^(i+1) <= x) | |
| 1157 i++; p *= 2; | |
| 1158 } | |
| 1159 // p = 2^(i+1) && x < p (i.e., 2^i <= x < 2^(i+1)) | |
| 605 | 1160 // (if p = 0 then overflow occurred and i = 63) |
| 0 | 1161 return i; |
| 1162 } | |
| 1163 | |
| 1164 //* the argument must be exactly a power of 2 | |
| 1165 inline int exact_log2(intptr_t x) { | |
| 1166 #ifdef ASSERT | |
| 1167 if (!is_power_of_2(x)) basic_fatal("x must be a power of 2"); | |
| 1168 #endif | |
| 1169 return log2_intptr(x); | |
| 1170 } | |
| 1171 | |
|
568
30663ca5e8f4
6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents:
559
diff
changeset
|
1172 //* the argument must be exactly a power of 2 |
|
30663ca5e8f4
6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents:
559
diff
changeset
|
1173 inline int exact_log2_long(jlong x) { |
|
30663ca5e8f4
6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents:
559
diff
changeset
|
1174 #ifdef ASSERT |
|
30663ca5e8f4
6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents:
559
diff
changeset
|
1175 if (!is_power_of_2_long(x)) basic_fatal("x must be a power of 2"); |
|
30663ca5e8f4
6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents:
559
diff
changeset
|
1176 #endif |
|
30663ca5e8f4
6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents:
559
diff
changeset
|
1177 return log2_long(x); |
|
30663ca5e8f4
6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents:
559
diff
changeset
|
1178 } |
|
30663ca5e8f4
6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents:
559
diff
changeset
|
1179 |
| 0 | 1180 |
| 1181 // returns integer round-up to the nearest multiple of s (s must be a power of two) | |
| 1182 inline intptr_t round_to(intptr_t x, uintx s) { | |
| 1183 #ifdef ASSERT | |
| 1184 if (!is_power_of_2(s)) basic_fatal("s must be a power of 2"); | |
| 1185 #endif | |
| 1186 const uintx m = s - 1; | |
| 1187 return mask_bits(x + m, ~m); | |
| 1188 } | |
| 1189 | |
| 1190 // returns integer round-down to the nearest multiple of s (s must be a power of two) | |
| 1191 inline intptr_t round_down(intptr_t x, uintx s) { | |
| 1192 #ifdef ASSERT | |
| 1193 if (!is_power_of_2(s)) basic_fatal("s must be a power of 2"); | |
| 1194 #endif | |
| 1195 const uintx m = s - 1; | |
| 1196 return mask_bits(x, ~m); | |
| 1197 } | |
| 1198 | |
| 1199 | |
| 1200 inline bool is_odd (intx x) { return x & 1; } | |
| 1201 inline bool is_even(intx x) { return !is_odd(x); } | |
| 1202 | |
| 1203 // "to" should be greater than "from." | |
| 1204 inline intx byte_size(void* from, void* to) { | |
| 1205 return (address)to - (address)from; | |
| 1206 } | |
| 1207 | |
| 1208 //---------------------------------------------------------------------------------------------------- | |
| 1209 // Avoid non-portable casts with these routines (DEPRECATED) | |
| 1210 | |
| 1211 // NOTE: USE Bytes class INSTEAD WHERE POSSIBLE | |
| 1212 // Bytes is optimized machine-specifically and may be much faster then the portable routines below. | |
| 1213 | |
| 1214 // Given sequence of four bytes, build into a 32-bit word | |
| 1215 // following the conventions used in class files. | |
| 1216 // On the 386, this could be realized with a simple address cast. | |
| 1217 // | |
| 1218 | |
| 1219 // This routine takes eight bytes: | |
| 1220 inline u8 build_u8_from( u1 c1, u1 c2, u1 c3, u1 c4, u1 c5, u1 c6, u1 c7, u1 c8 ) { | |
|
1789
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1221 return (( u8(c1) << 56 ) & ( u8(0xff) << 56 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1222 | (( u8(c2) << 48 ) & ( u8(0xff) << 48 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1223 | (( u8(c3) << 40 ) & ( u8(0xff) << 40 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1224 | (( u8(c4) << 32 ) & ( u8(0xff) << 32 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1225 | (( u8(c5) << 24 ) & ( u8(0xff) << 24 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1226 | (( u8(c6) << 16 ) & ( u8(0xff) << 16 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1227 | (( u8(c7) << 8 ) & ( u8(0xff) << 8 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1228 | (( u8(c8) << 0 ) & ( u8(0xff) << 0 )); |
| 0 | 1229 } |
| 1230 | |
| 1231 // This routine takes four bytes: | |
| 1232 inline u4 build_u4_from( u1 c1, u1 c2, u1 c3, u1 c4 ) { | |
|
1789
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1233 return (( u4(c1) << 24 ) & 0xff000000) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1234 | (( u4(c2) << 16 ) & 0x00ff0000) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1235 | (( u4(c3) << 8 ) & 0x0000ff00) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1236 | (( u4(c4) << 0 ) & 0x000000ff); |
| 0 | 1237 } |
| 1238 | |
| 1239 // And this one works if the four bytes are contiguous in memory: | |
| 1240 inline u4 build_u4_from( u1* p ) { | |
| 1241 return build_u4_from( p[0], p[1], p[2], p[3] ); | |
| 1242 } | |
| 1243 | |
| 1244 // Ditto for two-byte ints: | |
| 1245 inline u2 build_u2_from( u1 c1, u1 c2 ) { | |
|
1789
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1246 return u2((( u2(c1) << 8 ) & 0xff00) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1247 | (( u2(c2) << 0 ) & 0x00ff)); |
| 0 | 1248 } |
| 1249 | |
| 1250 // And this one works if the two bytes are contiguous in memory: | |
| 1251 inline u2 build_u2_from( u1* p ) { | |
| 1252 return build_u2_from( p[0], p[1] ); | |
| 1253 } | |
| 1254 | |
| 1255 // Ditto for floats: | |
| 1256 inline jfloat build_float_from( u1 c1, u1 c2, u1 c3, u1 c4 ) { | |
| 1257 u4 u = build_u4_from( c1, c2, c3, c4 ); | |
| 1258 return *(jfloat*)&u; | |
| 1259 } | |
| 1260 | |
| 1261 inline jfloat build_float_from( u1* p ) { | |
| 1262 u4 u = build_u4_from( p ); | |
| 1263 return *(jfloat*)&u; | |
| 1264 } | |
| 1265 | |
| 1266 | |
| 1267 // now (64-bit) longs | |
| 1268 | |
| 1269 inline jlong build_long_from( u1 c1, u1 c2, u1 c3, u1 c4, u1 c5, u1 c6, u1 c7, u1 c8 ) { | |
|
1789
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1270 return (( jlong(c1) << 56 ) & ( jlong(0xff) << 56 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1271 | (( jlong(c2) << 48 ) & ( jlong(0xff) << 48 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1272 | (( jlong(c3) << 40 ) & ( jlong(0xff) << 40 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1273 | (( jlong(c4) << 32 ) & ( jlong(0xff) << 32 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1274 | (( jlong(c5) << 24 ) & ( jlong(0xff) << 24 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1275 | (( jlong(c6) << 16 ) & ( jlong(0xff) << 16 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1276 | (( jlong(c7) << 8 ) & ( jlong(0xff) << 8 )) |
|
a83b0246bb77
6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents:
1783
diff
changeset
|
1277 | (( jlong(c8) << 0 ) & ( jlong(0xff) << 0 )); |
| 0 | 1278 } |
| 1279 | |
| 1280 inline jlong build_long_from( u1* p ) { | |
| 1281 return build_long_from( p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7] ); | |
| 1282 } | |
| 1283 | |
| 1284 | |
| 1285 // Doubles, too! | |
| 1286 inline jdouble build_double_from( u1 c1, u1 c2, u1 c3, u1 c4, u1 c5, u1 c6, u1 c7, u1 c8 ) { | |
| 1287 jlong u = build_long_from( c1, c2, c3, c4, c5, c6, c7, c8 ); | |
| 1288 return *(jdouble*)&u; | |
| 1289 } | |
| 1290 | |
| 1291 inline jdouble build_double_from( u1* p ) { | |
| 1292 jlong u = build_long_from( p ); | |
| 1293 return *(jdouble*)&u; | |
| 1294 } | |
| 1295 | |
| 1296 | |
| 1297 // Portable routines to go the other way: | |
| 1298 | |
| 1299 inline void explode_short_to( u2 x, u1& c1, u1& c2 ) { | |
| 1300 c1 = u1(x >> 8); | |
| 1301 c2 = u1(x); | |
| 1302 } | |
| 1303 | |
| 1304 inline void explode_short_to( u2 x, u1* p ) { | |
| 1305 explode_short_to( x, p[0], p[1]); | |
| 1306 } | |
| 1307 | |
| 1308 inline void explode_int_to( u4 x, u1& c1, u1& c2, u1& c3, u1& c4 ) { | |
| 1309 c1 = u1(x >> 24); | |
| 1310 c2 = u1(x >> 16); | |
| 1311 c3 = u1(x >> 8); | |
| 1312 c4 = u1(x); | |
| 1313 } | |
| 1314 | |
| 1315 inline void explode_int_to( u4 x, u1* p ) { | |
| 1316 explode_int_to( x, p[0], p[1], p[2], p[3]); | |
| 1317 } | |
| 1318 | |
| 1319 | |
| 1320 // Pack and extract shorts to/from ints: | |
| 1321 | |
| 1322 inline int extract_low_short_from_int(jint x) { | |
| 1323 return x & 0xffff; | |
| 1324 } | |
| 1325 | |
| 1326 inline int extract_high_short_from_int(jint x) { | |
| 1327 return (x >> 16) & 0xffff; | |
| 1328 } | |
| 1329 | |
| 1330 inline int build_int_from_shorts( jushort low, jushort high ) { | |
| 1331 return ((int)((unsigned int)high << 16) | (unsigned int)low); | |
| 1332 } | |
| 1333 | |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1334 // Convert pointer to intptr_t, for use in printing pointers. |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1335 inline intptr_t p2i(const void * p) { |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1336 return (intptr_t) p; |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1337 } |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1338 |
| 0 | 1339 // Printf-style formatters for fixed- and variable-width types as pointers and |
| 3960 | 1340 // integers. These are derived from the definitions in inttypes.h. If the platform |
| 1341 // doesn't provide appropriate definitions, they should be provided in | |
| 1342 // the compiler-specific definitions file (e.g., globalDefinitions_gcc.hpp) | |
| 0 | 1343 |
| 2361 | 1344 #define BOOL_TO_STR(_b_) ((_b_) ? "true" : "false") |
| 2152 | 1345 |
| 0 | 1346 // Format 32-bit quantities. |
| 3960 | 1347 #define INT32_FORMAT "%" PRId32 |
| 1348 #define UINT32_FORMAT "%" PRIu32 | |
| 1349 #define INT32_FORMAT_W(width) "%" #width PRId32 | |
| 1350 #define UINT32_FORMAT_W(width) "%" #width PRIu32 | |
| 0 | 1351 |
| 3960 | 1352 #define PTR32_FORMAT "0x%08" PRIx32 |
| 0 | 1353 |
| 1354 // Format 64-bit quantities. | |
| 3960 | 1355 #define INT64_FORMAT "%" PRId64 |
| 1356 #define UINT64_FORMAT "%" PRIu64 | |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1357 #define UINT64_FORMAT_X "%" PRIx64 |
| 3960 | 1358 #define INT64_FORMAT_W(width) "%" #width PRId64 |
| 1359 #define UINT64_FORMAT_W(width) "%" #width PRIu64 | |
| 0 | 1360 |
| 3960 | 1361 #define PTR64_FORMAT "0x%016" PRIx64 |
| 0 | 1362 |
|
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
7176
diff
changeset
|
1363 // Format jlong, if necessary |
|
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
7176
diff
changeset
|
1364 #ifndef JLONG_FORMAT |
|
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
7176
diff
changeset
|
1365 #define JLONG_FORMAT INT64_FORMAT |
|
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
7176
diff
changeset
|
1366 #endif |
|
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
7176
diff
changeset
|
1367 #ifndef JULONG_FORMAT |
|
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
7176
diff
changeset
|
1368 #define JULONG_FORMAT UINT64_FORMAT |
|
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
7176
diff
changeset
|
1369 #endif |
|
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
7176
diff
changeset
|
1370 |
| 3960 | 1371 // Format pointers which change size between 32- and 64-bit. |
| 0 | 1372 #ifdef _LP64 |
| 3960 | 1373 #define INTPTR_FORMAT "0x%016" PRIxPTR |
| 1374 #define PTR_FORMAT "0x%016" PRIxPTR | |
| 0 | 1375 #else // !_LP64 |
| 3960 | 1376 #define INTPTR_FORMAT "0x%08" PRIxPTR |
| 1377 #define PTR_FORMAT "0x%08" PRIxPTR | |
| 0 | 1378 #endif // _LP64 |
| 1379 | |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1380 #define INTPTR_FORMAT_W(width) "%" #width PRIxPTR |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1381 |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1382 #define SSIZE_FORMAT "%" PRIdPTR |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1383 #define SIZE_FORMAT "%" PRIuPTR |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1384 #define SIZE_FORMAT_HEX "0x%" PRIxPTR |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1385 #define SSIZE_FORMAT_W(width) "%" #width PRIdPTR |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1386 #define SIZE_FORMAT_W(width) "%" #width PRIuPTR |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
1387 #define SIZE_FORMAT_HEX_W(width) "0x%" #width PRIxPTR |
| 3960 | 1388 |
| 1389 #define INTX_FORMAT "%" PRIdPTR | |
| 1390 #define UINTX_FORMAT "%" PRIuPTR | |
| 1391 #define INTX_FORMAT_W(width) "%" #width PRIdPTR | |
| 1392 #define UINTX_FORMAT_W(width) "%" #width PRIuPTR | |
| 1393 | |
| 0 | 1394 |
| 1395 // Enable zap-a-lot if in debug version. | |
| 1396 | |
| 1397 # ifdef ASSERT | |
| 1398 # ifdef COMPILER2 | |
| 1399 # define ENABLE_ZAP_DEAD_LOCALS | |
| 1400 #endif /* COMPILER2 */ | |
| 1401 # endif /* ASSERT */ | |
| 1402 | |
| 1403 #define ARRAY_SIZE(array) (sizeof(array)/sizeof((array)[0])) | |
| 1972 | 1404 |
|
7176
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6982
diff
changeset
|
1405 // Dereference vptr |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6982
diff
changeset
|
1406 // All C++ compilers that we know of have the vtbl pointer in the first |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6982
diff
changeset
|
1407 // word. If there are exceptions, this function needs to be made compiler |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6982
diff
changeset
|
1408 // specific. |
|
17935
7384f6a12fc1
8038212: Method::is_valid_method() check has performance regression impact for stackwalking
coleenp
parents:
17810
diff
changeset
|
1409 static inline void* dereference_vptr(const void* addr) { |
|
7176
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6982
diff
changeset
|
1410 return *(void**)addr; |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6982
diff
changeset
|
1411 } |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6982
diff
changeset
|
1412 |
|
9060
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
1413 #ifndef PRODUCT |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
1414 |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
1415 // For unit testing only |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
1416 class GlobalDefinitions { |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
1417 public: |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
1418 static void test_globals(); |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
1419 }; |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
1420 |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
1421 #endif // PRODUCT |
|
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
7623
diff
changeset
|
1422 |
| 1972 | 1423 #endif // SHARE_VM_UTILITIES_GLOBALDEFINITIONS_HPP |