Mercurial > hg > graal-jvmci-8
comparison src/share/vm/oops/objArrayKlass.cpp @ 6948:e522a00b91aa
Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works
author | Doug Simon <doug.simon@oracle.com> |
---|---|
date | Mon, 12 Nov 2012 23:14:12 +0100 |
parents | 6e5a59a8e4a7 |
children | 070d523b96a7 |
comparison
equal
deleted
inserted
replaced
6711:ae13cc658b80 | 6948:e522a00b91aa |
---|---|
21 * questions. | 21 * questions. |
22 * | 22 * |
23 */ | 23 */ |
24 | 24 |
25 #include "precompiled.hpp" | 25 #include "precompiled.hpp" |
26 #include "classfile/symbolTable.hpp" | |
26 #include "classfile/systemDictionary.hpp" | 27 #include "classfile/systemDictionary.hpp" |
27 #include "classfile/vmSymbols.hpp" | 28 #include "classfile/vmSymbols.hpp" |
28 #include "gc_implementation/shared/markSweep.inline.hpp" | 29 #include "gc_implementation/shared/markSweep.inline.hpp" |
29 #include "gc_interface/collectedHeap.inline.hpp" | 30 #include "gc_interface/collectedHeap.inline.hpp" |
30 #include "memory/genOopClosures.inline.hpp" | 31 #include "memory/genOopClosures.inline.hpp" |
32 #include "memory/metadataFactory.hpp" | |
31 #include "memory/resourceArea.hpp" | 33 #include "memory/resourceArea.hpp" |
32 #include "memory/universe.inline.hpp" | 34 #include "memory/universe.inline.hpp" |
33 #include "oops/instanceKlass.hpp" | 35 #include "oops/instanceKlass.hpp" |
36 #include "oops/klass.inline.hpp" | |
34 #include "oops/objArrayKlass.hpp" | 37 #include "oops/objArrayKlass.hpp" |
35 #include "oops/objArrayKlass.inline.hpp" | 38 #include "oops/objArrayKlass.inline.hpp" |
36 #include "oops/objArrayKlassKlass.hpp" | |
37 #include "oops/objArrayOop.hpp" | 39 #include "oops/objArrayOop.hpp" |
38 #include "oops/oop.inline.hpp" | 40 #include "oops/oop.inline.hpp" |
39 #include "oops/oop.inline2.hpp" | 41 #include "oops/oop.inline2.hpp" |
40 #include "oops/symbol.hpp" | 42 #include "oops/symbol.hpp" |
41 #include "runtime/handles.inline.hpp" | 43 #include "runtime/handles.inline.hpp" |
42 #include "runtime/mutexLocker.hpp" | 44 #include "runtime/mutexLocker.hpp" |
43 #include "utilities/copy.hpp" | 45 #include "utilities/copy.hpp" |
44 #ifndef SERIALGC | 46 #ifndef SERIALGC |
47 #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp" | |
45 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | 48 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" |
46 #include "gc_implementation/g1/g1OopClosures.inline.hpp" | 49 #include "gc_implementation/g1/g1OopClosures.inline.hpp" |
47 #include "gc_implementation/g1/g1RemSet.inline.hpp" | 50 #include "gc_implementation/g1/g1RemSet.inline.hpp" |
48 #include "gc_implementation/g1/heapRegionSeq.inline.hpp" | 51 #include "gc_implementation/g1/heapRegionSeq.inline.hpp" |
49 #include "gc_implementation/parNew/parOopClosures.inline.hpp" | 52 #include "gc_implementation/parNew/parOopClosures.inline.hpp" |
51 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp" | 54 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp" |
52 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp" | 55 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp" |
53 #include "oops/oop.pcgc.inline.hpp" | 56 #include "oops/oop.pcgc.inline.hpp" |
54 #endif | 57 #endif |
55 | 58 |
56 int objArrayKlass::oop_size(oop obj) const { | 59 ObjArrayKlass* ObjArrayKlass::allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS) { |
60 assert(ObjArrayKlass::header_size() <= InstanceKlass::header_size(), | |
61 "array klasses must be same size as InstanceKlass"); | |
62 | |
63 int size = ArrayKlass::static_size(ObjArrayKlass::header_size()); | |
64 | |
65 return new (loader_data, size, THREAD) ObjArrayKlass(n, klass_handle, name); | |
66 } | |
67 | |
68 Klass* ObjArrayKlass::allocate_objArray_klass(ClassLoaderData* loader_data, | |
69 int n, KlassHandle element_klass, TRAPS) { | |
70 | |
71 // Eagerly allocate the direct array supertype. | |
72 KlassHandle super_klass = KlassHandle(); | |
73 if (!Universe::is_bootstrapping() || SystemDictionary::Object_klass_loaded()) { | |
74 KlassHandle element_super (THREAD, element_klass->super()); | |
75 if (element_super.not_null()) { | |
76 // The element type has a direct super. E.g., String[] has direct super of Object[]. | |
77 super_klass = KlassHandle(THREAD, element_super->array_klass_or_null()); | |
78 bool supers_exist = super_klass.not_null(); | |
79 // Also, see if the element has secondary supertypes. | |
80 // We need an array type for each. | |
81 Array<Klass*>* element_supers = element_klass->secondary_supers(); | |
82 for( int i = element_supers->length()-1; i >= 0; i-- ) { | |
83 Klass* elem_super = element_supers->at(i); | |
84 if (Klass::cast(elem_super)->array_klass_or_null() == NULL) { | |
85 supers_exist = false; | |
86 break; | |
87 } | |
88 } | |
89 if (!supers_exist) { | |
90 // Oops. Not allocated yet. Back out, allocate it, and retry. | |
91 #ifndef PRODUCT | |
92 if (WizardMode) { | |
93 tty->print_cr("Must retry array klass creation for depth %d",n); | |
94 } | |
95 #endif | |
96 KlassHandle ek; | |
97 { | |
98 MutexUnlocker mu(MultiArray_lock); | |
99 MutexUnlocker mc(Compile_lock); // for vtables | |
100 Klass* sk = element_super->array_klass(CHECK_0); | |
101 super_klass = KlassHandle(THREAD, sk); | |
102 for( int i = element_supers->length()-1; i >= 0; i-- ) { | |
103 KlassHandle elem_super (THREAD, element_supers->at(i)); | |
104 elem_super->array_klass(CHECK_0); | |
105 } | |
106 // Now retry from the beginning | |
107 Klass* klass_oop = element_klass->array_klass(n, CHECK_0); | |
108 // Create a handle because the enclosing brace, when locking | |
109 // can cause a gc. Better to have this function return a Handle. | |
110 ek = KlassHandle(THREAD, klass_oop); | |
111 } // re-lock | |
112 return ek(); | |
113 } | |
114 } else { | |
115 // The element type is already Object. Object[] has direct super of Object. | |
116 super_klass = KlassHandle(THREAD, SystemDictionary::Object_klass()); | |
117 } | |
118 } | |
119 | |
120 // Create type name for klass. | |
121 Symbol* name = NULL; | |
122 if (!element_klass->oop_is_instance() || | |
123 (name = InstanceKlass::cast(element_klass())->array_name()) == NULL) { | |
124 | |
125 ResourceMark rm(THREAD); | |
126 char *name_str = element_klass->name()->as_C_string(); | |
127 int len = element_klass->name()->utf8_length(); | |
128 char *new_str = NEW_RESOURCE_ARRAY(char, len + 4); | |
129 int idx = 0; | |
130 new_str[idx++] = '['; | |
131 if (element_klass->oop_is_instance()) { // it could be an array or simple type | |
132 new_str[idx++] = 'L'; | |
133 } | |
134 memcpy(&new_str[idx], name_str, len * sizeof(char)); | |
135 idx += len; | |
136 if (element_klass->oop_is_instance()) { | |
137 new_str[idx++] = ';'; | |
138 } | |
139 new_str[idx++] = '\0'; | |
140 name = SymbolTable::new_permanent_symbol(new_str, CHECK_0); | |
141 if (element_klass->oop_is_instance()) { | |
142 InstanceKlass* ik = InstanceKlass::cast(element_klass()); | |
143 ik->set_array_name(name); | |
144 } | |
145 } | |
146 | |
147 // Initialize instance variables | |
148 ObjArrayKlass* oak = ObjArrayKlass::allocate(loader_data, n, element_klass, name, CHECK_0); | |
149 | |
150 // Add all classes to our internal class loader list here, | |
151 // including classes in the bootstrap (NULL) class loader. | |
152 // GC walks these as strong roots. | |
153 loader_data->add_class(oak); | |
154 | |
155 // Call complete_create_array_klass after all instance variables has been initialized. | |
156 ArrayKlass::complete_create_array_klass(oak, super_klass, CHECK_0); | |
157 | |
158 return oak; | |
159 } | |
160 | |
161 ObjArrayKlass::ObjArrayKlass(int n, KlassHandle element_klass, Symbol* name) : ArrayKlass(name) { | |
162 this->set_dimension(n); | |
163 this->set_element_klass(element_klass()); | |
164 // decrement refcount because object arrays are not explicitly freed. The | |
165 // InstanceKlass array_name() keeps the name counted while the klass is | |
166 // loaded. | |
167 name->decrement_refcount(); | |
168 | |
169 Klass* bk; | |
170 if (element_klass->oop_is_objArray()) { | |
171 bk = ObjArrayKlass::cast(element_klass())->bottom_klass(); | |
172 } else { | |
173 bk = element_klass(); | |
174 } | |
175 assert(bk != NULL && (Klass::cast(bk)->oop_is_instance() || Klass::cast(bk)->oop_is_typeArray()), "invalid bottom klass"); | |
176 this->set_bottom_klass(bk); | |
177 this->set_class_loader_data(bk->class_loader_data()); | |
178 | |
179 this->set_layout_helper(array_layout_helper(T_OBJECT)); | |
180 assert(this->oop_is_array(), "sanity"); | |
181 assert(this->oop_is_objArray(), "sanity"); | |
182 } | |
183 | |
184 int ObjArrayKlass::oop_size(oop obj) const { | |
57 assert(obj->is_objArray(), "must be object array"); | 185 assert(obj->is_objArray(), "must be object array"); |
58 return objArrayOop(obj)->object_size(); | 186 return objArrayOop(obj)->object_size(); |
59 } | 187 } |
60 | 188 |
61 objArrayOop objArrayKlass::allocate(int length, TRAPS) { | 189 objArrayOop ObjArrayKlass::allocate(int length, TRAPS) { |
62 if (length >= 0) { | 190 if (length >= 0) { |
63 if (length <= arrayOopDesc::max_array_length(T_OBJECT)) { | 191 if (length <= arrayOopDesc::max_array_length(T_OBJECT)) { |
64 int size = objArrayOopDesc::object_size(length); | 192 int size = objArrayOopDesc::object_size(length); |
65 KlassHandle h_k(THREAD, as_klassOop()); | 193 KlassHandle h_k(THREAD, this); |
66 objArrayOop a = (objArrayOop)CollectedHeap::array_allocate(h_k, size, length, CHECK_NULL); | 194 return (objArrayOop)CollectedHeap::array_allocate(h_k, size, length, CHECK_NULL); |
67 assert(a->is_parsable(), "Can't publish unless parsable"); | |
68 return a; | |
69 } else { | 195 } else { |
70 report_java_out_of_memory("Requested array size exceeds VM limit"); | 196 report_java_out_of_memory("Requested array size exceeds VM limit"); |
71 JvmtiExport::post_array_size_exhausted(); | 197 JvmtiExport::post_array_size_exhausted(); |
72 THROW_OOP_0(Universe::out_of_memory_error_array_size()); | 198 THROW_OOP_0(Universe::out_of_memory_error_array_size()); |
73 } | 199 } |
76 } | 202 } |
77 } | 203 } |
78 | 204 |
79 static int multi_alloc_counter = 0; | 205 static int multi_alloc_counter = 0; |
80 | 206 |
81 oop objArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) { | 207 oop ObjArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) { |
82 int length = *sizes; | 208 int length = *sizes; |
83 // Call to lower_dimension uses this pointer, so most be called before a | 209 // Call to lower_dimension uses this pointer, so most be called before a |
84 // possible GC | 210 // possible GC |
85 KlassHandle h_lower_dimension(THREAD, lower_dimension()); | 211 KlassHandle h_lower_dimension(THREAD, lower_dimension()); |
86 // If length < 0 allocate will throw an exception. | 212 // If length < 0 allocate will throw an exception. |
87 objArrayOop array = allocate(length, CHECK_NULL); | 213 objArrayOop array = allocate(length, CHECK_NULL); |
88 assert(array->is_parsable(), "Don't handlize unless parsable"); | |
89 objArrayHandle h_array (THREAD, array); | 214 objArrayHandle h_array (THREAD, array); |
90 if (rank > 1) { | 215 if (rank > 1) { |
91 if (length != 0) { | 216 if (length != 0) { |
92 for (int index = 0; index < length; index++) { | 217 for (int index = 0; index < length; index++) { |
93 arrayKlass* ak = arrayKlass::cast(h_lower_dimension()); | 218 ArrayKlass* ak = ArrayKlass::cast(h_lower_dimension()); |
94 oop sub_array = ak->multi_allocate(rank-1, &sizes[1], CHECK_NULL); | 219 oop sub_array = ak->multi_allocate(rank-1, &sizes[1], CHECK_NULL); |
95 assert(sub_array->is_parsable(), "Don't publish until parsable"); | |
96 h_array->obj_at_put(index, sub_array); | 220 h_array->obj_at_put(index, sub_array); |
97 } | 221 } |
98 } else { | 222 } else { |
99 // Since this array dimension has zero length, nothing will be | 223 // Since this array dimension has zero length, nothing will be |
100 // allocated, however the lower dimension values must be checked | 224 // allocated, however the lower dimension values must be checked |
109 } | 233 } |
110 return h_array(); | 234 return h_array(); |
111 } | 235 } |
112 | 236 |
113 // Either oop or narrowOop depending on UseCompressedOops. | 237 // Either oop or narrowOop depending on UseCompressedOops. |
114 template <class T> void objArrayKlass::do_copy(arrayOop s, T* src, | 238 template <class T> void ObjArrayKlass::do_copy(arrayOop s, T* src, |
115 arrayOop d, T* dst, int length, TRAPS) { | 239 arrayOop d, T* dst, int length, TRAPS) { |
116 | 240 |
117 BarrierSet* bs = Universe::heap()->barrier_set(); | 241 BarrierSet* bs = Universe::heap()->barrier_set(); |
118 // For performance reasons, we assume we are that the write barrier we | 242 // For performance reasons, we assume we are that the write barrier we |
119 // are using has optimized modes for arrays of references. At least one | 243 // are using has optimized modes for arrays of references. At least one |
126 assert(length > 0, "sanity check"); | 250 assert(length > 0, "sanity check"); |
127 bs->write_ref_array_pre(dst, length); | 251 bs->write_ref_array_pre(dst, length); |
128 Copy::conjoint_oops_atomic(src, dst, length); | 252 Copy::conjoint_oops_atomic(src, dst, length); |
129 } else { | 253 } else { |
130 // We have to make sure all elements conform to the destination array | 254 // We have to make sure all elements conform to the destination array |
131 klassOop bound = objArrayKlass::cast(d->klass())->element_klass(); | 255 Klass* bound = ObjArrayKlass::cast(d->klass())->element_klass(); |
132 klassOop stype = objArrayKlass::cast(s->klass())->element_klass(); | 256 Klass* stype = ObjArrayKlass::cast(s->klass())->element_klass(); |
133 if (stype == bound || Klass::cast(stype)->is_subtype_of(bound)) { | 257 if (stype == bound || Klass::cast(stype)->is_subtype_of(bound)) { |
134 // elements are guaranteed to be subtypes, so no check necessary | 258 // elements are guaranteed to be subtypes, so no check necessary |
135 bs->write_ref_array_pre(dst, length); | 259 bs->write_ref_array_pre(dst, length); |
136 Copy::conjoint_oops_atomic(src, dst, length); | 260 Copy::conjoint_oops_atomic(src, dst, length); |
137 } else { | 261 } else { |
164 } | 288 } |
165 } | 289 } |
166 bs->write_ref_array((HeapWord*)dst, length); | 290 bs->write_ref_array((HeapWord*)dst, length); |
167 } | 291 } |
168 | 292 |
169 void objArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, | 293 void ObjArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, |
170 int dst_pos, int length, TRAPS) { | 294 int dst_pos, int length, TRAPS) { |
171 assert(s->is_objArray(), "must be obj array"); | 295 assert(s->is_objArray(), "must be obj array"); |
172 | 296 |
173 if (!d->is_objArray()) { | 297 if (!d->is_objArray()) { |
174 THROW(vmSymbols::java_lang_ArrayStoreException()); | 298 THROW(vmSymbols::java_lang_ArrayStoreException()); |
201 do_copy<oop> (s, src, d, dst, length, CHECK); | 325 do_copy<oop> (s, src, d, dst, length, CHECK); |
202 } | 326 } |
203 } | 327 } |
204 | 328 |
205 | 329 |
206 klassOop objArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) { | 330 Klass* ObjArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) { |
207 objArrayKlassHandle h_this(THREAD, as_klassOop()); | 331 |
208 return array_klass_impl(h_this, or_null, n, CHECK_NULL); | 332 assert(dimension() <= n, "check order of chain"); |
209 } | 333 int dim = dimension(); |
210 | 334 if (dim == n) return this; |
211 | 335 |
212 klassOop objArrayKlass::array_klass_impl(objArrayKlassHandle this_oop, bool or_null, int n, TRAPS) { | 336 if (higher_dimension() == NULL) { |
213 | |
214 assert(this_oop->dimension() <= n, "check order of chain"); | |
215 int dimension = this_oop->dimension(); | |
216 if (dimension == n) | |
217 return this_oop(); | |
218 | |
219 objArrayKlassHandle ak (THREAD, this_oop->higher_dimension()); | |
220 if (ak.is_null()) { | |
221 if (or_null) return NULL; | 337 if (or_null) return NULL; |
222 | 338 |
223 ResourceMark rm; | 339 ResourceMark rm; |
224 JavaThread *jt = (JavaThread *)THREAD; | 340 JavaThread *jt = (JavaThread *)THREAD; |
225 { | 341 { |
226 MutexLocker mc(Compile_lock, THREAD); // for vtables | 342 MutexLocker mc(Compile_lock, THREAD); // for vtables |
227 // Ensure atomic creation of higher dimensions | 343 // Ensure atomic creation of higher dimensions |
228 MutexLocker mu(MultiArray_lock, THREAD); | 344 MutexLocker mu(MultiArray_lock, THREAD); |
229 | 345 |
230 // Check if another thread beat us | 346 // Check if another thread beat us |
231 ak = objArrayKlassHandle(THREAD, this_oop->higher_dimension()); | 347 if (higher_dimension() == NULL) { |
232 if( ak.is_null() ) { | |
233 | 348 |
234 // Create multi-dim klass object and link them together | 349 // Create multi-dim klass object and link them together |
235 klassOop new_klass = | 350 Klass* k = |
236 objArrayKlassKlass::cast(Universe::objArrayKlassKlassObj())-> | 351 ObjArrayKlass::allocate_objArray_klass(class_loader_data(), dim + 1, this, CHECK_NULL); |
237 allocate_objArray_klass(dimension + 1, this_oop, CHECK_NULL); | 352 ObjArrayKlass* ak = ObjArrayKlass::cast(k); |
238 ak = objArrayKlassHandle(THREAD, new_klass); | 353 ak->set_lower_dimension(this); |
239 ak->set_lower_dimension(this_oop()); | |
240 OrderAccess::storestore(); | 354 OrderAccess::storestore(); |
241 this_oop->set_higher_dimension(ak()); | 355 set_higher_dimension(ak); |
242 assert(ak->oop_is_objArray(), "incorrect initialization of objArrayKlass"); | 356 assert(ak->oop_is_objArray(), "incorrect initialization of ObjArrayKlass"); |
243 } | 357 } |
244 } | 358 } |
245 } else { | 359 } else { |
246 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); | 360 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); |
247 } | 361 } |
248 | 362 |
363 ObjArrayKlass *ak = ObjArrayKlass::cast(higher_dimension()); | |
249 if (or_null) { | 364 if (or_null) { |
250 return ak->array_klass_or_null(n); | 365 return ak->array_klass_or_null(n); |
251 } | 366 } |
252 return ak->array_klass(n, CHECK_NULL); | 367 return ak->array_klass(n, CHECK_NULL); |
253 } | 368 } |
254 | 369 |
255 klassOop objArrayKlass::array_klass_impl(bool or_null, TRAPS) { | 370 Klass* ObjArrayKlass::array_klass_impl(bool or_null, TRAPS) { |
256 return array_klass_impl(or_null, dimension() + 1, CHECK_NULL); | 371 return array_klass_impl(or_null, dimension() + 1, CHECK_NULL); |
257 } | 372 } |
258 | 373 |
259 bool objArrayKlass::can_be_primary_super_slow() const { | 374 bool ObjArrayKlass::can_be_primary_super_slow() const { |
260 if (!bottom_klass()->klass_part()->can_be_primary_super()) | 375 if (!bottom_klass()->can_be_primary_super()) |
261 // array of interfaces | 376 // array of interfaces |
262 return false; | 377 return false; |
263 else | 378 else |
264 return Klass::can_be_primary_super_slow(); | 379 return Klass::can_be_primary_super_slow(); |
265 } | 380 } |
266 | 381 |
267 objArrayOop objArrayKlass::compute_secondary_supers(int num_extra_slots, TRAPS) { | 382 GrowableArray<Klass*>* ObjArrayKlass::compute_secondary_supers(int num_extra_slots) { |
268 // interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... }; | 383 // interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... }; |
269 objArrayOop es = Klass::cast(element_klass())->secondary_supers(); | 384 Array<Klass*>* elem_supers = Klass::cast(element_klass())->secondary_supers(); |
270 objArrayHandle elem_supers (THREAD, es); | 385 int num_elem_supers = elem_supers == NULL ? 0 : elem_supers->length(); |
271 int num_elem_supers = elem_supers.is_null() ? 0 : elem_supers->length(); | |
272 int num_secondaries = num_extra_slots + 2 + num_elem_supers; | 386 int num_secondaries = num_extra_slots + 2 + num_elem_supers; |
273 if (num_secondaries == 2) { | 387 if (num_secondaries == 2) { |
274 // Must share this for correct bootstrapping! | 388 // Must share this for correct bootstrapping! |
275 return Universe::the_array_interfaces_array(); | 389 set_secondary_supers(Universe::the_array_interfaces_array()); |
390 return NULL; | |
276 } else { | 391 } else { |
277 objArrayOop sec_oop = oopFactory::new_system_objArray(num_secondaries, CHECK_NULL); | 392 GrowableArray<Klass*>* secondaries = new GrowableArray<Klass*>(num_elem_supers+2); |
278 objArrayHandle secondaries(THREAD, sec_oop); | 393 secondaries->push(SystemDictionary::Cloneable_klass()); |
279 secondaries->obj_at_put(num_extra_slots+0, SystemDictionary::Cloneable_klass()); | 394 secondaries->push(SystemDictionary::Serializable_klass()); |
280 secondaries->obj_at_put(num_extra_slots+1, SystemDictionary::Serializable_klass()); | |
281 for (int i = 0; i < num_elem_supers; i++) { | 395 for (int i = 0; i < num_elem_supers; i++) { |
282 klassOop elem_super = (klassOop) elem_supers->obj_at(i); | 396 Klass* elem_super = (Klass*) elem_supers->at(i); |
283 klassOop array_super = elem_super->klass_part()->array_klass_or_null(); | 397 Klass* array_super = elem_super->array_klass_or_null(); |
284 assert(array_super != NULL, "must already have been created"); | 398 assert(array_super != NULL, "must already have been created"); |
285 secondaries->obj_at_put(num_extra_slots+2+i, array_super); | 399 secondaries->push(array_super); |
286 } | 400 } |
287 return secondaries(); | 401 return secondaries; |
288 } | 402 } |
289 } | 403 } |
290 | 404 |
291 bool objArrayKlass::compute_is_subtype_of(klassOop k) { | 405 bool ObjArrayKlass::compute_is_subtype_of(Klass* k) { |
292 if (!k->klass_part()->oop_is_objArray()) | 406 if (!k->oop_is_objArray()) |
293 return arrayKlass::compute_is_subtype_of(k); | 407 return ArrayKlass::compute_is_subtype_of(k); |
294 | 408 |
295 objArrayKlass* oak = objArrayKlass::cast(k); | 409 ObjArrayKlass* oak = ObjArrayKlass::cast(k); |
296 return element_klass()->klass_part()->is_subtype_of(oak->element_klass()); | 410 return element_klass()->is_subtype_of(oak->element_klass()); |
297 } | 411 } |
298 | 412 |
299 void objArrayKlass::initialize(TRAPS) { | 413 void ObjArrayKlass::initialize(TRAPS) { |
300 Klass::cast(bottom_klass())->initialize(THREAD); // dispatches to either instanceKlass or typeArrayKlass | 414 Klass::cast(bottom_klass())->initialize(THREAD); // dispatches to either InstanceKlass or TypeArrayKlass |
301 } | 415 } |
302 | 416 |
303 #define ObjArrayKlass_SPECIALIZED_OOP_ITERATE(T, a, p, do_oop) \ | 417 #define ObjArrayKlass_SPECIALIZED_OOP_ITERATE(T, a, p, do_oop) \ |
304 { \ | 418 { \ |
305 T* p = (T*)(a)->base(); \ | 419 T* p = (T*)(a)->base(); \ |
340 } else { \ | 454 } else { \ |
341 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \ | 455 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \ |
342 a, p, low, high, do_oop) \ | 456 a, p, low, high, do_oop) \ |
343 } | 457 } |
344 | 458 |
345 void objArrayKlass::oop_follow_contents(oop obj) { | 459 void ObjArrayKlass::oop_follow_contents(oop obj) { |
346 assert (obj->is_array(), "obj must be array"); | 460 assert (obj->is_array(), "obj must be array"); |
347 objArrayOop(obj)->follow_header(); | 461 MarkSweep::follow_klass(obj->klass()); |
348 if (UseCompressedOops) { | 462 if (UseCompressedOops) { |
349 objarray_follow_contents<narrowOop>(obj, 0); | 463 objarray_follow_contents<narrowOop>(obj, 0); |
350 } else { | 464 } else { |
351 objarray_follow_contents<oop>(obj, 0); | 465 objarray_follow_contents<oop>(obj, 0); |
352 } | 466 } |
353 } | 467 } |
354 | 468 |
355 #ifndef SERIALGC | 469 #ifndef SERIALGC |
356 void objArrayKlass::oop_follow_contents(ParCompactionManager* cm, | 470 void ObjArrayKlass::oop_follow_contents(ParCompactionManager* cm, |
357 oop obj) { | 471 oop obj) { |
358 assert(obj->is_array(), "obj must be array"); | 472 assert(obj->is_array(), "obj must be array"); |
359 objArrayOop(obj)->follow_header(cm); | 473 PSParallelCompact::follow_klass(cm, obj->klass()); |
360 if (UseCompressedOops) { | 474 if (UseCompressedOops) { |
361 objarray_follow_contents<narrowOop>(cm, obj, 0); | 475 objarray_follow_contents<narrowOop>(cm, obj, 0); |
362 } else { | 476 } else { |
363 objarray_follow_contents<oop>(cm, obj, 0); | 477 objarray_follow_contents<oop>(cm, obj, 0); |
364 } | 478 } |
365 } | 479 } |
366 #endif // SERIALGC | 480 #endif // SERIALGC |
367 | 481 |
482 #define if_do_metadata_checked(closure, nv_suffix) \ | |
483 /* Make sure the non-virtual and the virtual versions match. */ \ | |
484 assert(closure->do_metadata##nv_suffix() == closure->do_metadata(), \ | |
485 "Inconsistency in do_metadata"); \ | |
486 if (closure->do_metadata##nv_suffix()) | |
487 | |
368 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ | 488 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ |
369 \ | 489 \ |
370 int objArrayKlass::oop_oop_iterate##nv_suffix(oop obj, \ | 490 int ObjArrayKlass::oop_oop_iterate##nv_suffix(oop obj, \ |
371 OopClosureType* closure) { \ | 491 OopClosureType* closure) { \ |
372 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \ | 492 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \ |
373 assert (obj->is_array(), "obj must be array"); \ | 493 assert (obj->is_array(), "obj must be array"); \ |
374 objArrayOop a = objArrayOop(obj); \ | 494 objArrayOop a = objArrayOop(obj); \ |
375 /* Get size before changing pointers. */ \ | 495 /* Get size before changing pointers. */ \ |
376 /* Don't call size() or oop_size() since that is a virtual call. */ \ | 496 /* Don't call size() or oop_size() since that is a virtual call. */ \ |
377 int size = a->object_size(); \ | 497 int size = a->object_size(); \ |
378 if (closure->do_header()) { \ | 498 if_do_metadata_checked(closure, nv_suffix) { \ |
379 a->oop_iterate_header(closure); \ | 499 closure->do_klass##nv_suffix(obj->klass()); \ |
380 } \ | 500 } \ |
381 ObjArrayKlass_OOP_ITERATE(a, p, (closure)->do_oop##nv_suffix(p)) \ | 501 ObjArrayKlass_OOP_ITERATE(a, p, (closure)->do_oop##nv_suffix(p)) \ |
382 return size; \ | 502 return size; \ |
383 } | 503 } |
384 | 504 |
385 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \ | 505 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \ |
386 \ | 506 \ |
387 int objArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \ | 507 int ObjArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \ |
388 OopClosureType* closure, \ | 508 OopClosureType* closure, \ |
389 MemRegion mr) { \ | 509 MemRegion mr) { \ |
390 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \ | 510 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \ |
391 assert(obj->is_array(), "obj must be array"); \ | 511 assert(obj->is_array(), "obj must be array"); \ |
392 objArrayOop a = objArrayOop(obj); \ | 512 objArrayOop a = objArrayOop(obj); \ |
393 /* Get size before changing pointers. */ \ | 513 /* Get size before changing pointers. */ \ |
394 /* Don't call size() or oop_size() since that is a virtual call */ \ | 514 /* Don't call size() or oop_size() since that is a virtual call */ \ |
395 int size = a->object_size(); \ | 515 int size = a->object_size(); \ |
396 if (closure->do_header()) { \ | 516 if_do_metadata_checked(closure, nv_suffix) { \ |
397 a->oop_iterate_header(closure, mr); \ | 517 /* SSS: Do we need to pass down mr here? */ \ |
518 closure->do_klass##nv_suffix(a->klass()); \ | |
398 } \ | 519 } \ |
399 ObjArrayKlass_BOUNDED_OOP_ITERATE( \ | 520 ObjArrayKlass_BOUNDED_OOP_ITERATE( \ |
400 a, p, mr.start(), mr.end(), (closure)->do_oop##nv_suffix(p)) \ | 521 a, p, mr.start(), mr.end(), (closure)->do_oop##nv_suffix(p)) \ |
401 return size; \ | 522 return size; \ |
402 } | 523 } |
403 | 524 |
404 // Like oop_oop_iterate but only iterates over a specified range and only used | 525 // Like oop_oop_iterate but only iterates over a specified range and only used |
405 // for objArrayOops. | 526 // for objArrayOops. |
406 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r(OopClosureType, nv_suffix) \ | 527 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r(OopClosureType, nv_suffix) \ |
407 \ | 528 \ |
408 int objArrayKlass::oop_oop_iterate_range##nv_suffix(oop obj, \ | 529 int ObjArrayKlass::oop_oop_iterate_range##nv_suffix(oop obj, \ |
409 OopClosureType* closure, \ | 530 OopClosureType* closure, \ |
410 int start, int end) { \ | 531 int start, int end) { \ |
411 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \ | 532 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \ |
412 assert(obj->is_array(), "obj must be array"); \ | 533 assert(obj->is_array(), "obj must be array"); \ |
413 objArrayOop a = objArrayOop(obj); \ | 534 objArrayOop a = objArrayOop(obj); \ |
417 if (UseCompressedOops) { \ | 538 if (UseCompressedOops) { \ |
418 HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<narrowOop>(start);\ | 539 HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<narrowOop>(start);\ |
419 /* this might be wierd if end needs to be aligned on HeapWord boundary */ \ | 540 /* this might be wierd if end needs to be aligned on HeapWord boundary */ \ |
420 HeapWord* high = (HeapWord*)((narrowOop*)a->base() + end); \ | 541 HeapWord* high = (HeapWord*)((narrowOop*)a->base() + end); \ |
421 MemRegion mr(low, high); \ | 542 MemRegion mr(low, high); \ |
422 if (closure->do_header()) { \ | 543 if_do_metadata_checked(closure, nv_suffix) { \ |
423 a->oop_iterate_header(closure, mr); \ | 544 /* SSS: Do we need to pass down mr here? */ \ |
545 closure->do_klass##nv_suffix(a->klass()); \ | |
424 } \ | 546 } \ |
425 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \ | 547 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \ |
426 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \ | 548 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \ |
427 } else { \ | 549 } else { \ |
428 HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<oop>(start); \ | 550 HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<oop>(start); \ |
429 HeapWord* high = (HeapWord*)((oop*)a->base() + end); \ | 551 HeapWord* high = (HeapWord*)((oop*)a->base() + end); \ |
430 MemRegion mr(low, high); \ | 552 MemRegion mr(low, high); \ |
431 if (closure->do_header()) { \ | 553 if_do_metadata_checked(closure, nv_suffix) { \ |
432 a->oop_iterate_header(closure, mr); \ | 554 /* SSS: Do we need to pass down mr here? */ \ |
555 closure->do_klass##nv_suffix(a->klass()); \ | |
433 } \ | 556 } \ |
434 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \ | 557 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \ |
435 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \ | 558 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \ |
436 } \ | 559 } \ |
437 return size; \ | 560 return size; \ |
442 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m) | 565 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m) |
443 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m) | 566 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m) |
444 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r) | 567 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r) |
445 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r) | 568 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r) |
446 | 569 |
447 int objArrayKlass::oop_adjust_pointers(oop obj) { | 570 int ObjArrayKlass::oop_adjust_pointers(oop obj) { |
448 assert(obj->is_objArray(), "obj must be obj array"); | 571 assert(obj->is_objArray(), "obj must be obj array"); |
449 objArrayOop a = objArrayOop(obj); | 572 objArrayOop a = objArrayOop(obj); |
450 // Get size before changing pointers. | 573 // Get size before changing pointers. |
451 // Don't call size() or oop_size() since that is a virtual call. | 574 // Don't call size() or oop_size() since that is a virtual call. |
452 int size = a->object_size(); | 575 int size = a->object_size(); |
453 a->adjust_header(); | 576 MarkSweep::adjust_klass(a->klass()); |
454 ObjArrayKlass_OOP_ITERATE(a, p, MarkSweep::adjust_pointer(p)) | 577 ObjArrayKlass_OOP_ITERATE(a, p, MarkSweep::adjust_pointer(p)) |
455 return size; | 578 return size; |
456 } | 579 } |
457 | 580 |
458 #ifndef SERIALGC | 581 #ifndef SERIALGC |
459 void objArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { | 582 void ObjArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { |
460 assert(obj->is_objArray(), "obj must be obj array"); | 583 assert(obj->is_objArray(), "obj must be obj array"); |
461 ObjArrayKlass_OOP_ITERATE( \ | 584 ObjArrayKlass_OOP_ITERATE( \ |
462 objArrayOop(obj), p, \ | 585 objArrayOop(obj), p, \ |
463 if (PSScavenge::should_scavenge(p)) { \ | 586 if (PSScavenge::should_scavenge(p)) { \ |
464 pm->claim_or_forward_depth(p); \ | 587 pm->claim_or_forward_depth(p); \ |
465 }) | 588 }) |
466 } | 589 } |
467 | 590 |
468 int objArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { | 591 int ObjArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { |
469 assert (obj->is_objArray(), "obj must be obj array"); | 592 assert (obj->is_objArray(), "obj must be obj array"); |
470 objArrayOop a = objArrayOop(obj); | 593 objArrayOop a = objArrayOop(obj); |
594 int size = a->object_size(); | |
595 a->update_header(cm); | |
471 ObjArrayKlass_OOP_ITERATE(a, p, PSParallelCompact::adjust_pointer(p)) | 596 ObjArrayKlass_OOP_ITERATE(a, p, PSParallelCompact::adjust_pointer(p)) |
472 return a->object_size(); | 597 return size; |
473 } | 598 } |
474 #endif // SERIALGC | 599 #endif // SERIALGC |
475 | 600 |
476 // JVM support | 601 // JVM support |
477 | 602 |
478 jint objArrayKlass::compute_modifier_flags(TRAPS) const { | 603 jint ObjArrayKlass::compute_modifier_flags(TRAPS) const { |
479 // The modifier for an objectArray is the same as its element | 604 // The modifier for an objectArray is the same as its element |
480 if (element_klass() == NULL) { | 605 if (element_klass() == NULL) { |
481 assert(Universe::is_bootstrapping(), "partial objArray only at startup"); | 606 assert(Universe::is_bootstrapping(), "partial objArray only at startup"); |
482 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; | 607 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; |
483 } | 608 } |
487 return (element_flags & (JVM_ACC_PUBLIC | JVM_ACC_PRIVATE | JVM_ACC_PROTECTED)) | 612 return (element_flags & (JVM_ACC_PUBLIC | JVM_ACC_PRIVATE | JVM_ACC_PROTECTED)) |
488 | (JVM_ACC_ABSTRACT | JVM_ACC_FINAL); | 613 | (JVM_ACC_ABSTRACT | JVM_ACC_FINAL); |
489 } | 614 } |
490 | 615 |
491 | 616 |
617 // Printing | |
618 | |
619 void ObjArrayKlass::print_on(outputStream* st) const { | |
492 #ifndef PRODUCT | 620 #ifndef PRODUCT |
493 // Printing | 621 Klass::print_on(st); |
494 | 622 st->print(" - instance klass: "); |
495 void objArrayKlass::oop_print_on(oop obj, outputStream* st) { | 623 element_klass()->print_value_on(st); |
496 arrayKlass::oop_print_on(obj, st); | 624 st->cr(); |
625 #endif //PRODUCT | |
626 } | |
627 | |
628 void ObjArrayKlass::print_value_on(outputStream* st) const { | |
629 assert(is_klass(), "must be klass"); | |
630 | |
631 element_klass()->print_value_on(st); | |
632 st->print("[]"); | |
633 } | |
634 | |
635 #ifndef PRODUCT | |
636 | |
637 void ObjArrayKlass::oop_print_on(oop obj, outputStream* st) { | |
638 ArrayKlass::oop_print_on(obj, st); | |
497 assert(obj->is_objArray(), "must be objArray"); | 639 assert(obj->is_objArray(), "must be objArray"); |
498 objArrayOop oa = objArrayOop(obj); | 640 objArrayOop oa = objArrayOop(obj); |
499 int print_len = MIN2((intx) oa->length(), MaxElementPrintSize); | 641 int print_len = MIN2((intx) oa->length(), MaxElementPrintSize); |
500 for(int index = 0; index < print_len; index++) { | 642 for(int index = 0; index < print_len; index++) { |
501 st->print(" - %3d : ", index); | 643 st->print(" - %3d : ", index); |
502 oa->obj_at(index)->print_value_on(st); | 644 oa->obj_at(index)->print_value_on(st); |
503 st->cr(); | 645 st->cr(); |
504 } | 646 } |
505 int remaining = oa->length() - print_len; | 647 int remaining = oa->length() - print_len; |
506 if (remaining > 0) { | 648 if (remaining > 0) { |
507 tty->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining); | 649 st->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining); |
508 } | 650 } |
509 } | 651 } |
510 | 652 |
511 #endif //PRODUCT | 653 #endif //PRODUCT |
512 | 654 |
513 static int max_objArray_print_length = 4; | 655 static int max_objArray_print_length = 4; |
514 | 656 |
515 void objArrayKlass::oop_print_value_on(oop obj, outputStream* st) { | 657 void ObjArrayKlass::oop_print_value_on(oop obj, outputStream* st) { |
516 assert(obj->is_objArray(), "must be objArray"); | 658 assert(obj->is_objArray(), "must be objArray"); |
517 st->print("a "); | 659 st->print("a "); |
518 element_klass()->print_value_on(st); | 660 element_klass()->print_value_on(st); |
519 int len = objArrayOop(obj)->length(); | 661 int len = objArrayOop(obj)->length(); |
520 st->print("[%d] ", len); | 662 st->print("[%d] ", len); |
529 } | 671 } |
530 st->print(" }"); | 672 st->print(" }"); |
531 } | 673 } |
532 } | 674 } |
533 | 675 |
534 const char* objArrayKlass::internal_name() const { | 676 const char* ObjArrayKlass::internal_name() const { |
535 return external_name(); | 677 return external_name(); |
536 } | 678 } |
537 | 679 |
680 | |
538 // Verification | 681 // Verification |
539 | 682 |
540 void objArrayKlass::oop_verify_on(oop obj, outputStream* st) { | 683 void ObjArrayKlass::verify_on(outputStream* st) { |
541 arrayKlass::oop_verify_on(obj, st); | 684 ArrayKlass::verify_on(st); |
685 guarantee(element_klass()->is_metadata(), "should be in metaspace"); | |
686 guarantee(element_klass()->is_klass(), "should be klass"); | |
687 guarantee(bottom_klass()->is_metadata(), "should be in metaspace"); | |
688 guarantee(bottom_klass()->is_klass(), "should be klass"); | |
689 Klass* bk = Klass::cast(bottom_klass()); | |
690 guarantee(bk->oop_is_instance() || bk->oop_is_typeArray(), "invalid bottom klass"); | |
691 } | |
692 | |
693 void ObjArrayKlass::oop_verify_on(oop obj, outputStream* st) { | |
694 ArrayKlass::oop_verify_on(obj, st); | |
542 guarantee(obj->is_objArray(), "must be objArray"); | 695 guarantee(obj->is_objArray(), "must be objArray"); |
543 objArrayOop oa = objArrayOop(obj); | 696 objArrayOop oa = objArrayOop(obj); |
544 for(int index = 0; index < oa->length(); index++) { | 697 for(int index = 0; index < oa->length(); index++) { |
545 guarantee(oa->obj_at(index)->is_oop_or_null(), "should be oop"); | 698 guarantee(oa->obj_at(index)->is_oop_or_null(), "should be oop"); |
546 } | 699 } |