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