Mercurial > hg > truffle
annotate src/share/vm/utilities/globalDefinitions.hpp @ 2152:0fa27f37d4d4
6977804: G1: remove the zero-filling thread
Summary: This changeset removes the zero-filling thread from G1 and collapses the two free region lists we had before (the "free" and "unclean" lists) into one. The new free list uses the new heap region sets / lists abstractions that we'll ultimately use it to keep track of all regions in the heap. A heap region set was also introduced for the humongous regions. Finally, this change increases the concurrency between the thread that completes freeing regions (after a cleanup pause) and the rest of the system (before we'd have to wait for said thread to complete before allocating a new region). The changest also includes a lot of refactoring and code simplification.
Reviewed-by: jcoomes, johnc
| author | tonyp |
|---|---|
| date | Wed, 19 Jan 2011 19:30:42 -0500 |
| parents | f95d63e2154a |
| children | d25d4ca69222 b92c45f2bc75 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2152 | 2 * Copyright (c) 1997, 2011, 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 | |
| 28 #ifdef TARGET_COMPILER_gcc | |
| 29 # include "utilities/globalDefinitions_gcc.hpp" | |
| 30 #endif | |
| 31 #ifdef TARGET_COMPILER_visCPP | |
| 32 # include "utilities/globalDefinitions_visCPP.hpp" | |
| 33 #endif | |
| 34 #ifdef TARGET_COMPILER_sparcWorks | |
| 35 # include "utilities/globalDefinitions_sparcWorks.hpp" | |
| 36 #endif | |
| 37 | |
| 38 #include "utilities/macros.hpp" | |
| 39 | |
| 0 | 40 // This file holds all globally used constants & types, class (forward) |
| 41 // declarations and a few frequently used utility functions. | |
| 42 | |
| 43 //---------------------------------------------------------------------------------------------------- | |
| 44 // Constants | |
| 45 | |
| 46 const int LogBytesPerShort = 1; | |
| 47 const int LogBytesPerInt = 2; | |
| 48 #ifdef _LP64 | |
| 49 const int LogBytesPerWord = 3; | |
| 50 #else | |
| 51 const int LogBytesPerWord = 2; | |
| 52 #endif | |
| 53 const int LogBytesPerLong = 3; | |
| 54 | |
| 55 const int BytesPerShort = 1 << LogBytesPerShort; | |
| 56 const int BytesPerInt = 1 << LogBytesPerInt; | |
| 57 const int BytesPerWord = 1 << LogBytesPerWord; | |
| 58 const int BytesPerLong = 1 << LogBytesPerLong; | |
| 59 | |
| 60 const int LogBitsPerByte = 3; | |
| 61 const int LogBitsPerShort = LogBitsPerByte + LogBytesPerShort; | |
| 62 const int LogBitsPerInt = LogBitsPerByte + LogBytesPerInt; | |
| 63 const int LogBitsPerWord = LogBitsPerByte + LogBytesPerWord; | |
| 64 const int LogBitsPerLong = LogBitsPerByte + LogBytesPerLong; | |
| 65 | |
| 66 const int BitsPerByte = 1 << LogBitsPerByte; | |
| 67 const int BitsPerShort = 1 << LogBitsPerShort; | |
| 68 const int BitsPerInt = 1 << LogBitsPerInt; | |
| 69 const int BitsPerWord = 1 << LogBitsPerWord; | |
| 70 const int BitsPerLong = 1 << LogBitsPerLong; | |
| 71 | |
| 72 const int WordAlignmentMask = (1 << LogBytesPerWord) - 1; | |
| 73 const int LongAlignmentMask = (1 << LogBytesPerLong) - 1; | |
| 74 | |
| 75 const int WordsPerLong = 2; // Number of stack entries for longs | |
| 76 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
77 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
|
78 extern int heapOopSize; // Oop within a java object |
| 0 | 79 const int wordSize = sizeof(char*); |
| 80 const int longSize = sizeof(jlong); | |
| 81 const int jintSize = sizeof(jint); | |
| 82 const int size_tSize = sizeof(size_t); | |
| 83 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
84 const int BytesPerOop = BytesPerWord; // Full-width oop |
| 0 | 85 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
86 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
|
87 extern int LogBitsPerHeapOop; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
88 extern int BytesPerHeapOop; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
89 extern int BitsPerHeapOop; |
| 0 | 90 |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
91 // 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
|
92 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
|
93 |
| 0 | 94 const int BitsPerJavaInteger = 32; |
|
559
7628781568e1
6795362: 32bit server compiler leads to wrong results on solaris-x86
twisti
parents:
361
diff
changeset
|
95 const int BitsPerJavaLong = 64; |
| 0 | 96 const int BitsPerSize_t = size_tSize * BitsPerByte; |
| 97 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
98 // 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
|
99 const int jintAsStringSize = 12; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
100 |
| 0 | 101 // In fact this should be |
| 102 // log2_intptr(sizeof(class JavaThread)) - log2_intptr(64); | |
| 103 // see os::set_memory_serialize_page() | |
| 104 #ifdef _LP64 | |
| 105 const int SerializePageShiftCount = 4; | |
| 106 #else | |
| 107 const int SerializePageShiftCount = 3; | |
| 108 #endif | |
| 109 | |
| 110 // An opaque struct of heap-word width, so that HeapWord* can be a generic | |
| 111 // pointer into the heap. We require that object sizes be measured in | |
| 112 // units of heap words, so that that | |
| 113 // HeapWord* hw; | |
| 114 // hw += oop(hw)->foo(); | |
| 115 // works, where foo is a method (like size or scavenge) that returns the | |
| 116 // object size. | |
| 117 class HeapWord { | |
| 118 friend class VMStructs; | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
145
diff
changeset
|
119 private: |
| 0 | 120 char* i; |
|
361
a4f9ef0c0375
6743059: Error in spaceDecorator.cpp "optimized" build.
jmasa
parents:
269
diff
changeset
|
121 #ifndef PRODUCT |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
145
diff
changeset
|
122 public: |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
145
diff
changeset
|
123 char* value() { return i; } |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
145
diff
changeset
|
124 #endif |
| 0 | 125 }; |
| 126 | |
| 127 // 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
|
128 const int HeapWordSize = sizeof(HeapWord); |
| 0 | 129 #ifdef _LP64 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
130 const int LogHeapWordSize = 3; |
| 0 | 131 #else |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
132 const int LogHeapWordSize = 2; |
| 0 | 133 #endif |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
134 const int HeapWordsPerLong = BytesPerLong / HeapWordSize; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
135 const int LogHeapWordsPerLong = LogBytesPerLong - LogHeapWordSize; |
| 0 | 136 |
| 137 // The larger HeapWordSize for 64bit requires larger heaps | |
| 138 // for the same application running in 64bit. See bug 4967770. | |
| 139 // The minimum alignment to a heap word size is done. Other | |
| 140 // parts of the memory system may required additional alignment | |
| 141 // and are responsible for those alignments. | |
| 142 #ifdef _LP64 | |
| 143 #define ScaleForWordSize(x) align_size_down_((x) * 13 / 10, HeapWordSize) | |
| 144 #else | |
| 145 #define ScaleForWordSize(x) (x) | |
| 146 #endif | |
| 147 | |
| 148 // The minimum number of native machine words necessary to contain "byte_size" | |
| 149 // bytes. | |
| 150 inline size_t heap_word_size(size_t byte_size) { | |
| 151 return (byte_size + (HeapWordSize-1)) >> LogHeapWordSize; | |
| 152 } | |
| 153 | |
| 154 | |
| 155 const size_t K = 1024; | |
| 156 const size_t M = K*K; | |
| 157 const size_t G = M*K; | |
| 158 const size_t HWperKB = K / sizeof(HeapWord); | |
| 159 | |
| 1261 | 160 const size_t LOG_K = 10; |
| 161 const size_t LOG_M = 2 * LOG_K; | |
| 162 const size_t LOG_G = 2 * LOG_M; | |
| 163 | |
| 0 | 164 const jint min_jint = (jint)1 << (sizeof(jint)*BitsPerByte-1); // 0x80000000 == smallest jint |
| 165 const jint max_jint = (juint)min_jint - 1; // 0x7FFFFFFF == largest jint | |
| 166 | |
| 167 // Constants for converting from a base unit to milli-base units. For | |
| 168 // example from seconds to milliseconds and microseconds | |
| 169 | |
| 170 const int MILLIUNITS = 1000; // milli units per base unit | |
| 171 const int MICROUNITS = 1000000; // micro units per base unit | |
| 172 const int NANOUNITS = 1000000000; // nano units per base unit | |
| 173 | |
| 174 inline const char* proper_unit_for_byte_size(size_t s) { | |
| 175 if (s >= 10*M) { | |
| 176 return "M"; | |
| 177 } else if (s >= 10*K) { | |
| 178 return "K"; | |
| 179 } else { | |
| 180 return "B"; | |
| 181 } | |
| 182 } | |
| 183 | |
| 184 inline size_t byte_size_in_proper_unit(size_t s) { | |
| 185 if (s >= 10*M) { | |
| 186 return s/M; | |
| 187 } else if (s >= 10*K) { | |
| 188 return s/K; | |
| 189 } else { | |
| 190 return s; | |
| 191 } | |
| 192 } | |
| 193 | |
| 194 | |
| 195 //---------------------------------------------------------------------------------------------------- | |
| 196 // VM type definitions | |
| 197 | |
| 198 // intx and uintx are the 'extended' int and 'extended' unsigned int types; | |
| 199 // they are 32bit wide on a 32-bit platform, and 64bit wide on a 64bit platform. | |
| 200 | |
| 201 typedef intptr_t intx; | |
| 202 typedef uintptr_t uintx; | |
| 203 | |
| 204 const intx min_intx = (intx)1 << (sizeof(intx)*BitsPerByte-1); | |
| 205 const intx max_intx = (uintx)min_intx - 1; | |
| 206 const uintx max_uintx = (uintx)-1; | |
| 207 | |
| 208 // Table of values: | |
| 209 // sizeof intx 4 8 | |
| 210 // min_intx 0x80000000 0x8000000000000000 | |
| 211 // max_intx 0x7FFFFFFF 0x7FFFFFFFFFFFFFFF | |
| 212 // max_uintx 0xFFFFFFFF 0xFFFFFFFFFFFFFFFF | |
| 213 | |
| 214 typedef unsigned int uint; NEEDS_CLEANUP | |
| 215 | |
| 216 | |
| 217 //---------------------------------------------------------------------------------------------------- | |
| 218 // Java type definitions | |
| 219 | |
| 220 // All kinds of 'plain' byte addresses | |
| 221 typedef signed char s_char; | |
| 222 typedef unsigned char u_char; | |
| 223 typedef u_char* address; | |
| 224 typedef uintptr_t address_word; // unsigned integer which will hold a pointer | |
| 225 // except for some implementations of a C++ | |
| 226 // linkage pointer to function. Should never | |
| 227 // need one of those to be placed in this | |
| 228 // type anyway. | |
| 229 | |
| 230 // Utility functions to "portably" (?) bit twiddle pointers | |
| 231 // Where portable means keep ANSI C++ compilers quiet | |
| 232 | |
| 233 inline address set_address_bits(address x, int m) { return address(intptr_t(x) | m); } | |
| 234 inline address clear_address_bits(address x, int m) { return address(intptr_t(x) & ~m); } | |
| 235 | |
| 236 // Utility functions to "portably" make cast to/from function pointers. | |
| 237 | |
| 238 inline address_word mask_address_bits(address x, int m) { return address_word(x) & m; } | |
| 239 inline address_word castable_address(address x) { return address_word(x) ; } | |
| 240 inline address_word castable_address(void* x) { return address_word(x) ; } | |
| 241 | |
| 242 // Pointer subtraction. | |
| 243 // The idea here is to avoid ptrdiff_t, which is signed and so doesn't have | |
| 244 // the range we might need to find differences from one end of the heap | |
| 245 // to the other. | |
| 246 // A typical use might be: | |
| 247 // if (pointer_delta(end(), top()) >= size) { | |
| 248 // // enough room for an object of size | |
| 249 // ... | |
| 250 // and then additions like | |
| 251 // ... top() + size ... | |
| 252 // are safe because we know that top() is at least size below end(). | |
| 253 inline size_t pointer_delta(const void* left, | |
| 254 const void* right, | |
| 255 size_t element_size) { | |
| 256 return (((uintptr_t) left) - ((uintptr_t) right)) / element_size; | |
| 257 } | |
| 258 // A version specialized for HeapWord*'s. | |
| 259 inline size_t pointer_delta(const HeapWord* left, const HeapWord* right) { | |
| 260 return pointer_delta(left, right, sizeof(HeapWord)); | |
| 261 } | |
| 262 | |
| 263 // | |
| 264 // ANSI C++ does not allow casting from one pointer type to a function pointer | |
| 265 // directly without at best a warning. This macro accomplishes it silently | |
| 266 // In every case that is present at this point the value be cast is a pointer | |
| 267 // to a C linkage function. In somecase the type used for the cast reflects | |
| 268 // that linkage and a picky compiler would not complain. In other cases because | |
| 269 // there is no convenient place to place a typedef with extern C linkage (i.e | |
| 270 // a platform dependent header file) it doesn't. At this point no compiler seems | |
| 271 // picky enough to catch these instances (which are few). It is possible that | |
| 272 // using templates could fix these for all cases. This use of templates is likely | |
| 273 // so far from the middle of the road that it is likely to be problematic in | |
| 274 // many C++ compilers. | |
| 275 // | |
| 276 #define CAST_TO_FN_PTR(func_type, value) ((func_type)(castable_address(value))) | |
| 277 #define CAST_FROM_FN_PTR(new_type, func_ptr) ((new_type)((address_word)(func_ptr))) | |
| 278 | |
| 279 // Unsigned byte types for os and stream.hpp | |
| 280 | |
| 281 // Unsigned one, two, four and eigth byte quantities used for describing | |
| 282 // the .class file format. See JVM book chapter 4. | |
| 283 | |
| 284 typedef jubyte u1; | |
| 285 typedef jushort u2; | |
| 286 typedef juint u4; | |
| 287 typedef julong u8; | |
| 288 | |
| 289 const jubyte max_jubyte = (jubyte)-1; // 0xFF largest jubyte | |
| 290 const jushort max_jushort = (jushort)-1; // 0xFFFF largest jushort | |
| 291 const juint max_juint = (juint)-1; // 0xFFFFFFFF largest juint | |
| 292 const julong max_julong = (julong)-1; // 0xFF....FF largest julong | |
| 293 | |
| 294 //---------------------------------------------------------------------------------------------------- | |
| 295 // JVM spec restrictions | |
| 296 | |
| 297 const int max_method_code_size = 64*K - 1; // JVM spec, 2nd ed. section 4.8.1 (p.134) | |
| 298 | |
| 299 | |
| 300 //---------------------------------------------------------------------------------------------------- | |
| 301 // HotSwap - for JVMTI aka Class File Replacement and PopFrame | |
| 302 // | |
| 303 // Determines whether on-the-fly class replacement and frame popping are enabled. | |
| 304 | |
| 305 #define HOTSWAP | |
| 306 | |
| 307 //---------------------------------------------------------------------------------------------------- | |
| 308 // Object alignment, in units of HeapWords. | |
| 309 // | |
| 310 // Minimum is max(BytesPerLong, BytesPerDouble, BytesPerOop) / HeapWordSize, so jlong, jdouble and | |
| 311 // reference fields can be naturally aligned. | |
| 312 | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
313 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
|
314 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
|
315 extern int MinObjAlignmentInBytesMask; |
| 0 | 316 |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
317 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
|
318 extern int LogMinObjAlignmentInBytes; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
319 |
| 0 | 320 // Machine dependent stuff |
| 321 | |
| 1972 | 322 #ifdef TARGET_ARCH_x86 |
| 323 # include "globalDefinitions_x86.hpp" | |
| 324 #endif | |
| 325 #ifdef TARGET_ARCH_sparc | |
| 326 # include "globalDefinitions_sparc.hpp" | |
| 327 #endif | |
| 328 #ifdef TARGET_ARCH_zero | |
| 329 # include "globalDefinitions_zero.hpp" | |
| 330 #endif | |
| 331 | |
| 0 | 332 |
| 333 // The byte alignment to be used by Arena::Amalloc. See bugid 4169348. | |
| 334 // Note: this value must be a power of 2 | |
| 335 | |
| 336 #define ARENA_AMALLOC_ALIGNMENT (2*BytesPerWord) | |
| 337 | |
| 338 // Signed variants of alignment helpers. There are two versions of each, a macro | |
| 339 // for use in places like enum definitions that require compile-time constant | |
| 340 // expressions and a function for all other places so as to get type checking. | |
| 341 | |
| 342 #define align_size_up_(size, alignment) (((size) + ((alignment) - 1)) & ~((alignment) - 1)) | |
| 343 | |
| 344 inline intptr_t align_size_up(intptr_t size, intptr_t alignment) { | |
| 345 return align_size_up_(size, alignment); | |
| 346 } | |
| 347 | |
| 348 #define align_size_down_(size, alignment) ((size) & ~((alignment) - 1)) | |
| 349 | |
| 350 inline intptr_t align_size_down(intptr_t size, intptr_t alignment) { | |
| 351 return align_size_down_(size, alignment); | |
| 352 } | |
| 353 | |
| 354 // Align objects by rounding up their size, in HeapWord units. | |
| 355 | |
| 356 #define align_object_size_(size) align_size_up_(size, MinObjAlignment) | |
| 357 | |
| 358 inline intptr_t align_object_size(intptr_t size) { | |
| 359 return align_size_up(size, MinObjAlignment); | |
| 360 } | |
| 361 | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
362 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
|
363 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
|
364 } |
| 0 | 365 |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1311
diff
changeset
|
366 // Pad out certain offsets to jlong alignment, in HeapWord units. |
| 0 | 367 |
| 368 inline intptr_t align_object_offset(intptr_t offset) { | |
| 369 return align_size_up(offset, HeapWordsPerLong); | |
| 370 } | |
| 371 | |
| 1665 | 372 // The expected size in bytes of a cache line, used to pad data structures. |
| 373 #define DEFAULT_CACHE_LINE_SIZE 64 | |
| 374 | |
| 375 // Bytes needed to pad type to avoid cache-line sharing; alignment should be the | |
| 376 // expected cache line size (a power of two). The first addend avoids sharing | |
| 377 // when the start address is not a multiple of alignment; the second maintains | |
| 378 // alignment of starting addresses that happen to be a multiple. | |
| 379 #define PADDING_SIZE(type, alignment) \ | |
| 380 ((alignment) + align_size_up_(sizeof(type), alignment)) | |
| 381 | |
| 382 // Templates to create a subclass padded to avoid cache line sharing. These are | |
| 383 // effective only when applied to derived-most (leaf) classes. | |
| 384 | |
| 385 // When no args are passed to the base ctor. | |
| 386 template <class T, size_t alignment = DEFAULT_CACHE_LINE_SIZE> | |
| 387 class Padded: public T { | |
| 388 private: | |
| 389 char _pad_buf_[PADDING_SIZE(T, alignment)]; | |
| 390 }; | |
| 391 | |
| 392 // When either 0 or 1 args may be passed to the base ctor. | |
| 393 template <class T, typename Arg1T, size_t alignment = DEFAULT_CACHE_LINE_SIZE> | |
| 394 class Padded01: public T { | |
| 395 public: | |
| 396 Padded01(): T() { } | |
| 397 Padded01(Arg1T arg1): T(arg1) { } | |
| 398 private: | |
| 399 char _pad_buf_[PADDING_SIZE(T, alignment)]; | |
| 400 }; | |
| 0 | 401 |
| 402 //---------------------------------------------------------------------------------------------------- | |
| 403 // Utility macros for compilers | |
| 404 // used to silence compiler warnings | |
| 405 | |
| 406 #define Unused_Variable(var) var | |
| 407 | |
| 408 | |
| 409 //---------------------------------------------------------------------------------------------------- | |
| 410 // Miscellaneous | |
| 411 | |
| 412 // 6302670 Eliminate Hotspot __fabsf dependency | |
| 413 // All fabs() callers should call this function instead, which will implicitly | |
| 414 // convert the operand to double, avoiding a dependency on __fabsf which | |
| 415 // doesn't exist in early versions of Solaris 8. | |
| 416 inline double fabsd(double value) { | |
| 417 return fabs(value); | |
| 418 } | |
| 419 | |
| 420 inline jint low (jlong value) { return jint(value); } | |
| 421 inline jint high(jlong value) { return jint(value >> 32); } | |
| 422 | |
| 423 // the fancy casts are a hopefully portable way | |
| 424 // to do unsigned 32 to 64 bit type conversion | |
| 425 inline void set_low (jlong* value, jint low ) { *value &= (jlong)0xffffffff << 32; | |
| 426 *value |= (jlong)(julong)(juint)low; } | |
| 427 | |
| 428 inline void set_high(jlong* value, jint high) { *value &= (jlong)(julong)(juint)0xffffffff; | |
| 429 *value |= (jlong)high << 32; } | |
| 430 | |
| 431 inline jlong jlong_from(jint h, jint l) { | |
| 432 jlong result = 0; // initialization to avoid warning | |
| 433 set_high(&result, h); | |
| 434 set_low(&result, l); | |
| 435 return result; | |
| 436 } | |
| 437 | |
| 438 union jlong_accessor { | |
| 439 jint words[2]; | |
| 440 jlong long_value; | |
| 441 }; | |
| 442 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
443 void basic_types_init(); // cannot define here; uses assert |
| 0 | 444 |
| 445 | |
| 446 // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/runtime/BasicType.java | |
| 447 enum BasicType { | |
| 448 T_BOOLEAN = 4, | |
| 449 T_CHAR = 5, | |
| 450 T_FLOAT = 6, | |
| 451 T_DOUBLE = 7, | |
| 452 T_BYTE = 8, | |
| 453 T_SHORT = 9, | |
| 454 T_INT = 10, | |
| 455 T_LONG = 11, | |
| 456 T_OBJECT = 12, | |
| 457 T_ARRAY = 13, | |
| 458 T_VOID = 14, | |
| 459 T_ADDRESS = 15, | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
460 T_NARROWOOP= 16, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
461 T_CONFLICT = 17, // for stack value type with conflicting contents |
| 0 | 462 T_ILLEGAL = 99 |
| 463 }; | |
| 464 | |
|
29
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
465 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
|
466 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
|
467 } |
|
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
468 |
| 710 | 469 inline bool is_subword_type(BasicType t) { |
| 470 // these guys are processed exactly like T_INT in calling sequences: | |
| 471 return (t == T_BOOLEAN || t == T_CHAR || t == T_BYTE || t == T_SHORT); | |
| 472 } | |
| 473 | |
| 474 inline bool is_signed_subword_type(BasicType t) { | |
| 475 return (t == T_BYTE || t == T_SHORT); | |
| 476 } | |
| 477 | |
| 0 | 478 // Convert a char from a classfile signature to a BasicType |
| 479 inline BasicType char2type(char c) { | |
| 480 switch( c ) { | |
| 481 case 'B': return T_BYTE; | |
| 482 case 'C': return T_CHAR; | |
| 483 case 'D': return T_DOUBLE; | |
| 484 case 'F': return T_FLOAT; | |
| 485 case 'I': return T_INT; | |
| 486 case 'J': return T_LONG; | |
| 487 case 'S': return T_SHORT; | |
| 488 case 'Z': return T_BOOLEAN; | |
| 489 case 'V': return T_VOID; | |
| 490 case 'L': return T_OBJECT; | |
| 491 case '[': return T_ARRAY; | |
| 492 } | |
| 493 return T_ILLEGAL; | |
| 494 } | |
| 495 | |
| 496 extern char type2char_tab[T_CONFLICT+1]; // Map a BasicType to a jchar | |
| 497 inline char type2char(BasicType t) { return (uint)t < T_CONFLICT+1 ? type2char_tab[t] : 0; } | |
| 498 extern int type2size[T_CONFLICT+1]; // Map BasicType to result stack elements | |
| 499 extern const char* type2name_tab[T_CONFLICT+1]; // Map a BasicType to a jchar | |
| 500 inline const char* type2name(BasicType t) { return (uint)t < T_CONFLICT+1 ? type2name_tab[t] : NULL; } | |
| 501 extern BasicType name2type(const char* name); | |
| 502 | |
| 503 // Auxilary math routines | |
| 504 // least common multiple | |
| 505 extern size_t lcm(size_t a, size_t b); | |
| 506 | |
| 507 | |
| 508 // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/runtime/BasicType.java | |
| 509 enum BasicTypeSize { | |
| 510 T_BOOLEAN_size = 1, | |
| 511 T_CHAR_size = 1, | |
| 512 T_FLOAT_size = 1, | |
| 513 T_DOUBLE_size = 2, | |
| 514 T_BYTE_size = 1, | |
| 515 T_SHORT_size = 1, | |
| 516 T_INT_size = 1, | |
| 517 T_LONG_size = 2, | |
| 518 T_OBJECT_size = 1, | |
| 519 T_ARRAY_size = 1, | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
520 T_NARROWOOP_size = 1, |
| 0 | 521 T_VOID_size = 0 |
| 522 }; | |
| 523 | |
| 524 | |
| 525 // maps a BasicType to its instance field storage type: | |
| 526 // all sub-word integral types are widened to T_INT | |
| 527 extern BasicType type2field[T_CONFLICT+1]; | |
| 528 extern BasicType type2wfield[T_CONFLICT+1]; | |
| 529 | |
| 530 | |
| 531 // size in bytes | |
| 532 enum ArrayElementSize { | |
| 533 T_BOOLEAN_aelem_bytes = 1, | |
| 534 T_CHAR_aelem_bytes = 2, | |
| 535 T_FLOAT_aelem_bytes = 4, | |
| 536 T_DOUBLE_aelem_bytes = 8, | |
| 537 T_BYTE_aelem_bytes = 1, | |
| 538 T_SHORT_aelem_bytes = 2, | |
| 539 T_INT_aelem_bytes = 4, | |
| 540 T_LONG_aelem_bytes = 8, | |
| 541 #ifdef _LP64 | |
| 542 T_OBJECT_aelem_bytes = 8, | |
| 543 T_ARRAY_aelem_bytes = 8, | |
| 544 #else | |
| 545 T_OBJECT_aelem_bytes = 4, | |
| 546 T_ARRAY_aelem_bytes = 4, | |
| 547 #endif | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
548 T_NARROWOOP_aelem_bytes = 4, |
| 0 | 549 T_VOID_aelem_bytes = 0 |
| 550 }; | |
| 551 | |
|
29
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
552 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
|
553 #ifdef ASSERT |
|
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
554 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
|
555 #else |
| 1763 | 556 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
|
557 #endif |
| 0 | 558 |
| 559 | |
| 560 // JavaValue serves as a container for arbitrary Java values. | |
| 561 | |
| 562 class JavaValue { | |
| 563 | |
| 564 public: | |
| 565 typedef union JavaCallValue { | |
| 566 jfloat f; | |
| 567 jdouble d; | |
| 568 jint i; | |
| 569 jlong l; | |
| 570 jobject h; | |
| 571 } JavaCallValue; | |
| 572 | |
| 573 private: | |
| 574 BasicType _type; | |
| 575 JavaCallValue _value; | |
| 576 | |
| 577 public: | |
| 578 JavaValue(BasicType t = T_ILLEGAL) { _type = t; } | |
| 579 | |
| 580 JavaValue(jfloat value) { | |
| 581 _type = T_FLOAT; | |
| 582 _value.f = value; | |
| 583 } | |
| 584 | |
| 585 JavaValue(jdouble value) { | |
| 586 _type = T_DOUBLE; | |
| 587 _value.d = value; | |
| 588 } | |
| 589 | |
| 590 jfloat get_jfloat() const { return _value.f; } | |
| 591 jdouble get_jdouble() const { return _value.d; } | |
| 592 jint get_jint() const { return _value.i; } | |
| 593 jlong get_jlong() const { return _value.l; } | |
| 594 jobject get_jobject() const { return _value.h; } | |
| 595 JavaCallValue* get_value_addr() { return &_value; } | |
| 596 BasicType get_type() const { return _type; } | |
| 597 | |
| 598 void set_jfloat(jfloat f) { _value.f = f;} | |
| 599 void set_jdouble(jdouble d) { _value.d = d;} | |
| 600 void set_jint(jint i) { _value.i = i;} | |
| 601 void set_jlong(jlong l) { _value.l = l;} | |
| 602 void set_jobject(jobject h) { _value.h = h;} | |
| 603 void set_type(BasicType t) { _type = t; } | |
| 604 | |
| 605 jboolean get_jboolean() const { return (jboolean) (_value.i);} | |
| 606 jbyte get_jbyte() const { return (jbyte) (_value.i);} | |
| 607 jchar get_jchar() const { return (jchar) (_value.i);} | |
| 608 jshort get_jshort() const { return (jshort) (_value.i);} | |
| 609 | |
| 610 }; | |
| 611 | |
| 612 | |
| 613 #define STACK_BIAS 0 | |
| 614 // V9 Sparc CPU's running in 64 Bit mode use a stack bias of 7ff | |
| 615 // in order to extend the reach of the stack pointer. | |
| 616 #if defined(SPARC) && defined(_LP64) | |
| 617 #undef STACK_BIAS | |
| 618 #define STACK_BIAS 0x7ff | |
| 619 #endif | |
| 620 | |
| 621 | |
| 622 // TosState describes the top-of-stack state before and after the execution of | |
| 623 // a bytecode or method. The top-of-stack value may be cached in one or more CPU | |
| 624 // registers. The TosState corresponds to the 'machine represention' of this cached | |
| 625 // value. There's 4 states corresponding to the JAVA types int, long, float & double | |
| 626 // as well as a 5th state in case the top-of-stack value is actually on the top | |
| 627 // of stack (in memory) and thus not cached. The atos state corresponds to the itos | |
| 628 // state when it comes to machine representation but is used separately for (oop) | |
| 629 // type specific operations (e.g. verification code). | |
| 630 | |
| 631 enum TosState { // describes the tos cache contents | |
| 632 btos = 0, // byte, bool tos cached | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
633 ctos = 1, // char tos cached |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
634 stos = 2, // short tos cached |
| 0 | 635 itos = 3, // int tos cached |
| 636 ltos = 4, // long tos cached | |
| 637 ftos = 5, // float tos cached | |
| 638 dtos = 6, // double tos cached | |
| 639 atos = 7, // object cached | |
| 640 vtos = 8, // tos not cached | |
| 641 number_of_states, | |
| 642 ilgl // illegal state: should not occur | |
| 643 }; | |
| 644 | |
| 645 | |
| 646 inline TosState as_TosState(BasicType type) { | |
| 647 switch (type) { | |
| 648 case T_BYTE : return btos; | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
649 case T_BOOLEAN: return btos; // FIXME: Add ztos |
| 0 | 650 case T_CHAR : return ctos; |
| 651 case T_SHORT : return stos; | |
| 652 case T_INT : return itos; | |
| 653 case T_LONG : return ltos; | |
| 654 case T_FLOAT : return ftos; | |
| 655 case T_DOUBLE : return dtos; | |
| 656 case T_VOID : return vtos; | |
| 657 case T_ARRAY : // fall through | |
| 658 case T_OBJECT : return atos; | |
| 659 } | |
| 660 return ilgl; | |
| 661 } | |
| 662 | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
663 inline BasicType as_BasicType(TosState state) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
664 switch (state) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
665 //case ztos: return T_BOOLEAN;//FIXME |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
666 case btos : return T_BYTE; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
667 case ctos : return T_CHAR; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
668 case stos : return T_SHORT; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
669 case itos : return T_INT; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
670 case ltos : return T_LONG; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
671 case ftos : return T_FLOAT; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
672 case dtos : return T_DOUBLE; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
673 case atos : return T_OBJECT; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
674 case vtos : return T_VOID; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
675 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
676 return T_ILLEGAL; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
677 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
678 |
| 0 | 679 |
| 680 // Helper function to convert BasicType info into TosState | |
| 681 // Note: Cannot define here as it uses global constant at the time being. | |
| 682 TosState as_TosState(BasicType type); | |
| 683 | |
| 684 | |
| 685 // ReferenceType is used to distinguish between java/lang/ref/Reference subclasses | |
| 686 | |
| 687 enum ReferenceType { | |
| 688 REF_NONE, // Regular class | |
| 689 REF_OTHER, // Subclass of java/lang/ref/Reference, but not subclass of one of the classes below | |
| 690 REF_SOFT, // Subclass of java/lang/ref/SoftReference | |
| 691 REF_WEAK, // Subclass of java/lang/ref/WeakReference | |
| 692 REF_FINAL, // Subclass of java/lang/ref/FinalReference | |
| 693 REF_PHANTOM // Subclass of java/lang/ref/PhantomReference | |
| 694 }; | |
| 695 | |
| 696 | |
| 697 // JavaThreadState keeps track of which part of the code a thread is executing in. This | |
| 698 // information is needed by the safepoint code. | |
| 699 // | |
| 700 // There are 4 essential states: | |
| 701 // | |
| 702 // _thread_new : Just started, but not executed init. code yet (most likely still in OS init code) | |
| 703 // _thread_in_native : In native code. This is a safepoint region, since all oops will be in jobject handles | |
| 704 // _thread_in_vm : Executing in the vm | |
| 705 // _thread_in_Java : Executing either interpreted or compiled Java code (or could be in a stub) | |
| 706 // | |
| 707 // Each state has an associated xxxx_trans state, which is an intermediate state used when a thread is in | |
| 708 // a transition from one state to another. These extra states makes it possible for the safepoint code to | |
| 709 // handle certain thread_states without having to suspend the thread - making the safepoint code faster. | |
| 710 // | |
| 711 // Given a state, the xxx_trans state can always be found by adding 1. | |
| 712 // | |
| 713 enum JavaThreadState { | |
| 714 _thread_uninitialized = 0, // should never happen (missing initialization) | |
| 715 _thread_new = 2, // just starting up, i.e., in process of being initialized | |
| 716 _thread_new_trans = 3, // corresponding transition state (not used, included for completness) | |
| 717 _thread_in_native = 4, // running in native code | |
| 718 _thread_in_native_trans = 5, // corresponding transition state | |
| 719 _thread_in_vm = 6, // running in VM | |
| 720 _thread_in_vm_trans = 7, // corresponding transition state | |
| 721 _thread_in_Java = 8, // running in Java or in stub code | |
| 722 _thread_in_Java_trans = 9, // corresponding transition state (not used, included for completness) | |
| 723 _thread_blocked = 10, // blocked in vm | |
| 724 _thread_blocked_trans = 11, // corresponding transition state | |
| 725 _thread_max_state = 12 // maximum thread state+1 - used for statistics allocation | |
| 726 }; | |
| 727 | |
| 728 | |
| 729 // Handy constants for deciding which compiler mode to use. | |
| 730 enum MethodCompilation { | |
| 731 InvocationEntryBci = -1, // i.e., not a on-stack replacement compilation | |
| 732 InvalidOSREntryBci = -2 | |
| 733 }; | |
| 734 | |
| 735 // Enumeration to distinguish tiers of compilation | |
| 736 enum CompLevel { | |
| 1783 | 737 CompLevel_any = -1, |
| 738 CompLevel_all = -1, | |
| 739 CompLevel_none = 0, // Interpreter | |
| 740 CompLevel_simple = 1, // C1 | |
| 741 CompLevel_limited_profile = 2, // C1, invocation & backedge counters | |
| 742 CompLevel_full_profile = 3, // C1, invocation & backedge counters + mdo | |
| 743 CompLevel_full_optimization = 4, // C2 | |
| 0 | 744 |
| 1783 | 745 #if defined(COMPILER2) |
| 746 CompLevel_highest_tier = CompLevel_full_optimization, // pure C2 and tiered | |
| 747 #elif defined(COMPILER1) | |
| 748 CompLevel_highest_tier = CompLevel_simple, // pure C1 | |
| 0 | 749 #else |
| 1783 | 750 CompLevel_highest_tier = CompLevel_none, |
| 751 #endif | |
| 752 | |
| 753 #if defined(TIERED) | |
| 754 CompLevel_initial_compile = CompLevel_full_profile // tiered | |
| 755 #elif defined(COMPILER1) | |
| 756 CompLevel_initial_compile = CompLevel_simple // pure C1 | |
| 757 #elif defined(COMPILER2) | |
| 758 CompLevel_initial_compile = CompLevel_full_optimization // pure C2 | |
| 759 #else | |
| 760 CompLevel_initial_compile = CompLevel_none | |
| 761 #endif | |
| 0 | 762 }; |
| 763 | |
| 1783 | 764 inline bool is_c1_compile(int comp_level) { |
| 765 return comp_level > CompLevel_none && comp_level < CompLevel_full_optimization; | |
| 0 | 766 } |
| 1783 | 767 |
| 768 inline bool is_c2_compile(int comp_level) { | |
| 0 | 769 return comp_level == CompLevel_full_optimization; |
| 770 } | |
| 1783 | 771 |
| 0 | 772 inline bool is_highest_tier_compile(int comp_level) { |
| 773 return comp_level == CompLevel_highest_tier; | |
| 774 } | |
| 775 | |
| 776 //---------------------------------------------------------------------------------------------------- | |
| 777 // 'Forward' declarations of frequently used classes | |
| 778 // (in order to reduce interface dependencies & reduce | |
| 779 // number of unnecessary compilations after changes) | |
| 780 | |
| 781 class symbolTable; | |
| 782 class ClassFileStream; | |
| 783 | |
| 784 class Event; | |
| 785 | |
| 786 class Thread; | |
| 787 class VMThread; | |
| 788 class JavaThread; | |
| 789 class Threads; | |
| 790 | |
| 791 class VM_Operation; | |
| 792 class VMOperationQueue; | |
| 793 | |
| 794 class CodeBlob; | |
| 795 class nmethod; | |
| 796 class OSRAdapter; | |
| 797 class I2CAdapter; | |
| 798 class C2IAdapter; | |
| 799 class CompiledIC; | |
| 800 class relocInfo; | |
| 801 class ScopeDesc; | |
| 802 class PcDesc; | |
| 803 | |
| 804 class Recompiler; | |
| 805 class Recompilee; | |
| 806 class RecompilationPolicy; | |
| 807 class RFrame; | |
| 808 class CompiledRFrame; | |
| 809 class InterpretedRFrame; | |
| 810 | |
| 811 class frame; | |
| 812 | |
| 813 class vframe; | |
| 814 class javaVFrame; | |
| 815 class interpretedVFrame; | |
| 816 class compiledVFrame; | |
| 817 class deoptimizedVFrame; | |
| 818 class externalVFrame; | |
| 819 class entryVFrame; | |
| 820 | |
| 821 class RegisterMap; | |
| 822 | |
| 823 class Mutex; | |
| 824 class Monitor; | |
| 825 class BasicLock; | |
| 826 class BasicObjectLock; | |
| 827 | |
| 828 class PeriodicTask; | |
| 829 | |
| 830 class JavaCallWrapper; | |
| 831 | |
| 832 class oopDesc; | |
| 833 | |
| 834 class NativeCall; | |
| 835 | |
| 836 class zone; | |
| 837 | |
| 838 class StubQueue; | |
| 839 | |
| 840 class outputStream; | |
| 841 | |
| 842 class ResourceArea; | |
| 843 | |
| 844 class DebugInformationRecorder; | |
| 845 class ScopeValue; | |
| 846 class CompressedStream; | |
| 847 class DebugInfoReadStream; | |
| 848 class DebugInfoWriteStream; | |
| 849 class LocationValue; | |
| 850 class ConstantValue; | |
| 851 class IllegalValue; | |
| 852 | |
| 853 class PrivilegedElement; | |
| 854 class MonitorArray; | |
| 855 | |
| 856 class MonitorInfo; | |
| 857 | |
| 858 class OffsetClosure; | |
| 859 class OopMapCache; | |
| 860 class InterpreterOopMap; | |
| 861 class OopMapCacheEntry; | |
| 862 class OSThread; | |
| 863 | |
| 864 typedef int (*OSThreadStartFunc)(void*); | |
| 865 | |
| 866 class Space; | |
| 867 | |
| 868 class JavaValue; | |
| 869 class methodHandle; | |
| 870 class JavaCallArguments; | |
| 871 | |
| 872 // Basic support for errors (general debug facilities not defined at this point fo the include phase) | |
| 873 | |
| 874 extern void basic_fatal(const char* msg); | |
| 875 | |
| 876 | |
| 877 //---------------------------------------------------------------------------------------------------- | |
| 878 // Special constants for debugging | |
| 879 | |
| 880 const jint badInt = -3; // generic "bad int" value | |
| 881 const long badAddressVal = -2; // generic "bad address" value | |
| 882 const long badOopVal = -1; // generic "bad oop" value | |
| 883 const intptr_t badHeapOopVal = (intptr_t) CONST64(0x2BAD4B0BBAADBABE); // value used to zap heap after GC | |
| 884 const int badHandleValue = 0xBC; // value used to zap vm handle area | |
| 885 const int badResourceValue = 0xAB; // value used to zap resource area | |
| 886 const int freeBlockPad = 0xBA; // value used to pad freed blocks. | |
| 887 const int uninitBlockPad = 0xF1; // value used to zap newly malloc'd blocks. | |
| 888 const intptr_t badJNIHandleVal = (intptr_t) CONST64(0xFEFEFEFEFEFEFEFE); // value used to zap jni handle area | |
| 889 const juint badHeapWordVal = 0xBAADBABE; // value used to zap heap after GC | |
| 890 const int badCodeHeapNewVal= 0xCC; // value used to zap Code heap at allocation | |
| 891 const int badCodeHeapFreeVal = 0xDD; // value used to zap Code heap at deallocation | |
| 892 | |
| 893 | |
| 894 // (These must be implemented as #defines because C++ compilers are | |
| 895 // not obligated to inline non-integral constants!) | |
| 896 #define badAddress ((address)::badAddressVal) | |
| 897 #define badOop ((oop)::badOopVal) | |
| 898 #define badHeapWord (::badHeapWordVal) | |
| 899 #define badJNIHandle ((oop)::badJNIHandleVal) | |
| 900 | |
|
1311
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
1261
diff
changeset
|
901 // 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
|
902 #define TASKQUEUE_SIZE (NOT_LP64(1<<14) LP64_ONLY(1<<17)) |
| 0 | 903 |
| 904 //---------------------------------------------------------------------------------------------------- | |
| 905 // Utility functions for bitfield manipulations | |
| 906 | |
| 907 const intptr_t AllBits = ~0; // all bits set in a word | |
| 908 const intptr_t NoBits = 0; // no bits set in a word | |
| 909 const jlong NoLongBits = 0; // no bits set in a long | |
| 910 const intptr_t OneBit = 1; // only right_most bit set in a word | |
| 911 | |
| 912 // get a word with the n.th or the right-most or left-most n bits set | |
| 913 // (note: #define used only so that they can be used in enum constant definitions) | |
| 914 #define nth_bit(n) (n >= BitsPerWord ? 0 : OneBit << (n)) | |
| 915 #define right_n_bits(n) (nth_bit(n) - 1) | |
| 916 #define left_n_bits(n) (right_n_bits(n) << (n >= BitsPerWord ? 0 : (BitsPerWord - n))) | |
| 917 | |
| 918 // bit-operations using a mask m | |
| 919 inline void set_bits (intptr_t& x, intptr_t m) { x |= m; } | |
| 920 inline void clear_bits (intptr_t& x, intptr_t m) { x &= ~m; } | |
| 921 inline intptr_t mask_bits (intptr_t x, intptr_t m) { return x & m; } | |
| 922 inline jlong mask_long_bits (jlong x, jlong m) { return x & m; } | |
| 923 inline bool mask_bits_are_true (intptr_t flags, intptr_t mask) { return (flags & mask) == mask; } | |
| 924 | |
| 925 // bit-operations using the n.th bit | |
| 926 inline void set_nth_bit(intptr_t& x, int n) { set_bits (x, nth_bit(n)); } | |
| 927 inline void clear_nth_bit(intptr_t& x, int n) { clear_bits(x, nth_bit(n)); } | |
| 928 inline bool is_set_nth_bit(intptr_t x, int n) { return mask_bits (x, nth_bit(n)) != NoBits; } | |
| 929 | |
| 930 // returns the bitfield of x starting at start_bit_no with length field_length (no sign-extension!) | |
| 931 inline intptr_t bitfield(intptr_t x, int start_bit_no, int field_length) { | |
| 932 return mask_bits(x >> start_bit_no, right_n_bits(field_length)); | |
| 933 } | |
| 934 | |
| 935 | |
| 936 //---------------------------------------------------------------------------------------------------- | |
| 937 // Utility functions for integers | |
| 938 | |
| 939 // Avoid use of global min/max macros which may cause unwanted double | |
| 940 // evaluation of arguments. | |
| 941 #ifdef max | |
| 942 #undef max | |
| 943 #endif | |
| 944 | |
| 945 #ifdef min | |
| 946 #undef min | |
| 947 #endif | |
| 948 | |
| 949 #define max(a,b) Do_not_use_max_use_MAX2_instead | |
| 950 #define min(a,b) Do_not_use_min_use_MIN2_instead | |
| 951 | |
| 952 // It is necessary to use templates here. Having normal overloaded | |
| 953 // functions does not work because it is necessary to provide both 32- | |
| 954 // and 64-bit overloaded functions, which does not work, and having | |
| 955 // explicitly-typed versions of these routines (i.e., MAX2I, MAX2L) | |
| 956 // will be even more error-prone than macros. | |
| 957 template<class T> inline T MAX2(T a, T b) { return (a > b) ? a : b; } | |
| 958 template<class T> inline T MIN2(T a, T b) { return (a < b) ? a : b; } | |
| 959 template<class T> inline T MAX3(T a, T b, T c) { return MAX2(MAX2(a, b), c); } | |
| 960 template<class T> inline T MIN3(T a, T b, T c) { return MIN2(MIN2(a, b), c); } | |
| 961 template<class T> inline T MAX4(T a, T b, T c, T d) { return MAX2(MAX3(a, b, c), d); } | |
| 962 template<class T> inline T MIN4(T a, T b, T c, T d) { return MIN2(MIN3(a, b, c), d); } | |
| 963 | |
| 964 template<class T> inline T ABS(T x) { return (x > 0) ? x : -x; } | |
| 965 | |
| 966 // true if x is a power of 2, false otherwise | |
| 967 inline bool is_power_of_2(intptr_t x) { | |
| 968 return ((x != NoBits) && (mask_bits(x, x - 1) == NoBits)); | |
| 969 } | |
| 970 | |
| 971 // long version of is_power_of_2 | |
| 972 inline bool is_power_of_2_long(jlong x) { | |
| 973 return ((x != NoLongBits) && (mask_long_bits(x, x - 1) == NoLongBits)); | |
| 974 } | |
| 975 | |
| 976 //* largest i such that 2^i <= x | |
| 977 // A negative value of 'x' will return '31' | |
| 978 inline int log2_intptr(intptr_t x) { | |
| 979 int i = -1; | |
| 980 uintptr_t p = 1; | |
| 981 while (p != 0 && p <= (uintptr_t)x) { | |
| 982 // p = 2^(i+1) && p <= x (i.e., 2^(i+1) <= x) | |
| 983 i++; p *= 2; | |
| 984 } | |
| 985 // p = 2^(i+1) && x < p (i.e., 2^i <= x < 2^(i+1)) | |
| 605 | 986 // (if p = 0 then overflow occurred and i = 31) |
| 0 | 987 return i; |
| 988 } | |
| 989 | |
| 990 //* largest i such that 2^i <= x | |
| 991 // A negative value of 'x' will return '63' | |
| 992 inline int log2_long(jlong x) { | |
| 993 int i = -1; | |
| 994 julong p = 1; | |
| 995 while (p != 0 && p <= (julong)x) { | |
| 996 // p = 2^(i+1) && p <= x (i.e., 2^(i+1) <= x) | |
| 997 i++; p *= 2; | |
| 998 } | |
| 999 // p = 2^(i+1) && x < p (i.e., 2^i <= x < 2^(i+1)) | |
| 605 | 1000 // (if p = 0 then overflow occurred and i = 63) |
| 0 | 1001 return i; |
| 1002 } | |
| 1003 | |
| 1004 //* the argument must be exactly a power of 2 | |
| 1005 inline int exact_log2(intptr_t x) { | |
| 1006 #ifdef ASSERT | |
| 1007 if (!is_power_of_2(x)) basic_fatal("x must be a power of 2"); | |
| 1008 #endif | |
| 1009 return log2_intptr(x); | |
| 1010 } | |
| 1011 | |
|
568
30663ca5e8f4
6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents:
559
diff
changeset
|
1012 //* 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
|
1013 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
|
1014 #ifdef ASSERT |
|
30663ca5e8f4
6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents:
559
diff
changeset
|
1015 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
|
1016 #endif |
|
30663ca5e8f4
6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents:
559
diff
changeset
|
1017 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
|
1018 } |
|
30663ca5e8f4
6805724: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
twisti
parents:
559
diff
changeset
|
1019 |
| 0 | 1020 |
| 1021 // returns integer round-up to the nearest multiple of s (s must be a power of two) | |
| 1022 inline intptr_t round_to(intptr_t x, uintx s) { | |
| 1023 #ifdef ASSERT | |
| 1024 if (!is_power_of_2(s)) basic_fatal("s must be a power of 2"); | |
| 1025 #endif | |
| 1026 const uintx m = s - 1; | |
| 1027 return mask_bits(x + m, ~m); | |
| 1028 } | |
| 1029 | |
| 1030 // returns integer round-down to the nearest multiple of s (s must be a power of two) | |
| 1031 inline intptr_t round_down(intptr_t x, uintx s) { | |
| 1032 #ifdef ASSERT | |
| 1033 if (!is_power_of_2(s)) basic_fatal("s must be a power of 2"); | |
| 1034 #endif | |
| 1035 const uintx m = s - 1; | |
| 1036 return mask_bits(x, ~m); | |
| 1037 } | |
| 1038 | |
| 1039 | |
| 1040 inline bool is_odd (intx x) { return x & 1; } | |
| 1041 inline bool is_even(intx x) { return !is_odd(x); } | |
| 1042 | |
| 1043 // "to" should be greater than "from." | |
| 1044 inline intx byte_size(void* from, void* to) { | |
| 1045 return (address)to - (address)from; | |
| 1046 } | |
| 1047 | |
| 1048 //---------------------------------------------------------------------------------------------------- | |
| 1049 // Avoid non-portable casts with these routines (DEPRECATED) | |
| 1050 | |
| 1051 // NOTE: USE Bytes class INSTEAD WHERE POSSIBLE | |
| 1052 // Bytes is optimized machine-specifically and may be much faster then the portable routines below. | |
| 1053 | |
| 1054 // Given sequence of four bytes, build into a 32-bit word | |
| 1055 // following the conventions used in class files. | |
| 1056 // On the 386, this could be realized with a simple address cast. | |
| 1057 // | |
| 1058 | |
| 1059 // This routine takes eight bytes: | |
| 1060 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
|
1061 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
|
1062 | (( 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
|
1063 | (( 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
|
1064 | (( 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
|
1065 | (( 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
|
1066 | (( 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
|
1067 | (( 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
|
1068 | (( u8(c8) << 0 ) & ( u8(0xff) << 0 )); |
| 0 | 1069 } |
| 1070 | |
| 1071 // This routine takes four bytes: | |
| 1072 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
|
1073 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
|
1074 | (( 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
|
1075 | (( 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
|
1076 | (( u4(c4) << 0 ) & 0x000000ff); |
| 0 | 1077 } |
| 1078 | |
| 1079 // And this one works if the four bytes are contiguous in memory: | |
| 1080 inline u4 build_u4_from( u1* p ) { | |
| 1081 return build_u4_from( p[0], p[1], p[2], p[3] ); | |
| 1082 } | |
| 1083 | |
| 1084 // Ditto for two-byte ints: | |
| 1085 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
|
1086 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
|
1087 | (( u2(c2) << 0 ) & 0x00ff)); |
| 0 | 1088 } |
| 1089 | |
| 1090 // And this one works if the two bytes are contiguous in memory: | |
| 1091 inline u2 build_u2_from( u1* p ) { | |
| 1092 return build_u2_from( p[0], p[1] ); | |
| 1093 } | |
| 1094 | |
| 1095 // Ditto for floats: | |
| 1096 inline jfloat build_float_from( u1 c1, u1 c2, u1 c3, u1 c4 ) { | |
| 1097 u4 u = build_u4_from( c1, c2, c3, c4 ); | |
| 1098 return *(jfloat*)&u; | |
| 1099 } | |
| 1100 | |
| 1101 inline jfloat build_float_from( u1* p ) { | |
| 1102 u4 u = build_u4_from( p ); | |
| 1103 return *(jfloat*)&u; | |
| 1104 } | |
| 1105 | |
| 1106 | |
| 1107 // now (64-bit) longs | |
| 1108 | |
| 1109 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
|
1110 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
|
1111 | (( 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
|
1112 | (( 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
|
1113 | (( 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
|
1114 | (( 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
|
1115 | (( 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
|
1116 | (( 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
|
1117 | (( jlong(c8) << 0 ) & ( jlong(0xff) << 0 )); |
| 0 | 1118 } |
| 1119 | |
| 1120 inline jlong build_long_from( u1* p ) { | |
| 1121 return build_long_from( p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7] ); | |
| 1122 } | |
| 1123 | |
| 1124 | |
| 1125 // Doubles, too! | |
| 1126 inline jdouble build_double_from( u1 c1, u1 c2, u1 c3, u1 c4, u1 c5, u1 c6, u1 c7, u1 c8 ) { | |
| 1127 jlong u = build_long_from( c1, c2, c3, c4, c5, c6, c7, c8 ); | |
| 1128 return *(jdouble*)&u; | |
| 1129 } | |
| 1130 | |
| 1131 inline jdouble build_double_from( u1* p ) { | |
| 1132 jlong u = build_long_from( p ); | |
| 1133 return *(jdouble*)&u; | |
| 1134 } | |
| 1135 | |
| 1136 | |
| 1137 // Portable routines to go the other way: | |
| 1138 | |
| 1139 inline void explode_short_to( u2 x, u1& c1, u1& c2 ) { | |
| 1140 c1 = u1(x >> 8); | |
| 1141 c2 = u1(x); | |
| 1142 } | |
| 1143 | |
| 1144 inline void explode_short_to( u2 x, u1* p ) { | |
| 1145 explode_short_to( x, p[0], p[1]); | |
| 1146 } | |
| 1147 | |
| 1148 inline void explode_int_to( u4 x, u1& c1, u1& c2, u1& c3, u1& c4 ) { | |
| 1149 c1 = u1(x >> 24); | |
| 1150 c2 = u1(x >> 16); | |
| 1151 c3 = u1(x >> 8); | |
| 1152 c4 = u1(x); | |
| 1153 } | |
| 1154 | |
| 1155 inline void explode_int_to( u4 x, u1* p ) { | |
| 1156 explode_int_to( x, p[0], p[1], p[2], p[3]); | |
| 1157 } | |
| 1158 | |
| 1159 | |
| 1160 // Pack and extract shorts to/from ints: | |
| 1161 | |
| 1162 inline int extract_low_short_from_int(jint x) { | |
| 1163 return x & 0xffff; | |
| 1164 } | |
| 1165 | |
| 1166 inline int extract_high_short_from_int(jint x) { | |
| 1167 return (x >> 16) & 0xffff; | |
| 1168 } | |
| 1169 | |
| 1170 inline int build_int_from_shorts( jushort low, jushort high ) { | |
| 1171 return ((int)((unsigned int)high << 16) | (unsigned int)low); | |
| 1172 } | |
| 1173 | |
| 1174 // Printf-style formatters for fixed- and variable-width types as pointers and | |
| 1175 // integers. | |
| 1176 // | |
| 1177 // Each compiler-specific definitions file (e.g., globalDefinitions_gcc.hpp) | |
| 1178 // must define the macro FORMAT64_MODIFIER, which is the modifier for '%x' or | |
| 1179 // '%d' formats to indicate a 64-bit quantity; commonly "l" (in LP64) or "ll" | |
| 1180 // (in ILP32). | |
| 1181 | |
| 2152 | 1182 #define BOOL_TO_STR(__b) (__b) ? "true" : "false" |
| 1183 | |
| 0 | 1184 // Format 32-bit quantities. |
| 1185 #define INT32_FORMAT "%d" | |
| 1186 #define UINT32_FORMAT "%u" | |
| 1187 #define INT32_FORMAT_W(width) "%" #width "d" | |
| 1188 #define UINT32_FORMAT_W(width) "%" #width "u" | |
| 1189 | |
| 1190 #define PTR32_FORMAT "0x%08x" | |
| 1191 | |
| 1192 // Format 64-bit quantities. | |
| 1193 #define INT64_FORMAT "%" FORMAT64_MODIFIER "d" | |
| 1194 #define UINT64_FORMAT "%" FORMAT64_MODIFIER "u" | |
| 1195 #define PTR64_FORMAT "0x%016" FORMAT64_MODIFIER "x" | |
| 1196 | |
| 1197 #define INT64_FORMAT_W(width) "%" #width FORMAT64_MODIFIER "d" | |
| 1198 #define UINT64_FORMAT_W(width) "%" #width FORMAT64_MODIFIER "u" | |
| 1199 | |
| 1200 // Format macros that allow the field width to be specified. The width must be | |
| 1201 // a string literal (e.g., "8") or a macro that evaluates to one. | |
| 1202 #ifdef _LP64 | |
|
513
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
361
diff
changeset
|
1203 #define UINTX_FORMAT_W(width) UINT64_FORMAT_W(width) |
| 0 | 1204 #define SSIZE_FORMAT_W(width) INT64_FORMAT_W(width) |
| 1205 #define SIZE_FORMAT_W(width) UINT64_FORMAT_W(width) | |
| 1206 #else | |
|
513
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
361
diff
changeset
|
1207 #define UINTX_FORMAT_W(width) UINT32_FORMAT_W(width) |
| 0 | 1208 #define SSIZE_FORMAT_W(width) INT32_FORMAT_W(width) |
| 1209 #define SIZE_FORMAT_W(width) UINT32_FORMAT_W(width) | |
| 1210 #endif // _LP64 | |
| 1211 | |
| 1212 // Format pointers and size_t (or size_t-like integer types) which change size | |
|
513
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
361
diff
changeset
|
1213 // between 32- and 64-bit. The pointer format theoretically should be "%p", |
|
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
361
diff
changeset
|
1214 // however, it has different output on different platforms. On Windows, the data |
|
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
361
diff
changeset
|
1215 // will be padded with zeros automatically. On Solaris, we can use "%016p" & |
|
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
361
diff
changeset
|
1216 // "%08p" on 64 bit & 32 bit platforms to make the data padded with extra zeros. |
|
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
361
diff
changeset
|
1217 // On Linux, "%016p" or "%08p" is not be allowed, at least on the latest GCC |
|
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
361
diff
changeset
|
1218 // 4.3.2. So we have to use "%016x" or "%08x" to simulate the printing format. |
|
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
361
diff
changeset
|
1219 // GCC 4.3.2, however requires the data to be converted to "intptr_t" when |
|
2328d1d3f8cf
6781583: Hotspot build fails on linux 64 bit platform with gcc 4.3.2
xlu
parents:
361
diff
changeset
|
1220 // using "%x". |
| 0 | 1221 #ifdef _LP64 |
| 1222 #define PTR_FORMAT PTR64_FORMAT | |
| 1223 #define UINTX_FORMAT UINT64_FORMAT | |
| 1224 #define INTX_FORMAT INT64_FORMAT | |
| 1225 #define SIZE_FORMAT UINT64_FORMAT | |
| 1226 #define SSIZE_FORMAT INT64_FORMAT | |
| 1227 #else // !_LP64 | |
| 1228 #define PTR_FORMAT PTR32_FORMAT | |
| 1229 #define UINTX_FORMAT UINT32_FORMAT | |
| 1230 #define INTX_FORMAT INT32_FORMAT | |
| 1231 #define SIZE_FORMAT UINT32_FORMAT | |
| 1232 #define SSIZE_FORMAT INT32_FORMAT | |
| 1233 #endif // _LP64 | |
| 1234 | |
| 1235 #define INTPTR_FORMAT PTR_FORMAT | |
| 1236 | |
| 1237 // Enable zap-a-lot if in debug version. | |
| 1238 | |
| 1239 # ifdef ASSERT | |
| 1240 # ifdef COMPILER2 | |
| 1241 # define ENABLE_ZAP_DEAD_LOCALS | |
| 1242 #endif /* COMPILER2 */ | |
| 1243 # endif /* ASSERT */ | |
| 1244 | |
| 1245 #define ARRAY_SIZE(array) (sizeof(array)/sizeof((array)[0])) | |
| 1972 | 1246 |
| 1247 #endif // SHARE_VM_UTILITIES_GLOBALDEFINITIONS_HPP |