Mercurial > hg > truffle
annotate src/share/vm/oops/klassVtable.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 | 8d9fc28831cc |
| children | 69f26e8e09f9 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
8021
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
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:
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 |
|
8021
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
93 #if INCLUDE_JVMTI |
| 0 | 94 // RedefineClasses() API support: |
| 95 // If any entry of this vtable points to any of old_methods, | |
| 96 // replace it with the corresponding new_method. | |
| 97 // trace_name_printed is set to true if the current call has | |
| 98 // printed the klass name so that other routines in the adjust_* | |
| 99 // group don't print the klass name. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
100 void adjust_method_entries(Method** old_methods, Method** new_methods, |
| 0 | 101 int methods_length, bool * trace_name_printed); |
|
8021
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
102 bool check_no_old_or_obsolete_entries(); |
|
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
103 void dump_vtable(); |
|
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
104 #endif // INCLUDE_JVMTI |
| 0 | 105 |
| 106 // Debugging code | |
| 107 void print() PRODUCT_RETURN; | |
| 108 void verify(outputStream* st, bool force = false); | |
| 109 static void print_statistics() PRODUCT_RETURN; | |
| 110 | |
| 111 protected: | |
| 112 friend class vtableEntry; | |
| 113 private: | |
|
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
16
diff
changeset
|
114 enum { VTABLE_TRANSITIVE_OVERRIDE_VERSION = 51 } ; |
| 0 | 115 void copy_vtable_to(vtableEntry* start); |
| 116 int initialize_from_super(KlassHandle super); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
117 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
|
118 void put_method_at(Method* m, int index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
119 static bool needs_new_vtable_entry(methodHandle m, Klass* super, Handle classloader, Symbol* classname, AccessFlags access_flags, TRAPS); |
| 0 | 120 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
121 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
|
122 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
|
123 Handle target_loader, Symbol* target_classname, Thread* THREAD); |
| 0 | 124 |
| 125 // support for miranda methods | |
| 126 bool is_miranda_entry_at(int i); | |
| 6934 | 127 void fill_in_mirandas(int* initialized); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
128 static bool is_miranda(Method* m, Array<Method*>* class_methods, Klass* super); |
| 6934 | 129 static void add_new_mirandas_to_lists( |
| 130 GrowableArray<Method*>* new_mirandas, | |
| 131 GrowableArray<Method*>* all_mirandas, | |
| 132 Array<Method*>* current_interface_methods, Array<Method*>* class_methods, | |
| 133 Klass* super); | |
| 134 static void get_mirandas( | |
| 135 GrowableArray<Method*>* new_mirandas, | |
| 136 GrowableArray<Method*>* all_mirandas, Klass* super, | |
| 137 Array<Method*>* class_methods, Array<Klass*>* local_interfaces); | |
| 0 | 138 |
| 139 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
|
140 inline InstanceKlass* ik() const; |
| 0 | 141 }; |
| 142 | |
| 143 | |
| 144 // private helper class for klassVtable | |
| 145 // description of entry points: | |
| 146 // destination is interpreted: | |
| 147 // from_compiled_code_entry_point -> c2iadapter | |
| 148 // from_interpreter_entry_point -> interpreter entry point | |
| 149 // destination is compiled: | |
| 150 // from_compiled_code_entry_point -> nmethod entry point | |
| 151 // from_interpreter_entry_point -> i2cadapter | |
| 152 class vtableEntry VALUE_OBJ_CLASS_SPEC { | |
| 153 public: | |
| 154 // size in words | |
| 155 static int size() { | |
| 156 return sizeof(vtableEntry) / sizeof(HeapWord); | |
| 157 } | |
| 158 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
|
159 Method* method() const { return _method; } |
| 0 | 160 |
| 161 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
162 Method* _method; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
163 void set(Method* method) { assert(method != NULL, "use clear"); _method = method; } |
| 0 | 164 void clear() { _method = NULL; } |
| 165 void print() PRODUCT_RETURN; | |
| 166 void verify(klassVtable* vt, outputStream* st); | |
| 167 | |
| 168 friend class klassVtable; | |
| 169 }; | |
| 170 | |
| 171 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
172 inline Method* klassVtable::method_at(int i) const { |
| 0 | 173 assert(i >= 0 && i < _length, "index out of bounds"); |
| 174 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
|
175 assert(((Metadata*)table()[i].method())->is_method(), "should be method"); |
| 0 | 176 return table()[i].method(); |
| 177 } | |
| 178 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
179 inline Method* klassVtable::unchecked_method_at(int i) const { |
| 0 | 180 assert(i >= 0 && i < _length, "index out of bounds"); |
| 181 return table()[i].method(); | |
| 182 } | |
| 183 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
184 inline Method** klassVtable::adr_method_at(int i) const { |
| 0 | 185 // Allow one past the last entry to be referenced; useful for loop bounds. |
| 186 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
|
187 return (Method**)(address(table() + i) + vtableEntry::method_offset_in_bytes()); |
| 0 | 188 } |
| 189 | |
| 190 // -------------------------------------------------------------------------------- | |
| 191 class klassItable; | |
| 192 class itableMethodEntry; | |
| 193 | |
| 194 class itableOffsetEntry VALUE_OBJ_CLASS_SPEC { | |
| 195 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
196 Klass* _interface; |
| 0 | 197 int _offset; |
| 198 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
199 Klass* interface_klass() const { return _interface; } |
| 0 | 200 int offset() const { return _offset; } |
| 201 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
202 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
|
203 itableMethodEntry* first_method_entry(Klass* k) { return method_entry(k, _offset); } |
| 0 | 204 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
205 void initialize(Klass* interf, int offset) { _interface = interf; _offset = offset; } |
| 0 | 206 |
| 207 // Static size and offset accessors | |
| 208 static int size() { return sizeof(itableOffsetEntry) / HeapWordSize; } // size in words | |
| 209 static int interface_offset_in_bytes() { return offset_of(itableOffsetEntry, _interface); } | |
| 210 static int offset_offset_in_bytes() { return offset_of(itableOffsetEntry, _offset); } | |
| 211 | |
| 212 friend class klassItable; | |
| 213 }; | |
| 214 | |
| 215 | |
| 216 class itableMethodEntry VALUE_OBJ_CLASS_SPEC { | |
| 217 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
218 Method* _method; |
| 0 | 219 |
| 220 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
221 Method* method() const { return _method; } |
| 0 | 222 |
| 223 void clear() { _method = NULL; } | |
| 224 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
225 void initialize(Method* method); |
| 0 | 226 |
| 227 // Static size and offset accessors | |
| 228 static int size() { return sizeof(itableMethodEntry) / HeapWordSize; } // size in words | |
| 229 static int method_offset_in_bytes() { return offset_of(itableMethodEntry, _method); } | |
| 230 | |
| 231 friend class klassItable; | |
| 232 }; | |
| 233 | |
| 234 // | |
| 235 // Format of an itable | |
| 236 // | |
| 237 // ---- offset table --- | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
238 // Klass* of interface 1 \ |
| 0 | 239 // offset to vtable from start of oop / offset table entry |
| 240 // ... | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
241 // Klass* of interface n \ |
| 0 | 242 // offset to vtable from start of oop / offset table entry |
| 243 // --- vtable for interface 1 --- | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
244 // Method* \ |
| 0 | 245 // compiler entry point / method table entry |
| 246 // ... | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
247 // Method* \ |
| 0 | 248 // compiler entry point / method table entry |
| 249 // -- vtable for interface 2 --- | |
| 250 // ... | |
| 251 // | |
| 252 class klassItable : public ResourceObj { | |
| 253 private: | |
| 254 instanceKlassHandle _klass; // my klass | |
| 255 int _table_offset; // offset of start of itable data within klass (in words) | |
| 256 int _size_offset_table; // size of offset table (in itableOffset entries) | |
| 257 int _size_method_table; // size of methodtable (in itableMethodEntry entries) | |
| 258 | |
| 259 void initialize_itable_for_interface(int method_table_offset, KlassHandle interf_h, bool checkconstraints, TRAPS); | |
| 260 public: | |
| 261 klassItable(instanceKlassHandle klass); | |
| 262 | |
| 263 itableOffsetEntry* offset_entry(int i) { assert(0 <= i && i <= _size_offset_table, "index out of bounds"); | |
| 264 return &((itableOffsetEntry*)vtable_start())[i]; } | |
| 265 | |
| 266 itableMethodEntry* method_entry(int i) { assert(0 <= i && i <= _size_method_table, "index out of bounds"); | |
| 267 return &((itableMethodEntry*)method_start())[i]; } | |
| 268 | |
|
16
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
269 int size_offset_table() { return _size_offset_table; } |
| 0 | 270 |
| 271 // Initialization | |
| 272 void initialize_itable(bool checkconstraints, TRAPS); | |
| 273 | |
| 274 // Updates | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
275 void initialize_with_method(Method* m); |
| 0 | 276 |
|
8021
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
277 #if INCLUDE_JVMTI |
| 0 | 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); |
|
8021
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
286 bool check_no_old_or_obsolete_entries(); |
|
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
287 void dump_itable(); |
|
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
288 #endif // INCLUDE_JVMTI |
| 0 | 289 |
| 290 // Setup of itable | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
291 static int compute_itable_size(Array<Klass*>* transitive_interfaces); |
| 0 | 292 static void setup_itable_offset_table(instanceKlassHandle klass); |
| 293 | |
| 294 // Resolving of method to index | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
295 static int compute_itable_index(Method* m); |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
16
diff
changeset
|
296 // ...and back again: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
297 static Method* method_for_itable_index(Klass* klass, int itable_index); |
| 0 | 298 |
| 299 // Debugging/Statistics | |
| 300 static void print_statistics() PRODUCT_RETURN; | |
| 301 private: | |
| 302 intptr_t* vtable_start() const { return ((intptr_t*)_klass()) + _table_offset; } | |
| 303 intptr_t* method_start() const { return vtable_start() + _size_offset_table * itableOffsetEntry::size(); } | |
| 304 | |
| 305 // Helper methods | |
| 306 static int calc_itable_size(int num_interfaces, int num_methods) { return (num_interfaces * itableOffsetEntry::size()) + (num_methods * itableMethodEntry::size()); } | |
| 307 | |
| 308 // Statistics | |
| 309 NOT_PRODUCT(static int _total_classes;) // Total no. of classes with itables | |
| 310 NOT_PRODUCT(static long _total_size;) // Total no. of bytes used for itables | |
| 311 | |
| 312 static void update_stats(int size) PRODUCT_RETURN NOT_PRODUCT({ _total_classes++; _total_size += size; }) | |
| 313 }; | |
| 1972 | 314 |
| 315 #endif // SHARE_VM_OOPS_KLASSVTABLE_HPP |