Mercurial > hg > truffle
comparison src/share/vm/memory/universe.hpp @ 6725:da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes
Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland
Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
author | coleenp |
---|---|
date | Sat, 01 Sep 2012 13:25:18 -0400 |
parents | 24b9c7f4cae6 |
children | 2a48c84f1d04 |
comparison
equal
deleted
inserted
replaced
6724:36d1d483d5d6 | 6725:da91efe96a93 |
---|---|
24 | 24 |
25 #ifndef SHARE_VM_MEMORY_UNIVERSE_HPP | 25 #ifndef SHARE_VM_MEMORY_UNIVERSE_HPP |
26 #define SHARE_VM_MEMORY_UNIVERSE_HPP | 26 #define SHARE_VM_MEMORY_UNIVERSE_HPP |
27 | 27 |
28 #include "runtime/handles.hpp" | 28 #include "runtime/handles.hpp" |
29 #include "utilities/array.hpp" | |
29 #include "utilities/growableArray.hpp" | 30 #include "utilities/growableArray.hpp" |
30 | 31 |
31 // Universe is a name space holding known system classes and objects in the VM. | 32 // Universe is a name space holding known system classes and objects in the VM. |
32 // | 33 // |
33 // Loaded classes are accessible through the SystemDictionary. | 34 // Loaded classes are accessible through the SystemDictionary. |
38 | 39 |
39 class CollectedHeap; | 40 class CollectedHeap; |
40 class DeferredObjAllocEvent; | 41 class DeferredObjAllocEvent; |
41 | 42 |
42 | 43 |
43 // Common parts of a methodOop cache. This cache safely interacts with | 44 // Common parts of a Method* cache. This cache safely interacts with |
44 // the RedefineClasses API. | 45 // the RedefineClasses API. |
45 // | 46 // |
46 class CommonMethodOopCache : public CHeapObj<mtClass> { | 47 class CommonMethodOopCache : public CHeapObj<mtClass> { |
47 // We save the klassOop and the idnum of methodOop in order to get | 48 // We save the Klass* and the idnum of Method* in order to get |
48 // the current cached methodOop. | 49 // the current cached Method*. |
49 private: | 50 private: |
50 klassOop _klass; | 51 Klass* _klass; |
51 int _method_idnum; | 52 int _method_idnum; |
52 | 53 |
53 public: | 54 public: |
54 CommonMethodOopCache() { _klass = NULL; _method_idnum = -1; } | 55 CommonMethodOopCache() { _klass = NULL; _method_idnum = -1; } |
55 ~CommonMethodOopCache() { _klass = NULL; _method_idnum = -1; } | 56 ~CommonMethodOopCache() { _klass = NULL; _method_idnum = -1; } |
56 | 57 |
57 void init(klassOop k, methodOop m, TRAPS); | 58 void init(Klass* k, Method* m, TRAPS); |
58 klassOop klass() const { return _klass; } | 59 Klass* klass() const { return _klass; } |
59 int method_idnum() const { return _method_idnum; } | 60 int method_idnum() const { return _method_idnum; } |
60 | 61 |
61 // GC support | 62 // Enhanced Class Redefinition support |
62 void oops_do(OopClosure* f) { f->do_oop((oop*)&_klass); } | 63 void classes_do(void f(Klass*)) { |
63 }; | 64 f(_klass); |
64 | 65 } |
65 | 66 |
66 // A helper class for caching a methodOop when the user of the cache | 67 // CDS support. Replace the klass in this with the archive version |
67 // cares about all versions of the methodOop. | 68 // could use this for Enhanced Class Redefinition also. |
69 void serialize(SerializeClosure* f) { | |
70 f->do_ptr((void**)&_klass); | |
71 } | |
72 }; | |
73 | |
74 | |
75 // A helper class for caching a Method* when the user of the cache | |
76 // cares about all versions of the Method*. | |
68 // | 77 // |
69 class ActiveMethodOopsCache : public CommonMethodOopCache { | 78 class ActiveMethodOopsCache : public CommonMethodOopCache { |
70 // This subclass adds weak references to older versions of the | 79 // This subclass adds weak references to older versions of the |
71 // methodOop and a query method for a methodOop. | 80 // Method* and a query method for a Method*. |
72 | 81 |
73 private: | 82 private: |
74 // If the cached methodOop has not been redefined, then | 83 // If the cached Method* has not been redefined, then |
75 // _prev_methods will be NULL. If all of the previous | 84 // _prev_methods will be NULL. If all of the previous |
76 // versions of the method have been collected, then | 85 // versions of the method have been collected, then |
77 // _prev_methods can have a length of zero. | 86 // _prev_methods can have a length of zero. |
78 GrowableArray<jweak>* _prev_methods; | 87 GrowableArray<Method*>* _prev_methods; |
79 | 88 |
80 public: | 89 public: |
81 ActiveMethodOopsCache() { _prev_methods = NULL; } | 90 ActiveMethodOopsCache() { _prev_methods = NULL; } |
82 ~ActiveMethodOopsCache(); | 91 ~ActiveMethodOopsCache(); |
83 | 92 |
84 void add_previous_version(const methodOop method); | 93 void add_previous_version(Method* const method); |
85 bool is_same_method(const methodOop method) const; | 94 bool is_same_method(Method* const method) const; |
86 }; | 95 }; |
87 | 96 |
88 | 97 |
89 // A helper class for caching a methodOop when the user of the cache | 98 // A helper class for caching a Method* when the user of the cache |
90 // only cares about the latest version of the methodOop. | 99 // only cares about the latest version of the Method*. |
91 // | 100 // |
92 class LatestMethodOopCache : public CommonMethodOopCache { | 101 class LatestMethodOopCache : public CommonMethodOopCache { |
93 // This subclass adds a getter method for the latest methodOop. | 102 // This subclass adds a getter method for the latest Method*. |
94 | 103 |
95 public: | 104 public: |
96 methodOop get_methodOop(); | 105 Method* get_Method(); |
97 }; | 106 }; |
98 | 107 |
99 // For UseCompressedOops. | 108 // For UseCompressedOops. |
100 struct NarrowOopStruct { | 109 struct NarrowOopStruct { |
101 // Base address for oop-within-java-object materialization. | 110 // Base address for oop-within-java-object materialization. |
124 friend class oopDesc; | 133 friend class oopDesc; |
125 friend class ClassLoader; | 134 friend class ClassLoader; |
126 friend class Arguments; | 135 friend class Arguments; |
127 friend class SystemDictionary; | 136 friend class SystemDictionary; |
128 friend class VMStructs; | 137 friend class VMStructs; |
129 friend class CompactingPermGenGen; | |
130 friend class VM_PopulateDumpSharedSpace; | 138 friend class VM_PopulateDumpSharedSpace; |
131 | 139 |
132 friend jint universe_init(); | 140 friend jint universe_init(); |
133 friend void universe2_init(); | 141 friend void universe2_init(); |
134 friend bool universe_post_init(); | 142 friend bool universe_post_init(); |
135 | 143 |
136 private: | 144 private: |
137 // Known classes in the VM | 145 // Known classes in the VM |
138 static klassOop _boolArrayKlassObj; | 146 static Klass* _boolArrayKlassObj; |
139 static klassOop _byteArrayKlassObj; | 147 static Klass* _byteArrayKlassObj; |
140 static klassOop _charArrayKlassObj; | 148 static Klass* _charArrayKlassObj; |
141 static klassOop _intArrayKlassObj; | 149 static Klass* _intArrayKlassObj; |
142 static klassOop _shortArrayKlassObj; | 150 static Klass* _shortArrayKlassObj; |
143 static klassOop _longArrayKlassObj; | 151 static Klass* _longArrayKlassObj; |
144 static klassOop _singleArrayKlassObj; | 152 static Klass* _singleArrayKlassObj; |
145 static klassOop _doubleArrayKlassObj; | 153 static Klass* _doubleArrayKlassObj; |
146 static klassOop _typeArrayKlassObjs[T_VOID+1]; | 154 static Klass* _typeArrayKlassObjs[T_VOID+1]; |
147 | 155 |
148 static klassOop _objectArrayKlassObj; | 156 static Klass* _objectArrayKlassObj; |
149 | |
150 static klassOop _methodKlassObj; | |
151 static klassOop _constMethodKlassObj; | |
152 static klassOop _methodDataKlassObj; | |
153 static klassOop _klassKlassObj; | |
154 static klassOop _arrayKlassKlassObj; | |
155 static klassOop _objArrayKlassKlassObj; | |
156 static klassOop _typeArrayKlassKlassObj; | |
157 static klassOop _instanceKlassKlassObj; | |
158 static klassOop _constantPoolKlassObj; | |
159 static klassOop _constantPoolCacheKlassObj; | |
160 static klassOop _compiledICHolderKlassObj; | |
161 static klassOop _systemObjArrayKlassObj; | |
162 | 157 |
163 // Known objects in the VM | 158 // Known objects in the VM |
164 | 159 |
165 // Primitive objects | 160 // Primitive objects |
166 static oop _int_mirror; | 161 static oop _int_mirror; |
174 static oop _void_mirror; | 169 static oop _void_mirror; |
175 | 170 |
176 static oop _main_thread_group; // Reference to the main thread group object | 171 static oop _main_thread_group; // Reference to the main thread group object |
177 static oop _system_thread_group; // Reference to the system thread group object | 172 static oop _system_thread_group; // Reference to the system thread group object |
178 | 173 |
179 static typeArrayOop _the_empty_byte_array; // Canonicalized byte array | |
180 static typeArrayOop _the_empty_short_array; // Canonicalized short array | |
181 static typeArrayOop _the_empty_int_array; // Canonicalized int array | |
182 static objArrayOop _the_empty_system_obj_array; // Canonicalized system obj array | |
183 static objArrayOop _the_empty_class_klass_array; // Canonicalized obj array of type java.lang.Class | 174 static objArrayOop _the_empty_class_klass_array; // Canonicalized obj array of type java.lang.Class |
184 static objArrayOop _the_array_interfaces_array; // Canonicalized 2-array of cloneable & serializable klasses | |
185 static oop _the_null_string; // A cache of "null" as a Java string | 175 static oop _the_null_string; // A cache of "null" as a Java string |
186 static oop _the_min_jint_string; // A cache of "-2147483648" as a Java string | 176 static oop _the_min_jint_string; // A cache of "-2147483648" as a Java string |
187 static LatestMethodOopCache* _finalizer_register_cache; // static method for registering finalizable objects | 177 static LatestMethodOopCache* _finalizer_register_cache; // static method for registering finalizable objects |
188 static LatestMethodOopCache* _loader_addClass_cache; // method for registering loaded classes in class loader vector | |
189 static ActiveMethodOopsCache* _reflect_invoke_cache; // method for security checks | 178 static ActiveMethodOopsCache* _reflect_invoke_cache; // method for security checks |
190 static oop _out_of_memory_error_java_heap; // preallocated error object (no backtrace) | 179 static oop _out_of_memory_error_java_heap; // preallocated error object (no backtrace) |
191 static oop _out_of_memory_error_perm_gen; // preallocated error object (no backtrace) | 180 static oop _out_of_memory_error_perm_gen; // preallocated error object (no backtrace) |
192 static oop _out_of_memory_error_array_size;// preallocated error object (no backtrace) | 181 static oop _out_of_memory_error_array_size;// preallocated error object (no backtrace) |
193 static oop _out_of_memory_error_gc_overhead_limit; // preallocated error object (no backtrace) | 182 static oop _out_of_memory_error_gc_overhead_limit; // preallocated error object (no backtrace) |
183 | |
184 static Array<int>* _the_empty_int_array; // Canonicalized int array | |
185 static Array<u2>* _the_empty_short_array; // Canonicalized short array | |
186 static Array<Klass*>* _the_empty_klass_array; // Canonicalized klass obj array | |
187 static Array<Method*>* _the_empty_method_array; // Canonicalized method obj array | |
188 | |
189 static Array<Klass*>* _the_array_interfaces_array; | |
194 | 190 |
195 // array of preallocated error objects with backtrace | 191 // array of preallocated error objects with backtrace |
196 static objArrayOop _preallocated_out_of_memory_error_array; | 192 static objArrayOop _preallocated_out_of_memory_error_array; |
197 | 193 |
198 // number of preallocated error objects available for use | 194 // number of preallocated error objects available for use |
248 static oop check_mirror(oop m) { | 244 static oop check_mirror(oop m) { |
249 assert(m != NULL, "mirror not initialized"); | 245 assert(m != NULL, "mirror not initialized"); |
250 return m; | 246 return m; |
251 } | 247 } |
252 | 248 |
253 // Debugging | |
254 static int _verify_count; // number of verifies done | |
255 // True during call to verify(). Should only be set/cleared in verify(). | |
256 static bool _verify_in_progress; | |
257 | |
258 static void compute_verify_oop_data(); | |
259 | |
260 public: | |
261 // Known classes in the VM | |
262 static klassOop boolArrayKlassObj() { return _boolArrayKlassObj; } | |
263 static klassOop byteArrayKlassObj() { return _byteArrayKlassObj; } | |
264 static klassOop charArrayKlassObj() { return _charArrayKlassObj; } | |
265 static klassOop intArrayKlassObj() { return _intArrayKlassObj; } | |
266 static klassOop shortArrayKlassObj() { return _shortArrayKlassObj; } | |
267 static klassOop longArrayKlassObj() { return _longArrayKlassObj; } | |
268 static klassOop singleArrayKlassObj() { return _singleArrayKlassObj; } | |
269 static klassOop doubleArrayKlassObj() { return _doubleArrayKlassObj; } | |
270 | |
271 static klassOop objectArrayKlassObj() { | |
272 return _objectArrayKlassObj; | |
273 } | |
274 | |
275 static klassOop typeArrayKlassObj(BasicType t) { | |
276 assert((uint)t < T_VOID+1, err_msg("range check for type: %s", type2name(t))); | |
277 assert(_typeArrayKlassObjs[t] != NULL, "domain check"); | |
278 return _typeArrayKlassObjs[t]; | |
279 } | |
280 | |
281 static klassOop methodKlassObj() { return _methodKlassObj; } | |
282 static klassOop constMethodKlassObj() { return _constMethodKlassObj; } | |
283 static klassOop methodDataKlassObj() { return _methodDataKlassObj; } | |
284 static klassOop klassKlassObj() { return _klassKlassObj; } | |
285 static klassOop arrayKlassKlassObj() { return _arrayKlassKlassObj; } | |
286 static klassOop objArrayKlassKlassObj() { return _objArrayKlassKlassObj; } | |
287 static klassOop typeArrayKlassKlassObj() { return _typeArrayKlassKlassObj; } | |
288 static klassOop instanceKlassKlassObj() { return _instanceKlassKlassObj; } | |
289 static klassOop constantPoolKlassObj() { return _constantPoolKlassObj; } | |
290 static klassOop constantPoolCacheKlassObj() { return _constantPoolCacheKlassObj; } | |
291 static klassOop compiledICHolderKlassObj() { return _compiledICHolderKlassObj; } | |
292 static klassOop systemObjArrayKlassObj() { return _systemObjArrayKlassObj; } | |
293 | |
294 // Known objects in the VM | |
295 static oop int_mirror() { return check_mirror(_int_mirror); } | |
296 static oop float_mirror() { return check_mirror(_float_mirror); } | |
297 static oop double_mirror() { return check_mirror(_double_mirror); } | |
298 static oop byte_mirror() { return check_mirror(_byte_mirror); } | |
299 static oop bool_mirror() { return check_mirror(_bool_mirror); } | |
300 static oop char_mirror() { return check_mirror(_char_mirror); } | |
301 static oop long_mirror() { return check_mirror(_long_mirror); } | |
302 static oop short_mirror() { return check_mirror(_short_mirror); } | |
303 static oop void_mirror() { return check_mirror(_void_mirror); } | |
304 | |
305 // table of same | |
306 static oop _mirrors[T_VOID+1]; | |
307 | |
308 static oop java_mirror(BasicType t) { | |
309 assert((uint)t < T_VOID+1, "range check"); | |
310 return check_mirror(_mirrors[t]); | |
311 } | |
312 static oop main_thread_group() { return _main_thread_group; } | |
313 static void set_main_thread_group(oop group) { _main_thread_group = group;} | |
314 | |
315 static oop system_thread_group() { return _system_thread_group; } | |
316 static void set_system_thread_group(oop group) { _system_thread_group = group;} | |
317 | |
318 static typeArrayOop the_empty_byte_array() { return _the_empty_byte_array; } | |
319 static typeArrayOop the_empty_short_array() { return _the_empty_short_array; } | |
320 static typeArrayOop the_empty_int_array() { return _the_empty_int_array; } | |
321 static objArrayOop the_empty_system_obj_array () { return _the_empty_system_obj_array; } | |
322 static objArrayOop the_empty_class_klass_array () { return _the_empty_class_klass_array; } | |
323 static objArrayOop the_array_interfaces_array() { return _the_array_interfaces_array; } | |
324 static oop the_null_string() { return _the_null_string; } | |
325 static oop the_min_jint_string() { return _the_min_jint_string; } | |
326 static methodOop finalizer_register_method() { return _finalizer_register_cache->get_methodOop(); } | |
327 static methodOop loader_addClass_method() { return _loader_addClass_cache->get_methodOop(); } | |
328 static ActiveMethodOopsCache* reflect_invoke_cache() { return _reflect_invoke_cache; } | |
329 static oop null_ptr_exception_instance() { return _null_ptr_exception_instance; } | |
330 static oop arithmetic_exception_instance() { return _arithmetic_exception_instance; } | |
331 static oop virtual_machine_error_instance() { return _virtual_machine_error_instance; } | |
332 static oop vm_exception() { return _vm_exception; } | |
333 | |
334 // OutOfMemoryError support. Returns an error with the required message. The returned error | |
335 // may or may not have a backtrace. If error has a backtrace then the stack trace is already | |
336 // filled in. | |
337 static oop out_of_memory_error_java_heap() { return gen_out_of_memory_error(_out_of_memory_error_java_heap); } | |
338 static oop out_of_memory_error_perm_gen() { return gen_out_of_memory_error(_out_of_memory_error_perm_gen); } | |
339 static oop out_of_memory_error_array_size() { return gen_out_of_memory_error(_out_of_memory_error_array_size); } | |
340 static oop out_of_memory_error_gc_overhead_limit() { return gen_out_of_memory_error(_out_of_memory_error_gc_overhead_limit); } | |
341 | |
342 // Accessors needed for fast allocation | |
343 static klassOop* boolArrayKlassObj_addr() { return &_boolArrayKlassObj; } | |
344 static klassOop* byteArrayKlassObj_addr() { return &_byteArrayKlassObj; } | |
345 static klassOop* charArrayKlassObj_addr() { return &_charArrayKlassObj; } | |
346 static klassOop* intArrayKlassObj_addr() { return &_intArrayKlassObj; } | |
347 static klassOop* shortArrayKlassObj_addr() { return &_shortArrayKlassObj; } | |
348 static klassOop* longArrayKlassObj_addr() { return &_longArrayKlassObj; } | |
349 static klassOop* singleArrayKlassObj_addr() { return &_singleArrayKlassObj; } | |
350 static klassOop* doubleArrayKlassObj_addr() { return &_doubleArrayKlassObj; } | |
351 static klassOop* systemObjArrayKlassObj_addr() { return &_systemObjArrayKlassObj; } | |
352 | |
353 // The particular choice of collected heap. | |
354 static CollectedHeap* heap() { return _collectedHeap; } | |
355 | |
356 // For UseCompressedOops | |
357 static address* narrow_oop_base_addr() { return &_narrow_oop._base; } | |
358 static address narrow_oop_base() { return _narrow_oop._base; } | |
359 static bool is_narrow_oop_base(void* addr) { return (narrow_oop_base() == (address)addr); } | |
360 static int narrow_oop_shift() { return _narrow_oop._shift; } | |
361 static void set_narrow_oop_base(address base) { _narrow_oop._base = base; } | |
362 static void set_narrow_oop_shift(int shift) { _narrow_oop._shift = shift; } | |
363 static bool narrow_oop_use_implicit_null_checks() { return _narrow_oop._use_implicit_null_checks; } | |
364 static void set_narrow_oop_use_implicit_null_checks(bool use) { _narrow_oop._use_implicit_null_checks = use; } | |
365 // Narrow Oop encoding mode: | 249 // Narrow Oop encoding mode: |
366 // 0 - Use 32-bits oops without encoding when | 250 // 0 - Use 32-bits oops without encoding when |
367 // NarrowOopHeapBaseMin + heap_size < 4Gb | 251 // NarrowOopHeapBaseMin + heap_size < 4Gb |
368 // 1 - Use zero based compressed oops with encoding when | 252 // 1 - Use zero based compressed oops with encoding when |
369 // NarrowOopHeapBaseMin + heap_size < 32Gb | 253 // NarrowOopHeapBaseMin + heap_size < 32Gb |
371 enum NARROW_OOP_MODE { | 255 enum NARROW_OOP_MODE { |
372 UnscaledNarrowOop = 0, | 256 UnscaledNarrowOop = 0, |
373 ZeroBasedNarrowOop = 1, | 257 ZeroBasedNarrowOop = 1, |
374 HeapBasedNarrowOop = 2 | 258 HeapBasedNarrowOop = 2 |
375 }; | 259 }; |
376 static char* preferred_heap_base(size_t heap_size, NARROW_OOP_MODE mode); | 260 static char* preferred_heap_base(size_t heap_size, NARROW_OOP_MODE mode); |
261 static void set_narrow_oop_base(address base) { _narrow_oop._base = base; } | |
262 static void set_narrow_oop_use_implicit_null_checks(bool use) { _narrow_oop._use_implicit_null_checks = use; } | |
263 | |
264 // Debugging | |
265 static int _verify_count; // number of verifies done | |
266 // True during call to verify(). Should only be set/cleared in verify(). | |
267 static bool _verify_in_progress; | |
268 | |
269 static void compute_verify_oop_data(); | |
270 | |
271 public: | |
272 // Known classes in the VM | |
273 static Klass* boolArrayKlassObj() { return _boolArrayKlassObj; } | |
274 static Klass* byteArrayKlassObj() { return _byteArrayKlassObj; } | |
275 static Klass* charArrayKlassObj() { return _charArrayKlassObj; } | |
276 static Klass* intArrayKlassObj() { return _intArrayKlassObj; } | |
277 static Klass* shortArrayKlassObj() { return _shortArrayKlassObj; } | |
278 static Klass* longArrayKlassObj() { return _longArrayKlassObj; } | |
279 static Klass* singleArrayKlassObj() { return _singleArrayKlassObj; } | |
280 static Klass* doubleArrayKlassObj() { return _doubleArrayKlassObj; } | |
281 | |
282 static Klass* objectArrayKlassObj() { | |
283 return _objectArrayKlassObj; | |
284 } | |
285 | |
286 static Klass* typeArrayKlassObj(BasicType t) { | |
287 assert((uint)t < T_VOID+1, err_msg("range check for type: %s", type2name(t))); | |
288 assert(_typeArrayKlassObjs[t] != NULL, "domain check"); | |
289 return _typeArrayKlassObjs[t]; | |
290 } | |
291 | |
292 // Known objects in the VM | |
293 static oop int_mirror() { return check_mirror(_int_mirror); } | |
294 static oop float_mirror() { return check_mirror(_float_mirror); } | |
295 static oop double_mirror() { return check_mirror(_double_mirror); } | |
296 static oop byte_mirror() { return check_mirror(_byte_mirror); } | |
297 static oop bool_mirror() { return check_mirror(_bool_mirror); } | |
298 static oop char_mirror() { return check_mirror(_char_mirror); } | |
299 static oop long_mirror() { return check_mirror(_long_mirror); } | |
300 static oop short_mirror() { return check_mirror(_short_mirror); } | |
301 static oop void_mirror() { return check_mirror(_void_mirror); } | |
302 | |
303 // table of same | |
304 static oop _mirrors[T_VOID+1]; | |
305 | |
306 static oop java_mirror(BasicType t) { | |
307 assert((uint)t < T_VOID+1, "range check"); | |
308 return check_mirror(_mirrors[t]); | |
309 } | |
310 static oop main_thread_group() { return _main_thread_group; } | |
311 static void set_main_thread_group(oop group) { _main_thread_group = group;} | |
312 | |
313 static oop system_thread_group() { return _system_thread_group; } | |
314 static void set_system_thread_group(oop group) { _system_thread_group = group;} | |
315 | |
316 static objArrayOop the_empty_class_klass_array () { return _the_empty_class_klass_array; } | |
317 static Array<Klass*>* the_array_interfaces_array() { return _the_array_interfaces_array; } | |
318 static oop the_null_string() { return _the_null_string; } | |
319 static oop the_min_jint_string() { return _the_min_jint_string; } | |
320 static Method* finalizer_register_method() { return _finalizer_register_cache->get_Method(); } | |
321 static ActiveMethodOopsCache* reflect_invoke_cache() { return _reflect_invoke_cache; } | |
322 static oop null_ptr_exception_instance() { return _null_ptr_exception_instance; } | |
323 static oop arithmetic_exception_instance() { return _arithmetic_exception_instance; } | |
324 static oop virtual_machine_error_instance() { return _virtual_machine_error_instance; } | |
325 static oop vm_exception() { return _vm_exception; } | |
326 | |
327 static Array<int>* the_empty_int_array() { return _the_empty_int_array; } | |
328 static Array<u2>* the_empty_short_array() { return _the_empty_short_array; } | |
329 static Array<Method*>* the_empty_method_array() { return _the_empty_method_array; } | |
330 static Array<Klass*>* the_empty_klass_array() { return _the_empty_klass_array; } | |
331 | |
332 // OutOfMemoryError support. Returns an error with the required message. The returned error | |
333 // may or may not have a backtrace. If error has a backtrace then the stack trace is already | |
334 // filled in. | |
335 static oop out_of_memory_error_java_heap() { return gen_out_of_memory_error(_out_of_memory_error_java_heap); } | |
336 static oop out_of_memory_error_perm_gen() { return gen_out_of_memory_error(_out_of_memory_error_perm_gen); } | |
337 static oop out_of_memory_error_array_size() { return gen_out_of_memory_error(_out_of_memory_error_array_size); } | |
338 static oop out_of_memory_error_gc_overhead_limit() { return gen_out_of_memory_error(_out_of_memory_error_gc_overhead_limit); } | |
339 | |
340 // Accessors needed for fast allocation | |
341 static Klass** boolArrayKlassObj_addr() { return &_boolArrayKlassObj; } | |
342 static Klass** byteArrayKlassObj_addr() { return &_byteArrayKlassObj; } | |
343 static Klass** charArrayKlassObj_addr() { return &_charArrayKlassObj; } | |
344 static Klass** intArrayKlassObj_addr() { return &_intArrayKlassObj; } | |
345 static Klass** shortArrayKlassObj_addr() { return &_shortArrayKlassObj; } | |
346 static Klass** longArrayKlassObj_addr() { return &_longArrayKlassObj; } | |
347 static Klass** singleArrayKlassObj_addr() { return &_singleArrayKlassObj; } | |
348 static Klass** doubleArrayKlassObj_addr() { return &_doubleArrayKlassObj; } | |
349 static Klass** objectArrayKlassObj_addr() { return &_objectArrayKlassObj; } | |
350 | |
351 // The particular choice of collected heap. | |
352 static CollectedHeap* heap() { return _collectedHeap; } | |
353 | |
354 // For UseCompressedOops | |
355 static address* narrow_oop_base_addr() { return &_narrow_oop._base; } | |
356 static address narrow_oop_base() { return _narrow_oop._base; } | |
357 static bool is_narrow_oop_base(void* addr) { return (narrow_oop_base() == (address)addr); } | |
358 static int narrow_oop_shift() { return _narrow_oop._shift; } | |
359 static bool narrow_oop_use_implicit_null_checks() { return _narrow_oop._use_implicit_null_checks; } | |
360 | |
361 // this is set in vm_version on sparc (and then reset in universe afaict) | |
362 static void set_narrow_oop_shift(int shift) { _narrow_oop._shift = shift; } | |
363 | |
364 // Reserve Java heap and determine CompressedOops mode | |
365 static ReservedSpace reserve_heap(size_t heap_size, size_t alignment); | |
377 | 366 |
378 // Historic gc information | 367 // Historic gc information |
379 static size_t get_heap_capacity_at_last_gc() { return _heap_capacity_at_last_gc; } | 368 static size_t get_heap_capacity_at_last_gc() { return _heap_capacity_at_last_gc; } |
380 static size_t get_heap_free_at_last_gc() { return _heap_capacity_at_last_gc - _heap_used_at_last_gc; } | 369 static size_t get_heap_free_at_last_gc() { return _heap_capacity_at_last_gc - _heap_used_at_last_gc; } |
381 static size_t get_heap_used_at_last_gc() { return _heap_used_at_last_gc; } | 370 static size_t get_heap_used_at_last_gc() { return _heap_used_at_last_gc; } |
398 | 387 |
399 // Apply "f" to the addresses of all the direct heap pointers maintained | 388 // Apply "f" to the addresses of all the direct heap pointers maintained |
400 // as static fields of "Universe". | 389 // as static fields of "Universe". |
401 static void oops_do(OopClosure* f, bool do_all = false); | 390 static void oops_do(OopClosure* f, bool do_all = false); |
402 | 391 |
392 // CDS support | |
393 static void serialize(SerializeClosure* f, bool do_all = false); | |
394 | |
403 // Apply "f" to all klasses for basic types (classes not present in | 395 // Apply "f" to all klasses for basic types (classes not present in |
404 // SystemDictionary). | 396 // SystemDictionary). |
405 static void basic_type_classes_do(void f(klassOop)); | 397 static void basic_type_classes_do(void f(Klass*)); |
406 | |
407 // Apply "f" to all system klasses (classes not present in SystemDictionary). | |
408 static void system_classes_do(void f(klassOop)); | |
409 | 398 |
410 // For sharing -- fill in a list of known vtable pointers. | 399 // For sharing -- fill in a list of known vtable pointers. |
411 static void init_self_patching_vtbl_list(void** list, int count); | 400 static void init_self_patching_vtbl_list(void** list, int count); |
412 | 401 |
413 // Debugging | 402 // Debugging |
436 // Oop verification (see MacroAssembler::verify_oop) | 425 // Oop verification (see MacroAssembler::verify_oop) |
437 static uintptr_t verify_oop_mask() PRODUCT_RETURN0; | 426 static uintptr_t verify_oop_mask() PRODUCT_RETURN0; |
438 static uintptr_t verify_oop_bits() PRODUCT_RETURN0; | 427 static uintptr_t verify_oop_bits() PRODUCT_RETURN0; |
439 static uintptr_t verify_mark_bits() PRODUCT_RETURN0; | 428 static uintptr_t verify_mark_bits() PRODUCT_RETURN0; |
440 static uintptr_t verify_mark_mask() PRODUCT_RETURN0; | 429 static uintptr_t verify_mark_mask() PRODUCT_RETURN0; |
441 static uintptr_t verify_klass_mask() PRODUCT_RETURN0; | |
442 static uintptr_t verify_klass_bits() PRODUCT_RETURN0; | |
443 | 430 |
444 // Flushing and deoptimization | 431 // Flushing and deoptimization |
445 static void flush_dependents_on(instanceKlassHandle dependee); | 432 static void flush_dependents_on(instanceKlassHandle dependee); |
446 static void flush_dependents_on(Handle call_site, Handle method_handle); | 433 static void flush_dependents_on(Handle call_site, Handle method_handle); |
447 #ifdef HOTSWAP | 434 #ifdef HOTSWAP |