truffle: src/share/vm/oops/objArrayKlass.cpp annotate

annotate src/share/vm/oops/objArrayKlass.cpp @ 1091:6aa7255741f3

6906727: UseCompressedOops: some card-marking fixes related to object arrays Summary: Introduced a new write_ref_array(HeapWords* start, size_t count) method that does the requisite MemRegion range calculation so (some of the) clients of the erstwhile write_ref_array(MemRegion mr) do not need to worry. This removed all external uses of array_size(), which was also simplified and made private. Asserts were added to catch other possible issues. Further, less essential, fixes stemming from this investigation are deferred to CR 6904516 (to follow shortly in hs17). Reviewed-by: kvn, coleenp, jmasa

author	ysr
date	Thu, 03 Dec 2009 15:01:57 -0800
parents	494244ae0171
children	4ce7240d622c

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	2 * Copyright 1997-2009 Sun Microsystems, Inc. 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 *
a61af66fc99e Initial load duke parents: diff changeset	19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
a61af66fc99e Initial load duke parents: diff changeset	20 * CA 95054 USA or visit www.sun.com if you need additional information or
a61af66fc99e Initial load duke parents: diff changeset	21 * have any questions.
a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
a61af66fc99e Initial load duke parents: diff changeset	25 # include "incls/_precompiled.incl"
a61af66fc99e Initial load duke parents: diff changeset	26 # include "incls/_objArrayKlass.cpp.incl"
a61af66fc99e Initial load duke parents: diff changeset	27
a61af66fc99e Initial load duke parents: diff changeset	28 int objArrayKlass::oop_size(oop obj) const {
a61af66fc99e Initial load duke parents: diff changeset	29 assert(obj->is_objArray(), "must be object array");
a61af66fc99e Initial load duke parents: diff changeset	30 return objArrayOop(obj)->object_size();
a61af66fc99e Initial load duke parents: diff changeset	31 }
a61af66fc99e Initial load duke parents: diff changeset	32
a61af66fc99e Initial load duke parents: diff changeset	33 objArrayOop objArrayKlass::allocate(int length, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	34 if (length >= 0) {
a61af66fc99e Initial load duke parents: diff changeset	35 if (length <= arrayOopDesc::max_array_length(T_OBJECT)) {
a61af66fc99e Initial load duke parents: diff changeset	36 int size = objArrayOopDesc::object_size(length);
a61af66fc99e Initial load duke parents: diff changeset	37 KlassHandle h_k(THREAD, as_klassOop());
a61af66fc99e Initial load duke parents: diff changeset	38 objArrayOop a = (objArrayOop)CollectedHeap::array_allocate(h_k, size, length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	39 assert(a->is_parsable(), "Can't publish unless parsable");
a61af66fc99e Initial load duke parents: diff changeset	40 return a;
a61af66fc99e Initial load duke parents: diff changeset	41 } else {
876 1413494da700 6850957: Honor -XX:OnOutOfMemoryError when array size exceeds VM limit martin parents: 665 diff changeset	42 report_java_out_of_memory("Requested array size exceeds VM limit");
0 a61af66fc99e Initial load duke parents: diff changeset	43 THROW_OOP_0(Universe::out_of_memory_error_array_size());
a61af66fc99e Initial load duke parents: diff changeset	44 }
a61af66fc99e Initial load duke parents: diff changeset	45 } else {
a61af66fc99e Initial load duke parents: diff changeset	46 THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
a61af66fc99e Initial load duke parents: diff changeset	47 }
a61af66fc99e Initial load duke parents: diff changeset	48 }
a61af66fc99e Initial load duke parents: diff changeset	49
a61af66fc99e Initial load duke parents: diff changeset	50 static int multi_alloc_counter = 0;
a61af66fc99e Initial load duke parents: diff changeset	51
a61af66fc99e Initial load duke parents: diff changeset	52 oop objArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	53 int length = *sizes;
a61af66fc99e Initial load duke parents: diff changeset	54 // Call to lower_dimension uses this pointer, so most be called before a
a61af66fc99e Initial load duke parents: diff changeset	55 // possible GC
a61af66fc99e Initial load duke parents: diff changeset	56 KlassHandle h_lower_dimension(THREAD, lower_dimension());
a61af66fc99e Initial load duke parents: diff changeset	57 // If length < 0 allocate will throw an exception.
a61af66fc99e Initial load duke parents: diff changeset	58 objArrayOop array = allocate(length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	59 assert(array->is_parsable(), "Don't handlize unless parsable");
a61af66fc99e Initial load duke parents: diff changeset	60 objArrayHandle h_array (THREAD, array);
a61af66fc99e Initial load duke parents: diff changeset	61 if (rank > 1) {
a61af66fc99e Initial load duke parents: diff changeset	62 if (length != 0) {
a61af66fc99e Initial load duke parents: diff changeset	63 for (int index = 0; index < length; index++) {
a61af66fc99e Initial load duke parents: diff changeset	64 arrayKlass* ak = arrayKlass::cast(h_lower_dimension());
a61af66fc99e Initial load duke parents: diff changeset	65 oop sub_array = ak->multi_allocate(rank-1, &sizes[1], CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	66 assert(sub_array->is_parsable(), "Don't publish until parsable");
a61af66fc99e Initial load duke parents: diff changeset	67 h_array->obj_at_put(index, sub_array);
a61af66fc99e Initial load duke parents: diff changeset	68 }
a61af66fc99e Initial load duke parents: diff changeset	69 } else {
a61af66fc99e Initial load duke parents: diff changeset	70 // Since this array dimension has zero length, nothing will be
a61af66fc99e Initial load duke parents: diff changeset	71 // allocated, however the lower dimension values must be checked
a61af66fc99e Initial load duke parents: diff changeset	72 // for illegal values.
a61af66fc99e Initial load duke parents: diff changeset	73 for (int i = 0; i < rank - 1; ++i) {
a61af66fc99e Initial load duke parents: diff changeset	74 sizes += 1;
a61af66fc99e Initial load duke parents: diff changeset	75 if (*sizes < 0) {
a61af66fc99e Initial load duke parents: diff changeset	76 THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
a61af66fc99e Initial load duke parents: diff changeset	77 }
a61af66fc99e Initial load duke parents: diff changeset	78 }
a61af66fc99e Initial load duke parents: diff changeset	79 }
a61af66fc99e Initial load duke parents: diff changeset	80 }
a61af66fc99e Initial load duke parents: diff changeset	81 return h_array();
a61af66fc99e Initial load duke parents: diff changeset	82 }
a61af66fc99e Initial load duke parents: diff changeset	83
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	84 // Either oop or narrowOop depending on UseCompressedOops.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	85 template <class T> void objArrayKlass::do_copy(arrayOop s, T* src,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	86 arrayOop d, T* dst, int length, TRAPS) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	87
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	88 BarrierSet* bs = Universe::heap()->barrier_set();
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	89 // For performance reasons, we assume we are that the write barrier we
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	90 // are using has optimized modes for arrays of references. At least one
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	91 // of the asserts below will fail if this is not the case.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	92 assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt");
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	93 assert(bs->has_write_ref_array_pre_opt(), "For pre-barrier as well.");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	94
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	95 if (s == d) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	96 // since source and destination are equal we do not need conversion checks.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	97 assert(length > 0, "sanity check");
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 665 diff changeset	98 bs->write_ref_array_pre(dst, length);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	99 Copy::conjoint_oops_atomic(src, dst, length);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	100 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	101 // We have to make sure all elements conform to the destination array
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	102 klassOop bound = objArrayKlass::cast(d->klass())->element_klass();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	103 klassOop stype = objArrayKlass::cast(s->klass())->element_klass();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	104 if (stype == bound \|\| Klass::cast(stype)->is_subtype_of(bound)) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	105 // elements are guaranteed to be subtypes, so no check necessary
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 665 diff changeset	106 bs->write_ref_array_pre(dst, length);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	107 Copy::conjoint_oops_atomic(src, dst, length);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	108 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	109 // slow case: need individual subtype checks
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	110 // note: don't use obj_at_put below because it includes a redundant store check
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	111 T* from = src;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	112 T* end = from + length;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	113 for (T* p = dst; from < end; from++, p++) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	114 // XXX this is going to be slow.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	115 T element = *from;
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	116 // even slower now
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	117 bool element_is_null = oopDesc::is_null(element);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	118 oop new_val = element_is_null ? oop(NULL)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	119 : oopDesc::decode_heap_oop_not_null(element);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	120 if (element_is_null \|\|
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	121 Klass::cast((new_val->klass()))->is_subtype_of(bound)) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	122 bs->write_ref_field_pre(p, new_val);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	123 p = from;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	124 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	125 // We must do a barrier to cover the partial copy.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	126 const size_t pd = pointer_delta(p, dst, (size_t)heapOopSize);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	127 // pointer delta is scaled to number of elements (length field in
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	128 // objArrayOop) which we assume is 32 bit.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	129 assert(pd == (size_t)(int)pd, "length field overflow");
1091 6aa7255741f3 6906727: UseCompressedOops: some card-marking fixes related to object arrays ysr parents: 879 diff changeset	130 bs->write_ref_array((HeapWord*)dst, pd);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	131 THROW(vmSymbols::java_lang_ArrayStoreException());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	132 return;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	133 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	134 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	135 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	136 }
1091 6aa7255741f3 6906727: UseCompressedOops: some card-marking fixes related to object arrays ysr parents: 879 diff changeset	137 bs->write_ref_array((HeapWord*)dst, length);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	138 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	139
0 a61af66fc99e Initial load duke parents: diff changeset	140 void objArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d,
a61af66fc99e Initial load duke parents: diff changeset	141 int dst_pos, int length, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	142 assert(s->is_objArray(), "must be obj array");
a61af66fc99e Initial load duke parents: diff changeset	143
a61af66fc99e Initial load duke parents: diff changeset	144 if (!d->is_objArray()) {
a61af66fc99e Initial load duke parents: diff changeset	145 THROW(vmSymbols::java_lang_ArrayStoreException());
a61af66fc99e Initial load duke parents: diff changeset	146 }
a61af66fc99e Initial load duke parents: diff changeset	147
a61af66fc99e Initial load duke parents: diff changeset	148 // Check is all offsets and lengths are non negative
a61af66fc99e Initial load duke parents: diff changeset	149 if (src_pos < 0 \|\| dst_pos < 0 \|\| length < 0) {
a61af66fc99e Initial load duke parents: diff changeset	150 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
a61af66fc99e Initial load duke parents: diff changeset	151 }
a61af66fc99e Initial load duke parents: diff changeset	152 // Check if the ranges are valid
a61af66fc99e Initial load duke parents: diff changeset	153 if ( (((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length())
a61af66fc99e Initial load duke parents: diff changeset	154 \|\| (((unsigned int) length + (unsigned int) dst_pos) > (unsigned int) d->length()) ) {
a61af66fc99e Initial load duke parents: diff changeset	155 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
a61af66fc99e Initial load duke parents: diff changeset	156 }
a61af66fc99e Initial load duke parents: diff changeset	157
a61af66fc99e Initial load duke parents: diff changeset	158 // Special case. Boundary cases must be checked first
a61af66fc99e Initial load duke parents: diff changeset	159 // This allows the following call: copy_array(s, s.length(), d.length(), 0).
a61af66fc99e Initial load duke parents: diff changeset	160 // This is correct, since the position is supposed to be an 'in between point', i.e., s.length(),
a61af66fc99e Initial load duke parents: diff changeset	161 // points to the right of the last element.
a61af66fc99e Initial load duke parents: diff changeset	162 if (length==0) {
a61af66fc99e Initial load duke parents: diff changeset	163 return;
a61af66fc99e Initial load duke parents: diff changeset	164 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	165 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	166 narrowOop* const src = objArrayOop(s)->obj_at_addr<narrowOop>(src_pos);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	167 narrowOop* const dst = objArrayOop(d)->obj_at_addr<narrowOop>(dst_pos);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	168 do_copy<narrowOop>(s, src, d, dst, length, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	169 } else {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	170 oop* const src = objArrayOop(s)->obj_at_addr<oop>(src_pos);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	171 oop* const dst = objArrayOop(d)->obj_at_addr<oop>(dst_pos);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	172 do_copy<oop> (s, src, d, dst, length, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	173 }
a61af66fc99e Initial load duke parents: diff changeset	174 }
a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176
a61af66fc99e Initial load duke parents: diff changeset	177 klassOop objArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	178 objArrayKlassHandle h_this(THREAD, as_klassOop());
a61af66fc99e Initial load duke parents: diff changeset	179 return array_klass_impl(h_this, or_null, n, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	180 }
a61af66fc99e Initial load duke parents: diff changeset	181
a61af66fc99e Initial load duke parents: diff changeset	182
a61af66fc99e Initial load duke parents: diff changeset	183 klassOop objArrayKlass::array_klass_impl(objArrayKlassHandle this_oop, bool or_null, int n, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	184
a61af66fc99e Initial load duke parents: diff changeset	185 assert(this_oop->dimension() <= n, "check order of chain");
a61af66fc99e Initial load duke parents: diff changeset	186 int dimension = this_oop->dimension();
a61af66fc99e Initial load duke parents: diff changeset	187 if (dimension == n)
a61af66fc99e Initial load duke parents: diff changeset	188 return this_oop();
a61af66fc99e Initial load duke parents: diff changeset	189
a61af66fc99e Initial load duke parents: diff changeset	190 objArrayKlassHandle ak (THREAD, this_oop->higher_dimension());
a61af66fc99e Initial load duke parents: diff changeset	191 if (ak.is_null()) {
a61af66fc99e Initial load duke parents: diff changeset	192 if (or_null) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	193
a61af66fc99e Initial load duke parents: diff changeset	194 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	195 JavaThread jt = (JavaThread )THREAD;
a61af66fc99e Initial load duke parents: diff changeset	196 {
a61af66fc99e Initial load duke parents: diff changeset	197 MutexLocker mc(Compile_lock, THREAD); // for vtables
a61af66fc99e Initial load duke parents: diff changeset	198 // Ensure atomic creation of higher dimensions
a61af66fc99e Initial load duke parents: diff changeset	199 MutexLocker mu(MultiArray_lock, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	200
a61af66fc99e Initial load duke parents: diff changeset	201 // Check if another thread beat us
a61af66fc99e Initial load duke parents: diff changeset	202 ak = objArrayKlassHandle(THREAD, this_oop->higher_dimension());
a61af66fc99e Initial load duke parents: diff changeset	203 if( ak.is_null() ) {
a61af66fc99e Initial load duke parents: diff changeset	204
a61af66fc99e Initial load duke parents: diff changeset	205 // Create multi-dim klass object and link them together
a61af66fc99e Initial load duke parents: diff changeset	206 klassOop new_klass =
a61af66fc99e Initial load duke parents: diff changeset	207 objArrayKlassKlass::cast(Universe::objArrayKlassKlassObj())->
a61af66fc99e Initial load duke parents: diff changeset	208 allocate_objArray_klass(dimension + 1, this_oop, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	209 ak = objArrayKlassHandle(THREAD, new_klass);
a61af66fc99e Initial load duke parents: diff changeset	210 this_oop->set_higher_dimension(ak());
a61af66fc99e Initial load duke parents: diff changeset	211 ak->set_lower_dimension(this_oop());
a61af66fc99e Initial load duke parents: diff changeset	212 assert(ak->oop_is_objArray(), "incorrect initialization of objArrayKlass");
a61af66fc99e Initial load duke parents: diff changeset	213 }
a61af66fc99e Initial load duke parents: diff changeset	214 }
a61af66fc99e Initial load duke parents: diff changeset	215 } else {
a61af66fc99e Initial load duke parents: diff changeset	216 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
a61af66fc99e Initial load duke parents: diff changeset	217 }
a61af66fc99e Initial load duke parents: diff changeset	218
a61af66fc99e Initial load duke parents: diff changeset	219 if (or_null) {
a61af66fc99e Initial load duke parents: diff changeset	220 return ak->array_klass_or_null(n);
a61af66fc99e Initial load duke parents: diff changeset	221 }
a61af66fc99e Initial load duke parents: diff changeset	222 return ak->array_klass(n, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	223 }
a61af66fc99e Initial load duke parents: diff changeset	224
a61af66fc99e Initial load duke parents: diff changeset	225 klassOop objArrayKlass::array_klass_impl(bool or_null, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	226 return array_klass_impl(or_null, dimension() + 1, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	227 }
a61af66fc99e Initial load duke parents: diff changeset	228
a61af66fc99e Initial load duke parents: diff changeset	229 bool objArrayKlass::can_be_primary_super_slow() const {
a61af66fc99e Initial load duke parents: diff changeset	230 if (!bottom_klass()->klass_part()->can_be_primary_super())
a61af66fc99e Initial load duke parents: diff changeset	231 // array of interfaces
a61af66fc99e Initial load duke parents: diff changeset	232 return false;
a61af66fc99e Initial load duke parents: diff changeset	233 else
a61af66fc99e Initial load duke parents: diff changeset	234 return Klass::can_be_primary_super_slow();
a61af66fc99e Initial load duke parents: diff changeset	235 }
a61af66fc99e Initial load duke parents: diff changeset	236
a61af66fc99e Initial load duke parents: diff changeset	237 objArrayOop objArrayKlass::compute_secondary_supers(int num_extra_slots, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	238 // interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... };
a61af66fc99e Initial load duke parents: diff changeset	239 objArrayOop es = Klass::cast(element_klass())->secondary_supers();
a61af66fc99e Initial load duke parents: diff changeset	240 objArrayHandle elem_supers (THREAD, es);
a61af66fc99e Initial load duke parents: diff changeset	241 int num_elem_supers = elem_supers.is_null() ? 0 : elem_supers->length();
a61af66fc99e Initial load duke parents: diff changeset	242 int num_secondaries = num_extra_slots + 2 + num_elem_supers;
a61af66fc99e Initial load duke parents: diff changeset	243 if (num_secondaries == 2) {
a61af66fc99e Initial load duke parents: diff changeset	244 // Must share this for correct bootstrapping!
a61af66fc99e Initial load duke parents: diff changeset	245 return Universe::the_array_interfaces_array();
a61af66fc99e Initial load duke parents: diff changeset	246 } else {
a61af66fc99e Initial load duke parents: diff changeset	247 objArrayOop sec_oop = oopFactory::new_system_objArray(num_secondaries, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	248 objArrayHandle secondaries(THREAD, sec_oop);
a61af66fc99e Initial load duke parents: diff changeset	249 secondaries->obj_at_put(num_extra_slots+0, SystemDictionary::cloneable_klass());
a61af66fc99e Initial load duke parents: diff changeset	250 secondaries->obj_at_put(num_extra_slots+1, SystemDictionary::serializable_klass());
a61af66fc99e Initial load duke parents: diff changeset	251 for (int i = 0; i < num_elem_supers; i++) {
a61af66fc99e Initial load duke parents: diff changeset	252 klassOop elem_super = (klassOop) elem_supers->obj_at(i);
a61af66fc99e Initial load duke parents: diff changeset	253 klassOop array_super = elem_super->klass_part()->array_klass_or_null();
a61af66fc99e Initial load duke parents: diff changeset	254 assert(array_super != NULL, "must already have been created");
a61af66fc99e Initial load duke parents: diff changeset	255 secondaries->obj_at_put(num_extra_slots+2+i, array_super);
a61af66fc99e Initial load duke parents: diff changeset	256 }
a61af66fc99e Initial load duke parents: diff changeset	257 return secondaries();
a61af66fc99e Initial load duke parents: diff changeset	258 }
a61af66fc99e Initial load duke parents: diff changeset	259 }
a61af66fc99e Initial load duke parents: diff changeset	260
a61af66fc99e Initial load duke parents: diff changeset	261 bool objArrayKlass::compute_is_subtype_of(klassOop k) {
a61af66fc99e Initial load duke parents: diff changeset	262 if (!k->klass_part()->oop_is_objArray())
a61af66fc99e Initial load duke parents: diff changeset	263 return arrayKlass::compute_is_subtype_of(k);
a61af66fc99e Initial load duke parents: diff changeset	264
a61af66fc99e Initial load duke parents: diff changeset	265 objArrayKlass* oak = objArrayKlass::cast(k);
a61af66fc99e Initial load duke parents: diff changeset	266 return element_klass()->klass_part()->is_subtype_of(oak->element_klass());
a61af66fc99e Initial load duke parents: diff changeset	267 }
a61af66fc99e Initial load duke parents: diff changeset	268
a61af66fc99e Initial load duke parents: diff changeset	269 void objArrayKlass::initialize(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	270 Klass::cast(bottom_klass())->initialize(THREAD); // dispatches to either instanceKlass or typeArrayKlass
a61af66fc99e Initial load duke parents: diff changeset	271 }
a61af66fc99e Initial load duke parents: diff changeset	272
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	273 #define ObjArrayKlass_SPECIALIZED_OOP_ITERATE(T, a, p, do_oop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	274 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	275 T* p = (T*)(a)->base(); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	276 T* const end = p + (a)->length(); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	277 while (p < end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	278 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	279 p++; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	280 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	281 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	282
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	283 #define ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(T, a, p, low, high, do_oop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	284 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	285 T* const l = (T*)(low); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	286 T* const h = (T*)(high); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	287 T* p = (T*)(a)->base(); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	288 T* end = p + (a)->length(); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	289 if (p < l) p = l; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	290 if (end > h) end = h; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	291 while (p < end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	292 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	293 ++p; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	294 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	295 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	296
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	297 #define ObjArrayKlass_OOP_ITERATE(a, p, do_oop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	298 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	299 ObjArrayKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	300 a, p, do_oop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	301 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	302 ObjArrayKlass_SPECIALIZED_OOP_ITERATE(oop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	303 a, p, do_oop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	304 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	305
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	306 #define ObjArrayKlass_BOUNDED_OOP_ITERATE(a, p, low, high, do_oop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	307 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	308 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	309 a, p, low, high, do_oop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	310 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	311 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	312 a, p, low, high, do_oop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	313 }
0 a61af66fc99e Initial load duke parents: diff changeset	314
a61af66fc99e Initial load duke parents: diff changeset	315 void objArrayKlass::oop_follow_contents(oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	316 assert (obj->is_array(), "obj must be array");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	317 objArrayOop a = objArrayOop(obj);
0 a61af66fc99e Initial load duke parents: diff changeset	318 a->follow_header();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	319 ObjArrayKlass_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	320 a, p, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	321 /* we call mark_and_follow here to avoid excessive marking stack usage */ \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	322 MarkSweep::mark_and_follow(p))
0 a61af66fc99e Initial load duke parents: diff changeset	323 }
a61af66fc99e Initial load duke parents: diff changeset	324
a61af66fc99e Initial load duke parents: diff changeset	325 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	326 void objArrayKlass::oop_follow_contents(ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	327 oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	328 assert (obj->is_array(), "obj must be array");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	329 objArrayOop a = objArrayOop(obj);
0 a61af66fc99e Initial load duke parents: diff changeset	330 a->follow_header(cm);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	331 ObjArrayKlass_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	332 a, p, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	333 /* we call mark_and_follow here to avoid excessive marking stack usage */ \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	334 PSParallelCompact::mark_and_follow(cm, p))
0 a61af66fc99e Initial load duke parents: diff changeset	335 }
a61af66fc99e Initial load duke parents: diff changeset	336 #endif // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	337
a61af66fc99e Initial load duke parents: diff changeset	338 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
a61af66fc99e Initial load duke parents: diff changeset	339 \
a61af66fc99e Initial load duke parents: diff changeset	340 int objArrayKlass::oop_oop_iterate##nv_suffix(oop obj, \
a61af66fc99e Initial load duke parents: diff changeset	341 OopClosureType* closure) { \
a61af66fc99e Initial load duke parents: diff changeset	342 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
a61af66fc99e Initial load duke parents: diff changeset	343 assert (obj->is_array(), "obj must be array"); \
a61af66fc99e Initial load duke parents: diff changeset	344 objArrayOop a = objArrayOop(obj); \
a61af66fc99e Initial load duke parents: diff changeset	345 /* Get size before changing pointers. */ \
a61af66fc99e Initial load duke parents: diff changeset	346 /* Don't call size() or oop_size() since that is a virtual call. */ \
a61af66fc99e Initial load duke parents: diff changeset	347 int size = a->object_size(); \
a61af66fc99e Initial load duke parents: diff changeset	348 if (closure->do_header()) { \
a61af66fc99e Initial load duke parents: diff changeset	349 a->oop_iterate_header(closure); \
a61af66fc99e Initial load duke parents: diff changeset	350 } \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	351 ObjArrayKlass_OOP_ITERATE(a, p, (closure)->do_oop##nv_suffix(p)) \
0 a61af66fc99e Initial load duke parents: diff changeset	352 return size; \
a61af66fc99e Initial load duke parents: diff changeset	353 }
a61af66fc99e Initial load duke parents: diff changeset	354
a61af66fc99e Initial load duke parents: diff changeset	355 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \
a61af66fc99e Initial load duke parents: diff changeset	356 \
a61af66fc99e Initial load duke parents: diff changeset	357 int objArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \
a61af66fc99e Initial load duke parents: diff changeset	358 OopClosureType* closure, \
a61af66fc99e Initial load duke parents: diff changeset	359 MemRegion mr) { \
a61af66fc99e Initial load duke parents: diff changeset	360 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
a61af66fc99e Initial load duke parents: diff changeset	361 assert(obj->is_array(), "obj must be array"); \
a61af66fc99e Initial load duke parents: diff changeset	362 objArrayOop a = objArrayOop(obj); \
a61af66fc99e Initial load duke parents: diff changeset	363 /* Get size before changing pointers. */ \
a61af66fc99e Initial load duke parents: diff changeset	364 /* Don't call size() or oop_size() since that is a virtual call */ \
a61af66fc99e Initial load duke parents: diff changeset	365 int size = a->object_size(); \
a61af66fc99e Initial load duke parents: diff changeset	366 if (closure->do_header()) { \
a61af66fc99e Initial load duke parents: diff changeset	367 a->oop_iterate_header(closure, mr); \
a61af66fc99e Initial load duke parents: diff changeset	368 } \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	369 ObjArrayKlass_BOUNDED_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	370 a, p, mr.start(), mr.end(), (closure)->do_oop##nv_suffix(p)) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	371 return size; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	372 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	373
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	374 // Like oop_oop_iterate but only iterates over a specified range and only used
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	375 // for objArrayOops.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	376 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r(OopClosureType, nv_suffix) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	377 \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	378 int objArrayKlass::oop_oop_iterate_range##nv_suffix(oop obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	379 OopClosureType* closure, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	380 int start, int end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	381 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	382 assert(obj->is_array(), "obj must be array"); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	383 objArrayOop a = objArrayOop(obj); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	384 /* Get size before changing pointers. */ \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	385 /* Don't call size() or oop_size() since that is a virtual call */ \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	386 int size = a->object_size(); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	387 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	388 HeapWord* low = start == 0 ? (HeapWord)a : (HeapWord)a->obj_at_addr<narrowOop>(start);\
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	389 /* this might be wierd if end needs to be aligned on HeapWord boundary */ \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	390 HeapWord* high = (HeapWord)((narrowOop)a->base() + end); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	391 MemRegion mr(low, high); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	392 if (closure->do_header()) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	393 a->oop_iterate_header(closure, mr); \
0 a61af66fc99e Initial load duke parents: diff changeset	394 } \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	395 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	396 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \
0 a61af66fc99e Initial load duke parents: diff changeset	397 } else { \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	398 HeapWord* low = start == 0 ? (HeapWord)a : (HeapWord)a->obj_at_addr<oop>(start); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	399 HeapWord* high = (HeapWord)((oop)a->base() + end); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	400 MemRegion mr(low, high); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	401 if (closure->do_header()) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	402 a->oop_iterate_header(closure, mr); \
0 a61af66fc99e Initial load duke parents: diff changeset	403 } \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	404 ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	405 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \
0 a61af66fc99e Initial load duke parents: diff changeset	406 } \
a61af66fc99e Initial load duke parents: diff changeset	407 return size; \
a61af66fc99e Initial load duke parents: diff changeset	408 }
a61af66fc99e Initial load duke parents: diff changeset	409
a61af66fc99e Initial load duke parents: diff changeset	410 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN)
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	411 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN)
0 a61af66fc99e Initial load duke parents: diff changeset	412 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m)
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	413 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m)
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	414 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r)
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	415 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r)
0 a61af66fc99e Initial load duke parents: diff changeset	416
a61af66fc99e Initial load duke parents: diff changeset	417 int objArrayKlass::oop_adjust_pointers(oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	418 assert(obj->is_objArray(), "obj must be obj array");
a61af66fc99e Initial load duke parents: diff changeset	419 objArrayOop a = objArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	420 // Get size before changing pointers.
a61af66fc99e Initial load duke parents: diff changeset	421 // Don't call size() or oop_size() since that is a virtual call.
a61af66fc99e Initial load duke parents: diff changeset	422 int size = a->object_size();
a61af66fc99e Initial load duke parents: diff changeset	423 a->adjust_header();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	424 ObjArrayKlass_OOP_ITERATE(a, p, MarkSweep::adjust_pointer(p))
0 a61af66fc99e Initial load duke parents: diff changeset	425 return size;
a61af66fc99e Initial load duke parents: diff changeset	426 }
a61af66fc99e Initial load duke parents: diff changeset	427
a61af66fc99e Initial load duke parents: diff changeset	428 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	429 void objArrayKlass::oop_copy_contents(PSPromotionManager* pm, oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	430 assert(!pm->depth_first(), "invariant");
a61af66fc99e Initial load duke parents: diff changeset	431 assert(obj->is_objArray(), "obj must be obj array");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	432 ObjArrayKlass_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	433 objArrayOop(obj), p, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	434 if (PSScavenge::should_scavenge(p)) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	435 pm->claim_or_forward_breadth(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	436 })
0 a61af66fc99e Initial load duke parents: diff changeset	437 }
a61af66fc99e Initial load duke parents: diff changeset	438
a61af66fc99e Initial load duke parents: diff changeset	439 void objArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	440 assert(pm->depth_first(), "invariant");
a61af66fc99e Initial load duke parents: diff changeset	441 assert(obj->is_objArray(), "obj must be obj array");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	442 ObjArrayKlass_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	443 objArrayOop(obj), p, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	444 if (PSScavenge::should_scavenge(p)) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	445 pm->claim_or_forward_depth(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	446 })
0 a61af66fc99e Initial load duke parents: diff changeset	447 }
a61af66fc99e Initial load duke parents: diff changeset	448
a61af66fc99e Initial load duke parents: diff changeset	449 int objArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	450 assert (obj->is_objArray(), "obj must be obj array");
a61af66fc99e Initial load duke parents: diff changeset	451 objArrayOop a = objArrayOop(obj);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	452 ObjArrayKlass_OOP_ITERATE(a, p, PSParallelCompact::adjust_pointer(p))
0 a61af66fc99e Initial load duke parents: diff changeset	453 return a->object_size();
a61af66fc99e Initial load duke parents: diff changeset	454 }
a61af66fc99e Initial load duke parents: diff changeset	455
a61af66fc99e Initial load duke parents: diff changeset	456 int objArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj,
a61af66fc99e Initial load duke parents: diff changeset	457 HeapWord* beg_addr, HeapWord* end_addr) {
a61af66fc99e Initial load duke parents: diff changeset	458 assert (obj->is_objArray(), "obj must be obj array");
a61af66fc99e Initial load duke parents: diff changeset	459 objArrayOop a = objArrayOop(obj);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	460 ObjArrayKlass_BOUNDED_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	461 a, p, beg_addr, end_addr, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	462 PSParallelCompact::adjust_pointer(p))
0 a61af66fc99e Initial load duke parents: diff changeset	463 return a->object_size();
a61af66fc99e Initial load duke parents: diff changeset	464 }
a61af66fc99e Initial load duke parents: diff changeset	465 #endif // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	466
a61af66fc99e Initial load duke parents: diff changeset	467 // JVM support
a61af66fc99e Initial load duke parents: diff changeset	468
a61af66fc99e Initial load duke parents: diff changeset	469 jint objArrayKlass::compute_modifier_flags(TRAPS) const {
a61af66fc99e Initial load duke parents: diff changeset	470 // The modifier for an objectArray is the same as its element
a61af66fc99e Initial load duke parents: diff changeset	471 if (element_klass() == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	472 assert(Universe::is_bootstrapping(), "partial objArray only at startup");
a61af66fc99e Initial load duke parents: diff changeset	473 return JVM_ACC_ABSTRACT \| JVM_ACC_FINAL \| JVM_ACC_PUBLIC;
a61af66fc99e Initial load duke parents: diff changeset	474 }
398 443791f333a2 6700107: java/lang/Class/forName/TooManyDimensions.java crashes with SIGSEGV in c2 compiler with fastdebug coleenp parents: 356 diff changeset	475 // Return the flags of the bottom element type.
443791f333a2 6700107: java/lang/Class/forName/TooManyDimensions.java crashes with SIGSEGV in c2 compiler with fastdebug coleenp parents: 356 diff changeset	476 jint element_flags = Klass::cast(bottom_klass())->compute_modifier_flags(CHECK_0);
0 a61af66fc99e Initial load duke parents: diff changeset	477
a61af66fc99e Initial load duke parents: diff changeset	478 return (element_flags & (JVM_ACC_PUBLIC \| JVM_ACC_PRIVATE \| JVM_ACC_PROTECTED))
a61af66fc99e Initial load duke parents: diff changeset	479 \| (JVM_ACC_ABSTRACT \| JVM_ACC_FINAL);
a61af66fc99e Initial load duke parents: diff changeset	480 }
a61af66fc99e Initial load duke parents: diff changeset	481
a61af66fc99e Initial load duke parents: diff changeset	482
a61af66fc99e Initial load duke parents: diff changeset	483 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	484 // Printing
a61af66fc99e Initial load duke parents: diff changeset	485
a61af66fc99e Initial load duke parents: diff changeset	486 void objArrayKlass::oop_print_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	487 arrayKlass::oop_print_on(obj, st);
a61af66fc99e Initial load duke parents: diff changeset	488 assert(obj->is_objArray(), "must be objArray");
a61af66fc99e Initial load duke parents: diff changeset	489 objArrayOop oa = objArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	490 int print_len = MIN2((intx) oa->length(), MaxElementPrintSize);
a61af66fc99e Initial load duke parents: diff changeset	491 for(int index = 0; index < print_len; index++) {
a61af66fc99e Initial load duke parents: diff changeset	492 st->print(" - %3d : ", index);
a61af66fc99e Initial load duke parents: diff changeset	493 oa->obj_at(index)->print_value_on(st);
a61af66fc99e Initial load duke parents: diff changeset	494 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	495 }
a61af66fc99e Initial load duke parents: diff changeset	496 int remaining = oa->length() - print_len;
a61af66fc99e Initial load duke parents: diff changeset	497 if (remaining > 0) {
a61af66fc99e Initial load duke parents: diff changeset	498 tty->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining);
a61af66fc99e Initial load duke parents: diff changeset	499 }
a61af66fc99e Initial load duke parents: diff changeset	500 }
a61af66fc99e Initial load duke parents: diff changeset	501
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	502 static int max_objArray_print_length = 4;
0 a61af66fc99e Initial load duke parents: diff changeset	503
a61af66fc99e Initial load duke parents: diff changeset	504 void objArrayKlass::oop_print_value_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	505 assert(obj->is_objArray(), "must be objArray");
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	506 st->print("a ");
0 a61af66fc99e Initial load duke parents: diff changeset	507 element_klass()->print_value_on(st);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	508 int len = objArrayOop(obj)->length();
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	509 st->print("[%d] ", len);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	510 obj->print_address_on(st);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	511 if (PrintOopAddress \|\| PrintMiscellaneous && (WizardMode \|\| Verbose)) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	512 st->print("{");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	513 for (int i = 0; i < len; i++) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	514 if (i > max_objArray_print_length) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	515 st->print("..."); break;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	516 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	517 st->print(" "INTPTR_FORMAT, (intptr_t)(void*)objArrayOop(obj)->obj_at(i));
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	518 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	519 st->print(" }");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	520 }
0 a61af66fc99e Initial load duke parents: diff changeset	521 }
a61af66fc99e Initial load duke parents: diff changeset	522
a61af66fc99e Initial load duke parents: diff changeset	523 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	524
a61af66fc99e Initial load duke parents: diff changeset	525 const char* objArrayKlass::internal_name() const {
a61af66fc99e Initial load duke parents: diff changeset	526 return external_name();
a61af66fc99e Initial load duke parents: diff changeset	527 }
a61af66fc99e Initial load duke parents: diff changeset	528
a61af66fc99e Initial load duke parents: diff changeset	529 // Verification
a61af66fc99e Initial load duke parents: diff changeset	530
a61af66fc99e Initial load duke parents: diff changeset	531 void objArrayKlass::oop_verify_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	532 arrayKlass::oop_verify_on(obj, st);
a61af66fc99e Initial load duke parents: diff changeset	533 guarantee(obj->is_objArray(), "must be objArray");
a61af66fc99e Initial load duke parents: diff changeset	534 objArrayOop oa = objArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	535 for(int index = 0; index < oa->length(); index++) {
a61af66fc99e Initial load duke parents: diff changeset	536 guarantee(oa->obj_at(index)->is_oop_or_null(), "should be oop");
a61af66fc99e Initial load duke parents: diff changeset	537 }
a61af66fc99e Initial load duke parents: diff changeset	538 }
a61af66fc99e Initial load duke parents: diff changeset	539
a61af66fc99e Initial load duke parents: diff changeset	540 void objArrayKlass::oop_verify_old_oop(oop obj, oop* p, bool allow_dirty) {
a61af66fc99e Initial load duke parents: diff changeset	541 /* $$$ move into remembered set verification?
a61af66fc99e Initial load duke parents: diff changeset	542 RememberedSet::verify_old_oop(obj, p, allow_dirty, true);
a61af66fc99e Initial load duke parents: diff changeset	543 */
a61af66fc99e Initial load duke parents: diff changeset	544 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	545 void objArrayKlass::oop_verify_old_oop(oop obj, narrowOop* p, bool allow_dirty) {}

Mercurial > hg > truffle

annotate src/share/vm/oops/objArrayKlass.cpp @ 1091:6aa7255741f3