Mercurial > hg > truffle
annotate src/share/vm/oops/klassVtable.hpp @ 14649:f6301b007a16
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Wed, 26 Feb 2014 15:20:41 -0800 |
| parents | ac9cb1d5a202 |
| children |
| 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. | |
|
12823
ac9cb1d5a202
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
12264
diff
changeset
|
100 bool adjust_default_method(int vtable_index, Method* old_method, Method* new_method); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
101 void adjust_method_entries(Method** old_methods, Method** new_methods, |
| 0 | 102 int methods_length, bool * trace_name_printed); |
|
8021
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
103 bool check_no_old_or_obsolete_entries(); |
|
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
104 void dump_vtable(); |
|
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
105 #endif // INCLUDE_JVMTI |
| 0 | 106 |
| 107 // Debugging code | |
| 108 void print() PRODUCT_RETURN; | |
| 109 void verify(outputStream* st, bool force = false); | |
| 110 static void print_statistics() PRODUCT_RETURN; | |
| 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 |
|
12823
ac9cb1d5a202
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
12264
diff
changeset
|
122 bool update_inherited_vtable(InstanceKlass* klass, methodHandle target_method, int super_vtable_len, int default_index, bool checkconstraints, TRAPS); |
|
6725
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); | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12258
diff
changeset
|
128 int fill_in_mirandas(int initialized); |
|
12823
ac9cb1d5a202
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
12264
diff
changeset
|
129 static bool is_miranda(Method* m, Array<Method*>* class_methods, |
|
ac9cb1d5a202
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
12264
diff
changeset
|
130 Array<Method*>* default_methods, Klass* super); |
| 6934 | 131 static void add_new_mirandas_to_lists( |
| 132 GrowableArray<Method*>* new_mirandas, | |
| 133 GrowableArray<Method*>* all_mirandas, | |
|
12823
ac9cb1d5a202
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
12264
diff
changeset
|
134 Array<Method*>* current_interface_methods, |
|
ac9cb1d5a202
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
12264
diff
changeset
|
135 Array<Method*>* class_methods, |
|
ac9cb1d5a202
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
12264
diff
changeset
|
136 Array<Method*>* default_methods, |
| 6934 | 137 Klass* super); |
| 138 static void get_mirandas( | |
| 139 GrowableArray<Method*>* new_mirandas, | |
| 140 GrowableArray<Method*>* all_mirandas, Klass* super, | |
|
12823
ac9cb1d5a202
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
12264
diff
changeset
|
141 Array<Method*>* class_methods, |
|
ac9cb1d5a202
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
12264
diff
changeset
|
142 Array<Method*>* default_methods, |
|
ac9cb1d5a202
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
12264
diff
changeset
|
143 Array<Klass*>* local_interfaces); |
| 0 | 144 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
|
145 inline InstanceKlass* ik() const; |
| 0 | 146 }; |
| 147 | |
| 148 | |
| 149 // private helper class for klassVtable | |
| 150 // description of entry points: | |
| 151 // destination is interpreted: | |
| 152 // from_compiled_code_entry_point -> c2iadapter | |
| 153 // from_interpreter_entry_point -> interpreter entry point | |
| 154 // destination is compiled: | |
| 155 // from_compiled_code_entry_point -> nmethod entry point | |
| 156 // from_interpreter_entry_point -> i2cadapter | |
| 157 class vtableEntry VALUE_OBJ_CLASS_SPEC { | |
|
12258
69f26e8e09f9
8024760: add more types, fields and constants to VMStructs
twisti
parents:
8021
diff
changeset
|
158 friend class VMStructs; |
|
69f26e8e09f9
8024760: add more types, fields and constants to VMStructs
twisti
parents:
8021
diff
changeset
|
159 |
| 0 | 160 public: |
| 161 // size in words | |
| 162 static int size() { | |
| 163 return sizeof(vtableEntry) / sizeof(HeapWord); | |
| 164 } | |
| 165 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
|
166 Method* method() const { return _method; } |
| 0 | 167 |
| 168 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
169 Method* _method; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
170 void set(Method* method) { assert(method != NULL, "use clear"); _method = method; } |
| 0 | 171 void clear() { _method = NULL; } |
| 172 void print() PRODUCT_RETURN; | |
| 173 void verify(klassVtable* vt, outputStream* st); | |
| 174 | |
| 175 friend class klassVtable; | |
| 176 }; | |
| 177 | |
| 178 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
179 inline Method* klassVtable::method_at(int i) const { |
| 0 | 180 assert(i >= 0 && i < _length, "index out of bounds"); |
| 181 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
|
182 assert(((Metadata*)table()[i].method())->is_method(), "should be method"); |
| 0 | 183 return table()[i].method(); |
| 184 } | |
| 185 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
186 inline Method* klassVtable::unchecked_method_at(int i) const { |
| 0 | 187 assert(i >= 0 && i < _length, "index out of bounds"); |
| 188 return table()[i].method(); | |
| 189 } | |
| 190 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
191 inline Method** klassVtable::adr_method_at(int i) const { |
| 0 | 192 // Allow one past the last entry to be referenced; useful for loop bounds. |
| 193 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
|
194 return (Method**)(address(table() + i) + vtableEntry::method_offset_in_bytes()); |
| 0 | 195 } |
| 196 | |
| 197 // -------------------------------------------------------------------------------- | |
| 198 class klassItable; | |
| 199 class itableMethodEntry; | |
| 200 | |
| 201 class itableOffsetEntry VALUE_OBJ_CLASS_SPEC { | |
| 202 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
203 Klass* _interface; |
| 0 | 204 int _offset; |
| 205 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
206 Klass* interface_klass() const { return _interface; } |
| 0 | 207 int offset() const { return _offset; } |
| 208 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
209 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
|
210 itableMethodEntry* first_method_entry(Klass* k) { return method_entry(k, _offset); } |
| 0 | 211 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
212 void initialize(Klass* interf, int offset) { _interface = interf; _offset = offset; } |
| 0 | 213 |
| 214 // Static size and offset accessors | |
| 215 static int size() { return sizeof(itableOffsetEntry) / HeapWordSize; } // size in words | |
| 216 static int interface_offset_in_bytes() { return offset_of(itableOffsetEntry, _interface); } | |
| 217 static int offset_offset_in_bytes() { return offset_of(itableOffsetEntry, _offset); } | |
| 218 | |
| 219 friend class klassItable; | |
| 220 }; | |
| 221 | |
| 222 | |
| 223 class itableMethodEntry VALUE_OBJ_CLASS_SPEC { | |
| 224 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
225 Method* _method; |
| 0 | 226 |
| 227 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
228 Method* method() const { return _method; } |
| 0 | 229 |
| 230 void clear() { _method = NULL; } | |
| 231 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
232 void initialize(Method* method); |
| 0 | 233 |
| 234 // Static size and offset accessors | |
| 235 static int size() { return sizeof(itableMethodEntry) / HeapWordSize; } // size in words | |
| 236 static int method_offset_in_bytes() { return offset_of(itableMethodEntry, _method); } | |
| 237 | |
| 238 friend class klassItable; | |
| 239 }; | |
| 240 | |
| 241 // | |
| 242 // Format of an itable | |
| 243 // | |
| 244 // ---- offset table --- | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
245 // Klass* of interface 1 \ |
| 0 | 246 // offset to vtable from start of oop / offset table entry |
| 247 // ... | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
248 // Klass* of interface n \ |
| 0 | 249 // offset to vtable from start of oop / offset table entry |
| 250 // --- vtable for interface 1 --- | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
251 // Method* \ |
| 0 | 252 // compiler entry point / method table entry |
| 253 // ... | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
254 // Method* \ |
| 0 | 255 // compiler entry point / method table entry |
| 256 // -- vtable for interface 2 --- | |
| 257 // ... | |
| 258 // | |
| 259 class klassItable : public ResourceObj { | |
| 260 private: | |
| 261 instanceKlassHandle _klass; // my klass | |
| 262 int _table_offset; // offset of start of itable data within klass (in words) | |
| 263 int _size_offset_table; // size of offset table (in itableOffset entries) | |
| 264 int _size_method_table; // size of methodtable (in itableMethodEntry entries) | |
| 265 | |
| 266 void initialize_itable_for_interface(int method_table_offset, KlassHandle interf_h, bool checkconstraints, TRAPS); | |
| 267 public: | |
| 268 klassItable(instanceKlassHandle klass); | |
| 269 | |
| 270 itableOffsetEntry* offset_entry(int i) { assert(0 <= i && i <= _size_offset_table, "index out of bounds"); | |
| 271 return &((itableOffsetEntry*)vtable_start())[i]; } | |
| 272 | |
| 273 itableMethodEntry* method_entry(int i) { assert(0 <= i && i <= _size_method_table, "index out of bounds"); | |
| 274 return &((itableMethodEntry*)method_start())[i]; } | |
| 275 | |
|
16
f8236e79048a
6664627: Merge changes made only in hotspot 11 forward to jdk 7
dcubed
parents:
0
diff
changeset
|
276 int size_offset_table() { return _size_offset_table; } |
| 0 | 277 |
| 278 // Initialization | |
| 279 void initialize_itable(bool checkconstraints, TRAPS); | |
| 280 | |
| 281 // Updates | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
282 void initialize_with_method(Method* m); |
| 0 | 283 |
|
8021
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
284 #if INCLUDE_JVMTI |
| 0 | 285 // RedefineClasses() API support: |
| 286 // if any entry of this itable points to any of old_methods, | |
| 287 // replace it with the corresponding new_method. | |
| 288 // trace_name_printed is set to true if the current call has | |
| 289 // printed the klass name so that other routines in the adjust_* | |
| 290 // group don't print the klass name. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
291 void adjust_method_entries(Method** old_methods, Method** new_methods, |
| 0 | 292 int methods_length, bool * trace_name_printed); |
|
8021
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
293 bool check_no_old_or_obsolete_entries(); |
|
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
294 void dump_itable(); |
|
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
6934
diff
changeset
|
295 #endif // INCLUDE_JVMTI |
| 0 | 296 |
| 297 // Setup of itable | |
|
12823
ac9cb1d5a202
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
12264
diff
changeset
|
298 static int assign_itable_indices_for_interface(Klass* klass); |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12258
diff
changeset
|
299 static int method_count_for_interface(Klass* klass); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
300 static int compute_itable_size(Array<Klass*>* transitive_interfaces); |
| 0 | 301 static void setup_itable_offset_table(instanceKlassHandle klass); |
| 302 | |
| 303 // Resolving of method to index | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3245
diff
changeset
|
304 static Method* method_for_itable_index(Klass* klass, int itable_index); |
| 0 | 305 |
| 306 // Debugging/Statistics | |
| 307 static void print_statistics() PRODUCT_RETURN; | |
| 308 private: | |
| 309 intptr_t* vtable_start() const { return ((intptr_t*)_klass()) + _table_offset; } | |
| 310 intptr_t* method_start() const { return vtable_start() + _size_offset_table * itableOffsetEntry::size(); } | |
| 311 | |
| 312 // Helper methods | |
| 313 static int calc_itable_size(int num_interfaces, int num_methods) { return (num_interfaces * itableOffsetEntry::size()) + (num_methods * itableMethodEntry::size()); } | |
| 314 | |
| 315 // Statistics | |
| 316 NOT_PRODUCT(static int _total_classes;) // Total no. of classes with itables | |
| 317 NOT_PRODUCT(static long _total_size;) // Total no. of bytes used for itables | |
| 318 | |
| 319 static void update_stats(int size) PRODUCT_RETURN NOT_PRODUCT({ _total_classes++; _total_size += size; }) | |
| 320 }; | |
| 1972 | 321 |
| 322 #endif // SHARE_VM_OOPS_KLASSVTABLE_HPP |