Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/universe.hpp @ 1721:413ad0331a0c
6977924: Changes for 6975078 produce build error with certain gcc versions
Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error.
Reviewed-by: jcoomes, ysr, phh
| author | johnc |
|---|---|
| date | Wed, 18 Aug 2010 10:59:06 -0700 |
| parents | c18cbe5936b8 |
| children | 3b2dea75431e |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1080
diff
changeset
|
2 * Copyright (c) 1997, 2009, 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:
1080
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1080
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:
1080
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 25 // Universe is a name space holding known system classes and objects in the VM. | |
| 26 // | |
| 27 // Loaded classes are accessible through the SystemDictionary. | |
| 28 // | |
| 29 // The object heap is allocated and accessed through Universe, and various allocation | |
| 30 // support is provided. Allocation by the interpreter and compiled code is done inline | |
| 31 // and bails out to Scavenge::invoke_and_allocate. | |
| 32 | |
| 33 class CollectedHeap; | |
| 34 class DeferredObjAllocEvent; | |
| 35 | |
| 36 | |
| 37 // Common parts of a methodOop cache. This cache safely interacts with | |
| 38 // the RedefineClasses API. | |
| 39 // | |
| 40 class CommonMethodOopCache : public CHeapObj { | |
| 41 // We save the klassOop and the idnum of methodOop in order to get | |
| 42 // the current cached methodOop. | |
| 43 private: | |
| 44 klassOop _klass; | |
| 45 int _method_idnum; | |
| 46 | |
| 47 public: | |
| 48 CommonMethodOopCache() { _klass = NULL; _method_idnum = -1; } | |
| 49 ~CommonMethodOopCache() { _klass = NULL; _method_idnum = -1; } | |
| 50 | |
| 51 void init(klassOop k, methodOop m, TRAPS); | |
| 52 klassOop klass() const { return _klass; } | |
| 53 int method_idnum() const { return _method_idnum; } | |
| 54 | |
| 55 // GC support | |
| 56 void oops_do(OopClosure* f) { f->do_oop((oop*)&_klass); } | |
| 57 }; | |
| 58 | |
| 59 | |
| 60 // A helper class for caching a methodOop when the user of the cache | |
| 61 // cares about all versions of the methodOop. | |
| 62 // | |
| 63 class ActiveMethodOopsCache : public CommonMethodOopCache { | |
| 64 // This subclass adds weak references to older versions of the | |
| 65 // methodOop and a query method for a methodOop. | |
| 66 | |
| 67 private: | |
| 68 // If the cached methodOop has not been redefined, then | |
| 69 // _prev_methods will be NULL. If all of the previous | |
| 70 // versions of the method have been collected, then | |
| 71 // _prev_methods can have a length of zero. | |
| 72 GrowableArray<jweak>* _prev_methods; | |
| 73 | |
| 74 public: | |
| 75 ActiveMethodOopsCache() { _prev_methods = NULL; } | |
| 76 ~ActiveMethodOopsCache(); | |
| 77 | |
| 78 void add_previous_version(const methodOop method); | |
| 79 bool is_same_method(const methodOop method) const; | |
| 80 }; | |
| 81 | |
| 82 | |
| 83 // A helper class for caching a methodOop when the user of the cache | |
| 84 // only cares about the latest version of the methodOop. | |
| 85 // | |
| 86 class LatestMethodOopCache : public CommonMethodOopCache { | |
| 87 // This subclass adds a getter method for the latest methodOop. | |
| 88 | |
| 89 public: | |
| 90 methodOop get_methodOop(); | |
| 91 }; | |
| 92 | |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
93 // For UseCompressedOops. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
94 struct NarrowOopStruct { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
95 // Base address for oop-within-java-object materialization. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
96 // NULL if using wide oops or zero based narrow oops. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
97 address _base; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
98 // Number of shift bits for encoding/decoding narrow oops. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
99 // 0 if using wide oops or zero based unscaled narrow oops, |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
100 // LogMinObjAlignmentInBytes otherwise. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
101 int _shift; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
102 // Generate code with implicit null checks for narrow oops. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
103 bool _use_implicit_null_checks; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
104 }; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
105 |
| 0 | 106 |
| 107 class Universe: AllStatic { | |
|
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
196
diff
changeset
|
108 // Ugh. Universe is much too friendly. |
| 0 | 109 friend class MarkSweep; |
| 110 friend class oopDesc; | |
| 111 friend class ClassLoader; | |
| 112 friend class Arguments; | |
| 113 friend class SystemDictionary; | |
| 114 friend class VMStructs; | |
| 115 friend class CompactingPermGenGen; | |
| 116 friend class VM_PopulateDumpSharedSpace; | |
| 117 | |
| 118 friend jint universe_init(); | |
| 119 friend void universe2_init(); | |
| 120 friend bool universe_post_init(); | |
| 121 | |
| 122 private: | |
| 123 // Known classes in the VM | |
| 124 static klassOop _boolArrayKlassObj; | |
| 125 static klassOop _byteArrayKlassObj; | |
| 126 static klassOop _charArrayKlassObj; | |
| 127 static klassOop _intArrayKlassObj; | |
| 128 static klassOop _shortArrayKlassObj; | |
| 129 static klassOop _longArrayKlassObj; | |
| 130 static klassOop _singleArrayKlassObj; | |
| 131 static klassOop _doubleArrayKlassObj; | |
| 132 static klassOop _typeArrayKlassObjs[T_VOID+1]; | |
| 133 | |
| 134 static klassOop _objectArrayKlassObj; | |
| 135 | |
| 136 static klassOop _symbolKlassObj; | |
| 137 static klassOop _methodKlassObj; | |
| 138 static klassOop _constMethodKlassObj; | |
| 139 static klassOop _methodDataKlassObj; | |
| 140 static klassOop _klassKlassObj; | |
| 141 static klassOop _arrayKlassKlassObj; | |
| 142 static klassOop _objArrayKlassKlassObj; | |
| 143 static klassOop _typeArrayKlassKlassObj; | |
| 144 static klassOop _instanceKlassKlassObj; | |
| 145 static klassOop _constantPoolKlassObj; | |
| 146 static klassOop _constantPoolCacheKlassObj; | |
| 147 static klassOop _compiledICHolderKlassObj; | |
| 148 static klassOop _systemObjArrayKlassObj; | |
| 149 | |
| 150 // Known objects in the VM | |
| 151 | |
| 152 // Primitive objects | |
| 153 static oop _int_mirror; | |
| 154 static oop _float_mirror; | |
| 155 static oop _double_mirror; | |
| 156 static oop _byte_mirror; | |
| 157 static oop _bool_mirror; | |
| 158 static oop _char_mirror; | |
| 159 static oop _long_mirror; | |
| 160 static oop _short_mirror; | |
| 161 static oop _void_mirror; | |
| 162 | |
| 163 static oop _main_thread_group; // Reference to the main thread group object | |
| 164 static oop _system_thread_group; // Reference to the system thread group object | |
| 165 | |
| 166 static typeArrayOop _the_empty_byte_array; // Canonicalized byte array | |
| 167 static typeArrayOop _the_empty_short_array; // Canonicalized short array | |
| 168 static typeArrayOop _the_empty_int_array; // Canonicalized int array | |
| 169 static objArrayOop _the_empty_system_obj_array; // Canonicalized system obj array | |
| 170 static objArrayOop _the_empty_class_klass_array; // Canonicalized obj array of type java.lang.Class | |
| 171 static objArrayOop _the_array_interfaces_array; // Canonicalized 2-array of cloneable & serializable klasses | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
860
diff
changeset
|
172 static oop _the_null_string; // A cache of "null" as a Java string |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
860
diff
changeset
|
173 static oop _the_min_jint_string; // A cache of "-2147483648" as a Java string |
| 0 | 174 static LatestMethodOopCache* _finalizer_register_cache; // static method for registering finalizable objects |
| 175 static LatestMethodOopCache* _loader_addClass_cache; // method for registering loaded classes in class loader vector | |
| 176 static ActiveMethodOopsCache* _reflect_invoke_cache; // method for security checks | |
| 177 static oop _out_of_memory_error_java_heap; // preallocated error object (no backtrace) | |
| 178 static oop _out_of_memory_error_perm_gen; // preallocated error object (no backtrace) | |
| 179 static oop _out_of_memory_error_array_size;// preallocated error object (no backtrace) | |
| 180 static oop _out_of_memory_error_gc_overhead_limit; // preallocated error object (no backtrace) | |
| 181 | |
| 182 // array of preallocated error objects with backtrace | |
| 183 static objArrayOop _preallocated_out_of_memory_error_array; | |
| 184 | |
| 185 // number of preallocated error objects available for use | |
| 186 static volatile jint _preallocated_out_of_memory_error_avail_count; | |
| 187 | |
| 188 static oop _null_ptr_exception_instance; // preallocated exception object | |
| 189 static oop _arithmetic_exception_instance; // preallocated exception object | |
| 190 static oop _virtual_machine_error_instance; // preallocated exception object | |
| 191 // The object used as an exception dummy when exceptions are thrown for | |
| 192 // the vm thread. | |
| 193 static oop _vm_exception; | |
| 194 | |
| 195 static oop _emptySymbol; // Canonical empty string ("") symbol | |
| 196 | |
| 197 // The particular choice of collected heap. | |
| 198 static CollectedHeap* _collectedHeap; | |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
199 |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
200 // For UseCompressedOops. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
201 static struct NarrowOopStruct _narrow_oop; |
| 0 | 202 |
| 203 // array of dummy objects used with +FullGCAlot | |
| 204 debug_only(static objArrayOop _fullgc_alot_dummy_array;) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
205 // index of next entry to clear |
| 0 | 206 debug_only(static int _fullgc_alot_dummy_next;) |
| 207 | |
| 208 // Compiler/dispatch support | |
| 209 static int _base_vtable_size; // Java vtbl size of klass Object (in words) | |
| 210 | |
| 211 // Initialization | |
| 212 static bool _bootstrapping; // true during genesis | |
| 213 static bool _fully_initialized; // true after universe_init and initialize_vtables called | |
| 214 | |
| 215 // the array of preallocated errors with backtraces | |
| 216 static objArrayOop preallocated_out_of_memory_errors() { return _preallocated_out_of_memory_error_array; } | |
| 217 | |
| 218 // generate an out of memory error; if possible using an error with preallocated backtrace; | |
| 219 // otherwise return the given default error. | |
| 220 static oop gen_out_of_memory_error(oop default_err); | |
| 221 | |
| 222 // Historic gc information | |
| 223 static size_t _heap_capacity_at_last_gc; | |
| 224 static size_t _heap_used_at_last_gc; | |
| 225 | |
| 226 static jint initialize_heap(); | |
| 227 static void initialize_basic_type_mirrors(TRAPS); | |
| 228 static void fixup_mirrors(TRAPS); | |
| 229 | |
| 230 static void reinitialize_vtable_of(KlassHandle h_k, TRAPS); | |
| 231 static void reinitialize_itables(TRAPS); | |
| 232 static void compute_base_vtable_size(); // compute vtable size of class Object | |
| 233 | |
| 234 static void genesis(TRAPS); // Create the initial world | |
| 235 | |
| 236 // Mirrors for primitive classes (created eagerly) | |
| 237 static oop check_mirror(oop m) { | |
| 238 assert(m != NULL, "mirror not initialized"); | |
| 239 return m; | |
| 240 } | |
| 241 | |
| 242 // Debugging | |
| 243 static int _verify_count; // number of verifies done | |
| 244 // True during call to verify(). Should only be set/cleared in verify(). | |
| 245 static bool _verify_in_progress; | |
| 246 | |
| 247 static void compute_verify_oop_data(); | |
| 248 | |
| 249 public: | |
| 250 // Known classes in the VM | |
| 251 static klassOop boolArrayKlassObj() { return _boolArrayKlassObj; } | |
| 252 static klassOop byteArrayKlassObj() { return _byteArrayKlassObj; } | |
| 253 static klassOop charArrayKlassObj() { return _charArrayKlassObj; } | |
| 254 static klassOop intArrayKlassObj() { return _intArrayKlassObj; } | |
| 255 static klassOop shortArrayKlassObj() { return _shortArrayKlassObj; } | |
| 256 static klassOop longArrayKlassObj() { return _longArrayKlassObj; } | |
| 257 static klassOop singleArrayKlassObj() { return _singleArrayKlassObj; } | |
| 258 static klassOop doubleArrayKlassObj() { return _doubleArrayKlassObj; } | |
| 259 | |
| 260 static klassOop objectArrayKlassObj() { | |
| 261 return _objectArrayKlassObj; | |
| 262 } | |
| 263 | |
| 264 static klassOop typeArrayKlassObj(BasicType t) { | |
| 265 assert((uint)t < T_VOID+1, "range check"); | |
| 266 assert(_typeArrayKlassObjs[t] != NULL, "domain check"); | |
| 267 return _typeArrayKlassObjs[t]; | |
| 268 } | |
| 269 | |
| 270 static klassOop symbolKlassObj() { return _symbolKlassObj; } | |
| 271 static klassOop methodKlassObj() { return _methodKlassObj; } | |
| 272 static klassOop constMethodKlassObj() { return _constMethodKlassObj; } | |
| 273 static klassOop methodDataKlassObj() { return _methodDataKlassObj; } | |
| 274 static klassOop klassKlassObj() { return _klassKlassObj; } | |
| 275 static klassOop arrayKlassKlassObj() { return _arrayKlassKlassObj; } | |
| 276 static klassOop objArrayKlassKlassObj() { return _objArrayKlassKlassObj; } | |
| 277 static klassOop typeArrayKlassKlassObj() { return _typeArrayKlassKlassObj; } | |
| 278 static klassOop instanceKlassKlassObj() { return _instanceKlassKlassObj; } | |
| 279 static klassOop constantPoolKlassObj() { return _constantPoolKlassObj; } | |
| 280 static klassOop constantPoolCacheKlassObj() { return _constantPoolCacheKlassObj; } | |
| 281 static klassOop compiledICHolderKlassObj() { return _compiledICHolderKlassObj; } | |
| 282 static klassOop systemObjArrayKlassObj() { return _systemObjArrayKlassObj; } | |
| 283 | |
| 284 // Known objects in tbe VM | |
| 285 static oop int_mirror() { return check_mirror(_int_mirror); | |
| 286 } | |
| 287 static oop float_mirror() { return check_mirror(_float_mirror); } | |
| 288 static oop double_mirror() { return check_mirror(_double_mirror); } | |
| 289 static oop byte_mirror() { return check_mirror(_byte_mirror); } | |
| 290 static oop bool_mirror() { return check_mirror(_bool_mirror); } | |
| 291 static oop char_mirror() { return check_mirror(_char_mirror); } | |
| 292 static oop long_mirror() { return check_mirror(_long_mirror); } | |
| 293 static oop short_mirror() { return check_mirror(_short_mirror); } | |
| 294 static oop void_mirror() { return check_mirror(_void_mirror); } | |
| 295 | |
| 296 // table of same | |
| 297 static oop _mirrors[T_VOID+1]; | |
| 298 | |
| 299 static oop java_mirror(BasicType t) { | |
| 300 assert((uint)t < T_VOID+1, "range check"); | |
| 301 return check_mirror(_mirrors[t]); | |
| 302 } | |
| 303 static oop main_thread_group() { return _main_thread_group; } | |
| 304 static void set_main_thread_group(oop group) { _main_thread_group = group;} | |
| 305 | |
| 306 static oop system_thread_group() { return _system_thread_group; } | |
| 307 static void set_system_thread_group(oop group) { _system_thread_group = group;} | |
| 308 | |
| 309 static typeArrayOop the_empty_byte_array() { return _the_empty_byte_array; } | |
| 310 static typeArrayOop the_empty_short_array() { return _the_empty_short_array; } | |
| 311 static typeArrayOop the_empty_int_array() { return _the_empty_int_array; } | |
| 312 static objArrayOop the_empty_system_obj_array () { return _the_empty_system_obj_array; } | |
| 313 static objArrayOop the_empty_class_klass_array () { return _the_empty_class_klass_array; } | |
| 314 static objArrayOop the_array_interfaces_array() { return _the_array_interfaces_array; } | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
860
diff
changeset
|
315 static oop the_null_string() { return _the_null_string; } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
860
diff
changeset
|
316 static oop the_min_jint_string() { return _the_min_jint_string; } |
| 0 | 317 static methodOop finalizer_register_method() { return _finalizer_register_cache->get_methodOop(); } |
| 318 static methodOop loader_addClass_method() { return _loader_addClass_cache->get_methodOop(); } | |
| 319 static ActiveMethodOopsCache* reflect_invoke_cache() { return _reflect_invoke_cache; } | |
| 320 static oop null_ptr_exception_instance() { return _null_ptr_exception_instance; } | |
| 321 static oop arithmetic_exception_instance() { return _arithmetic_exception_instance; } | |
| 322 static oop virtual_machine_error_instance() { return _virtual_machine_error_instance; } | |
| 323 static oop vm_exception() { return _vm_exception; } | |
| 324 static oop emptySymbol() { return _emptySymbol; } | |
| 325 | |
| 326 // OutOfMemoryError support. Returns an error with the required message. The returned error | |
| 327 // may or may not have a backtrace. If error has a backtrace then the stack trace is already | |
| 328 // filled in. | |
| 329 static oop out_of_memory_error_java_heap() { return gen_out_of_memory_error(_out_of_memory_error_java_heap); } | |
| 330 static oop out_of_memory_error_perm_gen() { return gen_out_of_memory_error(_out_of_memory_error_perm_gen); } | |
| 331 static oop out_of_memory_error_array_size() { return gen_out_of_memory_error(_out_of_memory_error_array_size); } | |
| 332 static oop out_of_memory_error_gc_overhead_limit() { return gen_out_of_memory_error(_out_of_memory_error_gc_overhead_limit); } | |
| 333 | |
| 334 // Accessors needed for fast allocation | |
| 335 static klassOop* boolArrayKlassObj_addr() { return &_boolArrayKlassObj; } | |
| 336 static klassOop* byteArrayKlassObj_addr() { return &_byteArrayKlassObj; } | |
| 337 static klassOop* charArrayKlassObj_addr() { return &_charArrayKlassObj; } | |
| 338 static klassOop* intArrayKlassObj_addr() { return &_intArrayKlassObj; } | |
| 339 static klassOop* shortArrayKlassObj_addr() { return &_shortArrayKlassObj; } | |
| 340 static klassOop* longArrayKlassObj_addr() { return &_longArrayKlassObj; } | |
| 341 static klassOop* singleArrayKlassObj_addr() { return &_singleArrayKlassObj; } | |
| 342 static klassOop* doubleArrayKlassObj_addr() { return &_doubleArrayKlassObj; } | |
| 343 | |
| 344 // The particular choice of collected heap. | |
| 345 static CollectedHeap* heap() { return _collectedHeap; } | |
| 346 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
347 // For UseCompressedOops |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
348 static address* narrow_oop_base_addr() { return &_narrow_oop._base; } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
349 static address narrow_oop_base() { return _narrow_oop._base; } |
| 858 | 350 static bool is_narrow_oop_base(void* addr) { return (narrow_oop_base() == (address)addr); } |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
351 static int narrow_oop_shift() { return _narrow_oop._shift; } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
352 static void set_narrow_oop_base(address base) { _narrow_oop._base = base; } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
353 static void set_narrow_oop_shift(int shift) { _narrow_oop._shift = shift; } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
354 static bool narrow_oop_use_implicit_null_checks() { return _narrow_oop._use_implicit_null_checks; } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
355 static void set_narrow_oop_use_implicit_null_checks(bool use) { _narrow_oop._use_implicit_null_checks = use; } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
356 // Narrow Oop encoding mode: |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
357 // 0 - Use 32-bits oops without encoding when |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
358 // NarrowOopHeapBaseMin + heap_size < 4Gb |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
359 // 1 - Use zero based compressed oops with encoding when |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
360 // NarrowOopHeapBaseMin + heap_size < 32Gb |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
361 // 2 - Use compressed oops with heap base + encoding. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
362 enum NARROW_OOP_MODE { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
363 UnscaledNarrowOop = 0, |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
364 ZeroBasedNarrowOop = 1, |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
365 HeapBasedNarrowOop = 2 |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
366 }; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
367 static char* preferred_heap_base(size_t heap_size, NARROW_OOP_MODE mode); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
368 |
| 0 | 369 // Historic gc information |
| 370 static size_t get_heap_capacity_at_last_gc() { return _heap_capacity_at_last_gc; } | |
| 371 static size_t get_heap_free_at_last_gc() { return _heap_capacity_at_last_gc - _heap_used_at_last_gc; } | |
| 372 static size_t get_heap_used_at_last_gc() { return _heap_used_at_last_gc; } | |
| 373 static void update_heap_info_at_gc(); | |
| 374 | |
| 375 // Testers | |
| 376 static bool is_bootstrapping() { return _bootstrapping; } | |
| 377 static bool is_fully_initialized() { return _fully_initialized; } | |
| 378 | |
| 379 static inline bool element_type_should_be_aligned(BasicType type); | |
| 380 static inline bool field_type_should_be_aligned(BasicType type); | |
| 381 static bool on_page_boundary(void* addr); | |
| 382 static bool should_fill_in_stack_trace(Handle throwable); | |
| 383 static void check_alignment(uintx size, uintx alignment, const char* name); | |
| 384 | |
| 385 // Finalizer support. | |
| 386 static void run_finalizers_on_exit(); | |
| 387 | |
| 388 // Iteration | |
| 389 | |
| 390 // Apply "f" to the addresses of all the direct heap pointers maintained | |
| 391 // as static fields of "Universe". | |
| 392 static void oops_do(OopClosure* f, bool do_all = false); | |
| 393 | |
| 394 // Apply "f" to all klasses for basic types (classes not present in | |
| 395 // SystemDictionary). | |
| 396 static void basic_type_classes_do(void f(klassOop)); | |
| 397 | |
| 398 // Apply "f" to all system klasses (classes not present in SystemDictionary). | |
| 399 static void system_classes_do(void f(klassOop)); | |
| 400 | |
| 401 // For sharing -- fill in a list of known vtable pointers. | |
| 402 static void init_self_patching_vtbl_list(void** list, int count); | |
| 403 | |
| 404 // Debugging | |
| 405 static bool verify_in_progress() { return _verify_in_progress; } | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
647
diff
changeset
|
406 static void verify(bool allow_dirty = true, bool silent = false, bool option = true); |
| 0 | 407 static int verify_count() { return _verify_count; } |
| 408 static void print(); | |
| 409 static void print_on(outputStream* st); | |
| 410 static void print_heap_at_SIGBREAK(); | |
| 411 static void print_heap_before_gc() { print_heap_before_gc(gclog_or_tty); } | |
| 412 static void print_heap_after_gc() { print_heap_after_gc(gclog_or_tty); } | |
| 413 static void print_heap_before_gc(outputStream* st); | |
| 414 static void print_heap_after_gc(outputStream* st); | |
| 415 | |
| 416 // Change the number of dummy objects kept reachable by the full gc dummy | |
| 417 // array; this should trigger relocation in a sliding compaction collector. | |
| 418 debug_only(static bool release_fullgc_alot_dummy();) | |
| 419 // The non-oop pattern (see compiledIC.hpp, etc) | |
| 420 static void* non_oop_word(); | |
| 421 | |
| 422 // Oop verification (see MacroAssembler::verify_oop) | |
| 423 static uintptr_t verify_oop_mask() PRODUCT_RETURN0; | |
| 424 static uintptr_t verify_oop_bits() PRODUCT_RETURN0; | |
| 425 static uintptr_t verify_mark_bits() PRODUCT_RETURN0; | |
| 426 static uintptr_t verify_mark_mask() PRODUCT_RETURN0; | |
| 427 static uintptr_t verify_klass_mask() PRODUCT_RETURN0; | |
| 428 static uintptr_t verify_klass_bits() PRODUCT_RETURN0; | |
| 429 | |
| 430 // Flushing and deoptimization | |
| 431 static void flush_dependents_on(instanceKlassHandle dependee); | |
| 432 #ifdef HOTSWAP | |
| 433 // Flushing and deoptimization in case of evolution | |
| 434 static void flush_evol_dependents_on(instanceKlassHandle dependee); | |
| 435 #endif // HOTSWAP | |
| 436 // Support for fullspeed debugging | |
| 437 static void flush_dependents_on_method(methodHandle dependee); | |
| 438 | |
| 439 // Compiler support | |
| 440 static int base_vtable_size() { return _base_vtable_size; } | |
| 441 }; | |
| 442 | |
| 443 class DeferredObjAllocEvent : public CHeapObj { | |
| 444 private: | |
| 445 oop _oop; | |
| 446 size_t _bytesize; | |
| 447 jint _arena_id; | |
| 448 | |
| 449 public: | |
| 450 DeferredObjAllocEvent(const oop o, const size_t s, const jint id) { | |
| 451 _oop = o; | |
| 452 _bytesize = s; | |
| 453 _arena_id = id; | |
| 454 } | |
| 455 | |
| 456 ~DeferredObjAllocEvent() { | |
| 457 } | |
| 458 | |
| 459 jint arena_id() { return _arena_id; } | |
| 460 size_t bytesize() { return _bytesize; } | |
| 461 oop get_oop() { return _oop; } | |
| 462 }; |