Mercurial > hg > truffle
annotate src/share/vm/oops/klass.hpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
| author | Bernhard Urban <bernhard.urban@jku.at> |
|---|---|
| date | Mon, 15 Apr 2013 19:54:58 +0200 |
| parents | b9a918201d47 |
| children | 4d5872186e76 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 7956 | 2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1155
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1155
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:
1155
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OOPS_KLASS_HPP |
| 26 #define SHARE_VM_OOPS_KLASS_HPP | |
| 27 | |
| 28 #include "memory/genOopClosures.hpp" | |
| 29 #include "memory/iterator.hpp" | |
| 30 #include "memory/memRegion.hpp" | |
| 31 #include "memory/specialized_oop_closures.hpp" | |
| 32 #include "oops/klassPS.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
33 #include "oops/metadata.hpp" |
| 1972 | 34 #include "oops/oop.hpp" |
| 35 #include "runtime/orderAccess.hpp" | |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
2376
diff
changeset
|
36 #include "trace/traceMacros.hpp" |
| 1972 | 37 #include "utilities/accessFlags.hpp" |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7409
diff
changeset
|
38 #include "utilities/macros.hpp" |
|
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7409
diff
changeset
|
39 #if INCLUDE_ALL_GCS |
| 1972 | 40 #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp" |
| 41 #include "gc_implementation/g1/g1OopClosures.hpp" | |
| 42 #include "gc_implementation/parNew/parOopClosures.hpp" | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7409
diff
changeset
|
43 #endif // INCLUDE_ALL_GCS |
| 1972 | 44 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
45 // |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
46 // A Klass provides: |
| 0 | 47 // 1: language level class object (method dictionary etc.) |
| 48 // 2: provide vm dispatch behavior for the object | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
49 // Both functions are combined into one C++ class. |
| 0 | 50 |
| 51 // One reason for the oop/klass dichotomy in the implementation is | |
| 52 // that we don't want a C++ vtbl pointer in every object. Thus, | |
| 53 // normal oops don't have any virtual functions. Instead, they | |
| 54 // forward all "virtual" functions to their klass, which does have | |
| 55 // a vtbl and does the C++ dispatch depending on the object's | |
| 56 // actual type. (See oop.inline.hpp for some of the forwarding code.) | |
| 57 // ALL FUNCTIONS IMPLEMENTING THIS DISPATCH ARE PREFIXED WITH "oop_"! | |
| 58 | |
| 59 // Klass layout: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
60 // [C++ vtbl ptr ] (contained in Metadata) |
| 0 | 61 // [layout_helper ] |
| 62 // [super_check_offset ] for fast subtype checks | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
63 // [name ] |
| 0 | 64 // [secondary_super_cache] for fast subtype checks |
| 65 // [secondary_supers ] array of 2ndary supertypes | |
| 66 // [primary_supers 0] | |
| 67 // [primary_supers 1] | |
| 68 // [primary_supers 2] | |
| 69 // ... | |
| 70 // [primary_supers 7] | |
| 71 // [java_mirror ] | |
| 72 // [super ] | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
73 // [subklass ] first subclass |
| 0 | 74 // [next_sibling ] link to chain additional subklasses |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
75 // [next_link ] |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
76 // [class_loader_data] |
| 0 | 77 // [modifier_flags] |
| 78 // [access_flags ] | |
| 79 // [last_biased_lock_bulk_revocation_time] (64 bits) | |
| 80 // [prototype_header] | |
| 81 // [biased_lock_revocation_count] | |
|
7968
44c5fcd9cb25
8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents:
7409
diff
changeset
|
82 // [alloc_count ] |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
83 // [_modified_oops] |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
84 // [_accumulated_modified_oops] |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
2376
diff
changeset
|
85 // [trace_id] |
| 0 | 86 |
| 87 | |
| 88 // Forward declarations. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
89 template <class T> class Array; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
90 template <class T> class GrowableArray; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
91 class ClassLoaderData; |
| 0 | 92 class klassVtable; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
93 class ParCompactionManager; |
| 7956 | 94 class KlassSizeStats; |
| 0 | 95 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
96 class Klass : public Metadata { |
| 0 | 97 friend class VMStructs; |
| 98 protected: | |
| 99 // note: put frequently-used fields together at start of klass structure | |
| 100 // for better cache behavior (may not make much of a difference but sure won't hurt) | |
| 101 enum { _primary_super_limit = 8 }; | |
| 102 | |
| 103 // The "layout helper" is a combined descriptor of object layout. | |
| 104 // For klasses which are neither instance nor array, the value is zero. | |
| 105 // | |
| 106 // For instances, layout helper is a positive number, the instance size. | |
| 107 // This size is already passed through align_object_size and scaled to bytes. | |
| 108 // The low order bit is set if instances of this class cannot be | |
| 109 // allocated using the fastpath. | |
| 110 // | |
| 111 // For arrays, layout helper is a negative number, containing four | |
| 112 // distinct bytes, as follows: | |
| 113 // MSB:[tag, hsz, ebt, log2(esz)]:LSB | |
| 114 // where: | |
| 115 // tag is 0x80 if the elements are oops, 0xC0 if non-oops | |
| 116 // hsz is array header size in bytes (i.e., offset of first element) | |
| 117 // ebt is the BasicType of the elements | |
| 118 // esz is the element size in bytes | |
| 119 // This packed word is arranged so as to be quickly unpacked by the | |
| 120 // various fast paths that use the various subfields. | |
| 121 // | |
| 122 // The esz bits can be used directly by a SLL instruction, without masking. | |
| 123 // | |
| 124 // Note that the array-kind tag looks like 0x00 for instance klasses, | |
| 125 // since their length in bytes is always less than 24Mb. | |
| 126 // | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
127 // Final note: This comes first, immediately after C++ vtable, |
| 0 | 128 // because it is frequently queried. |
| 129 jint _layout_helper; | |
| 130 | |
| 131 // The fields _super_check_offset, _secondary_super_cache, _secondary_supers | |
| 132 // and _primary_supers all help make fast subtype checks. See big discussion | |
| 133 // in doc/server_compiler/checktype.txt | |
| 134 // | |
| 135 // Where to look to observe a supertype (it is &_secondary_super_cache for | |
| 136 // secondary supers, else is &_primary_supers[depth()]. | |
| 137 juint _super_check_offset; | |
| 138 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
139 // Class name. Instance classes: java/lang/String, etc. Array classes: [I, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
140 // [Ljava/lang/String;, etc. Set to zero for all other kinds of classes. |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
141 Symbol* _name; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
142 |
| 0 | 143 // Cache of last observed secondary supertype |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
144 Klass* _secondary_super_cache; |
| 0 | 145 // Array of all secondary supertypes |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
146 Array<Klass*>* _secondary_supers; |
| 0 | 147 // Ordered list of all primary supertypes |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
148 Klass* _primary_supers[_primary_super_limit]; |
| 0 | 149 // java/lang/Class instance mirroring this class |
| 150 oop _java_mirror; | |
|
7036
8c4b757c2eb9
added more #ifdefs for GRAAL specific code
Doug Simon <doug.simon@oracle.com>
parents:
6988
diff
changeset
|
151 #ifdef GRAAL |
|
7084
9ba90252ce08
HotSpotResolvedJavaType is now the HotSpot implementation of ResolvedJavaType,
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7036
diff
changeset
|
152 // com/oracle/graal/hotspot/HotSpotResolvedObjectType mirroring this class |
|
2891
75a99b4f1c98
Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents:
2874
diff
changeset
|
153 oop _graal_mirror; |
|
7036
8c4b757c2eb9
added more #ifdefs for GRAAL specific code
Doug Simon <doug.simon@oracle.com>
parents:
6988
diff
changeset
|
154 #endif |
| 0 | 155 // Superclass |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
156 Klass* _super; |
| 0 | 157 // First subclass (NULL if none); _subklass->next_sibling() is next one |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
158 Klass* _subklass; |
| 0 | 159 // Sibling link (or NULL); links all subklasses of a klass |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
160 Klass* _next_sibling; |
| 0 | 161 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
162 // All klasses loaded by a class loader are chained through these links |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
163 Klass* _next_link; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
164 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
165 // The VM's representation of the ClassLoader used to load this class. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
166 // Provide access the corresponding instance java.lang.ClassLoader. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
167 ClassLoaderData* _class_loader_data; |
| 0 | 168 |
| 169 jint _modifier_flags; // Processed access flags, for use by Class.getModifiers. | |
| 170 AccessFlags _access_flags; // Access flags. The class/interface distinction is stored here. | |
| 171 | |
|
7968
44c5fcd9cb25
8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents:
7409
diff
changeset
|
172 // Biased locking implementation and statistics |
|
44c5fcd9cb25
8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents:
7409
diff
changeset
|
173 // (the 64-bit chunk goes first, to avoid some fragmentation) |
|
44c5fcd9cb25
8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents:
7409
diff
changeset
|
174 jlong _last_biased_lock_bulk_revocation_time; |
|
44c5fcd9cb25
8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents:
7409
diff
changeset
|
175 markOop _prototype_header; // Used when biased locking is both enabled and disabled for this type |
|
44c5fcd9cb25
8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents:
7409
diff
changeset
|
176 jint _biased_lock_revocation_count; |
|
44c5fcd9cb25
8006280: Need to reorder metadata structures to reduce size (64-bit)
iklam
parents:
7409
diff
changeset
|
177 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
178 juint _alloc_count; // allocation profiling support |
| 0 | 179 |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
2376
diff
changeset
|
180 TRACE_DEFINE_KLASS_TRACE_ID; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
181 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
182 // Remembered sets support for the oops in the klasses. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
183 jbyte _modified_oops; // Card Table Equivalent (YC/CMS support) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
184 jbyte _accumulated_modified_oops; // Mod Union Equivalent (CMS support) |
| 0 | 185 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
186 // Constructor |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
187 Klass(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
188 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
189 void* operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, TRAPS); |
| 0 | 190 |
| 191 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
192 bool is_klass() const volatile { return true; } |
| 0 | 193 |
| 194 // super | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
195 Klass* super() const { return _super; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
196 void set_super(Klass* k) { _super = k; } |
| 0 | 197 |
| 198 // initializes _super link, _primary_supers & _secondary_supers arrays | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
199 void initialize_supers(Klass* k, TRAPS); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
200 void initialize_supers_impl1(Klass* k); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
201 void initialize_supers_impl2(Klass* k); |
| 0 | 202 |
| 203 // klass-specific helper for initializing _secondary_supers | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
204 virtual GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots); |
| 0 | 205 |
| 206 // java_super is the Java-level super type as specified by Class.getSuperClass. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
207 virtual Klass* java_super() const { return NULL; } |
| 0 | 208 |
| 209 juint super_check_offset() const { return _super_check_offset; } | |
| 210 void set_super_check_offset(juint o) { _super_check_offset = o; } | |
| 211 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
212 Klass* secondary_super_cache() const { return _secondary_super_cache; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
213 void set_secondary_super_cache(Klass* k) { _secondary_super_cache = k; } |
| 0 | 214 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
215 Array<Klass*>* secondary_supers() const { return _secondary_supers; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
216 void set_secondary_supers(Array<Klass*>* k) { _secondary_supers = k; } |
| 0 | 217 |
| 218 // Return the element of the _super chain of the given depth. | |
| 219 // If there is no such element, return either NULL or this. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
220 Klass* primary_super_of_depth(juint i) const { |
| 0 | 221 assert(i < primary_super_limit(), "oob"); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
222 Klass* super = _primary_supers[i]; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
223 assert(super == NULL || super->super_depth() == i, "correct display"); |
| 0 | 224 return super; |
| 225 } | |
| 226 | |
| 227 // Can this klass be a primary super? False for interfaces and arrays of | |
| 228 // interfaces. False also for arrays or classes with long super chains. | |
| 229 bool can_be_primary_super() const { | |
|
4762
069ab3f976d3
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
2376
diff
changeset
|
230 const juint secondary_offset = in_bytes(secondary_super_cache_offset()); |
| 0 | 231 return super_check_offset() != secondary_offset; |
| 232 } | |
| 233 virtual bool can_be_primary_super_slow() const; | |
| 234 | |
| 235 // Returns number of primary supers; may be a number in the inclusive range [0, primary_super_limit]. | |
| 236 juint super_depth() const { | |
| 237 if (!can_be_primary_super()) { | |
| 238 return primary_super_limit(); | |
| 239 } else { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
240 juint d = (super_check_offset() - in_bytes(primary_supers_offset())) / sizeof(Klass*); |
| 0 | 241 assert(d < primary_super_limit(), "oob"); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
242 assert(_primary_supers[d] == this, "proper init"); |
| 0 | 243 return d; |
| 244 } | |
| 245 } | |
| 246 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
247 // store an oop into a field of a Klass |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
248 void klass_oop_store(oop* p, oop v); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
249 void klass_oop_store(volatile oop* p, oop v); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
250 |
| 0 | 251 // java mirror |
| 252 oop java_mirror() const { return _java_mirror; } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
253 void set_java_mirror(oop m) { klass_oop_store(&_java_mirror, m); } |
| 0 | 254 |
|
7036
8c4b757c2eb9
added more #ifdefs for GRAAL specific code
Doug Simon <doug.simon@oracle.com>
parents:
6988
diff
changeset
|
255 #ifdef GRAAL |
|
7125
1baf7f1e3f23
decoupled C++ Graal runtime from C1
Doug Simon <doug.simon@oracle.com>
parents:
7084
diff
changeset
|
256 // Graal mirror |
|
2891
75a99b4f1c98
Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents:
2874
diff
changeset
|
257 oop graal_mirror() const { return _graal_mirror; } |
|
75a99b4f1c98
Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents:
2874
diff
changeset
|
258 void set_graal_mirror(oop m) { oop_store((oop*) &_graal_mirror, m); } |
|
7036
8c4b757c2eb9
added more #ifdefs for GRAAL specific code
Doug Simon <doug.simon@oracle.com>
parents:
6988
diff
changeset
|
259 #endif |
|
1941
79d04223b8a5
Added caching for resolved types and resolved fields.
Thomas Wuerthinger <wuerthinger@ssw.jku.at>
parents:
1681
diff
changeset
|
260 |
| 0 | 261 // modifier flags |
| 262 jint modifier_flags() const { return _modifier_flags; } | |
| 263 void set_modifier_flags(jint flags) { _modifier_flags = flags; } | |
| 264 | |
| 265 // size helper | |
| 266 int layout_helper() const { return _layout_helper; } | |
| 267 void set_layout_helper(int lh) { _layout_helper = lh; } | |
| 268 | |
| 269 // Note: for instances layout_helper() may include padding. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
270 // Use InstanceKlass::contains_field_offset to classify field offsets. |
| 0 | 271 |
| 272 // sub/superklass links | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
273 InstanceKlass* superklass() const; |
| 0 | 274 Klass* subklass() const; |
| 275 Klass* next_sibling() const; | |
| 276 void append_to_sibling_list(); // add newly created receiver to superklass' subklass list | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
277 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
278 void set_next_link(Klass* k) { _next_link = k; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
279 Klass* next_link() const { return _next_link; } // The next klass defined by the class loader. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
280 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
281 // class loader data |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
282 ClassLoaderData* class_loader_data() const { return _class_loader_data; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
283 void set_class_loader_data(ClassLoaderData* loader_data) { _class_loader_data = loader_data; } |
| 0 | 284 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
285 // The Klasses are not placed in the Heap, so the Card Table or |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
286 // the Mod Union Table can't be used to mark when klasses have modified oops. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
287 // The CT and MUT bits saves this information for the individual Klasses. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
288 void record_modified_oops() { _modified_oops = 1; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
289 void clear_modified_oops() { _modified_oops = 0; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
290 bool has_modified_oops() { return _modified_oops == 1; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
291 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
292 void accumulate_modified_oops() { if (has_modified_oops()) _accumulated_modified_oops = 1; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
293 void clear_accumulated_modified_oops() { _accumulated_modified_oops = 0; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
294 bool has_accumulated_modified_oops() { return _accumulated_modified_oops == 1; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
295 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
296 protected: // internal accessors |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
297 Klass* subklass_oop() const { return _subklass; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
298 Klass* next_sibling_oop() const { return _next_sibling; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
299 void set_subklass(Klass* s); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
300 void set_next_sibling(Klass* s); |
| 0 | 301 |
| 302 public: | |
| 303 // Allocation profiling support | |
| 304 juint alloc_count() const { return _alloc_count; } | |
| 305 void set_alloc_count(juint n) { _alloc_count = n; } | |
| 306 virtual juint alloc_size() const = 0; | |
| 307 virtual void set_alloc_size(juint n) = 0; | |
| 308 | |
| 309 // Compiler support | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
310 static ByteSize super_offset() { return in_ByteSize(offset_of(Klass, _super)); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
311 static ByteSize super_check_offset_offset() { return in_ByteSize(offset_of(Klass, _super_check_offset)); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
312 static ByteSize primary_supers_offset() { return in_ByteSize(offset_of(Klass, _primary_supers)); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
313 static ByteSize secondary_super_cache_offset() { return in_ByteSize(offset_of(Klass, _secondary_super_cache)); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
314 static ByteSize secondary_supers_offset() { return in_ByteSize(offset_of(Klass, _secondary_supers)); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
315 static ByteSize java_mirror_offset() { return in_ByteSize(offset_of(Klass, _java_mirror)); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
316 static ByteSize modifier_flags_offset() { return in_ByteSize(offset_of(Klass, _modifier_flags)); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
317 static ByteSize layout_helper_offset() { return in_ByteSize(offset_of(Klass, _layout_helper)); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
318 static ByteSize access_flags_offset() { return in_ByteSize(offset_of(Klass, _access_flags)); } |
|
7036
8c4b757c2eb9
added more #ifdefs for GRAAL specific code
Doug Simon <doug.simon@oracle.com>
parents:
6988
diff
changeset
|
319 #ifdef GRAAL |
|
6948
e522a00b91aa
Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works
Doug Simon <doug.simon@oracle.com>
diff
changeset
|
320 static ByteSize graal_mirror_offset() { return in_ByteSize(offset_of(Klass, _graal_mirror)); } |
|
7036
8c4b757c2eb9
added more #ifdefs for GRAAL specific code
Doug Simon <doug.simon@oracle.com>
parents:
6988
diff
changeset
|
321 static ByteSize next_sibling_offset() { return in_ByteSize(offset_of(Klass, _next_sibling)); } |
|
8c4b757c2eb9
added more #ifdefs for GRAAL specific code
Doug Simon <doug.simon@oracle.com>
parents:
6988
diff
changeset
|
322 static ByteSize subklass_offset() { return in_ByteSize(offset_of(Klass, _subklass)); } |
|
8c4b757c2eb9
added more #ifdefs for GRAAL specific code
Doug Simon <doug.simon@oracle.com>
parents:
6988
diff
changeset
|
323 #endif |
| 0 | 324 |
| 325 // Unpacking layout_helper: | |
| 326 enum { | |
| 327 _lh_neutral_value = 0, // neutral non-array non-instance value | |
| 328 _lh_instance_slow_path_bit = 0x01, | |
| 329 _lh_log2_element_size_shift = BitsPerByte*0, | |
| 330 _lh_log2_element_size_mask = BitsPerLong-1, | |
| 331 _lh_element_type_shift = BitsPerByte*1, | |
| 332 _lh_element_type_mask = right_n_bits(BitsPerByte), // shifted mask | |
| 333 _lh_header_size_shift = BitsPerByte*2, | |
| 334 _lh_header_size_mask = right_n_bits(BitsPerByte), // shifted mask | |
| 335 _lh_array_tag_bits = 2, | |
| 336 _lh_array_tag_shift = BitsPerInt - _lh_array_tag_bits, | |
| 337 _lh_array_tag_type_value = ~0x00, // 0xC0000000 >> 30 | |
| 338 _lh_array_tag_obj_value = ~0x01 // 0x80000000 >> 30 | |
| 339 }; | |
| 340 | |
| 341 static int layout_helper_size_in_bytes(jint lh) { | |
| 342 assert(lh > (jint)_lh_neutral_value, "must be instance"); | |
| 343 return (int) lh & ~_lh_instance_slow_path_bit; | |
| 344 } | |
| 345 static bool layout_helper_needs_slow_path(jint lh) { | |
| 346 assert(lh > (jint)_lh_neutral_value, "must be instance"); | |
| 347 return (lh & _lh_instance_slow_path_bit) != 0; | |
| 348 } | |
| 349 static bool layout_helper_is_instance(jint lh) { | |
| 350 return (jint)lh > (jint)_lh_neutral_value; | |
| 351 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
352 static bool layout_helper_is_array(jint lh) { |
| 0 | 353 return (jint)lh < (jint)_lh_neutral_value; |
| 354 } | |
| 355 static bool layout_helper_is_typeArray(jint lh) { | |
| 356 // _lh_array_tag_type_value == (lh >> _lh_array_tag_shift); | |
| 357 return (juint)lh >= (juint)(_lh_array_tag_type_value << _lh_array_tag_shift); | |
| 358 } | |
| 359 static bool layout_helper_is_objArray(jint lh) { | |
| 360 // _lh_array_tag_obj_value == (lh >> _lh_array_tag_shift); | |
| 361 return (jint)lh < (jint)(_lh_array_tag_type_value << _lh_array_tag_shift); | |
| 362 } | |
| 363 static int layout_helper_header_size(jint lh) { | |
| 364 assert(lh < (jint)_lh_neutral_value, "must be array"); | |
| 365 int hsize = (lh >> _lh_header_size_shift) & _lh_header_size_mask; | |
| 366 assert(hsize > 0 && hsize < (int)sizeof(oopDesc)*3, "sanity"); | |
| 367 return hsize; | |
| 368 } | |
| 369 static BasicType layout_helper_element_type(jint lh) { | |
| 370 assert(lh < (jint)_lh_neutral_value, "must be array"); | |
| 371 int btvalue = (lh >> _lh_element_type_shift) & _lh_element_type_mask; | |
| 372 assert(btvalue >= T_BOOLEAN && btvalue <= T_OBJECT, "sanity"); | |
| 373 return (BasicType) btvalue; | |
| 374 } | |
| 375 static int layout_helper_log2_element_size(jint lh) { | |
| 376 assert(lh < (jint)_lh_neutral_value, "must be array"); | |
| 377 int l2esz = (lh >> _lh_log2_element_size_shift) & _lh_log2_element_size_mask; | |
| 378 assert(l2esz <= LogBitsPerLong, "sanity"); | |
| 379 return l2esz; | |
| 380 } | |
| 381 static jint array_layout_helper(jint tag, int hsize, BasicType etype, int log2_esize) { | |
| 382 return (tag << _lh_array_tag_shift) | |
| 383 | (hsize << _lh_header_size_shift) | |
| 384 | ((int)etype << _lh_element_type_shift) | |
| 385 | (log2_esize << _lh_log2_element_size_shift); | |
| 386 } | |
| 387 static jint instance_layout_helper(jint size, bool slow_path_flag) { | |
| 388 return (size << LogHeapWordSize) | |
| 389 | (slow_path_flag ? _lh_instance_slow_path_bit : 0); | |
| 390 } | |
| 391 static int layout_helper_to_size_helper(jint lh) { | |
| 392 assert(lh > (jint)_lh_neutral_value, "must be instance"); | |
| 393 // Note that the following expression discards _lh_instance_slow_path_bit. | |
| 394 return lh >> LogHeapWordSize; | |
| 395 } | |
| 396 // Out-of-line version computes everything based on the etype: | |
| 397 static jint array_layout_helper(BasicType etype); | |
| 398 | |
| 399 // What is the maximum number of primary superclasses any klass can have? | |
| 400 #ifdef PRODUCT | |
| 401 static juint primary_super_limit() { return _primary_super_limit; } | |
| 402 #else | |
| 403 static juint primary_super_limit() { | |
| 404 assert(FastSuperclassLimit <= _primary_super_limit, "parameter oob"); | |
| 405 return FastSuperclassLimit; | |
| 406 } | |
| 407 #endif | |
| 408 | |
| 409 // vtables | |
| 410 virtual klassVtable* vtable() const { return NULL; } | |
| 411 | |
| 412 // subclass check | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
413 bool is_subclass_of(Klass* k) const; |
| 0 | 414 // subtype check: true if is_subclass_of, or if k is interface and receiver implements it |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
415 bool is_subtype_of(Klass* k) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
416 juint off = k->super_check_offset(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
417 Klass* sup = *(Klass**)( (address)this + off ); |
|
4762
069ab3f976d3
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
2376
diff
changeset
|
418 const juint secondary_offset = in_bytes(secondary_super_cache_offset()); |
| 0 | 419 if (sup == k) { |
| 420 return true; | |
| 421 } else if (off != secondary_offset) { | |
| 422 return false; | |
| 423 } else { | |
| 424 return search_secondary_supers(k); | |
| 425 } | |
| 426 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
427 bool search_secondary_supers(Klass* k) const; |
| 0 | 428 |
| 605 | 429 // Find LCA in class hierarchy |
| 0 | 430 Klass *LCA( Klass *k ); |
| 431 | |
| 432 // Check whether reflection/jni/jvm code is allowed to instantiate this class; | |
| 433 // if not, throw either an Error or an Exception. | |
| 434 virtual void check_valid_for_instantiation(bool throwError, TRAPS); | |
| 435 | |
| 436 // array copying | |
| 437 virtual void copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS); | |
| 438 | |
| 439 // tells if the class should be initialized | |
| 440 virtual bool should_be_initialized() const { return false; } | |
| 441 // initializes the klass | |
| 442 virtual void initialize(TRAPS); | |
| 443 // lookup operation for MethodLookupCache | |
| 444 friend class MethodLookupCache; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
445 virtual Method* uncached_lookup_method(Symbol* name, Symbol* signature) const; |
| 0 | 446 public: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
447 Method* lookup_method(Symbol* name, Symbol* signature) const { |
| 0 | 448 return uncached_lookup_method(name, signature); |
| 449 } | |
| 450 | |
| 451 // array class with specific rank | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
452 Klass* array_klass(int rank, TRAPS) { return array_klass_impl(false, rank, THREAD); } |
| 0 | 453 |
| 454 // array class with this klass as element type | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
455 Klass* array_klass(TRAPS) { return array_klass_impl(false, THREAD); } |
| 0 | 456 |
| 457 // These will return NULL instead of allocating on the heap: | |
| 458 // NB: these can block for a mutex, like other functions with TRAPS arg. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
459 Klass* array_klass_or_null(int rank); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
460 Klass* array_klass_or_null(); |
| 0 | 461 |
| 462 virtual oop protection_domain() { return NULL; } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
463 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
464 oop class_loader() const; |
| 0 | 465 |
| 7409 | 466 virtual oop klass_holder() const { return class_loader(); } |
| 467 | |
| 0 | 468 protected: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
469 virtual Klass* array_klass_impl(bool or_null, int rank, TRAPS); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
470 virtual Klass* array_klass_impl(bool or_null, TRAPS); |
| 0 | 471 |
| 472 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
473 // CDS support - remove and restore oops from metadata. Oops are not shared. |
| 0 | 474 virtual void remove_unshareable_info(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
475 virtual void restore_unshareable_info(TRAPS); |
| 0 | 476 |
| 477 protected: | |
| 478 // computes the subtype relationship | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
479 virtual bool compute_is_subtype_of(Klass* k); |
| 0 | 480 public: |
| 481 // ALL FUNCTIONS BELOW THIS POINT ARE DISPATCHED FROM AN OOP | |
| 482 // These functions describe behavior for the oop not the KLASS. | |
| 483 | |
| 484 // actual oop size of obj in memory | |
| 485 virtual int oop_size(oop obj) const = 0; | |
| 486 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
487 // Size of klass in word size. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
488 virtual int size() const = 0; |
| 7956 | 489 #if INCLUDE_SERVICES |
| 490 virtual void collect_statistics(KlassSizeStats *sz) const; | |
| 491 #endif | |
| 0 | 492 |
| 493 // Returns the Java name for a class (Resource allocated) | |
| 494 // For arrays, this returns the name of the element with a leading '['. | |
| 495 // For classes, this returns the name with the package separators | |
| 496 // turned into '.'s. | |
| 497 const char* external_name() const; | |
| 498 // Returns the name for a class (Resource allocated) as the class | |
| 499 // would appear in a signature. | |
| 500 // For arrays, this returns the name of the element with a leading '['. | |
| 501 // For classes, this returns the name with a leading 'L' and a trailing ';' | |
| 502 // and the package separators as '/'. | |
|
1039
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
628
diff
changeset
|
503 virtual const char* signature_name() const; |
| 0 | 504 |
| 505 // garbage collection support | |
| 506 virtual void oop_follow_contents(oop obj) = 0; | |
| 507 virtual int oop_adjust_pointers(oop obj) = 0; | |
| 508 | |
| 509 // Parallel Scavenge and Parallel Old | |
| 510 PARALLEL_GC_DECLS_PV | |
| 511 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
512 // type testing operations |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
513 protected: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
514 virtual bool oop_is_instance_slow() const { return false; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
515 virtual bool oop_is_array_slow() const { return false; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
516 virtual bool oop_is_objArray_slow() const { return false; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
517 virtual bool oop_is_typeArray_slow() const { return false; } |
| 0 | 518 public: |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2177
diff
changeset
|
519 virtual bool oop_is_instanceMirror() const { return false; } |
| 0 | 520 virtual bool oop_is_instanceRef() const { return false; } |
| 521 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
522 // Fast non-virtual versions |
| 0 | 523 #ifndef ASSERT |
| 524 #define assert_same_query(xval, xcheck) xval | |
| 525 #else | |
| 526 private: | |
| 527 static bool assert_same_query(bool xval, bool xslow) { | |
| 528 assert(xval == xslow, "slow and fast queries agree"); | |
| 529 return xval; | |
| 530 } | |
| 531 public: | |
| 532 #endif | |
| 533 inline bool oop_is_instance() const { return assert_same_query( | |
| 534 layout_helper_is_instance(layout_helper()), | |
| 535 oop_is_instance_slow()); } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
536 inline bool oop_is_array() const { return assert_same_query( |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
537 layout_helper_is_array(layout_helper()), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
538 oop_is_array_slow()); } |
| 0 | 539 inline bool oop_is_objArray() const { return assert_same_query( |
| 540 layout_helper_is_objArray(layout_helper()), | |
| 541 oop_is_objArray_slow()); } | |
| 542 inline bool oop_is_typeArray() const { return assert_same_query( | |
| 543 layout_helper_is_typeArray(layout_helper()), | |
| 544 oop_is_typeArray_slow()); } | |
| 545 #undef assert_same_query | |
| 546 | |
| 547 // Access flags | |
| 548 AccessFlags access_flags() const { return _access_flags; } | |
| 549 void set_access_flags(AccessFlags flags) { _access_flags = flags; } | |
| 550 | |
| 551 bool is_public() const { return _access_flags.is_public(); } | |
| 552 bool is_final() const { return _access_flags.is_final(); } | |
| 553 bool is_interface() const { return _access_flags.is_interface(); } | |
| 554 bool is_abstract() const { return _access_flags.is_abstract(); } | |
| 555 bool is_super() const { return _access_flags.is_super(); } | |
| 556 bool is_synthetic() const { return _access_flags.is_synthetic(); } | |
| 557 void set_is_synthetic() { _access_flags.set_is_synthetic(); } | |
| 558 bool has_finalizer() const { return _access_flags.has_finalizer(); } | |
| 559 bool has_final_method() const { return _access_flags.has_final_method(); } | |
| 560 void set_has_finalizer() { _access_flags.set_has_finalizer(); } | |
| 561 void set_has_final_method() { _access_flags.set_has_final_method(); } | |
| 562 bool is_cloneable() const { return _access_flags.is_cloneable(); } | |
| 563 void set_is_cloneable() { _access_flags.set_is_cloneable(); } | |
| 564 bool has_vanilla_constructor() const { return _access_flags.has_vanilla_constructor(); } | |
| 565 void set_has_vanilla_constructor() { _access_flags.set_has_vanilla_constructor(); } | |
| 566 bool has_miranda_methods () const { return access_flags().has_miranda_methods(); } | |
| 567 void set_has_miranda_methods() { _access_flags.set_has_miranda_methods(); } | |
| 568 | |
| 569 // Biased locking support | |
| 570 // Note: the prototype header is always set up to be at least the | |
| 571 // prototype markOop. If biased locking is enabled it may further be | |
| 572 // biasable and have an epoch. | |
| 573 markOop prototype_header() const { return _prototype_header; } | |
| 574 // NOTE: once instances of this klass are floating around in the | |
| 575 // system, this header must only be updated at a safepoint. | |
| 576 // NOTE 2: currently we only ever set the prototype header to the | |
| 577 // biasable prototype for instanceKlasses. There is no technical | |
| 578 // reason why it could not be done for arrayKlasses aside from | |
| 579 // wanting to reduce the initial scope of this optimization. There | |
| 580 // are potential problems in setting the bias pattern for | |
| 581 // JVM-internal oops. | |
| 582 inline void set_prototype_header(markOop header); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
583 static ByteSize prototype_header_offset() { return in_ByteSize(offset_of(Klass, _prototype_header)); } |
| 0 | 584 |
| 585 int biased_lock_revocation_count() const { return (int) _biased_lock_revocation_count; } | |
| 586 // Atomically increments biased_lock_revocation_count and returns updated value | |
| 587 int atomic_incr_biased_lock_revocation_count(); | |
| 588 void set_biased_lock_revocation_count(int val) { _biased_lock_revocation_count = (jint) val; } | |
| 589 jlong last_biased_lock_bulk_revocation_time() { return _last_biased_lock_bulk_revocation_time; } | |
| 590 void set_last_biased_lock_bulk_revocation_time(jlong cur_time) { _last_biased_lock_bulk_revocation_time = cur_time; } | |
| 591 | |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
2376
diff
changeset
|
592 TRACE_DEFINE_KLASS_METHODS; |
| 0 | 593 |
| 594 // garbage collection support | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
595 virtual void oops_do(OopClosure* cl); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
596 |
|
7185
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
597 // Iff the class loader (or mirror for anonymous classes) is alive the |
|
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
598 // Klass is considered alive. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
599 // The is_alive closure passed in depends on the Garbage Collector used. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
600 bool is_loader_alive(BoolObjectClosure* is_alive); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
601 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
602 static void clean_weak_klass_links(BoolObjectClosure* is_alive); |
| 0 | 603 |
| 604 // Prefetch within oop iterators. This is a macro because we | |
| 605 // can't guarantee that the compiler will inline it. In 64-bit | |
| 606 // it generally doesn't. Signature is | |
| 607 // | |
| 608 // static void prefetch_beyond(oop* const start, | |
| 609 // oop* const end, | |
| 610 // const intx foffset, | |
| 611 // const Prefetch::style pstyle); | |
| 612 #define prefetch_beyond(start, end, foffset, pstyle) { \ | |
| 613 const intx foffset_ = (foffset); \ | |
| 614 const Prefetch::style pstyle_ = (pstyle); \ | |
| 615 assert(foffset_ > 0, "prefetch beyond, not behind"); \ | |
| 616 if (pstyle_ != Prefetch::do_none) { \ | |
| 617 oop* ref = (start); \ | |
| 618 if (ref < (end)) { \ | |
| 619 switch (pstyle_) { \ | |
| 620 case Prefetch::do_read: \ | |
| 621 Prefetch::read(*ref, foffset_); \ | |
| 622 break; \ | |
| 623 case Prefetch::do_write: \ | |
| 624 Prefetch::write(*ref, foffset_); \ | |
| 625 break; \ | |
| 626 default: \ | |
| 627 ShouldNotReachHere(); \ | |
| 628 break; \ | |
| 629 } \ | |
| 630 } \ | |
| 631 } \ | |
| 632 } | |
| 633 | |
| 634 // iterators | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
635 virtual int oop_oop_iterate(oop obj, ExtendedOopClosure* blk) = 0; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
636 virtual int oop_oop_iterate_v(oop obj, ExtendedOopClosure* blk) { |
| 0 | 637 return oop_oop_iterate(obj, blk); |
| 638 } | |
| 639 | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7409
diff
changeset
|
640 #if INCLUDE_ALL_GCS |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
641 // In case we don't have a specialized backward scanner use forward |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
642 // iteration. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
643 virtual int oop_oop_iterate_backwards_v(oop obj, ExtendedOopClosure* blk) { |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
644 return oop_oop_iterate_v(obj, blk); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
645 } |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7409
diff
changeset
|
646 #endif // INCLUDE_ALL_GCS |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
647 |
| 0 | 648 // Iterates "blk" over all the oops in "obj" (of type "this") within "mr". |
| 649 // (I don't see why the _m should be required, but without it the Solaris | |
| 650 // C++ gives warning messages about overridings of the "oop_oop_iterate" | |
| 651 // defined above "hiding" this virtual function. (DLD, 6/20/00)) */ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
652 virtual int oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) = 0; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
653 virtual int oop_oop_iterate_v_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) { |
| 0 | 654 return oop_oop_iterate_m(obj, blk, mr); |
| 655 } | |
| 656 | |
| 657 // Versions of the above iterators specialized to particular subtypes | |
| 658 // of OopClosure, to avoid closure virtual calls. | |
| 659 #define Klass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ | |
| 660 virtual int oop_oop_iterate##nv_suffix(oop obj, OopClosureType* blk) { \ | |
| 661 /* Default implementation reverts to general version. */ \ | |
| 662 return oop_oop_iterate(obj, blk); \ | |
| 663 } \ | |
| 664 \ | |
| 665 /* Iterates "blk" over all the oops in "obj" (of type "this") within "mr". \ | |
| 666 (I don't see why the _m should be required, but without it the Solaris \ | |
| 667 C++ gives warning messages about overridings of the "oop_oop_iterate" \ | |
| 668 defined above "hiding" this virtual function. (DLD, 6/20/00)) */ \ | |
| 669 virtual int oop_oop_iterate##nv_suffix##_m(oop obj, \ | |
| 670 OopClosureType* blk, \ | |
| 671 MemRegion mr) { \ | |
| 672 return oop_oop_iterate_m(obj, blk, mr); \ | |
| 673 } | |
| 674 | |
| 675 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_DECL) | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
676 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_DECL) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
677 |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7409
diff
changeset
|
678 #if INCLUDE_ALL_GCS |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
679 #define Klass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
680 virtual int oop_oop_iterate_backwards##nv_suffix(oop obj, \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
681 OopClosureType* blk) { \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
682 /* Default implementation reverts to general version. */ \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
683 return oop_oop_iterate_backwards_v(obj, blk); \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
684 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
685 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
686 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_BACKWARDS_DECL) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
687 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_BACKWARDS_DECL) |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7409
diff
changeset
|
688 #endif // INCLUDE_ALL_GCS |
| 0 | 689 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
690 virtual void array_klasses_do(void f(Klass* k)) {} |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
691 virtual void with_array_klasses_do(void f(Klass* k)); |
| 0 | 692 |
| 693 // Return self, except for abstract classes with exactly 1 | |
| 694 // implementor. Then return the 1 concrete implementation. | |
| 695 Klass *up_cast_abstract(); | |
| 696 | |
| 697 // klass name | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
698 Symbol* name() const { return _name; } |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
699 void set_name(Symbol* n); |
| 0 | 700 |
| 701 public: | |
| 702 // jvm support | |
| 703 virtual jint compute_modifier_flags(TRAPS) const; | |
| 704 | |
| 705 // JVMTI support | |
| 706 virtual jint jvmti_class_status() const; | |
| 707 | |
| 708 // Printing | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
709 virtual void print_on(outputStream* st) const; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
710 |
|
1155
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1039
diff
changeset
|
711 virtual void oop_print_value_on(oop obj, outputStream* st); |
| 0 | 712 virtual void oop_print_on (oop obj, outputStream* st); |
| 713 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
714 virtual const char* internal_name() const = 0; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
715 |
| 0 | 716 // Verification |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
717 virtual void verify_on(outputStream* st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
718 void verify() { verify_on(tty); } |
| 0 | 719 |
| 720 #ifndef PRODUCT | |
| 721 void verify_vtable_index(int index); | |
| 722 #endif | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
723 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
724 virtual void oop_verify_on(oop obj, outputStream* st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
725 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
726 private: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
727 // barriers used by klass_oop_store |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
728 void klass_update_barrier_set(oop v); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
729 void klass_update_barrier_set_pre(void* p, oop v); |
| 0 | 730 }; |
| 1972 | 731 |
| 732 #endif // SHARE_VM_OOPS_KLASS_HPP |