annotate src/share/vm/oops/instanceKlass.cpp @ 3917:eca1193ca245

4965777: GC changes to support use of discovered field for pending references Summary: If and when the reference handler thread is able to use the discovered field to link reference objects in its pending list, so will GC. In that case, GC will scan through this field once a reference object has been placed on the pending list, but not scan that field before that stage, as the field is used by the concurrent GC thread to link discovered objects. When ReferenceHandleR thread does not use the discovered field for the purpose of linking the elements in the pending list, as would be the case in older JDKs, the JVM will fall back to the old behaviour of using the next field for that purpose. Reviewed-by: jcoomes, mchung, stefank
author ysr
date Wed, 07 Sep 2011 13:55:42 -0700
parents fdb992d83a87
children e6b1331a51d2
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
2227
e5383553fd4e 7014851: Remove unused parallel compaction code
stefank
parents: 2177
diff changeset
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1490
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1490
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1490
diff changeset
21 * questions.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
26 #include "classfile/javaClasses.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
27 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
28 #include "classfile/verifier.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
29 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
30 #include "compiler/compileBroker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
31 #include "gc_implementation/shared/markSweep.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
32 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
33 #include "interpreter/oopMapCache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
34 #include "interpreter/rewriter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
35 #include "jvmtifiles/jvmti.h"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
36 #include "memory/genOopClosures.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
37 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
38 #include "memory/permGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
39 #include "oops/instanceKlass.hpp"
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
40 #include "oops/instanceMirrorKlass.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
41 #include "oops/instanceOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
42 #include "oops/methodOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
43 #include "oops/objArrayKlassKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
44 #include "oops/oop.inline.hpp"
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
45 #include "oops/symbol.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
46 #include "prims/jvmtiExport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
47 #include "prims/jvmtiRedefineClassesTrace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
48 #include "runtime/fieldDescriptor.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
49 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
50 #include "runtime/javaCalls.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
51 #include "runtime/mutexLocker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
52 #include "services/threadService.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
53 #include "utilities/dtrace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
54 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
55 # include "thread_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
56 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
57 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
58 # include "thread_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
59 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
60 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
61 # include "thread_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
62 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
63 #ifndef SERIALGC
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
64 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
65 #include "gc_implementation/g1/g1OopClosures.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
66 #include "gc_implementation/g1/g1RemSet.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
67 #include "gc_implementation/g1/heapRegionSeq.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
68 #include "gc_implementation/parNew/parOopClosures.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
69 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
70 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
71 #include "oops/oop.pcgc.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
72 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
73 #ifdef COMPILER1
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
74 #include "c1/c1_Compiler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
75 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
76
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
77 #ifdef DTRACE_ENABLED
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
78
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
79 HS_DTRACE_PROBE_DECL4(hotspot, class__initialization__required,
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
80 char*, intptr_t, oop, intptr_t);
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
81 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__recursive,
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
82 char*, intptr_t, oop, intptr_t, int);
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
83 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__concurrent,
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
84 char*, intptr_t, oop, intptr_t, int);
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
85 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__erroneous,
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
86 char*, intptr_t, oop, intptr_t, int);
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
87 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__super__failed,
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
88 char*, intptr_t, oop, intptr_t, int);
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
89 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__clinit,
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
90 char*, intptr_t, oop, intptr_t, int);
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
91 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__error,
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
92 char*, intptr_t, oop, intptr_t, int);
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
93 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__end,
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
94 char*, intptr_t, oop, intptr_t, int);
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
95
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
96 #define DTRACE_CLASSINIT_PROBE(type, clss, thread_type) \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
97 { \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
98 char* data = NULL; \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
99 int len = 0; \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
100 Symbol* name = (clss)->name(); \
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
101 if (name != NULL) { \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
102 data = (char*)name->bytes(); \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
103 len = name->utf8_length(); \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
104 } \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
105 HS_DTRACE_PROBE4(hotspot, class__initialization__##type, \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
106 data, len, (clss)->class_loader(), thread_type); \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
107 }
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
108
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
109 #define DTRACE_CLASSINIT_PROBE_WAIT(type, clss, thread_type, wait) \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
110 { \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
111 char* data = NULL; \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
112 int len = 0; \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
113 Symbol* name = (clss)->name(); \
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
114 if (name != NULL) { \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
115 data = (char*)name->bytes(); \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
116 len = name->utf8_length(); \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
117 } \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
118 HS_DTRACE_PROBE5(hotspot, class__initialization__##type, \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
119 data, len, (clss)->class_loader(), thread_type, wait); \
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
120 }
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
121
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
122 #else // ndef DTRACE_ENABLED
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
123
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
124 #define DTRACE_CLASSINIT_PROBE(type, clss, thread_type)
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
125 #define DTRACE_CLASSINIT_PROBE_WAIT(type, clss, thread_type, wait)
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
126
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
127 #endif // ndef DTRACE_ENABLED
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
128
0
a61af66fc99e Initial load
duke
parents:
diff changeset
129 bool instanceKlass::should_be_initialized() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
130 return !is_initialized();
a61af66fc99e Initial load
duke
parents:
diff changeset
131 }
a61af66fc99e Initial load
duke
parents:
diff changeset
132
a61af66fc99e Initial load
duke
parents:
diff changeset
133 klassVtable* instanceKlass::vtable() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
134 return new klassVtable(as_klassOop(), start_of_vtable(), vtable_length() / vtableEntry::size());
a61af66fc99e Initial load
duke
parents:
diff changeset
135 }
a61af66fc99e Initial load
duke
parents:
diff changeset
136
a61af66fc99e Initial load
duke
parents:
diff changeset
137 klassItable* instanceKlass::itable() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
138 return new klassItable(as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
139 }
a61af66fc99e Initial load
duke
parents:
diff changeset
140
a61af66fc99e Initial load
duke
parents:
diff changeset
141 void instanceKlass::eager_initialize(Thread *thread) {
a61af66fc99e Initial load
duke
parents:
diff changeset
142 if (!EagerInitialization) return;
a61af66fc99e Initial load
duke
parents:
diff changeset
143
a61af66fc99e Initial load
duke
parents:
diff changeset
144 if (this->is_not_initialized()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
145 // abort if the the class has a class initializer
a61af66fc99e Initial load
duke
parents:
diff changeset
146 if (this->class_initializer() != NULL) return;
a61af66fc99e Initial load
duke
parents:
diff changeset
147
a61af66fc99e Initial load
duke
parents:
diff changeset
148 // abort if it is java.lang.Object (initialization is handled in genesis)
a61af66fc99e Initial load
duke
parents:
diff changeset
149 klassOop super = this->super();
a61af66fc99e Initial load
duke
parents:
diff changeset
150 if (super == NULL) return;
a61af66fc99e Initial load
duke
parents:
diff changeset
151
a61af66fc99e Initial load
duke
parents:
diff changeset
152 // abort if the super class should be initialized
a61af66fc99e Initial load
duke
parents:
diff changeset
153 if (!instanceKlass::cast(super)->is_initialized()) return;
a61af66fc99e Initial load
duke
parents:
diff changeset
154
a61af66fc99e Initial load
duke
parents:
diff changeset
155 // call body to expose the this pointer
a61af66fc99e Initial load
duke
parents:
diff changeset
156 instanceKlassHandle this_oop(thread, this->as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
157 eager_initialize_impl(this_oop);
a61af66fc99e Initial load
duke
parents:
diff changeset
158 }
a61af66fc99e Initial load
duke
parents:
diff changeset
159 }
a61af66fc99e Initial load
duke
parents:
diff changeset
160
a61af66fc99e Initial load
duke
parents:
diff changeset
161
a61af66fc99e Initial load
duke
parents:
diff changeset
162 void instanceKlass::eager_initialize_impl(instanceKlassHandle this_oop) {
a61af66fc99e Initial load
duke
parents:
diff changeset
163 EXCEPTION_MARK;
a61af66fc99e Initial load
duke
parents:
diff changeset
164 ObjectLocker ol(this_oop, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
165
a61af66fc99e Initial load
duke
parents:
diff changeset
166 // abort if someone beat us to the initialization
a61af66fc99e Initial load
duke
parents:
diff changeset
167 if (!this_oop->is_not_initialized()) return; // note: not equivalent to is_initialized()
a61af66fc99e Initial load
duke
parents:
diff changeset
168
a61af66fc99e Initial load
duke
parents:
diff changeset
169 ClassState old_state = this_oop->_init_state;
a61af66fc99e Initial load
duke
parents:
diff changeset
170 link_class_impl(this_oop, true, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
171 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load
duke
parents:
diff changeset
172 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load
duke
parents:
diff changeset
173 // Abort if linking the class throws an exception.
a61af66fc99e Initial load
duke
parents:
diff changeset
174
a61af66fc99e Initial load
duke
parents:
diff changeset
175 // Use a test to avoid redundantly resetting the state if there's
a61af66fc99e Initial load
duke
parents:
diff changeset
176 // no change. Set_init_state() asserts that state changes make
a61af66fc99e Initial load
duke
parents:
diff changeset
177 // progress, whereas here we might just be spinning in place.
a61af66fc99e Initial load
duke
parents:
diff changeset
178 if( old_state != this_oop->_init_state )
a61af66fc99e Initial load
duke
parents:
diff changeset
179 this_oop->set_init_state (old_state);
a61af66fc99e Initial load
duke
parents:
diff changeset
180 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
181 // linking successfull, mark class as initialized
a61af66fc99e Initial load
duke
parents:
diff changeset
182 this_oop->set_init_state (fully_initialized);
a61af66fc99e Initial load
duke
parents:
diff changeset
183 // trace
a61af66fc99e Initial load
duke
parents:
diff changeset
184 if (TraceClassInitialization) {
a61af66fc99e Initial load
duke
parents:
diff changeset
185 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
186 tty->print_cr("[Initialized %s without side effects]", this_oop->external_name());
a61af66fc99e Initial load
duke
parents:
diff changeset
187 }
a61af66fc99e Initial load
duke
parents:
diff changeset
188 }
a61af66fc99e Initial load
duke
parents:
diff changeset
189 }
a61af66fc99e Initial load
duke
parents:
diff changeset
190
a61af66fc99e Initial load
duke
parents:
diff changeset
191
a61af66fc99e Initial load
duke
parents:
diff changeset
192 // See "The Virtual Machine Specification" section 2.16.5 for a detailed explanation of the class initialization
a61af66fc99e Initial load
duke
parents:
diff changeset
193 // process. The step comments refers to the procedure described in that section.
a61af66fc99e Initial load
duke
parents:
diff changeset
194 // Note: implementation moved to static method to expose the this pointer.
a61af66fc99e Initial load
duke
parents:
diff changeset
195 void instanceKlass::initialize(TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
196 if (this->should_be_initialized()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
197 HandleMark hm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
198 instanceKlassHandle this_oop(THREAD, this->as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
199 initialize_impl(this_oop, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
200 // Note: at this point the class may be initialized
a61af66fc99e Initial load
duke
parents:
diff changeset
201 // OR it may be in the state of being initialized
a61af66fc99e Initial load
duke
parents:
diff changeset
202 // in case of recursive initialization!
a61af66fc99e Initial load
duke
parents:
diff changeset
203 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
204 assert(is_initialized(), "sanity check");
a61af66fc99e Initial load
duke
parents:
diff changeset
205 }
a61af66fc99e Initial load
duke
parents:
diff changeset
206 }
a61af66fc99e Initial load
duke
parents:
diff changeset
207
a61af66fc99e Initial load
duke
parents:
diff changeset
208
a61af66fc99e Initial load
duke
parents:
diff changeset
209 bool instanceKlass::verify_code(
a61af66fc99e Initial load
duke
parents:
diff changeset
210 instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
211 // 1) Verify the bytecodes
a61af66fc99e Initial load
duke
parents:
diff changeset
212 Verifier::Mode mode =
a61af66fc99e Initial load
duke
parents:
diff changeset
213 throw_verifyerror ? Verifier::ThrowException : Verifier::NoException;
973
ad6585fd4087 6830542: Performance: JVM_DefineClass already verified.
acorn
parents: 964
diff changeset
214 return Verifier::verify(this_oop, mode, this_oop->should_verify_class(), CHECK_false);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
215 }
a61af66fc99e Initial load
duke
parents:
diff changeset
216
a61af66fc99e Initial load
duke
parents:
diff changeset
217
a61af66fc99e Initial load
duke
parents:
diff changeset
218 // Used exclusively by the shared spaces dump mechanism to prevent
a61af66fc99e Initial load
duke
parents:
diff changeset
219 // classes mapped into the shared regions in new VMs from appearing linked.
a61af66fc99e Initial load
duke
parents:
diff changeset
220
a61af66fc99e Initial load
duke
parents:
diff changeset
221 void instanceKlass::unlink_class() {
a61af66fc99e Initial load
duke
parents:
diff changeset
222 assert(is_linked(), "must be linked");
a61af66fc99e Initial load
duke
parents:
diff changeset
223 _init_state = loaded;
a61af66fc99e Initial load
duke
parents:
diff changeset
224 }
a61af66fc99e Initial load
duke
parents:
diff changeset
225
a61af66fc99e Initial load
duke
parents:
diff changeset
226 void instanceKlass::link_class(TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
227 assert(is_loaded(), "must be loaded");
a61af66fc99e Initial load
duke
parents:
diff changeset
228 if (!is_linked()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
229 instanceKlassHandle this_oop(THREAD, this->as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
230 link_class_impl(this_oop, true, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
231 }
a61af66fc99e Initial load
duke
parents:
diff changeset
232 }
a61af66fc99e Initial load
duke
parents:
diff changeset
233
a61af66fc99e Initial load
duke
parents:
diff changeset
234 // Called to verify that a class can link during initialization, without
a61af66fc99e Initial load
duke
parents:
diff changeset
235 // throwing a VerifyError.
a61af66fc99e Initial load
duke
parents:
diff changeset
236 bool instanceKlass::link_class_or_fail(TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
237 assert(is_loaded(), "must be loaded");
a61af66fc99e Initial load
duke
parents:
diff changeset
238 if (!is_linked()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
239 instanceKlassHandle this_oop(THREAD, this->as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
240 link_class_impl(this_oop, false, CHECK_false);
a61af66fc99e Initial load
duke
parents:
diff changeset
241 }
a61af66fc99e Initial load
duke
parents:
diff changeset
242 return is_linked();
a61af66fc99e Initial load
duke
parents:
diff changeset
243 }
a61af66fc99e Initial load
duke
parents:
diff changeset
244
a61af66fc99e Initial load
duke
parents:
diff changeset
245 bool instanceKlass::link_class_impl(
a61af66fc99e Initial load
duke
parents:
diff changeset
246 instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
247 // check for error state
a61af66fc99e Initial load
duke
parents:
diff changeset
248 if (this_oop->is_in_error_state()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
249 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
250 THROW_MSG_(vmSymbols::java_lang_NoClassDefFoundError(),
a61af66fc99e Initial load
duke
parents:
diff changeset
251 this_oop->external_name(), false);
a61af66fc99e Initial load
duke
parents:
diff changeset
252 }
a61af66fc99e Initial load
duke
parents:
diff changeset
253 // return if already verified
a61af66fc99e Initial load
duke
parents:
diff changeset
254 if (this_oop->is_linked()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
255 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
256 }
a61af66fc99e Initial load
duke
parents:
diff changeset
257
a61af66fc99e Initial load
duke
parents:
diff changeset
258 // Timing
a61af66fc99e Initial load
duke
parents:
diff changeset
259 // timer handles recursion
a61af66fc99e Initial load
duke
parents:
diff changeset
260 assert(THREAD->is_Java_thread(), "non-JavaThread in link_class_impl");
a61af66fc99e Initial load
duke
parents:
diff changeset
261 JavaThread* jt = (JavaThread*)THREAD;
a61af66fc99e Initial load
duke
parents:
diff changeset
262
a61af66fc99e Initial load
duke
parents:
diff changeset
263 // link super class before linking this class
a61af66fc99e Initial load
duke
parents:
diff changeset
264 instanceKlassHandle super(THREAD, this_oop->super());
a61af66fc99e Initial load
duke
parents:
diff changeset
265 if (super.not_null()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
266 if (super->is_interface()) { // check if super class is an interface
a61af66fc99e Initial load
duke
parents:
diff changeset
267 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
268 Exceptions::fthrow(
a61af66fc99e Initial load
duke
parents:
diff changeset
269 THREAD_AND_LOCATION,
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
270 vmSymbols::java_lang_IncompatibleClassChangeError(),
0
a61af66fc99e Initial load
duke
parents:
diff changeset
271 "class %s has interface %s as super class",
a61af66fc99e Initial load
duke
parents:
diff changeset
272 this_oop->external_name(),
a61af66fc99e Initial load
duke
parents:
diff changeset
273 super->external_name()
a61af66fc99e Initial load
duke
parents:
diff changeset
274 );
a61af66fc99e Initial load
duke
parents:
diff changeset
275 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
276 }
a61af66fc99e Initial load
duke
parents:
diff changeset
277
a61af66fc99e Initial load
duke
parents:
diff changeset
278 link_class_impl(super, throw_verifyerror, CHECK_false);
a61af66fc99e Initial load
duke
parents:
diff changeset
279 }
a61af66fc99e Initial load
duke
parents:
diff changeset
280
a61af66fc99e Initial load
duke
parents:
diff changeset
281 // link all interfaces implemented by this class before linking this class
a61af66fc99e Initial load
duke
parents:
diff changeset
282 objArrayHandle interfaces (THREAD, this_oop->local_interfaces());
a61af66fc99e Initial load
duke
parents:
diff changeset
283 int num_interfaces = interfaces->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
284 for (int index = 0; index < num_interfaces; index++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
285 HandleMark hm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
286 instanceKlassHandle ih(THREAD, klassOop(interfaces->obj_at(index)));
a61af66fc99e Initial load
duke
parents:
diff changeset
287 link_class_impl(ih, throw_verifyerror, CHECK_false);
a61af66fc99e Initial load
duke
parents:
diff changeset
288 }
a61af66fc99e Initial load
duke
parents:
diff changeset
289
a61af66fc99e Initial load
duke
parents:
diff changeset
290 // in case the class is linked in the process of linking its superclasses
a61af66fc99e Initial load
duke
parents:
diff changeset
291 if (this_oop->is_linked()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
292 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
293 }
a61af66fc99e Initial load
duke
parents:
diff changeset
294
875
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
295 // trace only the link time for this klass that includes
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
296 // the verification time
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
297 PerfClassTraceTime vmtimer(ClassLoader::perf_class_link_time(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
298 ClassLoader::perf_class_link_selftime(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
299 ClassLoader::perf_classes_linked(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
300 jt->get_thread_stat()->perf_recursion_counts_addr(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
301 jt->get_thread_stat()->perf_timers_addr(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
302 PerfClassTraceTime::CLASS_LINK);
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
303
0
a61af66fc99e Initial load
duke
parents:
diff changeset
304 // verification & rewriting
a61af66fc99e Initial load
duke
parents:
diff changeset
305 {
a61af66fc99e Initial load
duke
parents:
diff changeset
306 ObjectLocker ol(this_oop, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
307 // rewritten will have been set if loader constraint error found
a61af66fc99e Initial load
duke
parents:
diff changeset
308 // on an earlier link attempt
a61af66fc99e Initial load
duke
parents:
diff changeset
309 // don't verify or rewrite if already rewritten
a61af66fc99e Initial load
duke
parents:
diff changeset
310 if (!this_oop->is_linked()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
311 if (!this_oop->is_rewritten()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
312 {
a61af66fc99e Initial load
duke
parents:
diff changeset
313 // Timer includes any side effects of class verification (resolution,
a61af66fc99e Initial load
duke
parents:
diff changeset
314 // etc), but not recursive entry into verify_code().
875
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
315 PerfClassTraceTime timer(ClassLoader::perf_class_verify_time(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
316 ClassLoader::perf_class_verify_selftime(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
317 ClassLoader::perf_classes_verified(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
318 jt->get_thread_stat()->perf_recursion_counts_addr(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
319 jt->get_thread_stat()->perf_timers_addr(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
320 PerfClassTraceTime::CLASS_VERIFY);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
321 bool verify_ok = verify_code(this_oop, throw_verifyerror, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
322 if (!verify_ok) {
a61af66fc99e Initial load
duke
parents:
diff changeset
323 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
324 }
a61af66fc99e Initial load
duke
parents:
diff changeset
325 }
a61af66fc99e Initial load
duke
parents:
diff changeset
326
a61af66fc99e Initial load
duke
parents:
diff changeset
327 // Just in case a side-effect of verify linked this class already
a61af66fc99e Initial load
duke
parents:
diff changeset
328 // (which can sometimes happen since the verifier loads classes
a61af66fc99e Initial load
duke
parents:
diff changeset
329 // using custom class loaders, which are free to initialize things)
a61af66fc99e Initial load
duke
parents:
diff changeset
330 if (this_oop->is_linked()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
331 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
332 }
a61af66fc99e Initial load
duke
parents:
diff changeset
333
a61af66fc99e Initial load
duke
parents:
diff changeset
334 // also sets rewritten
a61af66fc99e Initial load
duke
parents:
diff changeset
335 this_oop->rewrite_class(CHECK_false);
a61af66fc99e Initial load
duke
parents:
diff changeset
336 }
a61af66fc99e Initial load
duke
parents:
diff changeset
337
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2408
diff changeset
338 // relocate jsrs and link methods after they are all rewritten
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2408
diff changeset
339 this_oop->relocate_and_link_methods(CHECK_false);
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2408
diff changeset
340
0
a61af66fc99e Initial load
duke
parents:
diff changeset
341 // Initialize the vtable and interface table after
a61af66fc99e Initial load
duke
parents:
diff changeset
342 // methods have been rewritten since rewrite may
a61af66fc99e Initial load
duke
parents:
diff changeset
343 // fabricate new methodOops.
a61af66fc99e Initial load
duke
parents:
diff changeset
344 // also does loader constraint checking
a61af66fc99e Initial load
duke
parents:
diff changeset
345 if (!this_oop()->is_shared()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
346 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
347 this_oop->vtable()->initialize_vtable(true, CHECK_false);
a61af66fc99e Initial load
duke
parents:
diff changeset
348 this_oop->itable()->initialize_itable(true, CHECK_false);
a61af66fc99e Initial load
duke
parents:
diff changeset
349 }
a61af66fc99e Initial load
duke
parents:
diff changeset
350 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
351 else {
a61af66fc99e Initial load
duke
parents:
diff changeset
352 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
353 this_oop->vtable()->verify(tty, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
354 // In case itable verification is ever added.
a61af66fc99e Initial load
duke
parents:
diff changeset
355 // this_oop->itable()->verify(tty, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
356 }
a61af66fc99e Initial load
duke
parents:
diff changeset
357 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
358 this_oop->set_init_state(linked);
a61af66fc99e Initial load
duke
parents:
diff changeset
359 if (JvmtiExport::should_post_class_prepare()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
360 Thread *thread = THREAD;
a61af66fc99e Initial load
duke
parents:
diff changeset
361 assert(thread->is_Java_thread(), "thread->is_Java_thread()");
a61af66fc99e Initial load
duke
parents:
diff changeset
362 JvmtiExport::post_class_prepare((JavaThread *) thread, this_oop());
a61af66fc99e Initial load
duke
parents:
diff changeset
363 }
a61af66fc99e Initial load
duke
parents:
diff changeset
364 }
a61af66fc99e Initial load
duke
parents:
diff changeset
365 }
a61af66fc99e Initial load
duke
parents:
diff changeset
366 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
367 }
a61af66fc99e Initial load
duke
parents:
diff changeset
368
a61af66fc99e Initial load
duke
parents:
diff changeset
369
a61af66fc99e Initial load
duke
parents:
diff changeset
370 // Rewrite the byte codes of all of the methods of a class.
a61af66fc99e Initial load
duke
parents:
diff changeset
371 // The rewriter must be called exactly once. Rewriting must happen after
a61af66fc99e Initial load
duke
parents:
diff changeset
372 // verification but before the first method of the class is executed.
a61af66fc99e Initial load
duke
parents:
diff changeset
373 void instanceKlass::rewrite_class(TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
374 assert(is_loaded(), "must be loaded");
a61af66fc99e Initial load
duke
parents:
diff changeset
375 instanceKlassHandle this_oop(THREAD, this->as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
376 if (this_oop->is_rewritten()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
377 assert(this_oop()->is_shared(), "rewriting an unshared class?");
a61af66fc99e Initial load
duke
parents:
diff changeset
378 return;
a61af66fc99e Initial load
duke
parents:
diff changeset
379 }
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2408
diff changeset
380 Rewriter::rewrite(this_oop, CHECK);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
381 this_oop->set_rewritten();
a61af66fc99e Initial load
duke
parents:
diff changeset
382 }
a61af66fc99e Initial load
duke
parents:
diff changeset
383
3748
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2408
diff changeset
384 // Now relocate and link method entry points after class is rewritten.
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2408
diff changeset
385 // This is outside is_rewritten flag. In case of an exception, it can be
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2408
diff changeset
386 // executed more than once.
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2408
diff changeset
387 void instanceKlass::relocate_and_link_methods(TRAPS) {
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2408
diff changeset
388 assert(is_loaded(), "must be loaded");
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2408
diff changeset
389 instanceKlassHandle this_oop(THREAD, this->as_klassOop());
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2408
diff changeset
390 Rewriter::relocate_and_link(this_oop, CHECK);
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2408
diff changeset
391 }
d3b9f2be46ab 7033141: assert(has_cp_cache(i)) failed: oob
coleenp
parents: 2408
diff changeset
392
0
a61af66fc99e Initial load
duke
parents:
diff changeset
393
a61af66fc99e Initial load
duke
parents:
diff changeset
394 void instanceKlass::initialize_impl(instanceKlassHandle this_oop, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
395 // Make sure klass is linked (verified) before initialization
a61af66fc99e Initial load
duke
parents:
diff changeset
396 // A class could already be verified, since it has been reflected upon.
a61af66fc99e Initial load
duke
parents:
diff changeset
397 this_oop->link_class(CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
398
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
399 DTRACE_CLASSINIT_PROBE(required, instanceKlass::cast(this_oop()), -1);
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
400
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
401 bool wait = false;
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
402
0
a61af66fc99e Initial load
duke
parents:
diff changeset
403 // refer to the JVM book page 47 for description of steps
a61af66fc99e Initial load
duke
parents:
diff changeset
404 // Step 1
a61af66fc99e Initial load
duke
parents:
diff changeset
405 { ObjectLocker ol(this_oop, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
406
a61af66fc99e Initial load
duke
parents:
diff changeset
407 Thread *self = THREAD; // it's passed the current thread
a61af66fc99e Initial load
duke
parents:
diff changeset
408
a61af66fc99e Initial load
duke
parents:
diff changeset
409 // Step 2
a61af66fc99e Initial load
duke
parents:
diff changeset
410 // If we were to use wait() instead of waitInterruptibly() then
a61af66fc99e Initial load
duke
parents:
diff changeset
411 // we might end up throwing IE from link/symbol resolution sites
a61af66fc99e Initial load
duke
parents:
diff changeset
412 // that aren't expected to throw. This would wreak havoc. See 6320309.
a61af66fc99e Initial load
duke
parents:
diff changeset
413 while(this_oop->is_being_initialized() && !this_oop->is_reentrant_initialization(self)) {
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
414 wait = true;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
415 ol.waitUninterruptibly(CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
416 }
a61af66fc99e Initial load
duke
parents:
diff changeset
417
a61af66fc99e Initial load
duke
parents:
diff changeset
418 // Step 3
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
419 if (this_oop->is_being_initialized() && this_oop->is_reentrant_initialization(self)) {
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
420 DTRACE_CLASSINIT_PROBE_WAIT(recursive, instanceKlass::cast(this_oop()), -1,wait);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
421 return;
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
422 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
423
a61af66fc99e Initial load
duke
parents:
diff changeset
424 // Step 4
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
425 if (this_oop->is_initialized()) {
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
426 DTRACE_CLASSINIT_PROBE_WAIT(concurrent, instanceKlass::cast(this_oop()), -1,wait);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
427 return;
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
428 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
429
a61af66fc99e Initial load
duke
parents:
diff changeset
430 // Step 5
a61af66fc99e Initial load
duke
parents:
diff changeset
431 if (this_oop->is_in_error_state()) {
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
432 DTRACE_CLASSINIT_PROBE_WAIT(erroneous, instanceKlass::cast(this_oop()), -1,wait);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
433 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
434 const char* desc = "Could not initialize class ";
a61af66fc99e Initial load
duke
parents:
diff changeset
435 const char* className = this_oop->external_name();
a61af66fc99e Initial load
duke
parents:
diff changeset
436 size_t msglen = strlen(desc) + strlen(className) + 1;
1751
2528b5bd749c 6980262: Memory leak when exception is thrown in static initializer
kamg
parents: 1706
diff changeset
437 char* message = NEW_RESOURCE_ARRAY(char, msglen);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
438 if (NULL == message) {
a61af66fc99e Initial load
duke
parents:
diff changeset
439 // Out of memory: can't create detailed error message
a61af66fc99e Initial load
duke
parents:
diff changeset
440 THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), className);
a61af66fc99e Initial load
duke
parents:
diff changeset
441 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
442 jio_snprintf(message, msglen, "%s%s", desc, className);
a61af66fc99e Initial load
duke
parents:
diff changeset
443 THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), message);
a61af66fc99e Initial load
duke
parents:
diff changeset
444 }
a61af66fc99e Initial load
duke
parents:
diff changeset
445 }
a61af66fc99e Initial load
duke
parents:
diff changeset
446
a61af66fc99e Initial load
duke
parents:
diff changeset
447 // Step 6
a61af66fc99e Initial load
duke
parents:
diff changeset
448 this_oop->set_init_state(being_initialized);
a61af66fc99e Initial load
duke
parents:
diff changeset
449 this_oop->set_init_thread(self);
a61af66fc99e Initial load
duke
parents:
diff changeset
450 }
a61af66fc99e Initial load
duke
parents:
diff changeset
451
a61af66fc99e Initial load
duke
parents:
diff changeset
452 // Step 7
a61af66fc99e Initial load
duke
parents:
diff changeset
453 klassOop super_klass = this_oop->super();
a61af66fc99e Initial load
duke
parents:
diff changeset
454 if (super_klass != NULL && !this_oop->is_interface() && Klass::cast(super_klass)->should_be_initialized()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
455 Klass::cast(super_klass)->initialize(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
456
a61af66fc99e Initial load
duke
parents:
diff changeset
457 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load
duke
parents:
diff changeset
458 Handle e(THREAD, PENDING_EXCEPTION);
a61af66fc99e Initial load
duke
parents:
diff changeset
459 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load
duke
parents:
diff changeset
460 {
a61af66fc99e Initial load
duke
parents:
diff changeset
461 EXCEPTION_MARK;
a61af66fc99e Initial load
duke
parents:
diff changeset
462 this_oop->set_initialization_state_and_notify(initialization_error, THREAD); // Locks object, set state, and notify all waiting threads
a61af66fc99e Initial load
duke
parents:
diff changeset
463 CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, superclass initialization error is thrown below
a61af66fc99e Initial load
duke
parents:
diff changeset
464 }
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
465 DTRACE_CLASSINIT_PROBE_WAIT(super__failed, instanceKlass::cast(this_oop()), -1,wait);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
466 THROW_OOP(e());
a61af66fc99e Initial load
duke
parents:
diff changeset
467 }
a61af66fc99e Initial load
duke
parents:
diff changeset
468 }
a61af66fc99e Initial load
duke
parents:
diff changeset
469
a61af66fc99e Initial load
duke
parents:
diff changeset
470 // Step 8
a61af66fc99e Initial load
duke
parents:
diff changeset
471 {
a61af66fc99e Initial load
duke
parents:
diff changeset
472 assert(THREAD->is_Java_thread(), "non-JavaThread in initialize_impl");
a61af66fc99e Initial load
duke
parents:
diff changeset
473 JavaThread* jt = (JavaThread*)THREAD;
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
474 DTRACE_CLASSINIT_PROBE_WAIT(clinit, instanceKlass::cast(this_oop()), -1,wait);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
475 // Timer includes any side effects of class initialization (resolution,
a61af66fc99e Initial load
duke
parents:
diff changeset
476 // etc), but not recursive entry into call_class_initializer().
875
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
477 PerfClassTraceTime timer(ClassLoader::perf_class_init_time(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
478 ClassLoader::perf_class_init_selftime(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
479 ClassLoader::perf_classes_inited(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
480 jt->get_thread_stat()->perf_recursion_counts_addr(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
481 jt->get_thread_stat()->perf_timers_addr(),
6a93908f268f 6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents: 676
diff changeset
482 PerfClassTraceTime::CLASS_CLINIT);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
483 this_oop->call_class_initializer(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
484 }
a61af66fc99e Initial load
duke
parents:
diff changeset
485
a61af66fc99e Initial load
duke
parents:
diff changeset
486 // Step 9
a61af66fc99e Initial load
duke
parents:
diff changeset
487 if (!HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load
duke
parents:
diff changeset
488 this_oop->set_initialization_state_and_notify(fully_initialized, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
489 { ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
490 debug_only(this_oop->vtable()->verify(tty, true);)
a61af66fc99e Initial load
duke
parents:
diff changeset
491 }
a61af66fc99e Initial load
duke
parents:
diff changeset
492 }
a61af66fc99e Initial load
duke
parents:
diff changeset
493 else {
a61af66fc99e Initial load
duke
parents:
diff changeset
494 // Step 10 and 11
a61af66fc99e Initial load
duke
parents:
diff changeset
495 Handle e(THREAD, PENDING_EXCEPTION);
a61af66fc99e Initial load
duke
parents:
diff changeset
496 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load
duke
parents:
diff changeset
497 {
a61af66fc99e Initial load
duke
parents:
diff changeset
498 EXCEPTION_MARK;
a61af66fc99e Initial load
duke
parents:
diff changeset
499 this_oop->set_initialization_state_and_notify(initialization_error, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
500 CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, class initialization error is thrown below
a61af66fc99e Initial load
duke
parents:
diff changeset
501 }
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
502 DTRACE_CLASSINIT_PROBE_WAIT(error, instanceKlass::cast(this_oop()), -1,wait);
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1039
diff changeset
503 if (e->is_a(SystemDictionary::Error_klass())) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
504 THROW_OOP(e());
a61af66fc99e Initial load
duke
parents:
diff changeset
505 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
506 JavaCallArguments args(e);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
507 THROW_ARG(vmSymbols::java_lang_ExceptionInInitializerError(),
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
508 vmSymbols::throwable_void_signature(),
0
a61af66fc99e Initial load
duke
parents:
diff changeset
509 &args);
a61af66fc99e Initial load
duke
parents:
diff changeset
510 }
a61af66fc99e Initial load
duke
parents:
diff changeset
511 }
1324
e392695de029 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 1155
diff changeset
512 DTRACE_CLASSINIT_PROBE_WAIT(end, instanceKlass::cast(this_oop()), -1,wait);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
513 }
a61af66fc99e Initial load
duke
parents:
diff changeset
514
a61af66fc99e Initial load
duke
parents:
diff changeset
515
a61af66fc99e Initial load
duke
parents:
diff changeset
516 // Note: implementation moved to static method to expose the this pointer.
a61af66fc99e Initial load
duke
parents:
diff changeset
517 void instanceKlass::set_initialization_state_and_notify(ClassState state, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
518 instanceKlassHandle kh(THREAD, this->as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
519 set_initialization_state_and_notify_impl(kh, state, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
520 }
a61af66fc99e Initial load
duke
parents:
diff changeset
521
a61af66fc99e Initial load
duke
parents:
diff changeset
522 void instanceKlass::set_initialization_state_and_notify_impl(instanceKlassHandle this_oop, ClassState state, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
523 ObjectLocker ol(this_oop, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
524 this_oop->set_init_state(state);
a61af66fc99e Initial load
duke
parents:
diff changeset
525 ol.notify_all(CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
526 }
a61af66fc99e Initial load
duke
parents:
diff changeset
527
a61af66fc99e Initial load
duke
parents:
diff changeset
528 void instanceKlass::add_implementor(klassOop k) {
a61af66fc99e Initial load
duke
parents:
diff changeset
529 assert(Compile_lock->owned_by_self(), "");
a61af66fc99e Initial load
duke
parents:
diff changeset
530 // Filter out my subinterfaces.
a61af66fc99e Initial load
duke
parents:
diff changeset
531 // (Note: Interfaces are never on the subklass list.)
a61af66fc99e Initial load
duke
parents:
diff changeset
532 if (instanceKlass::cast(k)->is_interface()) return;
a61af66fc99e Initial load
duke
parents:
diff changeset
533
a61af66fc99e Initial load
duke
parents:
diff changeset
534 // Filter out subclasses whose supers already implement me.
a61af66fc99e Initial load
duke
parents:
diff changeset
535 // (Note: CHA must walk subclasses of direct implementors
a61af66fc99e Initial load
duke
parents:
diff changeset
536 // in order to locate indirect implementors.)
a61af66fc99e Initial load
duke
parents:
diff changeset
537 klassOop sk = instanceKlass::cast(k)->super();
a61af66fc99e Initial load
duke
parents:
diff changeset
538 if (sk != NULL && instanceKlass::cast(sk)->implements_interface(as_klassOop()))
a61af66fc99e Initial load
duke
parents:
diff changeset
539 // We only need to check one immediate superclass, since the
a61af66fc99e Initial load
duke
parents:
diff changeset
540 // implements_interface query looks at transitive_interfaces.
a61af66fc99e Initial load
duke
parents:
diff changeset
541 // Any supers of the super have the same (or fewer) transitive_interfaces.
a61af66fc99e Initial load
duke
parents:
diff changeset
542 return;
a61af66fc99e Initial load
duke
parents:
diff changeset
543
a61af66fc99e Initial load
duke
parents:
diff changeset
544 // Update number of implementors
a61af66fc99e Initial load
duke
parents:
diff changeset
545 int i = _nof_implementors++;
a61af66fc99e Initial load
duke
parents:
diff changeset
546
a61af66fc99e Initial load
duke
parents:
diff changeset
547 // Record this implementor, if there are not too many already
a61af66fc99e Initial load
duke
parents:
diff changeset
548 if (i < implementors_limit) {
a61af66fc99e Initial load
duke
parents:
diff changeset
549 assert(_implementors[i] == NULL, "should be exactly one implementor");
a61af66fc99e Initial load
duke
parents:
diff changeset
550 oop_store_without_check((oop*)&_implementors[i], k);
a61af66fc99e Initial load
duke
parents:
diff changeset
551 } else if (i == implementors_limit) {
a61af66fc99e Initial load
duke
parents:
diff changeset
552 // clear out the list on first overflow
a61af66fc99e Initial load
duke
parents:
diff changeset
553 for (int i2 = 0; i2 < implementors_limit; i2++)
a61af66fc99e Initial load
duke
parents:
diff changeset
554 oop_store_without_check((oop*)&_implementors[i2], NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
555 }
a61af66fc99e Initial load
duke
parents:
diff changeset
556
a61af66fc99e Initial load
duke
parents:
diff changeset
557 // The implementor also implements the transitive_interfaces
a61af66fc99e Initial load
duke
parents:
diff changeset
558 for (int index = 0; index < local_interfaces()->length(); index++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
559 instanceKlass::cast(klassOop(local_interfaces()->obj_at(index)))->add_implementor(k);
a61af66fc99e Initial load
duke
parents:
diff changeset
560 }
a61af66fc99e Initial load
duke
parents:
diff changeset
561 }
a61af66fc99e Initial load
duke
parents:
diff changeset
562
a61af66fc99e Initial load
duke
parents:
diff changeset
563 void instanceKlass::init_implementor() {
a61af66fc99e Initial load
duke
parents:
diff changeset
564 for (int i = 0; i < implementors_limit; i++)
a61af66fc99e Initial load
duke
parents:
diff changeset
565 oop_store_without_check((oop*)&_implementors[i], NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
566 _nof_implementors = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
567 }
a61af66fc99e Initial load
duke
parents:
diff changeset
568
a61af66fc99e Initial load
duke
parents:
diff changeset
569
a61af66fc99e Initial load
duke
parents:
diff changeset
570 void instanceKlass::process_interfaces(Thread *thread) {
a61af66fc99e Initial load
duke
parents:
diff changeset
571 // link this class into the implementors list of every interface it implements
a61af66fc99e Initial load
duke
parents:
diff changeset
572 KlassHandle this_as_oop (thread, this->as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
573 for (int i = local_interfaces()->length() - 1; i >= 0; i--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
574 assert(local_interfaces()->obj_at(i)->is_klass(), "must be a klass");
a61af66fc99e Initial load
duke
parents:
diff changeset
575 instanceKlass* interf = instanceKlass::cast(klassOop(local_interfaces()->obj_at(i)));
a61af66fc99e Initial load
duke
parents:
diff changeset
576 assert(interf->is_interface(), "expected interface");
a61af66fc99e Initial load
duke
parents:
diff changeset
577 interf->add_implementor(this_as_oop());
a61af66fc99e Initial load
duke
parents:
diff changeset
578 }
a61af66fc99e Initial load
duke
parents:
diff changeset
579 }
a61af66fc99e Initial load
duke
parents:
diff changeset
580
a61af66fc99e Initial load
duke
parents:
diff changeset
581 bool instanceKlass::can_be_primary_super_slow() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
582 if (is_interface())
a61af66fc99e Initial load
duke
parents:
diff changeset
583 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
584 else
a61af66fc99e Initial load
duke
parents:
diff changeset
585 return Klass::can_be_primary_super_slow();
a61af66fc99e Initial load
duke
parents:
diff changeset
586 }
a61af66fc99e Initial load
duke
parents:
diff changeset
587
a61af66fc99e Initial load
duke
parents:
diff changeset
588 objArrayOop instanceKlass::compute_secondary_supers(int num_extra_slots, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
589 // The secondaries are the implemented interfaces.
a61af66fc99e Initial load
duke
parents:
diff changeset
590 instanceKlass* ik = instanceKlass::cast(as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
591 objArrayHandle interfaces (THREAD, ik->transitive_interfaces());
a61af66fc99e Initial load
duke
parents:
diff changeset
592 int num_secondaries = num_extra_slots + interfaces->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
593 if (num_secondaries == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
594 return Universe::the_empty_system_obj_array();
a61af66fc99e Initial load
duke
parents:
diff changeset
595 } else if (num_extra_slots == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
596 return interfaces();
a61af66fc99e Initial load
duke
parents:
diff changeset
597 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
598 // a mix of both
a61af66fc99e Initial load
duke
parents:
diff changeset
599 objArrayOop secondaries = oopFactory::new_system_objArray(num_secondaries, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
600 for (int i = 0; i < interfaces->length(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
601 secondaries->obj_at_put(num_extra_slots+i, interfaces->obj_at(i));
a61af66fc99e Initial load
duke
parents:
diff changeset
602 }
a61af66fc99e Initial load
duke
parents:
diff changeset
603 return secondaries;
a61af66fc99e Initial load
duke
parents:
diff changeset
604 }
a61af66fc99e Initial load
duke
parents:
diff changeset
605 }
a61af66fc99e Initial load
duke
parents:
diff changeset
606
a61af66fc99e Initial load
duke
parents:
diff changeset
607 bool instanceKlass::compute_is_subtype_of(klassOop k) {
a61af66fc99e Initial load
duke
parents:
diff changeset
608 if (Klass::cast(k)->is_interface()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
609 return implements_interface(k);
a61af66fc99e Initial load
duke
parents:
diff changeset
610 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
611 return Klass::compute_is_subtype_of(k);
a61af66fc99e Initial load
duke
parents:
diff changeset
612 }
a61af66fc99e Initial load
duke
parents:
diff changeset
613 }
a61af66fc99e Initial load
duke
parents:
diff changeset
614
a61af66fc99e Initial load
duke
parents:
diff changeset
615 bool instanceKlass::implements_interface(klassOop k) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
616 if (as_klassOop() == k) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
617 assert(Klass::cast(k)->is_interface(), "should be an interface class");
a61af66fc99e Initial load
duke
parents:
diff changeset
618 for (int i = 0; i < transitive_interfaces()->length(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
619 if (transitive_interfaces()->obj_at(i) == k) {
a61af66fc99e Initial load
duke
parents:
diff changeset
620 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
621 }
a61af66fc99e Initial load
duke
parents:
diff changeset
622 }
a61af66fc99e Initial load
duke
parents:
diff changeset
623 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
624 }
a61af66fc99e Initial load
duke
parents:
diff changeset
625
a61af66fc99e Initial load
duke
parents:
diff changeset
626 objArrayOop instanceKlass::allocate_objArray(int n, int length, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
627 if (length < 0) THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
a61af66fc99e Initial load
duke
parents:
diff changeset
628 if (length > arrayOopDesc::max_array_length(T_OBJECT)) {
876
1413494da700 6850957: Honor -XX:OnOutOfMemoryError when array size exceeds VM limit
martin
parents: 875
diff changeset
629 report_java_out_of_memory("Requested array size exceeds VM limit");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
630 THROW_OOP_0(Universe::out_of_memory_error_array_size());
a61af66fc99e Initial load
duke
parents:
diff changeset
631 }
a61af66fc99e Initial load
duke
parents:
diff changeset
632 int size = objArrayOopDesc::object_size(length);
a61af66fc99e Initial load
duke
parents:
diff changeset
633 klassOop ak = array_klass(n, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
634 KlassHandle h_ak (THREAD, ak);
a61af66fc99e Initial load
duke
parents:
diff changeset
635 objArrayOop o =
a61af66fc99e Initial load
duke
parents:
diff changeset
636 (objArrayOop)CollectedHeap::array_allocate(h_ak, size, length, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
637 return o;
a61af66fc99e Initial load
duke
parents:
diff changeset
638 }
a61af66fc99e Initial load
duke
parents:
diff changeset
639
a61af66fc99e Initial load
duke
parents:
diff changeset
640 instanceOop instanceKlass::register_finalizer(instanceOop i, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
641 if (TraceFinalizerRegistration) {
a61af66fc99e Initial load
duke
parents:
diff changeset
642 tty->print("Registered ");
a61af66fc99e Initial load
duke
parents:
diff changeset
643 i->print_value_on(tty);
a61af66fc99e Initial load
duke
parents:
diff changeset
644 tty->print_cr(" (" INTPTR_FORMAT ") as finalizable", (address)i);
a61af66fc99e Initial load
duke
parents:
diff changeset
645 }
a61af66fc99e Initial load
duke
parents:
diff changeset
646 instanceHandle h_i(THREAD, i);
a61af66fc99e Initial load
duke
parents:
diff changeset
647 // Pass the handle as argument, JavaCalls::call expects oop as jobjects
a61af66fc99e Initial load
duke
parents:
diff changeset
648 JavaValue result(T_VOID);
a61af66fc99e Initial load
duke
parents:
diff changeset
649 JavaCallArguments args(h_i);
a61af66fc99e Initial load
duke
parents:
diff changeset
650 methodHandle mh (THREAD, Universe::finalizer_register_method());
a61af66fc99e Initial load
duke
parents:
diff changeset
651 JavaCalls::call(&result, mh, &args, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
652 return h_i();
a61af66fc99e Initial load
duke
parents:
diff changeset
653 }
a61af66fc99e Initial load
duke
parents:
diff changeset
654
a61af66fc99e Initial load
duke
parents:
diff changeset
655 instanceOop instanceKlass::allocate_instance(TRAPS) {
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
656 assert(!oop_is_instanceMirror(), "wrong allocation path");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
657 bool has_finalizer_flag = has_finalizer(); // Query before possible GC
a61af66fc99e Initial load
duke
parents:
diff changeset
658 int size = size_helper(); // Query before forming handle.
a61af66fc99e Initial load
duke
parents:
diff changeset
659
a61af66fc99e Initial load
duke
parents:
diff changeset
660 KlassHandle h_k(THREAD, as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
661
a61af66fc99e Initial load
duke
parents:
diff changeset
662 instanceOop i;
a61af66fc99e Initial load
duke
parents:
diff changeset
663
a61af66fc99e Initial load
duke
parents:
diff changeset
664 i = (instanceOop)CollectedHeap::obj_allocate(h_k, size, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
665 if (has_finalizer_flag && !RegisterFinalizersAtInit) {
a61af66fc99e Initial load
duke
parents:
diff changeset
666 i = register_finalizer(i, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
667 }
a61af66fc99e Initial load
duke
parents:
diff changeset
668 return i;
a61af66fc99e Initial load
duke
parents:
diff changeset
669 }
a61af66fc99e Initial load
duke
parents:
diff changeset
670
a61af66fc99e Initial load
duke
parents:
diff changeset
671 instanceOop instanceKlass::allocate_permanent_instance(TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
672 // Finalizer registration occurs in the Object.<init> constructor
a61af66fc99e Initial load
duke
parents:
diff changeset
673 // and constructors normally aren't run when allocating perm
a61af66fc99e Initial load
duke
parents:
diff changeset
674 // instances so simply disallow finalizable perm objects. This can
a61af66fc99e Initial load
duke
parents:
diff changeset
675 // be relaxed if a need for it is found.
a61af66fc99e Initial load
duke
parents:
diff changeset
676 assert(!has_finalizer(), "perm objects not allowed to have finalizers");
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
677 assert(!oop_is_instanceMirror(), "wrong allocation path");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
678 int size = size_helper(); // Query before forming handle.
a61af66fc99e Initial load
duke
parents:
diff changeset
679 KlassHandle h_k(THREAD, as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
680 instanceOop i = (instanceOop)
a61af66fc99e Initial load
duke
parents:
diff changeset
681 CollectedHeap::permanent_obj_allocate(h_k, size, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
682 return i;
a61af66fc99e Initial load
duke
parents:
diff changeset
683 }
a61af66fc99e Initial load
duke
parents:
diff changeset
684
a61af66fc99e Initial load
duke
parents:
diff changeset
685 void instanceKlass::check_valid_for_instantiation(bool throwError, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
686 if (is_interface() || is_abstract()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
687 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
688 THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError()
a61af66fc99e Initial load
duke
parents:
diff changeset
689 : vmSymbols::java_lang_InstantiationException(), external_name());
a61af66fc99e Initial load
duke
parents:
diff changeset
690 }
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1039
diff changeset
691 if (as_klassOop() == SystemDictionary::Class_klass()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
692 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
693 THROW_MSG(throwError ? vmSymbols::java_lang_IllegalAccessError()
a61af66fc99e Initial load
duke
parents:
diff changeset
694 : vmSymbols::java_lang_IllegalAccessException(), external_name());
a61af66fc99e Initial load
duke
parents:
diff changeset
695 }
a61af66fc99e Initial load
duke
parents:
diff changeset
696 }
a61af66fc99e Initial load
duke
parents:
diff changeset
697
a61af66fc99e Initial load
duke
parents:
diff changeset
698 klassOop instanceKlass::array_klass_impl(bool or_null, int n, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
699 instanceKlassHandle this_oop(THREAD, as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
700 return array_klass_impl(this_oop, or_null, n, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
701 }
a61af66fc99e Initial load
duke
parents:
diff changeset
702
a61af66fc99e Initial load
duke
parents:
diff changeset
703 klassOop instanceKlass::array_klass_impl(instanceKlassHandle this_oop, bool or_null, int n, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
704 if (this_oop->array_klasses() == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
705 if (or_null) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
706
a61af66fc99e Initial load
duke
parents:
diff changeset
707 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
708 JavaThread *jt = (JavaThread *)THREAD;
a61af66fc99e Initial load
duke
parents:
diff changeset
709 {
a61af66fc99e Initial load
duke
parents:
diff changeset
710 // Atomic creation of array_klasses
a61af66fc99e Initial load
duke
parents:
diff changeset
711 MutexLocker mc(Compile_lock, THREAD); // for vtables
a61af66fc99e Initial load
duke
parents:
diff changeset
712 MutexLocker ma(MultiArray_lock, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
713
a61af66fc99e Initial load
duke
parents:
diff changeset
714 // Check if update has already taken place
a61af66fc99e Initial load
duke
parents:
diff changeset
715 if (this_oop->array_klasses() == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
716 objArrayKlassKlass* oakk =
a61af66fc99e Initial load
duke
parents:
diff changeset
717 (objArrayKlassKlass*)Universe::objArrayKlassKlassObj()->klass_part();
a61af66fc99e Initial load
duke
parents:
diff changeset
718
a61af66fc99e Initial load
duke
parents:
diff changeset
719 klassOop k = oakk->allocate_objArray_klass(1, this_oop, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
720 this_oop->set_array_klasses(k);
a61af66fc99e Initial load
duke
parents:
diff changeset
721 }
a61af66fc99e Initial load
duke
parents:
diff changeset
722 }
a61af66fc99e Initial load
duke
parents:
diff changeset
723 }
a61af66fc99e Initial load
duke
parents:
diff changeset
724 // _this will always be set at this point
a61af66fc99e Initial load
duke
parents:
diff changeset
725 objArrayKlass* oak = (objArrayKlass*)this_oop->array_klasses()->klass_part();
a61af66fc99e Initial load
duke
parents:
diff changeset
726 if (or_null) {
a61af66fc99e Initial load
duke
parents:
diff changeset
727 return oak->array_klass_or_null(n);
a61af66fc99e Initial load
duke
parents:
diff changeset
728 }
a61af66fc99e Initial load
duke
parents:
diff changeset
729 return oak->array_klass(n, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
730 }
a61af66fc99e Initial load
duke
parents:
diff changeset
731
a61af66fc99e Initial load
duke
parents:
diff changeset
732 klassOop instanceKlass::array_klass_impl(bool or_null, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
733 return array_klass_impl(or_null, 1, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
734 }
a61af66fc99e Initial load
duke
parents:
diff changeset
735
a61af66fc99e Initial load
duke
parents:
diff changeset
736 void instanceKlass::call_class_initializer(TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
737 instanceKlassHandle ik (THREAD, as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
738 call_class_initializer_impl(ik, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
739 }
a61af66fc99e Initial load
duke
parents:
diff changeset
740
a61af66fc99e Initial load
duke
parents:
diff changeset
741 static int call_class_initializer_impl_counter = 0; // for debugging
a61af66fc99e Initial load
duke
parents:
diff changeset
742
a61af66fc99e Initial load
duke
parents:
diff changeset
743 methodOop instanceKlass::class_initializer() {
2334
dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 2227
diff changeset
744 methodOop clinit = find_method(
dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 2227
diff changeset
745 vmSymbols::class_initializer_name(), vmSymbols::void_method_signature());
dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 2227
diff changeset
746 if (clinit != NULL && clinit->has_valid_initializer_flags()) {
dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 2227
diff changeset
747 return clinit;
dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 2227
diff changeset
748 }
dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents: 2227
diff changeset
749 return NULL;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
750 }
a61af66fc99e Initial load
duke
parents:
diff changeset
751
a61af66fc99e Initial load
duke
parents:
diff changeset
752 void instanceKlass::call_class_initializer_impl(instanceKlassHandle this_oop, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
753 methodHandle h_method(THREAD, this_oop->class_initializer());
a61af66fc99e Initial load
duke
parents:
diff changeset
754 assert(!this_oop->is_initialized(), "we cannot initialize twice");
a61af66fc99e Initial load
duke
parents:
diff changeset
755 if (TraceClassInitialization) {
a61af66fc99e Initial load
duke
parents:
diff changeset
756 tty->print("%d Initializing ", call_class_initializer_impl_counter++);
a61af66fc99e Initial load
duke
parents:
diff changeset
757 this_oop->name()->print_value();
a61af66fc99e Initial load
duke
parents:
diff changeset
758 tty->print_cr("%s (" INTPTR_FORMAT ")", h_method() == NULL ? "(no method)" : "", (address)this_oop());
a61af66fc99e Initial load
duke
parents:
diff changeset
759 }
a61af66fc99e Initial load
duke
parents:
diff changeset
760 if (h_method() != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
761 JavaCallArguments args; // No arguments
a61af66fc99e Initial load
duke
parents:
diff changeset
762 JavaValue result(T_VOID);
a61af66fc99e Initial load
duke
parents:
diff changeset
763 JavaCalls::call(&result, h_method, &args, CHECK); // Static call (no args)
a61af66fc99e Initial load
duke
parents:
diff changeset
764 }
a61af66fc99e Initial load
duke
parents:
diff changeset
765 }
a61af66fc99e Initial load
duke
parents:
diff changeset
766
a61af66fc99e Initial load
duke
parents:
diff changeset
767
a61af66fc99e Initial load
duke
parents:
diff changeset
768 void instanceKlass::mask_for(methodHandle method, int bci,
a61af66fc99e Initial load
duke
parents:
diff changeset
769 InterpreterOopMap* entry_for) {
a61af66fc99e Initial load
duke
parents:
diff changeset
770 // Dirty read, then double-check under a lock.
a61af66fc99e Initial load
duke
parents:
diff changeset
771 if (_oop_map_cache == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
772 // Otherwise, allocate a new one.
a61af66fc99e Initial load
duke
parents:
diff changeset
773 MutexLocker x(OopMapCacheAlloc_lock);
a61af66fc99e Initial load
duke
parents:
diff changeset
774 // First time use. Allocate a cache in C heap
a61af66fc99e Initial load
duke
parents:
diff changeset
775 if (_oop_map_cache == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
776 _oop_map_cache = new OopMapCache();
a61af66fc99e Initial load
duke
parents:
diff changeset
777 }
a61af66fc99e Initial load
duke
parents:
diff changeset
778 }
a61af66fc99e Initial load
duke
parents:
diff changeset
779 // _oop_map_cache is constant after init; lookup below does is own locking.
a61af66fc99e Initial load
duke
parents:
diff changeset
780 _oop_map_cache->lookup(method, bci, entry_for);
a61af66fc99e Initial load
duke
parents:
diff changeset
781 }
a61af66fc99e Initial load
duke
parents:
diff changeset
782
a61af66fc99e Initial load
duke
parents:
diff changeset
783
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
784 bool instanceKlass::find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
785 const int n = fields()->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
786 for (int i = 0; i < n; i += next_offset ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
787 int name_index = fields()->ushort_at(i + name_index_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
788 int sig_index = fields()->ushort_at(i + signature_index_offset);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
789 Symbol* f_name = constants()->symbol_at(name_index);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
790 Symbol* f_sig = constants()->symbol_at(sig_index);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
791 if (f_name == name && f_sig == sig) {
a61af66fc99e Initial load
duke
parents:
diff changeset
792 fd->initialize(as_klassOop(), i);
a61af66fc99e Initial load
duke
parents:
diff changeset
793 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
794 }
a61af66fc99e Initial load
duke
parents:
diff changeset
795 }
a61af66fc99e Initial load
duke
parents:
diff changeset
796 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
797 }
a61af66fc99e Initial load
duke
parents:
diff changeset
798
a61af66fc99e Initial load
duke
parents:
diff changeset
799
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
800 void instanceKlass::shared_symbols_iterate(SymbolClosure* closure) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
801 Klass::shared_symbols_iterate(closure);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
802 closure->do_symbol(&_generic_signature);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
803 closure->do_symbol(&_source_file_name);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
804 closure->do_symbol(&_source_debug_extension);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
805
0
a61af66fc99e Initial load
duke
parents:
diff changeset
806 const int n = fields()->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
807 for (int i = 0; i < n; i += next_offset ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
808 int name_index = fields()->ushort_at(i + name_index_offset);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
809 closure->do_symbol(constants()->symbol_at_addr(name_index));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
810 int sig_index = fields()->ushort_at(i + signature_index_offset);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
811 closure->do_symbol(constants()->symbol_at_addr(sig_index));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
812 }
a61af66fc99e Initial load
duke
parents:
diff changeset
813 }
a61af66fc99e Initial load
duke
parents:
diff changeset
814
a61af66fc99e Initial load
duke
parents:
diff changeset
815
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
816 klassOop instanceKlass::find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
817 const int n = local_interfaces()->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
818 for (int i = 0; i < n; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
819 klassOop intf1 = klassOop(local_interfaces()->obj_at(i));
a61af66fc99e Initial load
duke
parents:
diff changeset
820 assert(Klass::cast(intf1)->is_interface(), "just checking type");
a61af66fc99e Initial load
duke
parents:
diff changeset
821 // search for field in current interface
a61af66fc99e Initial load
duke
parents:
diff changeset
822 if (instanceKlass::cast(intf1)->find_local_field(name, sig, fd)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
823 assert(fd->is_static(), "interface field must be static");
a61af66fc99e Initial load
duke
parents:
diff changeset
824 return intf1;
a61af66fc99e Initial load
duke
parents:
diff changeset
825 }
a61af66fc99e Initial load
duke
parents:
diff changeset
826 // search for field in direct superinterfaces
a61af66fc99e Initial load
duke
parents:
diff changeset
827 klassOop intf2 = instanceKlass::cast(intf1)->find_interface_field(name, sig, fd);
a61af66fc99e Initial load
duke
parents:
diff changeset
828 if (intf2 != NULL) return intf2;
a61af66fc99e Initial load
duke
parents:
diff changeset
829 }
a61af66fc99e Initial load
duke
parents:
diff changeset
830 // otherwise field lookup fails
a61af66fc99e Initial load
duke
parents:
diff changeset
831 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
832 }
a61af66fc99e Initial load
duke
parents:
diff changeset
833
a61af66fc99e Initial load
duke
parents:
diff changeset
834
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
835 klassOop instanceKlass::find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
836 // search order according to newest JVM spec (5.4.3.2, p.167).
a61af66fc99e Initial load
duke
parents:
diff changeset
837 // 1) search for field in current klass
a61af66fc99e Initial load
duke
parents:
diff changeset
838 if (find_local_field(name, sig, fd)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
839 return as_klassOop();
a61af66fc99e Initial load
duke
parents:
diff changeset
840 }
a61af66fc99e Initial load
duke
parents:
diff changeset
841 // 2) search for field recursively in direct superinterfaces
a61af66fc99e Initial load
duke
parents:
diff changeset
842 { klassOop intf = find_interface_field(name, sig, fd);
a61af66fc99e Initial load
duke
parents:
diff changeset
843 if (intf != NULL) return intf;
a61af66fc99e Initial load
duke
parents:
diff changeset
844 }
a61af66fc99e Initial load
duke
parents:
diff changeset
845 // 3) apply field lookup recursively if superclass exists
a61af66fc99e Initial load
duke
parents:
diff changeset
846 { klassOop supr = super();
a61af66fc99e Initial load
duke
parents:
diff changeset
847 if (supr != NULL) return instanceKlass::cast(supr)->find_field(name, sig, fd);
a61af66fc99e Initial load
duke
parents:
diff changeset
848 }
a61af66fc99e Initial load
duke
parents:
diff changeset
849 // 4) otherwise field lookup fails
a61af66fc99e Initial load
duke
parents:
diff changeset
850 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
851 }
a61af66fc99e Initial load
duke
parents:
diff changeset
852
a61af66fc99e Initial load
duke
parents:
diff changeset
853
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
854 klassOop instanceKlass::find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
855 // search order according to newest JVM spec (5.4.3.2, p.167).
a61af66fc99e Initial load
duke
parents:
diff changeset
856 // 1) search for field in current klass
a61af66fc99e Initial load
duke
parents:
diff changeset
857 if (find_local_field(name, sig, fd)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
858 if (fd->is_static() == is_static) return as_klassOop();
a61af66fc99e Initial load
duke
parents:
diff changeset
859 }
a61af66fc99e Initial load
duke
parents:
diff changeset
860 // 2) search for field recursively in direct superinterfaces
a61af66fc99e Initial load
duke
parents:
diff changeset
861 if (is_static) {
a61af66fc99e Initial load
duke
parents:
diff changeset
862 klassOop intf = find_interface_field(name, sig, fd);
a61af66fc99e Initial load
duke
parents:
diff changeset
863 if (intf != NULL) return intf;
a61af66fc99e Initial load
duke
parents:
diff changeset
864 }
a61af66fc99e Initial load
duke
parents:
diff changeset
865 // 3) apply field lookup recursively if superclass exists
a61af66fc99e Initial load
duke
parents:
diff changeset
866 { klassOop supr = super();
a61af66fc99e Initial load
duke
parents:
diff changeset
867 if (supr != NULL) return instanceKlass::cast(supr)->find_field(name, sig, is_static, fd);
a61af66fc99e Initial load
duke
parents:
diff changeset
868 }
a61af66fc99e Initial load
duke
parents:
diff changeset
869 // 4) otherwise field lookup fails
a61af66fc99e Initial load
duke
parents:
diff changeset
870 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
871 }
a61af66fc99e Initial load
duke
parents:
diff changeset
872
a61af66fc99e Initial load
duke
parents:
diff changeset
873
a61af66fc99e Initial load
duke
parents:
diff changeset
874 bool instanceKlass::find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
875 int length = fields()->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
876 for (int i = 0; i < length; i += next_offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
877 if (offset_from_fields( i ) == offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
878 fd->initialize(as_klassOop(), i);
a61af66fc99e Initial load
duke
parents:
diff changeset
879 if (fd->is_static() == is_static) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
880 }
a61af66fc99e Initial load
duke
parents:
diff changeset
881 }
a61af66fc99e Initial load
duke
parents:
diff changeset
882 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
883 }
a61af66fc99e Initial load
duke
parents:
diff changeset
884
a61af66fc99e Initial load
duke
parents:
diff changeset
885
a61af66fc99e Initial load
duke
parents:
diff changeset
886 bool instanceKlass::find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
887 klassOop klass = as_klassOop();
a61af66fc99e Initial load
duke
parents:
diff changeset
888 while (klass != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
889 if (instanceKlass::cast(klass)->find_local_field_from_offset(offset, is_static, fd)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
890 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
891 }
a61af66fc99e Initial load
duke
parents:
diff changeset
892 klass = Klass::cast(klass)->super();
a61af66fc99e Initial load
duke
parents:
diff changeset
893 }
a61af66fc99e Initial load
duke
parents:
diff changeset
894 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
895 }
a61af66fc99e Initial load
duke
parents:
diff changeset
896
a61af66fc99e Initial load
duke
parents:
diff changeset
897
a61af66fc99e Initial load
duke
parents:
diff changeset
898 void instanceKlass::methods_do(void f(methodOop method)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
899 int len = methods()->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
900 for (int index = 0; index < len; index++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
901 methodOop m = methodOop(methods()->obj_at(index));
a61af66fc99e Initial load
duke
parents:
diff changeset
902 assert(m->is_method(), "must be method");
a61af66fc99e Initial load
duke
parents:
diff changeset
903 f(m);
a61af66fc99e Initial load
duke
parents:
diff changeset
904 }
a61af66fc99e Initial load
duke
parents:
diff changeset
905 }
a61af66fc99e Initial load
duke
parents:
diff changeset
906
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
907
0
a61af66fc99e Initial load
duke
parents:
diff changeset
908 void instanceKlass::do_local_static_fields(FieldClosure* cl) {
a61af66fc99e Initial load
duke
parents:
diff changeset
909 fieldDescriptor fd;
a61af66fc99e Initial load
duke
parents:
diff changeset
910 int length = fields()->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
911 for (int i = 0; i < length; i += next_offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
912 fd.initialize(as_klassOop(), i);
a61af66fc99e Initial load
duke
parents:
diff changeset
913 if (fd.is_static()) cl->do_field(&fd);
a61af66fc99e Initial load
duke
parents:
diff changeset
914 }
a61af66fc99e Initial load
duke
parents:
diff changeset
915 }
a61af66fc99e Initial load
duke
parents:
diff changeset
916
a61af66fc99e Initial load
duke
parents:
diff changeset
917
a61af66fc99e Initial load
duke
parents:
diff changeset
918 void instanceKlass::do_local_static_fields(void f(fieldDescriptor*, TRAPS), TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
919 instanceKlassHandle h_this(THREAD, as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
920 do_local_static_fields_impl(h_this, f, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
921 }
a61af66fc99e Initial load
duke
parents:
diff changeset
922
a61af66fc99e Initial load
duke
parents:
diff changeset
923
a61af66fc99e Initial load
duke
parents:
diff changeset
924 void instanceKlass::do_local_static_fields_impl(instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
925 fieldDescriptor fd;
a61af66fc99e Initial load
duke
parents:
diff changeset
926 int length = this_oop->fields()->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
927 for (int i = 0; i < length; i += next_offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
928 fd.initialize(this_oop(), i);
a61af66fc99e Initial load
duke
parents:
diff changeset
929 if (fd.is_static()) { f(&fd, CHECK); } // Do NOT remove {}! (CHECK macro expands into several statements)
a61af66fc99e Initial load
duke
parents:
diff changeset
930 }
a61af66fc99e Initial load
duke
parents:
diff changeset
931 }
a61af66fc99e Initial load
duke
parents:
diff changeset
932
a61af66fc99e Initial load
duke
parents:
diff changeset
933
44
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
934 static int compare_fields_by_offset(int* a, int* b) {
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
935 return a[0] - b[0];
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
936 }
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
937
0
a61af66fc99e Initial load
duke
parents:
diff changeset
938 void instanceKlass::do_nonstatic_fields(FieldClosure* cl) {
a61af66fc99e Initial load
duke
parents:
diff changeset
939 instanceKlass* super = superklass();
a61af66fc99e Initial load
duke
parents:
diff changeset
940 if (super != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
941 super->do_nonstatic_fields(cl);
a61af66fc99e Initial load
duke
parents:
diff changeset
942 }
44
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
943 fieldDescriptor fd;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
944 int length = fields()->length();
44
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
945 // In DebugInfo nonstatic fields are sorted by offset.
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
946 int* fields_sorted = NEW_C_HEAP_ARRAY(int, 2*(length+1));
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
947 int j = 0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
948 for (int i = 0; i < length; i += next_offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
949 fd.initialize(as_klassOop(), i);
44
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
950 if (!fd.is_static()) {
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
951 fields_sorted[j + 0] = fd.offset();
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
952 fields_sorted[j + 1] = i;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
953 j += 2;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
954 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
955 }
44
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
956 if (j > 0) {
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
957 length = j;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
958 // _sort_Fn is defined in growableArray.hpp.
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
959 qsort(fields_sorted, length/2, 2*sizeof(int), (_sort_Fn)compare_fields_by_offset);
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
960 for (int i = 0; i < length; i += 2) {
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
961 fd.initialize(as_klassOop(), fields_sorted[i + 1]);
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
962 assert(!fd.is_static() && fd.offset() == fields_sorted[i], "only nonstatic fields");
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
963 cl->do_field(&fd);
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
964 }
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
965 }
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents: 0
diff changeset
966 FREE_C_HEAP_ARRAY(int, fields_sorted);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
967 }
a61af66fc99e Initial load
duke
parents:
diff changeset
968
a61af66fc99e Initial load
duke
parents:
diff changeset
969
a61af66fc99e Initial load
duke
parents:
diff changeset
970 void instanceKlass::array_klasses_do(void f(klassOop k)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
971 if (array_klasses() != NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
972 arrayKlass::cast(array_klasses())->array_klasses_do(f);
a61af66fc99e Initial load
duke
parents:
diff changeset
973 }
a61af66fc99e Initial load
duke
parents:
diff changeset
974
a61af66fc99e Initial load
duke
parents:
diff changeset
975
a61af66fc99e Initial load
duke
parents:
diff changeset
976 void instanceKlass::with_array_klasses_do(void f(klassOop k)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
977 f(as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
978 array_klasses_do(f);
a61af66fc99e Initial load
duke
parents:
diff changeset
979 }
a61af66fc99e Initial load
duke
parents:
diff changeset
980
a61af66fc99e Initial load
duke
parents:
diff changeset
981 #ifdef ASSERT
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
982 static int linear_search(objArrayOop methods, Symbol* name, Symbol* signature) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
983 int len = methods->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
984 for (int index = 0; index < len; index++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
985 methodOop m = (methodOop)(methods->obj_at(index));
a61af66fc99e Initial load
duke
parents:
diff changeset
986 assert(m->is_method(), "must be method");
a61af66fc99e Initial load
duke
parents:
diff changeset
987 if (m->signature() == signature && m->name() == name) {
a61af66fc99e Initial load
duke
parents:
diff changeset
988 return index;
a61af66fc99e Initial load
duke
parents:
diff changeset
989 }
a61af66fc99e Initial load
duke
parents:
diff changeset
990 }
a61af66fc99e Initial load
duke
parents:
diff changeset
991 return -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
992 }
a61af66fc99e Initial load
duke
parents:
diff changeset
993 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
994
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
995 methodOop instanceKlass::find_method(Symbol* name, Symbol* signature) const {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
996 return instanceKlass::find_method(methods(), name, signature);
a61af66fc99e Initial load
duke
parents:
diff changeset
997 }
a61af66fc99e Initial load
duke
parents:
diff changeset
998
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
999 methodOop instanceKlass::find_method(objArrayOop methods, Symbol* name, Symbol* signature) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1000 int len = methods->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
1001 // methods are sorted, so do binary search
a61af66fc99e Initial load
duke
parents:
diff changeset
1002 int l = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1003 int h = len - 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
1004 while (l <= h) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1005 int mid = (l + h) >> 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
1006 methodOop m = (methodOop)methods->obj_at(mid);
a61af66fc99e Initial load
duke
parents:
diff changeset
1007 assert(m->is_method(), "must be method");
a61af66fc99e Initial load
duke
parents:
diff changeset
1008 int res = m->name()->fast_compare(name);
a61af66fc99e Initial load
duke
parents:
diff changeset
1009 if (res == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1010 // found matching name; do linear search to find matching signature
a61af66fc99e Initial load
duke
parents:
diff changeset
1011 // first, quick check for common case
a61af66fc99e Initial load
duke
parents:
diff changeset
1012 if (m->signature() == signature) return m;
a61af66fc99e Initial load
duke
parents:
diff changeset
1013 // search downwards through overloaded methods
a61af66fc99e Initial load
duke
parents:
diff changeset
1014 int i;
a61af66fc99e Initial load
duke
parents:
diff changeset
1015 for (i = mid - 1; i >= l; i--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1016 methodOop m = (methodOop)methods->obj_at(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
1017 assert(m->is_method(), "must be method");
a61af66fc99e Initial load
duke
parents:
diff changeset
1018 if (m->name() != name) break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1019 if (m->signature() == signature) return m;
a61af66fc99e Initial load
duke
parents:
diff changeset
1020 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1021 // search upwards
a61af66fc99e Initial load
duke
parents:
diff changeset
1022 for (i = mid + 1; i <= h; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1023 methodOop m = (methodOop)methods->obj_at(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
1024 assert(m->is_method(), "must be method");
a61af66fc99e Initial load
duke
parents:
diff changeset
1025 if (m->name() != name) break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1026 if (m->signature() == signature) return m;
a61af66fc99e Initial load
duke
parents:
diff changeset
1027 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1028 // not found
a61af66fc99e Initial load
duke
parents:
diff changeset
1029 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
1030 int index = linear_search(methods, name, signature);
1490
f03d0a26bf83 6888954: argument formatting for assert() and friends
jcoomes
parents: 1324
diff changeset
1031 assert(index == -1, err_msg("binary search should have found entry %d", index));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1032 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
1033 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1034 } else if (res < 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1035 l = mid + 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
1036 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1037 h = mid - 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
1038 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1039 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1040 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
1041 int index = linear_search(methods, name, signature);
1490
f03d0a26bf83 6888954: argument formatting for assert() and friends
jcoomes
parents: 1324
diff changeset
1042 assert(index == -1, err_msg("binary search should have found entry %d", index));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1043 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
1044 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1045 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1046
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1047 methodOop instanceKlass::uncached_lookup_method(Symbol* name, Symbol* signature) const {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1048 klassOop klass = as_klassOop();
a61af66fc99e Initial load
duke
parents:
diff changeset
1049 while (klass != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1050 methodOop method = instanceKlass::cast(klass)->find_method(name, signature);
a61af66fc99e Initial load
duke
parents:
diff changeset
1051 if (method != NULL) return method;
a61af66fc99e Initial load
duke
parents:
diff changeset
1052 klass = instanceKlass::cast(klass)->super();
a61af66fc99e Initial load
duke
parents:
diff changeset
1053 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1054 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1055 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1056
a61af66fc99e Initial load
duke
parents:
diff changeset
1057 // lookup a method in all the interfaces that this class implements
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1058 methodOop instanceKlass::lookup_method_in_all_interfaces(Symbol* name,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1059 Symbol* signature) const {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1060 objArrayOop all_ifs = instanceKlass::cast(as_klassOop())->transitive_interfaces();
a61af66fc99e Initial load
duke
parents:
diff changeset
1061 int num_ifs = all_ifs->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
1062 instanceKlass *ik = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1063 for (int i = 0; i < num_ifs; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1064 ik = instanceKlass::cast(klassOop(all_ifs->obj_at(i)));
a61af66fc99e Initial load
duke
parents:
diff changeset
1065 methodOop m = ik->lookup_method(name, signature);
a61af66fc99e Initial load
duke
parents:
diff changeset
1066 if (m != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1067 return m;
a61af66fc99e Initial load
duke
parents:
diff changeset
1068 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1069 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1070 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1071 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1072
a61af66fc99e Initial load
duke
parents:
diff changeset
1073 /* jni_id_for_impl for jfieldIds only */
a61af66fc99e Initial load
duke
parents:
diff changeset
1074 JNIid* instanceKlass::jni_id_for_impl(instanceKlassHandle this_oop, int offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1075 MutexLocker ml(JfieldIdCreation_lock);
a61af66fc99e Initial load
duke
parents:
diff changeset
1076 // Retry lookup after we got the lock
a61af66fc99e Initial load
duke
parents:
diff changeset
1077 JNIid* probe = this_oop->jni_ids() == NULL ? NULL : this_oop->jni_ids()->find(offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
1078 if (probe == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1079 // Slow case, allocate new static field identifier
a61af66fc99e Initial load
duke
parents:
diff changeset
1080 probe = new JNIid(this_oop->as_klassOop(), offset, this_oop->jni_ids());
a61af66fc99e Initial load
duke
parents:
diff changeset
1081 this_oop->set_jni_ids(probe);
a61af66fc99e Initial load
duke
parents:
diff changeset
1082 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1083 return probe;
a61af66fc99e Initial load
duke
parents:
diff changeset
1084 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1085
a61af66fc99e Initial load
duke
parents:
diff changeset
1086
a61af66fc99e Initial load
duke
parents:
diff changeset
1087 /* jni_id_for for jfieldIds only */
a61af66fc99e Initial load
duke
parents:
diff changeset
1088 JNIid* instanceKlass::jni_id_for(int offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1089 JNIid* probe = jni_ids() == NULL ? NULL : jni_ids()->find(offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
1090 if (probe == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1091 probe = jni_id_for_impl(this->as_klassOop(), offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
1092 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1093 return probe;
a61af66fc99e Initial load
duke
parents:
diff changeset
1094 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1095
a61af66fc99e Initial load
duke
parents:
diff changeset
1096
a61af66fc99e Initial load
duke
parents:
diff changeset
1097 // Lookup or create a jmethodID.
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1098 // This code is called by the VMThread and JavaThreads so the
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1099 // locking has to be done very carefully to avoid deadlocks
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1100 // and/or other cache consistency problems.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1101 //
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1102 jmethodID instanceKlass::get_jmethod_id(instanceKlassHandle ik_h, methodHandle method_h) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1103 size_t idnum = (size_t)method_h->method_idnum();
a61af66fc99e Initial load
duke
parents:
diff changeset
1104 jmethodID* jmeths = ik_h->methods_jmethod_ids_acquire();
a61af66fc99e Initial load
duke
parents:
diff changeset
1105 size_t length = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1106 jmethodID id = NULL;
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1107
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1108 // We use a double-check locking idiom here because this cache is
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1109 // performance sensitive. In the normal system, this cache only
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1110 // transitions from NULL to non-NULL which is safe because we use
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1111 // release_set_methods_jmethod_ids() to advertise the new cache.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1112 // A partially constructed cache should never be seen by a racing
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1113 // thread. We also use release_store_ptr() to save a new jmethodID
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1114 // in the cache so a partially constructed jmethodID should never be
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1115 // seen either. Cache reads of existing jmethodIDs proceed without a
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1116 // lock, but cache writes of a new jmethodID requires uniqueness and
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1117 // creation of the cache itself requires no leaks so a lock is
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1118 // generally acquired in those two cases.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1119 //
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1120 // If the RedefineClasses() API has been used, then this cache can
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1121 // grow and we'll have transitions from non-NULL to bigger non-NULL.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1122 // Cache creation requires no leaks and we require safety between all
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1123 // cache accesses and freeing of the old cache so a lock is generally
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1124 // acquired when the RedefineClasses() API has been used.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1125
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1126 if (jmeths != NULL) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1127 // the cache already exists
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1128 if (!ik_h->idnum_can_increment()) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1129 // the cache can't grow so we can just get the current values
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1130 get_jmethod_id_length_value(jmeths, idnum, &length, &id);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1131 } else {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1132 // cache can grow so we have to be more careful
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1133 if (Threads::number_of_threads() == 0 ||
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1134 SafepointSynchronize::is_at_safepoint()) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1135 // we're single threaded or at a safepoint - no locking needed
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1136 get_jmethod_id_length_value(jmeths, idnum, &length, &id);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1137 } else {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1138 MutexLocker ml(JmethodIdCreation_lock);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1139 get_jmethod_id_length_value(jmeths, idnum, &length, &id);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1140 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1141 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1142 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1143 // implied else:
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1144 // we need to allocate a cache so default length and id values are good
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1145
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1146 if (jmeths == NULL || // no cache yet
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1147 length <= idnum || // cache is too short
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1148 id == NULL) { // cache doesn't contain entry
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1149
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1150 // This function can be called by the VMThread so we have to do all
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1151 // things that might block on a safepoint before grabbing the lock.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1152 // Otherwise, we can deadlock with the VMThread or have a cache
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1153 // consistency issue. These vars keep track of what we might have
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1154 // to free after the lock is dropped.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1155 jmethodID to_dealloc_id = NULL;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1156 jmethodID* to_dealloc_jmeths = NULL;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1157
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1158 // may not allocate new_jmeths or use it if we allocate it
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1159 jmethodID* new_jmeths = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1160 if (length <= idnum) {
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1161 // allocate a new cache that might be used
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1162 size_t size = MAX2(idnum+1, (size_t)ik_h->idnum_allocated_count());
a61af66fc99e Initial load
duke
parents:
diff changeset
1163 new_jmeths = NEW_C_HEAP_ARRAY(jmethodID, size+1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1164 memset(new_jmeths, 0, (size+1)*sizeof(jmethodID));
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1165 // cache size is stored in element[0], other elements offset by one
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1166 new_jmeths[0] = (jmethodID)size;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1167 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1168
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1169 // allocate a new jmethodID that might be used
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1170 jmethodID new_id = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1171 if (method_h->is_old() && !method_h->is_obsolete()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1172 // The method passed in is old (but not obsolete), we need to use the current version
a61af66fc99e Initial load
duke
parents:
diff changeset
1173 methodOop current_method = ik_h->method_with_idnum((int)idnum);
a61af66fc99e Initial load
duke
parents:
diff changeset
1174 assert(current_method != NULL, "old and but not obsolete, so should exist");
a61af66fc99e Initial load
duke
parents:
diff changeset
1175 methodHandle current_method_h(current_method == NULL? method_h() : current_method);
a61af66fc99e Initial load
duke
parents:
diff changeset
1176 new_id = JNIHandles::make_jmethod_id(current_method_h);
a61af66fc99e Initial load
duke
parents:
diff changeset
1177 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1178 // It is the current version of the method or an obsolete method,
a61af66fc99e Initial load
duke
parents:
diff changeset
1179 // use the version passed in
a61af66fc99e Initial load
duke
parents:
diff changeset
1180 new_id = JNIHandles::make_jmethod_id(method_h);
a61af66fc99e Initial load
duke
parents:
diff changeset
1181 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1182
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1183 if (Threads::number_of_threads() == 0 ||
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1184 SafepointSynchronize::is_at_safepoint()) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1185 // we're single threaded or at a safepoint - no locking needed
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1186 id = get_jmethod_id_fetch_or_update(ik_h, idnum, new_id, new_jmeths,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1187 &to_dealloc_id, &to_dealloc_jmeths);
49
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1188 } else {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1189 MutexLocker ml(JmethodIdCreation_lock);
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1190 id = get_jmethod_id_fetch_or_update(ik_h, idnum, new_id, new_jmeths,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1191 &to_dealloc_id, &to_dealloc_jmeths);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1192 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1193
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1194 // The lock has been dropped so we can free resources.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1195 // Free up either the old cache or the new cache if we allocated one.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1196 if (to_dealloc_jmeths != NULL) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1197 FreeHeap(to_dealloc_jmeths);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1198 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1199 // free up the new ID since it wasn't needed
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1200 if (to_dealloc_id != NULL) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1201 JNIHandles::destroy_jmethod_id(to_dealloc_id);
49
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1202 }
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1203 }
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1204 return id;
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1205 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1206
49
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1207
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1208 // Common code to fetch the jmethodID from the cache or update the
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1209 // cache with the new jmethodID. This function should never do anything
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1210 // that causes the caller to go to a safepoint or we can deadlock with
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1211 // the VMThread or have cache consistency issues.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1212 //
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1213 jmethodID instanceKlass::get_jmethod_id_fetch_or_update(
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1214 instanceKlassHandle ik_h, size_t idnum, jmethodID new_id,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1215 jmethodID* new_jmeths, jmethodID* to_dealloc_id_p,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1216 jmethodID** to_dealloc_jmeths_p) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1217 assert(new_id != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1218 assert(to_dealloc_id_p != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1219 assert(to_dealloc_jmeths_p != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1220 assert(Threads::number_of_threads() == 0 ||
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1221 SafepointSynchronize::is_at_safepoint() ||
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1222 JmethodIdCreation_lock->owned_by_self(), "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1223
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1224 // reacquire the cache - we are locked, single threaded or at a safepoint
49
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1225 jmethodID* jmeths = ik_h->methods_jmethod_ids_acquire();
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1226 jmethodID id = NULL;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1227 size_t length = 0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1228
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1229 if (jmeths == NULL || // no cache yet
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1230 (length = (size_t)jmeths[0]) <= idnum) { // cache is too short
49
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1231 if (jmeths != NULL) {
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1232 // copy any existing entries from the old cache
49
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1233 for (size_t index = 0; index < length; index++) {
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1234 new_jmeths[index+1] = jmeths[index+1];
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1235 }
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1236 *to_dealloc_jmeths_p = jmeths; // save old cache for later delete
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1237 }
49
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1238 ik_h->release_set_methods_jmethod_ids(jmeths = new_jmeths);
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1239 } else {
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1240 // fetch jmethodID (if any) from the existing cache
49
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1241 id = jmeths[idnum+1];
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1242 *to_dealloc_jmeths_p = new_jmeths; // save new cache for later delete
49
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1243 }
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1244 if (id == NULL) {
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1245 // No matching jmethodID in the existing cache or we have a new
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1246 // cache or we just grew the cache. This cache write is done here
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1247 // by the first thread to win the foot race because a jmethodID
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1248 // needs to be unique once it is generally available.
49
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1249 id = new_id;
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1250
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1251 // The jmethodID cache can be read while unlocked so we have to
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1252 // make sure the new jmethodID is complete before installing it
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1253 // in the cache.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1254 OrderAccess::release_store_ptr(&jmeths[idnum+1], id);
49
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents: 47
diff changeset
1255 } else {
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1256 *to_dealloc_id_p = new_id; // save new id for later delete
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1257 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1258 return id;
a61af66fc99e Initial load
duke
parents:
diff changeset
1259 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1260
a61af66fc99e Initial load
duke
parents:
diff changeset
1261
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1262 // Common code to get the jmethodID cache length and the jmethodID
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1263 // value at index idnum if there is one.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1264 //
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1265 void instanceKlass::get_jmethod_id_length_value(jmethodID* cache,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1266 size_t idnum, size_t *length_p, jmethodID* id_p) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1267 assert(cache != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1268 assert(length_p != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1269 assert(id_p != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1270
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1271 // cache size is stored in element[0], other elements offset by one
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1272 *length_p = (size_t)cache[0];
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1273 if (*length_p <= idnum) { // cache is too short
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1274 *id_p = NULL;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1275 } else {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1276 *id_p = cache[idnum+1]; // fetch jmethodID (if any)
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1277 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1278 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1279
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1280
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1281 // Lookup a jmethodID, NULL if not found. Do no blocking, no allocations, no handles
a61af66fc99e Initial load
duke
parents:
diff changeset
1282 jmethodID instanceKlass::jmethod_id_or_null(methodOop method) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1283 size_t idnum = (size_t)method->method_idnum();
a61af66fc99e Initial load
duke
parents:
diff changeset
1284 jmethodID* jmeths = methods_jmethod_ids_acquire();
a61af66fc99e Initial load
duke
parents:
diff changeset
1285 size_t length; // length assigned as debugging crumb
a61af66fc99e Initial load
duke
parents:
diff changeset
1286 jmethodID id = NULL;
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1287 if (jmeths != NULL && // If there is a cache
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1288 (length = (size_t)jmeths[0]) > idnum) { // and if it is long enough,
a61af66fc99e Initial load
duke
parents:
diff changeset
1289 id = jmeths[idnum+1]; // Look up the id (may be NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
1290 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1291 return id;
a61af66fc99e Initial load
duke
parents:
diff changeset
1292 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1293
a61af66fc99e Initial load
duke
parents:
diff changeset
1294
a61af66fc99e Initial load
duke
parents:
diff changeset
1295 // Cache an itable index
a61af66fc99e Initial load
duke
parents:
diff changeset
1296 void instanceKlass::set_cached_itable_index(size_t idnum, int index) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1297 int* indices = methods_cached_itable_indices_acquire();
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1298 int* to_dealloc_indices = NULL;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1299
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1300 // We use a double-check locking idiom here because this cache is
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1301 // performance sensitive. In the normal system, this cache only
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1302 // transitions from NULL to non-NULL which is safe because we use
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1303 // release_set_methods_cached_itable_indices() to advertise the
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1304 // new cache. A partially constructed cache should never be seen
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1305 // by a racing thread. Cache reads and writes proceed without a
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1306 // lock, but creation of the cache itself requires no leaks so a
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1307 // lock is generally acquired in that case.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1308 //
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1309 // If the RedefineClasses() API has been used, then this cache can
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1310 // grow and we'll have transitions from non-NULL to bigger non-NULL.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1311 // Cache creation requires no leaks and we require safety between all
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1312 // cache accesses and freeing of the old cache so a lock is generally
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1313 // acquired when the RedefineClasses() API has been used.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1314
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1315 if (indices == NULL || idnum_can_increment()) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1316 // we need a cache or the cache can grow
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1317 MutexLocker ml(JNICachedItableIndex_lock);
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1318 // reacquire the cache to see if another thread already did the work
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1319 indices = methods_cached_itable_indices_acquire();
a61af66fc99e Initial load
duke
parents:
diff changeset
1320 size_t length = 0;
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1321 // cache size is stored in element[0], other elements offset by one
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1322 if (indices == NULL || (length = (size_t)indices[0]) <= idnum) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1323 size_t size = MAX2(idnum+1, (size_t)idnum_allocated_count());
a61af66fc99e Initial load
duke
parents:
diff changeset
1324 int* new_indices = NEW_C_HEAP_ARRAY(int, size+1);
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1325 new_indices[0] = (int)size;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1326 // copy any existing entries
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1327 size_t i;
a61af66fc99e Initial load
duke
parents:
diff changeset
1328 for (i = 0; i < length; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1329 new_indices[i+1] = indices[i+1];
a61af66fc99e Initial load
duke
parents:
diff changeset
1330 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1331 // Set all the rest to -1
a61af66fc99e Initial load
duke
parents:
diff changeset
1332 for (i = length; i < size; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1333 new_indices[i+1] = -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
1334 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1335 if (indices != NULL) {
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1336 // We have an old cache to delete so save it for after we
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1337 // drop the lock.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1338 to_dealloc_indices = indices;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1339 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1340 release_set_methods_cached_itable_indices(indices = new_indices);
a61af66fc99e Initial load
duke
parents:
diff changeset
1341 }
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1342
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1343 if (idnum_can_increment()) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1344 // this cache can grow so we have to write to it safely
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1345 indices[idnum+1] = index;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1346 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1347 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1348 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
a61af66fc99e Initial load
duke
parents:
diff changeset
1349 }
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1350
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1351 if (!idnum_can_increment()) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1352 // The cache cannot grow and this JNI itable index value does not
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1353 // have to be unique like a jmethodID. If there is a race to set it,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1354 // it doesn't matter.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1355 indices[idnum+1] = index;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1356 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1357
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1358 if (to_dealloc_indices != NULL) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1359 // we allocated a new cache so free the old one
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1360 FreeHeap(to_dealloc_indices);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
1361 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1362 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1363
a61af66fc99e Initial load
duke
parents:
diff changeset
1364
a61af66fc99e Initial load
duke
parents:
diff changeset
1365 // Retrieve a cached itable index
a61af66fc99e Initial load
duke
parents:
diff changeset
1366 int instanceKlass::cached_itable_index(size_t idnum) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1367 int* indices = methods_cached_itable_indices_acquire();
a61af66fc99e Initial load
duke
parents:
diff changeset
1368 if (indices != NULL && ((size_t)indices[0]) > idnum) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1369 // indices exist and are long enough, retrieve possible cached
a61af66fc99e Initial load
duke
parents:
diff changeset
1370 return indices[idnum+1];
a61af66fc99e Initial load
duke
parents:
diff changeset
1371 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1372 return -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
1373 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1374
a61af66fc99e Initial load
duke
parents:
diff changeset
1375
a61af66fc99e Initial load
duke
parents:
diff changeset
1376 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1377 // nmethodBucket is used to record dependent nmethods for
a61af66fc99e Initial load
duke
parents:
diff changeset
1378 // deoptimization. nmethod dependencies are actually <klass, method>
a61af66fc99e Initial load
duke
parents:
diff changeset
1379 // pairs but we really only care about the klass part for purposes of
a61af66fc99e Initial load
duke
parents:
diff changeset
1380 // finding nmethods which might need to be deoptimized. Instead of
a61af66fc99e Initial load
duke
parents:
diff changeset
1381 // recording the method, a count of how many times a particular nmethod
a61af66fc99e Initial load
duke
parents:
diff changeset
1382 // was recorded is kept. This ensures that any recording errors are
a61af66fc99e Initial load
duke
parents:
diff changeset
1383 // noticed since an nmethod should be removed as many times are it's
a61af66fc99e Initial load
duke
parents:
diff changeset
1384 // added.
a61af66fc99e Initial load
duke
parents:
diff changeset
1385 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1386 class nmethodBucket {
a61af66fc99e Initial load
duke
parents:
diff changeset
1387 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
1388 nmethod* _nmethod;
a61af66fc99e Initial load
duke
parents:
diff changeset
1389 int _count;
a61af66fc99e Initial load
duke
parents:
diff changeset
1390 nmethodBucket* _next;
a61af66fc99e Initial load
duke
parents:
diff changeset
1391
a61af66fc99e Initial load
duke
parents:
diff changeset
1392 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
1393 nmethodBucket(nmethod* nmethod, nmethodBucket* next) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1394 _nmethod = nmethod;
a61af66fc99e Initial load
duke
parents:
diff changeset
1395 _next = next;
a61af66fc99e Initial load
duke
parents:
diff changeset
1396 _count = 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
1397 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1398 int count() { return _count; }
a61af66fc99e Initial load
duke
parents:
diff changeset
1399 int increment() { _count += 1; return _count; }
a61af66fc99e Initial load
duke
parents:
diff changeset
1400 int decrement() { _count -= 1; assert(_count >= 0, "don't underflow"); return _count; }
a61af66fc99e Initial load
duke
parents:
diff changeset
1401 nmethodBucket* next() { return _next; }
a61af66fc99e Initial load
duke
parents:
diff changeset
1402 void set_next(nmethodBucket* b) { _next = b; }
a61af66fc99e Initial load
duke
parents:
diff changeset
1403 nmethod* get_nmethod() { return _nmethod; }
a61af66fc99e Initial load
duke
parents:
diff changeset
1404 };
a61af66fc99e Initial load
duke
parents:
diff changeset
1405
a61af66fc99e Initial load
duke
parents:
diff changeset
1406
a61af66fc99e Initial load
duke
parents:
diff changeset
1407 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1408 // Walk the list of dependent nmethods searching for nmethods which
3852
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents: 3748
diff changeset
1409 // are dependent on the changes that were passed in and mark them for
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1410 // deoptimization. Returns the number of nmethods found.
a61af66fc99e Initial load
duke
parents:
diff changeset
1411 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1412 int instanceKlass::mark_dependent_nmethods(DepChange& changes) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1413 assert_locked_or_safepoint(CodeCache_lock);
a61af66fc99e Initial load
duke
parents:
diff changeset
1414 int found = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1415 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load
duke
parents:
diff changeset
1416 while (b != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1417 nmethod* nm = b->get_nmethod();
a61af66fc99e Initial load
duke
parents:
diff changeset
1418 // since dependencies aren't removed until an nmethod becomes a zombie,
a61af66fc99e Initial load
duke
parents:
diff changeset
1419 // the dependency list may contain nmethods which aren't alive.
a61af66fc99e Initial load
duke
parents:
diff changeset
1420 if (nm->is_alive() && !nm->is_marked_for_deoptimization() && nm->check_dependency_on(changes)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1421 if (TraceDependencies) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1422 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
1423 tty->print_cr("Marked for deoptimization");
a61af66fc99e Initial load
duke
parents:
diff changeset
1424 tty->print_cr(" context = %s", this->external_name());
a61af66fc99e Initial load
duke
parents:
diff changeset
1425 changes.print();
a61af66fc99e Initial load
duke
parents:
diff changeset
1426 nm->print();
a61af66fc99e Initial load
duke
parents:
diff changeset
1427 nm->print_dependencies();
a61af66fc99e Initial load
duke
parents:
diff changeset
1428 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1429 nm->mark_for_deoptimization();
a61af66fc99e Initial load
duke
parents:
diff changeset
1430 found++;
a61af66fc99e Initial load
duke
parents:
diff changeset
1431 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1432 b = b->next();
a61af66fc99e Initial load
duke
parents:
diff changeset
1433 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1434 return found;
a61af66fc99e Initial load
duke
parents:
diff changeset
1435 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1436
a61af66fc99e Initial load
duke
parents:
diff changeset
1437
a61af66fc99e Initial load
duke
parents:
diff changeset
1438 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1439 // Add an nmethodBucket to the list of dependencies for this nmethod.
a61af66fc99e Initial load
duke
parents:
diff changeset
1440 // It's possible that an nmethod has multiple dependencies on this klass
a61af66fc99e Initial load
duke
parents:
diff changeset
1441 // so a count is kept for each bucket to guarantee that creation and
a61af66fc99e Initial load
duke
parents:
diff changeset
1442 // deletion of dependencies is consistent.
a61af66fc99e Initial load
duke
parents:
diff changeset
1443 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1444 void instanceKlass::add_dependent_nmethod(nmethod* nm) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1445 assert_locked_or_safepoint(CodeCache_lock);
a61af66fc99e Initial load
duke
parents:
diff changeset
1446 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load
duke
parents:
diff changeset
1447 nmethodBucket* last = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1448 while (b != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1449 if (nm == b->get_nmethod()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1450 b->increment();
a61af66fc99e Initial load
duke
parents:
diff changeset
1451 return;
a61af66fc99e Initial load
duke
parents:
diff changeset
1452 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1453 b = b->next();
a61af66fc99e Initial load
duke
parents:
diff changeset
1454 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1455 _dependencies = new nmethodBucket(nm, _dependencies);
a61af66fc99e Initial load
duke
parents:
diff changeset
1456 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1457
a61af66fc99e Initial load
duke
parents:
diff changeset
1458
a61af66fc99e Initial load
duke
parents:
diff changeset
1459 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1460 // Decrement count of the nmethod in the dependency list and remove
a61af66fc99e Initial load
duke
parents:
diff changeset
1461 // the bucket competely when the count goes to 0. This method must
a61af66fc99e Initial load
duke
parents:
diff changeset
1462 // find a corresponding bucket otherwise there's a bug in the
a61af66fc99e Initial load
duke
parents:
diff changeset
1463 // recording of dependecies.
a61af66fc99e Initial load
duke
parents:
diff changeset
1464 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1465 void instanceKlass::remove_dependent_nmethod(nmethod* nm) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1466 assert_locked_or_safepoint(CodeCache_lock);
a61af66fc99e Initial load
duke
parents:
diff changeset
1467 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load
duke
parents:
diff changeset
1468 nmethodBucket* last = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1469 while (b != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1470 if (nm == b->get_nmethod()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1471 if (b->decrement() == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1472 if (last == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1473 _dependencies = b->next();
a61af66fc99e Initial load
duke
parents:
diff changeset
1474 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1475 last->set_next(b->next());
a61af66fc99e Initial load
duke
parents:
diff changeset
1476 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1477 delete b;
a61af66fc99e Initial load
duke
parents:
diff changeset
1478 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1479 return;
a61af66fc99e Initial load
duke
parents:
diff changeset
1480 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1481 last = b;
a61af66fc99e Initial load
duke
parents:
diff changeset
1482 b = b->next();
a61af66fc99e Initial load
duke
parents:
diff changeset
1483 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1484 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
1485 tty->print_cr("### %s can't find dependent nmethod:", this->external_name());
a61af66fc99e Initial load
duke
parents:
diff changeset
1486 nm->print();
a61af66fc99e Initial load
duke
parents:
diff changeset
1487 #endif // ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
1488 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
1489 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1490
a61af66fc99e Initial load
duke
parents:
diff changeset
1491
a61af66fc99e Initial load
duke
parents:
diff changeset
1492 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
1493 void instanceKlass::print_dependent_nmethods(bool verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1494 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load
duke
parents:
diff changeset
1495 int idx = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1496 while (b != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1497 nmethod* nm = b->get_nmethod();
a61af66fc99e Initial load
duke
parents:
diff changeset
1498 tty->print("[%d] count=%d { ", idx++, b->count());
a61af66fc99e Initial load
duke
parents:
diff changeset
1499 if (!verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1500 nm->print_on(tty, "nmethod");
a61af66fc99e Initial load
duke
parents:
diff changeset
1501 tty->print_cr(" } ");
a61af66fc99e Initial load
duke
parents:
diff changeset
1502 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1503 nm->print();
a61af66fc99e Initial load
duke
parents:
diff changeset
1504 nm->print_dependencies();
a61af66fc99e Initial load
duke
parents:
diff changeset
1505 tty->print_cr("--- } ");
a61af66fc99e Initial load
duke
parents:
diff changeset
1506 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1507 b = b->next();
a61af66fc99e Initial load
duke
parents:
diff changeset
1508 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1509 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1510
a61af66fc99e Initial load
duke
parents:
diff changeset
1511
a61af66fc99e Initial load
duke
parents:
diff changeset
1512 bool instanceKlass::is_dependent_nmethod(nmethod* nm) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1513 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load
duke
parents:
diff changeset
1514 while (b != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1515 if (nm == b->get_nmethod()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1516 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1517 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1518 b = b->next();
a61af66fc99e Initial load
duke
parents:
diff changeset
1519 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1520 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1521 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1522 #endif //PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
1523
a61af66fc99e Initial load
duke
parents:
diff changeset
1524
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1525 #ifdef ASSERT
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1526 template <class T> void assert_is_in(T *p) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1527 T heap_oop = oopDesc::load_heap_oop(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1528 if (!oopDesc::is_null(heap_oop)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1529 oop o = oopDesc::decode_heap_oop_not_null(heap_oop);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1530 assert(Universe::heap()->is_in(o), "should be in heap");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1531 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1532 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1533 template <class T> void assert_is_in_closed_subset(T *p) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1534 T heap_oop = oopDesc::load_heap_oop(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1535 if (!oopDesc::is_null(heap_oop)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1536 oop o = oopDesc::decode_heap_oop_not_null(heap_oop);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1537 assert(Universe::heap()->is_in_closed_subset(o), "should be in closed");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1538 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1539 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1540 template <class T> void assert_is_in_reserved(T *p) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1541 T heap_oop = oopDesc::load_heap_oop(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1542 if (!oopDesc::is_null(heap_oop)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1543 oop o = oopDesc::decode_heap_oop_not_null(heap_oop);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1544 assert(Universe::heap()->is_in_reserved(o), "should be in reserved");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1545 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1546 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1547 template <class T> void assert_nothing(T *p) {}
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1548
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1549 #else
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1550 template <class T> void assert_is_in(T *p) {}
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1551 template <class T> void assert_is_in_closed_subset(T *p) {}
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1552 template <class T> void assert_is_in_reserved(T *p) {}
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1553 template <class T> void assert_nothing(T *p) {}
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1554 #endif // ASSERT
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1555
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1556 //
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1557 // Macros that iterate over areas of oops which are specialized on type of
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1558 // oop pointer either narrow or wide, depending on UseCompressedOops
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1559 //
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1560 // Parameters are:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1561 // T - type of oop to point to (either oop or narrowOop)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1562 // start_p - starting pointer for region to iterate over
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1563 // count - number of oops or narrowOops to iterate over
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1564 // do_oop - action to perform on each oop (it's arbitrary C code which
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1565 // makes it more efficient to put in a macro rather than making
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1566 // it a template function)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1567 // assert_fn - assert function which is template function because performance
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1568 // doesn't matter when enabled.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1569 #define InstanceKlass_SPECIALIZED_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1570 T, start_p, count, do_oop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1571 assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1572 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1573 T* p = (T*)(start_p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1574 T* const end = p + (count); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1575 while (p < end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1576 (assert_fn)(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1577 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1578 ++p; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1579 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1580 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1581
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1582 #define InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1583 T, start_p, count, do_oop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1584 assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1585 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1586 T* const start = (T*)(start_p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1587 T* p = start + (count); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1588 while (start < p) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1589 --p; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1590 (assert_fn)(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1591 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1592 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1593 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1594
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1595 #define InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1596 T, start_p, count, low, high, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1597 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1598 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1599 T* const l = (T*)(low); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1600 T* const h = (T*)(high); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1601 assert(mask_bits((intptr_t)l, sizeof(T)-1) == 0 && \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1602 mask_bits((intptr_t)h, sizeof(T)-1) == 0, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1603 "bounded region must be properly aligned"); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1604 T* p = (T*)(start_p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1605 T* end = p + (count); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1606 if (p < l) p = l; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1607 if (end > h) end = h; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1608 while (p < end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1609 (assert_fn)(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1610 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1611 ++p; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1612 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1613 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1614
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1615
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1616 // The following macros call specialized macros, passing either oop or
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1617 // narrowOop as the specialization type. These test the UseCompressedOops
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1618 // flag.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1619 #define InstanceKlass_OOP_MAP_ITERATE(obj, do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1620 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1621 /* Compute oopmap block range. The common case \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1622 is nonstatic_oop_map_size == 1. */ \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1623 OopMapBlock* map = start_of_nonstatic_oop_maps(); \
938
b37c246bf7ce 6861660: OopMapBlock count/size confusion
jcoomes
parents: 876
diff changeset
1624 OopMapBlock* const end_map = map + nonstatic_oop_map_count(); \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1625 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1626 while (map < end_map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1627 InstanceKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
938
b37c246bf7ce 6861660: OopMapBlock count/size confusion
jcoomes
parents: 876
diff changeset
1628 obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1629 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1630 ++map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1631 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1632 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1633 while (map < end_map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1634 InstanceKlass_SPECIALIZED_OOP_ITERATE(oop, \
938
b37c246bf7ce 6861660: OopMapBlock count/size confusion
jcoomes
parents: 876
diff changeset
1635 obj->obj_field_addr<oop>(map->offset()), map->count(), \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1636 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1637 ++map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1638 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1639 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1640 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1641
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1642 #define InstanceKlass_OOP_MAP_REVERSE_ITERATE(obj, do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1643 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1644 OopMapBlock* const start_map = start_of_nonstatic_oop_maps(); \
938
b37c246bf7ce 6861660: OopMapBlock count/size confusion
jcoomes
parents: 876
diff changeset
1645 OopMapBlock* map = start_map + nonstatic_oop_map_count(); \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1646 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1647 while (start_map < map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1648 --map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1649 InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE(narrowOop, \
938
b37c246bf7ce 6861660: OopMapBlock count/size confusion
jcoomes
parents: 876
diff changeset
1650 obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1651 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1652 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1653 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1654 while (start_map < map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1655 --map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1656 InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE(oop, \
938
b37c246bf7ce 6861660: OopMapBlock count/size confusion
jcoomes
parents: 876
diff changeset
1657 obj->obj_field_addr<oop>(map->offset()), map->count(), \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1658 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1659 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1660 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1661 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1662
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1663 #define InstanceKlass_BOUNDED_OOP_MAP_ITERATE(obj, low, high, do_oop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1664 assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1665 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1666 /* Compute oopmap block range. The common case is \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1667 nonstatic_oop_map_size == 1, so we accept the \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1668 usually non-existent extra overhead of examining \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1669 all the maps. */ \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1670 OopMapBlock* map = start_of_nonstatic_oop_maps(); \
938
b37c246bf7ce 6861660: OopMapBlock count/size confusion
jcoomes
parents: 876
diff changeset
1671 OopMapBlock* const end_map = map + nonstatic_oop_map_count(); \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1672 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1673 while (map < end_map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1674 InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \
938
b37c246bf7ce 6861660: OopMapBlock count/size confusion
jcoomes
parents: 876
diff changeset
1675 obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1676 low, high, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1677 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1678 ++map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1679 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1680 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1681 while (map < end_map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1682 InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \
938
b37c246bf7ce 6861660: OopMapBlock count/size confusion
jcoomes
parents: 876
diff changeset
1683 obj->obj_field_addr<oop>(map->offset()), map->count(), \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1684 low, high, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1685 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1686 ++map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1687 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1688 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1689 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1690
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1691 void instanceKlass::oop_follow_contents(oop obj) {
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1692 assert(obj != NULL, "can't follow the content of NULL object");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1693 obj->follow_header();
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1694 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1695 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1696 MarkSweep::mark_and_push(p), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1697 assert_is_in_closed_subset)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1698 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1699
a61af66fc99e Initial load
duke
parents:
diff changeset
1700 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
1701 void instanceKlass::oop_follow_contents(ParCompactionManager* cm,
a61af66fc99e Initial load
duke
parents:
diff changeset
1702 oop obj) {
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1703 assert(obj != NULL, "can't follow the content of NULL object");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1704 obj->follow_header(cm);
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1705 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1706 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1707 PSParallelCompact::mark_and_push(cm, p), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1708 assert_is_in)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1709 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1710 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
1711
a61af66fc99e Initial load
duke
parents:
diff changeset
1712 // closure's do_header() method dicates whether the given closure should be
a61af66fc99e Initial load
duke
parents:
diff changeset
1713 // applied to the klass ptr in the object header.
a61af66fc99e Initial load
duke
parents:
diff changeset
1714
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1715 #define InstanceKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1716 \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1717 int instanceKlass::oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) { \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1718 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::ik);\
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1719 /* header */ \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1720 if (closure->do_header()) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1721 obj->oop_iterate_header(closure); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1722 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1723 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1724 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1725 SpecializationStats:: \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1726 record_do_oop_call##nv_suffix(SpecializationStats::ik); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1727 (closure)->do_oop##nv_suffix(p), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1728 assert_is_in_closed_subset) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1729 return size_helper(); \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1730 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1731
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1732 #ifndef SERIALGC
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1733 #define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1734 \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1735 int instanceKlass::oop_oop_iterate_backwards##nv_suffix(oop obj, \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1736 OopClosureType* closure) { \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1737 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::ik); \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1738 /* header */ \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1739 if (closure->do_header()) { \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1740 obj->oop_iterate_header(closure); \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1741 } \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1742 /* instance variables */ \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1743 InstanceKlass_OOP_MAP_REVERSE_ITERATE( \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1744 obj, \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1745 SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::ik);\
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1746 (closure)->do_oop##nv_suffix(p), \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1747 assert_is_in_closed_subset) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1748 return size_helper(); \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1749 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1750 #endif // !SERIALGC
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1751
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1752 #define InstanceKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1753 \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1754 int instanceKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1755 OopClosureType* closure, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1756 MemRegion mr) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1757 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::ik);\
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1758 if (closure->do_header()) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1759 obj->oop_iterate_header(closure, mr); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1760 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1761 InstanceKlass_BOUNDED_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1762 obj, mr.start(), mr.end(), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1763 (closure)->do_oop##nv_suffix(p), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1764 assert_is_in_closed_subset) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1765 return size_helper(); \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1766 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1767
a61af66fc99e Initial load
duke
parents:
diff changeset
1768 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DEFN)
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1769 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DEFN)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1770 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DEFN_m)
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1771 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DEFN_m)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1772 #ifndef SERIALGC
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1773 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1774 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
1775 #endif // !SERIALGC
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1776
a61af66fc99e Initial load
duke
parents:
diff changeset
1777 int instanceKlass::oop_adjust_pointers(oop obj) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1778 int size = size_helper();
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1779 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1780 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1781 MarkSweep::adjust_pointer(p), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1782 assert_is_in)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1783 obj->adjust_header();
a61af66fc99e Initial load
duke
parents:
diff changeset
1784 return size;
a61af66fc99e Initial load
duke
parents:
diff changeset
1785 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1786
a61af66fc99e Initial load
duke
parents:
diff changeset
1787 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
1788 void instanceKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1789 InstanceKlass_OOP_MAP_REVERSE_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1790 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1791 if (PSScavenge::should_scavenge(p)) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1792 pm->claim_or_forward_depth(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1793 }, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1794 assert_nothing )
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1795 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1796
a61af66fc99e Initial load
duke
parents:
diff changeset
1797 int instanceKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1798 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1799 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1800 PSParallelCompact::adjust_pointer(p), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
1801 assert_nothing)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1802 return size_helper();
a61af66fc99e Initial load
duke
parents:
diff changeset
1803 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1804
a61af66fc99e Initial load
duke
parents:
diff changeset
1805 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
1806
a61af66fc99e Initial load
duke
parents:
diff changeset
1807 // This klass is alive but the implementor link is not followed/updated.
a61af66fc99e Initial load
duke
parents:
diff changeset
1808 // Subklass and sibling links are handled by Klass::follow_weak_klass_links
a61af66fc99e Initial load
duke
parents:
diff changeset
1809
a61af66fc99e Initial load
duke
parents:
diff changeset
1810 void instanceKlass::follow_weak_klass_links(
a61af66fc99e Initial load
duke
parents:
diff changeset
1811 BoolObjectClosure* is_alive, OopClosure* keep_alive) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1812 assert(is_alive->do_object_b(as_klassOop()), "this oop should be live");
a61af66fc99e Initial load
duke
parents:
diff changeset
1813 if (ClassUnloading) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1814 for (int i = 0; i < implementors_limit; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1815 klassOop impl = _implementors[i];
a61af66fc99e Initial load
duke
parents:
diff changeset
1816 if (impl == NULL) break; // no more in the list
a61af66fc99e Initial load
duke
parents:
diff changeset
1817 if (!is_alive->do_object_b(impl)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1818 // remove this guy from the list by overwriting him with the tail
a61af66fc99e Initial load
duke
parents:
diff changeset
1819 int lasti = --_nof_implementors;
a61af66fc99e Initial load
duke
parents:
diff changeset
1820 assert(lasti >= i && lasti < implementors_limit, "just checking");
a61af66fc99e Initial load
duke
parents:
diff changeset
1821 _implementors[i] = _implementors[lasti];
a61af66fc99e Initial load
duke
parents:
diff changeset
1822 _implementors[lasti] = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1823 --i; // rerun the loop at this index
a61af66fc99e Initial load
duke
parents:
diff changeset
1824 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1825 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1826 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1827 for (int i = 0; i < implementors_limit; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1828 keep_alive->do_oop(&adr_implementors()[i]);
a61af66fc99e Initial load
duke
parents:
diff changeset
1829 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1830 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1831 Klass::follow_weak_klass_links(is_alive, keep_alive);
a61af66fc99e Initial load
duke
parents:
diff changeset
1832 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1833
a61af66fc99e Initial load
duke
parents:
diff changeset
1834 void instanceKlass::remove_unshareable_info() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1835 Klass::remove_unshareable_info();
a61af66fc99e Initial load
duke
parents:
diff changeset
1836 init_implementor();
a61af66fc99e Initial load
duke
parents:
diff changeset
1837 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1838
a61af66fc99e Initial load
duke
parents:
diff changeset
1839 static void clear_all_breakpoints(methodOop m) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1840 m->clear_all_breakpoints();
a61af66fc99e Initial load
duke
parents:
diff changeset
1841 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1842
a61af66fc99e Initial load
duke
parents:
diff changeset
1843 void instanceKlass::release_C_heap_structures() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1844 // Deallocate oop map cache
a61af66fc99e Initial load
duke
parents:
diff changeset
1845 if (_oop_map_cache != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1846 delete _oop_map_cache;
a61af66fc99e Initial load
duke
parents:
diff changeset
1847 _oop_map_cache = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1848 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1849
a61af66fc99e Initial load
duke
parents:
diff changeset
1850 // Deallocate JNI identifiers for jfieldIDs
a61af66fc99e Initial load
duke
parents:
diff changeset
1851 JNIid::deallocate(jni_ids());
a61af66fc99e Initial load
duke
parents:
diff changeset
1852 set_jni_ids(NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1853
a61af66fc99e Initial load
duke
parents:
diff changeset
1854 jmethodID* jmeths = methods_jmethod_ids_acquire();
a61af66fc99e Initial load
duke
parents:
diff changeset
1855 if (jmeths != (jmethodID*)NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1856 release_set_methods_jmethod_ids(NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1857 FreeHeap(jmeths);
a61af66fc99e Initial load
duke
parents:
diff changeset
1858 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1859
a61af66fc99e Initial load
duke
parents:
diff changeset
1860 int* indices = methods_cached_itable_indices_acquire();
a61af66fc99e Initial load
duke
parents:
diff changeset
1861 if (indices != (int*)NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1862 release_set_methods_cached_itable_indices(NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1863 FreeHeap(indices);
a61af66fc99e Initial load
duke
parents:
diff changeset
1864 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1865
a61af66fc99e Initial load
duke
parents:
diff changeset
1866 // release dependencies
a61af66fc99e Initial load
duke
parents:
diff changeset
1867 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load
duke
parents:
diff changeset
1868 _dependencies = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1869 while (b != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1870 nmethodBucket* next = b->next();
a61af66fc99e Initial load
duke
parents:
diff changeset
1871 delete b;
a61af66fc99e Initial load
duke
parents:
diff changeset
1872 b = next;
a61af66fc99e Initial load
duke
parents:
diff changeset
1873 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1874
a61af66fc99e Initial load
duke
parents:
diff changeset
1875 // Deallocate breakpoint records
a61af66fc99e Initial load
duke
parents:
diff changeset
1876 if (breakpoints() != 0x0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1877 methods_do(clear_all_breakpoints);
a61af66fc99e Initial load
duke
parents:
diff changeset
1878 assert(breakpoints() == 0x0, "should have cleared breakpoints");
a61af66fc99e Initial load
duke
parents:
diff changeset
1879 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1880
a61af66fc99e Initial load
duke
parents:
diff changeset
1881 // deallocate information about previous versions
a61af66fc99e Initial load
duke
parents:
diff changeset
1882 if (_previous_versions != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1883 for (int i = _previous_versions->length() - 1; i >= 0; i--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1884 PreviousVersionNode * pv_node = _previous_versions->at(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
1885 delete pv_node;
a61af66fc99e Initial load
duke
parents:
diff changeset
1886 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1887 delete _previous_versions;
a61af66fc99e Initial load
duke
parents:
diff changeset
1888 _previous_versions = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1889 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1890
a61af66fc99e Initial load
duke
parents:
diff changeset
1891 // deallocate the cached class file
a61af66fc99e Initial load
duke
parents:
diff changeset
1892 if (_cached_class_file_bytes != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1893 os::free(_cached_class_file_bytes);
a61af66fc99e Initial load
duke
parents:
diff changeset
1894 _cached_class_file_bytes = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1895 _cached_class_file_len = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1896 }
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1897
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1898 // Decrement symbol reference counts associated with the unloaded class.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1899 if (_name != NULL) _name->decrement_refcount();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1900 // unreference array name derived from this class name (arrays of an unloaded
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1901 // class can't be referenced anymore).
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1902 if (_array_name != NULL) _array_name->decrement_refcount();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1903 if (_source_file_name != NULL) _source_file_name->decrement_refcount();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1904 if (_source_debug_extension != NULL) _source_debug_extension->decrement_refcount();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1905 // walk constant pool and decrement symbol reference counts
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1906 _constants->unreference_symbols();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1907 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1908
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1909 void instanceKlass::set_source_file_name(Symbol* n) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1910 _source_file_name = n;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1911 if (_source_file_name != NULL) _source_file_name->increment_refcount();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1912 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1913
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1914 void instanceKlass::set_source_debug_extension(Symbol* n) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1915 _source_debug_extension = n;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1916 if (_source_debug_extension != NULL) _source_debug_extension->increment_refcount();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1917 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1918
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
1919 address instanceKlass::static_field_addr(int offset) {
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
1920 return (address)(offset + instanceMirrorKlass::offset_of_static_fields() + (intptr_t)java_mirror());
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
1921 }
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
1922
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
1923
1039
987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 997
diff changeset
1924 const char* instanceKlass::signature_name() const {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1925 const char* src = (const char*) (name()->as_C_string());
a61af66fc99e Initial load
duke
parents:
diff changeset
1926 const int src_length = (int)strlen(src);
a61af66fc99e Initial load
duke
parents:
diff changeset
1927 char* dest = NEW_RESOURCE_ARRAY(char, src_length + 3);
a61af66fc99e Initial load
duke
parents:
diff changeset
1928 int src_index = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1929 int dest_index = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1930 dest[dest_index++] = 'L';
a61af66fc99e Initial load
duke
parents:
diff changeset
1931 while (src_index < src_length) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1932 dest[dest_index++] = src[src_index++];
a61af66fc99e Initial load
duke
parents:
diff changeset
1933 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1934 dest[dest_index++] = ';';
a61af66fc99e Initial load
duke
parents:
diff changeset
1935 dest[dest_index] = '\0';
a61af66fc99e Initial load
duke
parents:
diff changeset
1936 return dest;
a61af66fc99e Initial load
duke
parents:
diff changeset
1937 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1938
a61af66fc99e Initial load
duke
parents:
diff changeset
1939 // different verisons of is_same_class_package
a61af66fc99e Initial load
duke
parents:
diff changeset
1940 bool instanceKlass::is_same_class_package(klassOop class2) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1941 klassOop class1 = as_klassOop();
a61af66fc99e Initial load
duke
parents:
diff changeset
1942 oop classloader1 = instanceKlass::cast(class1)->class_loader();
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1943 Symbol* classname1 = Klass::cast(class1)->name();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1944
a61af66fc99e Initial load
duke
parents:
diff changeset
1945 if (Klass::cast(class2)->oop_is_objArray()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1946 class2 = objArrayKlass::cast(class2)->bottom_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1947 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1948 oop classloader2;
a61af66fc99e Initial load
duke
parents:
diff changeset
1949 if (Klass::cast(class2)->oop_is_instance()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1950 classloader2 = instanceKlass::cast(class2)->class_loader();
a61af66fc99e Initial load
duke
parents:
diff changeset
1951 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1952 assert(Klass::cast(class2)->oop_is_typeArray(), "should be type array");
a61af66fc99e Initial load
duke
parents:
diff changeset
1953 classloader2 = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1954 }
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1955 Symbol* classname2 = Klass::cast(class2)->name();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1956
a61af66fc99e Initial load
duke
parents:
diff changeset
1957 return instanceKlass::is_same_class_package(classloader1, classname1,
a61af66fc99e Initial load
duke
parents:
diff changeset
1958 classloader2, classname2);
a61af66fc99e Initial load
duke
parents:
diff changeset
1959 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1960
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1961 bool instanceKlass::is_same_class_package(oop classloader2, Symbol* classname2) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1962 klassOop class1 = as_klassOop();
a61af66fc99e Initial load
duke
parents:
diff changeset
1963 oop classloader1 = instanceKlass::cast(class1)->class_loader();
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1964 Symbol* classname1 = Klass::cast(class1)->name();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1965
a61af66fc99e Initial load
duke
parents:
diff changeset
1966 return instanceKlass::is_same_class_package(classloader1, classname1,
a61af66fc99e Initial load
duke
parents:
diff changeset
1967 classloader2, classname2);
a61af66fc99e Initial load
duke
parents:
diff changeset
1968 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1969
a61af66fc99e Initial load
duke
parents:
diff changeset
1970 // return true if two classes are in the same package, classloader
a61af66fc99e Initial load
duke
parents:
diff changeset
1971 // and classname information is enough to determine a class's package
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1972 bool instanceKlass::is_same_class_package(oop class_loader1, Symbol* class_name1,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1973 oop class_loader2, Symbol* class_name2) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1974 if (class_loader1 != class_loader2) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1975 return false;
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
1976 } else if (class_name1 == class_name2) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
1977 return true; // skip painful bytewise comparison
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1978 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1979 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
1980
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1981 // The Symbol*'s are in UTF8 encoding. Since we only need to check explicitly
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1982 // for ASCII characters ('/', 'L', '['), we can keep them in UTF8 encoding.
a61af66fc99e Initial load
duke
parents:
diff changeset
1983 // Otherwise, we just compare jbyte values between the strings.
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1984 const jbyte *name1 = class_name1->base();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1985 const jbyte *name2 = class_name2->base();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1986
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1987 const jbyte *last_slash1 = UTF8::strrchr(name1, class_name1->utf8_length(), '/');
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
1988 const jbyte *last_slash2 = UTF8::strrchr(name2, class_name2->utf8_length(), '/');
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1989
a61af66fc99e Initial load
duke
parents:
diff changeset
1990 if ((last_slash1 == NULL) || (last_slash2 == NULL)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1991 // One of the two doesn't have a package. Only return true
a61af66fc99e Initial load
duke
parents:
diff changeset
1992 // if the other one also doesn't have a package.
a61af66fc99e Initial load
duke
parents:
diff changeset
1993 return last_slash1 == last_slash2;
a61af66fc99e Initial load
duke
parents:
diff changeset
1994 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1995 // Skip over '['s
a61af66fc99e Initial load
duke
parents:
diff changeset
1996 if (*name1 == '[') {
a61af66fc99e Initial load
duke
parents:
diff changeset
1997 do {
a61af66fc99e Initial load
duke
parents:
diff changeset
1998 name1++;
a61af66fc99e Initial load
duke
parents:
diff changeset
1999 } while (*name1 == '[');
a61af66fc99e Initial load
duke
parents:
diff changeset
2000 if (*name1 != 'L') {
a61af66fc99e Initial load
duke
parents:
diff changeset
2001 // Something is terribly wrong. Shouldn't be here.
a61af66fc99e Initial load
duke
parents:
diff changeset
2002 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2003 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2004 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2005 if (*name2 == '[') {
a61af66fc99e Initial load
duke
parents:
diff changeset
2006 do {
a61af66fc99e Initial load
duke
parents:
diff changeset
2007 name2++;
a61af66fc99e Initial load
duke
parents:
diff changeset
2008 } while (*name2 == '[');
a61af66fc99e Initial load
duke
parents:
diff changeset
2009 if (*name2 != 'L') {
a61af66fc99e Initial load
duke
parents:
diff changeset
2010 // Something is terribly wrong. Shouldn't be here.
a61af66fc99e Initial load
duke
parents:
diff changeset
2011 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2012 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2013 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2014
a61af66fc99e Initial load
duke
parents:
diff changeset
2015 // Check that package part is identical
a61af66fc99e Initial load
duke
parents:
diff changeset
2016 int length1 = last_slash1 - name1;
a61af66fc99e Initial load
duke
parents:
diff changeset
2017 int length2 = last_slash2 - name2;
a61af66fc99e Initial load
duke
parents:
diff changeset
2018
a61af66fc99e Initial load
duke
parents:
diff changeset
2019 return UTF8::equal(name1, length1, name2, length2);
a61af66fc99e Initial load
duke
parents:
diff changeset
2020 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2021 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2022 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2023
652
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2024 // Returns true iff super_method can be overridden by a method in targetclassname
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2025 // See JSL 3rd edition 8.4.6.1
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2026 // Assumes name-signature match
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2027 // "this" is instanceKlass of super_method which must exist
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2028 // note that the instanceKlass of the method in the targetclassname has not always been created yet
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
2029 bool instanceKlass::is_override(methodHandle super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS) {
652
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2030 // Private methods can not be overridden
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2031 if (super_method->is_private()) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2032 return false;
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2033 }
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2034 // If super method is accessible, then override
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2035 if ((super_method->is_protected()) ||
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2036 (super_method->is_public())) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2037 return true;
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2038 }
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2039 // Package-private methods are not inherited outside of package
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2040 assert(super_method->is_package_private(), "must be package private");
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
2041 return(is_same_class_package(targetclassloader(), targetclassname));
652
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents: 605
diff changeset
2042 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2043
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2044 /* defined for now in jvm.cpp, for historical reasons *--
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2045 klassOop instanceKlass::compute_enclosing_class_impl(instanceKlassHandle self,
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
2046 Symbol*& simple_name_result, TRAPS) {
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2047 ...
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2048 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2049 */
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2050
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2051 // tell if two classes have the same enclosing class (at package level)
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2052 bool instanceKlass::is_same_package_member_impl(instanceKlassHandle class1,
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2053 klassOop class2_oop, TRAPS) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2054 if (class2_oop == class1->as_klassOop()) return true;
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2055 if (!Klass::cast(class2_oop)->oop_is_instance()) return false;
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2056 instanceKlassHandle class2(THREAD, class2_oop);
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2057
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2058 // must be in same package before we try anything else
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2059 if (!class1->is_same_class_package(class2->class_loader(), class2->name()))
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2060 return false;
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2061
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2062 // As long as there is an outer1.getEnclosingClass,
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2063 // shift the search outward.
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2064 instanceKlassHandle outer1 = class1;
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2065 for (;;) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2066 // As we walk along, look for equalities between outer1 and class2.
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2067 // Eventually, the walks will terminate as outer1 stops
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2068 // at the top-level class around the original class.
1126
933a3e806ce6 6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents: 1039
diff changeset
2069 bool ignore_inner_is_member;
933a3e806ce6 6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents: 1039
diff changeset
2070 klassOop next = outer1->compute_enclosing_class(&ignore_inner_is_member,
933a3e806ce6 6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents: 1039
diff changeset
2071 CHECK_false);
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2072 if (next == NULL) break;
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2073 if (next == class2()) return true;
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2074 outer1 = instanceKlassHandle(THREAD, next);
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2075 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2076
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2077 // Now do the same for class2.
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2078 instanceKlassHandle outer2 = class2;
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2079 for (;;) {
1126
933a3e806ce6 6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents: 1039
diff changeset
2080 bool ignore_inner_is_member;
933a3e806ce6 6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents: 1039
diff changeset
2081 klassOop next = outer2->compute_enclosing_class(&ignore_inner_is_member,
933a3e806ce6 6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents: 1039
diff changeset
2082 CHECK_false);
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2083 if (next == NULL) break;
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2084 // Might as well check the new outer against all available values.
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2085 if (next == class1()) return true;
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2086 if (next == outer1()) return true;
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2087 outer2 = instanceKlassHandle(THREAD, next);
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2088 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2089
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2090 // If by this point we have not found an equality between the
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2091 // two classes, we know they are in separate package members.
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2092 return false;
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2093 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2094
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2095
a61af66fc99e Initial load
duke
parents:
diff changeset
2096 jint instanceKlass::compute_modifier_flags(TRAPS) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2097 klassOop k = as_klassOop();
a61af66fc99e Initial load
duke
parents:
diff changeset
2098 jint access = access_flags().as_int();
a61af66fc99e Initial load
duke
parents:
diff changeset
2099
a61af66fc99e Initial load
duke
parents:
diff changeset
2100 // But check if it happens to be member class.
a61af66fc99e Initial load
duke
parents:
diff changeset
2101 typeArrayOop inner_class_list = inner_classes();
a61af66fc99e Initial load
duke
parents:
diff changeset
2102 int length = (inner_class_list == NULL) ? 0 : inner_class_list->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
2103 assert (length % instanceKlass::inner_class_next_offset == 0, "just checking");
a61af66fc99e Initial load
duke
parents:
diff changeset
2104 if (length > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2105 typeArrayHandle inner_class_list_h(THREAD, inner_class_list);
a61af66fc99e Initial load
duke
parents:
diff changeset
2106 instanceKlassHandle ik(THREAD, k);
a61af66fc99e Initial load
duke
parents:
diff changeset
2107 for (int i = 0; i < length; i += instanceKlass::inner_class_next_offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2108 int ioff = inner_class_list_h->ushort_at(
a61af66fc99e Initial load
duke
parents:
diff changeset
2109 i + instanceKlass::inner_class_inner_class_info_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2110
a61af66fc99e Initial load
duke
parents:
diff changeset
2111 // Inner class attribute can be zero, skip it.
a61af66fc99e Initial load
duke
parents:
diff changeset
2112 // Strange but true: JVM spec. allows null inner class refs.
a61af66fc99e Initial load
duke
parents:
diff changeset
2113 if (ioff == 0) continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
2114
a61af66fc99e Initial load
duke
parents:
diff changeset
2115 // only look at classes that are already loaded
a61af66fc99e Initial load
duke
parents:
diff changeset
2116 // since we are looking for the flags for our self.
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
2117 Symbol* inner_name = ik->constants()->klass_name_at(ioff);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2118 if ((ik->name() == inner_name)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2119 // This is really a member class.
a61af66fc99e Initial load
duke
parents:
diff changeset
2120 access = inner_class_list_h->ushort_at(i + instanceKlass::inner_class_access_flags_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2121 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2122 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2123 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2124 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2125 // Remember to strip ACC_SUPER bit
a61af66fc99e Initial load
duke
parents:
diff changeset
2126 return (access & (~JVM_ACC_SUPER)) & JVM_ACC_WRITTEN_FLAGS;
a61af66fc99e Initial load
duke
parents:
diff changeset
2127 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2128
a61af66fc99e Initial load
duke
parents:
diff changeset
2129 jint instanceKlass::jvmti_class_status() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2130 jint result = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2131
a61af66fc99e Initial load
duke
parents:
diff changeset
2132 if (is_linked()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2133 result |= JVMTI_CLASS_STATUS_VERIFIED | JVMTI_CLASS_STATUS_PREPARED;
a61af66fc99e Initial load
duke
parents:
diff changeset
2134 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2135
a61af66fc99e Initial load
duke
parents:
diff changeset
2136 if (is_initialized()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2137 assert(is_linked(), "Class status is not consistent");
a61af66fc99e Initial load
duke
parents:
diff changeset
2138 result |= JVMTI_CLASS_STATUS_INITIALIZED;
a61af66fc99e Initial load
duke
parents:
diff changeset
2139 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2140 if (is_in_error_state()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2141 result |= JVMTI_CLASS_STATUS_ERROR;
a61af66fc99e Initial load
duke
parents:
diff changeset
2142 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2143 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
2144 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2145
a61af66fc99e Initial load
duke
parents:
diff changeset
2146 methodOop instanceKlass::method_at_itable(klassOop holder, int index, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2147 itableOffsetEntry* ioe = (itableOffsetEntry*)start_of_itable();
a61af66fc99e Initial load
duke
parents:
diff changeset
2148 int method_table_offset_in_words = ioe->offset()/wordSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
2149 int nof_interfaces = (method_table_offset_in_words - itable_offset_in_words())
a61af66fc99e Initial load
duke
parents:
diff changeset
2150 / itableOffsetEntry::size();
a61af66fc99e Initial load
duke
parents:
diff changeset
2151
a61af66fc99e Initial load
duke
parents:
diff changeset
2152 for (int cnt = 0 ; ; cnt ++, ioe ++) {
605
98cb887364d3 6810672: Comment typos
twisti
parents: 356
diff changeset
2153 // If the interface isn't implemented by the receiver class,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2154 // the VM should throw IncompatibleClassChangeError.
a61af66fc99e Initial load
duke
parents:
diff changeset
2155 if (cnt >= nof_interfaces) {
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
2156 THROW_0(vmSymbols::java_lang_IncompatibleClassChangeError());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2157 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2158
a61af66fc99e Initial load
duke
parents:
diff changeset
2159 klassOop ik = ioe->interface_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
2160 if (ik == holder) break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2161 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2162
a61af66fc99e Initial load
duke
parents:
diff changeset
2163 itableMethodEntry* ime = ioe->first_method_entry(as_klassOop());
a61af66fc99e Initial load
duke
parents:
diff changeset
2164 methodOop m = ime[index].method();
a61af66fc99e Initial load
duke
parents:
diff changeset
2165 if (m == NULL) {
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
2166 THROW_0(vmSymbols::java_lang_AbstractMethodError());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2167 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2168 return m;
a61af66fc99e Initial load
duke
parents:
diff changeset
2169 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2170
a61af66fc99e Initial load
duke
parents:
diff changeset
2171 // On-stack replacement stuff
a61af66fc99e Initial load
duke
parents:
diff changeset
2172 void instanceKlass::add_osr_nmethod(nmethod* n) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2173 // only one compilation can be active
a61af66fc99e Initial load
duke
parents:
diff changeset
2174 NEEDS_CLEANUP
a61af66fc99e Initial load
duke
parents:
diff changeset
2175 // This is a short non-blocking critical region, so the no safepoint check is ok.
a61af66fc99e Initial load
duke
parents:
diff changeset
2176 OsrList_lock->lock_without_safepoint_check();
a61af66fc99e Initial load
duke
parents:
diff changeset
2177 assert(n->is_osr_method(), "wrong kind of nmethod");
989
148e5441d916 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 876
diff changeset
2178 n->set_osr_link(osr_nmethods_head());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2179 set_osr_nmethods_head(n);
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2180 // Raise the highest osr level if necessary
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2181 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2182 methodOop m = n->method();
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2183 m->set_highest_osr_comp_level(MAX2(m->highest_osr_comp_level(), n->comp_level()));
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2184 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2185 // Remember to unlock again
a61af66fc99e Initial load
duke
parents:
diff changeset
2186 OsrList_lock->unlock();
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2187
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2188 // Get rid of the osr methods for the same bci that have lower levels.
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2189 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2190 for (int l = CompLevel_limited_profile; l < n->comp_level(); l++) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2191 nmethod *inv = lookup_osr_nmethod(n->method(), n->osr_entry_bci(), l, true);
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2192 if (inv != NULL && inv->is_in_use()) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2193 inv->make_not_entrant();
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2194 }
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2195 }
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2196 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2197 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2198
a61af66fc99e Initial load
duke
parents:
diff changeset
2199
a61af66fc99e Initial load
duke
parents:
diff changeset
2200 void instanceKlass::remove_osr_nmethod(nmethod* n) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2201 // This is a short non-blocking critical region, so the no safepoint check is ok.
a61af66fc99e Initial load
duke
parents:
diff changeset
2202 OsrList_lock->lock_without_safepoint_check();
a61af66fc99e Initial load
duke
parents:
diff changeset
2203 assert(n->is_osr_method(), "wrong kind of nmethod");
a61af66fc99e Initial load
duke
parents:
diff changeset
2204 nmethod* last = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2205 nmethod* cur = osr_nmethods_head();
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2206 int max_level = CompLevel_none; // Find the max comp level excluding n
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2207 methodOop m = n->method();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2208 // Search for match
a61af66fc99e Initial load
duke
parents:
diff changeset
2209 while(cur != NULL && cur != n) {
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2210 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2211 // Find max level before n
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2212 max_level = MAX2(max_level, cur->comp_level());
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2213 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2214 last = cur;
989
148e5441d916 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 876
diff changeset
2215 cur = cur->osr_link();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2216 }
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2217 nmethod* next = NULL;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2218 if (cur == n) {
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2219 next = cur->osr_link();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2220 if (last == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2221 // Remove first element
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2222 set_osr_nmethods_head(next);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2223 } else {
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2224 last->set_osr_link(next);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2225 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2226 }
989
148e5441d916 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 876
diff changeset
2227 n->set_osr_link(NULL);
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2228 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2229 cur = next;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2230 while (cur != NULL) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2231 // Find max level after n
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2232 max_level = MAX2(max_level, cur->comp_level());
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2233 cur = cur->osr_link();
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2234 }
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2235 m->set_highest_osr_comp_level(max_level);
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2236 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2237 // Remember to unlock again
a61af66fc99e Initial load
duke
parents:
diff changeset
2238 OsrList_lock->unlock();
a61af66fc99e Initial load
duke
parents:
diff changeset
2239 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2240
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2241 nmethod* instanceKlass::lookup_osr_nmethod(const methodOop m, int bci, int comp_level, bool match_level) const {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2242 // This is a short non-blocking critical region, so the no safepoint check is ok.
a61af66fc99e Initial load
duke
parents:
diff changeset
2243 OsrList_lock->lock_without_safepoint_check();
a61af66fc99e Initial load
duke
parents:
diff changeset
2244 nmethod* osr = osr_nmethods_head();
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2245 nmethod* best = NULL;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2246 while (osr != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2247 assert(osr->is_osr_method(), "wrong kind of nmethod found in chain");
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2248 // There can be a time when a c1 osr method exists but we are waiting
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2249 // for a c2 version. When c2 completes its osr nmethod we will trash
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2250 // the c1 version and only be able to find the c2 version. However
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2251 // while we overflow in the c1 code at back branches we don't want to
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2252 // try and switch to the same code as we are already running
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2253
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2254 if (osr->method() == m &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2255 (bci == InvocationEntryBci || osr->osr_entry_bci() == bci)) {
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2256 if (match_level) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2257 if (osr->comp_level() == comp_level) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2258 // Found a match - return it.
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2259 OsrList_lock->unlock();
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2260 return osr;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2261 }
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2262 } else {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2263 if (best == NULL || (osr->comp_level() > best->comp_level())) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2264 if (osr->comp_level() == CompLevel_highest_tier) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2265 // Found the best possible - return it.
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2266 OsrList_lock->unlock();
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2267 return osr;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2268 }
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2269 best = osr;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2270 }
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2271 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2272 }
989
148e5441d916 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 876
diff changeset
2273 osr = osr->osr_link();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2274 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2275 OsrList_lock->unlock();
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2276 if (best != NULL && best->comp_level() >= comp_level && match_level == false) {
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2277 return best;
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1751
diff changeset
2278 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2279 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2280 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2281
a61af66fc99e Initial load
duke
parents:
diff changeset
2282 // -----------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2283 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
2284
a61af66fc99e Initial load
duke
parents:
diff changeset
2285 // Printing
a61af66fc99e Initial load
duke
parents:
diff changeset
2286
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2287 #define BULLET " - "
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2288
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2289 void FieldPrinter::do_field(fieldDescriptor* fd) {
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2290 _st->print(BULLET);
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
2291 if (_obj == NULL) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2292 fd->print_on(_st);
a61af66fc99e Initial load
duke
parents:
diff changeset
2293 _st->cr();
a61af66fc99e Initial load
duke
parents:
diff changeset
2294 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2295 fd->print_on_for(_st, _obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
2296 _st->cr();
a61af66fc99e Initial load
duke
parents:
diff changeset
2297 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2298 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2299
a61af66fc99e Initial load
duke
parents:
diff changeset
2300
a61af66fc99e Initial load
duke
parents:
diff changeset
2301 void instanceKlass::oop_print_on(oop obj, outputStream* st) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2302 Klass::oop_print_on(obj, st);
a61af66fc99e Initial load
duke
parents:
diff changeset
2303
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1039
diff changeset
2304 if (as_klassOop() == SystemDictionary::String_klass()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2305 typeArrayOop value = java_lang_String::value(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
2306 juint offset = java_lang_String::offset(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
2307 juint length = java_lang_String::length(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
2308 if (value != NULL &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2309 value->is_typeArray() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2310 offset <= (juint) value->length() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2311 offset + length <= (juint) value->length()) {
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2312 st->print(BULLET"string: ");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2313 Handle h_obj(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
2314 java_lang_String::print(h_obj, st);
a61af66fc99e Initial load
duke
parents:
diff changeset
2315 st->cr();
a61af66fc99e Initial load
duke
parents:
diff changeset
2316 if (!WizardMode) return; // that is enough
a61af66fc99e Initial load
duke
parents:
diff changeset
2317 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2318 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2319
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2320 st->print_cr(BULLET"---- fields (total size %d words):", oop_size(obj));
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
2321 FieldPrinter print_field(st, obj);
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
2322 do_nonstatic_fields(&print_field);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2323
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1039
diff changeset
2324 if (as_klassOop() == SystemDictionary::Class_klass()) {
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2325 st->print(BULLET"signature: ");
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2326 java_lang_Class::print_signature(obj, st);
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2327 st->cr();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2328 klassOop mirrored_klass = java_lang_Class::as_klassOop(obj);
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2329 st->print(BULLET"fake entry for mirror: ");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2330 mirrored_klass->print_value_on(st);
a61af66fc99e Initial load
duke
parents:
diff changeset
2331 st->cr();
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2332 st->print(BULLET"fake entry resolved_constructor: ");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2333 methodOop ctor = java_lang_Class::resolved_constructor(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
2334 ctor->print_value_on(st);
a61af66fc99e Initial load
duke
parents:
diff changeset
2335 klassOop array_klass = java_lang_Class::array_klass(obj);
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2336 st->cr();
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2337 st->print(BULLET"fake entry for array: ");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2338 array_klass->print_value_on(st);
a61af66fc99e Initial load
duke
parents:
diff changeset
2339 st->cr();
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
2340 st->print_cr(BULLET"fake entry for oop_size: %d", java_lang_Class::oop_size(obj));
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
2341 st->print_cr(BULLET"fake entry for static_oop_field_count: %d", java_lang_Class::static_oop_field_count(obj));
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
2342 klassOop real_klass = java_lang_Class::as_klassOop(obj);
2408
2cd0180da6e1 7032306: Fastdebug build failure on Solaris with SS11 compilers
never
parents: 2376
diff changeset
2343 if (real_klass != NULL && real_klass->klass_part()->oop_is_instance()) {
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
2344 instanceKlass::cast(real_klass)->do_local_static_fields(&print_field);
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
2345 }
1039
987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 997
diff changeset
2346 } else if (as_klassOop() == SystemDictionary::MethodType_klass()) {
987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 997
diff changeset
2347 st->print(BULLET"signature: ");
2357
8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 2334
diff changeset
2348 java_lang_invoke_MethodType::print_signature(obj, st);
1039
987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 997
diff changeset
2349 st->cr();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2350 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2351 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2352
1155
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents: 1144
diff changeset
2353 #endif //PRODUCT
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents: 1144
diff changeset
2354
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2355 void instanceKlass::oop_print_value_on(oop obj, outputStream* st) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2356 st->print("a ");
a61af66fc99e Initial load
duke
parents:
diff changeset
2357 name()->print_value_on(st);
a61af66fc99e Initial load
duke
parents:
diff changeset
2358 obj->print_address_on(st);
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1039
diff changeset
2359 if (as_klassOop() == SystemDictionary::String_klass()
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2360 && java_lang_String::value(obj) != NULL) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2361 ResourceMark rm;
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2362 int len = java_lang_String::length(obj);
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2363 int plen = (len < 24 ? len : 12);
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2364 char* str = java_lang_String::as_utf8_string(obj, 0, plen);
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2365 st->print(" = \"%s\"", str);
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2366 if (len > plen)
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2367 st->print("...[%d]", len);
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1039
diff changeset
2368 } else if (as_klassOop() == SystemDictionary::Class_klass()) {
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2369 klassOop k = java_lang_Class::as_klassOop(obj);
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2370 st->print(" = ");
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2371 if (k != NULL) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2372 k->print_value_on(st);
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2373 } else {
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2374 const char* tname = type2name(java_lang_Class::primitive_type(obj));
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2375 st->print("%s", tname ? tname : "type?");
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2376 }
1039
987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 997
diff changeset
2377 } else if (as_klassOop() == SystemDictionary::MethodType_klass()) {
987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638)
jrose
parents: 997
diff changeset
2378 st->print(" = ");
2357
8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 2334
diff changeset
2379 java_lang_invoke_MethodType::print_signature(obj, st);
665
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2380 } else if (java_lang_boxing_object::is_instance(obj)) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2381 st->print(" = ");
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2382 java_lang_boxing_object::print(obj, st);
c89f86385056 6814659: separable cleanups and subroutines for 6655638
jrose
parents: 605
diff changeset
2383 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2384 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2385
a61af66fc99e Initial load
duke
parents:
diff changeset
2386 const char* instanceKlass::internal_name() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2387 return external_name();
a61af66fc99e Initial load
duke
parents:
diff changeset
2388 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2389
a61af66fc99e Initial load
duke
parents:
diff changeset
2390 // Verification
a61af66fc99e Initial load
duke
parents:
diff changeset
2391
a61af66fc99e Initial load
duke
parents:
diff changeset
2392 class VerifyFieldClosure: public OopClosure {
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2393 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2394 template <class T> void do_oop_work(T* p) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2395 guarantee(Universe::heap()->is_in_closed_subset(p), "should be in heap");
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2396 oop obj = oopDesc::load_decode_heap_oop(p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2397 if (!obj->is_oop_or_null()) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2398 tty->print_cr("Failed: " PTR_FORMAT " -> " PTR_FORMAT, p, (address)obj);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2399 Universe::print();
a61af66fc99e Initial load
duke
parents:
diff changeset
2400 guarantee(false, "boom");
a61af66fc99e Initial load
duke
parents:
diff changeset
2401 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2402 }
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2403 public:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2404 virtual void do_oop(oop* p) { VerifyFieldClosure::do_oop_work(p); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2405 virtual void do_oop(narrowOop* p) { VerifyFieldClosure::do_oop_work(p); }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2406 };
a61af66fc99e Initial load
duke
parents:
diff changeset
2407
a61af66fc99e Initial load
duke
parents:
diff changeset
2408 void instanceKlass::oop_verify_on(oop obj, outputStream* st) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2409 Klass::oop_verify_on(obj, st);
a61af66fc99e Initial load
duke
parents:
diff changeset
2410 VerifyFieldClosure blk;
a61af66fc99e Initial load
duke
parents:
diff changeset
2411 oop_oop_iterate(obj, &blk);
a61af66fc99e Initial load
duke
parents:
diff changeset
2412 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2413
a61af66fc99e Initial load
duke
parents:
diff changeset
2414 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
2415
a61af66fc99e Initial load
duke
parents:
diff changeset
2416 void instanceKlass::verify_class_klass_nonstatic_oop_maps(klassOop k) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2417 // This verification code is disabled. JDK_Version::is_gte_jdk14x_version()
a61af66fc99e Initial load
duke
parents:
diff changeset
2418 // cannot be called since this function is called before the VM is
a61af66fc99e Initial load
duke
parents:
diff changeset
2419 // able to determine what JDK version is running with.
a61af66fc99e Initial load
duke
parents:
diff changeset
2420 // The check below always is false since 1.4.
a61af66fc99e Initial load
duke
parents:
diff changeset
2421 return;
a61af66fc99e Initial load
duke
parents:
diff changeset
2422
a61af66fc99e Initial load
duke
parents:
diff changeset
2423 // This verification code temporarily disabled for the 1.4
a61af66fc99e Initial load
duke
parents:
diff changeset
2424 // reflection implementation since java.lang.Class now has
a61af66fc99e Initial load
duke
parents:
diff changeset
2425 // Java-level instance fields. Should rewrite this to handle this
a61af66fc99e Initial load
duke
parents:
diff changeset
2426 // case.
a61af66fc99e Initial load
duke
parents:
diff changeset
2427 if (!(JDK_Version::is_gte_jdk14x_version() && UseNewReflection)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2428 // Verify that java.lang.Class instances have a fake oop field added.
a61af66fc99e Initial load
duke
parents:
diff changeset
2429 instanceKlass* ik = instanceKlass::cast(k);
a61af66fc99e Initial load
duke
parents:
diff changeset
2430
a61af66fc99e Initial load
duke
parents:
diff changeset
2431 // Check that we have the right class
a61af66fc99e Initial load
duke
parents:
diff changeset
2432 static bool first_time = true;
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1039
diff changeset
2433 guarantee(k == SystemDictionary::Class_klass() && first_time, "Invalid verify of maps");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2434 first_time = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2435 const int extra = java_lang_Class::number_of_fake_oop_fields;
a61af66fc99e Initial load
duke
parents:
diff changeset
2436 guarantee(ik->nonstatic_field_size() == extra, "just checking");
938
b37c246bf7ce 6861660: OopMapBlock count/size confusion
jcoomes
parents: 876
diff changeset
2437 guarantee(ik->nonstatic_oop_map_count() == 1, "just checking");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2438 guarantee(ik->size_helper() == align_object_size(instanceOopDesc::header_size() + extra), "just checking");
a61af66fc99e Initial load
duke
parents:
diff changeset
2439
a61af66fc99e Initial load
duke
parents:
diff changeset
2440 // Check that the map is (2,extra)
a61af66fc99e Initial load
duke
parents:
diff changeset
2441 int offset = java_lang_Class::klass_offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
2442
a61af66fc99e Initial load
duke
parents:
diff changeset
2443 OopMapBlock* map = ik->start_of_nonstatic_oop_maps();
939
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 938
diff changeset
2444 guarantee(map->offset() == offset && map->count() == (unsigned int) extra,
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception
jcoomes
parents: 938
diff changeset
2445 "sanity");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2446 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2447 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2448
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2449 #endif // ndef PRODUCT
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2450
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2451 // JNIid class for jfieldIDs only
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2452 // Note to reviewers:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2453 // These JNI functions are just moved over to column 1 and not changed
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2454 // in the compressed oops workspace.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2455 JNIid::JNIid(klassOop holder, int offset, JNIid* next) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2456 _holder = holder;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2457 _offset = offset;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2458 _next = next;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2459 debug_only(_is_static_field_id = false;)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2460 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2461
a61af66fc99e Initial load
duke
parents:
diff changeset
2462
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2463 JNIid* JNIid::find(int offset) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2464 JNIid* current = this;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2465 while (current != NULL) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2466 if (current->offset() == offset) return current;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2467 current = current->next();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2468 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2469 return NULL;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2470 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2471
a61af66fc99e Initial load
duke
parents:
diff changeset
2472 void JNIid::oops_do(OopClosure* f) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2473 for (JNIid* cur = this; cur != NULL; cur = cur->next()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2474 f->do_oop(cur->holder_addr());
a61af66fc99e Initial load
duke
parents:
diff changeset
2475 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2476 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2477
a61af66fc99e Initial load
duke
parents:
diff changeset
2478 void JNIid::deallocate(JNIid* current) {
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2479 while (current != NULL) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2480 JNIid* next = current->next();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2481 delete current;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2482 current = next;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2483 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2484 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2485
a61af66fc99e Initial load
duke
parents:
diff changeset
2486
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2487 void JNIid::verify(klassOop holder) {
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2357
diff changeset
2488 int first_field_offset = instanceMirrorKlass::offset_of_static_fields();
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2489 int end_field_offset;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2490 end_field_offset = first_field_offset + (instanceKlass::cast(holder)->static_field_size() * wordSize);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2491
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2492 JNIid* current = this;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2493 while (current != NULL) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2494 guarantee(current->holder() == holder, "Invalid klass in JNIid");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2495 #ifdef ASSERT
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2496 int o = current->offset();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2497 if (current->is_static_field_id()) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2498 guarantee(o >= first_field_offset && o < end_field_offset, "Invalid static field offset in JNIid");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2499 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2500 #endif
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2501 current = current->next();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2502 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2503 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2504
a61af66fc99e Initial load
duke
parents:
diff changeset
2505
a61af66fc99e Initial load
duke
parents:
diff changeset
2506 #ifdef ASSERT
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2507 void instanceKlass::set_init_state(ClassState state) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2508 bool good_state = as_klassOop()->is_shared() ? (_init_state <= state)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2509 : (_init_state < state);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2510 assert(good_state || state == allocated, "illegal state transition");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2511 _init_state = state;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2512 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2513 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
2514
a61af66fc99e Initial load
duke
parents:
diff changeset
2515
a61af66fc99e Initial load
duke
parents:
diff changeset
2516 // RedefineClasses() support for previous versions:
a61af66fc99e Initial load
duke
parents:
diff changeset
2517
a61af66fc99e Initial load
duke
parents:
diff changeset
2518 // Add an information node that contains weak references to the
a61af66fc99e Initial load
duke
parents:
diff changeset
2519 // interesting parts of the previous version of the_class.
977
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
2520 // This is also where we clean out any unused weak references.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
2521 // Note that while we delete nodes from the _previous_versions
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
2522 // array, we never delete the array itself until the klass is
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
2523 // unloaded. The has_been_redefined() query depends on that fact.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents: 974
diff changeset
2524 //
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2525 void instanceKlass::add_previous_version(instanceKlassHandle ikh,
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2526 BitMap* emcp_methods, int emcp_method_count) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2527 assert(Thread::current()->is_VM_thread(),
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 52
diff changeset
2528 "only VMThread can add previous versions");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2529
a61af66fc99e Initial load
duke
parents:
diff changeset
2530 if (_previous_versions == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2531 // This is the first previous version so make some space.
a61af66fc99e Initial load
duke
parents:
diff changeset
2532 // Start with 2 elements under the assumption that the class
a61af66fc99e Initial load
duke
parents:
diff changeset
2533 // won't be redefined much.
a61af66fc99e Initial load
duke
parents:
diff changeset
2534 _previous_versions = new (ResourceObj::C_HEAP)
a61af66fc99e Initial load
duke
parents:
diff changeset
2535 GrowableArray<PreviousVersionNode *>(2, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
2536 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2537
a61af66fc99e Initial load
duke
parents:
diff changeset
2538 // RC_TRACE macro has an embedded ResourceMark
a61af66fc99e Initial load
duke
parents:
diff changeset
2539 RC_TRACE(0x00000100, ("adding previous version ref for %s @%d, EMCP_cnt=%d",
a61af66fc99e Initial load
duke
parents:
diff changeset
2540 ikh->external_name(), _previous_versions->length(), emcp_method_count));
a61af66fc99e Initial load
duke
parents:
diff changeset
2541 constantPoolHandle cp_h(ikh->constants());
47
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2542 jobject cp_ref;
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2543 if (cp_h->is_shared()) {
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2544 // a shared ConstantPool requires a regular reference; a weak
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2545 // reference would be collectible
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2546 cp_ref = JNIHandles::make_global(cp_h);
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2547 } else {
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2548 cp_ref = JNIHandles::make_weak_global(cp_h);
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2549 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2550 PreviousVersionNode * pv_node = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2551 objArrayOop old_methods = ikh->methods();
a61af66fc99e Initial load
duke
parents:
diff changeset
2552
a61af66fc99e Initial load
duke
parents:
diff changeset
2553 if (emcp_method_count == 0) {
47
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2554 // non-shared ConstantPool gets a weak reference
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2555 pv_node = new PreviousVersionNode(cp_ref, !cp_h->is_shared(), NULL);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2556 RC_TRACE(0x00000400,
a61af66fc99e Initial load
duke
parents:
diff changeset
2557 ("add: all methods are obsolete; flushing any EMCP weak refs"));
a61af66fc99e Initial load
duke
parents:
diff changeset
2558 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2559 int local_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2560 GrowableArray<jweak>* method_refs = new (ResourceObj::C_HEAP)
a61af66fc99e Initial load
duke
parents:
diff changeset
2561 GrowableArray<jweak>(emcp_method_count, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
2562 for (int i = 0; i < old_methods->length(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2563 if (emcp_methods->at(i)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2564 // this old method is EMCP so save a weak ref
a61af66fc99e Initial load
duke
parents:
diff changeset
2565 methodOop old_method = (methodOop) old_methods->obj_at(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
2566 methodHandle old_method_h(old_method);
a61af66fc99e Initial load
duke
parents:
diff changeset
2567 jweak method_ref = JNIHandles::make_weak_global(old_method_h);
a61af66fc99e Initial load
duke
parents:
diff changeset
2568 method_refs->append(method_ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2569 if (++local_count >= emcp_method_count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2570 // no more EMCP methods so bail out now
a61af66fc99e Initial load
duke
parents:
diff changeset
2571 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2572 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2573 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2574 }
47
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2575 // non-shared ConstantPool gets a weak reference
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2576 pv_node = new PreviousVersionNode(cp_ref, !cp_h->is_shared(), method_refs);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2577 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2578
a61af66fc99e Initial load
duke
parents:
diff changeset
2579 _previous_versions->append(pv_node);
a61af66fc99e Initial load
duke
parents:
diff changeset
2580
a61af66fc99e Initial load
duke
parents:
diff changeset
2581 // Using weak references allows the interesting parts of previous
a61af66fc99e Initial load
duke
parents:
diff changeset
2582 // classes to be GC'ed when they are no longer needed. Since the
a61af66fc99e Initial load
duke
parents:
diff changeset
2583 // caller is the VMThread and we are at a safepoint, this is a good
a61af66fc99e Initial load
duke
parents:
diff changeset
2584 // time to clear out unused weak references.
a61af66fc99e Initial load
duke
parents:
diff changeset
2585
a61af66fc99e Initial load
duke
parents:
diff changeset
2586 RC_TRACE(0x00000400, ("add: previous version length=%d",
a61af66fc99e Initial load
duke
parents:
diff changeset
2587 _previous_versions->length()));
a61af66fc99e Initial load
duke
parents:
diff changeset
2588
a61af66fc99e Initial load
duke
parents:
diff changeset
2589 // skip the last entry since we just added it
a61af66fc99e Initial load
duke
parents:
diff changeset
2590 for (int i = _previous_versions->length() - 2; i >= 0; i--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2591 // check the previous versions array for a GC'ed weak refs
a61af66fc99e Initial load
duke
parents:
diff changeset
2592 pv_node = _previous_versions->at(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
2593 cp_ref = pv_node->prev_constant_pool();
47
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2594 assert(cp_ref != NULL, "cp ref was unexpectedly cleared");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2595 if (cp_ref == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2596 delete pv_node;
a61af66fc99e Initial load
duke
parents:
diff changeset
2597 _previous_versions->remove_at(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
2598 // Since we are traversing the array backwards, we don't have to
a61af66fc99e Initial load
duke
parents:
diff changeset
2599 // do anything special with the index.
a61af66fc99e Initial load
duke
parents:
diff changeset
2600 continue; // robustness
a61af66fc99e Initial load
duke
parents:
diff changeset
2601 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2602
a61af66fc99e Initial load
duke
parents:
diff changeset
2603 constantPoolOop cp = (constantPoolOop)JNIHandles::resolve(cp_ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2604 if (cp == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2605 // this entry has been GC'ed so remove it
a61af66fc99e Initial load
duke
parents:
diff changeset
2606 delete pv_node;
a61af66fc99e Initial load
duke
parents:
diff changeset
2607 _previous_versions->remove_at(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
2608 // Since we are traversing the array backwards, we don't have to
a61af66fc99e Initial load
duke
parents:
diff changeset
2609 // do anything special with the index.
a61af66fc99e Initial load
duke
parents:
diff changeset
2610 continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
2611 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2612 RC_TRACE(0x00000400, ("add: previous version @%d is alive", i));
a61af66fc99e Initial load
duke
parents:
diff changeset
2613 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2614
a61af66fc99e Initial load
duke
parents:
diff changeset
2615 GrowableArray<jweak>* method_refs = pv_node->prev_EMCP_methods();
a61af66fc99e Initial load
duke
parents:
diff changeset
2616 if (method_refs != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2617 RC_TRACE(0x00000400, ("add: previous methods length=%d",
a61af66fc99e Initial load
duke
parents:
diff changeset
2618 method_refs->length()));
a61af66fc99e Initial load
duke
parents:
diff changeset
2619 for (int j = method_refs->length() - 1; j >= 0; j--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2620 jweak method_ref = method_refs->at(j);
a61af66fc99e Initial load
duke
parents:
diff changeset
2621 assert(method_ref != NULL, "weak method ref was unexpectedly cleared");
a61af66fc99e Initial load
duke
parents:
diff changeset
2622 if (method_ref == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2623 method_refs->remove_at(j);
a61af66fc99e Initial load
duke
parents:
diff changeset
2624 // Since we are traversing the array backwards, we don't have to
a61af66fc99e Initial load
duke
parents:
diff changeset
2625 // do anything special with the index.
a61af66fc99e Initial load
duke
parents:
diff changeset
2626 continue; // robustness
a61af66fc99e Initial load
duke
parents:
diff changeset
2627 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2628
a61af66fc99e Initial load
duke
parents:
diff changeset
2629 methodOop method = (methodOop)JNIHandles::resolve(method_ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2630 if (method == NULL || emcp_method_count == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2631 // This method entry has been GC'ed or the current
a61af66fc99e Initial load
duke
parents:
diff changeset
2632 // RedefineClasses() call has made all methods obsolete
a61af66fc99e Initial load
duke
parents:
diff changeset
2633 // so remove it.
a61af66fc99e Initial load
duke
parents:
diff changeset
2634 JNIHandles::destroy_weak_global(method_ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2635 method_refs->remove_at(j);
a61af66fc99e Initial load
duke
parents:
diff changeset
2636 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2637 // RC_TRACE macro has an embedded ResourceMark
a61af66fc99e Initial load
duke
parents:
diff changeset
2638 RC_TRACE(0x00000400,
a61af66fc99e Initial load
duke
parents:
diff changeset
2639 ("add: %s(%s): previous method @%d in version @%d is alive",
a61af66fc99e Initial load
duke
parents:
diff changeset
2640 method->name()->as_C_string(), method->signature()->as_C_string(),
a61af66fc99e Initial load
duke
parents:
diff changeset
2641 j, i));
a61af66fc99e Initial load
duke
parents:
diff changeset
2642 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2643 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2644 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2645 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2646
a61af66fc99e Initial load
duke
parents:
diff changeset
2647 int obsolete_method_count = old_methods->length() - emcp_method_count;
a61af66fc99e Initial load
duke
parents:
diff changeset
2648
a61af66fc99e Initial load
duke
parents:
diff changeset
2649 if (emcp_method_count != 0 && obsolete_method_count != 0 &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2650 _previous_versions->length() > 1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2651 // We have a mix of obsolete and EMCP methods. If there is more
a61af66fc99e Initial load
duke
parents:
diff changeset
2652 // than the previous version that we just added, then we have to
a61af66fc99e Initial load
duke
parents:
diff changeset
2653 // clear out any matching EMCP method entries the hard way.
a61af66fc99e Initial load
duke
parents:
diff changeset
2654 int local_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2655 for (int i = 0; i < old_methods->length(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2656 if (!emcp_methods->at(i)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2657 // only obsolete methods are interesting
a61af66fc99e Initial load
duke
parents:
diff changeset
2658 methodOop old_method = (methodOop) old_methods->obj_at(i);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
2659 Symbol* m_name = old_method->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1972
diff changeset
2660 Symbol* m_signature = old_method->signature();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2661
a61af66fc99e Initial load
duke
parents:
diff changeset
2662 // skip the last entry since we just added it
a61af66fc99e Initial load
duke
parents:
diff changeset
2663 for (int j = _previous_versions->length() - 2; j >= 0; j--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2664 // check the previous versions array for a GC'ed weak refs
a61af66fc99e Initial load
duke
parents:
diff changeset
2665 pv_node = _previous_versions->at(j);
a61af66fc99e Initial load
duke
parents:
diff changeset
2666 cp_ref = pv_node->prev_constant_pool();
47
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2667 assert(cp_ref != NULL, "cp ref was unexpectedly cleared");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2668 if (cp_ref == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2669 delete pv_node;
a61af66fc99e Initial load
duke
parents:
diff changeset
2670 _previous_versions->remove_at(j);
a61af66fc99e Initial load
duke
parents:
diff changeset
2671 // Since we are traversing the array backwards, we don't have to
a61af66fc99e Initial load
duke
parents:
diff changeset
2672 // do anything special with the index.
a61af66fc99e Initial load
duke
parents:
diff changeset
2673 continue; // robustness
a61af66fc99e Initial load
duke
parents:
diff changeset
2674 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2675
a61af66fc99e Initial load
duke
parents:
diff changeset
2676 constantPoolOop cp = (constantPoolOop)JNIHandles::resolve(cp_ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2677 if (cp == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2678 // this entry has been GC'ed so remove it
a61af66fc99e Initial load
duke
parents:
diff changeset
2679 delete pv_node;
a61af66fc99e Initial load
duke
parents:
diff changeset
2680 _previous_versions->remove_at(j);
a61af66fc99e Initial load
duke
parents:
diff changeset
2681 // Since we are traversing the array backwards, we don't have to
a61af66fc99e Initial load
duke
parents:
diff changeset
2682 // do anything special with the index.
a61af66fc99e Initial load
duke
parents:
diff changeset
2683 continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
2684 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2685
a61af66fc99e Initial load
duke
parents:
diff changeset
2686 GrowableArray<jweak>* method_refs = pv_node->prev_EMCP_methods();
a61af66fc99e Initial load
duke
parents:
diff changeset
2687 if (method_refs == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2688 // We have run into a PreviousVersion generation where
a61af66fc99e Initial load
duke
parents:
diff changeset
2689 // all methods were made obsolete during that generation's
a61af66fc99e Initial load
duke
parents:
diff changeset
2690 // RedefineClasses() operation. At the time of that
a61af66fc99e Initial load
duke
parents:
diff changeset
2691 // operation, all EMCP methods were flushed so we don't
a61af66fc99e Initial load
duke
parents:
diff changeset
2692 // have to go back any further.
a61af66fc99e Initial load
duke
parents:
diff changeset
2693 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2694 // A NULL method_refs is different than an empty method_refs.
a61af66fc99e Initial load
duke
parents:
diff changeset
2695 // We cannot infer any optimizations about older generations
a61af66fc99e Initial load
duke
parents:
diff changeset
2696 // from an empty method_refs for the current generation.
a61af66fc99e Initial load
duke
parents:
diff changeset
2697 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2698 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2699
a61af66fc99e Initial load
duke
parents:
diff changeset
2700 for (int k = method_refs->length() - 1; k >= 0; k--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2701 jweak method_ref = method_refs->at(k);
a61af66fc99e Initial load
duke
parents:
diff changeset
2702 assert(method_ref != NULL,
a61af66fc99e Initial load
duke
parents:
diff changeset
2703 "weak method ref was unexpectedly cleared");
a61af66fc99e Initial load
duke
parents:
diff changeset
2704 if (method_ref == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2705 method_refs->remove_at(k);
a61af66fc99e Initial load
duke
parents:
diff changeset
2706 // Since we are traversing the array backwards, we don't
a61af66fc99e Initial load
duke
parents:
diff changeset
2707 // have to do anything special with the index.
a61af66fc99e Initial load
duke
parents:
diff changeset
2708 continue; // robustness
a61af66fc99e Initial load
duke
parents:
diff changeset
2709 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2710
a61af66fc99e Initial load
duke
parents:
diff changeset
2711 methodOop method = (methodOop)JNIHandles::resolve(method_ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2712 if (method == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2713 // this method entry has been GC'ed so skip it
a61af66fc99e Initial load
duke
parents:
diff changeset
2714 JNIHandles::destroy_weak_global(method_ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2715 method_refs->remove_at(k);
a61af66fc99e Initial load
duke
parents:
diff changeset
2716 continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
2717 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2718
a61af66fc99e Initial load
duke
parents:
diff changeset
2719 if (method->name() == m_name &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2720 method->signature() == m_signature) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2721 // The current RedefineClasses() call has made all EMCP
a61af66fc99e Initial load
duke
parents:
diff changeset
2722 // versions of this method obsolete so mark it as obsolete
a61af66fc99e Initial load
duke
parents:
diff changeset
2723 // and remove the weak ref.
a61af66fc99e Initial load
duke
parents:
diff changeset
2724 RC_TRACE(0x00000400,
a61af66fc99e Initial load
duke
parents:
diff changeset
2725 ("add: %s(%s): flush obsolete method @%d in version @%d",
a61af66fc99e Initial load
duke
parents:
diff changeset
2726 m_name->as_C_string(), m_signature->as_C_string(), k, j));
a61af66fc99e Initial load
duke
parents:
diff changeset
2727
a61af66fc99e Initial load
duke
parents:
diff changeset
2728 method->set_is_obsolete();
a61af66fc99e Initial load
duke
parents:
diff changeset
2729 JNIHandles::destroy_weak_global(method_ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2730 method_refs->remove_at(k);
a61af66fc99e Initial load
duke
parents:
diff changeset
2731 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2732 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2733 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2734
a61af66fc99e Initial load
duke
parents:
diff changeset
2735 // The previous loop may not find a matching EMCP method, but
a61af66fc99e Initial load
duke
parents:
diff changeset
2736 // that doesn't mean that we can optimize and not go any
a61af66fc99e Initial load
duke
parents:
diff changeset
2737 // further back in the PreviousVersion generations. The EMCP
a61af66fc99e Initial load
duke
parents:
diff changeset
2738 // method for this generation could have already been GC'ed,
a61af66fc99e Initial load
duke
parents:
diff changeset
2739 // but there still may be an older EMCP method that has not
a61af66fc99e Initial load
duke
parents:
diff changeset
2740 // been GC'ed.
a61af66fc99e Initial load
duke
parents:
diff changeset
2741 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2742
a61af66fc99e Initial load
duke
parents:
diff changeset
2743 if (++local_count >= obsolete_method_count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2744 // no more obsolete methods so bail out now
a61af66fc99e Initial load
duke
parents:
diff changeset
2745 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2746 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2747 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2748 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2749 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2750 } // end add_previous_version()
a61af66fc99e Initial load
duke
parents:
diff changeset
2751
a61af66fc99e Initial load
duke
parents:
diff changeset
2752
a61af66fc99e Initial load
duke
parents:
diff changeset
2753 // Determine if instanceKlass has a previous version.
a61af66fc99e Initial load
duke
parents:
diff changeset
2754 bool instanceKlass::has_previous_version() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2755 if (_previous_versions == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2756 // no previous versions array so answer is easy
a61af66fc99e Initial load
duke
parents:
diff changeset
2757 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2758 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2759
a61af66fc99e Initial load
duke
parents:
diff changeset
2760 for (int i = _previous_versions->length() - 1; i >= 0; i--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2761 // Check the previous versions array for an info node that hasn't
a61af66fc99e Initial load
duke
parents:
diff changeset
2762 // been GC'ed
a61af66fc99e Initial load
duke
parents:
diff changeset
2763 PreviousVersionNode * pv_node = _previous_versions->at(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
2764
47
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2765 jobject cp_ref = pv_node->prev_constant_pool();
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2766 assert(cp_ref != NULL, "cp reference was unexpectedly cleared");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2767 if (cp_ref == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2768 continue; // robustness
a61af66fc99e Initial load
duke
parents:
diff changeset
2769 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2770
a61af66fc99e Initial load
duke
parents:
diff changeset
2771 constantPoolOop cp = (constantPoolOop)JNIHandles::resolve(cp_ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2772 if (cp != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2773 // we have at least one previous version
a61af66fc99e Initial load
duke
parents:
diff changeset
2774 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2775 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2776
a61af66fc99e Initial load
duke
parents:
diff changeset
2777 // We don't have to check the method refs. If the constant pool has
a61af66fc99e Initial load
duke
parents:
diff changeset
2778 // been GC'ed then so have the methods.
a61af66fc99e Initial load
duke
parents:
diff changeset
2779 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2780
a61af66fc99e Initial load
duke
parents:
diff changeset
2781 // all of the underlying nodes' info has been GC'ed
a61af66fc99e Initial load
duke
parents:
diff changeset
2782 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2783 } // end has_previous_version()
a61af66fc99e Initial load
duke
parents:
diff changeset
2784
a61af66fc99e Initial load
duke
parents:
diff changeset
2785 methodOop instanceKlass::method_with_idnum(int idnum) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2786 methodOop m = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2787 if (idnum < methods()->length()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2788 m = (methodOop) methods()->obj_at(idnum);
a61af66fc99e Initial load
duke
parents:
diff changeset
2789 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2790 if (m == NULL || m->method_idnum() != idnum) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2791 for (int index = 0; index < methods()->length(); ++index) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2792 m = (methodOop) methods()->obj_at(index);
a61af66fc99e Initial load
duke
parents:
diff changeset
2793 if (m->method_idnum() == idnum) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2794 return m;
a61af66fc99e Initial load
duke
parents:
diff changeset
2795 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2796 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2797 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2798 return m;
a61af66fc99e Initial load
duke
parents:
diff changeset
2799 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2800
a61af66fc99e Initial load
duke
parents:
diff changeset
2801
a61af66fc99e Initial load
duke
parents:
diff changeset
2802 // Set the annotation at 'idnum' to 'anno'.
a61af66fc99e Initial load
duke
parents:
diff changeset
2803 // We don't want to create or extend the array if 'anno' is NULL, since that is the
a61af66fc99e Initial load
duke
parents:
diff changeset
2804 // default value. However, if the array exists and is long enough, we must set NULL values.
a61af66fc99e Initial load
duke
parents:
diff changeset
2805 void instanceKlass::set_methods_annotations_of(int idnum, typeArrayOop anno, objArrayOop* md_p) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2806 objArrayOop md = *md_p;
a61af66fc99e Initial load
duke
parents:
diff changeset
2807 if (md != NULL && md->length() > idnum) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2808 md->obj_at_put(idnum, anno);
a61af66fc99e Initial load
duke
parents:
diff changeset
2809 } else if (anno != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2810 // create the array
a61af66fc99e Initial load
duke
parents:
diff changeset
2811 int length = MAX2(idnum+1, (int)_idnum_allocated_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
2812 md = oopFactory::new_system_objArray(length, Thread::current());
a61af66fc99e Initial load
duke
parents:
diff changeset
2813 if (*md_p != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2814 // copy the existing entries
a61af66fc99e Initial load
duke
parents:
diff changeset
2815 for (int index = 0; index < (*md_p)->length(); index++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2816 md->obj_at_put(index, (*md_p)->obj_at(index));
a61af66fc99e Initial load
duke
parents:
diff changeset
2817 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2818 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2819 set_annotations(md, md_p);
a61af66fc99e Initial load
duke
parents:
diff changeset
2820 md->obj_at_put(idnum, anno);
a61af66fc99e Initial load
duke
parents:
diff changeset
2821 } // if no array and idnum isn't included there is nothing to do
a61af66fc99e Initial load
duke
parents:
diff changeset
2822 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2823
a61af66fc99e Initial load
duke
parents:
diff changeset
2824 // Construct a PreviousVersionNode entry for the array hung off
a61af66fc99e Initial load
duke
parents:
diff changeset
2825 // the instanceKlass.
47
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2826 PreviousVersionNode::PreviousVersionNode(jobject prev_constant_pool,
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2827 bool prev_cp_is_weak, GrowableArray<jweak>* prev_EMCP_methods) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2828
a61af66fc99e Initial load
duke
parents:
diff changeset
2829 _prev_constant_pool = prev_constant_pool;
47
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2830 _prev_cp_is_weak = prev_cp_is_weak;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2831 _prev_EMCP_methods = prev_EMCP_methods;
a61af66fc99e Initial load
duke
parents:
diff changeset
2832 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2833
a61af66fc99e Initial load
duke
parents:
diff changeset
2834
a61af66fc99e Initial load
duke
parents:
diff changeset
2835 // Destroy a PreviousVersionNode
a61af66fc99e Initial load
duke
parents:
diff changeset
2836 PreviousVersionNode::~PreviousVersionNode() {
a61af66fc99e Initial load
duke
parents:
diff changeset
2837 if (_prev_constant_pool != NULL) {
47
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2838 if (_prev_cp_is_weak) {
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2839 JNIHandles::destroy_weak_global(_prev_constant_pool);
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2840 } else {
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2841 JNIHandles::destroy_global(_prev_constant_pool);
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2842 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2843 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2844
a61af66fc99e Initial load
duke
parents:
diff changeset
2845 if (_prev_EMCP_methods != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2846 for (int i = _prev_EMCP_methods->length() - 1; i >= 0; i--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2847 jweak method_ref = _prev_EMCP_methods->at(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
2848 if (method_ref != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2849 JNIHandles::destroy_weak_global(method_ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2850 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2851 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2852 delete _prev_EMCP_methods;
a61af66fc99e Initial load
duke
parents:
diff changeset
2853 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2854 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2855
a61af66fc99e Initial load
duke
parents:
diff changeset
2856
a61af66fc99e Initial load
duke
parents:
diff changeset
2857 // Construct a PreviousVersionInfo entry
a61af66fc99e Initial load
duke
parents:
diff changeset
2858 PreviousVersionInfo::PreviousVersionInfo(PreviousVersionNode *pv_node) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2859 _prev_constant_pool_handle = constantPoolHandle(); // NULL handle
a61af66fc99e Initial load
duke
parents:
diff changeset
2860 _prev_EMCP_method_handles = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2861
47
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2862 jobject cp_ref = pv_node->prev_constant_pool();
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents: 0
diff changeset
2863 assert(cp_ref != NULL, "constant pool ref was unexpectedly cleared");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2864 if (cp_ref == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2865 return; // robustness
a61af66fc99e Initial load
duke
parents:
diff changeset
2866 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2867
a61af66fc99e Initial load
duke
parents:
diff changeset
2868 constantPoolOop cp = (constantPoolOop)JNIHandles::resolve(cp_ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2869 if (cp == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2870 // Weak reference has been GC'ed. Since the constant pool has been
a61af66fc99e Initial load
duke
parents:
diff changeset
2871 // GC'ed, the methods have also been GC'ed.
a61af66fc99e Initial load
duke
parents:
diff changeset
2872 return;
a61af66fc99e Initial load
duke
parents:
diff changeset
2873 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2874
a61af66fc99e Initial load
duke
parents:
diff changeset
2875 // make the constantPoolOop safe to return
a61af66fc99e Initial load
duke
parents:
diff changeset
2876 _prev_constant_pool_handle = constantPoolHandle(cp);
a61af66fc99e Initial load
duke
parents:
diff changeset
2877
a61af66fc99e Initial load
duke
parents:
diff changeset
2878 GrowableArray<jweak>* method_refs = pv_node->prev_EMCP_methods();
a61af66fc99e Initial load
duke
parents:
diff changeset
2879 if (method_refs == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2880 // the instanceKlass did not have any EMCP methods
a61af66fc99e Initial load
duke
parents:
diff changeset
2881 return;
a61af66fc99e Initial load
duke
parents:
diff changeset
2882 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2883
a61af66fc99e Initial load
duke
parents:
diff changeset
2884 _prev_EMCP_method_handles = new GrowableArray<methodHandle>(10);
a61af66fc99e Initial load
duke
parents:
diff changeset
2885
a61af66fc99e Initial load
duke
parents:
diff changeset
2886 int n_methods = method_refs->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
2887 for (int i = 0; i < n_methods; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2888 jweak method_ref = method_refs->at(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
2889 assert(method_ref != NULL, "weak method ref was unexpectedly cleared");
a61af66fc99e Initial load
duke
parents:
diff changeset
2890 if (method_ref == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2891 continue; // robustness
a61af66fc99e Initial load
duke
parents:
diff changeset
2892 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2893
a61af66fc99e Initial load
duke
parents:
diff changeset
2894 methodOop method = (methodOop)JNIHandles::resolve(method_ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2895 if (method == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2896 // this entry has been GC'ed so skip it
a61af66fc99e Initial load
duke
parents:
diff changeset
2897 continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
2898 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2899
a61af66fc99e Initial load
duke
parents:
diff changeset
2900 // make the methodOop safe to return
a61af66fc99e Initial load
duke
parents:
diff changeset
2901 _prev_EMCP_method_handles->append(methodHandle(method));
a61af66fc99e Initial load
duke
parents:
diff changeset
2902 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2903 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2904
a61af66fc99e Initial load
duke
parents:
diff changeset
2905
a61af66fc99e Initial load
duke
parents:
diff changeset
2906 // Destroy a PreviousVersionInfo
a61af66fc99e Initial load
duke
parents:
diff changeset
2907 PreviousVersionInfo::~PreviousVersionInfo() {
a61af66fc99e Initial load
duke
parents:
diff changeset
2908 // Since _prev_EMCP_method_handles is not C-heap allocated, we
a61af66fc99e Initial load
duke
parents:
diff changeset
2909 // don't have to delete it.
a61af66fc99e Initial load
duke
parents:
diff changeset
2910 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2911
a61af66fc99e Initial load
duke
parents:
diff changeset
2912
a61af66fc99e Initial load
duke
parents:
diff changeset
2913 // Construct a helper for walking the previous versions array
a61af66fc99e Initial load
duke
parents:
diff changeset
2914 PreviousVersionWalker::PreviousVersionWalker(instanceKlass *ik) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2915 _previous_versions = ik->previous_versions();
a61af66fc99e Initial load
duke
parents:
diff changeset
2916 _current_index = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2917 // _hm needs no initialization
a61af66fc99e Initial load
duke
parents:
diff changeset
2918 _current_p = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2919 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2920
a61af66fc99e Initial load
duke
parents:
diff changeset
2921
a61af66fc99e Initial load
duke
parents:
diff changeset
2922 // Destroy a PreviousVersionWalker
a61af66fc99e Initial load
duke
parents:
diff changeset
2923 PreviousVersionWalker::~PreviousVersionWalker() {
a61af66fc99e Initial load
duke
parents:
diff changeset
2924 // Delete the current info just in case the caller didn't walk to
a61af66fc99e Initial load
duke
parents:
diff changeset
2925 // the end of the previous versions list. No harm if _current_p is
a61af66fc99e Initial load
duke
parents:
diff changeset
2926 // already NULL.
a61af66fc99e Initial load
duke
parents:
diff changeset
2927 delete _current_p;
a61af66fc99e Initial load
duke
parents:
diff changeset
2928
a61af66fc99e Initial load
duke
parents:
diff changeset
2929 // When _hm is destroyed, all the Handles returned in
a61af66fc99e Initial load
duke
parents:
diff changeset
2930 // PreviousVersionInfo objects will be destroyed.
a61af66fc99e Initial load
duke
parents:
diff changeset
2931 // Also, after this destructor is finished it will be
a61af66fc99e Initial load
duke
parents:
diff changeset
2932 // safe to delete the GrowableArray allocated in the
a61af66fc99e Initial load
duke
parents:
diff changeset
2933 // PreviousVersionInfo objects.
a61af66fc99e Initial load
duke
parents:
diff changeset
2934 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2935
a61af66fc99e Initial load
duke
parents:
diff changeset
2936
a61af66fc99e Initial load
duke
parents:
diff changeset
2937 // Return the interesting information for the next previous version
a61af66fc99e Initial load
duke
parents:
diff changeset
2938 // of the klass. Returns NULL if there are no more previous versions.
a61af66fc99e Initial load
duke
parents:
diff changeset
2939 PreviousVersionInfo* PreviousVersionWalker::next_previous_version() {
a61af66fc99e Initial load
duke
parents:
diff changeset
2940 if (_previous_versions == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2941 // no previous versions so nothing to return
a61af66fc99e Initial load
duke
parents:
diff changeset
2942 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2943 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2944
a61af66fc99e Initial load
duke
parents:
diff changeset
2945 delete _current_p; // cleanup the previous info for the caller
a61af66fc99e Initial load
duke
parents:
diff changeset
2946 _current_p = NULL; // reset to NULL so we don't delete same object twice
a61af66fc99e Initial load
duke
parents:
diff changeset
2947
a61af66fc99e Initial load
duke
parents:
diff changeset
2948 int length = _previous_versions->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
2949
a61af66fc99e Initial load
duke
parents:
diff changeset
2950 while (_current_index < length) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2951 PreviousVersionNode * pv_node = _previous_versions->at(_current_index++);
a61af66fc99e Initial load
duke
parents:
diff changeset
2952 PreviousVersionInfo * pv_info = new (ResourceObj::C_HEAP)
a61af66fc99e Initial load
duke
parents:
diff changeset
2953 PreviousVersionInfo(pv_node);
a61af66fc99e Initial load
duke
parents:
diff changeset
2954
a61af66fc99e Initial load
duke
parents:
diff changeset
2955 constantPoolHandle cp_h = pv_info->prev_constant_pool_handle();
a61af66fc99e Initial load
duke
parents:
diff changeset
2956 if (cp_h.is_null()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2957 delete pv_info;
a61af66fc99e Initial load
duke
parents:
diff changeset
2958
a61af66fc99e Initial load
duke
parents:
diff changeset
2959 // The underlying node's info has been GC'ed so try the next one.
a61af66fc99e Initial load
duke
parents:
diff changeset
2960 // We don't have to check the methods. If the constant pool has
a61af66fc99e Initial load
duke
parents:
diff changeset
2961 // GC'ed then so have the methods.
a61af66fc99e Initial load
duke
parents:
diff changeset
2962 continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
2963 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2964
a61af66fc99e Initial load
duke
parents:
diff changeset
2965 // Found a node with non GC'ed info so return it. The caller will
a61af66fc99e Initial load
duke
parents:
diff changeset
2966 // need to delete pv_info when they are done with it.
a61af66fc99e Initial load
duke
parents:
diff changeset
2967 _current_p = pv_info;
a61af66fc99e Initial load
duke
parents:
diff changeset
2968 return pv_info;
a61af66fc99e Initial load
duke
parents:
diff changeset
2969 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2970
a61af66fc99e Initial load
duke
parents:
diff changeset
2971 // all of the underlying nodes' info has been GC'ed
a61af66fc99e Initial load
duke
parents:
diff changeset
2972 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2973 } // end next_previous_version()