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