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