Mercurial > hg > truffle
annotate src/share/vm/oops/klassVtable.hpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | da91efe96a93 |
| children | d8ce2825b193 |
| 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 |
| 0 | 34 // and arrayKlass. klassVtable objects are used just as convenient transient accessors to the vtable, |
| 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 |
| 0 | 87 static void compute_vtable_size_and_num_mirandas(int &vtable_length, int &num_miranda_methods, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
88 Klass* super, Array<Method*>* methods, |
|
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
16
diff
changeset
|
89 AccessFlags class_flags, Handle classloader, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
90 Symbol* classname, Array<Klass*>* local_interfaces, |
|
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
16
diff
changeset
|
91 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); | |
| 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); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
130 static void add_new_mirandas_to_list(GrowableArray<Method*>* list_of_current_mirandas, Array<Method*>* current_interface_methods, Array<Method*>* class_methods, Klass* super); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
131 static void get_mirandas(GrowableArray<Method*>* mirandas, Klass* super, Array<Method*>* class_methods, Array<Klass*>* local_interfaces); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
132 static int get_num_mirandas(Klass* super, Array<Method*>* class_methods, Array<Klass*>* local_interfaces); |
| 0 | 133 |
| 134 | |
| 135 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
|
136 inline InstanceKlass* ik() const; |
| 0 | 137 }; |
| 138 | |
| 139 | |
| 140 // private helper class for klassVtable | |
| 141 // description of entry points: | |
| 142 // destination is interpreted: | |
| 143 // from_compiled_code_entry_point -> c2iadapter | |
| 144 // from_interpreter_entry_point -> interpreter entry point | |
| 145 // destination is compiled: | |
| 146 // from_compiled_code_entry_point -> nmethod entry point | |
| 147 // from_interpreter_entry_point -> i2cadapter | |
| 148 class vtableEntry VALUE_OBJ_CLASS_SPEC { | |
| 149 public: | |
| 150 // size in words | |
| 151 static int size() { | |
| 152 return sizeof(vtableEntry) / sizeof(HeapWord); | |
| 153 } | |
| 154 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
|
155 Method* method() const { return _method; } |
| 0 | 156 |
| 157 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
158 Method* _method; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
159 void set(Method* method) { assert(method != NULL, "use clear"); _method = method; } |
| 0 | 160 void clear() { _method = NULL; } |
| 161 void print() PRODUCT_RETURN; | |
| 162 void verify(klassVtable* vt, outputStream* st); | |
| 163 | |
| 164 friend class klassVtable; | |
| 165 }; | |
| 166 | |
| 167 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
168 inline Method* klassVtable::method_at(int i) const { |
| 0 | 169 assert(i >= 0 && i < _length, "index out of bounds"); |
| 170 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
|
171 assert(((Metadata*)table()[i].method())->is_method(), "should be method"); |
| 0 | 172 return table()[i].method(); |
| 173 } | |
| 174 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
175 inline Method* klassVtable::unchecked_method_at(int i) const { |
| 0 | 176 assert(i >= 0 && i < _length, "index out of bounds"); |
| 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::adr_method_at(int i) const { |
| 0 | 181 // Allow one past the last entry to be referenced; useful for loop bounds. |
| 182 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
|
183 return (Method**)(address(table() + i) + vtableEntry::method_offset_in_bytes()); |
| 0 | 184 } |
| 185 | |
| 186 // -------------------------------------------------------------------------------- | |
| 187 class klassItable; | |
| 188 class itableMethodEntry; | |
| 189 | |
| 190 class itableOffsetEntry VALUE_OBJ_CLASS_SPEC { | |
| 191 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
192 Klass* _interface; |
| 0 | 193 int _offset; |
| 194 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
195 Klass* interface_klass() const { return _interface; } |
| 0 | 196 int offset() const { return _offset; } |
| 197 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
198 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
|
199 itableMethodEntry* first_method_entry(Klass* k) { return method_entry(k, _offset); } |
| 0 | 200 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
201 void initialize(Klass* interf, int offset) { _interface = interf; _offset = offset; } |
| 0 | 202 |
| 203 // Static size and offset accessors | |
| 204 static int size() { return sizeof(itableOffsetEntry) / HeapWordSize; } // size in words | |
| 205 static int interface_offset_in_bytes() { return offset_of(itableOffsetEntry, _interface); } | |
| 206 static int offset_offset_in_bytes() { return offset_of(itableOffsetEntry, _offset); } | |
| 207 | |
| 208 friend class klassItable; | |
| 209 }; | |
| 210 | |
| 211 | |
| 212 class itableMethodEntry VALUE_OBJ_CLASS_SPEC { | |
| 213 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
214 Method* _method; |
| 0 | 215 |
| 216 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
217 Method* method() const { return _method; } |
| 0 | 218 |
| 219 void clear() { _method = NULL; } | |
| 220 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
221 void initialize(Method* method); |
| 0 | 222 |
| 223 // Static size and offset accessors | |
| 224 static int size() { return sizeof(itableMethodEntry) / HeapWordSize; } // size in words | |
| 225 static int method_offset_in_bytes() { return offset_of(itableMethodEntry, _method); } | |
| 226 | |
| 227 friend class klassItable; | |
| 228 }; | |
| 229 | |
| 230 // | |
| 231 // Format of an itable | |
| 232 // | |
| 233 // ---- offset table --- | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
234 // Klass* of interface 1 \ |
| 0 | 235 // offset to vtable from start of oop / offset table entry |
| 236 // ... | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
237 // Klass* of interface n \ |
| 0 | 238 // offset to vtable from start of oop / offset table entry |
| 239 // --- vtable for interface 1 --- | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
240 // Method* \ |
| 0 | 241 // compiler entry point / method table entry |
| 242 // ... | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
243 // Method* \ |
| 0 | 244 // compiler entry point / method table entry |
| 245 // -- vtable for interface 2 --- | |
| 246 // ... | |
| 247 // | |
| 248 class klassItable : public ResourceObj { | |
| 249 private: | |
| 250 instanceKlassHandle _klass; // my klass | |
| 251 int _table_offset; // offset of start of itable data within klass (in words) | |
| 252 int _size_offset_table; // size of offset table (in itableOffset entries) | |
| 253 int _size_method_table; // size of methodtable (in itableMethodEntry entries) | |
| 254 | |
| 255 void initialize_itable_for_interface(int method_table_offset, KlassHandle interf_h, bool checkconstraints, TRAPS); | |
| 256 public: | |
| 257 klassItable(instanceKlassHandle klass); | |
| 258 | |
| 259 itableOffsetEntry* offset_entry(int i) { assert(0 <= i && i <= _size_offset_table, "index out of bounds"); | |
| 260 return &((itableOffsetEntry*)vtable_start())[i]; } | |
| 261 | |
| 262 itableMethodEntry* method_entry(int i) { assert(0 <= i && i <= _size_method_table, "index out of bounds"); | |
| 263 return &((itableMethodEntry*)method_start())[i]; } | |
| 264 | |
|
16
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
265 int size_offset_table() { return _size_offset_table; } |
| 0 | 266 |
| 267 // Initialization | |
| 268 void initialize_itable(bool checkconstraints, TRAPS); | |
| 269 | |
| 270 // Updates | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
271 void initialize_with_method(Method* m); |
| 0 | 272 |
| 273 // RedefineClasses() API support: | |
| 274 // if any entry of this itable points to any of old_methods, | |
| 275 // replace it with the corresponding new_method. | |
| 276 // trace_name_printed is set to true if the current call has | |
| 277 // printed the klass name so that other routines in the adjust_* | |
| 278 // group don't print the klass name. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
279 void adjust_method_entries(Method** old_methods, Method** new_methods, |
| 0 | 280 int methods_length, bool * trace_name_printed); |
| 281 | |
| 282 // Setup of itable | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
283 static int compute_itable_size(Array<Klass*>* transitive_interfaces); |
| 0 | 284 static void setup_itable_offset_table(instanceKlassHandle klass); |
| 285 | |
| 286 // Resolving of method to index | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
287 static int compute_itable_index(Method* m); |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
16
diff
changeset
|
288 // ...and back again: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
289 static Method* method_for_itable_index(Klass* klass, int itable_index); |
| 0 | 290 |
| 291 // Debugging/Statistics | |
| 292 static void print_statistics() PRODUCT_RETURN; | |
| 293 private: | |
| 294 intptr_t* vtable_start() const { return ((intptr_t*)_klass()) + _table_offset; } | |
| 295 intptr_t* method_start() const { return vtable_start() + _size_offset_table * itableOffsetEntry::size(); } | |
| 296 | |
| 297 // Helper methods | |
| 298 static int calc_itable_size(int num_interfaces, int num_methods) { return (num_interfaces * itableOffsetEntry::size()) + (num_methods * itableMethodEntry::size()); } | |
| 299 | |
| 300 // Statistics | |
| 301 NOT_PRODUCT(static int _total_classes;) // Total no. of classes with itables | |
| 302 NOT_PRODUCT(static long _total_size;) // Total no. of bytes used for itables | |
| 303 | |
| 304 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
|
305 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
306 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
307 #ifndef PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
308 bool check_no_old_entries(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
309 #endif |
| 0 | 310 }; |
| 1972 | 311 |
| 312 #endif // SHARE_VM_OOPS_KLASSVTABLE_HPP |