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