Mercurial > hg > truffle
annotate src/share/vm/utilities/globalDefinitions.cpp @ 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 | 8a02ca5e5576 |
| children | 8e47bac5643a |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
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:
196
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
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:
196
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "runtime/os.hpp" | |
| 27 #include "utilities/globalDefinitions.hpp" | |
| 28 #include "utilities/top.hpp" | |
| 29 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
30 // Basic error support |
| 0 | 31 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
32 // Info for oops within a java object. Defaults are zero so |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
33 // things will break badly if incorrectly initialized. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
34 int heapOopSize = 0; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
35 int LogBytesPerHeapOop = 0; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
36 int LogBitsPerHeapOop = 0; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
37 int BytesPerHeapOop = 0; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
38 int BitsPerHeapOop = 0; |
| 0 | 39 |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
40 // Object alignment, in units of HeapWords. |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
41 // Defaults are -1 so things will break badly if incorrectly initialized. |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
42 int MinObjAlignment = -1; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
43 int MinObjAlignmentInBytes = -1; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
44 int MinObjAlignmentInBytesMask = 0; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
45 |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
46 int LogMinObjAlignment = -1; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
47 int LogMinObjAlignmentInBytes = -1; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
48 |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
49 // Oop encoding heap max |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
50 uint64_t OopEncodingHeapMax = 0; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
196
diff
changeset
|
51 |
| 0 | 52 void basic_fatal(const char* msg) { |
| 53 fatal(msg); | |
| 54 } | |
| 55 | |
| 56 // Something to help porters sleep at night | |
| 57 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
58 void basic_types_init() { |
| 0 | 59 #ifdef ASSERT |
| 60 #ifdef _LP64 | |
| 61 assert(min_intx == (intx)CONST64(0x8000000000000000), "correct constant"); | |
| 62 assert(max_intx == CONST64(0x7FFFFFFFFFFFFFFF), "correct constant"); | |
| 63 assert(max_uintx == CONST64(0xFFFFFFFFFFFFFFFF), "correct constant"); | |
| 64 assert( 8 == sizeof( intx), "wrong size for basic type"); | |
| 65 assert( 8 == sizeof( jobject), "wrong size for basic type"); | |
| 66 #else | |
| 67 assert(min_intx == (intx)0x80000000, "correct constant"); | |
| 68 assert(max_intx == 0x7FFFFFFF, "correct constant"); | |
| 69 assert(max_uintx == 0xFFFFFFFF, "correct constant"); | |
| 70 assert( 4 == sizeof( intx), "wrong size for basic type"); | |
| 71 assert( 4 == sizeof( jobject), "wrong size for basic type"); | |
| 72 #endif | |
| 73 assert( (~max_juint) == 0, "max_juint has all its bits"); | |
| 74 assert( (~max_uintx) == 0, "max_uintx has all its bits"); | |
| 75 assert( (~max_julong) == 0, "max_julong has all its bits"); | |
| 76 assert( 1 == sizeof( jbyte), "wrong size for basic type"); | |
| 77 assert( 2 == sizeof( jchar), "wrong size for basic type"); | |
| 78 assert( 2 == sizeof( jshort), "wrong size for basic type"); | |
| 79 assert( 4 == sizeof( juint), "wrong size for basic type"); | |
| 80 assert( 4 == sizeof( jint), "wrong size for basic type"); | |
| 81 assert( 1 == sizeof( jboolean), "wrong size for basic type"); | |
| 82 assert( 8 == sizeof( jlong), "wrong size for basic type"); | |
| 83 assert( 4 == sizeof( jfloat), "wrong size for basic type"); | |
| 84 assert( 8 == sizeof( jdouble), "wrong size for basic type"); | |
| 85 assert( 1 == sizeof( u1), "wrong size for basic type"); | |
| 86 assert( 2 == sizeof( u2), "wrong size for basic type"); | |
| 87 assert( 4 == sizeof( u4), "wrong size for basic type"); | |
| 88 | |
| 89 int num_type_chars = 0; | |
| 90 for (int i = 0; i < 99; i++) { | |
| 91 if (type2char((BasicType)i) != 0) { | |
| 92 assert(char2type(type2char((BasicType)i)) == i, "proper inverses"); | |
| 93 num_type_chars++; | |
| 94 } | |
| 95 } | |
| 96 assert(num_type_chars == 11, "must have tested the right number of mappings"); | |
| 97 assert(char2type(0) == T_ILLEGAL, "correct illegality"); | |
| 98 | |
| 99 { | |
| 100 for (int i = T_BOOLEAN; i <= T_CONFLICT; i++) { | |
| 101 BasicType vt = (BasicType)i; | |
| 102 BasicType ft = type2field[vt]; | |
| 103 switch (vt) { | |
| 104 // the following types might plausibly show up in memory layouts: | |
| 105 case T_BOOLEAN: | |
| 106 case T_BYTE: | |
| 107 case T_CHAR: | |
| 108 case T_SHORT: | |
| 109 case T_INT: | |
| 110 case T_FLOAT: | |
| 111 case T_DOUBLE: | |
| 112 case T_LONG: | |
| 113 case T_OBJECT: | |
| 114 case T_ADDRESS: // random raw pointer | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
115 case T_METADATA: // metadata pointer |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
116 case T_NARROWOOP: // compressed pointer |
| 0 | 117 case T_CONFLICT: // might as well support a bottom type |
| 118 case T_VOID: // padding or other unaddressed word | |
| 119 // layout type must map to itself | |
| 120 assert(vt == ft, ""); | |
| 121 break; | |
| 122 default: | |
| 123 // non-layout type must map to a (different) layout type | |
| 124 assert(vt != ft, ""); | |
| 125 assert(ft == type2field[ft], ""); | |
| 126 } | |
| 127 // every type must map to same-sized layout type: | |
| 128 assert(type2size[vt] == type2size[ft], ""); | |
| 129 } | |
| 130 } | |
| 131 // These are assumed, e.g., when filling HeapWords with juints. | |
| 132 assert(is_power_of_2(sizeof(juint)), "juint must be power of 2"); | |
| 133 assert(is_power_of_2(HeapWordSize), "HeapWordSize must be power of 2"); | |
| 134 assert((size_t)HeapWordSize >= sizeof(juint), | |
| 135 "HeapWord should be at least as large as juint"); | |
| 136 assert(sizeof(NULL) == sizeof(char*), "NULL must be same size as pointer"); | |
| 137 #endif | |
| 138 | |
| 139 if( JavaPriority1_To_OSPriority != -1 ) | |
| 140 os::java_to_os_priority[1] = JavaPriority1_To_OSPriority; | |
| 141 if( JavaPriority2_To_OSPriority != -1 ) | |
| 142 os::java_to_os_priority[2] = JavaPriority2_To_OSPriority; | |
| 143 if( JavaPriority3_To_OSPriority != -1 ) | |
| 144 os::java_to_os_priority[3] = JavaPriority3_To_OSPriority; | |
| 145 if( JavaPriority4_To_OSPriority != -1 ) | |
| 146 os::java_to_os_priority[4] = JavaPriority4_To_OSPriority; | |
| 147 if( JavaPriority5_To_OSPriority != -1 ) | |
| 148 os::java_to_os_priority[5] = JavaPriority5_To_OSPriority; | |
| 149 if( JavaPriority6_To_OSPriority != -1 ) | |
| 150 os::java_to_os_priority[6] = JavaPriority6_To_OSPriority; | |
| 151 if( JavaPriority7_To_OSPriority != -1 ) | |
| 152 os::java_to_os_priority[7] = JavaPriority7_To_OSPriority; | |
| 153 if( JavaPriority8_To_OSPriority != -1 ) | |
| 154 os::java_to_os_priority[8] = JavaPriority8_To_OSPriority; | |
| 155 if( JavaPriority9_To_OSPriority != -1 ) | |
| 156 os::java_to_os_priority[9] = JavaPriority9_To_OSPriority; | |
| 157 if(JavaPriority10_To_OSPriority != -1 ) | |
| 158 os::java_to_os_priority[10] = JavaPriority10_To_OSPriority; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
159 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
160 // Set the size of basic types here (after argument parsing but before |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
161 // stub generation). |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
162 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
163 // Size info for oops within java objects is fixed |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
164 heapOopSize = jintSize; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
165 LogBytesPerHeapOop = LogBytesPerInt; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
166 LogBitsPerHeapOop = LogBitsPerInt; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
167 BytesPerHeapOop = BytesPerInt; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
168 BitsPerHeapOop = BitsPerInt; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
169 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
170 heapOopSize = oopSize; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
171 LogBytesPerHeapOop = LogBytesPerWord; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
172 LogBitsPerHeapOop = LogBitsPerWord; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
173 BytesPerHeapOop = BytesPerWord; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
174 BitsPerHeapOop = BitsPerWord; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
175 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
176 _type2aelembytes[T_OBJECT] = heapOopSize; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
177 _type2aelembytes[T_ARRAY] = heapOopSize; |
| 0 | 178 } |
| 179 | |
| 180 | |
| 181 // Map BasicType to signature character | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
182 char type2char_tab[T_CONFLICT+1]={ 0, 0, 0, 0, 'Z', 'C', 'F', 'D', 'B', 'S', 'I', 'J', 'L', '[', 'V', 0, 0, 0, 0}; |
| 0 | 183 |
| 184 // Map BasicType to Java type name | |
| 185 const char* type2name_tab[T_CONFLICT+1] = { | |
| 186 NULL, NULL, NULL, NULL, | |
| 187 "boolean", | |
| 188 "char", | |
| 189 "float", | |
| 190 "double", | |
| 191 "byte", | |
| 192 "short", | |
| 193 "int", | |
| 194 "long", | |
| 195 "object", | |
| 196 "array", | |
| 197 "void", | |
| 198 "*address*", | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
199 "*narrowoop*", |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
200 "*metadata*", |
| 0 | 201 "*conflict*" |
| 202 }; | |
| 203 | |
| 204 | |
| 205 BasicType name2type(const char* name) { | |
| 206 for (int i = T_BOOLEAN; i <= T_VOID; i++) { | |
| 207 BasicType t = (BasicType)i; | |
| 208 if (type2name_tab[t] != NULL && 0 == strcmp(type2name_tab[t], name)) | |
| 209 return t; | |
| 210 } | |
| 211 return T_ILLEGAL; | |
| 212 } | |
| 213 | |
| 214 | |
| 215 // Map BasicType to size in words | |
|
6739
8a02ca5e5576
7195816: NPG: Crash in c1_ValueType - ShouldNotReachHere
roland
parents:
6725
diff
changeset
|
216 int type2size[T_CONFLICT+1]={ -1, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, -1}; |
| 0 | 217 |
| 218 BasicType type2field[T_CONFLICT+1] = { | |
| 219 (BasicType)0, // 0, | |
| 220 (BasicType)0, // 1, | |
| 221 (BasicType)0, // 2, | |
| 222 (BasicType)0, // 3, | |
| 223 T_BOOLEAN, // T_BOOLEAN = 4, | |
| 224 T_CHAR, // T_CHAR = 5, | |
| 225 T_FLOAT, // T_FLOAT = 6, | |
| 226 T_DOUBLE, // T_DOUBLE = 7, | |
| 227 T_BYTE, // T_BYTE = 8, | |
| 228 T_SHORT, // T_SHORT = 9, | |
| 229 T_INT, // T_INT = 10, | |
| 230 T_LONG, // T_LONG = 11, | |
| 231 T_OBJECT, // T_OBJECT = 12, | |
| 232 T_OBJECT, // T_ARRAY = 13, | |
| 233 T_VOID, // T_VOID = 14, | |
| 234 T_ADDRESS, // T_ADDRESS = 15, | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
235 T_NARROWOOP, // T_NARROWOOP= 16, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
236 T_METADATA, // T_METADATA = 17, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
237 T_CONFLICT // T_CONFLICT = 18, |
| 0 | 238 }; |
| 239 | |
| 240 | |
| 241 BasicType type2wfield[T_CONFLICT+1] = { | |
| 242 (BasicType)0, // 0, | |
| 243 (BasicType)0, // 1, | |
| 244 (BasicType)0, // 2, | |
| 245 (BasicType)0, // 3, | |
| 246 T_INT, // T_BOOLEAN = 4, | |
| 247 T_INT, // T_CHAR = 5, | |
| 248 T_FLOAT, // T_FLOAT = 6, | |
| 249 T_DOUBLE, // T_DOUBLE = 7, | |
| 250 T_INT, // T_BYTE = 8, | |
| 251 T_INT, // T_SHORT = 9, | |
| 252 T_INT, // T_INT = 10, | |
| 253 T_LONG, // T_LONG = 11, | |
| 254 T_OBJECT, // T_OBJECT = 12, | |
| 255 T_OBJECT, // T_ARRAY = 13, | |
| 256 T_VOID, // T_VOID = 14, | |
| 257 T_ADDRESS, // T_ADDRESS = 15, | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
258 T_NARROWOOP, // T_NARROWOOP = 16, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
259 T_METADATA, // T_METADATA = 17, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
260 T_CONFLICT // T_CONFLICT = 18, |
| 0 | 261 }; |
| 262 | |
| 263 | |
|
29
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
264 int _type2aelembytes[T_CONFLICT+1] = { |
| 0 | 265 0, // 0 |
| 266 0, // 1 | |
| 267 0, // 2 | |
| 268 0, // 3 | |
| 269 T_BOOLEAN_aelem_bytes, // T_BOOLEAN = 4, | |
| 270 T_CHAR_aelem_bytes, // T_CHAR = 5, | |
| 271 T_FLOAT_aelem_bytes, // T_FLOAT = 6, | |
| 272 T_DOUBLE_aelem_bytes, // T_DOUBLE = 7, | |
| 273 T_BYTE_aelem_bytes, // T_BYTE = 8, | |
| 274 T_SHORT_aelem_bytes, // T_SHORT = 9, | |
| 275 T_INT_aelem_bytes, // T_INT = 10, | |
| 276 T_LONG_aelem_bytes, // T_LONG = 11, | |
| 277 T_OBJECT_aelem_bytes, // T_OBJECT = 12, | |
| 278 T_ARRAY_aelem_bytes, // T_ARRAY = 13, | |
| 279 0, // T_VOID = 14, | |
|
29
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
280 T_OBJECT_aelem_bytes, // T_ADDRESS = 15, |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
281 T_NARROWOOP_aelem_bytes,// T_NARROWOOP= 16, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
282 T_OBJECT_aelem_bytes, // T_METADATA = 17, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
283 0 // T_CONFLICT = 18, |
| 0 | 284 }; |
| 285 | |
|
29
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
286 #ifdef ASSERT |
|
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
287 int type2aelembytes(BasicType t, bool allow_address) { |
|
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
288 assert(allow_address || t != T_ADDRESS, " "); |
|
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
289 return _type2aelembytes[t]; |
|
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
290 } |
|
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
291 #endif |
| 0 | 292 |
| 293 // Support for 64-bit integer arithmetic | |
| 294 | |
| 295 // The following code is mostly taken from JVM typedefs_md.h and system_md.c | |
| 296 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
29
diff
changeset
|
297 static const jlong high_bit = (jlong)1 << (jlong)63; |
| 0 | 298 static const jlong other_bits = ~high_bit; |
| 299 | |
| 300 jlong float2long(jfloat f) { | |
| 301 jlong tmp = (jlong) f; | |
| 302 if (tmp != high_bit) { | |
| 303 return tmp; | |
| 304 } else { | |
| 305 if (g_isnan((jdouble)f)) { | |
| 306 return 0; | |
| 307 } | |
| 308 if (f < 0) { | |
| 309 return high_bit; | |
| 310 } else { | |
| 311 return other_bits; | |
| 312 } | |
| 313 } | |
| 314 } | |
| 315 | |
| 316 | |
| 317 jlong double2long(jdouble f) { | |
| 318 jlong tmp = (jlong) f; | |
| 319 if (tmp != high_bit) { | |
| 320 return tmp; | |
| 321 } else { | |
| 322 if (g_isnan(f)) { | |
| 323 return 0; | |
| 324 } | |
| 325 if (f < 0) { | |
| 326 return high_bit; | |
| 327 } else { | |
| 328 return other_bits; | |
| 329 } | |
| 330 } | |
| 331 } | |
| 332 | |
| 333 // least common multiple | |
| 334 size_t lcm(size_t a, size_t b) { | |
| 335 size_t cur, div, next; | |
| 336 | |
| 337 cur = MAX2(a, b); | |
| 338 div = MIN2(a, b); | |
| 339 | |
| 340 assert(div != 0, "lcm requires positive arguments"); | |
| 341 | |
| 342 | |
| 343 while ((next = cur % div) != 0) { | |
| 344 cur = div; div = next; | |
| 345 } | |
| 346 | |
| 347 | |
| 348 julong result = julong(a) * b / div; | |
| 349 assert(result <= (size_t)max_uintx, "Integer overflow in lcm"); | |
| 350 | |
| 351 return size_t(result); | |
| 352 } |