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

annotate src/share/vm/oops/objArrayKlass.cpp @ 4155:394404b2d9bd

Removed strict requirement for GRAAL environment variable. It only needs to be set now if the graal directory is not in the directory hierarchy of GraalVM JDK.

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 21 Dec 2011 11:25:27 +0100
parents	e5383553fd4e
children	a735aec54ea4

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
2119 d4fca0a6abde 7011386: race in objArrayKlass::array_klass_impl kvn parents: 1972 diff changeset	2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1311 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1311 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1311 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	26 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	27 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	28 #include "gc_implementation/shared/markSweep.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	29 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	30 #include "memory/genOopClosures.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	31 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	32 #include "memory/universe.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	33 #include "oops/instanceKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	34 #include "oops/objArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	35 #include "oops/objArrayKlass.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	36 #include "oops/objArrayKlassKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	37 #include "oops/objArrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	38 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	39 #include "oops/oop.inline2.hpp"
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2119 diff changeset	40 #include "oops/symbol.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	41 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	42 #include "runtime/mutexLocker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	43 #include "utilities/copy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	44 #ifndef SERIALGC
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	45 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	46 #include "gc_implementation/g1/g1OopClosures.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	47 #include "gc_implementation/g1/g1RemSet.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	48 #include "gc_implementation/g1/heapRegionSeq.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	49 #include "gc_implementation/parNew/parOopClosures.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	50 #include "gc_implementation/parallelScavenge/psCompactionManager.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	51 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	52 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	53 #include "oops/oop.pcgc.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	54 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	55
a61af66fc99e Initial load duke parents: diff changeset	56 int objArrayKlass::oop_size(oop obj) const {
a61af66fc99e Initial load duke parents: diff changeset	57 assert(obj->is_objArray(), "must be object array");
a61af66fc99e Initial load duke parents: diff changeset	58 return objArrayOop(obj)->object_size();
a61af66fc99e Initial load duke parents: diff changeset	59 }
a61af66fc99e Initial load duke parents: diff changeset	60
a61af66fc99e Initial load duke parents: diff changeset	61 objArrayOop objArrayKlass::allocate(int length, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	62 if (length >= 0) {
a61af66fc99e Initial load duke parents: diff changeset	63 if (length <= arrayOopDesc::max_array_length(T_OBJECT)) {
a61af66fc99e Initial load duke parents: diff changeset	64 int size = objArrayOopDesc::object_size(length);
a61af66fc99e Initial load duke parents: diff changeset	65 KlassHandle h_k(THREAD, as_klassOop());
a61af66fc99e Initial load duke parents: diff changeset	66 objArrayOop a = (objArrayOop)CollectedHeap::array_allocate(h_k, size, length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	67 assert(a->is_parsable(), "Can't publish unless parsable");
a61af66fc99e Initial load duke parents: diff changeset	68 return a;
a61af66fc99e Initial load duke parents: diff changeset	69 } else {
876 1413494da700 6850957: Honor -XX:OnOutOfMemoryError when array size exceeds VM limit martin parents: 665 diff changeset	70 report_java_out_of_memory("Requested array size exceeds VM limit");
0 a61af66fc99e Initial load duke parents: diff changeset	71 THROW_OOP_0(Universe::out_of_memory_error_array_size());
a61af66fc99e Initial load duke parents: diff changeset	72 }
a61af66fc99e Initial load duke parents: diff changeset	73 } else {
a61af66fc99e Initial load duke parents: diff changeset	74 THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
a61af66fc99e Initial load duke parents: diff changeset	75 }
a61af66fc99e Initial load duke parents: diff changeset	76 }
a61af66fc99e Initial load duke parents: diff changeset	77
a61af66fc99e Initial load duke parents: diff changeset	78 static int multi_alloc_counter = 0;
a61af66fc99e Initial load duke parents: diff changeset	79
a61af66fc99e Initial load duke parents: diff changeset	80 oop objArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	81 int length = *sizes;
a61af66fc99e Initial load duke parents: diff changeset	82 // Call to lower_dimension uses this pointer, so most be called before a
a61af66fc99e Initial load duke parents: diff changeset	83 // possible GC
a61af66fc99e Initial load duke parents: diff changeset	84 KlassHandle h_lower_dimension(THREAD, lower_dimension());
a61af66fc99e Initial load duke parents: diff changeset	85 // If length < 0 allocate will throw an exception.
a61af66fc99e Initial load duke parents: diff changeset	86 objArrayOop array = allocate(length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	87 assert(array->is_parsable(), "Don't handlize unless parsable");
a61af66fc99e Initial load duke parents: diff changeset	88 objArrayHandle h_array (THREAD, array);
a61af66fc99e Initial load duke parents: diff changeset	89 if (rank > 1) {
a61af66fc99e Initial load duke parents: diff changeset	90 if (length != 0) {
a61af66fc99e Initial load duke parents: diff changeset	91 for (int index = 0; index < length; index++) {
a61af66fc99e Initial load duke parents: diff changeset	92 arrayKlass* ak = arrayKlass::cast(h_lower_dimension());
a61af66fc99e Initial load duke parents: diff changeset	93 oop sub_array = ak->multi_allocate(rank-1, &sizes[1], CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	94 assert(sub_array->is_parsable(), "Don't publish until parsable");
a61af66fc99e Initial load duke parents: diff changeset	95 h_array->obj_at_put(index, sub_array);
a61af66fc99e Initial load duke parents: diff changeset	96 }
a61af66fc99e Initial load duke parents: diff changeset	97 } else {
a61af66fc99e Initial load duke parents: diff changeset	98 // Since this array dimension has zero length, nothing will be
a61af66fc99e Initial load duke parents: diff changeset	99 // allocated, however the lower dimension values must be checked
a61af66fc99e Initial load duke parents: diff changeset	100 // for illegal values.
a61af66fc99e Initial load duke parents: diff changeset	101 for (int i = 0; i < rank - 1; ++i) {
a61af66fc99e Initial load duke parents: diff changeset	102 sizes += 1;
a61af66fc99e Initial load duke parents: diff changeset	103 if (*sizes < 0) {
a61af66fc99e Initial load duke parents: diff changeset	104 THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
a61af66fc99e Initial load duke parents: diff changeset	105 }
a61af66fc99e Initial load duke parents: diff changeset	106 }
a61af66fc99e Initial load duke parents: diff changeset	107 }
a61af66fc99e Initial load duke parents: diff changeset	108 }
a61af66fc99e Initial load duke parents: diff changeset	109 return h_array();
a61af66fc99e Initial load duke parents: diff changeset	110 }
a61af66fc99e Initial load duke parents: diff changeset	111
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	112 // 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	113 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	114 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	115
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	116 BarrierSet* bs = Universe::heap()->barrier_set();
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	117 // 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	118 // 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	119 // 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	120 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	121 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	122
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	123 if (s == d) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	124 // 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	125 assert(length > 0, "sanity check");
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 665 diff changeset	126 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	127 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	128 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	129 // 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	130 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	131 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	132 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	133 // 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	134 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	135 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	136 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	137 // 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	138 // 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	139 T* from = src;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	140 T* end = from + length;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	141 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	142 // 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	143 T element = *from;
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	144 // even slower now
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	145 bool element_is_null = oopDesc::is_null(element);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	146 oop new_val = element_is_null ? oop(NULL)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	147 : oopDesc::decode_heap_oop_not_null(element);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	148 if (element_is_null \|\|
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	149 Klass::cast((new_val->klass()))->is_subtype_of(bound)) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	150 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	151 p = from;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	152 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	153 // 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	154 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	155 // 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	156 // 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	157 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	158 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	159 THROW(vmSymbols::java_lang_ArrayStoreException());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	160 return;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	161 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	162 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	163 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	164 }
1091 6aa7255741f3 6906727: UseCompressedOops: some card-marking fixes related to object arrays ysr parents: 879 diff changeset	165 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	166 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	167
0 a61af66fc99e Initial load duke parents: diff changeset	168 void objArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d,
a61af66fc99e Initial load duke parents: diff changeset	169 int dst_pos, int length, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	170 assert(s->is_objArray(), "must be obj array");
a61af66fc99e Initial load duke parents: diff changeset	171
a61af66fc99e Initial load duke parents: diff changeset	172 if (!d->is_objArray()) {
a61af66fc99e Initial load duke parents: diff changeset	173 THROW(vmSymbols::java_lang_ArrayStoreException());
a61af66fc99e Initial load duke parents: diff changeset	174 }
a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176 // Check is all offsets and lengths are non negative
a61af66fc99e Initial load duke parents: diff changeset	177 if (src_pos < 0 \|\| dst_pos < 0 \|\| length < 0) {
a61af66fc99e Initial load duke parents: diff changeset	178 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
a61af66fc99e Initial load duke parents: diff changeset	179 }
a61af66fc99e Initial load duke parents: diff changeset	180 // Check if the ranges are valid
a61af66fc99e Initial load duke parents: diff changeset	181 if ( (((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length())
a61af66fc99e Initial load duke parents: diff changeset	182 \|\| (((unsigned int) length + (unsigned int) dst_pos) > (unsigned int) d->length()) ) {
a61af66fc99e Initial load duke parents: diff changeset	183 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
a61af66fc99e Initial load duke parents: diff changeset	184 }
a61af66fc99e Initial load duke parents: diff changeset	185
a61af66fc99e Initial load duke parents: diff changeset	186 // Special case. Boundary cases must be checked first
a61af66fc99e Initial load duke parents: diff changeset	187 // This allows the following call: copy_array(s, s.length(), d.length(), 0).
a61af66fc99e Initial load duke parents: diff changeset	188 // 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	189 // points to the right of the last element.
a61af66fc99e Initial load duke parents: diff changeset	190 if (length==0) {
a61af66fc99e Initial load duke parents: diff changeset	191 return;
a61af66fc99e Initial load duke parents: diff changeset	192 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	193 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	194 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	195 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	196 do_copy<narrowOop>(s, src, d, dst, length, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	197 } else {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	198 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	199 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	200 do_copy<oop> (s, src, d, dst, length, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	201 }
a61af66fc99e Initial load duke parents: diff changeset	202 }
a61af66fc99e Initial load duke parents: diff changeset	203
a61af66fc99e Initial load duke parents: diff changeset	204
a61af66fc99e Initial load duke parents: diff changeset	205 klassOop objArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	206 objArrayKlassHandle h_this(THREAD, as_klassOop());
a61af66fc99e Initial load duke parents: diff changeset	207 return array_klass_impl(h_this, or_null, n, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	208 }
a61af66fc99e Initial load duke parents: diff changeset	209
a61af66fc99e Initial load duke parents: diff changeset	210
a61af66fc99e Initial load duke parents: diff changeset	211 klassOop objArrayKlass::array_klass_impl(objArrayKlassHandle this_oop, bool or_null, int n, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	212
a61af66fc99e Initial load duke parents: diff changeset	213 assert(this_oop->dimension() <= n, "check order of chain");
a61af66fc99e Initial load duke parents: diff changeset	214 int dimension = this_oop->dimension();
a61af66fc99e Initial load duke parents: diff changeset	215 if (dimension == n)
a61af66fc99e Initial load duke parents: diff changeset	216 return this_oop();
a61af66fc99e Initial load duke parents: diff changeset	217
a61af66fc99e Initial load duke parents: diff changeset	218 objArrayKlassHandle ak (THREAD, this_oop->higher_dimension());
a61af66fc99e Initial load duke parents: diff changeset	219 if (ak.is_null()) {
a61af66fc99e Initial load duke parents: diff changeset	220 if (or_null) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	221
a61af66fc99e Initial load duke parents: diff changeset	222 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	223 JavaThread jt = (JavaThread )THREAD;
a61af66fc99e Initial load duke parents: diff changeset	224 {
a61af66fc99e Initial load duke parents: diff changeset	225 MutexLocker mc(Compile_lock, THREAD); // for vtables
a61af66fc99e Initial load duke parents: diff changeset	226 // Ensure atomic creation of higher dimensions
a61af66fc99e Initial load duke parents: diff changeset	227 MutexLocker mu(MultiArray_lock, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	228
a61af66fc99e Initial load duke parents: diff changeset	229 // Check if another thread beat us
a61af66fc99e Initial load duke parents: diff changeset	230 ak = objArrayKlassHandle(THREAD, this_oop->higher_dimension());
a61af66fc99e Initial load duke parents: diff changeset	231 if( ak.is_null() ) {
a61af66fc99e Initial load duke parents: diff changeset	232
a61af66fc99e Initial load duke parents: diff changeset	233 // Create multi-dim klass object and link them together
a61af66fc99e Initial load duke parents: diff changeset	234 klassOop new_klass =
a61af66fc99e Initial load duke parents: diff changeset	235 objArrayKlassKlass::cast(Universe::objArrayKlassKlassObj())->
a61af66fc99e Initial load duke parents: diff changeset	236 allocate_objArray_klass(dimension + 1, this_oop, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	237 ak = objArrayKlassHandle(THREAD, new_klass);
2119 d4fca0a6abde 7011386: race in objArrayKlass::array_klass_impl kvn parents: 1972 diff changeset	238 ak->set_lower_dimension(this_oop());
d4fca0a6abde 7011386: race in objArrayKlass::array_klass_impl kvn parents: 1972 diff changeset	239 OrderAccess::storestore();
0 a61af66fc99e Initial load duke parents: diff changeset	240 this_oop->set_higher_dimension(ak());
a61af66fc99e Initial load duke parents: diff changeset	241 assert(ak->oop_is_objArray(), "incorrect initialization of objArrayKlass");
a61af66fc99e Initial load duke parents: diff changeset	242 }
a61af66fc99e Initial load duke parents: diff changeset	243 }
a61af66fc99e Initial load duke parents: diff changeset	244 } else {
a61af66fc99e Initial load duke parents: diff changeset	245 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
a61af66fc99e Initial load duke parents: diff changeset	246 }
a61af66fc99e Initial load duke parents: diff changeset	247
a61af66fc99e Initial load duke parents: diff changeset	248 if (or_null) {
a61af66fc99e Initial load duke parents: diff changeset	249 return ak->array_klass_or_null(n);
a61af66fc99e Initial load duke parents: diff changeset	250 }
a61af66fc99e Initial load duke parents: diff changeset	251 return ak->array_klass(n, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	252 }
a61af66fc99e Initial load duke parents: diff changeset	253
a61af66fc99e Initial load duke parents: diff changeset	254 klassOop objArrayKlass::array_klass_impl(bool or_null, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	255 return array_klass_impl(or_null, dimension() + 1, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	256 }
a61af66fc99e Initial load duke parents: diff changeset	257
a61af66fc99e Initial load duke parents: diff changeset	258 bool objArrayKlass::can_be_primary_super_slow() const {
a61af66fc99e Initial load duke parents: diff changeset	259 if (!bottom_klass()->klass_part()->can_be_primary_super())
a61af66fc99e Initial load duke parents: diff changeset	260 // array of interfaces
a61af66fc99e Initial load duke parents: diff changeset	261 return false;
a61af66fc99e Initial load duke parents: diff changeset	262 else
a61af66fc99e Initial load duke parents: diff changeset	263 return Klass::can_be_primary_super_slow();
a61af66fc99e Initial load duke parents: diff changeset	264 }
a61af66fc99e Initial load duke parents: diff changeset	265
a61af66fc99e Initial load duke parents: diff changeset	266 objArrayOop objArrayKlass::compute_secondary_supers(int num_extra_slots, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	267 // interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... };
a61af66fc99e Initial load duke parents: diff changeset	268 objArrayOop es = Klass::cast(element_klass())->secondary_supers();
a61af66fc99e Initial load duke parents: diff changeset	269 objArrayHandle elem_supers (THREAD, es);
a61af66fc99e Initial load duke parents: diff changeset	270 int num_elem_supers = elem_supers.is_null() ? 0 : elem_supers->length();
a61af66fc99e Initial load duke parents: diff changeset	271 int num_secondaries = num_extra_slots + 2 + num_elem_supers;
a61af66fc99e Initial load duke parents: diff changeset	272 if (num_secondaries == 2) {
a61af66fc99e Initial load duke parents: diff changeset	273 // Must share this for correct bootstrapping!
a61af66fc99e Initial load duke parents: diff changeset	274 return Universe::the_array_interfaces_array();
a61af66fc99e Initial load duke parents: diff changeset	275 } else {
a61af66fc99e Initial load duke parents: diff changeset	276 objArrayOop sec_oop = oopFactory::new_system_objArray(num_secondaries, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	277 objArrayHandle secondaries(THREAD, sec_oop);
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1091 diff changeset	278 secondaries->obj_at_put(num_extra_slots+0, SystemDictionary::Cloneable_klass());
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1091 diff changeset	279 secondaries->obj_at_put(num_extra_slots+1, SystemDictionary::Serializable_klass());
0 a61af66fc99e Initial load duke parents: diff changeset	280 for (int i = 0; i < num_elem_supers; i++) {
a61af66fc99e Initial load duke parents: diff changeset	281 klassOop elem_super = (klassOop) elem_supers->obj_at(i);
a61af66fc99e Initial load duke parents: diff changeset	282 klassOop array_super = elem_super->klass_part()->array_klass_or_null();
a61af66fc99e Initial load duke parents: diff changeset	283 assert(array_super != NULL, "must already have been created");
a61af66fc99e Initial load duke parents: diff changeset	284 secondaries->obj_at_put(num_extra_slots+2+i, array_super);
a61af66fc99e Initial load duke parents: diff changeset	285 }
a61af66fc99e Initial load duke parents: diff changeset	286 return secondaries();
a61af66fc99e Initial load duke parents: diff changeset	287 }
a61af66fc99e Initial load duke parents: diff changeset	288 }
a61af66fc99e Initial load duke parents: diff changeset	289
a61af66fc99e Initial load duke parents: diff changeset	290 bool objArrayKlass::compute_is_subtype_of(klassOop k) {
a61af66fc99e Initial load duke parents: diff changeset	291 if (!k->klass_part()->oop_is_objArray())
a61af66fc99e Initial load duke parents: diff changeset	292 return arrayKlass::compute_is_subtype_of(k);
a61af66fc99e Initial load duke parents: diff changeset	293
a61af66fc99e Initial load duke parents: diff changeset	294 objArrayKlass* oak = objArrayKlass::cast(k);
a61af66fc99e Initial load duke parents: diff changeset	295 return element_klass()->klass_part()->is_subtype_of(oak->element_klass());
a61af66fc99e Initial load duke parents: diff changeset	296 }
a61af66fc99e Initial load duke parents: diff changeset	297
a61af66fc99e Initial load duke parents: diff changeset	298 void objArrayKlass::initialize(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	299 Klass::cast(bottom_klass())->initialize(THREAD); // dispatches to either instanceKlass or typeArrayKlass
a61af66fc99e Initial load duke parents: diff changeset	300 }
a61af66fc99e Initial load duke parents: diff changeset	301
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	302 #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	303 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	304 T* p = (T*)(a)->base(); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	305 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	306 while (p < end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	307 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	308 p++; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	309 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	310 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	311
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	312 #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	313 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	314 T* const l = (T*)(low); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	315 T* const h = (T*)(high); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	316 T* p = (T*)(a)->base(); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	317 T* end = p + (a)->length(); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	318 if (p < l) p = l; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	319 if (end > h) end = h; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	320 while (p < end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	321 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	322 ++p; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	323 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	324 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	325
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	326 #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	327 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	328 ObjArrayKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	329 a, p, do_oop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	330 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	331 ObjArrayKlass_SPECIALIZED_OOP_ITERATE(oop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	332 a, p, do_oop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	333 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	334
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	335 #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	336 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	337 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	338 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	339 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	340 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	341 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	342 }
0 a61af66fc99e Initial load duke parents: diff changeset	343
a61af66fc99e Initial load duke parents: diff changeset	344 void objArrayKlass::oop_follow_contents(oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	345 assert (obj->is_array(), "obj must be array");
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	346 objArrayOop(obj)->follow_header();
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	347 if (UseCompressedOops) {
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	348 objarray_follow_contents<narrowOop>(obj, 0);
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	349 } else {
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	350 objarray_follow_contents<oop>(obj, 0);
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	351 }
0 a61af66fc99e Initial load duke parents: diff changeset	352 }
a61af66fc99e Initial load duke parents: diff changeset	353
a61af66fc99e Initial load duke parents: diff changeset	354 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	355 void objArrayKlass::oop_follow_contents(ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	356 oop obj) {
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	357 assert(obj->is_array(), "obj must be array");
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	358 objArrayOop(obj)->follow_header(cm);
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	359 if (UseCompressedOops) {
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	360 objarray_follow_contents<narrowOop>(cm, obj, 0);
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	361 } else {
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	362 objarray_follow_contents<oop>(cm, obj, 0);
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	363 }
0 a61af66fc99e Initial load duke parents: diff changeset	364 }
a61af66fc99e Initial load duke parents: diff changeset	365 #endif // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	366
a61af66fc99e Initial load duke parents: diff changeset	367 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
a61af66fc99e Initial load duke parents: diff changeset	368 \
a61af66fc99e Initial load duke parents: diff changeset	369 int objArrayKlass::oop_oop_iterate##nv_suffix(oop obj, \
a61af66fc99e Initial load duke parents: diff changeset	370 OopClosureType* closure) { \
a61af66fc99e Initial load duke parents: diff changeset	371 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
a61af66fc99e Initial load duke parents: diff changeset	372 assert (obj->is_array(), "obj must be array"); \
a61af66fc99e Initial load duke parents: diff changeset	373 objArrayOop a = objArrayOop(obj); \
a61af66fc99e Initial load duke parents: diff changeset	374 /* Get size before changing pointers. */ \
a61af66fc99e Initial load duke parents: diff changeset	375 /* Don't call size() or oop_size() since that is a virtual call. */ \
a61af66fc99e Initial load duke parents: diff changeset	376 int size = a->object_size(); \
a61af66fc99e Initial load duke parents: diff changeset	377 if (closure->do_header()) { \
a61af66fc99e Initial load duke parents: diff changeset	378 a->oop_iterate_header(closure); \
a61af66fc99e Initial load duke parents: diff changeset	379 } \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	380 ObjArrayKlass_OOP_ITERATE(a, p, (closure)->do_oop##nv_suffix(p)) \
0 a61af66fc99e Initial load duke parents: diff changeset	381 return size; \
a61af66fc99e Initial load duke parents: diff changeset	382 }
a61af66fc99e Initial load duke parents: diff changeset	383
a61af66fc99e Initial load duke parents: diff changeset	384 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \
a61af66fc99e Initial load duke parents: diff changeset	385 \
a61af66fc99e Initial load duke parents: diff changeset	386 int objArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \
a61af66fc99e Initial load duke parents: diff changeset	387 OopClosureType* closure, \
a61af66fc99e Initial load duke parents: diff changeset	388 MemRegion mr) { \
a61af66fc99e Initial load duke parents: diff changeset	389 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
a61af66fc99e Initial load duke parents: diff changeset	390 assert(obj->is_array(), "obj must be array"); \
a61af66fc99e Initial load duke parents: diff changeset	391 objArrayOop a = objArrayOop(obj); \
a61af66fc99e Initial load duke parents: diff changeset	392 /* Get size before changing pointers. */ \
a61af66fc99e Initial load duke parents: diff changeset	393 /* Don't call size() or oop_size() since that is a virtual call */ \
a61af66fc99e Initial load duke parents: diff changeset	394 int size = a->object_size(); \
a61af66fc99e Initial load duke parents: diff changeset	395 if (closure->do_header()) { \
a61af66fc99e Initial load duke parents: diff changeset	396 a->oop_iterate_header(closure, mr); \
a61af66fc99e Initial load duke parents: diff changeset	397 } \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	398 ObjArrayKlass_BOUNDED_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	399 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	400 return size; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	401 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	402
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	403 // 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	404 // for objArrayOops.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	405 #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	406 \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	407 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	408 OopClosureType* closure, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	409 int start, int end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	410 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	411 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	412 objArrayOop a = objArrayOop(obj); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	413 /* Get size before changing pointers. */ \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	414 /* 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	415 int size = a->object_size(); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	416 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	417 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	418 /* 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	419 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	420 MemRegion mr(low, high); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	421 if (closure->do_header()) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	422 a->oop_iterate_header(closure, mr); \
0 a61af66fc99e Initial load duke parents: diff changeset	423 } \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	424 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	425 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \
0 a61af66fc99e Initial load duke parents: diff changeset	426 } else { \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	427 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	428 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	429 MemRegion mr(low, high); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	430 if (closure->do_header()) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	431 a->oop_iterate_header(closure, mr); \
0 a61af66fc99e Initial load duke parents: diff changeset	432 } \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	433 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	434 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \
0 a61af66fc99e Initial load duke parents: diff changeset	435 } \
a61af66fc99e Initial load duke parents: diff changeset	436 return size; \
a61af66fc99e Initial load duke parents: diff changeset	437 }
a61af66fc99e Initial load duke parents: diff changeset	438
a61af66fc99e Initial load duke parents: diff changeset	439 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	440 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN)
0 a61af66fc99e Initial load duke parents: diff changeset	441 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	442 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	443 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	444 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r)
0 a61af66fc99e Initial load duke parents: diff changeset	445
a61af66fc99e Initial load duke parents: diff changeset	446 int objArrayKlass::oop_adjust_pointers(oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	447 assert(obj->is_objArray(), "obj must be obj array");
a61af66fc99e Initial load duke parents: diff changeset	448 objArrayOop a = objArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	449 // Get size before changing pointers.
a61af66fc99e Initial load duke parents: diff changeset	450 // Don't call size() or oop_size() since that is a virtual call.
a61af66fc99e Initial load duke parents: diff changeset	451 int size = a->object_size();
a61af66fc99e Initial load duke parents: diff changeset	452 a->adjust_header();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	453 ObjArrayKlass_OOP_ITERATE(a, p, MarkSweep::adjust_pointer(p))
0 a61af66fc99e Initial load duke parents: diff changeset	454 return size;
a61af66fc99e Initial load duke parents: diff changeset	455 }
a61af66fc99e Initial load duke parents: diff changeset	456
a61af66fc99e Initial load duke parents: diff changeset	457 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	458 void objArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	459 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	460 ObjArrayKlass_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	461 objArrayOop(obj), p, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	462 if (PSScavenge::should_scavenge(p)) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	463 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	464 })
0 a61af66fc99e Initial load duke parents: diff changeset	465 }
a61af66fc99e Initial load duke parents: diff changeset	466
a61af66fc99e Initial load duke parents: diff changeset	467 int objArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	468 assert (obj->is_objArray(), "obj must be obj array");
a61af66fc99e Initial load duke parents: diff changeset	469 objArrayOop a = objArrayOop(obj);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	470 ObjArrayKlass_OOP_ITERATE(a, p, PSParallelCompact::adjust_pointer(p))
0 a61af66fc99e Initial load duke parents: diff changeset	471 return a->object_size();
a61af66fc99e Initial load duke parents: diff changeset	472 }
a61af66fc99e Initial load duke parents: diff changeset	473 #endif // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	474
a61af66fc99e Initial load duke parents: diff changeset	475 // JVM support
a61af66fc99e Initial load duke parents: diff changeset	476
a61af66fc99e Initial load duke parents: diff changeset	477 jint objArrayKlass::compute_modifier_flags(TRAPS) const {
a61af66fc99e Initial load duke parents: diff changeset	478 // The modifier for an objectArray is the same as its element
a61af66fc99e Initial load duke parents: diff changeset	479 if (element_klass() == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	480 assert(Universe::is_bootstrapping(), "partial objArray only at startup");
a61af66fc99e Initial load duke parents: diff changeset	481 return JVM_ACC_ABSTRACT \| JVM_ACC_FINAL \| JVM_ACC_PUBLIC;
a61af66fc99e Initial load duke parents: diff changeset	482 }
398 443791f333a2 6700107: java/lang/Class/forName/TooManyDimensions.java crashes with SIGSEGV in c2 compiler with fastdebug coleenp parents: 356 diff changeset	483 // 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	484 jint element_flags = Klass::cast(bottom_klass())->compute_modifier_flags(CHECK_0);
0 a61af66fc99e Initial load duke parents: diff changeset	485
a61af66fc99e Initial load duke parents: diff changeset	486 return (element_flags & (JVM_ACC_PUBLIC \| JVM_ACC_PRIVATE \| JVM_ACC_PROTECTED))
a61af66fc99e Initial load duke parents: diff changeset	487 \| (JVM_ACC_ABSTRACT \| JVM_ACC_FINAL);
a61af66fc99e Initial load duke parents: diff changeset	488 }
a61af66fc99e Initial load duke parents: diff changeset	489
a61af66fc99e Initial load duke parents: diff changeset	490
a61af66fc99e Initial load duke parents: diff changeset	491 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	492 // Printing
a61af66fc99e Initial load duke parents: diff changeset	493
a61af66fc99e Initial load duke parents: diff changeset	494 void objArrayKlass::oop_print_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	495 arrayKlass::oop_print_on(obj, st);
a61af66fc99e Initial load duke parents: diff changeset	496 assert(obj->is_objArray(), "must be objArray");
a61af66fc99e Initial load duke parents: diff changeset	497 objArrayOop oa = objArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	498 int print_len = MIN2((intx) oa->length(), MaxElementPrintSize);
a61af66fc99e Initial load duke parents: diff changeset	499 for(int index = 0; index < print_len; index++) {
a61af66fc99e Initial load duke parents: diff changeset	500 st->print(" - %3d : ", index);
a61af66fc99e Initial load duke parents: diff changeset	501 oa->obj_at(index)->print_value_on(st);
a61af66fc99e Initial load duke parents: diff changeset	502 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	503 }
a61af66fc99e Initial load duke parents: diff changeset	504 int remaining = oa->length() - print_len;
a61af66fc99e Initial load duke parents: diff changeset	505 if (remaining > 0) {
a61af66fc99e Initial load duke parents: diff changeset	506 tty->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining);
a61af66fc99e Initial load duke parents: diff changeset	507 }
a61af66fc99e Initial load duke parents: diff changeset	508 }
a61af66fc99e Initial load duke parents: diff changeset	509
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1142 diff changeset	510 #endif //PRODUCT
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1142 diff changeset	511
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	512 static int max_objArray_print_length = 4;
0 a61af66fc99e Initial load duke parents: diff changeset	513
a61af66fc99e Initial load duke parents: diff changeset	514 void objArrayKlass::oop_print_value_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	515 assert(obj->is_objArray(), "must be objArray");
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	516 st->print("a ");
0 a61af66fc99e Initial load duke parents: diff changeset	517 element_klass()->print_value_on(st);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	518 int len = objArrayOop(obj)->length();
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	519 st->print("[%d] ", len);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	520 obj->print_address_on(st);
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1142 diff changeset	521 if (NOT_PRODUCT(PrintOopAddress \|\|) PrintMiscellaneous && (WizardMode \|\| Verbose)) {
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	522 st->print("{");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	523 for (int i = 0; i < len; i++) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	524 if (i > max_objArray_print_length) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	525 st->print("..."); break;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	526 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	527 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	528 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	529 st->print(" }");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	530 }
0 a61af66fc99e Initial load duke parents: diff changeset	531 }
a61af66fc99e Initial load duke parents: diff changeset	532
a61af66fc99e Initial load duke parents: diff changeset	533 const char* objArrayKlass::internal_name() const {
a61af66fc99e Initial load duke parents: diff changeset	534 return external_name();
a61af66fc99e Initial load duke parents: diff changeset	535 }
a61af66fc99e Initial load duke parents: diff changeset	536
a61af66fc99e Initial load duke parents: diff changeset	537 // Verification
a61af66fc99e Initial load duke parents: diff changeset	538
a61af66fc99e Initial load duke parents: diff changeset	539 void objArrayKlass::oop_verify_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	540 arrayKlass::oop_verify_on(obj, st);
a61af66fc99e Initial load duke parents: diff changeset	541 guarantee(obj->is_objArray(), "must be objArray");
a61af66fc99e Initial load duke parents: diff changeset	542 objArrayOop oa = objArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	543 for(int index = 0; index < oa->length(); index++) {
a61af66fc99e Initial load duke parents: diff changeset	544 guarantee(oa->obj_at(index)->is_oop_or_null(), "should be oop");
a61af66fc99e Initial load duke parents: diff changeset	545 }
a61af66fc99e Initial load duke parents: diff changeset	546 }
a61af66fc99e Initial load duke parents: diff changeset	547
a61af66fc99e Initial load duke parents: diff changeset	548 void objArrayKlass::oop_verify_old_oop(oop obj, oop* p, bool allow_dirty) {
a61af66fc99e Initial load duke parents: diff changeset	549 /* $$$ move into remembered set verification?
a61af66fc99e Initial load duke parents: diff changeset	550 RememberedSet::verify_old_oop(obj, p, allow_dirty, true);
a61af66fc99e Initial load duke parents: diff changeset	551 */
a61af66fc99e Initial load duke parents: diff changeset	552 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	553 void objArrayKlass::oop_verify_old_oop(oop obj, narrowOop* p, bool allow_dirty) {}

Mercurial > hg > truffle

annotate src/share/vm/oops/objArrayKlass.cpp @ 4155:394404b2d9bd