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

annotate src/share/vm/oops/objArrayKlass.cpp @ 13212:eb03a7335eb0

Use fixed instead of virtual register for target in far foreign call, since the register allocator does not support virtual registers to be used at call sites.

author	Christian Wimmer <christian.wimmer@oracle.com>
date	Mon, 02 Dec 2013 14:20:32 -0800
parents	e0c9a1d29eb4
children	55a0da3d420b

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
5935 a735aec54ea4 7123170: JCK vm/jvmti/ResourceExhausted/resexh001/resexh00101/ tests fails since 7u4 b02 sspitsyn parents: 2227 diff changeset	2 * Copyright (c) 1997, 2012, 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"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	26 #include "classfile/symbolTable.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	27 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	28 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	29 #include "gc_implementation/shared/markSweep.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	30 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	31 #include "memory/genOopClosures.inline.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	32 #include "memory/metadataFactory.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	33 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	34 #include "memory/universe.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	35 #include "oops/instanceKlass.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	36 #include "oops/klass.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	37 #include "oops/objArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	38 #include "oops/objArrayKlass.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	39 #include "oops/objArrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	40 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	41 #include "oops/oop.inline2.hpp"
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2119 diff changeset	42 #include "oops/symbol.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	43 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	44 #include "runtime/mutexLocker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	45 #include "utilities/copy.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7185 diff changeset	46 #include "utilities/macros.hpp"
db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7185 diff changeset	47 #if INCLUDE_ALL_GCS
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	48 #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	49 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	50 #include "gc_implementation/g1/g1OopClosures.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	51 #include "gc_implementation/g1/g1RemSet.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	52 #include "gc_implementation/g1/heapRegionSeq.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	53 #include "gc_implementation/parNew/parOopClosures.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	54 #include "gc_implementation/parallelScavenge/psCompactionManager.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	55 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	56 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	57 #include "oops/oop.pcgc.inline.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7185 diff changeset	58 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	59
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	60 ObjArrayKlass* ObjArrayKlass::allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS) {
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	61 assert(ObjArrayKlass::header_size() <= InstanceKlass::header_size(),
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	62 "array klasses must be same size as InstanceKlass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	63
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	64 int size = ArrayKlass::static_size(ObjArrayKlass::header_size());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	65
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	66 return new (loader_data, size, THREAD) ObjArrayKlass(n, klass_handle, name);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	67 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	68
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	69 Klass* ObjArrayKlass::allocate_objArray_klass(ClassLoaderData* loader_data,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	70 int n, KlassHandle element_klass, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	71
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	72 // Eagerly allocate the direct array supertype.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	73 KlassHandle super_klass = KlassHandle();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	74 if (!Universe::is_bootstrapping() \|\| SystemDictionary::Object_klass_loaded()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	75 KlassHandle element_super (THREAD, element_klass->super());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	76 if (element_super.not_null()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	77 // The element type has a direct super. E.g., String[] has direct super of Object[].
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	78 super_klass = KlassHandle(THREAD, element_super->array_klass_or_null());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	79 bool supers_exist = super_klass.not_null();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	80 // Also, see if the element has secondary supertypes.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	81 // We need an array type for each.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	82 Array<Klass> element_supers = element_klass->secondary_supers();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	83 for( int i = element_supers->length()-1; i >= 0; i-- ) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	84 Klass* elem_super = element_supers->at(i);
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6840 diff changeset	85 if (elem_super->array_klass_or_null() == NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	86 supers_exist = false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	87 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	88 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	89 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	90 if (!supers_exist) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	91 // Oops. Not allocated yet. Back out, allocate it, and retry.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	92 KlassHandle ek;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	93 {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	94 MutexUnlocker mu(MultiArray_lock);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	95 MutexUnlocker mc(Compile_lock); // for vtables
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	96 Klass* sk = element_super->array_klass(CHECK_0);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	97 super_klass = KlassHandle(THREAD, sk);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	98 for( int i = element_supers->length()-1; i >= 0; i-- ) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	99 KlassHandle elem_super (THREAD, element_supers->at(i));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	100 elem_super->array_klass(CHECK_0);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	101 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	102 // Now retry from the beginning
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	103 Klass* klass_oop = element_klass->array_klass(n, CHECK_0);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	104 // Create a handle because the enclosing brace, when locking
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	105 // can cause a gc. Better to have this function return a Handle.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	106 ek = KlassHandle(THREAD, klass_oop);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	107 } // re-lock
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	108 return ek();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	109 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	110 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	111 // The element type is already Object. Object[] has direct super of Object.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	112 super_klass = KlassHandle(THREAD, SystemDictionary::Object_klass());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	113 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	114 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	115
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	116 // Create type name for klass.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	117 Symbol* name = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	118 if (!element_klass->oop_is_instance() \|\|
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	119 (name = InstanceKlass::cast(element_klass())->array_name()) == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	120
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	121 ResourceMark rm(THREAD);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	122 char *name_str = element_klass->name()->as_C_string();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	123 int len = element_klass->name()->utf8_length();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	124 char *new_str = NEW_RESOURCE_ARRAY(char, len + 4);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	125 int idx = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	126 new_str[idx++] = '[';
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	127 if (element_klass->oop_is_instance()) { // it could be an array or simple type
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	128 new_str[idx++] = 'L';
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	129 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	130 memcpy(&new_str[idx], name_str, len * sizeof(char));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	131 idx += len;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	132 if (element_klass->oop_is_instance()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	133 new_str[idx++] = ';';
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	134 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	135 new_str[idx++] = '\0';
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	136 name = SymbolTable::new_permanent_symbol(new_str, CHECK_0);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	137 if (element_klass->oop_is_instance()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	138 InstanceKlass* ik = InstanceKlass::cast(element_klass());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	139 ik->set_array_name(name);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	140 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	141 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	142
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	143 // Initialize instance variables
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	144 ObjArrayKlass* oak = ObjArrayKlass::allocate(loader_data, n, element_klass, name, CHECK_0);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	145
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	146 // Add all classes to our internal class loader list here,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	147 // including classes in the bootstrap (NULL) class loader.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	148 // GC walks these as strong roots.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	149 loader_data->add_class(oak);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	150
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	151 // Call complete_create_array_klass after all instance variables has been initialized.
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	152 ArrayKlass::complete_create_array_klass(oak, super_klass, CHECK_0);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	153
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	154 return oak;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	155 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	156
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	157 ObjArrayKlass::ObjArrayKlass(int n, KlassHandle element_klass, Symbol* name) : ArrayKlass(name) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	158 this->set_dimension(n);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	159 this->set_element_klass(element_klass());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	160 // decrement refcount because object arrays are not explicitly freed. The
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	161 // InstanceKlass array_name() keeps the name counted while the klass is
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	162 // loaded.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	163 name->decrement_refcount();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	164
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	165 Klass* bk;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	166 if (element_klass->oop_is_objArray()) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	167 bk = ObjArrayKlass::cast(element_klass())->bottom_klass();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	168 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	169 bk = element_klass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	170 }
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6840 diff changeset	171 assert(bk != NULL && (bk->oop_is_instance() \|\| bk->oop_is_typeArray()), "invalid bottom klass");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	172 this->set_bottom_klass(bk);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	173 this->set_class_loader_data(bk->class_loader_data());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	174
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	175 this->set_layout_helper(array_layout_helper(T_OBJECT));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	176 assert(this->oop_is_array(), "sanity");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	177 assert(this->oop_is_objArray(), "sanity");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	178 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	179
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	180 int ObjArrayKlass::oop_size(oop obj) const {
0 a61af66fc99e Initial load duke parents: diff changeset	181 assert(obj->is_objArray(), "must be object array");
a61af66fc99e Initial load duke parents: diff changeset	182 return objArrayOop(obj)->object_size();
a61af66fc99e Initial load duke parents: diff changeset	183 }
a61af66fc99e Initial load duke parents: diff changeset	184
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	185 objArrayOop ObjArrayKlass::allocate(int length, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	186 if (length >= 0) {
a61af66fc99e Initial load duke parents: diff changeset	187 if (length <= arrayOopDesc::max_array_length(T_OBJECT)) {
a61af66fc99e Initial load duke parents: diff changeset	188 int size = objArrayOopDesc::object_size(length);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	189 KlassHandle h_k(THREAD, this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	190 return (objArrayOop)CollectedHeap::array_allocate(h_k, size, length, CHECK_NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	191 } else {
876 1413494da700 6850957: Honor -XX:OnOutOfMemoryError when array size exceeds VM limit martin parents: 665 diff changeset	192 report_java_out_of_memory("Requested array size exceeds VM limit");
5935 a735aec54ea4 7123170: JCK vm/jvmti/ResourceExhausted/resexh001/resexh00101/ tests fails since 7u4 b02 sspitsyn parents: 2227 diff changeset	193 JvmtiExport::post_array_size_exhausted();
0 a61af66fc99e Initial load duke parents: diff changeset	194 THROW_OOP_0(Universe::out_of_memory_error_array_size());
a61af66fc99e Initial load duke parents: diff changeset	195 }
a61af66fc99e Initial load duke parents: diff changeset	196 } else {
a61af66fc99e Initial load duke parents: diff changeset	197 THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
a61af66fc99e Initial load duke parents: diff changeset	198 }
a61af66fc99e Initial load duke parents: diff changeset	199 }
a61af66fc99e Initial load duke parents: diff changeset	200
a61af66fc99e Initial load duke parents: diff changeset	201 static int multi_alloc_counter = 0;
a61af66fc99e Initial load duke parents: diff changeset	202
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	203 oop ObjArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	204 int length = *sizes;
a61af66fc99e Initial load duke parents: diff changeset	205 // Call to lower_dimension uses this pointer, so most be called before a
a61af66fc99e Initial load duke parents: diff changeset	206 // possible GC
a61af66fc99e Initial load duke parents: diff changeset	207 KlassHandle h_lower_dimension(THREAD, lower_dimension());
a61af66fc99e Initial load duke parents: diff changeset	208 // If length < 0 allocate will throw an exception.
a61af66fc99e Initial load duke parents: diff changeset	209 objArrayOop array = allocate(length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	210 objArrayHandle h_array (THREAD, array);
a61af66fc99e Initial load duke parents: diff changeset	211 if (rank > 1) {
a61af66fc99e Initial load duke parents: diff changeset	212 if (length != 0) {
a61af66fc99e Initial load duke parents: diff changeset	213 for (int index = 0; index < length; index++) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	214 ArrayKlass* ak = ArrayKlass::cast(h_lower_dimension());
0 a61af66fc99e Initial load duke parents: diff changeset	215 oop sub_array = ak->multi_allocate(rank-1, &sizes[1], CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	216 h_array->obj_at_put(index, sub_array);
a61af66fc99e Initial load duke parents: diff changeset	217 }
a61af66fc99e Initial load duke parents: diff changeset	218 } else {
a61af66fc99e Initial load duke parents: diff changeset	219 // Since this array dimension has zero length, nothing will be
a61af66fc99e Initial load duke parents: diff changeset	220 // allocated, however the lower dimension values must be checked
a61af66fc99e Initial load duke parents: diff changeset	221 // for illegal values.
a61af66fc99e Initial load duke parents: diff changeset	222 for (int i = 0; i < rank - 1; ++i) {
a61af66fc99e Initial load duke parents: diff changeset	223 sizes += 1;
a61af66fc99e Initial load duke parents: diff changeset	224 if (*sizes < 0) {
a61af66fc99e Initial load duke parents: diff changeset	225 THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
a61af66fc99e Initial load duke parents: diff changeset	226 }
a61af66fc99e Initial load duke parents: diff changeset	227 }
a61af66fc99e Initial load duke parents: diff changeset	228 }
a61af66fc99e Initial load duke parents: diff changeset	229 }
a61af66fc99e Initial load duke parents: diff changeset	230 return h_array();
a61af66fc99e Initial load duke parents: diff changeset	231 }
a61af66fc99e Initial load duke parents: diff changeset	232
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	233 // Either oop or narrowOop depending on UseCompressedOops.
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	234 template <class T> void ObjArrayKlass::do_copy(arrayOop s, T* src,
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	235 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	236
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	237 BarrierSet* bs = Universe::heap()->barrier_set();
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	238 // 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	239 // 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	240 // 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	241 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	242 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	243
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	244 if (s == d) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	245 // 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	246 assert(length > 0, "sanity check");
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 665 diff changeset	247 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	248 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	249 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	250 // We have to make sure all elements conform to the destination array
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	251 Klass* bound = ObjArrayKlass::cast(d->klass())->element_klass();
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	252 Klass* stype = ObjArrayKlass::cast(s->klass())->element_klass();
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6840 diff changeset	253 if (stype == bound \|\| stype->is_subtype_of(bound)) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	254 // 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	255 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	256 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	257 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	258 // 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	259 // 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	260 T* from = src;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	261 T* end = from + length;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	262 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	263 // 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	264 T element = *from;
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	265 // even slower now
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	266 bool element_is_null = oopDesc::is_null(element);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	267 oop new_val = element_is_null ? oop(NULL)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	268 : oopDesc::decode_heap_oop_not_null(element);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	269 if (element_is_null \|\|
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6840 diff changeset	270 (new_val->klass())->is_subtype_of(bound)) {
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	271 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	272 p = from;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	273 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	274 // 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	275 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	276 // 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	277 // 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	278 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	279 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	280 THROW(vmSymbols::java_lang_ArrayStoreException());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	281 return;
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 }
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 }
1091 6aa7255741f3 6906727: UseCompressedOops: some card-marking fixes related to object arrays ysr parents: 879 diff changeset	286 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	287 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	288
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	289 void ObjArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d,
0 a61af66fc99e Initial load duke parents: diff changeset	290 int dst_pos, int length, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	291 assert(s->is_objArray(), "must be obj array");
a61af66fc99e Initial load duke parents: diff changeset	292
a61af66fc99e Initial load duke parents: diff changeset	293 if (!d->is_objArray()) {
a61af66fc99e Initial load duke parents: diff changeset	294 THROW(vmSymbols::java_lang_ArrayStoreException());
a61af66fc99e Initial load duke parents: diff changeset	295 }
a61af66fc99e Initial load duke parents: diff changeset	296
a61af66fc99e Initial load duke parents: diff changeset	297 // Check is all offsets and lengths are non negative
a61af66fc99e Initial load duke parents: diff changeset	298 if (src_pos < 0 \|\| dst_pos < 0 \|\| length < 0) {
a61af66fc99e Initial load duke parents: diff changeset	299 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
a61af66fc99e Initial load duke parents: diff changeset	300 }
a61af66fc99e Initial load duke parents: diff changeset	301 // Check if the ranges are valid
a61af66fc99e Initial load duke parents: diff changeset	302 if ( (((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length())
a61af66fc99e Initial load duke parents: diff changeset	303 \|\| (((unsigned int) length + (unsigned int) dst_pos) > (unsigned int) d->length()) ) {
a61af66fc99e Initial load duke parents: diff changeset	304 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
a61af66fc99e Initial load duke parents: diff changeset	305 }
a61af66fc99e Initial load duke parents: diff changeset	306
a61af66fc99e Initial load duke parents: diff changeset	307 // Special case. Boundary cases must be checked first
a61af66fc99e Initial load duke parents: diff changeset	308 // This allows the following call: copy_array(s, s.length(), d.length(), 0).
a61af66fc99e Initial load duke parents: diff changeset	309 // 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	310 // points to the right of the last element.
a61af66fc99e Initial load duke parents: diff changeset	311 if (length==0) {
a61af66fc99e Initial load duke parents: diff changeset	312 return;
a61af66fc99e Initial load duke parents: diff changeset	313 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	314 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	315 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	316 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	317 do_copy<narrowOop>(s, src, d, dst, length, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	318 } else {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	319 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	320 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	321 do_copy<oop> (s, src, d, dst, length, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	322 }
a61af66fc99e Initial load duke parents: diff changeset	323 }
a61af66fc99e Initial load duke parents: diff changeset	324
a61af66fc99e Initial load duke parents: diff changeset	325
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	326 Klass* ObjArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	327
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	328 assert(dimension() <= n, "check order of chain");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	329 int dim = dimension();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	330 if (dim == n) return this;
0 a61af66fc99e Initial load duke parents: diff changeset	331
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	332 if (higher_dimension() == NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	333 if (or_null) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	334
a61af66fc99e Initial load duke parents: diff changeset	335 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	336 JavaThread jt = (JavaThread )THREAD;
a61af66fc99e Initial load duke parents: diff changeset	337 {
a61af66fc99e Initial load duke parents: diff changeset	338 MutexLocker mc(Compile_lock, THREAD); // for vtables
a61af66fc99e Initial load duke parents: diff changeset	339 // Ensure atomic creation of higher dimensions
a61af66fc99e Initial load duke parents: diff changeset	340 MutexLocker mu(MultiArray_lock, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	341
a61af66fc99e Initial load duke parents: diff changeset	342 // Check if another thread beat us
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	343 if (higher_dimension() == NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	344
a61af66fc99e Initial load duke parents: diff changeset	345 // Create multi-dim klass object and link them together
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	346 Klass* k =
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	347 ObjArrayKlass::allocate_objArray_klass(class_loader_data(), dim + 1, this, CHECK_NULL);
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	348 ObjArrayKlass* ak = ObjArrayKlass::cast(k);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	349 ak->set_lower_dimension(this);
2119 d4fca0a6abde 7011386: race in objArrayKlass::array_klass_impl kvn parents: 1972 diff changeset	350 OrderAccess::storestore();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	351 set_higher_dimension(ak);
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	352 assert(ak->oop_is_objArray(), "incorrect initialization of ObjArrayKlass");
0 a61af66fc99e Initial load duke parents: diff changeset	353 }
a61af66fc99e Initial load duke parents: diff changeset	354 }
a61af66fc99e Initial load duke parents: diff changeset	355 } else {
a61af66fc99e Initial load duke parents: diff changeset	356 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
a61af66fc99e Initial load duke parents: diff changeset	357 }
a61af66fc99e Initial load duke parents: diff changeset	358
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	359 ObjArrayKlass *ak = ObjArrayKlass::cast(higher_dimension());
0 a61af66fc99e Initial load duke parents: diff changeset	360 if (or_null) {
a61af66fc99e Initial load duke parents: diff changeset	361 return ak->array_klass_or_null(n);
a61af66fc99e Initial load duke parents: diff changeset	362 }
a61af66fc99e Initial load duke parents: diff changeset	363 return ak->array_klass(n, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	364 }
a61af66fc99e Initial load duke parents: diff changeset	365
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	366 Klass* ObjArrayKlass::array_klass_impl(bool or_null, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	367 return array_klass_impl(or_null, dimension() + 1, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	368 }
a61af66fc99e Initial load duke parents: diff changeset	369
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	370 bool ObjArrayKlass::can_be_primary_super_slow() const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	371 if (!bottom_klass()->can_be_primary_super())
0 a61af66fc99e Initial load duke parents: diff changeset	372 // array of interfaces
a61af66fc99e Initial load duke parents: diff changeset	373 return false;
a61af66fc99e Initial load duke parents: diff changeset	374 else
a61af66fc99e Initial load duke parents: diff changeset	375 return Klass::can_be_primary_super_slow();
a61af66fc99e Initial load duke parents: diff changeset	376 }
a61af66fc99e Initial load duke parents: diff changeset	377
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	378 GrowableArray<Klass> ObjArrayKlass::compute_secondary_supers(int num_extra_slots) {
0 a61af66fc99e Initial load duke parents: diff changeset	379 // interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... };
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6840 diff changeset	380 Array<Klass> elem_supers = element_klass()->secondary_supers();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	381 int num_elem_supers = elem_supers == NULL ? 0 : elem_supers->length();
0 a61af66fc99e Initial load duke parents: diff changeset	382 int num_secondaries = num_extra_slots + 2 + num_elem_supers;
a61af66fc99e Initial load duke parents: diff changeset	383 if (num_secondaries == 2) {
a61af66fc99e Initial load duke parents: diff changeset	384 // Must share this for correct bootstrapping!
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	385 set_secondary_supers(Universe::the_array_interfaces_array());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	386 return NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	387 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	388 GrowableArray<Klass> secondaries = new GrowableArray<Klass*>(num_elem_supers+2);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	389 secondaries->push(SystemDictionary::Cloneable_klass());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	390 secondaries->push(SystemDictionary::Serializable_klass());
0 a61af66fc99e Initial load duke parents: diff changeset	391 for (int i = 0; i < num_elem_supers; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	392 Klass* elem_super = (Klass*) elem_supers->at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	393 Klass* array_super = elem_super->array_klass_or_null();
0 a61af66fc99e Initial load duke parents: diff changeset	394 assert(array_super != NULL, "must already have been created");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	395 secondaries->push(array_super);
0 a61af66fc99e Initial load duke parents: diff changeset	396 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	397 return secondaries;
0 a61af66fc99e Initial load duke parents: diff changeset	398 }
a61af66fc99e Initial load duke parents: diff changeset	399 }
a61af66fc99e Initial load duke parents: diff changeset	400
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	401 bool ObjArrayKlass::compute_is_subtype_of(Klass* k) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	402 if (!k->oop_is_objArray())
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	403 return ArrayKlass::compute_is_subtype_of(k);
0 a61af66fc99e Initial load duke parents: diff changeset	404
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	405 ObjArrayKlass* oak = ObjArrayKlass::cast(k);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	406 return element_klass()->is_subtype_of(oak->element_klass());
0 a61af66fc99e Initial load duke parents: diff changeset	407 }
a61af66fc99e Initial load duke parents: diff changeset	408
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	409 void ObjArrayKlass::initialize(TRAPS) {
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6840 diff changeset	410 bottom_klass()->initialize(THREAD); // dispatches to either InstanceKlass or TypeArrayKlass
0 a61af66fc99e Initial load duke parents: diff changeset	411 }
a61af66fc99e Initial load duke parents: diff changeset	412
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	413 #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	414 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	415 T* p = (T*)(a)->base(); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	416 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	417 while (p < end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	418 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	419 p++; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	420 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	421 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	422
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	423 #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	424 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	425 T* const l = (T*)(low); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	426 T* const h = (T*)(high); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	427 T* p = (T*)(a)->base(); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	428 T* end = p + (a)->length(); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	429 if (p < l) p = l; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	430 if (end > h) end = h; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	431 while (p < end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	432 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	433 ++p; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	434 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	435 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	436
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	437 #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	438 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	439 ObjArrayKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	440 a, p, do_oop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	441 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	442 ObjArrayKlass_SPECIALIZED_OOP_ITERATE(oop, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	443 a, p, do_oop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	444 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	445
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	446 #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	447 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	448 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	449 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	450 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	451 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	452 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	453 }
0 a61af66fc99e Initial load duke parents: diff changeset	454
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	455 void ObjArrayKlass::oop_follow_contents(oop obj) {
0 a61af66fc99e Initial load duke parents: diff changeset	456 assert (obj->is_array(), "obj must be array");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	457 MarkSweep::follow_klass(obj->klass());
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	458 if (UseCompressedOops) {
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	459 objarray_follow_contents<narrowOop>(obj, 0);
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	460 } else {
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	461 objarray_follow_contents<oop>(obj, 0);
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	462 }
0 a61af66fc99e Initial load duke parents: diff changeset	463 }
a61af66fc99e Initial load duke parents: diff changeset	464
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7185 diff changeset	465 #if INCLUDE_ALL_GCS
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	466 void ObjArrayKlass::oop_follow_contents(ParCompactionManager* cm,
0 a61af66fc99e Initial load duke parents: diff changeset	467 oop obj) {
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	468 assert(obj->is_array(), "obj must be array");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	469 PSParallelCompact::follow_klass(cm, obj->klass());
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	470 if (UseCompressedOops) {
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	471 objarray_follow_contents<narrowOop>(cm, obj, 0);
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	472 } else {
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	473 objarray_follow_contents<oop>(cm, obj, 0);
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1155 diff changeset	474 }
0 a61af66fc99e Initial load duke parents: diff changeset	475 }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7185 diff changeset	476 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	477
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	478 #define if_do_metadata_checked(closure, nv_suffix) \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	479 /* Make sure the non-virtual and the virtual versions match. */ \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	480 assert(closure->do_metadata##nv_suffix() == closure->do_metadata(), \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	481 "Inconsistency in do_metadata"); \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	482 if (closure->do_metadata##nv_suffix())
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	483
0 a61af66fc99e Initial load duke parents: diff changeset	484 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
a61af66fc99e Initial load duke parents: diff changeset	485 \
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	486 int ObjArrayKlass::oop_oop_iterate##nv_suffix(oop obj, \
0 a61af66fc99e Initial load duke parents: diff changeset	487 OopClosureType* closure) { \
a61af66fc99e Initial load duke parents: diff changeset	488 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
a61af66fc99e Initial load duke parents: diff changeset	489 assert (obj->is_array(), "obj must be array"); \
a61af66fc99e Initial load duke parents: diff changeset	490 objArrayOop a = objArrayOop(obj); \
a61af66fc99e Initial load duke parents: diff changeset	491 /* Get size before changing pointers. */ \
a61af66fc99e Initial load duke parents: diff changeset	492 /* Don't call size() or oop_size() since that is a virtual call. */ \
a61af66fc99e Initial load duke parents: diff changeset	493 int size = a->object_size(); \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	494 if_do_metadata_checked(closure, nv_suffix) { \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	495 closure->do_klass##nv_suffix(obj->klass()); \
0 a61af66fc99e Initial load duke parents: diff changeset	496 } \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	497 ObjArrayKlass_OOP_ITERATE(a, p, (closure)->do_oop##nv_suffix(p)) \
0 a61af66fc99e Initial load duke parents: diff changeset	498 return size; \
a61af66fc99e Initial load duke parents: diff changeset	499 }
a61af66fc99e Initial load duke parents: diff changeset	500
a61af66fc99e Initial load duke parents: diff changeset	501 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \
a61af66fc99e Initial load duke parents: diff changeset	502 \
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	503 int ObjArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \
0 a61af66fc99e Initial load duke parents: diff changeset	504 OopClosureType* closure, \
a61af66fc99e Initial load duke parents: diff changeset	505 MemRegion mr) { \
a61af66fc99e Initial load duke parents: diff changeset	506 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
a61af66fc99e Initial load duke parents: diff changeset	507 assert(obj->is_array(), "obj must be array"); \
a61af66fc99e Initial load duke parents: diff changeset	508 objArrayOop a = objArrayOop(obj); \
a61af66fc99e Initial load duke parents: diff changeset	509 /* Get size before changing pointers. */ \
a61af66fc99e Initial load duke parents: diff changeset	510 /* Don't call size() or oop_size() since that is a virtual call */ \
a61af66fc99e Initial load duke parents: diff changeset	511 int size = a->object_size(); \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	512 if_do_metadata_checked(closure, nv_suffix) { \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	513 /* SSS: Do we need to pass down mr here? */ \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	514 closure->do_klass##nv_suffix(a->klass()); \
0 a61af66fc99e Initial load duke parents: diff changeset	515 } \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	516 ObjArrayKlass_BOUNDED_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	517 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	518 return size; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	519 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	520
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	521 // 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	522 // for objArrayOops.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	523 #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	524 \
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	525 int ObjArrayKlass::oop_oop_iterate_range##nv_suffix(oop obj, \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	526 OopClosureType* closure, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	527 int start, int end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	528 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	529 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	530 objArrayOop a = objArrayOop(obj); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	531 /* Get size before changing pointers. */ \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	532 /* 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	533 int size = a->object_size(); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	534 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	535 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	536 /* 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	537 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	538 MemRegion mr(low, high); \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	539 if_do_metadata_checked(closure, nv_suffix) { \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	540 /* SSS: Do we need to pass down mr here? */ \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	541 closure->do_klass##nv_suffix(a->klass()); \
0 a61af66fc99e Initial load duke parents: diff changeset	542 } \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	543 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	544 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \
0 a61af66fc99e Initial load duke parents: diff changeset	545 } else { \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	546 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	547 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	548 MemRegion mr(low, high); \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	549 if_do_metadata_checked(closure, nv_suffix) { \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	550 /* SSS: Do we need to pass down mr here? */ \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	551 closure->do_klass##nv_suffix(a->klass()); \
0 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 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	554 a, p, low, high, (closure)->do_oop##nv_suffix(p)) \
0 a61af66fc99e Initial load duke parents: diff changeset	555 } \
a61af66fc99e Initial load duke parents: diff changeset	556 return size; \
a61af66fc99e Initial load duke parents: diff changeset	557 }
a61af66fc99e Initial load duke parents: diff changeset	558
a61af66fc99e Initial load duke parents: diff changeset	559 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	560 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN)
0 a61af66fc99e Initial load duke parents: diff changeset	561 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	562 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	563 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	564 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r)
0 a61af66fc99e Initial load duke parents: diff changeset	565
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	566 int ObjArrayKlass::oop_adjust_pointers(oop obj) {
0 a61af66fc99e Initial load duke parents: diff changeset	567 assert(obj->is_objArray(), "obj must be obj array");
a61af66fc99e Initial load duke parents: diff changeset	568 objArrayOop a = objArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	569 // Get size before changing pointers.
a61af66fc99e Initial load duke parents: diff changeset	570 // Don't call size() or oop_size() since that is a virtual call.
a61af66fc99e Initial load duke parents: diff changeset	571 int size = a->object_size();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	572 MarkSweep::adjust_klass(a->klass());
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	573 ObjArrayKlass_OOP_ITERATE(a, p, MarkSweep::adjust_pointer(p))
0 a61af66fc99e Initial load duke parents: diff changeset	574 return size;
a61af66fc99e Initial load duke parents: diff changeset	575 }
a61af66fc99e Initial load duke parents: diff changeset	576
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7185 diff changeset	577 #if INCLUDE_ALL_GCS
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	578 void ObjArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
0 a61af66fc99e Initial load duke parents: diff changeset	579 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	580 ObjArrayKlass_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	581 objArrayOop(obj), p, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	582 if (PSScavenge::should_scavenge(p)) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	583 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	584 })
0 a61af66fc99e Initial load duke parents: diff changeset	585 }
a61af66fc99e Initial load duke parents: diff changeset	586
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	587 int ObjArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
0 a61af66fc99e Initial load duke parents: diff changeset	588 assert (obj->is_objArray(), "obj must be obj array");
a61af66fc99e Initial load duke parents: diff changeset	589 objArrayOop a = objArrayOop(obj);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	590 int size = a->object_size();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	591 a->update_header(cm);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	592 ObjArrayKlass_OOP_ITERATE(a, p, PSParallelCompact::adjust_pointer(p))
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	593 return size;
0 a61af66fc99e Initial load duke parents: diff changeset	594 }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7185 diff changeset	595 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	596
a61af66fc99e Initial load duke parents: diff changeset	597 // JVM support
a61af66fc99e Initial load duke parents: diff changeset	598
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	599 jint ObjArrayKlass::compute_modifier_flags(TRAPS) const {
0 a61af66fc99e Initial load duke parents: diff changeset	600 // The modifier for an objectArray is the same as its element
a61af66fc99e Initial load duke parents: diff changeset	601 if (element_klass() == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	602 assert(Universe::is_bootstrapping(), "partial objArray only at startup");
a61af66fc99e Initial load duke parents: diff changeset	603 return JVM_ACC_ABSTRACT \| JVM_ACC_FINAL \| JVM_ACC_PUBLIC;
a61af66fc99e Initial load duke parents: diff changeset	604 }
398 443791f333a2 6700107: java/lang/Class/forName/TooManyDimensions.java crashes with SIGSEGV in c2 compiler with fastdebug coleenp parents: 356 diff changeset	605 // Return the flags of the bottom element type.
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6840 diff changeset	606 jint element_flags = bottom_klass()->compute_modifier_flags(CHECK_0);
0 a61af66fc99e Initial load duke parents: diff changeset	607
a61af66fc99e Initial load duke parents: diff changeset	608 return (element_flags & (JVM_ACC_PUBLIC \| JVM_ACC_PRIVATE \| JVM_ACC_PROTECTED))
a61af66fc99e Initial load duke parents: diff changeset	609 \| (JVM_ACC_ABSTRACT \| JVM_ACC_FINAL);
a61af66fc99e Initial load duke parents: diff changeset	610 }
a61af66fc99e Initial load duke parents: diff changeset	611
a61af66fc99e Initial load duke parents: diff changeset	612
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	613 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	614
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	615 void ObjArrayKlass::print_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	616 #ifndef PRODUCT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	617 Klass::print_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	618 st->print(" - instance klass: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	619 element_klass()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	620 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	621 #endif //PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	622 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	623
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	624 void ObjArrayKlass::print_value_on(outputStream* st) const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	625 assert(is_klass(), "must be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	626
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	627 element_klass()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	628 st->print("[]");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	629 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	630
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	631 #ifndef PRODUCT
0 a61af66fc99e Initial load duke parents: diff changeset	632
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	633 void ObjArrayKlass::oop_print_on(oop obj, outputStream* st) {
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	634 ArrayKlass::oop_print_on(obj, st);
0 a61af66fc99e Initial load duke parents: diff changeset	635 assert(obj->is_objArray(), "must be objArray");
a61af66fc99e Initial load duke parents: diff changeset	636 objArrayOop oa = objArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	637 int print_len = MIN2((intx) oa->length(), MaxElementPrintSize);
a61af66fc99e Initial load duke parents: diff changeset	638 for(int index = 0; index < print_len; index++) {
a61af66fc99e Initial load duke parents: diff changeset	639 st->print(" - %3d : ", index);
a61af66fc99e Initial load duke parents: diff changeset	640 oa->obj_at(index)->print_value_on(st);
a61af66fc99e Initial load duke parents: diff changeset	641 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	642 }
a61af66fc99e Initial load duke parents: diff changeset	643 int remaining = oa->length() - print_len;
a61af66fc99e Initial load duke parents: diff changeset	644 if (remaining > 0) {
6815 86af3dacab81 8000227: [obj\|type]ArrayKlass::oop_print_on prints one line to tty instead of the provided output stream stefank parents: 6725 diff changeset	645 st->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining);
0 a61af66fc99e Initial load duke parents: diff changeset	646 }
a61af66fc99e Initial load duke parents: diff changeset	647 }
a61af66fc99e Initial load duke parents: diff changeset	648
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1142 diff changeset	649 #endif //PRODUCT
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1142 diff changeset	650
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	651 static int max_objArray_print_length = 4;
0 a61af66fc99e Initial load duke parents: diff changeset	652
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	653 void ObjArrayKlass::oop_print_value_on(oop obj, outputStream* st) {
0 a61af66fc99e Initial load duke parents: diff changeset	654 assert(obj->is_objArray(), "must be objArray");
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	655 st->print("a ");
0 a61af66fc99e Initial load duke parents: diff changeset	656 element_klass()->print_value_on(st);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	657 int len = objArrayOop(obj)->length();
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	658 st->print("[%d] ", len);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	659 obj->print_address_on(st);
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1142 diff changeset	660 if (NOT_PRODUCT(PrintOopAddress \|\|) PrintMiscellaneous && (WizardMode \|\| Verbose)) {
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	661 st->print("{");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	662 for (int i = 0; i < len; i++) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	663 if (i > max_objArray_print_length) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	664 st->print("..."); break;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	665 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	666 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	667 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	668 st->print(" }");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 398 diff changeset	669 }
0 a61af66fc99e Initial load duke parents: diff changeset	670 }
a61af66fc99e Initial load duke parents: diff changeset	671
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	672 const char* ObjArrayKlass::internal_name() const {
0 a61af66fc99e Initial load duke parents: diff changeset	673 return external_name();
a61af66fc99e Initial load duke parents: diff changeset	674 }
a61af66fc99e Initial load duke parents: diff changeset	675
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	676
0 a61af66fc99e Initial load duke parents: diff changeset	677 // Verification
a61af66fc99e Initial load duke parents: diff changeset	678
11034 e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 8001 diff changeset	679 void ObjArrayKlass::verify_on(outputStream* st, bool check_dictionary) {
e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 8001 diff changeset	680 ArrayKlass::verify_on(st, check_dictionary);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	681 guarantee(element_klass()->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	682 guarantee(bottom_klass()->is_klass(), "should be klass");
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6840 diff changeset	683 Klass* bk = bottom_klass();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	684 guarantee(bk->oop_is_instance() \|\| bk->oop_is_typeArray(), "invalid bottom klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	685 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	686
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	687 void ObjArrayKlass::oop_verify_on(oop obj, outputStream* st) {
d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	688 ArrayKlass::oop_verify_on(obj, st);
0 a61af66fc99e Initial load duke parents: diff changeset	689 guarantee(obj->is_objArray(), "must be objArray");
a61af66fc99e Initial load duke parents: diff changeset	690 objArrayOop oa = objArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	691 for(int index = 0; index < oa->length(); index++) {
a61af66fc99e Initial load duke parents: diff changeset	692 guarantee(oa->obj_at(index)->is_oop_or_null(), "should be oop");
a61af66fc99e Initial load duke parents: diff changeset	693 }
a61af66fc99e Initial load duke parents: diff changeset	694 }

Mercurial > hg > truffle

annotate src/share/vm/oops/objArrayKlass.cpp @ 13212:eb03a7335eb0