author | kvn |
Thu, 16 Apr 2015 14:05:48 -0700 | |
changeset 30227 | fdb68fee3e41 |
parent 30222 | bfe6be3c4ef8 |
parent 30164 | 0c9f9e006921 |
child 30764 | fec48bf5a827 |
child 31037 | 01a5c5fa5681 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
2 |
* Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. |
1 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
26 |
#include "classfile/javaClasses.hpp" |
|
27 |
#include "classfile/systemDictionary.hpp" |
|
28 |
#include "classfile/verifier.hpp" |
|
29 |
#include "classfile/vmSymbols.hpp" |
|
30 |
#include "compiler/compileBroker.hpp" |
|
31 |
#include "gc_interface/collectedHeap.inline.hpp" |
|
32 |
#include "interpreter/oopMapCache.hpp" |
|
33 |
#include "interpreter/rewriter.hpp" |
|
34 |
#include "jvmtifiles/jvmti.h" |
|
15437 | 35 |
#include "memory/heapInspection.hpp" |
25356
4a4a482298a6
8046670: Make CMS metadata aware closures applicable for other collectors
stefank
parents:
25351
diff
changeset
|
36 |
#include "memory/iterator.inline.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
37 |
#include "memory/metadataFactory.hpp" |
7397 | 38 |
#include "memory/oopFactory.hpp" |
29688 | 39 |
#include "memory/specialized_oop_closures.hpp" |
10546 | 40 |
#include "oops/fieldStreams.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
41 |
#include "oops/instanceClassLoaderKlass.hpp" |
30150
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
29792
diff
changeset
|
42 |
#include "oops/instanceKlass.inline.hpp" |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
43 |
#include "oops/instanceMirrorKlass.hpp" |
7397 | 44 |
#include "oops/instanceOop.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
45 |
#include "oops/klass.inline.hpp" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
46 |
#include "oops/method.hpp" |
7397 | 47 |
#include "oops/oop.inline.hpp" |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
48 |
#include "oops/symbol.hpp" |
7397 | 49 |
#include "prims/jvmtiExport.hpp" |
50 |
#include "prims/jvmtiRedefineClassesTrace.hpp" |
|
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
51 |
#include "prims/jvmtiRedefineClasses.hpp" |
22897
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
52 |
#include "prims/jvmtiThreadState.hpp" |
15099
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
53 |
#include "prims/methodComparator.hpp" |
25351
7c198a690050
8044775: Improve usage of umbrella header atomic.inline.hpp.
goetz
parents:
24828
diff
changeset
|
54 |
#include "runtime/atomic.inline.hpp" |
7397 | 55 |
#include "runtime/fieldDescriptor.hpp" |
56 |
#include "runtime/handles.inline.hpp" |
|
57 |
#include "runtime/javaCalls.hpp" |
|
58 |
#include "runtime/mutexLocker.hpp" |
|
24351
61b33cc6d3cf
8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents:
24322
diff
changeset
|
59 |
#include "runtime/orderAccess.inline.hpp" |
14583
d70ee55535f4
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
14490
diff
changeset
|
60 |
#include "runtime/thread.inline.hpp" |
17075
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
61 |
#include "services/classLoadingService.hpp" |
7397 | 62 |
#include "services/threadService.hpp" |
63 |
#include "utilities/dtrace.hpp" |
|
15482
470d0b0c09f1
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
15216
diff
changeset
|
64 |
#include "utilities/macros.hpp" |
7397 | 65 |
#ifdef COMPILER1 |
66 |
#include "c1/c1_Compiler.hpp" |
|
67 |
#endif |
|
1 | 68 |
|
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
24351
diff
changeset
|
69 |
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC |
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
24351
diff
changeset
|
70 |
|
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
71 |
#ifdef DTRACE_ENABLED |
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
72 |
|
10739 | 73 |
|
74 |
#define HOTSPOT_CLASS_INITIALIZATION_required HOTSPOT_CLASS_INITIALIZATION_REQUIRED |
|
75 |
#define HOTSPOT_CLASS_INITIALIZATION_recursive HOTSPOT_CLASS_INITIALIZATION_RECURSIVE |
|
76 |
#define HOTSPOT_CLASS_INITIALIZATION_concurrent HOTSPOT_CLASS_INITIALIZATION_CONCURRENT |
|
77 |
#define HOTSPOT_CLASS_INITIALIZATION_erroneous HOTSPOT_CLASS_INITIALIZATION_ERRONEOUS |
|
78 |
#define HOTSPOT_CLASS_INITIALIZATION_super__failed HOTSPOT_CLASS_INITIALIZATION_SUPER_FAILED |
|
79 |
#define HOTSPOT_CLASS_INITIALIZATION_clinit HOTSPOT_CLASS_INITIALIZATION_CLINIT |
|
80 |
#define HOTSPOT_CLASS_INITIALIZATION_error HOTSPOT_CLASS_INITIALIZATION_ERROR |
|
81 |
#define HOTSPOT_CLASS_INITIALIZATION_end HOTSPOT_CLASS_INITIALIZATION_END |
|
82 |
#define DTRACE_CLASSINIT_PROBE(type, clss, thread_type) \ |
|
83 |
{ \ |
|
84 |
char* data = NULL; \ |
|
85 |
int len = 0; \ |
|
86 |
Symbol* name = (clss)->name(); \ |
|
87 |
if (name != NULL) { \ |
|
88 |
data = (char*)name->bytes(); \ |
|
89 |
len = name->utf8_length(); \ |
|
90 |
} \ |
|
91 |
HOTSPOT_CLASS_INITIALIZATION_##type( \ |
|
92 |
data, len, (clss)->class_loader(), thread_type); \ |
|
93 |
} |
|
94 |
||
95 |
#define DTRACE_CLASSINIT_PROBE_WAIT(type, clss, thread_type, wait) \ |
|
96 |
{ \ |
|
97 |
char* data = NULL; \ |
|
98 |
int len = 0; \ |
|
99 |
Symbol* name = (clss)->name(); \ |
|
100 |
if (name != NULL) { \ |
|
101 |
data = (char*)name->bytes(); \ |
|
102 |
len = name->utf8_length(); \ |
|
103 |
} \ |
|
104 |
HOTSPOT_CLASS_INITIALIZATION_##type( \ |
|
105 |
data, len, (clss)->class_loader(), thread_type, wait); \ |
|
106 |
} |
|
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
107 |
|
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
108 |
#else // ndef DTRACE_ENABLED |
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
109 |
|
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
110 |
#define DTRACE_CLASSINIT_PROBE(type, clss, thread_type) |
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
111 |
#define DTRACE_CLASSINIT_PROBE_WAIT(type, clss, thread_type, wait) |
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
112 |
|
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
113 |
#endif // ndef DTRACE_ENABLED |
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
114 |
|
15104
f5d78994619f
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
14583
diff
changeset
|
115 |
volatile int InstanceKlass::_total_instanceKlass_count = 0; |
f5d78994619f
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
14583
diff
changeset
|
116 |
|
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
117 |
InstanceKlass* InstanceKlass::allocate_instance_klass( |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
118 |
ClassLoaderData* loader_data, |
15601 | 119 |
int vtable_len, |
120 |
int itable_len, |
|
121 |
int static_field_size, |
|
122 |
int nonstatic_oop_map_size, |
|
123 |
ReferenceType rt, |
|
124 |
AccessFlags access_flags, |
|
125 |
Symbol* name, |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
126 |
Klass* super_klass, |
15601 | 127 |
bool is_anonymous, |
128 |
TRAPS) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
129 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
130 |
int size = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size, |
15601 | 131 |
access_flags.is_interface(), is_anonymous); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
132 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
133 |
// Allocation |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
134 |
InstanceKlass* ik; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
135 |
if (rt == REF_NONE) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
136 |
if (name == vmSymbols::java_lang_Class()) { |
13738
d67be49a5beb
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
13736
diff
changeset
|
137 |
ik = new (loader_data, size, THREAD) InstanceMirrorKlass( |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
138 |
vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, |
15601 | 139 |
access_flags, is_anonymous); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
140 |
} else if (name == vmSymbols::java_lang_ClassLoader() || |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
141 |
(SystemDictionary::ClassLoader_klass_loaded() && |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
142 |
super_klass != NULL && |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
143 |
super_klass->is_subtype_of(SystemDictionary::ClassLoader_klass()))) { |
13738
d67be49a5beb
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
13736
diff
changeset
|
144 |
ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass( |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
145 |
vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, |
15601 | 146 |
access_flags, is_anonymous); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
147 |
} else { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
148 |
// normal class |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
149 |
ik = new (loader_data, size, THREAD) InstanceKlass( |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
150 |
vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, |
15601 | 151 |
access_flags, is_anonymous); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
152 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
153 |
} else { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
154 |
// reference klass |
13738
d67be49a5beb
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
13736
diff
changeset
|
155 |
ik = new (loader_data, size, THREAD) InstanceRefKlass( |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
156 |
vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, |
15601 | 157 |
access_flags, is_anonymous); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
158 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
159 |
|
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
160 |
// Check for pending exception before adding to the loader data and incrementing |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
161 |
// class count. Can get OOM here. |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
162 |
if (HAS_PENDING_EXCEPTION) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
163 |
return NULL; |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
164 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
165 |
|
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
166 |
// Add all classes to our internal class loader list here, |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
167 |
// including classes in the bootstrap (NULL) class loader. |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
168 |
loader_data->add_class(ik); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
169 |
|
15104
f5d78994619f
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
14583
diff
changeset
|
170 |
Atomic::inc(&_total_instanceKlass_count); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
171 |
return ik; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
172 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
173 |
|
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
174 |
|
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
175 |
// copy method ordering from resource area to Metaspace |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
176 |
void InstanceKlass::copy_method_ordering(intArray* m, TRAPS) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
177 |
if (m != NULL) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
178 |
// allocate a new array and copy contents (memcpy?) |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
179 |
_method_ordering = MetadataFactory::new_array<int>(class_loader_data(), m->length(), CHECK); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
180 |
for (int i = 0; i < m->length(); i++) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
181 |
_method_ordering->at_put(i, m->at(i)); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
182 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
183 |
} else { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
184 |
_method_ordering = Universe::the_empty_int_array(); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
185 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
186 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
187 |
|
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
188 |
// create a new array of vtable_indices for default methods |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
189 |
Array<int>* InstanceKlass::create_new_default_vtable_indices(int len, TRAPS) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
190 |
Array<int>* vtable_indices = MetadataFactory::new_array<int>(class_loader_data(), len, CHECK_NULL); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
191 |
assert(default_vtable_indices() == NULL, "only create once"); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
192 |
set_default_vtable_indices(vtable_indices); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
193 |
return vtable_indices; |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
194 |
} |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
195 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
196 |
InstanceKlass::InstanceKlass(int vtable_len, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
197 |
int itable_len, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
198 |
int static_field_size, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
199 |
int nonstatic_oop_map_size, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
200 |
ReferenceType rt, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
201 |
AccessFlags access_flags, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
202 |
bool is_anonymous) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
203 |
No_Safepoint_Verifier no_safepoint; // until k becomes parsable |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
204 |
|
15928
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
205 |
int iksize = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size, |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
206 |
access_flags.is_interface(), is_anonymous); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
207 |
|
15928
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
208 |
set_vtable_length(vtable_len); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
209 |
set_itable_length(itable_len); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
210 |
set_static_field_size(static_field_size); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
211 |
set_nonstatic_oop_map_size(nonstatic_oop_map_size); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
212 |
set_access_flags(access_flags); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
213 |
_misc_flags = 0; // initialize to zero |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
214 |
set_is_anonymous(is_anonymous); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
215 |
assert(size() == iksize, "wrong size for object"); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
216 |
|
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
217 |
set_array_klasses(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
218 |
set_methods(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
219 |
set_method_ordering(NULL); |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
220 |
set_default_methods(NULL); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
221 |
set_default_vtable_indices(NULL); |
15928
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
222 |
set_local_interfaces(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
223 |
set_transitive_interfaces(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
224 |
init_implementor(); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
225 |
set_fields(NULL, 0); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
226 |
set_constants(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
227 |
set_class_loader_data(NULL); |
19326
14cb6cf26a96
8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes.
jiangli
parents:
18940
diff
changeset
|
228 |
set_source_file_name_index(0); |
15928
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
229 |
set_source_debug_extension(NULL, 0); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
230 |
set_array_name(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
231 |
set_inner_classes(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
232 |
set_static_oop_field_count(0); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
233 |
set_nonstatic_field_size(0); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
234 |
set_is_marked_dependent(false); |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
235 |
set_has_unloaded_dependent(false); |
15928
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
236 |
set_init_state(InstanceKlass::allocated); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
237 |
set_init_thread(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
238 |
set_reference_type(rt); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
239 |
set_oop_map_cache(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
240 |
set_jni_ids(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
241 |
set_osr_nmethods_head(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
242 |
set_breakpoints(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
243 |
init_previous_versions(); |
19326
14cb6cf26a96
8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes.
jiangli
parents:
18940
diff
changeset
|
244 |
set_generic_signature_index(0); |
15928
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
245 |
release_set_methods_jmethod_ids(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
246 |
set_annotations(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
247 |
set_jvmti_cached_class_field_map(NULL); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
248 |
set_initial_method_idnum(0); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
249 |
_dependencies = NULL; |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
250 |
set_jvmti_cached_class_field_map(NULL); |
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
251 |
set_cached_class_file(NULL); |
15928
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
252 |
set_initial_method_idnum(0); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
253 |
set_minor_version(0); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
254 |
set_major_version(0); |
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
255 |
NOT_PRODUCT(_verify_count = 0;) |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
256 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
257 |
// initialize the non-header words to zero |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
258 |
intptr_t* p = (intptr_t*)this; |
15928
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
259 |
for (int index = InstanceKlass::header_size(); index < iksize; index++) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
260 |
p[index] = NULL_WORD; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
261 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
262 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
263 |
// Set temporary value until parseClassFile updates it with the real instance |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
264 |
// size. |
15928
f9d5c6e4107f
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
15601
diff
changeset
|
265 |
set_layout_helper(Klass::instance_layout_helper(0, true)); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
266 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
267 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
268 |
|
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
269 |
void InstanceKlass::deallocate_methods(ClassLoaderData* loader_data, |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
270 |
Array<Method*>* methods) { |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
271 |
if (methods != NULL && methods != Universe::the_empty_method_array() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
272 |
!methods->is_shared()) { |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
273 |
for (int i = 0; i < methods->length(); i++) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
274 |
Method* method = methods->at(i); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
275 |
if (method == NULL) continue; // maybe null if error processing |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
276 |
// Only want to delete methods that are not executing for RedefineClasses. |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
277 |
// The previous version will point to them so they're not totally dangling |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
278 |
assert (!method->on_stack(), "shouldn't be called with methods on stack"); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
279 |
MetadataFactory::free_metadata(loader_data, method); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
280 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
281 |
MetadataFactory::free_array<Method*>(loader_data, methods); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
282 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
283 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
284 |
|
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
285 |
void InstanceKlass::deallocate_interfaces(ClassLoaderData* loader_data, |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
286 |
Klass* super_klass, |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
287 |
Array<Klass*>* local_interfaces, |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
288 |
Array<Klass*>* transitive_interfaces) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
289 |
// Only deallocate transitive interfaces if not empty, same as super class |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
290 |
// or same as local interfaces. See code in parseClassFile. |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
291 |
Array<Klass*>* ti = transitive_interfaces; |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
292 |
if (ti != Universe::the_empty_klass_array() && ti != local_interfaces) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
293 |
// check that the interfaces don't come from super class |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
294 |
Array<Klass*>* sti = (super_klass == NULL) ? NULL : |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
295 |
InstanceKlass::cast(super_klass)->transitive_interfaces(); |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
296 |
if (ti != sti && ti != NULL && !ti->is_shared()) { |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
297 |
MetadataFactory::free_array<Klass*>(loader_data, ti); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
298 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
299 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
300 |
|
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
301 |
// local interfaces can be empty |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
302 |
if (local_interfaces != Universe::the_empty_klass_array() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
303 |
local_interfaces != NULL && !local_interfaces->is_shared()) { |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
304 |
MetadataFactory::free_array<Klass*>(loader_data, local_interfaces); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
305 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
306 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
307 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
308 |
// This function deallocates the metadata and C heap pointers that the |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
309 |
// InstanceKlass points to. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
310 |
void InstanceKlass::deallocate_contents(ClassLoaderData* loader_data) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
311 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
312 |
// Orphan the mirror first, CMS thinks it's still live. |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
313 |
if (java_mirror() != NULL) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
314 |
java_lang_Class::set_klass(java_mirror(), NULL); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
315 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
316 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
317 |
// Need to take this class off the class loader data list. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
318 |
loader_data->remove_class(this); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
319 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
320 |
// The array_klass for this class is created later, after error handling. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
321 |
// For class redefinition, we keep the original class so this scratch class |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
322 |
// doesn't have an array class. Either way, assert that there is nothing |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
323 |
// to deallocate. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
324 |
assert(array_klasses() == NULL, "array classes shouldn't be created for this class yet"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
325 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
326 |
// Release C heap allocated data that this might point to, which includes |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
327 |
// reference counting symbol names. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
328 |
release_C_heap_structures(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
329 |
|
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
330 |
deallocate_methods(loader_data, methods()); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
331 |
set_methods(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
332 |
|
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
333 |
if (method_ordering() != NULL && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
334 |
method_ordering() != Universe::the_empty_int_array() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
335 |
!method_ordering()->is_shared()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
336 |
MetadataFactory::free_array<int>(loader_data, method_ordering()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
337 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
338 |
set_method_ordering(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
339 |
|
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
340 |
// default methods can be empty |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
341 |
if (default_methods() != NULL && |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
342 |
default_methods() != Universe::the_empty_method_array() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
343 |
!default_methods()->is_shared()) { |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
344 |
MetadataFactory::free_array<Method*>(loader_data, default_methods()); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
345 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
346 |
// Do NOT deallocate the default methods, they are owned by superinterfaces. |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
347 |
set_default_methods(NULL); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
348 |
|
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
349 |
// default methods vtable indices can be empty |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
350 |
if (default_vtable_indices() != NULL && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
351 |
!default_vtable_indices()->is_shared()) { |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
352 |
MetadataFactory::free_array<int>(loader_data, default_vtable_indices()); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
353 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
354 |
set_default_vtable_indices(NULL); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
355 |
|
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
356 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
357 |
// This array is in Klass, but remove it with the InstanceKlass since |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
358 |
// this place would be the only caller and it can share memory with transitive |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
359 |
// interfaces. |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
360 |
if (secondary_supers() != NULL && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
361 |
secondary_supers() != Universe::the_empty_klass_array() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
362 |
secondary_supers() != transitive_interfaces() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
363 |
!secondary_supers()->is_shared()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
364 |
MetadataFactory::free_array<Klass*>(loader_data, secondary_supers()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
365 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
366 |
set_secondary_supers(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
367 |
|
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
368 |
deallocate_interfaces(loader_data, super(), local_interfaces(), transitive_interfaces()); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
369 |
set_transitive_interfaces(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
370 |
set_local_interfaces(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
371 |
|
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
372 |
if (fields() != NULL && !fields()->is_shared()) { |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
373 |
MetadataFactory::free_array<jushort>(loader_data, fields()); |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
374 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
375 |
set_fields(NULL, 0); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
376 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
377 |
// If a method from a redefined class is using this constant pool, don't |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
378 |
// delete it, yet. The new class's previous version will point to this. |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
379 |
if (constants() != NULL) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
380 |
assert (!constants()->on_stack(), "shouldn't be called if anything is onstack"); |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
381 |
if (!constants()->is_shared()) { |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
382 |
MetadataFactory::free_metadata(loader_data, constants()); |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
383 |
} |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
384 |
set_constants(NULL); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
385 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
386 |
|
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
387 |
if (inner_classes() != NULL && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
388 |
inner_classes() != Universe::the_empty_short_array() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
389 |
!inner_classes()->is_shared()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
390 |
MetadataFactory::free_array<jushort>(loader_data, inner_classes()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
391 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
392 |
set_inner_classes(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
393 |
|
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
394 |
// We should deallocate the Annotations instance if it's not in shared spaces. |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
395 |
if (annotations() != NULL && !annotations()->is_shared()) { |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
396 |
MetadataFactory::free_metadata(loader_data, annotations()); |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
397 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
398 |
set_annotations(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
399 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
400 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
401 |
bool InstanceKlass::should_be_initialized() const { |
1 | 402 |
return !is_initialized(); |
403 |
} |
|
404 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
405 |
klassVtable* InstanceKlass::vtable() const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
406 |
return new klassVtable(this, start_of_vtable(), vtable_length() / vtableEntry::size()); |
1 | 407 |
} |
408 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
409 |
klassItable* InstanceKlass::itable() const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
410 |
return new klassItable(instanceKlassHandle(this)); |
1 | 411 |
} |
412 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
413 |
void InstanceKlass::eager_initialize(Thread *thread) { |
1 | 414 |
if (!EagerInitialization) return; |
415 |
||
416 |
if (this->is_not_initialized()) { |
|
417 |
// abort if the the class has a class initializer |
|
418 |
if (this->class_initializer() != NULL) return; |
|
419 |
||
420 |
// abort if it is java.lang.Object (initialization is handled in genesis) |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
421 |
Klass* super = this->super(); |
1 | 422 |
if (super == NULL) return; |
423 |
||
424 |
// abort if the super class should be initialized |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
425 |
if (!InstanceKlass::cast(super)->is_initialized()) return; |
1 | 426 |
|
427 |
// call body to expose the this pointer |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
428 |
instanceKlassHandle this_k(thread, this); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
429 |
eager_initialize_impl(this_k); |
1 | 430 |
} |
431 |
} |
|
432 |
||
17826
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
433 |
// JVMTI spec thinks there are signers and protection domain in the |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
434 |
// instanceKlass. These accessors pretend these fields are there. |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
435 |
// The hprof specification also thinks these fields are in InstanceKlass. |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
436 |
oop InstanceKlass::protection_domain() const { |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
437 |
// return the protection_domain from the mirror |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
438 |
return java_lang_Class::protection_domain(java_mirror()); |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
439 |
} |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
440 |
|
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
441 |
// To remove these from requires an incompatible change and CCC request. |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
442 |
objArrayOop InstanceKlass::signers() const { |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
443 |
// return the signers from the mirror |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
444 |
return java_lang_Class::signers(java_mirror()); |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
445 |
} |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
446 |
|
20379
a4c59d30d67d
8025004: -XX:+CheckUnhandledOops asserts for JDK 8 Solaris fastdebug binaries
coleenp
parents:
20284
diff
changeset
|
447 |
oop InstanceKlass::init_lock() const { |
17826
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
448 |
// return the init lock from the mirror |
21079
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
449 |
oop lock = java_lang_Class::init_lock(java_mirror()); |
26556
72da4c813e44
8046210: Missing memory barrier when reading init_lock
dholmes
parents:
26316
diff
changeset
|
450 |
// Prevent reordering with any access of initialization state |
72da4c813e44
8046210: Missing memory barrier when reading init_lock
dholmes
parents:
26316
diff
changeset
|
451 |
OrderAccess::loadload(); |
21079
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
452 |
assert((oop)lock != NULL || !is_not_initialized(), // initialized or in_error state |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
453 |
"only fully initialized state can have a null lock"); |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
454 |
return lock; |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
455 |
} |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
456 |
|
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
457 |
// Set the initialization lock to null so the object can be GC'ed. Any racing |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
458 |
// threads to get this lock will see a null lock and will not lock. |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
459 |
// That's okay because they all check for initialized state after getting |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
460 |
// the lock and return. |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
461 |
void InstanceKlass::fence_and_clear_init_lock() { |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
462 |
// make sure previous stores are all done, notably the init_state. |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
463 |
OrderAccess::storestore(); |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
464 |
java_lang_Class::set_init_lock(java_mirror(), NULL); |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
465 |
assert(!is_not_initialized(), "class must be initialized now"); |
17826
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
466 |
} |
1 | 467 |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
468 |
void InstanceKlass::eager_initialize_impl(instanceKlassHandle this_k) { |
1 | 469 |
EXCEPTION_MARK; |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
470 |
oop init_lock = this_k->init_lock(); |
21079
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
471 |
ObjectLocker ol(init_lock, THREAD, init_lock != NULL); |
1 | 472 |
|
473 |
// abort if someone beat us to the initialization |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
474 |
if (!this_k->is_not_initialized()) return; // note: not equivalent to is_initialized() |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
475 |
|
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
476 |
ClassState old_state = this_k->init_state(); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
477 |
link_class_impl(this_k, true, THREAD); |
1 | 478 |
if (HAS_PENDING_EXCEPTION) { |
479 |
CLEAR_PENDING_EXCEPTION; |
|
480 |
// Abort if linking the class throws an exception. |
|
481 |
||
482 |
// Use a test to avoid redundantly resetting the state if there's |
|
483 |
// no change. Set_init_state() asserts that state changes make |
|
484 |
// progress, whereas here we might just be spinning in place. |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
485 |
if( old_state != this_k->_init_state ) |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
486 |
this_k->set_init_state (old_state); |
1 | 487 |
} else { |
488 |
// linking successfull, mark class as initialized |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
489 |
this_k->set_init_state (fully_initialized); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
490 |
this_k->fence_and_clear_init_lock(); |
1 | 491 |
// trace |
492 |
if (TraceClassInitialization) { |
|
493 |
ResourceMark rm(THREAD); |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
494 |
tty->print_cr("[Initialized %s without side effects]", this_k->external_name()); |
1 | 495 |
} |
496 |
} |
|
497 |
} |
|
498 |
||
499 |
||
500 |
// See "The Virtual Machine Specification" section 2.16.5 for a detailed explanation of the class initialization |
|
501 |
// process. The step comments refers to the procedure described in that section. |
|
502 |
// Note: implementation moved to static method to expose the this pointer. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
503 |
void InstanceKlass::initialize(TRAPS) { |
1 | 504 |
if (this->should_be_initialized()) { |
505 |
HandleMark hm(THREAD); |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
506 |
instanceKlassHandle this_k(THREAD, this); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
507 |
initialize_impl(this_k, CHECK); |
1 | 508 |
// Note: at this point the class may be initialized |
509 |
// OR it may be in the state of being initialized |
|
510 |
// in case of recursive initialization! |
|
511 |
} else { |
|
512 |
assert(is_initialized(), "sanity check"); |
|
513 |
} |
|
514 |
} |
|
515 |
||
516 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
517 |
bool InstanceKlass::verify_code( |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
518 |
instanceKlassHandle this_k, bool throw_verifyerror, TRAPS) { |
1 | 519 |
// 1) Verify the bytecodes |
520 |
Verifier::Mode mode = |
|
521 |
throw_verifyerror ? Verifier::ThrowException : Verifier::NoException; |
|
27680
8ecc0871c18e
8064811: Use THREAD instead of CHECK_NULL in return statements
stefank
parents:
27435
diff
changeset
|
522 |
return Verifier::verify(this_k, mode, this_k->should_verify_class(), THREAD); |
1 | 523 |
} |
524 |
||
525 |
||
526 |
// Used exclusively by the shared spaces dump mechanism to prevent |
|
527 |
// classes mapped into the shared regions in new VMs from appearing linked. |
|
528 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
529 |
void InstanceKlass::unlink_class() { |
1 | 530 |
assert(is_linked(), "must be linked"); |
531 |
_init_state = loaded; |
|
532 |
} |
|
533 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
534 |
void InstanceKlass::link_class(TRAPS) { |
1 | 535 |
assert(is_loaded(), "must be loaded"); |
536 |
if (!is_linked()) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
537 |
HandleMark hm(THREAD); |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
538 |
instanceKlassHandle this_k(THREAD, this); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
539 |
link_class_impl(this_k, true, CHECK); |
1 | 540 |
} |
541 |
} |
|
542 |
||
543 |
// Called to verify that a class can link during initialization, without |
|
544 |
// throwing a VerifyError. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
545 |
bool InstanceKlass::link_class_or_fail(TRAPS) { |
1 | 546 |
assert(is_loaded(), "must be loaded"); |
547 |
if (!is_linked()) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
548 |
HandleMark hm(THREAD); |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
549 |
instanceKlassHandle this_k(THREAD, this); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
550 |
link_class_impl(this_k, false, CHECK_false); |
1 | 551 |
} |
552 |
return is_linked(); |
|
553 |
} |
|
554 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
555 |
bool InstanceKlass::link_class_impl( |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
556 |
instanceKlassHandle this_k, bool throw_verifyerror, TRAPS) { |
1 | 557 |
// check for error state |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
558 |
if (this_k->is_in_error_state()) { |
1 | 559 |
ResourceMark rm(THREAD); |
560 |
THROW_MSG_(vmSymbols::java_lang_NoClassDefFoundError(), |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
561 |
this_k->external_name(), false); |
1 | 562 |
} |
563 |
// return if already verified |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
564 |
if (this_k->is_linked()) { |
1 | 565 |
return true; |
566 |
} |
|
567 |
||
568 |
// Timing |
|
569 |
// timer handles recursion |
|
570 |
assert(THREAD->is_Java_thread(), "non-JavaThread in link_class_impl"); |
|
571 |
JavaThread* jt = (JavaThread*)THREAD; |
|
572 |
||
573 |
// link super class before linking this class |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
574 |
instanceKlassHandle super(THREAD, this_k->super()); |
1 | 575 |
if (super.not_null()) { |
576 |
if (super->is_interface()) { // check if super class is an interface |
|
577 |
ResourceMark rm(THREAD); |
|
578 |
Exceptions::fthrow( |
|
579 |
THREAD_AND_LOCATION, |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
580 |
vmSymbols::java_lang_IncompatibleClassChangeError(), |
1 | 581 |
"class %s has interface %s as super class", |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
582 |
this_k->external_name(), |
1 | 583 |
super->external_name() |
584 |
); |
|
585 |
return false; |
|
586 |
} |
|
587 |
||
588 |
link_class_impl(super, throw_verifyerror, CHECK_false); |
|
589 |
} |
|
590 |
||
591 |
// link all interfaces implemented by this class before linking this class |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
592 |
Array<Klass*>* interfaces = this_k->local_interfaces(); |
1 | 593 |
int num_interfaces = interfaces->length(); |
594 |
for (int index = 0; index < num_interfaces; index++) { |
|
595 |
HandleMark hm(THREAD); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
596 |
instanceKlassHandle ih(THREAD, interfaces->at(index)); |
1 | 597 |
link_class_impl(ih, throw_verifyerror, CHECK_false); |
598 |
} |
|
599 |
||
600 |
// in case the class is linked in the process of linking its superclasses |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
601 |
if (this_k->is_linked()) { |
1 | 602 |
return true; |
603 |
} |
|
604 |
||
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
605 |
// trace only the link time for this klass that includes |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
606 |
// the verification time |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
607 |
PerfClassTraceTime vmtimer(ClassLoader::perf_class_link_time(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
608 |
ClassLoader::perf_class_link_selftime(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
609 |
ClassLoader::perf_classes_linked(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
610 |
jt->get_thread_stat()->perf_recursion_counts_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
611 |
jt->get_thread_stat()->perf_timers_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
612 |
PerfClassTraceTime::CLASS_LINK); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
613 |
|
1 | 614 |
// verification & rewriting |
615 |
{ |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
616 |
oop init_lock = this_k->init_lock(); |
21079
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
617 |
ObjectLocker ol(init_lock, THREAD, init_lock != NULL); |
1 | 618 |
// rewritten will have been set if loader constraint error found |
619 |
// on an earlier link attempt |
|
620 |
// don't verify or rewrite if already rewritten |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
621 |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
622 |
if (!this_k->is_linked()) { |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
623 |
if (!this_k->is_rewritten()) { |
1 | 624 |
{ |
625 |
// Timer includes any side effects of class verification (resolution, |
|
626 |
// etc), but not recursive entry into verify_code(). |
|
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
627 |
PerfClassTraceTime timer(ClassLoader::perf_class_verify_time(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
628 |
ClassLoader::perf_class_verify_selftime(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
629 |
ClassLoader::perf_classes_verified(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
630 |
jt->get_thread_stat()->perf_recursion_counts_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
631 |
jt->get_thread_stat()->perf_timers_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
632 |
PerfClassTraceTime::CLASS_VERIFY); |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
633 |
bool verify_ok = verify_code(this_k, throw_verifyerror, THREAD); |
1 | 634 |
if (!verify_ok) { |
635 |
return false; |
|
636 |
} |
|
637 |
} |
|
638 |
||
639 |
// Just in case a side-effect of verify linked this class already |
|
640 |
// (which can sometimes happen since the verifier loads classes |
|
641 |
// using custom class loaders, which are free to initialize things) |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
642 |
if (this_k->is_linked()) { |
1 | 643 |
return true; |
644 |
} |
|
645 |
||
646 |
// also sets rewritten |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
647 |
this_k->rewrite_class(CHECK_false); |
1 | 648 |
} |
649 |
||
9971 | 650 |
// relocate jsrs and link methods after they are all rewritten |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
651 |
this_k->link_methods(CHECK_false); |
9971 | 652 |
|
1 | 653 |
// Initialize the vtable and interface table after |
654 |
// methods have been rewritten since rewrite may |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
655 |
// fabricate new Method*s. |
1 | 656 |
// also does loader constraint checking |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
657 |
if (!this_k()->is_shared()) { |
1 | 658 |
ResourceMark rm(THREAD); |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
659 |
this_k->vtable()->initialize_vtable(true, CHECK_false); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
660 |
this_k->itable()->initialize_itable(true, CHECK_false); |
1 | 661 |
} |
662 |
#ifdef ASSERT |
|
663 |
else { |
|
664 |
ResourceMark rm(THREAD); |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
665 |
this_k->vtable()->verify(tty, true); |
1 | 666 |
// In case itable verification is ever added. |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
667 |
// this_k->itable()->verify(tty, true); |
1 | 668 |
} |
669 |
#endif |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
670 |
this_k->set_init_state(linked); |
1 | 671 |
if (JvmtiExport::should_post_class_prepare()) { |
672 |
Thread *thread = THREAD; |
|
673 |
assert(thread->is_Java_thread(), "thread->is_Java_thread()"); |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
674 |
JvmtiExport::post_class_prepare((JavaThread *) thread, this_k()); |
1 | 675 |
} |
676 |
} |
|
677 |
} |
|
678 |
return true; |
|
679 |
} |
|
680 |
||
681 |
||
682 |
// Rewrite the byte codes of all of the methods of a class. |
|
683 |
// The rewriter must be called exactly once. Rewriting must happen after |
|
684 |
// verification but before the first method of the class is executed. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
685 |
void InstanceKlass::rewrite_class(TRAPS) { |
1 | 686 |
assert(is_loaded(), "must be loaded"); |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
687 |
instanceKlassHandle this_k(THREAD, this); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
688 |
if (this_k->is_rewritten()) { |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
689 |
assert(this_k()->is_shared(), "rewriting an unshared class?"); |
1 | 690 |
return; |
691 |
} |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
692 |
Rewriter::rewrite(this_k, CHECK); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
693 |
this_k->set_rewritten(); |
1 | 694 |
} |
695 |
||
9971 | 696 |
// Now relocate and link method entry points after class is rewritten. |
697 |
// This is outside is_rewritten flag. In case of an exception, it can be |
|
698 |
// executed more than once. |
|
15099
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
699 |
void InstanceKlass::link_methods(TRAPS) { |
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
700 |
int len = methods()->length(); |
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
701 |
for (int i = len-1; i >= 0; i--) { |
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
702 |
methodHandle m(THREAD, methods()->at(i)); |
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
703 |
|
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
704 |
// Set up method entry points for compiler and interpreter . |
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
705 |
m->link_method(m, CHECK); |
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
706 |
} |
9971 | 707 |
} |
708 |
||
27402
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
709 |
// Eagerly initialize superinterfaces that declare default methods (concrete instance: any access) |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
710 |
void InstanceKlass::initialize_super_interfaces(instanceKlassHandle this_k, TRAPS) { |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
711 |
if (this_k->has_default_methods()) { |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
712 |
for (int i = 0; i < this_k->local_interfaces()->length(); ++i) { |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
713 |
Klass* iface = this_k->local_interfaces()->at(i); |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
714 |
InstanceKlass* ik = InstanceKlass::cast(iface); |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
715 |
if (ik->should_be_initialized()) { |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
716 |
if (ik->has_default_methods()) { |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
717 |
ik->initialize_super_interfaces(ik, THREAD); |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
718 |
} |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
719 |
// Only initialize() interfaces that "declare" concrete methods. |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
720 |
// has_default_methods drives searching superinterfaces since it |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
721 |
// means has_default_methods in its superinterface hierarchy |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
722 |
if (!HAS_PENDING_EXCEPTION && ik->declares_default_methods()) { |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
723 |
ik->initialize(THREAD); |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
724 |
} |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
725 |
if (HAS_PENDING_EXCEPTION) { |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
726 |
Handle e(THREAD, PENDING_EXCEPTION); |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
727 |
CLEAR_PENDING_EXCEPTION; |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
728 |
{ |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
729 |
EXCEPTION_MARK; |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
730 |
// Locks object, set state, and notify all waiting threads |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
731 |
this_k->set_initialization_state_and_notify( |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
732 |
initialization_error, THREAD); |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
733 |
|
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
734 |
// ignore any exception thrown, superclass initialization error is |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
735 |
// thrown below |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
736 |
CLEAR_PENDING_EXCEPTION; |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
737 |
} |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
738 |
THROW_OOP(e()); |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
739 |
} |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
740 |
} |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
741 |
} |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
742 |
} |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
743 |
} |
1 | 744 |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
745 |
void InstanceKlass::initialize_impl(instanceKlassHandle this_k, TRAPS) { |
1 | 746 |
// Make sure klass is linked (verified) before initialization |
747 |
// A class could already be verified, since it has been reflected upon. |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
748 |
this_k->link_class(CHECK); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
749 |
|
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
750 |
DTRACE_CLASSINIT_PROBE(required, InstanceKlass::cast(this_k()), -1); |
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
751 |
|
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
752 |
bool wait = false; |
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
753 |
|
1 | 754 |
// refer to the JVM book page 47 for description of steps |
755 |
// Step 1 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
756 |
{ |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
757 |
oop init_lock = this_k->init_lock(); |
21079
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
758 |
ObjectLocker ol(init_lock, THREAD, init_lock != NULL); |
1 | 759 |
|
760 |
Thread *self = THREAD; // it's passed the current thread |
|
761 |
||
762 |
// Step 2 |
|
763 |
// If we were to use wait() instead of waitInterruptibly() then |
|
764 |
// we might end up throwing IE from link/symbol resolution sites |
|
765 |
// that aren't expected to throw. This would wreak havoc. See 6320309. |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
766 |
while(this_k->is_being_initialized() && !this_k->is_reentrant_initialization(self)) { |
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
767 |
wait = true; |
1 | 768 |
ol.waitUninterruptibly(CHECK); |
769 |
} |
|
770 |
||
771 |
// Step 3 |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
772 |
if (this_k->is_being_initialized() && this_k->is_reentrant_initialization(self)) { |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
773 |
DTRACE_CLASSINIT_PROBE_WAIT(recursive, InstanceKlass::cast(this_k()), -1,wait); |
1 | 774 |
return; |
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
775 |
} |
1 | 776 |
|
777 |
// Step 4 |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
778 |
if (this_k->is_initialized()) { |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
779 |
DTRACE_CLASSINIT_PROBE_WAIT(concurrent, InstanceKlass::cast(this_k()), -1,wait); |
1 | 780 |
return; |
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
781 |
} |
1 | 782 |
|
783 |
// Step 5 |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
784 |
if (this_k->is_in_error_state()) { |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
785 |
DTRACE_CLASSINIT_PROBE_WAIT(erroneous, InstanceKlass::cast(this_k()), -1,wait); |
1 | 786 |
ResourceMark rm(THREAD); |
787 |
const char* desc = "Could not initialize class "; |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
788 |
const char* className = this_k->external_name(); |
1 | 789 |
size_t msglen = strlen(desc) + strlen(className) + 1; |
6421
7c02a5af38e7
6980262: Memory leak when exception is thrown in static initializer
kamg
parents:
6248
diff
changeset
|
790 |
char* message = NEW_RESOURCE_ARRAY(char, msglen); |
1 | 791 |
if (NULL == message) { |
792 |
// Out of memory: can't create detailed error message |
|
793 |
THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), className); |
|
794 |
} else { |
|
795 |
jio_snprintf(message, msglen, "%s%s", desc, className); |
|
796 |
THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), message); |
|
797 |
} |
|
798 |
} |
|
799 |
||
800 |
// Step 6 |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
801 |
this_k->set_init_state(being_initialized); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
802 |
this_k->set_init_thread(self); |
1 | 803 |
} |
804 |
||
805 |
// Step 7 |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
806 |
Klass* super_klass = this_k->super(); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
807 |
if (super_klass != NULL && !this_k->is_interface() && super_klass->should_be_initialized()) { |
14488 | 808 |
super_klass->initialize(THREAD); |
1 | 809 |
|
810 |
if (HAS_PENDING_EXCEPTION) { |
|
811 |
Handle e(THREAD, PENDING_EXCEPTION); |
|
812 |
CLEAR_PENDING_EXCEPTION; |
|
813 |
{ |
|
814 |
EXCEPTION_MARK; |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
815 |
this_k->set_initialization_state_and_notify(initialization_error, THREAD); // Locks object, set state, and notify all waiting threads |
1 | 816 |
CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, superclass initialization error is thrown below |
817 |
} |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
818 |
DTRACE_CLASSINIT_PROBE_WAIT(super__failed, InstanceKlass::cast(this_k()), -1,wait); |
1 | 819 |
THROW_OOP(e()); |
820 |
} |
|
821 |
} |
|
822 |
||
27402
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
823 |
// Recursively initialize any superinterfaces that declare default methods |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
824 |
// Only need to recurse if has_default_methods which includes declaring and |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
825 |
// inheriting default methods |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
826 |
if (this_k->has_default_methods()) { |
27402
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
827 |
this_k->initialize_super_interfaces(this_k, CHECK); |
14385 | 828 |
} |
829 |
||
1 | 830 |
// Step 8 |
831 |
{ |
|
832 |
assert(THREAD->is_Java_thread(), "non-JavaThread in initialize_impl"); |
|
833 |
JavaThread* jt = (JavaThread*)THREAD; |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
834 |
DTRACE_CLASSINIT_PROBE_WAIT(clinit, InstanceKlass::cast(this_k()), -1,wait); |
1 | 835 |
// Timer includes any side effects of class initialization (resolution, |
836 |
// etc), but not recursive entry into call_class_initializer(). |
|
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
837 |
PerfClassTraceTime timer(ClassLoader::perf_class_init_time(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
838 |
ClassLoader::perf_class_init_selftime(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
839 |
ClassLoader::perf_classes_inited(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
840 |
jt->get_thread_stat()->perf_recursion_counts_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
841 |
jt->get_thread_stat()->perf_timers_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
842 |
PerfClassTraceTime::CLASS_CLINIT); |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
843 |
this_k->call_class_initializer(THREAD); |
1 | 844 |
} |
845 |
||
846 |
// Step 9 |
|
847 |
if (!HAS_PENDING_EXCEPTION) { |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
848 |
this_k->set_initialization_state_and_notify(fully_initialized, CHECK); |
1 | 849 |
{ ResourceMark rm(THREAD); |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
850 |
debug_only(this_k->vtable()->verify(tty, true);) |
1 | 851 |
} |
852 |
} |
|
853 |
else { |
|
854 |
// Step 10 and 11 |
|
855 |
Handle e(THREAD, PENDING_EXCEPTION); |
|
856 |
CLEAR_PENDING_EXCEPTION; |
|
22897
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
857 |
// JVMTI has already reported the pending exception |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
858 |
// JVMTI internal flag reset is needed in order to report ExceptionInInitializerError |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
859 |
JvmtiExport::clear_detected_exception((JavaThread*)THREAD); |
1 | 860 |
{ |
861 |
EXCEPTION_MARK; |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
862 |
this_k->set_initialization_state_and_notify(initialization_error, THREAD); |
1 | 863 |
CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, class initialization error is thrown below |
22897
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
864 |
// JVMTI has already reported the pending exception |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
865 |
// JVMTI internal flag reset is needed in order to report ExceptionInInitializerError |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
866 |
JvmtiExport::clear_detected_exception((JavaThread*)THREAD); |
1 | 867 |
} |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
868 |
DTRACE_CLASSINIT_PROBE_WAIT(error, InstanceKlass::cast(this_k()), -1,wait); |
4571 | 869 |
if (e->is_a(SystemDictionary::Error_klass())) { |
1 | 870 |
THROW_OOP(e()); |
871 |
} else { |
|
872 |
JavaCallArguments args(e); |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
873 |
THROW_ARG(vmSymbols::java_lang_ExceptionInInitializerError(), |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
874 |
vmSymbols::throwable_void_signature(), |
1 | 875 |
&args); |
876 |
} |
|
877 |
} |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
878 |
DTRACE_CLASSINIT_PROBE_WAIT(end, InstanceKlass::cast(this_k()), -1,wait); |
1 | 879 |
} |
880 |
||
881 |
||
882 |
// Note: implementation moved to static method to expose the this pointer. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
883 |
void InstanceKlass::set_initialization_state_and_notify(ClassState state, TRAPS) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
884 |
instanceKlassHandle kh(THREAD, this); |
1 | 885 |
set_initialization_state_and_notify_impl(kh, state, CHECK); |
886 |
} |
|
887 |
||
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
888 |
void InstanceKlass::set_initialization_state_and_notify_impl(instanceKlassHandle this_k, ClassState state, TRAPS) { |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
889 |
oop init_lock = this_k->init_lock(); |
21079
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
890 |
ObjectLocker ol(init_lock, THREAD, init_lock != NULL); |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
891 |
this_k->set_init_state(state); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
892 |
this_k->fence_and_clear_init_lock(); |
1 | 893 |
ol.notify_all(CHECK); |
894 |
} |
|
895 |
||
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
896 |
// The embedded _implementor field can only record one implementor. |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
897 |
// When there are more than one implementors, the _implementor field |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
898 |
// is set to the interface Klass* itself. Following are the possible |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
899 |
// values for the _implementor field: |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
900 |
// NULL - no implementor |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
901 |
// implementor Klass* - one implementor |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
902 |
// self - more than one implementor |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
903 |
// |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
904 |
// The _implementor field only exists for interfaces. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
905 |
void InstanceKlass::add_implementor(Klass* k) { |
1 | 906 |
assert(Compile_lock->owned_by_self(), ""); |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
907 |
assert(is_interface(), "not interface"); |
1 | 908 |
// Filter out my subinterfaces. |
909 |
// (Note: Interfaces are never on the subklass list.) |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
910 |
if (InstanceKlass::cast(k)->is_interface()) return; |
1 | 911 |
|
912 |
// Filter out subclasses whose supers already implement me. |
|
913 |
// (Note: CHA must walk subclasses of direct implementors |
|
914 |
// in order to locate indirect implementors.) |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
915 |
Klass* sk = InstanceKlass::cast(k)->super(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
916 |
if (sk != NULL && InstanceKlass::cast(sk)->implements_interface(this)) |
1 | 917 |
// We only need to check one immediate superclass, since the |
918 |
// implements_interface query looks at transitive_interfaces. |
|
919 |
// Any supers of the super have the same (or fewer) transitive_interfaces. |
|
920 |
return; |
|
921 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
922 |
Klass* ik = implementor(); |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
923 |
if (ik == NULL) { |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
924 |
set_implementor(k); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
925 |
} else if (ik != this) { |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
926 |
// There is already an implementor. Use itself as an indicator of |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
927 |
// more than one implementors. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
928 |
set_implementor(this); |
1 | 929 |
} |
930 |
||
931 |
// The implementor also implements the transitive_interfaces |
|
932 |
for (int index = 0; index < local_interfaces()->length(); index++) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
933 |
InstanceKlass::cast(local_interfaces()->at(index))->add_implementor(k); |
1 | 934 |
} |
935 |
} |
|
936 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
937 |
void InstanceKlass::init_implementor() { |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
938 |
if (is_interface()) { |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
939 |
set_implementor(NULL); |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
940 |
} |
1 | 941 |
} |
942 |
||
943 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
944 |
void InstanceKlass::process_interfaces(Thread *thread) { |
1 | 945 |
// link this class into the implementors list of every interface it implements |
946 |
for (int i = local_interfaces()->length() - 1; i >= 0; i--) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
947 |
assert(local_interfaces()->at(i)->is_klass(), "must be a klass"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
948 |
InstanceKlass* interf = InstanceKlass::cast(local_interfaces()->at(i)); |
1 | 949 |
assert(interf->is_interface(), "expected interface"); |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
950 |
interf->add_implementor(this); |
1 | 951 |
} |
952 |
} |
|
953 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
954 |
bool InstanceKlass::can_be_primary_super_slow() const { |
1 | 955 |
if (is_interface()) |
956 |
return false; |
|
957 |
else |
|
958 |
return Klass::can_be_primary_super_slow(); |
|
959 |
} |
|
960 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
961 |
GrowableArray<Klass*>* InstanceKlass::compute_secondary_supers(int num_extra_slots) { |
1 | 962 |
// The secondaries are the implemented interfaces. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
963 |
InstanceKlass* ik = InstanceKlass::cast(this); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
964 |
Array<Klass*>* interfaces = ik->transitive_interfaces(); |
1 | 965 |
int num_secondaries = num_extra_slots + interfaces->length(); |
966 |
if (num_secondaries == 0) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
967 |
// Must share this for correct bootstrapping! |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
968 |
set_secondary_supers(Universe::the_empty_klass_array()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
969 |
return NULL; |
1 | 970 |
} else if (num_extra_slots == 0) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
971 |
// The secondary super list is exactly the same as the transitive interfaces. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
972 |
// Redefine classes has to be careful not to delete this! |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
973 |
set_secondary_supers(interfaces); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
974 |
return NULL; |
1 | 975 |
} else { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
976 |
// Copy transitive interfaces to a temporary growable array to be constructed |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
977 |
// into the secondary super list with extra slots. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
978 |
GrowableArray<Klass*>* secondaries = new GrowableArray<Klass*>(interfaces->length()); |
1 | 979 |
for (int i = 0; i < interfaces->length(); i++) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
980 |
secondaries->push(interfaces->at(i)); |
1 | 981 |
} |
982 |
return secondaries; |
|
983 |
} |
|
984 |
} |
|
985 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
986 |
bool InstanceKlass::compute_is_subtype_of(Klass* k) { |
14488 | 987 |
if (k->is_interface()) { |
1 | 988 |
return implements_interface(k); |
989 |
} else { |
|
990 |
return Klass::compute_is_subtype_of(k); |
|
991 |
} |
|
992 |
} |
|
993 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
994 |
bool InstanceKlass::implements_interface(Klass* k) const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
995 |
if (this == k) return true; |
14488 | 996 |
assert(k->is_interface(), "should be an interface class"); |
1 | 997 |
for (int i = 0; i < transitive_interfaces()->length(); i++) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
998 |
if (transitive_interfaces()->at(i) == k) { |
1 | 999 |
return true; |
1000 |
} |
|
1001 |
} |
|
1002 |
return false; |
|
1003 |
} |
|
1004 |
||
21768
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
1005 |
bool InstanceKlass::is_same_or_direct_interface(Klass *k) const { |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
1006 |
// Verify direct super interface |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
1007 |
if (this == k) return true; |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
1008 |
assert(k->is_interface(), "should be an interface class"); |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
1009 |
for (int i = 0; i < local_interfaces()->length(); i++) { |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
1010 |
if (local_interfaces()->at(i) == k) { |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
1011 |
return true; |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
1012 |
} |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
1013 |
} |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
1014 |
return false; |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
1015 |
} |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
1016 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1017 |
objArrayOop InstanceKlass::allocate_objArray(int n, int length, TRAPS) { |
1 | 1018 |
if (length < 0) THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); |
1019 |
if (length > arrayOopDesc::max_array_length(T_OBJECT)) { |
|
3576
4ceec8fb3e18
6850957: Honor -XX:OnOutOfMemoryError when array size exceeds VM limit
martin
parents:
3575
diff
changeset
|
1020 |
report_java_out_of_memory("Requested array size exceeds VM limit"); |
12114
9a825a536095
7123170: JCK vm/jvmti/ResourceExhausted/resexh001/resexh00101/ tests fails since 7u4 b02
sspitsyn
parents:
11407
diff
changeset
|
1021 |
JvmtiExport::post_array_size_exhausted(); |
1 | 1022 |
THROW_OOP_0(Universe::out_of_memory_error_array_size()); |
1023 |
} |
|
1024 |
int size = objArrayOopDesc::object_size(length); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1025 |
Klass* ak = array_klass(n, CHECK_NULL); |
1 | 1026 |
KlassHandle h_ak (THREAD, ak); |
1027 |
objArrayOop o = |
|
1028 |
(objArrayOop)CollectedHeap::array_allocate(h_ak, size, length, CHECK_NULL); |
|
1029 |
return o; |
|
1030 |
} |
|
1031 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1032 |
instanceOop InstanceKlass::register_finalizer(instanceOop i, TRAPS) { |
1 | 1033 |
if (TraceFinalizerRegistration) { |
1034 |
tty->print("Registered "); |
|
1035 |
i->print_value_on(tty); |
|
1036 |
tty->print_cr(" (" INTPTR_FORMAT ") as finalizable", (address)i); |
|
1037 |
} |
|
1038 |
instanceHandle h_i(THREAD, i); |
|
1039 |
// Pass the handle as argument, JavaCalls::call expects oop as jobjects |
|
1040 |
JavaValue result(T_VOID); |
|
1041 |
JavaCallArguments args(h_i); |
|
1042 |
methodHandle mh (THREAD, Universe::finalizer_register_method()); |
|
1043 |
JavaCalls::call(&result, mh, &args, CHECK_NULL); |
|
1044 |
return h_i(); |
|
1045 |
} |
|
1046 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1047 |
instanceOop InstanceKlass::allocate_instance(TRAPS) { |
1 | 1048 |
bool has_finalizer_flag = has_finalizer(); // Query before possible GC |
1049 |
int size = size_helper(); // Query before forming handle. |
|
1050 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1051 |
KlassHandle h_k(THREAD, this); |
1 | 1052 |
|
1053 |
instanceOop i; |
|
1054 |
||
1055 |
i = (instanceOop)CollectedHeap::obj_allocate(h_k, size, CHECK_NULL); |
|
1056 |
if (has_finalizer_flag && !RegisterFinalizersAtInit) { |
|
1057 |
i = register_finalizer(i, CHECK_NULL); |
|
1058 |
} |
|
1059 |
return i; |
|
1060 |
} |
|
1061 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1062 |
void InstanceKlass::check_valid_for_instantiation(bool throwError, TRAPS) { |
1 | 1063 |
if (is_interface() || is_abstract()) { |
1064 |
ResourceMark rm(THREAD); |
|
1065 |
THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError() |
|
1066 |
: vmSymbols::java_lang_InstantiationException(), external_name()); |
|
1067 |
} |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1068 |
if (this == SystemDictionary::Class_klass()) { |
1 | 1069 |
ResourceMark rm(THREAD); |
1070 |
THROW_MSG(throwError ? vmSymbols::java_lang_IllegalAccessError() |
|
1071 |
: vmSymbols::java_lang_IllegalAccessException(), external_name()); |
|
1072 |
} |
|
1073 |
} |
|
1074 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1075 |
Klass* InstanceKlass::array_klass_impl(bool or_null, int n, TRAPS) { |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1076 |
instanceKlassHandle this_k(THREAD, this); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1077 |
return array_klass_impl(this_k, or_null, n, THREAD); |
1 | 1078 |
} |
1079 |
||
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1080 |
Klass* InstanceKlass::array_klass_impl(instanceKlassHandle this_k, bool or_null, int n, TRAPS) { |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1081 |
if (this_k->array_klasses() == NULL) { |
1 | 1082 |
if (or_null) return NULL; |
1083 |
||
1084 |
ResourceMark rm; |
|
1085 |
JavaThread *jt = (JavaThread *)THREAD; |
|
1086 |
{ |
|
1087 |
// Atomic creation of array_klasses |
|
1088 |
MutexLocker mc(Compile_lock, THREAD); // for vtables |
|
1089 |
MutexLocker ma(MultiArray_lock, THREAD); |
|
1090 |
||
1091 |
// Check if update has already taken place |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1092 |
if (this_k->array_klasses() == NULL) { |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1093 |
Klass* k = ObjArrayKlass::allocate_objArray_klass(this_k->class_loader_data(), 1, this_k, CHECK_NULL); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1094 |
this_k->set_array_klasses(k); |
1 | 1095 |
} |
1096 |
} |
|
1097 |
} |
|
1098 |
// _this will always be set at this point |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1099 |
ObjArrayKlass* oak = (ObjArrayKlass*)this_k->array_klasses(); |
1 | 1100 |
if (or_null) { |
1101 |
return oak->array_klass_or_null(n); |
|
1102 |
} |
|
27680
8ecc0871c18e
8064811: Use THREAD instead of CHECK_NULL in return statements
stefank
parents:
27435
diff
changeset
|
1103 |
return oak->array_klass(n, THREAD); |
1 | 1104 |
} |
1105 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1106 |
Klass* InstanceKlass::array_klass_impl(bool or_null, TRAPS) { |
1 | 1107 |
return array_klass_impl(or_null, 1, THREAD); |
1108 |
} |
|
1109 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1110 |
void InstanceKlass::call_class_initializer(TRAPS) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1111 |
instanceKlassHandle ik (THREAD, this); |
1 | 1112 |
call_class_initializer_impl(ik, THREAD); |
1113 |
} |
|
1114 |
||
1115 |
static int call_class_initializer_impl_counter = 0; // for debugging |
|
1116 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1117 |
Method* InstanceKlass::class_initializer() { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1118 |
Method* clinit = find_method( |
8653
8797d788a4f1
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
8297
diff
changeset
|
1119 |
vmSymbols::class_initializer_name(), vmSymbols::void_method_signature()); |
8797d788a4f1
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
8297
diff
changeset
|
1120 |
if (clinit != NULL && clinit->has_valid_initializer_flags()) { |
8797d788a4f1
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
8297
diff
changeset
|
1121 |
return clinit; |
8797d788a4f1
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
8297
diff
changeset
|
1122 |
} |
8797d788a4f1
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
8297
diff
changeset
|
1123 |
return NULL; |
1 | 1124 |
} |
1125 |
||
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1126 |
void InstanceKlass::call_class_initializer_impl(instanceKlassHandle this_k, TRAPS) { |
14477
95e66ea71f71
6830717: replay of compilations would help with debugging
minqi
parents:
14385
diff
changeset
|
1127 |
if (ReplayCompiles && |
95e66ea71f71
6830717: replay of compilations would help with debugging
minqi
parents:
14385
diff
changeset
|
1128 |
(ReplaySuppressInitializers == 1 || |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1129 |
ReplaySuppressInitializers >= 2 && this_k->class_loader() != NULL)) { |
14477
95e66ea71f71
6830717: replay of compilations would help with debugging
minqi
parents:
14385
diff
changeset
|
1130 |
// Hide the existence of the initializer for the purpose of replaying the compile |
95e66ea71f71
6830717: replay of compilations would help with debugging
minqi
parents:
14385
diff
changeset
|
1131 |
return; |
95e66ea71f71
6830717: replay of compilations would help with debugging
minqi
parents:
14385
diff
changeset
|
1132 |
} |
95e66ea71f71
6830717: replay of compilations would help with debugging
minqi
parents:
14385
diff
changeset
|
1133 |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1134 |
methodHandle h_method(THREAD, this_k->class_initializer()); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1135 |
assert(!this_k->is_initialized(), "we cannot initialize twice"); |
1 | 1136 |
if (TraceClassInitialization) { |
1137 |
tty->print("%d Initializing ", call_class_initializer_impl_counter++); |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1138 |
this_k->name()->print_value(); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1139 |
tty->print_cr("%s (" INTPTR_FORMAT ")", h_method() == NULL ? "(no method)" : "", (address)this_k()); |
1 | 1140 |
} |
1141 |
if (h_method() != NULL) { |
|
1142 |
JavaCallArguments args; // No arguments |
|
1143 |
JavaValue result(T_VOID); |
|
1144 |
JavaCalls::call(&result, h_method, &args, CHECK); // Static call (no args) |
|
1145 |
} |
|
1146 |
} |
|
1147 |
||
1148 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1149 |
void InstanceKlass::mask_for(methodHandle method, int bci, |
1 | 1150 |
InterpreterOopMap* entry_for) { |
1151 |
// Dirty read, then double-check under a lock. |
|
1152 |
if (_oop_map_cache == NULL) { |
|
1153 |
// Otherwise, allocate a new one. |
|
1154 |
MutexLocker x(OopMapCacheAlloc_lock); |
|
1155 |
// First time use. Allocate a cache in C heap |
|
1156 |
if (_oop_map_cache == NULL) { |
|
22859
7b88983393b7
8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents:
21768
diff
changeset
|
1157 |
// Release stores from OopMapCache constructor before assignment |
7b88983393b7
8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents:
21768
diff
changeset
|
1158 |
// to _oop_map_cache. C++ compilers on ppc do not emit the |
7b88983393b7
8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents:
21768
diff
changeset
|
1159 |
// required memory barrier only because of the volatile |
7b88983393b7
8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents:
21768
diff
changeset
|
1160 |
// qualifier of _oop_map_cache. |
7b88983393b7
8029396: PPC64 (part 212): Several memory ordering fixes in C-code.
goetz
parents:
21768
diff
changeset
|
1161 |
OrderAccess::release_store_ptr(&_oop_map_cache, new OopMapCache()); |
1 | 1162 |
} |
1163 |
} |
|
1164 |
// _oop_map_cache is constant after init; lookup below does is own locking. |
|
1165 |
_oop_map_cache->lookup(method, bci, entry_for); |
|
1166 |
} |
|
1167 |
||
1168 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1169 |
bool InstanceKlass::find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1170 |
for (JavaFieldStream fs(this); !fs.done(); fs.next()) { |
10546 | 1171 |
Symbol* f_name = fs.name(); |
1172 |
Symbol* f_sig = fs.signature(); |
|
1 | 1173 |
if (f_name == name && f_sig == sig) { |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
1174 |
fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index()); |
1 | 1175 |
return true; |
1176 |
} |
|
1177 |
} |
|
1178 |
return false; |
|
1179 |
} |
|
1180 |
||
1181 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1182 |
Klass* InstanceKlass::find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const { |
1 | 1183 |
const int n = local_interfaces()->length(); |
1184 |
for (int i = 0; i < n; i++) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1185 |
Klass* intf1 = local_interfaces()->at(i); |
14488 | 1186 |
assert(intf1->is_interface(), "just checking type"); |
1 | 1187 |
// search for field in current interface |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1188 |
if (InstanceKlass::cast(intf1)->find_local_field(name, sig, fd)) { |
1 | 1189 |
assert(fd->is_static(), "interface field must be static"); |
1190 |
return intf1; |
|
1191 |
} |
|
1192 |
// search for field in direct superinterfaces |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1193 |
Klass* intf2 = InstanceKlass::cast(intf1)->find_interface_field(name, sig, fd); |
1 | 1194 |
if (intf2 != NULL) return intf2; |
1195 |
} |
|
1196 |
// otherwise field lookup fails |
|
1197 |
return NULL; |
|
1198 |
} |
|
1199 |
||
1200 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1201 |
Klass* InstanceKlass::find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const { |
1 | 1202 |
// search order according to newest JVM spec (5.4.3.2, p.167). |
1203 |
// 1) search for field in current klass |
|
1204 |
if (find_local_field(name, sig, fd)) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1205 |
return const_cast<InstanceKlass*>(this); |
1 | 1206 |
} |
1207 |
// 2) search for field recursively in direct superinterfaces |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1208 |
{ Klass* intf = find_interface_field(name, sig, fd); |
1 | 1209 |
if (intf != NULL) return intf; |
1210 |
} |
|
1211 |
// 3) apply field lookup recursively if superclass exists |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1212 |
{ Klass* supr = super(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1213 |
if (supr != NULL) return InstanceKlass::cast(supr)->find_field(name, sig, fd); |
1 | 1214 |
} |
1215 |
// 4) otherwise field lookup fails |
|
1216 |
return NULL; |
|
1217 |
} |
|
1218 |
||
1219 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1220 |
Klass* InstanceKlass::find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const { |
1 | 1221 |
// search order according to newest JVM spec (5.4.3.2, p.167). |
1222 |
// 1) search for field in current klass |
|
1223 |
if (find_local_field(name, sig, fd)) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1224 |
if (fd->is_static() == is_static) return const_cast<InstanceKlass*>(this); |
1 | 1225 |
} |
1226 |
// 2) search for field recursively in direct superinterfaces |
|
1227 |
if (is_static) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1228 |
Klass* intf = find_interface_field(name, sig, fd); |
1 | 1229 |
if (intf != NULL) return intf; |
1230 |
} |
|
1231 |
// 3) apply field lookup recursively if superclass exists |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1232 |
{ Klass* supr = super(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1233 |
if (supr != NULL) return InstanceKlass::cast(supr)->find_field(name, sig, is_static, fd); |
1 | 1234 |
} |
1235 |
// 4) otherwise field lookup fails |
|
1236 |
return NULL; |
|
1237 |
} |
|
1238 |
||
1239 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1240 |
bool InstanceKlass::find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1241 |
for (JavaFieldStream fs(this); !fs.done(); fs.next()) { |
10546 | 1242 |
if (fs.offset() == offset) { |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
1243 |
fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index()); |
1 | 1244 |
if (fd->is_static() == is_static) return true; |
1245 |
} |
|
1246 |
} |
|
1247 |
return false; |
|
1248 |
} |
|
1249 |
||
1250 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1251 |
bool InstanceKlass::find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1252 |
Klass* klass = const_cast<InstanceKlass*>(this); |
1 | 1253 |
while (klass != NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1254 |
if (InstanceKlass::cast(klass)->find_local_field_from_offset(offset, is_static, fd)) { |
1 | 1255 |
return true; |
1256 |
} |
|
14488 | 1257 |
klass = klass->super(); |
1 | 1258 |
} |
1259 |
return false; |
|
1260 |
} |
|
1261 |
||
1262 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1263 |
void InstanceKlass::methods_do(void f(Method* method)) { |
24658
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24424
diff
changeset
|
1264 |
// Methods aren't stable until they are loaded. This can be read outside |
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24424
diff
changeset
|
1265 |
// a lock through the ClassLoaderData for profiling |
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24424
diff
changeset
|
1266 |
if (!is_loaded()) { |
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24424
diff
changeset
|
1267 |
return; |
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24424
diff
changeset
|
1268 |
} |
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24424
diff
changeset
|
1269 |
|
1 | 1270 |
int len = methods()->length(); |
1271 |
for (int index = 0; index < len; index++) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1272 |
Method* m = methods()->at(index); |
1 | 1273 |
assert(m->is_method(), "must be method"); |
1274 |
f(m); |
|
1275 |
} |
|
1276 |
} |
|
1277 |
||
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
1278 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1279 |
void InstanceKlass::do_local_static_fields(FieldClosure* cl) { |
10546 | 1280 |
for (JavaFieldStream fs(this); !fs.done(); fs.next()) { |
1281 |
if (fs.access_flags().is_static()) { |
|
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
1282 |
fieldDescriptor& fd = fs.field_descriptor(); |
10546 | 1283 |
cl->do_field(&fd); |
1284 |
} |
|
1 | 1285 |
} |
1286 |
} |
|
1287 |
||
1288 |
||
23872
536c66fc43d3
8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents:
23515
diff
changeset
|
1289 |
void InstanceKlass::do_local_static_fields(void f(fieldDescriptor*, Handle, TRAPS), Handle mirror, TRAPS) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1290 |
instanceKlassHandle h_this(THREAD, this); |
23872
536c66fc43d3
8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents:
23515
diff
changeset
|
1291 |
do_local_static_fields_impl(h_this, f, mirror, CHECK); |
1 | 1292 |
} |
1293 |
||
1294 |
||
23872
536c66fc43d3
8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents:
23515
diff
changeset
|
1295 |
void InstanceKlass::do_local_static_fields_impl(instanceKlassHandle this_k, |
536c66fc43d3
8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents:
23515
diff
changeset
|
1296 |
void f(fieldDescriptor* fd, Handle, TRAPS), Handle mirror, TRAPS) { |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1297 |
for (JavaFieldStream fs(this_k()); !fs.done(); fs.next()) { |
10546 | 1298 |
if (fs.access_flags().is_static()) { |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
1299 |
fieldDescriptor& fd = fs.field_descriptor(); |
23872
536c66fc43d3
8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents:
23515
diff
changeset
|
1300 |
f(&fd, mirror, CHECK); |
10546 | 1301 |
} |
1 | 1302 |
} |
1303 |
} |
|
1304 |
||
1305 |
||
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1306 |
static int compare_fields_by_offset(int* a, int* b) { |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1307 |
return a[0] - b[0]; |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1308 |
} |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1309 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1310 |
void InstanceKlass::do_nonstatic_fields(FieldClosure* cl) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1311 |
InstanceKlass* super = superklass(); |
1 | 1312 |
if (super != NULL) { |
1313 |
super->do_nonstatic_fields(cl); |
|
1314 |
} |
|
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1315 |
fieldDescriptor fd; |
10546 | 1316 |
int length = java_fields_count(); |
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1317 |
// In DebugInfo nonstatic fields are sorted by offset. |
13195 | 1318 |
int* fields_sorted = NEW_C_HEAP_ARRAY(int, 2*(length+1), mtClass); |
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1319 |
int j = 0; |
10546 | 1320 |
for (int i = 0; i < length; i += 1) { |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
1321 |
fd.reinitialize(this, i); |
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1322 |
if (!fd.is_static()) { |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1323 |
fields_sorted[j + 0] = fd.offset(); |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1324 |
fields_sorted[j + 1] = i; |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1325 |
j += 2; |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1326 |
} |
1 | 1327 |
} |
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1328 |
if (j > 0) { |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1329 |
length = j; |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1330 |
// _sort_Fn is defined in growableArray.hpp. |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1331 |
qsort(fields_sorted, length/2, 2*sizeof(int), (_sort_Fn)compare_fields_by_offset); |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1332 |
for (int i = 0; i < length; i += 2) { |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
1333 |
fd.reinitialize(this, fields_sorted[i + 1]); |
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1334 |
assert(!fd.is_static() && fd.offset() == fields_sorted[i], "only nonstatic fields"); |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1335 |
cl->do_field(&fd); |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1336 |
} |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1337 |
} |
27880
afb974a04396
8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents:
27674
diff
changeset
|
1338 |
FREE_C_HEAP_ARRAY(int, fields_sorted); |
1 | 1339 |
} |
1340 |
||
1341 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1342 |
void InstanceKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1343 |
if (array_klasses() != NULL) |
13952
e3cf184080bc
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
13738
diff
changeset
|
1344 |
ArrayKlass::cast(array_klasses())->array_klasses_do(f, THREAD); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1345 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1346 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1347 |
void InstanceKlass::array_klasses_do(void f(Klass* k)) { |
1 | 1348 |
if (array_klasses() != NULL) |
13952
e3cf184080bc
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
13738
diff
changeset
|
1349 |
ArrayKlass::cast(array_klasses())->array_klasses_do(f); |
1 | 1350 |
} |
1351 |
||
1352 |
#ifdef ASSERT |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1353 |
static int linear_search(Array<Method*>* methods, Symbol* name, Symbol* signature) { |
1 | 1354 |
int len = methods->length(); |
1355 |
for (int index = 0; index < len; index++) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1356 |
Method* m = methods->at(index); |
1 | 1357 |
assert(m->is_method(), "must be method"); |
1358 |
if (m->signature() == signature && m->name() == name) { |
|
1359 |
return index; |
|
1360 |
} |
|
1361 |
} |
|
1362 |
return -1; |
|
1363 |
} |
|
1364 |
#endif |
|
1365 |
||
14385 | 1366 |
static int binary_search(Array<Method*>* methods, Symbol* name) { |
1 | 1367 |
int len = methods->length(); |
1368 |
// methods are sorted, so do binary search |
|
1369 |
int l = 0; |
|
1370 |
int h = len - 1; |
|
1371 |
while (l <= h) { |
|
1372 |
int mid = (l + h) >> 1; |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1373 |
Method* m = methods->at(mid); |
1 | 1374 |
assert(m->is_method(), "must be method"); |
1375 |
int res = m->name()->fast_compare(name); |
|
1376 |
if (res == 0) { |
|
14385 | 1377 |
return mid; |
1 | 1378 |
} else if (res < 0) { |
1379 |
l = mid + 1; |
|
1380 |
} else { |
|
1381 |
h = mid - 1; |
|
1382 |
} |
|
1383 |
} |
|
14385 | 1384 |
return -1; |
1385 |
} |
|
1386 |
||
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1387 |
// find_method looks up the name/signature in the local methods array |
14385 | 1388 |
Method* InstanceKlass::find_method(Symbol* name, Symbol* signature) const { |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1389 |
return find_method_impl(name, signature, find_overpass, find_static); |
23999
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1390 |
} |
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1391 |
|
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1392 |
Method* InstanceKlass::find_method_impl(Symbol* name, Symbol* signature, |
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1393 |
OverpassLookupMode overpass_mode, StaticLookupMode static_mode) const { |
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1394 |
return InstanceKlass::find_method_impl(methods(), name, signature, overpass_mode, static_mode); |
14385 | 1395 |
} |
1396 |
||
21913
0e2fd7282ac6
8028438: static superclass method masks default methods
acorn
parents:
21768
diff
changeset
|
1397 |
// find_instance_method looks up the name/signature in the local methods array |
0e2fd7282ac6
8028438: static superclass method masks default methods
acorn
parents:
21768
diff
changeset
|
1398 |
// and skips over static methods |
0e2fd7282ac6
8028438: static superclass method masks default methods
acorn
parents:
21768
diff
changeset
|
1399 |
Method* InstanceKlass::find_instance_method( |
0e2fd7282ac6
8028438: static superclass method masks default methods
acorn
parents:
21768
diff
changeset
|
1400 |
Array<Method*>* methods, Symbol* name, Symbol* signature) { |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1401 |
Method* meth = InstanceKlass::find_method_impl(methods, name, signature, |
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1402 |
find_overpass, skip_static); |
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1403 |
assert(((meth == NULL) || !meth->is_static()), "find_instance_method should have skipped statics"); |
21913
0e2fd7282ac6
8028438: static superclass method masks default methods
acorn
parents:
21768
diff
changeset
|
1404 |
return meth; |
0e2fd7282ac6
8028438: static superclass method masks default methods
acorn
parents:
21768
diff
changeset
|
1405 |
} |
0e2fd7282ac6
8028438: static superclass method masks default methods
acorn
parents:
21768
diff
changeset
|
1406 |
|
28514 | 1407 |
// find_instance_method looks up the name/signature in the local methods array |
1408 |
// and skips over static methods |
|
1409 |
Method* InstanceKlass::find_instance_method(Symbol* name, Symbol* signature) { |
|
1410 |
return InstanceKlass::find_instance_method(methods(), name, signature); |
|
1411 |
} |
|
1412 |
||
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1413 |
// find_method looks up the name/signature in the local methods array |
14385 | 1414 |
Method* InstanceKlass::find_method( |
1415 |
Array<Method*>* methods, Symbol* name, Symbol* signature) { |
|
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1416 |
return InstanceKlass::find_method_impl(methods, name, signature, find_overpass, find_static); |
23999
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1417 |
} |
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1418 |
|
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1419 |
Method* InstanceKlass::find_method_impl( |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1420 |
Array<Method*>* methods, Symbol* name, Symbol* signature, OverpassLookupMode overpass_mode, StaticLookupMode static_mode) { |
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1421 |
int hit = find_method_index(methods, name, signature, overpass_mode, static_mode); |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1422 |
return hit >= 0 ? methods->at(hit): NULL; |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1423 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1424 |
|
28514 | 1425 |
bool InstanceKlass::method_matches(Method* m, Symbol* signature, bool skipping_overpass, bool skipping_static) { |
1426 |
return (m->signature() == signature) && |
|
1427 |
(!skipping_overpass || !m->is_overpass()) && |
|
1428 |
(!skipping_static || !m->is_static()); |
|
1429 |
} |
|
1430 |
||
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1431 |
// Used directly for default_methods to find the index into the |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1432 |
// default_vtable_indices, and indirectly by find_method |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1433 |
// find_method_index looks in the local methods array to return the index |
23999
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1434 |
// of the matching name/signature. If, overpass methods are being ignored, |
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1435 |
// the search continues to find a potential non-overpass match. This capability |
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1436 |
// is important during method resolution to prefer a static method, for example, |
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1437 |
// over an overpass method. |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1438 |
int InstanceKlass::find_method_index( |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1439 |
Array<Method*>* methods, Symbol* name, Symbol* signature, OverpassLookupMode overpass_mode, StaticLookupMode static_mode) { |
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1440 |
bool skipping_overpass = (overpass_mode == skip_overpass); |
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1441 |
bool skipping_static = (static_mode == skip_static); |
14385 | 1442 |
int hit = binary_search(methods, name); |
1443 |
if (hit != -1) { |
|
1444 |
Method* m = methods->at(hit); |
|
28514 | 1445 |
|
14385 | 1446 |
// Do linear search to find matching signature. First, quick check |
23999
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1447 |
// for common case, ignoring overpasses if requested. |
28514 | 1448 |
if (method_matches(m, signature, skipping_overpass, skipping_static)) return hit; |
23999
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1449 |
|
14385 | 1450 |
// search downwards through overloaded methods |
1451 |
int i; |
|
1452 |
for (i = hit - 1; i >= 0; --i) { |
|
1453 |
Method* m = methods->at(i); |
|
1454 |
assert(m->is_method(), "must be method"); |
|
1455 |
if (m->name() != name) break; |
|
28514 | 1456 |
if (method_matches(m, signature, skipping_overpass, skipping_static)) return i; |
14385 | 1457 |
} |
1458 |
// search upwards |
|
1459 |
for (i = hit + 1; i < methods->length(); ++i) { |
|
1460 |
Method* m = methods->at(i); |
|
1461 |
assert(m->is_method(), "must be method"); |
|
1462 |
if (m->name() != name) break; |
|
28514 | 1463 |
if (method_matches(m, signature, skipping_overpass, skipping_static)) return i; |
14385 | 1464 |
} |
1465 |
// not found |
|
1 | 1466 |
#ifdef ASSERT |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1467 |
int index = (skipping_overpass || skipping_static) ? -1 : linear_search(methods, name, signature); |
14385 | 1468 |
assert(index == -1, err_msg("binary search should have found entry %d", index)); |
1 | 1469 |
#endif |
14385 | 1470 |
} |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1471 |
return -1; |
1 | 1472 |
} |
14385 | 1473 |
int InstanceKlass::find_method_by_name(Symbol* name, int* end) { |
1474 |
return find_method_by_name(methods(), name, end); |
|
1475 |
} |
|
1476 |
||
1477 |
int InstanceKlass::find_method_by_name( |
|
1478 |
Array<Method*>* methods, Symbol* name, int* end_ptr) { |
|
1479 |
assert(end_ptr != NULL, "just checking"); |
|
1480 |
int start = binary_search(methods, name); |
|
1481 |
int end = start + 1; |
|
1482 |
if (start != -1) { |
|
1483 |
while (start - 1 >= 0 && (methods->at(start - 1))->name() == name) --start; |
|
1484 |
while (end < methods->length() && (methods->at(end))->name() == name) ++end; |
|
1485 |
*end_ptr = end; |
|
1486 |
return start; |
|
1487 |
} |
|
1488 |
return -1; |
|
1489 |
} |
|
1490 |
||
22232
26acfad336c0
8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents:
22221
diff
changeset
|
1491 |
// uncached_lookup_method searches both the local class methods array and all |
26acfad336c0
8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents:
22221
diff
changeset
|
1492 |
// superclasses methods arrays, skipping any overpass methods in superclasses. |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1493 |
Method* InstanceKlass::uncached_lookup_method(Symbol* name, Symbol* signature, OverpassLookupMode overpass_mode) const { |
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1494 |
OverpassLookupMode overpass_local_mode = overpass_mode; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1495 |
Klass* klass = const_cast<InstanceKlass*>(this); |
1 | 1496 |
while (klass != NULL) { |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1497 |
Method* method = InstanceKlass::cast(klass)->find_method_impl(name, signature, overpass_local_mode, find_static); |
23999
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1498 |
if (method != NULL) { |
22232
26acfad336c0
8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents:
22221
diff
changeset
|
1499 |
return method; |
26acfad336c0
8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents:
22221
diff
changeset
|
1500 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1501 |
klass = InstanceKlass::cast(klass)->super(); |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1502 |
overpass_local_mode = skip_overpass; // Always ignore overpass methods in superclasses |
1 | 1503 |
} |
1504 |
return NULL; |
|
1505 |
} |
|
1506 |
||
24828
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1507 |
#ifdef ASSERT |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1508 |
// search through class hierarchy and return true if this class or |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1509 |
// one of the superclasses was redefined |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1510 |
bool InstanceKlass::has_redefined_this_or_super() const { |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1511 |
const InstanceKlass* klass = this; |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1512 |
while (klass != NULL) { |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1513 |
if (klass->has_been_redefined()) { |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1514 |
return true; |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1515 |
} |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1516 |
klass = InstanceKlass::cast(klass->super()); |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1517 |
} |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1518 |
return false; |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1519 |
} |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1520 |
#endif |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1521 |
|
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1522 |
// lookup a method in the default methods list then in all transitive interfaces |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1523 |
// Do NOT return private or static methods |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1524 |
Method* InstanceKlass::lookup_method_in_ordered_interfaces(Symbol* name, |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1525 |
Symbol* signature) const { |
20396
0ed0e7aa1ed8
8026185: nsk/jvmit/GetMethodDeclaringClass/declcls001 failed
acorn
parents:
20391
diff
changeset
|
1526 |
Method* m = NULL; |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1527 |
if (default_methods() != NULL) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1528 |
m = find_method(default_methods(), name, signature); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1529 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1530 |
// Look up interfaces |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1531 |
if (m == NULL) { |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1532 |
m = lookup_method_in_all_interfaces(name, signature, find_defaults); |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1533 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1534 |
return m; |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1535 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1536 |
|
1 | 1537 |
// lookup a method in all the interfaces that this class implements |
20284
595a25ab9474
8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default.
acorn
parents:
20282
diff
changeset
|
1538 |
// Do NOT return private or static methods, new in JDK8 which are not externally visible |
595a25ab9474
8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default.
acorn
parents:
20282
diff
changeset
|
1539 |
// They should only be found in the initial InterfaceMethodRef |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1540 |
Method* InstanceKlass::lookup_method_in_all_interfaces(Symbol* name, |
22232
26acfad336c0
8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents:
22221
diff
changeset
|
1541 |
Symbol* signature, |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1542 |
DefaultsLookupMode defaults_mode) const { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1543 |
Array<Klass*>* all_ifs = transitive_interfaces(); |
1 | 1544 |
int num_ifs = all_ifs->length(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1545 |
InstanceKlass *ik = NULL; |
1 | 1546 |
for (int i = 0; i < num_ifs; i++) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1547 |
ik = InstanceKlass::cast(all_ifs->at(i)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1548 |
Method* m = ik->lookup_method(name, signature); |
22232
26acfad336c0
8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents:
22221
diff
changeset
|
1549 |
if (m != NULL && m->is_public() && !m->is_static() && |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1550 |
((defaults_mode != skip_defaults) || !m->is_default_method())) { |
1 | 1551 |
return m; |
1552 |
} |
|
1553 |
} |
|
1554 |
return NULL; |
|
1555 |
} |
|
1556 |
||
1557 |
/* jni_id_for_impl for jfieldIds only */ |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1558 |
JNIid* InstanceKlass::jni_id_for_impl(instanceKlassHandle this_k, int offset) { |
1 | 1559 |
MutexLocker ml(JfieldIdCreation_lock); |
1560 |
// Retry lookup after we got the lock |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1561 |
JNIid* probe = this_k->jni_ids() == NULL ? NULL : this_k->jni_ids()->find(offset); |
1 | 1562 |
if (probe == NULL) { |
1563 |
// Slow case, allocate new static field identifier |
|
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1564 |
probe = new JNIid(this_k(), offset, this_k->jni_ids()); |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
1565 |
this_k->set_jni_ids(probe); |
1 | 1566 |
} |
1567 |
return probe; |
|
1568 |
} |
|
1569 |
||
1570 |
||
1571 |
/* jni_id_for for jfieldIds only */ |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1572 |
JNIid* InstanceKlass::jni_id_for(int offset) { |
1 | 1573 |
JNIid* probe = jni_ids() == NULL ? NULL : jni_ids()->find(offset); |
1574 |
if (probe == NULL) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1575 |
probe = jni_id_for_impl(this, offset); |
1 | 1576 |
} |
1577 |
return probe; |
|
1578 |
} |
|
1579 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1580 |
u2 InstanceKlass::enclosing_method_data(int offset) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1581 |
Array<jushort>* inner_class_list = inner_classes(); |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1582 |
if (inner_class_list == NULL) { |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1583 |
return 0; |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1584 |
} |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1585 |
int length = inner_class_list->length(); |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1586 |
if (length % inner_class_next_offset == 0) { |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1587 |
return 0; |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1588 |
} else { |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1589 |
int index = length - enclosing_method_attribute_size; |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1590 |
assert(offset < enclosing_method_attribute_size, "invalid offset"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1591 |
return inner_class_list->at(index + offset); |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1592 |
} |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1593 |
} |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1594 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1595 |
void InstanceKlass::set_enclosing_method_indices(u2 class_index, |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1596 |
u2 method_index) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1597 |
Array<jushort>* inner_class_list = inner_classes(); |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1598 |
assert (inner_class_list != NULL, "_inner_classes list is not set up"); |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1599 |
int length = inner_class_list->length(); |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1600 |
if (length % inner_class_next_offset == enclosing_method_attribute_size) { |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1601 |
int index = length - enclosing_method_attribute_size; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1602 |
inner_class_list->at_put( |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1603 |
index + enclosing_method_class_index_offset, class_index); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1604 |
inner_class_list->at_put( |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1605 |
index + enclosing_method_method_index_offset, method_index); |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1606 |
} |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1607 |
} |
1 | 1608 |
|
1609 |
// Lookup or create a jmethodID. |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1610 |
// This code is called by the VMThread and JavaThreads so the |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1611 |
// locking has to be done very carefully to avoid deadlocks |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1612 |
// and/or other cache consistency problems. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1613 |
// |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1614 |
jmethodID InstanceKlass::get_jmethod_id(instanceKlassHandle ik_h, methodHandle method_h) { |
1 | 1615 |
size_t idnum = (size_t)method_h->method_idnum(); |
1616 |
jmethodID* jmeths = ik_h->methods_jmethod_ids_acquire(); |
|
1617 |
size_t length = 0; |
|
1618 |
jmethodID id = NULL; |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1619 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1620 |
// We use a double-check locking idiom here because this cache is |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1621 |
// performance sensitive. In the normal system, this cache only |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1622 |
// transitions from NULL to non-NULL which is safe because we use |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1623 |
// release_set_methods_jmethod_ids() to advertise the new cache. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1624 |
// A partially constructed cache should never be seen by a racing |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1625 |
// thread. We also use release_store_ptr() to save a new jmethodID |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1626 |
// in the cache so a partially constructed jmethodID should never be |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1627 |
// seen either. Cache reads of existing jmethodIDs proceed without a |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1628 |
// lock, but cache writes of a new jmethodID requires uniqueness and |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1629 |
// creation of the cache itself requires no leaks so a lock is |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1630 |
// generally acquired in those two cases. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1631 |
// |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1632 |
// If the RedefineClasses() API has been used, then this cache can |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1633 |
// grow and we'll have transitions from non-NULL to bigger non-NULL. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1634 |
// Cache creation requires no leaks and we require safety between all |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1635 |
// cache accesses and freeing of the old cache so a lock is generally |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1636 |
// acquired when the RedefineClasses() API has been used. |
1 | 1637 |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1638 |
if (jmeths != NULL) { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1639 |
// the cache already exists |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1640 |
if (!ik_h->idnum_can_increment()) { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1641 |
// the cache can't grow so we can just get the current values |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1642 |
get_jmethod_id_length_value(jmeths, idnum, &length, &id); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1643 |
} else { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1644 |
// cache can grow so we have to be more careful |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1645 |
if (Threads::number_of_threads() == 0 || |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1646 |
SafepointSynchronize::is_at_safepoint()) { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1647 |
// we're single threaded or at a safepoint - no locking needed |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1648 |
get_jmethod_id_length_value(jmeths, idnum, &length, &id); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1649 |
} else { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1650 |
MutexLocker ml(JmethodIdCreation_lock); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1651 |
get_jmethod_id_length_value(jmeths, idnum, &length, &id); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1652 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1653 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1654 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1655 |
// implied else: |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1656 |
// we need to allocate a cache so default length and id values are good |
1 | 1657 |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1658 |
if (jmeths == NULL || // no cache yet |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1659 |
length <= idnum || // cache is too short |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1660 |
id == NULL) { // cache doesn't contain entry |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1661 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1662 |
// This function can be called by the VMThread so we have to do all |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1663 |
// things that might block on a safepoint before grabbing the lock. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1664 |
// Otherwise, we can deadlock with the VMThread or have a cache |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1665 |
// consistency issue. These vars keep track of what we might have |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1666 |
// to free after the lock is dropped. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1667 |
jmethodID to_dealloc_id = NULL; |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1668 |
jmethodID* to_dealloc_jmeths = NULL; |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1669 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1670 |
// may not allocate new_jmeths or use it if we allocate it |
1 | 1671 |
jmethodID* new_jmeths = NULL; |
1672 |
if (length <= idnum) { |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1673 |
// allocate a new cache that might be used |
1 | 1674 |
size_t size = MAX2(idnum+1, (size_t)ik_h->idnum_allocated_count()); |
13195 | 1675 |
new_jmeths = NEW_C_HEAP_ARRAY(jmethodID, size+1, mtClass); |
1 | 1676 |
memset(new_jmeths, 0, (size+1)*sizeof(jmethodID)); |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1677 |
// cache size is stored in element[0], other elements offset by one |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1678 |
new_jmeths[0] = (jmethodID)size; |
1 | 1679 |
} |
1680 |
||
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1681 |
// allocate a new jmethodID that might be used |
1 | 1682 |
jmethodID new_id = NULL; |
1683 |
if (method_h->is_old() && !method_h->is_obsolete()) { |
|
1684 |
// The method passed in is old (but not obsolete), we need to use the current version |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1685 |
Method* current_method = ik_h->method_with_idnum((int)idnum); |
1 | 1686 |
assert(current_method != NULL, "old and but not obsolete, so should exist"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1687 |
new_id = Method::make_jmethod_id(ik_h->class_loader_data(), current_method); |
1 | 1688 |
} else { |
1689 |
// It is the current version of the method or an obsolete method, |
|
1690 |
// use the version passed in |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1691 |
new_id = Method::make_jmethod_id(ik_h->class_loader_data(), method_h()); |
1 | 1692 |
} |
1693 |
||
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1694 |
if (Threads::number_of_threads() == 0 || |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1695 |
SafepointSynchronize::is_at_safepoint()) { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1696 |
// we're single threaded or at a safepoint - no locking needed |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1697 |
id = get_jmethod_id_fetch_or_update(ik_h, idnum, new_id, new_jmeths, |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1698 |
&to_dealloc_id, &to_dealloc_jmeths); |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1699 |
} else { |
1 | 1700 |
MutexLocker ml(JmethodIdCreation_lock); |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1701 |
id = get_jmethod_id_fetch_or_update(ik_h, idnum, new_id, new_jmeths, |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1702 |
&to_dealloc_id, &to_dealloc_jmeths); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1703 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1704 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1705 |
// The lock has been dropped so we can free resources. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1706 |
// Free up either the old cache or the new cache if we allocated one. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1707 |
if (to_dealloc_jmeths != NULL) { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1708 |
FreeHeap(to_dealloc_jmeths); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1709 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1710 |
// free up the new ID since it wasn't needed |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1711 |
if (to_dealloc_id != NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1712 |
Method::destroy_jmethod_id(ik_h->class_loader_data(), to_dealloc_id); |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1713 |
} |
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1714 |
} |
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1715 |
return id; |
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1716 |
} |
1 | 1717 |
|
27478 | 1718 |
// Figure out how many jmethodIDs haven't been allocated, and make |
1719 |
// sure space for them is pre-allocated. This makes getting all |
|
1720 |
// method ids much, much faster with classes with more than 8 |
|
1721 |
// methods, and has a *substantial* effect on performance with jvmti |
|
1722 |
// code that loads all jmethodIDs for all classes. |
|
1723 |
void InstanceKlass::ensure_space_for_methodids(int start_offset) { |
|
1724 |
int new_jmeths = 0; |
|
1725 |
int length = methods()->length(); |
|
1726 |
for (int index = start_offset; index < length; index++) { |
|
1727 |
Method* m = methods()->at(index); |
|
1728 |
jmethodID id = m->find_jmethod_id_or_null(); |
|
1729 |
if (id == NULL) { |
|
1730 |
new_jmeths++; |
|
1731 |
} |
|
1732 |
} |
|
1733 |
if (new_jmeths != 0) { |
|
1734 |
Method::ensure_jmethod_ids(class_loader_data(), new_jmeths); |
|
1735 |
} |
|
1736 |
} |
|
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1737 |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1738 |
// Common code to fetch the jmethodID from the cache or update the |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1739 |
// cache with the new jmethodID. This function should never do anything |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1740 |
// that causes the caller to go to a safepoint or we can deadlock with |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1741 |
// the VMThread or have cache consistency issues. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1742 |
// |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1743 |
jmethodID InstanceKlass::get_jmethod_id_fetch_or_update( |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1744 |
instanceKlassHandle ik_h, size_t idnum, jmethodID new_id, |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1745 |
jmethodID* new_jmeths, jmethodID* to_dealloc_id_p, |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1746 |
jmethodID** to_dealloc_jmeths_p) { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1747 |
assert(new_id != NULL, "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1748 |
assert(to_dealloc_id_p != NULL, "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1749 |
assert(to_dealloc_jmeths_p != NULL, "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1750 |
assert(Threads::number_of_threads() == 0 || |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1751 |
SafepointSynchronize::is_at_safepoint() || |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1752 |
JmethodIdCreation_lock->owned_by_self(), "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1753 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1754 |
// reacquire the cache - we are locked, single threaded or at a safepoint |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1755 |
jmethodID* jmeths = ik_h->methods_jmethod_ids_acquire(); |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1756 |
jmethodID id = NULL; |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1757 |
size_t length = 0; |
1 | 1758 |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1759 |
if (jmeths == NULL || // no cache yet |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1760 |
(length = (size_t)jmeths[0]) <= idnum) { // cache is too short |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1761 |
if (jmeths != NULL) { |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1762 |
// copy any existing entries from the old cache |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1763 |
for (size_t index = 0; index < length; index++) { |
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1764 |
new_jmeths[index+1] = jmeths[index+1]; |
1 | 1765 |
} |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1766 |
*to_dealloc_jmeths_p = jmeths; // save old cache for later delete |
1 | 1767 |
} |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1768 |
ik_h->release_set_methods_jmethod_ids(jmeths = new_jmeths); |
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1769 |
} else { |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1770 |
// fetch jmethodID (if any) from the existing cache |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1771 |
id = jmeths[idnum+1]; |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1772 |
*to_dealloc_jmeths_p = new_jmeths; // save new cache for later delete |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1773 |
} |
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1774 |
if (id == NULL) { |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1775 |
// No matching jmethodID in the existing cache or we have a new |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1776 |
// cache or we just grew the cache. This cache write is done here |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1777 |
// by the first thread to win the foot race because a jmethodID |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1778 |
// needs to be unique once it is generally available. |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1779 |
id = new_id; |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1780 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1781 |
// The jmethodID cache can be read while unlocked so we have to |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1782 |
// make sure the new jmethodID is complete before installing it |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1783 |
// in the cache. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1784 |
OrderAccess::release_store_ptr(&jmeths[idnum+1], id); |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1785 |
} else { |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1786 |
*to_dealloc_id_p = new_id; // save new id for later delete |
1 | 1787 |
} |
1788 |
return id; |
|
1789 |
} |
|
1790 |
||
1791 |
||
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1792 |
// Common code to get the jmethodID cache length and the jmethodID |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1793 |
// value at index idnum if there is one. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1794 |
// |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1795 |
void InstanceKlass::get_jmethod_id_length_value(jmethodID* cache, |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1796 |
size_t idnum, size_t *length_p, jmethodID* id_p) { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1797 |
assert(cache != NULL, "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1798 |
assert(length_p != NULL, "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1799 |
assert(id_p != NULL, "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1800 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1801 |
// cache size is stored in element[0], other elements offset by one |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1802 |
*length_p = (size_t)cache[0]; |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1803 |
if (*length_p <= idnum) { // cache is too short |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1804 |
*id_p = NULL; |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1805 |
} else { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1806 |
*id_p = cache[idnum+1]; // fetch jmethodID (if any) |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1807 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1808 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1809 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1810 |
|
1 | 1811 |
// Lookup a jmethodID, NULL if not found. Do no blocking, no allocations, no handles |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1812 |
jmethodID InstanceKlass::jmethod_id_or_null(Method* method) { |
1 | 1813 |
size_t idnum = (size_t)method->method_idnum(); |
1814 |
jmethodID* jmeths = methods_jmethod_ids_acquire(); |
|
1815 |
size_t length; // length assigned as debugging crumb |
|
1816 |
jmethodID id = NULL; |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1817 |
if (jmeths != NULL && // If there is a cache |
1 | 1818 |
(length = (size_t)jmeths[0]) > idnum) { // and if it is long enough, |
1819 |
id = jmeths[idnum+1]; // Look up the id (may be NULL) |
|
1820 |
} |
|
1821 |
return id; |
|
1822 |
} |
|
1823 |
||
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1824 |
int nmethodBucket::decrement() { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1825 |
return Atomic::add(-1, (volatile int *)&_count); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1826 |
} |
1 | 1827 |
|
1828 |
// |
|
1829 |
// Walk the list of dependent nmethods searching for nmethods which |
|
10265
4c869854aebd
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
9971
diff
changeset
|
1830 |
// are dependent on the changes that were passed in and mark them for |
1 | 1831 |
// deoptimization. Returns the number of nmethods found. |
1832 |
// |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1833 |
int InstanceKlass::mark_dependent_nmethods(DepChange& changes) { |
1 | 1834 |
assert_locked_or_safepoint(CodeCache_lock); |
1835 |
int found = 0; |
|
1836 |
nmethodBucket* b = _dependencies; |
|
1837 |
while (b != NULL) { |
|
1838 |
nmethod* nm = b->get_nmethod(); |
|
1839 |
// since dependencies aren't removed until an nmethod becomes a zombie, |
|
1840 |
// the dependency list may contain nmethods which aren't alive. |
|
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1841 |
if (b->count() > 0 && nm->is_alive() && !nm->is_marked_for_deoptimization() && nm->check_dependency_on(changes)) { |
1 | 1842 |
if (TraceDependencies) { |
1843 |
ResourceMark rm; |
|
1844 |
tty->print_cr("Marked for deoptimization"); |
|
1845 |
tty->print_cr(" context = %s", this->external_name()); |
|
1846 |
changes.print(); |
|
1847 |
nm->print(); |
|
1848 |
nm->print_dependencies(); |
|
1849 |
} |
|
1850 |
nm->mark_for_deoptimization(); |
|
1851 |
found++; |
|
1852 |
} |
|
1853 |
b = b->next(); |
|
1854 |
} |
|
1855 |
return found; |
|
1856 |
} |
|
1857 |
||
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1858 |
void InstanceKlass::clean_dependent_nmethods() { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1859 |
assert_locked_or_safepoint(CodeCache_lock); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1860 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1861 |
if (has_unloaded_dependent()) { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1862 |
nmethodBucket* b = _dependencies; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1863 |
nmethodBucket* last = NULL; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1864 |
while (b != NULL) { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1865 |
assert(b->count() >= 0, err_msg("bucket count: %d", b->count())); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1866 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1867 |
nmethodBucket* next = b->next(); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1868 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1869 |
if (b->count() == 0) { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1870 |
if (last == NULL) { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1871 |
_dependencies = next; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1872 |
} else { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1873 |
last->set_next(next); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1874 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1875 |
delete b; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1876 |
// last stays the same. |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1877 |
} else { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1878 |
last = b; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1879 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1880 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1881 |
b = next; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1882 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1883 |
set_has_unloaded_dependent(false); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1884 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1885 |
#ifdef ASSERT |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1886 |
else { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1887 |
// Verification |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1888 |
for (nmethodBucket* b = _dependencies; b != NULL; b = b->next()) { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1889 |
assert(b->count() >= 0, err_msg("bucket count: %d", b->count())); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1890 |
assert(b->count() != 0, "empty buckets need to be cleaned"); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1891 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1892 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1893 |
#endif |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1894 |
} |
1 | 1895 |
|
1896 |
// |
|
1897 |
// Add an nmethodBucket to the list of dependencies for this nmethod. |
|
1898 |
// It's possible that an nmethod has multiple dependencies on this klass |
|
1899 |
// so a count is kept for each bucket to guarantee that creation and |
|
1900 |
// deletion of dependencies is consistent. |
|
1901 |
// |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1902 |
void InstanceKlass::add_dependent_nmethod(nmethod* nm) { |
1 | 1903 |
assert_locked_or_safepoint(CodeCache_lock); |
1904 |
nmethodBucket* b = _dependencies; |
|
1905 |
nmethodBucket* last = NULL; |
|
1906 |
while (b != NULL) { |
|
1907 |
if (nm == b->get_nmethod()) { |
|
1908 |
b->increment(); |
|
1909 |
return; |
|
1910 |
} |
|
1911 |
b = b->next(); |
|
1912 |
} |
|
1913 |
_dependencies = new nmethodBucket(nm, _dependencies); |
|
1914 |
} |
|
1915 |
||
1916 |
||
1917 |
// |
|
1918 |
// Decrement count of the nmethod in the dependency list and remove |
|
1919 |
// the bucket competely when the count goes to 0. This method must |
|
1920 |
// find a corresponding bucket otherwise there's a bug in the |
|
1921 |
// recording of dependecies. |
|
1922 |
// |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1923 |
void InstanceKlass::remove_dependent_nmethod(nmethod* nm) { |
1 | 1924 |
assert_locked_or_safepoint(CodeCache_lock); |
1925 |
nmethodBucket* b = _dependencies; |
|
1926 |
nmethodBucket* last = NULL; |
|
1927 |
while (b != NULL) { |
|
1928 |
if (nm == b->get_nmethod()) { |
|
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1929 |
int val = b->decrement(); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1930 |
guarantee(val >= 0, err_msg("Underflow: %d", val)); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1931 |
if (val == 0) { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1932 |
set_has_unloaded_dependent(true); |
1 | 1933 |
} |
1934 |
return; |
|
1935 |
} |
|
1936 |
last = b; |
|
1937 |
b = b->next(); |
|
1938 |
} |
|
1939 |
#ifdef ASSERT |
|
1940 |
tty->print_cr("### %s can't find dependent nmethod:", this->external_name()); |
|
1941 |
nm->print(); |
|
1942 |
#endif // ASSERT |
|
1943 |
ShouldNotReachHere(); |
|
1944 |
} |
|
1945 |
||
1946 |
||
1947 |
#ifndef PRODUCT |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1948 |
void InstanceKlass::print_dependent_nmethods(bool verbose) { |
1 | 1949 |
nmethodBucket* b = _dependencies; |
1950 |
int idx = 0; |
|
1951 |
while (b != NULL) { |
|
1952 |
nmethod* nm = b->get_nmethod(); |
|
1953 |
tty->print("[%d] count=%d { ", idx++, b->count()); |
|
1954 |
if (!verbose) { |
|
1955 |
nm->print_on(tty, "nmethod"); |
|
1956 |
tty->print_cr(" } "); |
|
1957 |
} else { |
|
1958 |
nm->print(); |
|
1959 |
nm->print_dependencies(); |
|
1960 |
tty->print_cr("--- } "); |
|
1961 |
} |
|
1962 |
b = b->next(); |
|
1963 |
} |
|
1964 |
} |
|
1965 |
||
1966 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1967 |
bool InstanceKlass::is_dependent_nmethod(nmethod* nm) { |
1 | 1968 |
nmethodBucket* b = _dependencies; |
1969 |
while (b != NULL) { |
|
1970 |
if (nm == b->get_nmethod()) { |
|
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1971 |
#ifdef ASSERT |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1972 |
int count = b->count(); |
25500 | 1973 |
assert(count >= 0, err_msg("count shouldn't be negative: %d", count)); |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1974 |
#endif |
1 | 1975 |
return true; |
1976 |
} |
|
1977 |
b = b->next(); |
|
1978 |
} |
|
1979 |
return false; |
|
1980 |
} |
|
1981 |
#endif //PRODUCT |
|
1982 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1983 |
void InstanceKlass::clean_implementors_list(BoolObjectClosure* is_alive) { |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1984 |
assert(class_loader_data()->is_alive(is_alive), "this klass should be live"); |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
1985 |
if (is_interface()) { |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
1986 |
if (ClassUnloading) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1987 |
Klass* impl = implementor(); |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
1988 |
if (impl != NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1989 |
if (!impl->is_loader_alive(is_alive)) { |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
1990 |
// remove this guy |
15873
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
1991 |
Klass** klass = adr_implementor(); |
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
1992 |
assert(klass != NULL, "null klass"); |
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
1993 |
if (klass != NULL) { |
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
1994 |
*klass = NULL; |
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
1995 |
} |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
1996 |
} |
1 | 1997 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1998 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1999 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2000 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2001 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2002 |
void InstanceKlass::clean_method_data(BoolObjectClosure* is_alive) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2003 |
for (int m = 0; m < methods()->length(); m++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2004 |
MethodData* mdo = methods()->at(m)->method_data(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2005 |
if (mdo != NULL) { |
22916
582da2ed4dfa
8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents:
22881
diff
changeset
|
2006 |
mdo->clean_method_data(is_alive); |
1 | 2007 |
} |
2008 |
} |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2009 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2010 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2011 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2012 |
static void remove_unshareable_in_class(Klass* k) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2013 |
// remove klass's unshareable info |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2014 |
k->remove_unshareable_info(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2015 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2016 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2017 |
void InstanceKlass::remove_unshareable_info() { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2018 |
Klass::remove_unshareable_info(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2019 |
// Unlink the class |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2020 |
if (is_linked()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2021 |
unlink_class(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2022 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2023 |
init_implementor(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2024 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2025 |
constants()->remove_unshareable_info(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2026 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2027 |
for (int i = 0; i < methods()->length(); i++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2028 |
Method* m = methods()->at(i); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2029 |
m->remove_unshareable_info(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2030 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2031 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2032 |
// do array classes also. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2033 |
array_klasses_do(remove_unshareable_in_class); |
1 | 2034 |
} |
2035 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2036 |
static void restore_unshareable_in_class(Klass* k, TRAPS) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2037 |
// Array classes have null protection domain. |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2038 |
// --> see ArrayKlass::complete_create_array_klass() |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2039 |
k->restore_unshareable_info(ClassLoaderData::the_null_class_loader_data(), Handle(), CHECK); |
1 | 2040 |
} |
2041 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2042 |
void InstanceKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2043 |
Klass::restore_unshareable_info(loader_data, protection_domain, CHECK); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2044 |
instanceKlassHandle ik(THREAD, this); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2045 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2046 |
Array<Method*>* methods = ik->methods(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2047 |
int num_methods = methods->length(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2048 |
for (int index2 = 0; index2 < num_methods; ++index2) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2049 |
methodHandle m(THREAD, methods->at(index2)); |
23872
536c66fc43d3
8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents:
23515
diff
changeset
|
2050 |
m->restore_unshareable_info(CHECK); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2051 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2052 |
if (JvmtiExport::has_redefined_a_class()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2053 |
// Reinitialize vtable because RedefineClasses may have changed some |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2054 |
// entries in this vtable for super classes so the CDS vtable might |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2055 |
// point to old or obsolete entries. RedefineClasses doesn't fix up |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2056 |
// vtables in the shared system dictionary, only the main one. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2057 |
// It also redefines the itable too so fix that too. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2058 |
ResourceMark rm(THREAD); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2059 |
ik->vtable()->initialize_vtable(false, CHECK); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2060 |
ik->itable()->initialize_itable(false, CHECK); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2061 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2062 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2063 |
// restore constant pool resolved references |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2064 |
ik->constants()->restore_unshareable_info(CHECK); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2065 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2066 |
ik->array_klasses_do(restore_unshareable_in_class, CHECK); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2067 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2068 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2069 |
// returns true IFF is_in_error_state() has been changed as a result of this call. |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2070 |
bool InstanceKlass::check_sharing_error_state() { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2071 |
assert(DumpSharedSpaces, "should only be called during dumping"); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2072 |
bool old_state = is_in_error_state(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2073 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2074 |
if (!is_in_error_state()) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2075 |
bool bad = false; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2076 |
for (InstanceKlass* sup = java_super(); sup; sup = sup->java_super()) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2077 |
if (sup->is_in_error_state()) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2078 |
bad = true; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2079 |
break; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2080 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2081 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2082 |
if (!bad) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2083 |
Array<Klass*>* interfaces = transitive_interfaces(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2084 |
for (int i = 0; i < interfaces->length(); i++) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2085 |
Klass* iface = interfaces->at(i); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2086 |
if (InstanceKlass::cast(iface)->is_in_error_state()) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2087 |
bad = true; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2088 |
break; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2089 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2090 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2091 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2092 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2093 |
if (bad) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2094 |
set_in_error_state(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2095 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2096 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2097 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2098 |
return (old_state != is_in_error_state()); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2099 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2100 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2101 |
static void clear_all_breakpoints(Method* m) { |
1 | 2102 |
m->clear_all_breakpoints(); |
2103 |
} |
|
2104 |
||
17075
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2105 |
|
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2106 |
void InstanceKlass::notify_unload_class(InstanceKlass* ik) { |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2107 |
// notify the debugger |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2108 |
if (JvmtiExport::should_post_class_unload()) { |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2109 |
JvmtiExport::post_class_unload(ik); |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2110 |
} |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2111 |
|
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2112 |
// notify ClassLoadingService of class unload |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2113 |
ClassLoadingService::notify_class_unloaded(ik); |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2114 |
} |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2115 |
|
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2116 |
void InstanceKlass::release_C_heap_structures(InstanceKlass* ik) { |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2117 |
// Clean up C heap |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2118 |
ik->release_C_heap_structures(); |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2119 |
ik->constants()->release_C_heap_structures(); |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2120 |
} |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2121 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2122 |
void InstanceKlass::release_C_heap_structures() { |
17075
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2123 |
|
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2124 |
// Can't release the constant pool here because the constant pool can be |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2125 |
// deallocated separately from the InstanceKlass for default methods and |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2126 |
// redefine classes. |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2127 |
|
1 | 2128 |
// Deallocate oop map cache |
2129 |
if (_oop_map_cache != NULL) { |
|
2130 |
delete _oop_map_cache; |
|
2131 |
_oop_map_cache = NULL; |
|
2132 |
} |
|
2133 |
||
2134 |
// Deallocate JNI identifiers for jfieldIDs |
|
2135 |
JNIid::deallocate(jni_ids()); |
|
2136 |
set_jni_ids(NULL); |
|
2137 |
||
2138 |
jmethodID* jmeths = methods_jmethod_ids_acquire(); |
|
2139 |
if (jmeths != (jmethodID*)NULL) { |
|
2140 |
release_set_methods_jmethod_ids(NULL); |
|
2141 |
FreeHeap(jmeths); |
|
2142 |
} |
|
2143 |
||
17830
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2144 |
// Deallocate MemberNameTable |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2145 |
{ |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2146 |
Mutex* lock_or_null = SafepointSynchronize::is_at_safepoint() ? NULL : MemberNameTable_lock; |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2147 |
MutexLockerEx ml(lock_or_null, Mutex::_no_safepoint_check_flag); |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2148 |
MemberNameTable* mnt = member_names(); |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2149 |
if (mnt != NULL) { |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2150 |
delete mnt; |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2151 |
set_member_names(NULL); |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2152 |
} |
17029
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2153 |
} |
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2154 |
|
1 | 2155 |
// release dependencies |
2156 |
nmethodBucket* b = _dependencies; |
|
2157 |
_dependencies = NULL; |
|
2158 |
while (b != NULL) { |
|
2159 |
nmethodBucket* next = b->next(); |
|
2160 |
delete b; |
|
2161 |
b = next; |
|
2162 |
} |
|
2163 |
||
2164 |
// Deallocate breakpoint records |
|
2165 |
if (breakpoints() != 0x0) { |
|
2166 |
methods_do(clear_all_breakpoints); |
|
2167 |
assert(breakpoints() == 0x0, "should have cleared breakpoints"); |
|
2168 |
} |
|
2169 |
||
2170 |
// deallocate the cached class file |
|
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
2171 |
if (_cached_class_file != NULL) { |
27880
afb974a04396
8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents:
27674
diff
changeset
|
2172 |
os::free(_cached_class_file); |
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
2173 |
_cached_class_file = NULL; |
1 | 2174 |
} |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2175 |
|
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2176 |
// Decrement symbol reference counts associated with the unloaded class. |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2177 |
if (_name != NULL) _name->decrement_refcount(); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2178 |
// unreference array name derived from this class name (arrays of an unloaded |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2179 |
// class can't be referenced anymore). |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2180 |
if (_array_name != NULL) _array_name->decrement_refcount(); |
27880
afb974a04396
8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents:
27674
diff
changeset
|
2181 |
if (_source_debug_extension != NULL) FREE_C_HEAP_ARRAY(char, _source_debug_extension); |
15104
f5d78994619f
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
14583
diff
changeset
|
2182 |
|
f5d78994619f
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
14583
diff
changeset
|
2183 |
assert(_total_instanceKlass_count >= 1, "Sanity check"); |
f5d78994619f
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
14583
diff
changeset
|
2184 |
Atomic::dec(&_total_instanceKlass_count); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2185 |
} |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2186 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2187 |
void InstanceKlass::set_source_debug_extension(char* array, int length) { |
13201
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2188 |
if (array == NULL) { |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2189 |
_source_debug_extension = NULL; |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2190 |
} else { |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2191 |
// Adding one to the attribute length in order to store a null terminator |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2192 |
// character could cause an overflow because the attribute length is |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2193 |
// already coded with an u4 in the classfile, but in practice, it's |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2194 |
// unlikely to happen. |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2195 |
assert((length+1) > length, "Overflow checking"); |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2196 |
char* sde = NEW_C_HEAP_ARRAY(char, (length + 1), mtClass); |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2197 |
for (int i = 0; i < length; i++) { |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2198 |
sde[i] = array[i]; |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2199 |
} |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2200 |
sde[length] = '\0'; |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2201 |
_source_debug_extension = sde; |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2202 |
} |
1 | 2203 |
} |
2204 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2205 |
address InstanceKlass::static_field_addr(int offset) { |
20282
7f9cbdf89af2
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
20065
diff
changeset
|
2206 |
return (address)(offset + InstanceMirrorKlass::offset_of_static_fields() + cast_from_oop<intptr_t>(java_mirror())); |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2207 |
} |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2208 |
|
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2209 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2210 |
const char* InstanceKlass::signature_name() const { |
21183
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2211 |
int hash_len = 0; |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2212 |
char hash_buf[40]; |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2213 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2214 |
// If this is an anonymous class, append a hash to make the name unique |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2215 |
if (is_anonymous()) { |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2216 |
intptr_t hash = (java_mirror() != NULL) ? java_mirror()->identity_hash() : 0; |
27471 | 2217 |
jio_snprintf(hash_buf, sizeof(hash_buf), "/" UINTX_FORMAT, (uintx)hash); |
21183
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2218 |
hash_len = (int)strlen(hash_buf); |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2219 |
} |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2220 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2221 |
// Get the internal name as a c string |
1 | 2222 |
const char* src = (const char*) (name()->as_C_string()); |
2223 |
const int src_length = (int)strlen(src); |
|
21183
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2224 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2225 |
char* dest = NEW_RESOURCE_ARRAY(char, src_length + hash_len + 3); |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2226 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2227 |
// Add L as type indicator |
1 | 2228 |
int dest_index = 0; |
2229 |
dest[dest_index++] = 'L'; |
|
21183
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2230 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2231 |
// Add the actual class name |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2232 |
for (int src_index = 0; src_index < src_length; ) { |
1 | 2233 |
dest[dest_index++] = src[src_index++]; |
2234 |
} |
|
21183
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2235 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2236 |
// If we have a hash, append it |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2237 |
for (int hash_index = 0; hash_index < hash_len; ) { |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2238 |
dest[dest_index++] = hash_buf[hash_index++]; |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2239 |
} |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2240 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2241 |
// Add the semicolon and the NULL |
1 | 2242 |
dest[dest_index++] = ';'; |
2243 |
dest[dest_index] = '\0'; |
|
2244 |
return dest; |
|
2245 |
} |
|
2246 |
||
2247 |
// different verisons of is_same_class_package |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2248 |
bool InstanceKlass::is_same_class_package(Klass* class2) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2249 |
Klass* class1 = this; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2250 |
oop classloader1 = InstanceKlass::cast(class1)->class_loader(); |
14488 | 2251 |
Symbol* classname1 = class1->name(); |
2252 |
||
2253 |
if (class2->oop_is_objArray()) { |
|
13952
e3cf184080bc
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
13738
diff
changeset
|
2254 |
class2 = ObjArrayKlass::cast(class2)->bottom_klass(); |
1 | 2255 |
} |
2256 |
oop classloader2; |
|
14488 | 2257 |
if (class2->oop_is_instance()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2258 |
classloader2 = InstanceKlass::cast(class2)->class_loader(); |
1 | 2259 |
} else { |
14488 | 2260 |
assert(class2->oop_is_typeArray(), "should be type array"); |
1 | 2261 |
classloader2 = NULL; |
2262 |
} |
|
14488 | 2263 |
Symbol* classname2 = class2->name(); |
1 | 2264 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2265 |
return InstanceKlass::is_same_class_package(classloader1, classname1, |
1 | 2266 |
classloader2, classname2); |
2267 |
} |
|
2268 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2269 |
bool InstanceKlass::is_same_class_package(oop classloader2, Symbol* classname2) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2270 |
Klass* class1 = this; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2271 |
oop classloader1 = InstanceKlass::cast(class1)->class_loader(); |
14488 | 2272 |
Symbol* classname1 = class1->name(); |
1 | 2273 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2274 |
return InstanceKlass::is_same_class_package(classloader1, classname1, |
1 | 2275 |
classloader2, classname2); |
2276 |
} |
|
2277 |
||
2278 |
// return true if two classes are in the same package, classloader |
|
2279 |
// and classname information is enough to determine a class's package |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2280 |
bool InstanceKlass::is_same_class_package(oop class_loader1, Symbol* class_name1, |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2281 |
oop class_loader2, Symbol* class_name2) { |
1 | 2282 |
if (class_loader1 != class_loader2) { |
2283 |
return false; |
|
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2284 |
} else if (class_name1 == class_name2) { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2285 |
return true; // skip painful bytewise comparison |
1 | 2286 |
} else { |
2287 |
ResourceMark rm; |
|
2288 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2289 |
// The Symbol*'s are in UTF8 encoding. Since we only need to check explicitly |
1 | 2290 |
// for ASCII characters ('/', 'L', '['), we can keep them in UTF8 encoding. |
2291 |
// Otherwise, we just compare jbyte values between the strings. |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2292 |
const jbyte *name1 = class_name1->base(); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2293 |
const jbyte *name2 = class_name2->base(); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2294 |
|
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2295 |
const jbyte *last_slash1 = UTF8::strrchr(name1, class_name1->utf8_length(), '/'); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2296 |
const jbyte *last_slash2 = UTF8::strrchr(name2, class_name2->utf8_length(), '/'); |
1 | 2297 |
|
2298 |
if ((last_slash1 == NULL) || (last_slash2 == NULL)) { |
|
2299 |
// One of the two doesn't have a package. Only return true |
|
2300 |
// if the other one also doesn't have a package. |
|
2301 |
return last_slash1 == last_slash2; |
|
2302 |
} else { |
|
2303 |
// Skip over '['s |
|
2304 |
if (*name1 == '[') { |
|
2305 |
do { |
|
2306 |
name1++; |
|
2307 |
} while (*name1 == '['); |
|
2308 |
if (*name1 != 'L') { |
|
2309 |
// Something is terribly wrong. Shouldn't be here. |
|
2310 |
return false; |
|
2311 |
} |
|
2312 |
} |
|
2313 |
if (*name2 == '[') { |
|
2314 |
do { |
|
2315 |
name2++; |
|
2316 |
} while (*name2 == '['); |
|
2317 |
if (*name2 != 'L') { |
|
2318 |
// Something is terribly wrong. Shouldn't be here. |
|
2319 |
return false; |
|
2320 |
} |
|
2321 |
} |
|
2322 |
||
2323 |
// Check that package part is identical |
|
2324 |
int length1 = last_slash1 - name1; |
|
2325 |
int length2 = last_slash2 - name2; |
|
2326 |
||
2327 |
return UTF8::equal(name1, length1, name2, length2); |
|
2328 |
} |
|
2329 |
} |
|
2330 |
} |
|
2331 |
||
2264
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2332 |
// Returns true iff super_method can be overridden by a method in targetclassname |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2333 |
// See JSL 3rd edition 8.4.6.1 |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2334 |
// Assumes name-signature match |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2335 |
// "this" is InstanceKlass of super_method which must exist |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2336 |
// note that the InstanceKlass of the method in the targetclassname has not always been created yet |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2337 |
bool InstanceKlass::is_override(methodHandle super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS) { |
2264
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2338 |
// Private methods can not be overridden |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2339 |
if (super_method->is_private()) { |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2340 |
return false; |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2341 |
} |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2342 |
// If super method is accessible, then override |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2343 |
if ((super_method->is_protected()) || |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2344 |
(super_method->is_public())) { |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2345 |
return true; |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2346 |
} |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2347 |
// Package-private methods are not inherited outside of package |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2348 |
assert(super_method->is_package_private(), "must be package private"); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2349 |
return(is_same_class_package(targetclassloader(), targetclassname)); |
2264
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2350 |
} |
1 | 2351 |
|
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2352 |
/* defined for now in jvm.cpp, for historical reasons *-- |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2353 |
Klass* InstanceKlass::compute_enclosing_class_impl(instanceKlassHandle self, |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2354 |
Symbol*& simple_name_result, TRAPS) { |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2355 |
... |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2356 |
} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2357 |
*/ |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2358 |
|
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2359 |
// tell if two classes have the same enclosing class (at package level) |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2360 |
bool InstanceKlass::is_same_package_member_impl(instanceKlassHandle class1, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2361 |
Klass* class2_oop, TRAPS) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2362 |
if (class2_oop == class1()) return true; |
14488 | 2363 |
if (!class2_oop->oop_is_instance()) return false; |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2364 |
instanceKlassHandle class2(THREAD, class2_oop); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2365 |
|
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2366 |
// must be in same package before we try anything else |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2367 |
if (!class1->is_same_class_package(class2->class_loader(), class2->name())) |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2368 |
return false; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2369 |
|
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2370 |
// As long as there is an outer1.getEnclosingClass, |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2371 |
// shift the search outward. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2372 |
instanceKlassHandle outer1 = class1; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2373 |
for (;;) { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2374 |
// As we walk along, look for equalities between outer1 and class2. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2375 |
// Eventually, the walks will terminate as outer1 stops |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2376 |
// at the top-level class around the original class. |
4496
c5a0b15a8e7d
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
4094
diff
changeset
|
2377 |
bool ignore_inner_is_member; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2378 |
Klass* next = outer1->compute_enclosing_class(&ignore_inner_is_member, |
4496
c5a0b15a8e7d
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
4094
diff
changeset
|
2379 |
CHECK_false); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2380 |
if (next == NULL) break; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2381 |
if (next == class2()) return true; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2382 |
outer1 = instanceKlassHandle(THREAD, next); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2383 |
} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2384 |
|
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2385 |
// Now do the same for class2. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2386 |
instanceKlassHandle outer2 = class2; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2387 |
for (;;) { |
4496
c5a0b15a8e7d
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
4094
diff
changeset
|
2388 |
bool ignore_inner_is_member; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2389 |
Klass* next = outer2->compute_enclosing_class(&ignore_inner_is_member, |
4496
c5a0b15a8e7d
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
4094
diff
changeset
|
2390 |
CHECK_false); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2391 |
if (next == NULL) break; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2392 |
// Might as well check the new outer against all available values. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2393 |
if (next == class1()) return true; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2394 |
if (next == outer1()) return true; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2395 |
outer2 = instanceKlassHandle(THREAD, next); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2396 |
} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2397 |
|
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2398 |
// If by this point we have not found an equality between the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2399 |
// two classes, we know they are in separate package members. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2400 |
return false; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2401 |
} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2402 |
|
30222
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2403 |
bool InstanceKlass::find_inner_classes_attr(instanceKlassHandle k, int* ooff, int* noff, TRAPS) { |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2404 |
constantPoolHandle i_cp(THREAD, k->constants()); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2405 |
for (InnerClassesIterator iter(k); !iter.done(); iter.next()) { |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2406 |
int ioff = iter.inner_class_info_index(); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2407 |
if (ioff != 0) { |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2408 |
// Check to see if the name matches the class we're looking for |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2409 |
// before attempting to find the class. |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2410 |
if (i_cp->klass_name_at_matches(k, ioff)) { |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2411 |
Klass* inner_klass = i_cp->klass_at(ioff, CHECK_false); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2412 |
if (k() == inner_klass) { |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2413 |
*ooff = iter.outer_class_info_index(); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2414 |
*noff = iter.inner_name_index(); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2415 |
return true; |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2416 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2417 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2418 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2419 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2420 |
return false; |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2421 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2422 |
|
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2423 |
Klass* InstanceKlass::compute_enclosing_class_impl(instanceKlassHandle k, bool* inner_is_member, TRAPS) { |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2424 |
instanceKlassHandle outer_klass; |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2425 |
*inner_is_member = false; |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2426 |
int ooff = 0, noff = 0; |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2427 |
if (find_inner_classes_attr(k, &ooff, &noff, THREAD)) { |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2428 |
constantPoolHandle i_cp(THREAD, k->constants()); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2429 |
if (ooff != 0) { |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2430 |
Klass* ok = i_cp->klass_at(ooff, CHECK_NULL); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2431 |
outer_klass = instanceKlassHandle(THREAD, ok); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2432 |
*inner_is_member = true; |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2433 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2434 |
if (outer_klass.is_null()) { |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2435 |
// It may be anonymous; try for that. |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2436 |
int encl_method_class_idx = k->enclosing_method_class_index(); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2437 |
if (encl_method_class_idx != 0) { |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2438 |
Klass* ok = i_cp->klass_at(encl_method_class_idx, CHECK_NULL); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2439 |
outer_klass = instanceKlassHandle(THREAD, ok); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2440 |
*inner_is_member = false; |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2441 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2442 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2443 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2444 |
|
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2445 |
// If no inner class attribute found for this class. |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2446 |
if (outer_klass.is_null()) return NULL; |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2447 |
|
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2448 |
// Throws an exception if outer klass has not declared k as an inner klass |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2449 |
// We need evidence that each klass knows about the other, or else |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2450 |
// the system could allow a spoof of an inner class to gain access rights. |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2451 |
Reflection::check_for_inner_class(outer_klass, k, *inner_is_member, CHECK_NULL); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2452 |
return outer_klass(); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2453 |
} |
1 | 2454 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2455 |
jint InstanceKlass::compute_modifier_flags(TRAPS) const { |
1 | 2456 |
jint access = access_flags().as_int(); |
2457 |
||
2458 |
// But check if it happens to be member class. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2459 |
instanceKlassHandle ik(THREAD, this); |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2460 |
InnerClassesIterator iter(ik); |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2461 |
for (; !iter.done(); iter.next()) { |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2462 |
int ioff = iter.inner_class_info_index(); |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2463 |
// Inner class attribute can be zero, skip it. |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2464 |
// Strange but true: JVM spec. allows null inner class refs. |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2465 |
if (ioff == 0) continue; |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2466 |
|
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2467 |
// only look at classes that are already loaded |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2468 |
// since we are looking for the flags for our self. |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2469 |
Symbol* inner_name = ik->constants()->klass_name_at(ioff); |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2470 |
if ((ik->name() == inner_name)) { |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2471 |
// This is really a member class. |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2472 |
access = iter.inner_access_flags(); |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2473 |
break; |
1 | 2474 |
} |
2475 |
} |
|
2476 |
// Remember to strip ACC_SUPER bit |
|
2477 |
return (access & (~JVM_ACC_SUPER)) & JVM_ACC_WRITTEN_FLAGS; |
|
2478 |
} |
|
2479 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2480 |
jint InstanceKlass::jvmti_class_status() const { |
1 | 2481 |
jint result = 0; |
2482 |
||
2483 |
if (is_linked()) { |
|
2484 |
result |= JVMTI_CLASS_STATUS_VERIFIED | JVMTI_CLASS_STATUS_PREPARED; |
|
2485 |
} |
|
2486 |
||
2487 |
if (is_initialized()) { |
|
2488 |
assert(is_linked(), "Class status is not consistent"); |
|
2489 |
result |= JVMTI_CLASS_STATUS_INITIALIZED; |
|
2490 |
} |
|
2491 |
if (is_in_error_state()) { |
|
2492 |
result |= JVMTI_CLASS_STATUS_ERROR; |
|
2493 |
} |
|
2494 |
return result; |
|
2495 |
} |
|
2496 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2497 |
Method* InstanceKlass::method_at_itable(Klass* holder, int index, TRAPS) { |
1 | 2498 |
itableOffsetEntry* ioe = (itableOffsetEntry*)start_of_itable(); |
2499 |
int method_table_offset_in_words = ioe->offset()/wordSize; |
|
2500 |
int nof_interfaces = (method_table_offset_in_words - itable_offset_in_words()) |
|
2501 |
/ itableOffsetEntry::size(); |
|
2502 |
||
2503 |
for (int cnt = 0 ; ; cnt ++, ioe ++) { |
|
2131 | 2504 |
// If the interface isn't implemented by the receiver class, |
1 | 2505 |
// the VM should throw IncompatibleClassChangeError. |
2506 |
if (cnt >= nof_interfaces) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2507 |
THROW_NULL(vmSymbols::java_lang_IncompatibleClassChangeError()); |
1 | 2508 |
} |
2509 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2510 |
Klass* ik = ioe->interface_klass(); |
1 | 2511 |
if (ik == holder) break; |
2512 |
} |
|
2513 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2514 |
itableMethodEntry* ime = ioe->first_method_entry(this); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2515 |
Method* m = ime[index].method(); |
1 | 2516 |
if (m == NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2517 |
THROW_NULL(vmSymbols::java_lang_AbstractMethodError()); |
1 | 2518 |
} |
2519 |
return m; |
|
2520 |
} |
|
2521 |
||
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2522 |
|
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2523 |
#if INCLUDE_JVMTI |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2524 |
// update default_methods for redefineclasses for methods that are |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2525 |
// not yet in the vtable due to concurrent subclass define and superinterface |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2526 |
// redefinition |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2527 |
// Note: those in the vtable, should have been updated via adjust_method_entries |
29316
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2528 |
void InstanceKlass::adjust_default_methods(InstanceKlass* holder, bool* trace_name_printed) { |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2529 |
// search the default_methods for uses of either obsolete or EMCP methods |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2530 |
if (default_methods() != NULL) { |
29316
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2531 |
for (int index = 0; index < default_methods()->length(); index ++) { |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2532 |
Method* old_method = default_methods()->at(index); |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2533 |
if (old_method == NULL || old_method->method_holder() != holder || !old_method->is_old()) { |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2534 |
continue; // skip uninteresting entries |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2535 |
} |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2536 |
assert(!old_method->is_deleted(), "default methods may not be deleted"); |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2537 |
|
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2538 |
Method* new_method = holder->method_with_idnum(old_method->orig_method_idnum()); |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2539 |
|
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2540 |
assert(new_method != NULL, "method_with_idnum() should not be NULL"); |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2541 |
assert(old_method != new_method, "sanity check"); |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2542 |
|
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2543 |
default_methods()->at_put(index, new_method); |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2544 |
if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) { |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2545 |
if (!(*trace_name_printed)) { |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2546 |
// RC_TRACE_MESG macro has an embedded ResourceMark |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2547 |
RC_TRACE_MESG(("adjust: klassname=%s default methods from name=%s", |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2548 |
external_name(), |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2549 |
old_method->method_holder()->external_name())); |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2550 |
*trace_name_printed = true; |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2551 |
} |
29316
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2552 |
RC_TRACE(0x00100000, ("default method update: %s(%s) ", |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2553 |
new_method->name()->as_C_string(), |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2554 |
new_method->signature()->as_C_string())); |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2555 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2556 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2557 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2558 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2559 |
#endif // INCLUDE_JVMTI |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2560 |
|
1 | 2561 |
// On-stack replacement stuff |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2562 |
void InstanceKlass::add_osr_nmethod(nmethod* n) { |
1 | 2563 |
// only one compilation can be active |
27409
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2564 |
{ |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2565 |
// This is a short non-blocking critical region, so the no safepoint check is ok. |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2566 |
MutexLockerEx ml(OsrList_lock, Mutex::_no_safepoint_check_flag); |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2567 |
assert(n->is_osr_method(), "wrong kind of nmethod"); |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2568 |
n->set_osr_link(osr_nmethods_head()); |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2569 |
set_osr_nmethods_head(n); |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2570 |
// Raise the highest osr level if necessary |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2571 |
if (TieredCompilation) { |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2572 |
Method* m = n->method(); |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2573 |
m->set_highest_osr_comp_level(MAX2(m->highest_osr_comp_level(), n->comp_level())); |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2574 |
} |
6453 | 2575 |
} |
2576 |
||
2577 |
// Get rid of the osr methods for the same bci that have lower levels. |
|
2578 |
if (TieredCompilation) { |
|
2579 |
for (int l = CompLevel_limited_profile; l < n->comp_level(); l++) { |
|
2580 |
nmethod *inv = lookup_osr_nmethod(n->method(), n->osr_entry_bci(), l, true); |
|
2581 |
if (inv != NULL && inv->is_in_use()) { |
|
2582 |
inv->make_not_entrant(); |
|
2583 |
} |
|
2584 |
} |
|
2585 |
} |
|
1 | 2586 |
} |
2587 |
||
2588 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2589 |
void InstanceKlass::remove_osr_nmethod(nmethod* n) { |
1 | 2590 |
// This is a short non-blocking critical region, so the no safepoint check is ok. |
27409
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2591 |
MutexLockerEx ml(OsrList_lock, Mutex::_no_safepoint_check_flag); |
1 | 2592 |
assert(n->is_osr_method(), "wrong kind of nmethod"); |
2593 |
nmethod* last = NULL; |
|
2594 |
nmethod* cur = osr_nmethods_head(); |
|
6453 | 2595 |
int max_level = CompLevel_none; // Find the max comp level excluding n |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2596 |
Method* m = n->method(); |
1 | 2597 |
// Search for match |
2598 |
while(cur != NULL && cur != n) { |
|
22920
dd3a135fca38
8034188: OSR methods may not be recompiled at proper compilation level
neliasso
parents:
22916
diff
changeset
|
2599 |
if (TieredCompilation && m == cur->method()) { |
6453 | 2600 |
// Find max level before n |
2601 |
max_level = MAX2(max_level, cur->comp_level()); |
|
2602 |
} |
|
1 | 2603 |
last = cur; |
3908
24b55ad4c228
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
3576
diff
changeset
|
2604 |
cur = cur->osr_link(); |
1 | 2605 |
} |
6453 | 2606 |
nmethod* next = NULL; |
1 | 2607 |
if (cur == n) { |
6453 | 2608 |
next = cur->osr_link(); |
1 | 2609 |
if (last == NULL) { |
2610 |
// Remove first element |
|
6453 | 2611 |
set_osr_nmethods_head(next); |
1 | 2612 |
} else { |
6453 | 2613 |
last->set_osr_link(next); |
1 | 2614 |
} |
2615 |
} |
|
3908
24b55ad4c228
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
3576
diff
changeset
|
2616 |
n->set_osr_link(NULL); |
6453 | 2617 |
if (TieredCompilation) { |
2618 |
cur = next; |
|
2619 |
while (cur != NULL) { |
|
2620 |
// Find max level after n |
|
22920
dd3a135fca38
8034188: OSR methods may not be recompiled at proper compilation level
neliasso
parents:
22916
diff
changeset
|
2621 |
if (m == cur->method()) { |
dd3a135fca38
8034188: OSR methods may not be recompiled at proper compilation level
neliasso
parents:
22916
diff
changeset
|
2622 |
max_level = MAX2(max_level, cur->comp_level()); |
dd3a135fca38
8034188: OSR methods may not be recompiled at proper compilation level
neliasso
parents:
22916
diff
changeset
|
2623 |
} |
6453 | 2624 |
cur = cur->osr_link(); |
2625 |
} |
|
2626 |
m->set_highest_osr_comp_level(max_level); |
|
2627 |
} |
|
1 | 2628 |
} |
2629 |
||
27434
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2630 |
int InstanceKlass::mark_osr_nmethods(const Method* m) { |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2631 |
// This is a short non-blocking critical region, so the no safepoint check is ok. |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2632 |
MutexLockerEx ml(OsrList_lock, Mutex::_no_safepoint_check_flag); |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2633 |
nmethod* osr = osr_nmethods_head(); |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2634 |
int found = 0; |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2635 |
while (osr != NULL) { |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2636 |
assert(osr->is_osr_method(), "wrong kind of nmethod found in chain"); |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2637 |
if (osr->method() == m) { |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2638 |
osr->mark_for_deoptimization(); |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2639 |
found++; |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2640 |
} |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2641 |
osr = osr->osr_link(); |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2642 |
} |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2643 |
return found; |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2644 |
} |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2645 |
|
17370
59a0620561fa
8003557: NPG: Klass* const k should be const Klass* k.
minqi
parents:
17078
diff
changeset
|
2646 |
nmethod* InstanceKlass::lookup_osr_nmethod(const Method* m, int bci, int comp_level, bool match_level) const { |
1 | 2647 |
// This is a short non-blocking critical region, so the no safepoint check is ok. |
27409
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2648 |
MutexLockerEx ml(OsrList_lock, Mutex::_no_safepoint_check_flag); |
1 | 2649 |
nmethod* osr = osr_nmethods_head(); |
6453 | 2650 |
nmethod* best = NULL; |
1 | 2651 |
while (osr != NULL) { |
2652 |
assert(osr->is_osr_method(), "wrong kind of nmethod found in chain"); |
|
6453 | 2653 |
// There can be a time when a c1 osr method exists but we are waiting |
2654 |
// for a c2 version. When c2 completes its osr nmethod we will trash |
|
2655 |
// the c1 version and only be able to find the c2 version. However |
|
2656 |
// while we overflow in the c1 code at back branches we don't want to |
|
2657 |
// try and switch to the same code as we are already running |
|
2658 |
||
1 | 2659 |
if (osr->method() == m && |
2660 |
(bci == InvocationEntryBci || osr->osr_entry_bci() == bci)) { |
|
6453 | 2661 |
if (match_level) { |
2662 |
if (osr->comp_level() == comp_level) { |
|
2663 |
// Found a match - return it. |
|
2664 |
return osr; |
|
2665 |
} |
|
2666 |
} else { |
|
2667 |
if (best == NULL || (osr->comp_level() > best->comp_level())) { |
|
2668 |
if (osr->comp_level() == CompLevel_highest_tier) { |
|
2669 |
// Found the best possible - return it. |
|
2670 |
return osr; |
|
2671 |
} |
|
2672 |
best = osr; |
|
2673 |
} |
|
2674 |
} |
|
1 | 2675 |
} |
3908
24b55ad4c228
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
3576
diff
changeset
|
2676 |
osr = osr->osr_link(); |
1 | 2677 |
} |
6453 | 2678 |
if (best != NULL && best->comp_level() >= comp_level && match_level == false) { |
2679 |
return best; |
|
2680 |
} |
|
1 | 2681 |
return NULL; |
2682 |
} |
|
2683 |
||
27674
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2684 |
bool InstanceKlass::add_member_name(Handle mem_name) { |
17029
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2685 |
jweak mem_name_wref = JNIHandles::make_weak_global(mem_name); |
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2686 |
MutexLocker ml(MemberNameTable_lock); |
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2687 |
DEBUG_ONLY(No_Safepoint_Verifier nsv); |
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2688 |
|
27674
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2689 |
// Check if method has been redefined while taking out MemberNameTable_lock, if so |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2690 |
// return false. We cannot cache obsolete methods. They will crash when the function |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2691 |
// is called! |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2692 |
Method* method = (Method*)java_lang_invoke_MemberName::vmtarget(mem_name()); |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2693 |
if (method->is_obsolete()) { |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2694 |
return false; |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2695 |
} else if (method->is_old()) { |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2696 |
// Replace method with redefined version |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2697 |
java_lang_invoke_MemberName::set_vmtarget(mem_name(), method_with_idnum(method->method_idnum())); |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2698 |
} |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2699 |
|
17029
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2700 |
if (_member_names == NULL) { |
17828
17131ab4b3b5
8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes
sspitsyn
parents:
17826
diff
changeset
|
2701 |
_member_names = new (ResourceObj::C_HEAP, mtClass) MemberNameTable(idnum_allocated_count()); |
17029
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2702 |
} |
27674
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2703 |
_member_names->add_member_name(mem_name_wref); |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2704 |
return true; |
17029
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2705 |
} |
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2706 |
|
1 | 2707 |
// ----------------------------------------------------------------------------------------------------- |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2708 |
// Printing |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2709 |
|
1 | 2710 |
#ifndef PRODUCT |
2711 |
||
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2712 |
#define BULLET " - " |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2713 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2714 |
static const char* state_names[] = { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2715 |
"allocated", "loaded", "linked", "being_initialized", "fully_initialized", "initialization_error" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2716 |
}; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2717 |
|
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2718 |
static void print_vtable(intptr_t* start, int len, outputStream* st) { |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2719 |
for (int i = 0; i < len; i++) { |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2720 |
intptr_t e = start[i]; |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2721 |
st->print("%d : " INTPTR_FORMAT, i, e); |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2722 |
if (e != 0 && ((Metadata*)e)->is_metaspace_object()) { |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2723 |
st->print(" "); |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2724 |
((Metadata*)e)->print_value_on(st); |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2725 |
} |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2726 |
st->cr(); |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2727 |
} |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2728 |
} |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2729 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2730 |
void InstanceKlass::print_on(outputStream* st) const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2731 |
assert(is_klass(), "must be klass"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2732 |
Klass::print_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2733 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2734 |
st->print(BULLET"instance size: %d", size_helper()); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2735 |
st->print(BULLET"klass size: %d", size()); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2736 |
st->print(BULLET"access: "); access_flags().print_on(st); st->cr(); |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
24351
diff
changeset
|
2737 |
st->print(BULLET"state: "); st->print_cr("%s", state_names[_init_state]); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2738 |
st->print(BULLET"name: "); name()->print_value_on(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2739 |
st->print(BULLET"super: "); super()->print_value_on_maybe_null(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2740 |
st->print(BULLET"sub: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2741 |
Klass* sub = subklass(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2742 |
int n; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2743 |
for (n = 0; sub != NULL; n++, sub = sub->next_sibling()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2744 |
if (n < MaxSubklassPrintSize) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2745 |
sub->print_value_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2746 |
st->print(" "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2747 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2748 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2749 |
if (n >= MaxSubklassPrintSize) st->print("(%d more klasses...)", n - MaxSubklassPrintSize); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2750 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2751 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2752 |
if (is_interface()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2753 |
st->print_cr(BULLET"nof implementors: %d", nof_implementors()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2754 |
if (nof_implementors() == 1) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2755 |
st->print_cr(BULLET"implementor: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2756 |
st->print(" "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2757 |
implementor()->print_value_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2758 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2759 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2760 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2761 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2762 |
st->print(BULLET"arrays: "); array_klasses()->print_value_on_maybe_null(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2763 |
st->print(BULLET"methods: "); methods()->print_value_on(st); st->cr(); |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2764 |
if (Verbose || WizardMode) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2765 |
Array<Method*>* method_array = methods(); |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2766 |
for (int i = 0; i < method_array->length(); i++) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2767 |
st->print("%d : ", i); method_array->at(i)->print_value(); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2768 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2769 |
} |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2770 |
st->print(BULLET"method ordering: "); method_ordering()->print_value_on(st); st->cr(); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2771 |
st->print(BULLET"default_methods: "); default_methods()->print_value_on(st); st->cr(); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2772 |
if (Verbose && default_methods() != NULL) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2773 |
Array<Method*>* method_array = default_methods(); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2774 |
for (int i = 0; i < method_array->length(); i++) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2775 |
st->print("%d : ", i); method_array->at(i)->print_value(); st->cr(); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2776 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2777 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2778 |
if (default_vtable_indices() != NULL) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2779 |
st->print(BULLET"default vtable indices: "); default_vtable_indices()->print_value_on(st); st->cr(); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2780 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2781 |
st->print(BULLET"local interfaces: "); local_interfaces()->print_value_on(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2782 |
st->print(BULLET"trans. interfaces: "); transitive_interfaces()->print_value_on(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2783 |
st->print(BULLET"constants: "); constants()->print_value_on(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2784 |
if (class_loader_data() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2785 |
st->print(BULLET"class loader data: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2786 |
class_loader_data()->print_value_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2787 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2788 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2789 |
st->print(BULLET"host class: "); host_klass()->print_value_on_maybe_null(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2790 |
if (source_file_name() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2791 |
st->print(BULLET"source file: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2792 |
source_file_name()->print_value_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2793 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2794 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2795 |
if (source_debug_extension() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2796 |
st->print(BULLET"source debug extension: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2797 |
st->print("%s", source_debug_extension()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2798 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2799 |
} |
15601 | 2800 |
st->print(BULLET"class annotations: "); class_annotations()->print_value_on(st); st->cr(); |
2801 |
st->print(BULLET"class type annotations: "); class_type_annotations()->print_value_on(st); st->cr(); |
|
2802 |
st->print(BULLET"field annotations: "); fields_annotations()->print_value_on(st); st->cr(); |
|
2803 |
st->print(BULLET"field type annotations: "); fields_type_annotations()->print_value_on(st); st->cr(); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2804 |
{ |
20059
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
2805 |
bool have_pv = false; |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
2806 |
// previous versions are linked together through the InstanceKlass |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
2807 |
for (InstanceKlass* pv_node = _previous_versions; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
2808 |
pv_node != NULL; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
2809 |
pv_node = pv_node->previous_versions()) { |
20059
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
2810 |
if (!have_pv) |
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
2811 |
st->print(BULLET"previous version: "); |
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
2812 |
have_pv = true; |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
2813 |
pv_node->constants()->print_value_on(st); |
20059
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
2814 |
} |
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
2815 |
if (have_pv) st->cr(); |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
2816 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2817 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2818 |
if (generic_signature() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2819 |
st->print(BULLET"generic signature: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2820 |
generic_signature()->print_value_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2821 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2822 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2823 |
st->print(BULLET"inner classes: "); inner_classes()->print_value_on(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2824 |
st->print(BULLET"java mirror: "); java_mirror()->print_value_on(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2825 |
st->print(BULLET"vtable length %d (start addr: " INTPTR_FORMAT ")", vtable_length(), start_of_vtable()); st->cr(); |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2826 |
if (vtable_length() > 0 && (Verbose || WizardMode)) print_vtable(start_of_vtable(), vtable_length(), st); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2827 |
st->print(BULLET"itable length %d (start addr: " INTPTR_FORMAT ")", itable_length(), start_of_itable()); st->cr(); |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2828 |
if (itable_length() > 0 && (Verbose || WizardMode)) print_vtable(start_of_itable(), itable_length(), st); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2829 |
st->print_cr(BULLET"---- static fields (%d words):", static_field_size()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2830 |
FieldPrinter print_static_field(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2831 |
((InstanceKlass*)this)->do_local_static_fields(&print_static_field); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2832 |
st->print_cr(BULLET"---- non-static fields (%d words):", nonstatic_field_size()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2833 |
FieldPrinter print_nonstatic_field(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2834 |
((InstanceKlass*)this)->do_nonstatic_fields(&print_nonstatic_field); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2835 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2836 |
st->print(BULLET"non-static oop maps: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2837 |
OopMapBlock* map = start_of_nonstatic_oop_maps(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2838 |
OopMapBlock* end_map = map + nonstatic_oop_map_count(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2839 |
while (map < end_map) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2840 |
st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->count() - 1)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2841 |
map++; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2842 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2843 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2844 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2845 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2846 |
#endif //PRODUCT |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2847 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2848 |
void InstanceKlass::print_value_on(outputStream* st) const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2849 |
assert(is_klass(), "must be klass"); |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2850 |
if (Verbose || WizardMode) access_flags().print_on(st); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2851 |
name()->print_value_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2852 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2853 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2854 |
#ifndef PRODUCT |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2855 |
|
1 | 2856 |
void FieldPrinter::do_field(fieldDescriptor* fd) { |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2857 |
_st->print(BULLET); |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2858 |
if (_obj == NULL) { |
1 | 2859 |
fd->print_on(_st); |
2860 |
_st->cr(); |
|
2861 |
} else { |
|
2862 |
fd->print_on_for(_st, _obj); |
|
2863 |
_st->cr(); |
|
2864 |
} |
|
2865 |
} |
|
2866 |
||
2867 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2868 |
void InstanceKlass::oop_print_on(oop obj, outputStream* st) { |
1 | 2869 |
Klass::oop_print_on(obj, st); |
2870 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2871 |
if (this == SystemDictionary::String_klass()) { |
1 | 2872 |
typeArrayOop value = java_lang_String::value(obj); |
2873 |
juint offset = java_lang_String::offset(obj); |
|
2874 |
juint length = java_lang_String::length(obj); |
|
2875 |
if (value != NULL && |
|
2876 |
value->is_typeArray() && |
|
2877 |
offset <= (juint) value->length() && |
|
2878 |
offset + length <= (juint) value->length()) { |
|
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2879 |
st->print(BULLET"string: "); |
22907
f978a4a64728
8035648: Don't use Handle in java_lang_String::print
stefank
parents:
22881
diff
changeset
|
2880 |
java_lang_String::print(obj, st); |
1 | 2881 |
st->cr(); |
2882 |
if (!WizardMode) return; // that is enough |
|
2883 |
} |
|
2884 |
} |
|
2885 |
||
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2886 |
st->print_cr(BULLET"---- fields (total size %d words):", oop_size(obj)); |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2887 |
FieldPrinter print_field(st, obj); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2888 |
do_nonstatic_fields(&print_field); |
1 | 2889 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2890 |
if (this == SystemDictionary::Class_klass()) { |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2891 |
st->print(BULLET"signature: "); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2892 |
java_lang_Class::print_signature(obj, st); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2893 |
st->cr(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2894 |
Klass* mirrored_klass = java_lang_Class::as_Klass(obj); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2895 |
st->print(BULLET"fake entry for mirror: "); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2896 |
mirrored_klass->print_value_on_maybe_null(st); |
1 | 2897 |
st->cr(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2898 |
Klass* array_klass = java_lang_Class::array_klass(obj); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2899 |
st->print(BULLET"fake entry for array: "); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2900 |
array_klass->print_value_on_maybe_null(st); |
1 | 2901 |
st->cr(); |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2902 |
st->print_cr(BULLET"fake entry for oop_size: %d", java_lang_Class::oop_size(obj)); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2903 |
st->print_cr(BULLET"fake entry for static_oop_field_count: %d", java_lang_Class::static_oop_field_count(obj)); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2904 |
Klass* real_klass = java_lang_Class::as_Klass(obj); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2905 |
if (real_klass != NULL && real_klass->oop_is_instance()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2906 |
InstanceKlass::cast(real_klass)->do_local_static_fields(&print_field); |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2907 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2908 |
} else if (this == SystemDictionary::MethodType_klass()) { |
4094
1f424b2b2171
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
3916
diff
changeset
|
2909 |
st->print(BULLET"signature: "); |
8676
9098d4e927e1
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
8653
diff
changeset
|
2910 |
java_lang_invoke_MethodType::print_signature(obj, st); |
4094
1f424b2b2171
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
3916
diff
changeset
|
2911 |
st->cr(); |
1 | 2912 |
} |
2913 |
} |
|
2914 |
||
4584
e2a449e8cc6f
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
4573
diff
changeset
|
2915 |
#endif //PRODUCT |
e2a449e8cc6f
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
4573
diff
changeset
|
2916 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2917 |
void InstanceKlass::oop_print_value_on(oop obj, outputStream* st) { |
1 | 2918 |
st->print("a "); |
2919 |
name()->print_value_on(st); |
|
2920 |
obj->print_address_on(st); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2921 |
if (this == SystemDictionary::String_klass() |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2922 |
&& java_lang_String::value(obj) != NULL) { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2923 |
ResourceMark rm; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2924 |
int len = java_lang_String::length(obj); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2925 |
int plen = (len < 24 ? len : 12); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2926 |
char* str = java_lang_String::as_utf8_string(obj, 0, plen); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2927 |
st->print(" = \"%s\"", str); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2928 |
if (len > plen) |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2929 |
st->print("...[%d]", len); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2930 |
} else if (this == SystemDictionary::Class_klass()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2931 |
Klass* k = java_lang_Class::as_Klass(obj); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2932 |
st->print(" = "); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2933 |
if (k != NULL) { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2934 |
k->print_value_on(st); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2935 |
} else { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2936 |
const char* tname = type2name(java_lang_Class::primitive_type(obj)); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2937 |
st->print("%s", tname ? tname : "type?"); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2938 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2939 |
} else if (this == SystemDictionary::MethodType_klass()) { |
4094
1f424b2b2171
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
3916
diff
changeset
|
2940 |
st->print(" = "); |
8676
9098d4e927e1
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
8653
diff
changeset
|
2941 |
java_lang_invoke_MethodType::print_signature(obj, st); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2942 |
} else if (java_lang_boxing_object::is_instance(obj)) { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2943 |
st->print(" = "); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2944 |
java_lang_boxing_object::print(obj, st); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2945 |
} else if (this == SystemDictionary::LambdaForm_klass()) { |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
2946 |
oop vmentry = java_lang_invoke_LambdaForm::vmentry(obj); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
2947 |
if (vmentry != NULL) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
2948 |
st->print(" => "); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
2949 |
vmentry->print_value_on(st); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
2950 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2951 |
} else if (this == SystemDictionary::MemberName_klass()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2952 |
Metadata* vmtarget = java_lang_invoke_MemberName::vmtarget(obj); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
2953 |
if (vmtarget != NULL) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
2954 |
st->print(" = "); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
2955 |
vmtarget->print_value_on(st); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
2956 |
} else { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
2957 |
java_lang_invoke_MemberName::clazz(obj)->print_value_on(st); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
2958 |
st->print("."); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
2959 |
java_lang_invoke_MemberName::name(obj)->print_value_on(st); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
2960 |
} |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2961 |
} |
1 | 2962 |
} |
2963 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2964 |
const char* InstanceKlass::internal_name() const { |
1 | 2965 |
return external_name(); |
2966 |
} |
|
2967 |
||
15437 | 2968 |
#if INCLUDE_SERVICES |
2969 |
// Size Statistics |
|
2970 |
void InstanceKlass::collect_statistics(KlassSizeStats *sz) const { |
|
2971 |
Klass::collect_statistics(sz); |
|
2972 |
||
2973 |
sz->_inst_size = HeapWordSize * size_helper(); |
|
2974 |
sz->_vtab_bytes = HeapWordSize * align_object_offset(vtable_length()); |
|
2975 |
sz->_itab_bytes = HeapWordSize * align_object_offset(itable_length()); |
|
2976 |
sz->_nonstatic_oopmap_bytes = HeapWordSize * |
|
2977 |
((is_interface() || is_anonymous()) ? |
|
2978 |
align_object_offset(nonstatic_oop_map_size()) : |
|
2979 |
nonstatic_oop_map_size()); |
|
2980 |
||
2981 |
int n = 0; |
|
2982 |
n += (sz->_methods_array_bytes = sz->count_array(methods())); |
|
2983 |
n += (sz->_method_ordering_bytes = sz->count_array(method_ordering())); |
|
2984 |
n += (sz->_local_interfaces_bytes = sz->count_array(local_interfaces())); |
|
2985 |
n += (sz->_transitive_interfaces_bytes = sz->count_array(transitive_interfaces())); |
|
2986 |
n += (sz->_fields_bytes = sz->count_array(fields())); |
|
2987 |
n += (sz->_inner_classes_bytes = sz->count_array(inner_classes())); |
|
2988 |
sz->_ro_bytes += n; |
|
2989 |
||
2990 |
const ConstantPool* cp = constants(); |
|
2991 |
if (cp) { |
|
2992 |
cp->collect_statistics(sz); |
|
2993 |
} |
|
2994 |
||
2995 |
const Annotations* anno = annotations(); |
|
2996 |
if (anno) { |
|
2997 |
anno->collect_statistics(sz); |
|
2998 |
} |
|
2999 |
||
3000 |
const Array<Method*>* methods_array = methods(); |
|
3001 |
if (methods()) { |
|
3002 |
for (int i = 0; i < methods_array->length(); i++) { |
|
3003 |
Method* method = methods_array->at(i); |
|
3004 |
if (method) { |
|
3005 |
sz->_method_count ++; |
|
3006 |
method->collect_statistics(sz); |
|
3007 |
} |
|
3008 |
} |
|
3009 |
} |
|
3010 |
} |
|
3011 |
#endif // INCLUDE_SERVICES |
|
3012 |
||
1 | 3013 |
// Verification |
3014 |
||
3015 |
class VerifyFieldClosure: public OopClosure { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3016 |
protected: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3017 |
template <class T> void do_oop_work(T* p) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3018 |
oop obj = oopDesc::load_decode_heap_oop(p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3019 |
if (!obj->is_oop_or_null()) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3020 |
tty->print_cr("Failed: " PTR_FORMAT " -> " PTR_FORMAT, p, (address)obj); |
1 | 3021 |
Universe::print(); |
3022 |
guarantee(false, "boom"); |
|
3023 |
} |
|
3024 |
} |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3025 |
public: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3026 |
virtual void do_oop(oop* p) { VerifyFieldClosure::do_oop_work(p); } |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3027 |
virtual void do_oop(narrowOop* p) { VerifyFieldClosure::do_oop_work(p); } |
1 | 3028 |
}; |
3029 |
||
22794
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
22232
diff
changeset
|
3030 |
void InstanceKlass::verify_on(outputStream* st) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3031 |
#ifndef PRODUCT |
18439 | 3032 |
// Avoid redundant verifies, this really should be in product. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3033 |
if (_verify_count == Universe::verify_count()) return; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3034 |
_verify_count = Universe::verify_count(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3035 |
#endif |
18439 | 3036 |
|
3037 |
// Verify Klass |
|
22794
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
22232
diff
changeset
|
3038 |
Klass::verify_on(st); |
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
22232
diff
changeset
|
3039 |
|
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
22232
diff
changeset
|
3040 |
// Verify that klass is present in ClassLoaderData |
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
22232
diff
changeset
|
3041 |
guarantee(class_loader_data()->contains_klass(this), |
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
22232
diff
changeset
|
3042 |
"this class isn't found in class loader data"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3043 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3044 |
// Verify vtables |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3045 |
if (is_linked()) { |
18439 | 3046 |
ResourceMark rm; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3047 |
// $$$ This used to be done only for m/s collections. Doing it |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3048 |
// always seemed a valid generalization. (DLD -- 6/00) |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3049 |
vtable()->verify(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3050 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3051 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3052 |
// Verify first subklass |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
3053 |
if (subklass() != NULL) { |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
3054 |
guarantee(subklass()->is_klass(), "should be klass"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3055 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3056 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3057 |
// Verify siblings |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3058 |
Klass* super = this->super(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3059 |
Klass* sib = next_sibling(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3060 |
if (sib != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3061 |
if (sib == this) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3062 |
fatal(err_msg("subclass points to itself " PTR_FORMAT, sib)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3063 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3064 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3065 |
guarantee(sib->is_klass(), "should be klass"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3066 |
guarantee(sib->super() == super, "siblings should have same superklass"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3067 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3068 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3069 |
// Verify implementor fields |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3070 |
Klass* im = implementor(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3071 |
if (im != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3072 |
guarantee(is_interface(), "only interfaces should have implementor set"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3073 |
guarantee(im->is_klass(), "should be klass"); |
14488 | 3074 |
guarantee(!im->is_interface() || im == this, |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3075 |
"implementors cannot be interfaces"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3076 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3077 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3078 |
// Verify local interfaces |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3079 |
if (local_interfaces()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3080 |
Array<Klass*>* local_interfaces = this->local_interfaces(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3081 |
for (int j = 0; j < local_interfaces->length(); j++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3082 |
Klass* e = local_interfaces->at(j); |
14488 | 3083 |
guarantee(e->is_klass() && e->is_interface(), "invalid local interface"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3084 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3085 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3086 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3087 |
// Verify transitive interfaces |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3088 |
if (transitive_interfaces() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3089 |
Array<Klass*>* transitive_interfaces = this->transitive_interfaces(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3090 |
for (int j = 0; j < transitive_interfaces->length(); j++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3091 |
Klass* e = transitive_interfaces->at(j); |
14488 | 3092 |
guarantee(e->is_klass() && e->is_interface(), "invalid transitive interface"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3093 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3094 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3095 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3096 |
// Verify methods |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3097 |
if (methods() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3098 |
Array<Method*>* methods = this->methods(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3099 |
for (int j = 0; j < methods->length(); j++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3100 |
guarantee(methods->at(j)->is_method(), "non-method in methods array"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3101 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3102 |
for (int j = 0; j < methods->length() - 1; j++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3103 |
Method* m1 = methods->at(j); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3104 |
Method* m2 = methods->at(j + 1); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3105 |
guarantee(m1->name()->fast_compare(m2->name()) <= 0, "methods not sorted correctly"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3106 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3107 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3108 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3109 |
// Verify method ordering |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3110 |
if (method_ordering() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3111 |
Array<int>* method_ordering = this->method_ordering(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3112 |
int length = method_ordering->length(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3113 |
if (JvmtiExport::can_maintain_original_method_order() || |
16667
f0c0139a2125
8010943: guarantee(length == 0) failed: invalid method ordering length
hseigel
parents:
15935
diff
changeset
|
3114 |
((UseSharedSpaces || DumpSharedSpaces) && length != 0)) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3115 |
guarantee(length == methods()->length(), "invalid method ordering length"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3116 |
jlong sum = 0; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3117 |
for (int j = 0; j < length; j++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3118 |
int original_index = method_ordering->at(j); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3119 |
guarantee(original_index >= 0, "invalid method ordering index"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3120 |
guarantee(original_index < length, "invalid method ordering index"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3121 |
sum += original_index; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3122 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3123 |
// Verify sum of indices 0,1,...,length-1 |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3124 |
guarantee(sum == ((jlong)length*(length-1))/2, "invalid method ordering sum"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3125 |
} else { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3126 |
guarantee(length == 0, "invalid method ordering length"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3127 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3128 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3129 |
|
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3130 |
// Verify default methods |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3131 |
if (default_methods() != NULL) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3132 |
Array<Method*>* methods = this->default_methods(); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3133 |
for (int j = 0; j < methods->length(); j++) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3134 |
guarantee(methods->at(j)->is_method(), "non-method in methods array"); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3135 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3136 |
for (int j = 0; j < methods->length() - 1; j++) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3137 |
Method* m1 = methods->at(j); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3138 |
Method* m2 = methods->at(j + 1); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3139 |
guarantee(m1->name()->fast_compare(m2->name()) <= 0, "methods not sorted correctly"); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3140 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3141 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3142 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3143 |
// Verify JNI static field identifiers |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3144 |
if (jni_ids() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3145 |
jni_ids()->verify(this); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3146 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3147 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3148 |
// Verify other fields |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3149 |
if (array_klasses() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3150 |
guarantee(array_klasses()->is_klass(), "should be klass"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3151 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3152 |
if (constants() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3153 |
guarantee(constants()->is_constantPool(), "should be constant pool"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3154 |
} |
15873
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
3155 |
const Klass* host = host_klass(); |
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
3156 |
if (host != NULL) { |
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
3157 |
guarantee(host->is_klass(), "should be klass"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3158 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3159 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3160 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3161 |
void InstanceKlass::oop_verify_on(oop obj, outputStream* st) { |
1 | 3162 |
Klass::oop_verify_on(obj, st); |
3163 |
VerifyFieldClosure blk; |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3164 |
obj->oop_iterate_no_header(&blk); |
1 | 3165 |
} |
3166 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3167 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3168 |
// JNIid class for jfieldIDs only |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3169 |
// Note to reviewers: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3170 |
// These JNI functions are just moved over to column 1 and not changed |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3171 |
// in the compressed oops workspace. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3172 |
JNIid::JNIid(Klass* holder, int offset, JNIid* next) { |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3173 |
_holder = holder; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3174 |
_offset = offset; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3175 |
_next = next; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3176 |
debug_only(_is_static_field_id = false;) |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3177 |
} |
1 | 3178 |
|
3179 |
||
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3180 |
JNIid* JNIid::find(int offset) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3181 |
JNIid* current = this; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3182 |
while (current != NULL) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3183 |
if (current->offset() == offset) return current; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3184 |
current = current->next(); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3185 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3186 |
return NULL; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3187 |
} |
1 | 3188 |
|
3189 |
void JNIid::deallocate(JNIid* current) { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3190 |
while (current != NULL) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3191 |
JNIid* next = current->next(); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3192 |
delete current; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3193 |
current = next; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3194 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3195 |
} |
1 | 3196 |
|
3197 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3198 |
void JNIid::verify(Klass* holder) { |
13738
d67be49a5beb
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
13736
diff
changeset
|
3199 |
int first_field_offset = InstanceMirrorKlass::offset_of_static_fields(); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3200 |
int end_field_offset; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3201 |
end_field_offset = first_field_offset + (InstanceKlass::cast(holder)->static_field_size() * wordSize); |
1 | 3202 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3203 |
JNIid* current = this; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3204 |
while (current != NULL) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3205 |
guarantee(current->holder() == holder, "Invalid klass in JNIid"); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3206 |
#ifdef ASSERT |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3207 |
int o = current->offset(); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3208 |
if (current->is_static_field_id()) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3209 |
guarantee(o >= first_field_offset && o < end_field_offset, "Invalid static field offset in JNIid"); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3210 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3211 |
#endif |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3212 |
current = current->next(); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3213 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3214 |
} |
1 | 3215 |
|
3216 |
||
3217 |
#ifdef ASSERT |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3218 |
void InstanceKlass::set_init_state(ClassState state) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3219 |
bool good_state = is_shared() ? (_init_state <= state) |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3220 |
: (_init_state < state); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3221 |
assert(good_state || state == allocated, "illegal state transition"); |
11407
5399831730cd
7117052: instanceKlass::_init_state can be u1 type
coleenp
parents:
10739
diff
changeset
|
3222 |
_init_state = (u1)state; |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3223 |
} |
1 | 3224 |
#endif |
3225 |
||
3226 |
||
29576
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3227 |
|
1 | 3228 |
// RedefineClasses() support for previous versions: |
29576
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3229 |
int InstanceKlass::_previous_version_count = 0; |
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3230 |
|
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3231 |
// Purge previous versions before adding new previous versions of the class. |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3232 |
void InstanceKlass::purge_previous_versions(InstanceKlass* ik) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3233 |
if (ik->previous_versions() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3234 |
// This klass has previous versions so see what we can cleanup |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3235 |
// while it is safe to do so. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3236 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3237 |
int deleted_count = 0; // leave debugging breadcrumbs |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3238 |
int live_count = 0; |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3239 |
ClassLoaderData* loader_data = ik->class_loader_data(); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3240 |
assert(loader_data != NULL, "should never be null"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3241 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3242 |
// RC_TRACE macro has an embedded ResourceMark |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3243 |
RC_TRACE(0x00000200, ("purge: %s: previous versions", ik->external_name())); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3244 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3245 |
// previous versions are linked together through the InstanceKlass |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3246 |
InstanceKlass* pv_node = ik->previous_versions(); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3247 |
InstanceKlass* last = ik; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3248 |
int version = 0; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3249 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3250 |
// check the previous versions list |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3251 |
for (; pv_node != NULL; ) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3252 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3253 |
ConstantPool* pvcp = pv_node->constants(); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3254 |
assert(pvcp != NULL, "cp ref was unexpectedly cleared"); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3255 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3256 |
if (!pvcp->on_stack()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3257 |
// If the constant pool isn't on stack, none of the methods |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3258 |
// are executing. Unlink this previous_version. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3259 |
// The previous version InstanceKlass is on the ClassLoaderData deallocate list |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3260 |
// so will be deallocated during the next phase of class unloading. |
29576
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3261 |
RC_TRACE(0x00000200, ("purge: previous version " INTPTR_FORMAT " is dead", |
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3262 |
pv_node)); |
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3263 |
// For debugging purposes. |
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3264 |
pv_node->set_is_scratch_class(); |
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3265 |
pv_node->class_loader_data()->add_to_deallocate_list(pv_node); |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3266 |
pv_node = pv_node->previous_versions(); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3267 |
last->link_previous_versions(pv_node); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3268 |
deleted_count++; |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3269 |
version++; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3270 |
continue; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3271 |
} else { |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3272 |
RC_TRACE(0x00000200, ("purge: previous version " INTPTR_FORMAT " is alive", |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3273 |
pv_node)); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3274 |
assert(pvcp->pool_holder() != NULL, "Constant pool with no holder"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3275 |
guarantee (!loader_data->is_unloading(), "unloaded classes can't be on the stack"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3276 |
live_count++; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3277 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3278 |
|
29576
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3279 |
// At least one method is live in this previous version. |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3280 |
// Reset dead EMCP methods not to get breakpoints. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3281 |
// All methods are deallocated when all of the methods for this class are no |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3282 |
// longer running. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3283 |
Array<Method*>* method_refs = pv_node->methods(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3284 |
if (method_refs != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3285 |
RC_TRACE(0x00000200, ("purge: previous methods length=%d", |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3286 |
method_refs->length())); |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3287 |
for (int j = 0; j < method_refs->length(); j++) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3288 |
Method* method = method_refs->at(j); |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3289 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3290 |
if (!method->on_stack()) { |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3291 |
// no breakpoints for non-running methods |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3292 |
if (method->is_running_emcp()) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3293 |
method->set_running_emcp(false); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3294 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3295 |
} else { |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3296 |
assert (method->is_obsolete() || method->is_running_emcp(), |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3297 |
"emcp method cannot run after emcp bit is cleared"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3298 |
// RC_TRACE macro has an embedded ResourceMark |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3299 |
RC_TRACE(0x00000200, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3300 |
("purge: %s(%s): prev method @%d in version @%d is alive", |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3301 |
method->name()->as_C_string(), |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3302 |
method->signature()->as_C_string(), j, version)); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3303 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3304 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3305 |
} |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3306 |
// next previous version |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3307 |
last = pv_node; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3308 |
pv_node = pv_node->previous_versions(); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3309 |
version++; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3310 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3311 |
RC_TRACE(0x00000200, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3312 |
("purge: previous version stats: live=%d, deleted=%d", live_count, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3313 |
deleted_count)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3314 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3315 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3316 |
|
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3317 |
void InstanceKlass::mark_newly_obsolete_methods(Array<Method*>* old_methods, |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3318 |
int emcp_method_count) { |
1 | 3319 |
int obsolete_method_count = old_methods->length() - emcp_method_count; |
3320 |
||
3321 |
if (emcp_method_count != 0 && obsolete_method_count != 0 && |
|
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3322 |
_previous_versions != NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3323 |
// We have a mix of obsolete and EMCP methods so we have to |
1 | 3324 |
// clear out any matching EMCP method entries the hard way. |
3325 |
int local_count = 0; |
|
3326 |
for (int i = 0; i < old_methods->length(); i++) { |
|
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3327 |
Method* old_method = old_methods->at(i); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3328 |
if (old_method->is_obsolete()) { |
1 | 3329 |
// only obsolete methods are interesting |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
3330 |
Symbol* m_name = old_method->name(); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
3331 |
Symbol* m_signature = old_method->signature(); |
1 | 3332 |
|
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3333 |
// previous versions are linked together through the InstanceKlass |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3334 |
int j = 0; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3335 |
for (InstanceKlass* prev_version = _previous_versions; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3336 |
prev_version != NULL; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3337 |
prev_version = prev_version->previous_versions(), j++) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3338 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3339 |
Array<Method*>* method_refs = prev_version->methods(); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3340 |
for (int k = 0; k < method_refs->length(); k++) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3341 |
Method* method = method_refs->at(k); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3342 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3343 |
if (!method->is_obsolete() && |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3344 |
method->name() == m_name && |
1 | 3345 |
method->signature() == m_signature) { |
3346 |
// The current RedefineClasses() call has made all EMCP |
|
3347 |
// versions of this method obsolete so mark it as obsolete |
|
3348 |
RC_TRACE(0x00000400, |
|
3349 |
("add: %s(%s): flush obsolete method @%d in version @%d", |
|
3350 |
m_name->as_C_string(), m_signature->as_C_string(), k, j)); |
|
3351 |
||
3352 |
method->set_is_obsolete(); |
|
3353 |
break; |
|
3354 |
} |
|
3355 |
} |
|
3356 |
||
3357 |
// The previous loop may not find a matching EMCP method, but |
|
3358 |
// that doesn't mean that we can optimize and not go any |
|
3359 |
// further back in the PreviousVersion generations. The EMCP |
|
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3360 |
// method for this generation could have already been made obsolete, |
1 | 3361 |
// but there still may be an older EMCP method that has not |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3362 |
// been made obsolete. |
1 | 3363 |
} |
3364 |
||
3365 |
if (++local_count >= obsolete_method_count) { |
|
3366 |
// no more obsolete methods so bail out now |
|
3367 |
break; |
|
3368 |
} |
|
3369 |
} |
|
3370 |
} |
|
3371 |
} |
|
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3372 |
} |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3373 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3374 |
// Save the scratch_class as the previous version if any of the methods are running. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3375 |
// The previous_versions are used to set breakpoints in EMCP methods and they are |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3376 |
// also used to clean MethodData links to redefined methods that are no longer running. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3377 |
void InstanceKlass::add_previous_version(instanceKlassHandle scratch_class, |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3378 |
int emcp_method_count) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3379 |
assert(Thread::current()->is_VM_thread(), |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3380 |
"only VMThread can add previous versions"); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3381 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3382 |
// RC_TRACE macro has an embedded ResourceMark |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3383 |
RC_TRACE(0x00000400, ("adding previous version ref for %s, EMCP_cnt=%d", |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3384 |
scratch_class->external_name(), emcp_method_count)); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3385 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3386 |
// Clean out old previous versions |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3387 |
purge_previous_versions(this); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3388 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3389 |
// Mark newly obsolete methods in remaining previous versions. An EMCP method from |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3390 |
// a previous redefinition may be made obsolete by this redefinition. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3391 |
Array<Method*>* old_methods = scratch_class->methods(); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3392 |
mark_newly_obsolete_methods(old_methods, emcp_method_count); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3393 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3394 |
// If the constant pool for this previous version of the class |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3395 |
// is not marked as being on the stack, then none of the methods |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3396 |
// in this previous version of the class are on the stack so |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3397 |
// we don't need to add this as a previous version. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3398 |
ConstantPool* cp_ref = scratch_class->constants(); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3399 |
if (!cp_ref->on_stack()) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3400 |
RC_TRACE(0x00000400, ("add: scratch class not added; no methods are running")); |
29576
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3401 |
// For debugging purposes. |
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3402 |
scratch_class->set_is_scratch_class(); |
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3403 |
scratch_class->class_loader_data()->add_to_deallocate_list(scratch_class()); |
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3404 |
// Update count for class unloading. |
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3405 |
_previous_version_count--; |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3406 |
return; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3407 |
} |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3408 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3409 |
if (emcp_method_count != 0) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3410 |
// At least one method is still running, check for EMCP methods |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3411 |
for (int i = 0; i < old_methods->length(); i++) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3412 |
Method* old_method = old_methods->at(i); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3413 |
if (!old_method->is_obsolete() && old_method->on_stack()) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3414 |
// if EMCP method (not obsolete) is on the stack, mark as EMCP so that |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3415 |
// we can add breakpoints for it. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3416 |
|
29576
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3417 |
// We set the method->on_stack bit during safepoints for class redefinition |
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3418 |
// and use this bit to set the is_running_emcp bit. |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3419 |
// After the safepoint, the on_stack bit is cleared and the running emcp |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3420 |
// method may exit. If so, we would set a breakpoint in a method that |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3421 |
// is never reached, but this won't be noticeable to the programmer. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3422 |
old_method->set_running_emcp(true); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3423 |
RC_TRACE(0x00000400, ("add: EMCP method %s is on_stack " INTPTR_FORMAT, |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3424 |
old_method->name_and_sig_as_C_string(), old_method)); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3425 |
} else if (!old_method->is_obsolete()) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3426 |
RC_TRACE(0x00000400, ("add: EMCP method %s is NOT on_stack " INTPTR_FORMAT, |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3427 |
old_method->name_and_sig_as_C_string(), old_method)); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3428 |
} |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3429 |
} |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3430 |
} |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3431 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3432 |
// Add previous version if any methods are still running. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3433 |
RC_TRACE(0x00000400, ("add: scratch class added; one of its methods is on_stack")); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3434 |
assert(scratch_class->previous_versions() == NULL, "shouldn't have a previous version"); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3435 |
scratch_class->link_previous_versions(previous_versions()); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3436 |
link_previous_versions(scratch_class()); |
29576
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3437 |
// Update count for class unloading. |
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3438 |
_previous_version_count++; |
1 | 3439 |
} // end add_previous_version() |
3440 |
||
3441 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3442 |
Method* InstanceKlass::method_with_idnum(int idnum) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3443 |
Method* m = NULL; |
1 | 3444 |
if (idnum < methods()->length()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3445 |
m = methods()->at(idnum); |
1 | 3446 |
} |
3447 |
if (m == NULL || m->method_idnum() != idnum) { |
|
3448 |
for (int index = 0; index < methods()->length(); ++index) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3449 |
m = methods()->at(index); |
1 | 3450 |
if (m->method_idnum() == idnum) { |
3451 |
return m; |
|
3452 |
} |
|
3453 |
} |
|
20059
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
3454 |
// None found, return null for the caller to handle. |
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
3455 |
return NULL; |
1 | 3456 |
} |
3457 |
return m; |
|
3458 |
} |
|
3459 |
||
30107
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3460 |
|
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3461 |
Method* InstanceKlass::method_with_orig_idnum(int idnum) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3462 |
if (idnum >= methods()->length()) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3463 |
return NULL; |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3464 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3465 |
Method* m = methods()->at(idnum); |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3466 |
if (m != NULL && m->orig_method_idnum() == idnum) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3467 |
return m; |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3468 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3469 |
// Obsolete method idnum does not match the original idnum |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3470 |
for (int index = 0; index < methods()->length(); ++index) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3471 |
m = methods()->at(index); |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3472 |
if (m->orig_method_idnum() == idnum) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3473 |
return m; |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3474 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3475 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3476 |
// None found, return null for the caller to handle. |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3477 |
return NULL; |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3478 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3479 |
|
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3480 |
|
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3481 |
Method* InstanceKlass::method_with_orig_idnum(int idnum, int version) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3482 |
InstanceKlass* holder = get_klass_version(version); |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3483 |
if (holder == NULL) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3484 |
return NULL; // The version of klass is gone, no method is found |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3485 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3486 |
Method* method = holder->method_with_orig_idnum(idnum); |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3487 |
return method; |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3488 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3489 |
|
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3490 |
|
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3491 |
jint InstanceKlass::get_cached_class_file_len() { |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3492 |
return VM_RedefineClasses::get_cached_class_file_len(_cached_class_file); |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3493 |
} |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3494 |
|
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3495 |
unsigned char * InstanceKlass::get_cached_class_file_bytes() { |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3496 |
return VM_RedefineClasses::get_cached_class_file_bytes(_cached_class_file); |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3497 |
} |