duke@435: /* duke@435: * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved. duke@435: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. duke@435: * duke@435: * This code is free software; you can redistribute it and/or modify it duke@435: * under the terms of the GNU General Public License version 2 only, as duke@435: * published by the Free Software Foundation. duke@435: * duke@435: * This code is distributed in the hope that it will be useful, but WITHOUT duke@435: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or duke@435: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License duke@435: * version 2 for more details (a copy is included in the LICENSE file that duke@435: * accompanied this code). duke@435: * duke@435: * You should have received a copy of the GNU General Public License version duke@435: * 2 along with this work; if not, write to the Free Software Foundation, duke@435: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. duke@435: * duke@435: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, duke@435: * CA 95054 USA or visit www.sun.com if you need additional information or duke@435: * have any questions. duke@435: * duke@435: */ duke@435: duke@435: # include "incls/_precompiled.incl" duke@435: # include "incls/_objArrayKlass.cpp.incl" duke@435: duke@435: int objArrayKlass::oop_size(oop obj) const { duke@435: assert(obj->is_objArray(), "must be object array"); duke@435: return objArrayOop(obj)->object_size(); duke@435: } duke@435: duke@435: objArrayOop objArrayKlass::allocate(int length, TRAPS) { duke@435: if (length >= 0) { duke@435: if (length <= arrayOopDesc::max_array_length(T_OBJECT)) { duke@435: int size = objArrayOopDesc::object_size(length); duke@435: KlassHandle h_k(THREAD, as_klassOop()); duke@435: objArrayOop a = (objArrayOop)CollectedHeap::array_allocate(h_k, size, length, CHECK_NULL); duke@435: assert(a->is_parsable(), "Can't publish unless parsable"); duke@435: return a; duke@435: } else { duke@435: THROW_OOP_0(Universe::out_of_memory_error_array_size()); duke@435: } duke@435: } else { duke@435: THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); duke@435: } duke@435: } duke@435: duke@435: static int multi_alloc_counter = 0; duke@435: duke@435: oop objArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) { duke@435: int length = *sizes; duke@435: // Call to lower_dimension uses this pointer, so most be called before a duke@435: // possible GC duke@435: KlassHandle h_lower_dimension(THREAD, lower_dimension()); duke@435: // If length < 0 allocate will throw an exception. duke@435: objArrayOop array = allocate(length, CHECK_NULL); duke@435: assert(array->is_parsable(), "Don't handlize unless parsable"); duke@435: objArrayHandle h_array (THREAD, array); duke@435: if (rank > 1) { duke@435: if (length != 0) { duke@435: for (int index = 0; index < length; index++) { duke@435: arrayKlass* ak = arrayKlass::cast(h_lower_dimension()); duke@435: oop sub_array = ak->multi_allocate(rank-1, &sizes[1], CHECK_NULL); duke@435: assert(sub_array->is_parsable(), "Don't publish until parsable"); duke@435: h_array->obj_at_put(index, sub_array); duke@435: } duke@435: } else { duke@435: // Since this array dimension has zero length, nothing will be duke@435: // allocated, however the lower dimension values must be checked duke@435: // for illegal values. duke@435: for (int i = 0; i < rank - 1; ++i) { duke@435: sizes += 1; duke@435: if (*sizes < 0) { duke@435: THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); duke@435: } duke@435: } duke@435: } duke@435: } duke@435: return h_array(); duke@435: } duke@435: duke@435: void objArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, duke@435: int dst_pos, int length, TRAPS) { duke@435: assert(s->is_objArray(), "must be obj array"); duke@435: duke@435: if (!d->is_objArray()) { duke@435: THROW(vmSymbols::java_lang_ArrayStoreException()); duke@435: } duke@435: duke@435: // Check is all offsets and lengths are non negative duke@435: if (src_pos < 0 || dst_pos < 0 || length < 0) { duke@435: THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); duke@435: } duke@435: // Check if the ranges are valid duke@435: if ( (((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length()) duke@435: || (((unsigned int) length + (unsigned int) dst_pos) > (unsigned int) d->length()) ) { duke@435: THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); duke@435: } duke@435: duke@435: // Special case. Boundary cases must be checked first duke@435: // This allows the following call: copy_array(s, s.length(), d.length(), 0). duke@435: // This is correct, since the position is supposed to be an 'in between point', i.e., s.length(), duke@435: // points to the right of the last element. duke@435: if (length==0) { duke@435: return; duke@435: } duke@435: duke@435: oop* const src = objArrayOop(s)->obj_at_addr(src_pos); duke@435: oop* const dst = objArrayOop(d)->obj_at_addr(dst_pos); duke@435: const size_t word_len = length * HeapWordsPerOop; duke@435: duke@435: // For performance reasons, we assume we are using a card marking write duke@435: // barrier. The assert will fail if this is not the case. duke@435: BarrierSet* bs = Universe::heap()->barrier_set(); duke@435: assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt"); duke@435: duke@435: if (s == d) { duke@435: // since source and destination are equal we do not need conversion checks. duke@435: assert(length > 0, "sanity check"); duke@435: Copy::conjoint_oops_atomic(src, dst, length); duke@435: } else { duke@435: // We have to make sure all elements conform to the destination array duke@435: klassOop bound = objArrayKlass::cast(d->klass())->element_klass(); duke@435: klassOop stype = objArrayKlass::cast(s->klass())->element_klass(); duke@435: if (stype == bound || Klass::cast(stype)->is_subtype_of(bound)) { duke@435: // elements are guaranteed to be subtypes, so no check necessary duke@435: Copy::conjoint_oops_atomic(src, dst, length); duke@435: } else { duke@435: // slow case: need individual subtype checks duke@435: // note: don't use obj_at_put below because it includes a redundant store check duke@435: oop* from = src; duke@435: oop* end = from + length; duke@435: for (oop* p = dst; from < end; from++, p++) { duke@435: oop element = *from; duke@435: if (element == NULL || Klass::cast(element->klass())->is_subtype_of(bound)) { duke@435: *p = element; duke@435: } else { duke@435: // We must do a barrier to cover the partial copy. duke@435: const size_t done_word_len = pointer_delta(p, dst, oopSize) * duke@435: HeapWordsPerOop; duke@435: bs->write_ref_array(MemRegion((HeapWord*)dst, done_word_len)); duke@435: THROW(vmSymbols::java_lang_ArrayStoreException()); duke@435: return; duke@435: } duke@435: } duke@435: } duke@435: } duke@435: bs->write_ref_array(MemRegion((HeapWord*)dst, word_len)); duke@435: } duke@435: duke@435: duke@435: klassOop objArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) { duke@435: objArrayKlassHandle h_this(THREAD, as_klassOop()); duke@435: return array_klass_impl(h_this, or_null, n, CHECK_NULL); duke@435: } duke@435: duke@435: duke@435: klassOop objArrayKlass::array_klass_impl(objArrayKlassHandle this_oop, bool or_null, int n, TRAPS) { duke@435: duke@435: assert(this_oop->dimension() <= n, "check order of chain"); duke@435: int dimension = this_oop->dimension(); duke@435: if (dimension == n) duke@435: return this_oop(); duke@435: duke@435: objArrayKlassHandle ak (THREAD, this_oop->higher_dimension()); duke@435: if (ak.is_null()) { duke@435: if (or_null) return NULL; duke@435: duke@435: ResourceMark rm; duke@435: JavaThread *jt = (JavaThread *)THREAD; duke@435: { duke@435: MutexLocker mc(Compile_lock, THREAD); // for vtables duke@435: // Ensure atomic creation of higher dimensions duke@435: MutexLocker mu(MultiArray_lock, THREAD); duke@435: duke@435: // Check if another thread beat us duke@435: ak = objArrayKlassHandle(THREAD, this_oop->higher_dimension()); duke@435: if( ak.is_null() ) { duke@435: duke@435: // Create multi-dim klass object and link them together duke@435: klassOop new_klass = duke@435: objArrayKlassKlass::cast(Universe::objArrayKlassKlassObj())-> duke@435: allocate_objArray_klass(dimension + 1, this_oop, CHECK_NULL); duke@435: ak = objArrayKlassHandle(THREAD, new_klass); duke@435: this_oop->set_higher_dimension(ak()); duke@435: ak->set_lower_dimension(this_oop()); duke@435: assert(ak->oop_is_objArray(), "incorrect initialization of objArrayKlass"); duke@435: } duke@435: } duke@435: } else { duke@435: CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); duke@435: } duke@435: duke@435: if (or_null) { duke@435: return ak->array_klass_or_null(n); duke@435: } duke@435: return ak->array_klass(n, CHECK_NULL); duke@435: } duke@435: duke@435: klassOop objArrayKlass::array_klass_impl(bool or_null, TRAPS) { duke@435: return array_klass_impl(or_null, dimension() + 1, CHECK_NULL); duke@435: } duke@435: duke@435: bool objArrayKlass::can_be_primary_super_slow() const { duke@435: if (!bottom_klass()->klass_part()->can_be_primary_super()) duke@435: // array of interfaces duke@435: return false; duke@435: else duke@435: return Klass::can_be_primary_super_slow(); duke@435: } duke@435: duke@435: objArrayOop objArrayKlass::compute_secondary_supers(int num_extra_slots, TRAPS) { duke@435: // interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... }; duke@435: objArrayOop es = Klass::cast(element_klass())->secondary_supers(); duke@435: objArrayHandle elem_supers (THREAD, es); duke@435: int num_elem_supers = elem_supers.is_null() ? 0 : elem_supers->length(); duke@435: int num_secondaries = num_extra_slots + 2 + num_elem_supers; duke@435: if (num_secondaries == 2) { duke@435: // Must share this for correct bootstrapping! duke@435: return Universe::the_array_interfaces_array(); duke@435: } else { duke@435: objArrayOop sec_oop = oopFactory::new_system_objArray(num_secondaries, CHECK_NULL); duke@435: objArrayHandle secondaries(THREAD, sec_oop); duke@435: secondaries->obj_at_put(num_extra_slots+0, SystemDictionary::cloneable_klass()); duke@435: secondaries->obj_at_put(num_extra_slots+1, SystemDictionary::serializable_klass()); duke@435: for (int i = 0; i < num_elem_supers; i++) { duke@435: klassOop elem_super = (klassOop) elem_supers->obj_at(i); duke@435: klassOop array_super = elem_super->klass_part()->array_klass_or_null(); duke@435: assert(array_super != NULL, "must already have been created"); duke@435: secondaries->obj_at_put(num_extra_slots+2+i, array_super); duke@435: } duke@435: return secondaries(); duke@435: } duke@435: } duke@435: duke@435: bool objArrayKlass::compute_is_subtype_of(klassOop k) { duke@435: if (!k->klass_part()->oop_is_objArray()) duke@435: return arrayKlass::compute_is_subtype_of(k); duke@435: duke@435: objArrayKlass* oak = objArrayKlass::cast(k); duke@435: return element_klass()->klass_part()->is_subtype_of(oak->element_klass()); duke@435: } duke@435: duke@435: duke@435: void objArrayKlass::initialize(TRAPS) { duke@435: Klass::cast(bottom_klass())->initialize(THREAD); // dispatches to either instanceKlass or typeArrayKlass duke@435: } duke@435: duke@435: duke@435: void objArrayKlass::oop_follow_contents(oop obj) { duke@435: assert (obj->is_array(), "obj must be array"); duke@435: arrayOop a = arrayOop(obj); duke@435: a->follow_header(); duke@435: oop* base = (oop*)a->base(T_OBJECT); duke@435: oop* const end = base + a->length(); duke@435: while (base < end) { duke@435: if (*base != NULL) duke@435: // we call mark_and_follow here to avoid excessive marking stack usage duke@435: MarkSweep::mark_and_follow(base); duke@435: base++; duke@435: } duke@435: } duke@435: duke@435: #ifndef SERIALGC duke@435: void objArrayKlass::oop_follow_contents(ParCompactionManager* cm, duke@435: oop obj) { duke@435: assert (obj->is_array(), "obj must be array"); duke@435: arrayOop a = arrayOop(obj); duke@435: a->follow_header(cm); duke@435: oop* base = (oop*)a->base(T_OBJECT); duke@435: oop* const end = base + a->length(); duke@435: while (base < end) { duke@435: if (*base != NULL) duke@435: // we call mark_and_follow here to avoid excessive marking stack usage duke@435: PSParallelCompact::mark_and_follow(cm, base); duke@435: base++; duke@435: } duke@435: } duke@435: #endif // SERIALGC duke@435: duke@435: #define invoke_closure_on(base, closure, nv_suffix) { \ duke@435: if (*(base) != NULL) { \ duke@435: (closure)->do_oop##nv_suffix(base); \ duke@435: } \ duke@435: } duke@435: duke@435: #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ duke@435: \ duke@435: int objArrayKlass::oop_oop_iterate##nv_suffix(oop obj, \ duke@435: OopClosureType* closure) { \ duke@435: SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \ duke@435: assert (obj->is_array(), "obj must be array"); \ duke@435: objArrayOop a = objArrayOop(obj); \ duke@435: /* Get size before changing pointers. */ \ duke@435: /* Don't call size() or oop_size() since that is a virtual call. */ \ duke@435: int size = a->object_size(); \ duke@435: if (closure->do_header()) { \ duke@435: a->oop_iterate_header(closure); \ duke@435: } \ duke@435: oop* base = a->base(); \ duke@435: oop* const end = base + a->length(); \ duke@435: const intx field_offset = PrefetchFieldsAhead; \ duke@435: if (field_offset > 0) { \ duke@435: while (base < end) { \ duke@435: prefetch_beyond(base, end, field_offset, closure->prefetch_style()); \ duke@435: invoke_closure_on(base, closure, nv_suffix); \ duke@435: base++; \ duke@435: } \ duke@435: } else { \ duke@435: while (base < end) { \ duke@435: invoke_closure_on(base, closure, nv_suffix); \ duke@435: base++; \ duke@435: } \ duke@435: } \ duke@435: return size; \ duke@435: } duke@435: duke@435: #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \ duke@435: \ duke@435: int objArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \ duke@435: OopClosureType* closure, \ duke@435: MemRegion mr) { \ duke@435: SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \ duke@435: assert(obj->is_array(), "obj must be array"); \ duke@435: objArrayOop a = objArrayOop(obj); \ duke@435: /* Get size before changing pointers. */ \ duke@435: /* Don't call size() or oop_size() since that is a virtual call */ \ duke@435: int size = a->object_size(); \ duke@435: if (closure->do_header()) { \ duke@435: a->oop_iterate_header(closure, mr); \ duke@435: } \ duke@435: oop* bottom = (oop*)mr.start(); \ duke@435: oop* top = (oop*)mr.end(); \ duke@435: oop* base = a->base(); \ duke@435: oop* end = base + a->length(); \ duke@435: if (base < bottom) { \ duke@435: base = bottom; \ duke@435: } \ duke@435: if (end > top) { \ duke@435: end = top; \ duke@435: } \ duke@435: const intx field_offset = PrefetchFieldsAhead; \ duke@435: if (field_offset > 0) { \ duke@435: while (base < end) { \ duke@435: prefetch_beyond(base, end, field_offset, closure->prefetch_style()); \ duke@435: invoke_closure_on(base, closure, nv_suffix); \ duke@435: base++; \ duke@435: } \ duke@435: } else { \ duke@435: while (base < end) { \ duke@435: invoke_closure_on(base, closure, nv_suffix); \ duke@435: base++; \ duke@435: } \ duke@435: } \ duke@435: return size; \ duke@435: } duke@435: duke@435: ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN) duke@435: ALL_OOP_OOP_ITERATE_CLOSURES_3(ObjArrayKlass_OOP_OOP_ITERATE_DEFN) duke@435: ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m) duke@435: ALL_OOP_OOP_ITERATE_CLOSURES_3(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m) duke@435: duke@435: int objArrayKlass::oop_adjust_pointers(oop obj) { duke@435: assert(obj->is_objArray(), "obj must be obj array"); duke@435: objArrayOop a = objArrayOop(obj); duke@435: // Get size before changing pointers. duke@435: // Don't call size() or oop_size() since that is a virtual call. duke@435: int size = a->object_size(); duke@435: a->adjust_header(); duke@435: oop* base = a->base(); duke@435: oop* const end = base + a->length(); duke@435: while (base < end) { duke@435: MarkSweep::adjust_pointer(base); duke@435: base++; duke@435: } duke@435: return size; duke@435: } duke@435: duke@435: #ifndef SERIALGC duke@435: void objArrayKlass::oop_copy_contents(PSPromotionManager* pm, oop obj) { duke@435: assert(!pm->depth_first(), "invariant"); duke@435: assert(obj->is_objArray(), "obj must be obj array"); duke@435: // Compute oop range duke@435: oop* curr = objArrayOop(obj)->base(); duke@435: oop* end = curr + objArrayOop(obj)->length(); duke@435: // assert(align_object_size(end - (oop*)obj) == oop_size(obj), "checking size"); duke@435: assert(align_object_size(pointer_delta(end, obj, sizeof(oop*))) duke@435: == oop_size(obj), "checking size"); duke@435: duke@435: // Iterate over oops duke@435: while (curr < end) { duke@435: if (PSScavenge::should_scavenge(*curr)) { duke@435: pm->claim_or_forward_breadth(curr); duke@435: } duke@435: ++curr; duke@435: } duke@435: } duke@435: duke@435: void objArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { duke@435: assert(pm->depth_first(), "invariant"); duke@435: assert(obj->is_objArray(), "obj must be obj array"); duke@435: // Compute oop range duke@435: oop* curr = objArrayOop(obj)->base(); duke@435: oop* end = curr + objArrayOop(obj)->length(); duke@435: // assert(align_object_size(end - (oop*)obj) == oop_size(obj), "checking size"); duke@435: assert(align_object_size(pointer_delta(end, obj, sizeof(oop*))) duke@435: == oop_size(obj), "checking size"); duke@435: duke@435: // Iterate over oops duke@435: while (curr < end) { duke@435: if (PSScavenge::should_scavenge(*curr)) { duke@435: pm->claim_or_forward_depth(curr); duke@435: } duke@435: ++curr; duke@435: } duke@435: } duke@435: duke@435: int objArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { duke@435: assert (obj->is_objArray(), "obj must be obj array"); duke@435: objArrayOop a = objArrayOop(obj); duke@435: duke@435: oop* const base = a->base(); duke@435: oop* const beg_oop = base; duke@435: oop* const end_oop = base + a->length(); duke@435: for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) { duke@435: PSParallelCompact::adjust_pointer(cur_oop); duke@435: } duke@435: return a->object_size(); duke@435: } duke@435: duke@435: int objArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj, duke@435: HeapWord* beg_addr, HeapWord* end_addr) { duke@435: assert (obj->is_objArray(), "obj must be obj array"); duke@435: objArrayOop a = objArrayOop(obj); duke@435: duke@435: oop* const base = a->base(); duke@435: oop* const beg_oop = MAX2((oop*)beg_addr, base); duke@435: oop* const end_oop = MIN2((oop*)end_addr, base + a->length()); duke@435: for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) { duke@435: PSParallelCompact::adjust_pointer(cur_oop); duke@435: } duke@435: return a->object_size(); duke@435: } duke@435: #endif // SERIALGC duke@435: duke@435: // JVM support duke@435: duke@435: jint objArrayKlass::compute_modifier_flags(TRAPS) const { duke@435: // The modifier for an objectArray is the same as its element duke@435: if (element_klass() == NULL) { duke@435: assert(Universe::is_bootstrapping(), "partial objArray only at startup"); duke@435: return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; duke@435: } duke@435: // Recurse down the element list duke@435: jint element_flags = Klass::cast(element_klass())->compute_modifier_flags(CHECK_0); duke@435: duke@435: return (element_flags & (JVM_ACC_PUBLIC | JVM_ACC_PRIVATE | JVM_ACC_PROTECTED)) duke@435: | (JVM_ACC_ABSTRACT | JVM_ACC_FINAL); duke@435: } duke@435: duke@435: duke@435: #ifndef PRODUCT duke@435: // Printing duke@435: duke@435: void objArrayKlass::oop_print_on(oop obj, outputStream* st) { duke@435: arrayKlass::oop_print_on(obj, st); duke@435: assert(obj->is_objArray(), "must be objArray"); duke@435: objArrayOop oa = objArrayOop(obj); duke@435: int print_len = MIN2((intx) oa->length(), MaxElementPrintSize); duke@435: for(int index = 0; index < print_len; index++) { duke@435: st->print(" - %3d : ", index); duke@435: oa->obj_at(index)->print_value_on(st); duke@435: st->cr(); duke@435: } duke@435: int remaining = oa->length() - print_len; duke@435: if (remaining > 0) { duke@435: tty->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining); duke@435: } duke@435: } duke@435: duke@435: duke@435: void objArrayKlass::oop_print_value_on(oop obj, outputStream* st) { duke@435: assert(obj->is_objArray(), "must be objArray"); duke@435: element_klass()->print_value_on(st); duke@435: st->print("a [%d] ", objArrayOop(obj)->length()); duke@435: as_klassOop()->klass()->print_value_on(st); duke@435: } duke@435: duke@435: #endif // PRODUCT duke@435: duke@435: const char* objArrayKlass::internal_name() const { duke@435: return external_name(); duke@435: } duke@435: duke@435: // Verification duke@435: duke@435: void objArrayKlass::oop_verify_on(oop obj, outputStream* st) { duke@435: arrayKlass::oop_verify_on(obj, st); duke@435: guarantee(obj->is_objArray(), "must be objArray"); duke@435: objArrayOop oa = objArrayOop(obj); duke@435: for(int index = 0; index < oa->length(); index++) { duke@435: guarantee(oa->obj_at(index)->is_oop_or_null(), "should be oop"); duke@435: } duke@435: } duke@435: duke@435: void objArrayKlass::oop_verify_old_oop(oop obj, oop* p, bool allow_dirty) { duke@435: /* $$$ move into remembered set verification? duke@435: RememberedSet::verify_old_oop(obj, p, allow_dirty, true); duke@435: */ duke@435: }