graal-compiler: src/share/vm/memory/universe.hpp annotate

annotate src/share/vm/memory/universe.hpp @ 10186:b06ac540229e

8013132: Add a flag to turn off the output of the verbose verification code Reviewed-by: johnc, brutisso

author	stefank
date	Wed, 24 Apr 2013 20:13:37 +0200
parents	10d5f25a7c67
children	92ef81e2f571 7ee0d5c53c78

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
7982 10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6866 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	25 #ifndef SHARE_VM_MEMORY_UNIVERSE_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	26 #define SHARE_VM_MEMORY_UNIVERSE_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	28 #include "runtime/handles.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	29 #include "utilities/array.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	30 #include "utilities/growableArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	31
0 a61af66fc99e Initial load duke parents: diff changeset	32 // Universe is a name space holding known system classes and objects in the VM.
a61af66fc99e Initial load duke parents: diff changeset	33 //
a61af66fc99e Initial load duke parents: diff changeset	34 // Loaded classes are accessible through the SystemDictionary.
a61af66fc99e Initial load duke parents: diff changeset	35 //
a61af66fc99e Initial load duke parents: diff changeset	36 // The object heap is allocated and accessed through Universe, and various allocation
a61af66fc99e Initial load duke parents: diff changeset	37 // support is provided. Allocation by the interpreter and compiled code is done inline
a61af66fc99e Initial load duke parents: diff changeset	38 // and bails out to Scavenge::invoke_and_allocate.
a61af66fc99e Initial load duke parents: diff changeset	39
a61af66fc99e Initial load duke parents: diff changeset	40 class CollectedHeap;
a61af66fc99e Initial load duke parents: diff changeset	41 class DeferredObjAllocEvent;
a61af66fc99e Initial load duke parents: diff changeset	42
a61af66fc99e Initial load duke parents: diff changeset	43
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	44 // Common parts of a Method* cache. This cache safely interacts with
0 a61af66fc99e Initial load duke parents: diff changeset	45 // the RedefineClasses API.
a61af66fc99e Initial load duke parents: diff changeset	46 //
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6008 diff changeset	47 class CommonMethodOopCache : public CHeapObj<mtClass> {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	48 // We save the Klass* and the idnum of Method* in order to get
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	49 // the current cached Method*.
0 a61af66fc99e Initial load duke parents: diff changeset	50 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	51 Klass* _klass;
0 a61af66fc99e Initial load duke parents: diff changeset	52 int _method_idnum;
a61af66fc99e Initial load duke parents: diff changeset	53
a61af66fc99e Initial load duke parents: diff changeset	54 public:
a61af66fc99e Initial load duke parents: diff changeset	55 CommonMethodOopCache() { _klass = NULL; _method_idnum = -1; }
a61af66fc99e Initial load duke parents: diff changeset	56 ~CommonMethodOopCache() { _klass = NULL; _method_idnum = -1; }
a61af66fc99e Initial load duke parents: diff changeset	57
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	58 void init(Klass* k, Method* m, TRAPS);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	59 Klass* klass() const { return _klass; }
0 a61af66fc99e Initial load duke parents: diff changeset	60 int method_idnum() const { return _method_idnum; }
a61af66fc99e Initial load duke parents: diff changeset	61
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	62 // Enhanced Class Redefinition support
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	63 void classes_do(void f(Klass*)) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	64 f(_klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	65 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	66
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	67 // CDS support. Replace the klass in this with the archive version
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	68 // could use this for Enhanced Class Redefinition also.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	69 void serialize(SerializeClosure* f) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	70 f->do_ptr((void**)&_klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	71 }
0 a61af66fc99e Initial load duke parents: diff changeset	72 };
a61af66fc99e Initial load duke parents: diff changeset	73
a61af66fc99e Initial load duke parents: diff changeset	74
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	75 // A helper class for caching a Method* when the user of the cache
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	76 // cares about all versions of the Method*.
0 a61af66fc99e Initial load duke parents: diff changeset	77 //
a61af66fc99e Initial load duke parents: diff changeset	78 class ActiveMethodOopsCache : public CommonMethodOopCache {
a61af66fc99e Initial load duke parents: diff changeset	79 // This subclass adds weak references to older versions of the
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	80 // Method* and a query method for a Method*.
0 a61af66fc99e Initial load duke parents: diff changeset	81
a61af66fc99e Initial load duke parents: diff changeset	82 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	83 // If the cached Method* has not been redefined, then
0 a61af66fc99e Initial load duke parents: diff changeset	84 // _prev_methods will be NULL. If all of the previous
a61af66fc99e Initial load duke parents: diff changeset	85 // versions of the method have been collected, then
a61af66fc99e Initial load duke parents: diff changeset	86 // _prev_methods can have a length of zero.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	87 GrowableArray<Method> _prev_methods;
0 a61af66fc99e Initial load duke parents: diff changeset	88
a61af66fc99e Initial load duke parents: diff changeset	89 public:
a61af66fc99e Initial load duke parents: diff changeset	90 ActiveMethodOopsCache() { _prev_methods = NULL; }
a61af66fc99e Initial load duke parents: diff changeset	91 ~ActiveMethodOopsCache();
a61af66fc99e Initial load duke parents: diff changeset	92
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	93 void add_previous_version(Method* const method);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	94 bool is_same_method(Method* const method) const;
0 a61af66fc99e Initial load duke parents: diff changeset	95 };
a61af66fc99e Initial load duke parents: diff changeset	96
a61af66fc99e Initial load duke parents: diff changeset	97
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	98 // A helper class for caching a Method* when the user of the cache
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	99 // only cares about the latest version of the Method*.
0 a61af66fc99e Initial load duke parents: diff changeset	100 //
a61af66fc99e Initial load duke parents: diff changeset	101 class LatestMethodOopCache : public CommonMethodOopCache {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	102 // This subclass adds a getter method for the latest Method*.
0 a61af66fc99e Initial load duke parents: diff changeset	103
a61af66fc99e Initial load duke parents: diff changeset	104 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	105 Method* get_Method();
0 a61af66fc99e Initial load duke parents: diff changeset	106 };
a61af66fc99e Initial load duke parents: diff changeset	107
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	108 // For UseCompressedOops and UseCompressedKlassPointers.
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	109 struct NarrowPtrStruct {
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	110 // Base address for oop/klass-within-java-object materialization.
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	111 // NULL if using wide oops/klasses or zero based narrow oops/klasses.
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	112 address _base;
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	113 // Number of shift bits for encoding/decoding narrow ptrs.
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	114 // 0 if using wide ptrs or zero based unscaled narrow ptrs,
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	115 // LogMinObjAlignmentInBytes/LogKlassAlignmentInBytes otherwise.
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	116 int _shift;
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	117 // Generate code with implicit null checks for narrow ptrs.
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	118 bool _use_implicit_null_checks;
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	119 };
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	120
3772 6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	121 enum VerifyOption {
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	122 VerifyOption_Default = 0,
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	123
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	124 // G1
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	125 VerifyOption_G1UsePrevMarking = VerifyOption_Default,
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	126 VerifyOption_G1UseNextMarking = VerifyOption_G1UsePrevMarking + 1,
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	127 VerifyOption_G1UseMarkWord = VerifyOption_G1UseNextMarking + 1
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	128 };
0 a61af66fc99e Initial load duke parents: diff changeset	129
a61af66fc99e Initial load duke parents: diff changeset	130 class Universe: AllStatic {
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 196 diff changeset	131 // Ugh. Universe is much too friendly.
0 a61af66fc99e Initial load duke parents: diff changeset	132 friend class MarkSweep;
a61af66fc99e Initial load duke parents: diff changeset	133 friend class oopDesc;
a61af66fc99e Initial load duke parents: diff changeset	134 friend class ClassLoader;
a61af66fc99e Initial load duke parents: diff changeset	135 friend class Arguments;
a61af66fc99e Initial load duke parents: diff changeset	136 friend class SystemDictionary;
a61af66fc99e Initial load duke parents: diff changeset	137 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	138 friend class VM_PopulateDumpSharedSpace;
a61af66fc99e Initial load duke parents: diff changeset	139
a61af66fc99e Initial load duke parents: diff changeset	140 friend jint universe_init();
a61af66fc99e Initial load duke parents: diff changeset	141 friend void universe2_init();
a61af66fc99e Initial load duke parents: diff changeset	142 friend bool universe_post_init();
a61af66fc99e Initial load duke parents: diff changeset	143
a61af66fc99e Initial load duke parents: diff changeset	144 private:
a61af66fc99e Initial load duke parents: diff changeset	145 // Known classes in the VM
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	146 static Klass* _boolArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	147 static Klass* _byteArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	148 static Klass* _charArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	149 static Klass* _intArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	150 static Klass* _shortArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	151 static Klass* _longArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	152 static Klass* _singleArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	153 static Klass* _doubleArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	154 static Klass* _typeArrayKlassObjs[T_VOID+1];
0 a61af66fc99e Initial load duke parents: diff changeset	155
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	156 static Klass* _objectArrayKlassObj;
0 a61af66fc99e Initial load duke parents: diff changeset	157
a61af66fc99e Initial load duke parents: diff changeset	158 // Known objects in the VM
a61af66fc99e Initial load duke parents: diff changeset	159
a61af66fc99e Initial load duke parents: diff changeset	160 // Primitive objects
a61af66fc99e Initial load duke parents: diff changeset	161 static oop _int_mirror;
a61af66fc99e Initial load duke parents: diff changeset	162 static oop _float_mirror;
a61af66fc99e Initial load duke parents: diff changeset	163 static oop _double_mirror;
a61af66fc99e Initial load duke parents: diff changeset	164 static oop _byte_mirror;
a61af66fc99e Initial load duke parents: diff changeset	165 static oop _bool_mirror;
a61af66fc99e Initial load duke parents: diff changeset	166 static oop _char_mirror;
a61af66fc99e Initial load duke parents: diff changeset	167 static oop _long_mirror;
a61af66fc99e Initial load duke parents: diff changeset	168 static oop _short_mirror;
a61af66fc99e Initial load duke parents: diff changeset	169 static oop _void_mirror;
a61af66fc99e Initial load duke parents: diff changeset	170
a61af66fc99e Initial load duke parents: diff changeset	171 static oop _main_thread_group; // Reference to the main thread group object
a61af66fc99e Initial load duke parents: diff changeset	172 static oop _system_thread_group; // Reference to the system thread group object
a61af66fc99e Initial load duke parents: diff changeset	173
a61af66fc99e Initial load duke parents: diff changeset	174 static objArrayOop _the_empty_class_klass_array; // Canonicalized obj array of type java.lang.Class
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 860 diff changeset	175 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	176 static oop _the_min_jint_string; // A cache of "-2147483648" as a Java string
0 a61af66fc99e Initial load duke parents: diff changeset	177 static LatestMethodOopCache* _finalizer_register_cache; // static method for registering finalizable objects
6751 2a48c84f1d04 7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow coleenp parents: 6725 diff changeset	178 static LatestMethodOopCache* _loader_addClass_cache; // method for registering loaded classes in class loader vector
0 a61af66fc99e Initial load duke parents: diff changeset	179 static ActiveMethodOopsCache* _reflect_invoke_cache; // method for security checks
a61af66fc99e Initial load duke parents: diff changeset	180 static oop _out_of_memory_error_java_heap; // preallocated error object (no backtrace)
a61af66fc99e Initial load duke parents: diff changeset	181 static oop _out_of_memory_error_perm_gen; // preallocated error object (no backtrace)
a61af66fc99e Initial load duke parents: diff changeset	182 static oop _out_of_memory_error_array_size;// preallocated error object (no backtrace)
a61af66fc99e Initial load duke parents: diff changeset	183 static oop _out_of_memory_error_gc_overhead_limit; // preallocated error object (no backtrace)
a61af66fc99e Initial load duke parents: diff changeset	184
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	185 static Array<int>* _the_empty_int_array; // Canonicalized int array
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	186 static Array<u2>* _the_empty_short_array; // Canonicalized short array
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	187 static Array<Klass> _the_empty_klass_array; // Canonicalized klass obj array
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	188 static Array<Method> _the_empty_method_array; // Canonicalized method obj array
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	189
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	190 static Array<Klass> _the_array_interfaces_array;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	191
0 a61af66fc99e Initial load duke parents: diff changeset	192 // array of preallocated error objects with backtrace
a61af66fc99e Initial load duke parents: diff changeset	193 static objArrayOop _preallocated_out_of_memory_error_array;
a61af66fc99e Initial load duke parents: diff changeset	194
a61af66fc99e Initial load duke parents: diff changeset	195 // number of preallocated error objects available for use
a61af66fc99e Initial load duke parents: diff changeset	196 static volatile jint _preallocated_out_of_memory_error_avail_count;
a61af66fc99e Initial load duke parents: diff changeset	197
a61af66fc99e Initial load duke parents: diff changeset	198 static oop _null_ptr_exception_instance; // preallocated exception object
a61af66fc99e Initial load duke parents: diff changeset	199 static oop _arithmetic_exception_instance; // preallocated exception object
a61af66fc99e Initial load duke parents: diff changeset	200 static oop _virtual_machine_error_instance; // preallocated exception object
a61af66fc99e Initial load duke parents: diff changeset	201 // The object used as an exception dummy when exceptions are thrown for
a61af66fc99e Initial load duke parents: diff changeset	202 // the vm thread.
a61af66fc99e Initial load duke parents: diff changeset	203 static oop _vm_exception;
a61af66fc99e Initial load duke parents: diff changeset	204
a61af66fc99e Initial load duke parents: diff changeset	205 // The particular choice of collected heap.
a61af66fc99e Initial load duke parents: diff changeset	206 static CollectedHeap* _collectedHeap;
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	207
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	208 // For UseCompressedOops.
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	209 static struct NarrowPtrStruct _narrow_oop;
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	210 // For UseCompressedKlassPointers.
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	211 static struct NarrowPtrStruct _narrow_klass;
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	212 static address _narrow_ptrs_base;
0 a61af66fc99e Initial load duke parents: diff changeset	213
7982 10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6866 diff changeset	214 // Aligned size of the metaspace.
10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6866 diff changeset	215 static size_t _class_metaspace_size;
10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6866 diff changeset	216
0 a61af66fc99e Initial load duke parents: diff changeset	217 // array of dummy objects used with +FullGCAlot
a61af66fc99e Initial load duke parents: diff changeset	218 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	219 // index of next entry to clear
0 a61af66fc99e Initial load duke parents: diff changeset	220 debug_only(static int _fullgc_alot_dummy_next;)
a61af66fc99e Initial load duke parents: diff changeset	221
a61af66fc99e Initial load duke parents: diff changeset	222 // Compiler/dispatch support
a61af66fc99e Initial load duke parents: diff changeset	223 static int _base_vtable_size; // Java vtbl size of klass Object (in words)
a61af66fc99e Initial load duke parents: diff changeset	224
a61af66fc99e Initial load duke parents: diff changeset	225 // Initialization
a61af66fc99e Initial load duke parents: diff changeset	226 static bool _bootstrapping; // true during genesis
a61af66fc99e Initial load duke parents: diff changeset	227 static bool _fully_initialized; // true after universe_init and initialize_vtables called
a61af66fc99e Initial load duke parents: diff changeset	228
a61af66fc99e Initial load duke parents: diff changeset	229 // the array of preallocated errors with backtraces
a61af66fc99e Initial load duke parents: diff changeset	230 static objArrayOop preallocated_out_of_memory_errors() { return _preallocated_out_of_memory_error_array; }
a61af66fc99e Initial load duke parents: diff changeset	231
a61af66fc99e Initial load duke parents: diff changeset	232 // generate an out of memory error; if possible using an error with preallocated backtrace;
a61af66fc99e Initial load duke parents: diff changeset	233 // otherwise return the given default error.
a61af66fc99e Initial load duke parents: diff changeset	234 static oop gen_out_of_memory_error(oop default_err);
a61af66fc99e Initial load duke parents: diff changeset	235
a61af66fc99e Initial load duke parents: diff changeset	236 // Historic gc information
a61af66fc99e Initial load duke parents: diff changeset	237 static size_t _heap_capacity_at_last_gc;
a61af66fc99e Initial load duke parents: diff changeset	238 static size_t _heap_used_at_last_gc;
a61af66fc99e Initial load duke parents: diff changeset	239
a61af66fc99e Initial load duke parents: diff changeset	240 static jint initialize_heap();
a61af66fc99e Initial load duke parents: diff changeset	241 static void initialize_basic_type_mirrors(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	242 static void fixup_mirrors(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	243
a61af66fc99e Initial load duke parents: diff changeset	244 static void reinitialize_vtable_of(KlassHandle h_k, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	245 static void reinitialize_itables(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	246 static void compute_base_vtable_size(); // compute vtable size of class Object
a61af66fc99e Initial load duke parents: diff changeset	247
a61af66fc99e Initial load duke parents: diff changeset	248 static void genesis(TRAPS); // Create the initial world
a61af66fc99e Initial load duke parents: diff changeset	249
a61af66fc99e Initial load duke parents: diff changeset	250 // Mirrors for primitive classes (created eagerly)
a61af66fc99e Initial load duke parents: diff changeset	251 static oop check_mirror(oop m) {
a61af66fc99e Initial load duke parents: diff changeset	252 assert(m != NULL, "mirror not initialized");
a61af66fc99e Initial load duke parents: diff changeset	253 return m;
a61af66fc99e Initial load duke parents: diff changeset	254 }
a61af66fc99e Initial load duke parents: diff changeset	255
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	256 // Narrow Oop encoding mode:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	257 // 0 - Use 32-bits oops without encoding when
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	258 // NarrowOopHeapBaseMin + heap_size < 4Gb
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	259 // 1 - Use zero based compressed oops with encoding when
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	260 // NarrowOopHeapBaseMin + heap_size < 32Gb
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	261 // 2 - Use compressed oops with heap base + encoding.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	262 enum NARROW_OOP_MODE {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	263 UnscaledNarrowOop = 0,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	264 ZeroBasedNarrowOop = 1,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	265 HeapBasedNarrowOop = 2
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	266 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	267 static char* preferred_heap_base(size_t heap_size, NARROW_OOP_MODE mode);
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	268 static char* preferred_metaspace_base(size_t heap_size, NARROW_OOP_MODE mode);
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	269 static void set_narrow_oop_base(address base) {
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	270 assert(UseCompressedOops, "no compressed oops?");
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	271 _narrow_oop._base = base;
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	272 }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	273 static void set_narrow_klass_base(address base) {
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	274 assert(UseCompressedKlassPointers, "no compressed klass ptrs?");
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	275 _narrow_klass._base = base;
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	276 }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	277 static void set_narrow_oop_use_implicit_null_checks(bool use) {
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	278 assert(UseCompressedOops, "no compressed ptrs?");
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	279 _narrow_oop._use_implicit_null_checks = use;
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	280 }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	281 static bool reserve_metaspace_helper(bool with_base = false);
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	282 static ReservedHeapSpace reserve_heap_metaspace(size_t heap_size, size_t alignment, bool& contiguous);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	283
7982 10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6866 diff changeset	284 static size_t class_metaspace_size() {
10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6866 diff changeset	285 return _class_metaspace_size;
10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6866 diff changeset	286 }
10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6866 diff changeset	287 static void set_class_metaspace_size(size_t metaspace_size) {
10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6866 diff changeset	288 _class_metaspace_size = metaspace_size;
10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6866 diff changeset	289 }
10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6866 diff changeset	290
0 a61af66fc99e Initial load duke parents: diff changeset	291 // Debugging
a61af66fc99e Initial load duke parents: diff changeset	292 static int _verify_count; // number of verifies done
a61af66fc99e Initial load duke parents: diff changeset	293 // True during call to verify(). Should only be set/cleared in verify().
a61af66fc99e Initial load duke parents: diff changeset	294 static bool _verify_in_progress;
a61af66fc99e Initial load duke parents: diff changeset	295
a61af66fc99e Initial load duke parents: diff changeset	296 static void compute_verify_oop_data();
a61af66fc99e Initial load duke parents: diff changeset	297
a61af66fc99e Initial load duke parents: diff changeset	298 public:
a61af66fc99e Initial load duke parents: diff changeset	299 // Known classes in the VM
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	300 static Klass* boolArrayKlassObj() { return _boolArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	301 static Klass* byteArrayKlassObj() { return _byteArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	302 static Klass* charArrayKlassObj() { return _charArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	303 static Klass* intArrayKlassObj() { return _intArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	304 static Klass* shortArrayKlassObj() { return _shortArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	305 static Klass* longArrayKlassObj() { return _longArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	306 static Klass* singleArrayKlassObj() { return _singleArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	307 static Klass* doubleArrayKlassObj() { return _doubleArrayKlassObj; }
0 a61af66fc99e Initial load duke parents: diff changeset	308
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	309 static Klass* objectArrayKlassObj() {
0 a61af66fc99e Initial load duke parents: diff changeset	310 return _objectArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	311 }
a61af66fc99e Initial load duke parents: diff changeset	312
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	313 static Klass* typeArrayKlassObj(BasicType t) {
6182 765ee2d1674b 7157365: jruby/bench.bench_timeout crashes with JVM internal error twisti parents: 6008 diff changeset	314 assert((uint)t < T_VOID+1, err_msg("range check for type: %s", type2name(t)));
0 a61af66fc99e Initial load duke parents: diff changeset	315 assert(_typeArrayKlassObjs[t] != NULL, "domain check");
a61af66fc99e Initial load duke parents: diff changeset	316 return _typeArrayKlassObjs[t];
a61af66fc99e Initial load duke parents: diff changeset	317 }
a61af66fc99e Initial load duke parents: diff changeset	318
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	319 // Known objects in the VM
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	320 static oop int_mirror() { return check_mirror(_int_mirror); }
0 a61af66fc99e Initial load duke parents: diff changeset	321 static oop float_mirror() { return check_mirror(_float_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	322 static oop double_mirror() { return check_mirror(_double_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	323 static oop byte_mirror() { return check_mirror(_byte_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	324 static oop bool_mirror() { return check_mirror(_bool_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	325 static oop char_mirror() { return check_mirror(_char_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	326 static oop long_mirror() { return check_mirror(_long_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	327 static oop short_mirror() { return check_mirror(_short_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	328 static oop void_mirror() { return check_mirror(_void_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	329
a61af66fc99e Initial load duke parents: diff changeset	330 // table of same
a61af66fc99e Initial load duke parents: diff changeset	331 static oop _mirrors[T_VOID+1];
a61af66fc99e Initial load duke parents: diff changeset	332
a61af66fc99e Initial load duke parents: diff changeset	333 static oop java_mirror(BasicType t) {
a61af66fc99e Initial load duke parents: diff changeset	334 assert((uint)t < T_VOID+1, "range check");
a61af66fc99e Initial load duke parents: diff changeset	335 return check_mirror(_mirrors[t]);
a61af66fc99e Initial load duke parents: diff changeset	336 }
a61af66fc99e Initial load duke parents: diff changeset	337 static oop main_thread_group() { return _main_thread_group; }
a61af66fc99e Initial load duke parents: diff changeset	338 static void set_main_thread_group(oop group) { _main_thread_group = group;}
a61af66fc99e Initial load duke parents: diff changeset	339
a61af66fc99e Initial load duke parents: diff changeset	340 static oop system_thread_group() { return _system_thread_group; }
a61af66fc99e Initial load duke parents: diff changeset	341 static void set_system_thread_group(oop group) { _system_thread_group = group;}
a61af66fc99e Initial load duke parents: diff changeset	342
a61af66fc99e Initial load duke parents: diff changeset	343 static objArrayOop the_empty_class_klass_array () { return _the_empty_class_klass_array; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	344 static Array<Klass> the_array_interfaces_array() { return _the_array_interfaces_array; }
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 860 diff changeset	345 static oop the_null_string() { return _the_null_string; }
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 860 diff changeset	346 static oop the_min_jint_string() { return _the_min_jint_string; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	347 static Method* finalizer_register_method() { return _finalizer_register_cache->get_Method(); }
6751 2a48c84f1d04 7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow coleenp parents: 6725 diff changeset	348 static Method* loader_addClass_method() { return _loader_addClass_cache->get_Method(); }
0 a61af66fc99e Initial load duke parents: diff changeset	349 static ActiveMethodOopsCache* reflect_invoke_cache() { return _reflect_invoke_cache; }
a61af66fc99e Initial load duke parents: diff changeset	350 static oop null_ptr_exception_instance() { return _null_ptr_exception_instance; }
a61af66fc99e Initial load duke parents: diff changeset	351 static oop arithmetic_exception_instance() { return _arithmetic_exception_instance; }
a61af66fc99e Initial load duke parents: diff changeset	352 static oop virtual_machine_error_instance() { return _virtual_machine_error_instance; }
a61af66fc99e Initial load duke parents: diff changeset	353 static oop vm_exception() { return _vm_exception; }
a61af66fc99e Initial load duke parents: diff changeset	354
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	355 static Array<int>* the_empty_int_array() { return _the_empty_int_array; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	356 static Array<u2>* the_empty_short_array() { return _the_empty_short_array; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	357 static Array<Method> the_empty_method_array() { return _the_empty_method_array; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	358 static Array<Klass> the_empty_klass_array() { return _the_empty_klass_array; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	359
0 a61af66fc99e Initial load duke parents: diff changeset	360 // OutOfMemoryError support. Returns an error with the required message. The returned error
a61af66fc99e Initial load duke parents: diff changeset	361 // may or may not have a backtrace. If error has a backtrace then the stack trace is already
a61af66fc99e Initial load duke parents: diff changeset	362 // filled in.
a61af66fc99e Initial load duke parents: diff changeset	363 static oop out_of_memory_error_java_heap() { return gen_out_of_memory_error(_out_of_memory_error_java_heap); }
a61af66fc99e Initial load duke parents: diff changeset	364 static oop out_of_memory_error_perm_gen() { return gen_out_of_memory_error(_out_of_memory_error_perm_gen); }
a61af66fc99e Initial load duke parents: diff changeset	365 static oop out_of_memory_error_array_size() { return gen_out_of_memory_error(_out_of_memory_error_array_size); }
a61af66fc99e Initial load duke parents: diff changeset	366 static oop out_of_memory_error_gc_overhead_limit() { return gen_out_of_memory_error(_out_of_memory_error_gc_overhead_limit); }
a61af66fc99e Initial load duke parents: diff changeset	367
a61af66fc99e Initial load duke parents: diff changeset	368 // Accessors needed for fast allocation
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	369 static Klass** boolArrayKlassObj_addr() { return &_boolArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	370 static Klass** byteArrayKlassObj_addr() { return &_byteArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	371 static Klass** charArrayKlassObj_addr() { return &_charArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	372 static Klass** intArrayKlassObj_addr() { return &_intArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	373 static Klass** shortArrayKlassObj_addr() { return &_shortArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	374 static Klass** longArrayKlassObj_addr() { return &_longArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	375 static Klass** singleArrayKlassObj_addr() { return &_singleArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	376 static Klass** doubleArrayKlassObj_addr() { return &_doubleArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	377 static Klass** objectArrayKlassObj_addr() { return &_objectArrayKlassObj; }
0 a61af66fc99e Initial load duke parents: diff changeset	378
a61af66fc99e Initial load duke parents: diff changeset	379 // The particular choice of collected heap.
a61af66fc99e Initial load duke parents: diff changeset	380 static CollectedHeap* heap() { return _collectedHeap; }
a61af66fc99e Initial load duke parents: diff changeset	381
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	382 // For UseCompressedOops
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	383 static address narrow_oop_base() { return _narrow_oop._base; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	384 static bool is_narrow_oop_base(void* addr) { return (narrow_oop_base() == (address)addr); }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	385 static int narrow_oop_shift() { return _narrow_oop._shift; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	386 static bool narrow_oop_use_implicit_null_checks() { return _narrow_oop._use_implicit_null_checks; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	387
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	388 // For UseCompressedKlassPointers
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	389 static address narrow_klass_base() { return _narrow_klass._base; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	390 static bool is_narrow_klass_base(void* addr) { return (narrow_klass_base() == (address)addr); }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	391 static int narrow_klass_shift() { return _narrow_klass._shift; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	392 static bool narrow_klass_use_implicit_null_checks() { return _narrow_klass._use_implicit_null_checks; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	393
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	394 static address* narrow_ptrs_base_addr() { return &_narrow_ptrs_base; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	395 static void set_narrow_ptrs_base(address a) { _narrow_ptrs_base = a; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	396 static address narrow_ptrs_base() { return _narrow_ptrs_base; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	397
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	398 // this is set in vm_version on sparc (and then reset in universe afaict)
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	399 static void set_narrow_oop_shift(int shift) {
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	400 _narrow_oop._shift = shift;
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	401 }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	402
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	403 static void set_narrow_klass_shift(int shift) {
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	404 assert(shift == 0 \|\| shift == LogKlassAlignmentInBytes, "invalid shift for klass ptrs");
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	405 _narrow_klass._shift = shift;
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	406 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	407
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	408 // Reserve Java heap and determine CompressedOops mode
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	409 static ReservedSpace reserve_heap(size_t heap_size, size_t alignment);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	410
0 a61af66fc99e Initial load duke parents: diff changeset	411 // Historic gc information
a61af66fc99e Initial load duke parents: diff changeset	412 static size_t get_heap_capacity_at_last_gc() { return _heap_capacity_at_last_gc; }
a61af66fc99e Initial load duke parents: diff changeset	413 static size_t get_heap_free_at_last_gc() { return _heap_capacity_at_last_gc - _heap_used_at_last_gc; }
a61af66fc99e Initial load duke parents: diff changeset	414 static size_t get_heap_used_at_last_gc() { return _heap_used_at_last_gc; }
a61af66fc99e Initial load duke parents: diff changeset	415 static void update_heap_info_at_gc();
a61af66fc99e Initial load duke parents: diff changeset	416
a61af66fc99e Initial load duke parents: diff changeset	417 // Testers
a61af66fc99e Initial load duke parents: diff changeset	418 static bool is_bootstrapping() { return _bootstrapping; }
a61af66fc99e Initial load duke parents: diff changeset	419 static bool is_fully_initialized() { return _fully_initialized; }
a61af66fc99e Initial load duke parents: diff changeset	420
a61af66fc99e Initial load duke parents: diff changeset	421 static inline bool element_type_should_be_aligned(BasicType type);
a61af66fc99e Initial load duke parents: diff changeset	422 static inline bool field_type_should_be_aligned(BasicType type);
a61af66fc99e Initial load duke parents: diff changeset	423 static bool on_page_boundary(void* addr);
a61af66fc99e Initial load duke parents: diff changeset	424 static bool should_fill_in_stack_trace(Handle throwable);
a61af66fc99e Initial load duke parents: diff changeset	425 static void check_alignment(uintx size, uintx alignment, const char* name);
a61af66fc99e Initial load duke parents: diff changeset	426
a61af66fc99e Initial load duke parents: diff changeset	427 // Finalizer support.
a61af66fc99e Initial load duke parents: diff changeset	428 static void run_finalizers_on_exit();
a61af66fc99e Initial load duke parents: diff changeset	429
a61af66fc99e Initial load duke parents: diff changeset	430 // Iteration
a61af66fc99e Initial load duke parents: diff changeset	431
a61af66fc99e Initial load duke parents: diff changeset	432 // Apply "f" to the addresses of all the direct heap pointers maintained
a61af66fc99e Initial load duke parents: diff changeset	433 // as static fields of "Universe".
a61af66fc99e Initial load duke parents: diff changeset	434 static void oops_do(OopClosure* f, bool do_all = false);
a61af66fc99e Initial load duke parents: diff changeset	435
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	436 // CDS support
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	437 static void serialize(SerializeClosure* f, bool do_all = false);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	438
0 a61af66fc99e Initial load duke parents: diff changeset	439 // Apply "f" to all klasses for basic types (classes not present in
a61af66fc99e Initial load duke parents: diff changeset	440 // SystemDictionary).
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	441 static void basic_type_classes_do(void f(Klass*));
0 a61af66fc99e Initial load duke parents: diff changeset	442
a61af66fc99e Initial load duke parents: diff changeset	443 // For sharing -- fill in a list of known vtable pointers.
a61af66fc99e Initial load duke parents: diff changeset	444 static void init_self_patching_vtbl_list(void** list, int count);
a61af66fc99e Initial load duke parents: diff changeset	445
a61af66fc99e Initial load duke parents: diff changeset	446 // Debugging
a61af66fc99e Initial load duke parents: diff changeset	447 static bool verify_in_progress() { return _verify_in_progress; }
10186 b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 7982 diff changeset	448 static void verify(VerifyOption option, const char* prefix, bool silent = VerifySilently);
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 7982 diff changeset	449 static void verify(const char* prefix, bool silent = VerifySilently) {
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 7982 diff changeset	450 verify(VerifyOption_Default, prefix, silent);
6865 4202510ee0fe 8000831: Heap verification output incorrect/incomplete johnc parents: 6751 diff changeset	451 }
10186 b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 7982 diff changeset	452 static void verify(bool silent = VerifySilently) {
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 7982 diff changeset	453 verify("", silent);
6865 4202510ee0fe 8000831: Heap verification output incorrect/incomplete johnc parents: 6751 diff changeset	454 }
4202510ee0fe 8000831: Heap verification output incorrect/incomplete johnc parents: 6751 diff changeset	455
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3852 diff changeset	456 static int verify_count() { return _verify_count; }
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3852 diff changeset	457 // The default behavior is to call print_on() on gclog_or_tty.
0 a61af66fc99e Initial load duke parents: diff changeset	458 static void print();
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3852 diff changeset	459 // The extended parameter determines which method on the heap will
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3852 diff changeset	460 // be called: print_on() (extended == false) or print_extended_on()
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3852 diff changeset	461 // (extended == true).
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3852 diff changeset	462 static void print_on(outputStream* st, bool extended = false);
0 a61af66fc99e Initial load duke parents: diff changeset	463 static void print_heap_at_SIGBREAK();
a61af66fc99e Initial load duke parents: diff changeset	464 static void print_heap_before_gc() { print_heap_before_gc(gclog_or_tty); }
a61af66fc99e Initial load duke parents: diff changeset	465 static void print_heap_after_gc() { print_heap_after_gc(gclog_or_tty); }
4944 09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4073 diff changeset	466 static void print_heap_before_gc(outputStream* st, bool ignore_extended = false);
09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4073 diff changeset	467 static void print_heap_after_gc(outputStream* st, bool ignore_extended = false);
0 a61af66fc99e Initial load duke parents: diff changeset	468
a61af66fc99e Initial load duke parents: diff changeset	469 // Change the number of dummy objects kept reachable by the full gc dummy
a61af66fc99e Initial load duke parents: diff changeset	470 // array; this should trigger relocation in a sliding compaction collector.
a61af66fc99e Initial load duke parents: diff changeset	471 debug_only(static bool release_fullgc_alot_dummy();)
a61af66fc99e Initial load duke parents: diff changeset	472 // The non-oop pattern (see compiledIC.hpp, etc)
a61af66fc99e Initial load duke parents: diff changeset	473 static void* non_oop_word();
a61af66fc99e Initial load duke parents: diff changeset	474
a61af66fc99e Initial load duke parents: diff changeset	475 // Oop verification (see MacroAssembler::verify_oop)
a61af66fc99e Initial load duke parents: diff changeset	476 static uintptr_t verify_oop_mask() PRODUCT_RETURN0;
a61af66fc99e Initial load duke parents: diff changeset	477 static uintptr_t verify_oop_bits() PRODUCT_RETURN0;
a61af66fc99e Initial load duke parents: diff changeset	478 static uintptr_t verify_mark_bits() PRODUCT_RETURN0;
a61af66fc99e Initial load duke parents: diff changeset	479 static uintptr_t verify_mark_mask() PRODUCT_RETURN0;
a61af66fc99e Initial load duke parents: diff changeset	480
a61af66fc99e Initial load duke parents: diff changeset	481 // Flushing and deoptimization
a61af66fc99e Initial load duke parents: diff changeset	482 static void flush_dependents_on(instanceKlassHandle dependee);
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	483 static void flush_dependents_on(Handle call_site, Handle method_handle);
0 a61af66fc99e Initial load duke parents: diff changeset	484 #ifdef HOTSWAP
a61af66fc99e Initial load duke parents: diff changeset	485 // Flushing and deoptimization in case of evolution
a61af66fc99e Initial load duke parents: diff changeset	486 static void flush_evol_dependents_on(instanceKlassHandle dependee);
a61af66fc99e Initial load duke parents: diff changeset	487 #endif // HOTSWAP
a61af66fc99e Initial load duke parents: diff changeset	488 // Support for fullspeed debugging
a61af66fc99e Initial load duke parents: diff changeset	489 static void flush_dependents_on_method(methodHandle dependee);
a61af66fc99e Initial load duke parents: diff changeset	490
a61af66fc99e Initial load duke parents: diff changeset	491 // Compiler support
a61af66fc99e Initial load duke parents: diff changeset	492 static int base_vtable_size() { return _base_vtable_size; }
a61af66fc99e Initial load duke parents: diff changeset	493 };
a61af66fc99e Initial load duke parents: diff changeset	494
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6008 diff changeset	495 class DeferredObjAllocEvent : public CHeapObj<mtInternal> {
0 a61af66fc99e Initial load duke parents: diff changeset	496 private:
a61af66fc99e Initial load duke parents: diff changeset	497 oop _oop;
a61af66fc99e Initial load duke parents: diff changeset	498 size_t _bytesize;
a61af66fc99e Initial load duke parents: diff changeset	499 jint _arena_id;
a61af66fc99e Initial load duke parents: diff changeset	500
a61af66fc99e Initial load duke parents: diff changeset	501 public:
a61af66fc99e Initial load duke parents: diff changeset	502 DeferredObjAllocEvent(const oop o, const size_t s, const jint id) {
a61af66fc99e Initial load duke parents: diff changeset	503 _oop = o;
a61af66fc99e Initial load duke parents: diff changeset	504 _bytesize = s;
a61af66fc99e Initial load duke parents: diff changeset	505 _arena_id = id;
a61af66fc99e Initial load duke parents: diff changeset	506 }
a61af66fc99e Initial load duke parents: diff changeset	507
a61af66fc99e Initial load duke parents: diff changeset	508 ~DeferredObjAllocEvent() {
a61af66fc99e Initial load duke parents: diff changeset	509 }
a61af66fc99e Initial load duke parents: diff changeset	510
a61af66fc99e Initial load duke parents: diff changeset	511 jint arena_id() { return _arena_id; }
a61af66fc99e Initial load duke parents: diff changeset	512 size_t bytesize() { return _bytesize; }
a61af66fc99e Initial load duke parents: diff changeset	513 oop get_oop() { return _oop; }
a61af66fc99e Initial load duke parents: diff changeset	514 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	515
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	516 #endif // SHARE_VM_MEMORY_UNIVERSE_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/memory/universe.hpp @ 10186:b06ac540229e