Mercurial > hg > graal-compiler
annotate src/share/vm/oops/klassVtable.hpp @ 6972:bd7a7ce2e264
6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Mon, 12 Nov 2012 14:03:53 -0800 |
| parents | 4735d2c84362 |
| children | 8d9fc28831cc |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
676
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
676
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:
676
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OOPS_KLASSVTABLE_HPP |
| 26 #define SHARE_VM_OOPS_KLASSVTABLE_HPP | |
| 27 | |
| 28 #include "memory/allocation.hpp" | |
| 29 #include "oops/oopsHierarchy.hpp" | |
| 30 #include "runtime/handles.hpp" | |
| 31 #include "utilities/growableArray.hpp" | |
| 32 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
33 // A klassVtable abstracts the variable-length vtable that is embedded in InstanceKlass |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6725
diff
changeset
|
34 // and ArrayKlass. klassVtable objects are used just as convenient transient accessors to the vtable, |
| 0 | 35 // not to actually hold the vtable data. |
| 36 // Note: the klassVtable should not be accessed before the class has been verified | |
| 37 // (until that point, the vtable is uninitialized). | |
| 38 | |
| 39 // Currently a klassVtable contains a direct reference to the vtable data, and is therefore | |
| 40 // not preserved across GCs. | |
| 41 | |
| 42 class vtableEntry; | |
| 43 | |
| 44 class klassVtable : public ResourceObj { | |
| 45 KlassHandle _klass; // my klass | |
| 46 int _tableOffset; // offset of start of vtable data within klass | |
| 47 int _length; // length of vtable (number of entries) | |
| 48 #ifndef PRODUCT | |
| 49 int _verify_count; // to make verify faster | |
| 50 #endif | |
| 51 | |
| 52 // Ordering important, so greater_than (>) can be used as an merge operator. | |
| 53 enum AccessType { | |
| 54 acc_private = 0, | |
| 55 acc_package_private = 1, | |
| 56 acc_publicprotected = 2 | |
| 57 }; | |
| 58 | |
| 59 public: | |
| 60 klassVtable(KlassHandle h_klass, void* base, int length) : _klass(h_klass) { | |
| 61 _tableOffset = (address)base - (address)h_klass(); _length = length; | |
| 62 } | |
| 63 | |
| 64 // accessors | |
| 65 vtableEntry* table() const { return (vtableEntry*)(address(_klass()) + _tableOffset); } | |
| 66 KlassHandle klass() const { return _klass; } | |
| 67 int length() const { return _length; } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
68 inline Method* method_at(int i) const; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
69 inline Method* unchecked_method_at(int i) const; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
70 inline Method** adr_method_at(int i) const; |
| 0 | 71 |
| 72 // searching; all methods return -1 if not found | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
73 int index_of(Method* m) const { return index_of(m, _length); } |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
74 int index_of_miranda(Symbol* name, Symbol* signature); |
| 0 | 75 |
| 76 void initialize_vtable(bool checkconstraints, TRAPS); // initialize vtable of a new klass | |
| 77 | |
|
3245
8ce625481709
7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents:
2227
diff
changeset
|
78 // CDS/RedefineClasses support - clear vtables so they can be reinitialized |
|
8ce625481709
7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents:
2227
diff
changeset
|
79 // at dump time. Clearing gives us an easy way to tell if the vtable has |
|
8ce625481709
7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents:
2227
diff
changeset
|
80 // already been reinitialized at dump time (see dump.cpp). Vtables can |
|
8ce625481709
7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents:
2227
diff
changeset
|
81 // be initialized at run time by RedefineClasses so dumping the right order |
|
8ce625481709
7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents:
2227
diff
changeset
|
82 // is necessary. |
|
8ce625481709
7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents:
2227
diff
changeset
|
83 void clear_vtable(); |
|
8ce625481709
7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents:
2227
diff
changeset
|
84 bool is_initialized(); |
|
8ce625481709
7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents:
2227
diff
changeset
|
85 |
|
8ce625481709
7032407: Crash in LinkResolver::runtime_resolve_virtual_method()
coleenp
parents:
2227
diff
changeset
|
86 // computes vtable length (in words) and the number of miranda methods |
| 6934 | 87 static void compute_vtable_size_and_num_mirandas( |
| 88 int* vtable_length, int* num_new_mirandas, | |
| 89 GrowableArray<Method*>* all_mirandas, Klass* super, | |
| 90 Array<Method*>* methods, AccessFlags class_flags, Handle classloader, | |
| 91 Symbol* classname, Array<Klass*>* local_interfaces, TRAPS); | |
| 0 | 92 |
| 93 // RedefineClasses() API support: | |
| 94 // If any entry of this vtable points to any of old_methods, | |
| 95 // replace it with the corresponding new_method. | |
| 96 // trace_name_printed is set to true if the current call has | |
| 97 // printed the klass name so that other routines in the adjust_* | |
| 98 // group don't print the klass name. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
99 void adjust_method_entries(Method** old_methods, Method** new_methods, |
| 0 | 100 int methods_length, bool * trace_name_printed); |
| 101 | |
| 102 // Debugging code | |
| 103 void print() PRODUCT_RETURN; | |
| 104 void verify(outputStream* st, bool force = false); | |
| 105 static void print_statistics() PRODUCT_RETURN; | |
| 106 | |
| 107 #ifndef PRODUCT | |
| 108 bool check_no_old_entries(); | |
| 109 void dump_vtable(); | |
| 110 #endif | |
| 111 | |
| 112 protected: | |
| 113 friend class vtableEntry; | |
| 114 private: | |
|
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
16
diff
changeset
|
115 enum { VTABLE_TRANSITIVE_OVERRIDE_VERSION = 51 } ; |
| 0 | 116 void copy_vtable_to(vtableEntry* start); |
| 117 int initialize_from_super(KlassHandle super); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
118 int index_of(Method* m, int len) const; // same as index_of, but search only up to len |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
119 void put_method_at(Method* m, int index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
120 static bool needs_new_vtable_entry(methodHandle m, Klass* super, Handle classloader, Symbol* classname, AccessFlags access_flags, TRAPS); |
| 0 | 121 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
122 bool update_inherited_vtable(InstanceKlass* klass, methodHandle target_method, int super_vtable_len, bool checkconstraints, TRAPS); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
123 InstanceKlass* find_transitive_override(InstanceKlass* initialsuper, methodHandle target_method, int vtable_index, |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
124 Handle target_loader, Symbol* target_classname, Thread* THREAD); |
| 0 | 125 |
| 126 // support for miranda methods | |
| 127 bool is_miranda_entry_at(int i); | |
| 6934 | 128 void fill_in_mirandas(int* initialized); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
129 static bool is_miranda(Method* m, Array<Method*>* class_methods, Klass* super); |
| 6934 | 130 static void add_new_mirandas_to_lists( |
| 131 GrowableArray<Method*>* new_mirandas, | |
| 132 GrowableArray<Method*>* all_mirandas, | |
| 133 Array<Method*>* current_interface_methods, Array<Method*>* class_methods, | |
| 134 Klass* super); | |
| 135 static void get_mirandas( | |
| 136 GrowableArray<Method*>* new_mirandas, | |
| 137 GrowableArray<Method*>* all_mirandas, Klass* super, | |
| 138 Array<Method*>* class_methods, Array<Klass*>* local_interfaces); | |
| 0 | 139 |
| 140 void verify_against(outputStream* st, klassVtable* vt, int index); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
141 inline InstanceKlass* ik() const; |
| 0 | 142 }; |
| 143 | |
| 144 | |
| 145 // private helper class for klassVtable | |
| 146 // description of entry points: | |
| 147 // destination is interpreted: | |
| 148 // from_compiled_code_entry_point -> c2iadapter | |
| 149 // from_interpreter_entry_point -> interpreter entry point | |
| 150 // destination is compiled: | |
| 151 // from_compiled_code_entry_point -> nmethod entry point | |
| 152 // from_interpreter_entry_point -> i2cadapter | |
| 153 class vtableEntry VALUE_OBJ_CLASS_SPEC { | |
| 154 public: | |
| 155 // size in words | |
| 156 static int size() { | |
| 157 return sizeof(vtableEntry) / sizeof(HeapWord); | |
| 158 } | |
| 159 static int method_offset_in_bytes() { return offset_of(vtableEntry, _method); } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
160 Method* method() const { return _method; } |
| 0 | 161 |
| 162 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
163 Method* _method; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
164 void set(Method* method) { assert(method != NULL, "use clear"); _method = method; } |
| 0 | 165 void clear() { _method = NULL; } |
| 166 void print() PRODUCT_RETURN; | |
| 167 void verify(klassVtable* vt, outputStream* st); | |
| 168 | |
| 169 friend class klassVtable; | |
| 170 }; | |
| 171 | |
| 172 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
173 inline Method* klassVtable::method_at(int i) const { |
| 0 | 174 assert(i >= 0 && i < _length, "index out of bounds"); |
| 175 assert(table()[i].method() != NULL, "should not be null"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
176 assert(((Metadata*)table()[i].method())->is_method(), "should be method"); |
| 0 | 177 return table()[i].method(); |
| 178 } | |
| 179 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
180 inline Method* klassVtable::unchecked_method_at(int i) const { |
| 0 | 181 assert(i >= 0 && i < _length, "index out of bounds"); |
| 182 return table()[i].method(); | |
| 183 } | |
| 184 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
185 inline Method** klassVtable::adr_method_at(int i) const { |
| 0 | 186 // Allow one past the last entry to be referenced; useful for loop bounds. |
| 187 assert(i >= 0 && i <= _length, "index out of bounds"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
188 return (Method**)(address(table() + i) + vtableEntry::method_offset_in_bytes()); |
| 0 | 189 } |
| 190 | |
| 191 // -------------------------------------------------------------------------------- | |
| 192 class klassItable; | |
| 193 class itableMethodEntry; | |
| 194 | |
| 195 class itableOffsetEntry VALUE_OBJ_CLASS_SPEC { | |
| 196 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
197 Klass* _interface; |
| 0 | 198 int _offset; |
| 199 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
200 Klass* interface_klass() const { return _interface; } |
| 0 | 201 int offset() const { return _offset; } |
| 202 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
203 static itableMethodEntry* method_entry(Klass* k, int offset) { return (itableMethodEntry*)(((address)k) + offset); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
204 itableMethodEntry* first_method_entry(Klass* k) { return method_entry(k, _offset); } |
| 0 | 205 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
206 void initialize(Klass* interf, int offset) { _interface = interf; _offset = offset; } |
| 0 | 207 |
| 208 // Static size and offset accessors | |
| 209 static int size() { return sizeof(itableOffsetEntry) / HeapWordSize; } // size in words | |
| 210 static int interface_offset_in_bytes() { return offset_of(itableOffsetEntry, _interface); } | |
| 211 static int offset_offset_in_bytes() { return offset_of(itableOffsetEntry, _offset); } | |
| 212 | |
| 213 friend class klassItable; | |
| 214 }; | |
| 215 | |
| 216 | |
| 217 class itableMethodEntry VALUE_OBJ_CLASS_SPEC { | |
| 218 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
219 Method* _method; |
| 0 | 220 |
| 221 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
222 Method* method() const { return _method; } |
| 0 | 223 |
| 224 void clear() { _method = NULL; } | |
| 225 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
226 void initialize(Method* method); |
| 0 | 227 |
| 228 // Static size and offset accessors | |
| 229 static int size() { return sizeof(itableMethodEntry) / HeapWordSize; } // size in words | |
| 230 static int method_offset_in_bytes() { return offset_of(itableMethodEntry, _method); } | |
| 231 | |
| 232 friend class klassItable; | |
| 233 }; | |
| 234 | |
| 235 // | |
| 236 // Format of an itable | |
| 237 // | |
| 238 // ---- offset table --- | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
239 // Klass* of interface 1 \ |
| 0 | 240 // offset to vtable from start of oop / offset table entry |
| 241 // ... | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
242 // Klass* of interface n \ |
| 0 | 243 // offset to vtable from start of oop / offset table entry |
| 244 // --- vtable for interface 1 --- | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
245 // Method* \ |
| 0 | 246 // compiler entry point / method table entry |
| 247 // ... | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
248 // Method* \ |
| 0 | 249 // compiler entry point / method table entry |
| 250 // -- vtable for interface 2 --- | |
| 251 // ... | |
| 252 // | |
| 253 class klassItable : public ResourceObj { | |
| 254 private: | |
| 255 instanceKlassHandle _klass; // my klass | |
| 256 int _table_offset; // offset of start of itable data within klass (in words) | |
| 257 int _size_offset_table; // size of offset table (in itableOffset entries) | |
| 258 int _size_method_table; // size of methodtable (in itableMethodEntry entries) | |
| 259 | |
| 260 void initialize_itable_for_interface(int method_table_offset, KlassHandle interf_h, bool checkconstraints, TRAPS); | |
| 261 public: | |
| 262 klassItable(instanceKlassHandle klass); | |
| 263 | |
| 264 itableOffsetEntry* offset_entry(int i) { assert(0 <= i && i <= _size_offset_table, "index out of bounds"); | |
| 265 return &((itableOffsetEntry*)vtable_start())[i]; } | |
| 266 | |
| 267 itableMethodEntry* method_entry(int i) { assert(0 <= i && i <= _size_method_table, "index out of bounds"); | |
| 268 return &((itableMethodEntry*)method_start())[i]; } | |
| 269 | |
|
16
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
270 int size_offset_table() { return _size_offset_table; } |
| 0 | 271 |
| 272 // Initialization | |
| 273 void initialize_itable(bool checkconstraints, TRAPS); | |
| 274 | |
| 275 // Updates | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
276 void initialize_with_method(Method* m); |
| 0 | 277 |
| 278 // RedefineClasses() API support: | |
| 279 // if any entry of this itable points to any of old_methods, | |
| 280 // replace it with the corresponding new_method. | |
| 281 // trace_name_printed is set to true if the current call has | |
| 282 // printed the klass name so that other routines in the adjust_* | |
| 283 // group don't print the klass name. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
284 void adjust_method_entries(Method** old_methods, Method** new_methods, |
| 0 | 285 int methods_length, bool * trace_name_printed); |
| 286 | |
| 287 // Setup of itable | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
288 static int compute_itable_size(Array<Klass*>* transitive_interfaces); |
| 0 | 289 static void setup_itable_offset_table(instanceKlassHandle klass); |
| 290 | |
| 291 // Resolving of method to index | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
292 static int compute_itable_index(Method* m); |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
16
diff
changeset
|
293 // ...and back again: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
294 static Method* method_for_itable_index(Klass* klass, int itable_index); |
| 0 | 295 |
| 296 // Debugging/Statistics | |
| 297 static void print_statistics() PRODUCT_RETURN; | |
| 298 private: | |
| 299 intptr_t* vtable_start() const { return ((intptr_t*)_klass()) + _table_offset; } | |
| 300 intptr_t* method_start() const { return vtable_start() + _size_offset_table * itableOffsetEntry::size(); } | |
| 301 | |
| 302 // Helper methods | |
| 303 static int calc_itable_size(int num_interfaces, int num_methods) { return (num_interfaces * itableOffsetEntry::size()) + (num_methods * itableMethodEntry::size()); } | |
| 304 | |
| 305 // Statistics | |
| 306 NOT_PRODUCT(static int _total_classes;) // Total no. of classes with itables | |
| 307 NOT_PRODUCT(static long _total_size;) // Total no. of bytes used for itables | |
| 308 | |
| 309 static void update_stats(int size) PRODUCT_RETURN NOT_PRODUCT({ _total_classes++; _total_size += size; }) | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
310 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
311 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
312 #ifndef PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
313 bool check_no_old_entries(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
314 #endif |
| 0 | 315 }; |
| 1972 | 316 |
| 317 #endif // SHARE_VM_OOPS_KLASSVTABLE_HPP |