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

annotate src/share/vm/oops/typeArrayKlass.cpp @ 6862:8a5ea0a9ccc4

7127708: G1: change task num types from int to uint in concurrent mark Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich. Reviewed-by: johnc Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>

author	johnc
date	Sat, 06 Oct 2012 01:17:44 -0700
parents	86af3dacab81
children	6e5a59a8e4a7

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: 3961 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: 1334 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1334 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: 1334 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: 5979 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_interface/collectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	30 #include "gc_interface/collectedHeap.inline.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	31 #include "memory/metadataFactory.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	32 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	33 #include "memory/universe.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: 5979 diff changeset	36 #include "oops/klass.inline.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	37 #include "oops/objArrayKlass.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	38 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	39 #include "oops/typeArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	40 #include "oops/typeArrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	41 #include "runtime/handles.inline.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	42
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	43 bool typeArrayKlass::compute_is_subtype_of(Klass* k) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	44 if (!k->oop_is_typeArray()) {
0 a61af66fc99e Initial load duke parents: diff changeset	45 return arrayKlass::compute_is_subtype_of(k);
a61af66fc99e Initial load duke parents: diff changeset	46 }
a61af66fc99e Initial load duke parents: diff changeset	47
a61af66fc99e Initial load duke parents: diff changeset	48 typeArrayKlass* tak = typeArrayKlass::cast(k);
a61af66fc99e Initial load duke parents: diff changeset	49 if (dimension() != tak->dimension()) return false;
a61af66fc99e Initial load duke parents: diff changeset	50
a61af66fc99e Initial load duke parents: diff changeset	51 return element_type() == tak->element_type();
a61af66fc99e Initial load duke parents: diff changeset	52 }
a61af66fc99e Initial load duke parents: diff changeset	53
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	54 typeArrayKlass* typeArrayKlass::create_klass(BasicType type,
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 0 diff changeset	55 const char* name_str, TRAPS) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2119 diff changeset	56 Symbol* sym = NULL;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2119 diff changeset	57 if (name_str != NULL) {
5979 fc9d8850ab8b 7150058: Allocate symbols from null boot loader to an arena for NMT coleenp parents: 5935 diff changeset	58 sym = SymbolTable::new_permanent_symbol(name_str, CHECK_NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	59 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	60
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	61 ClassLoaderData* null_loader_data = ClassLoaderData::the_null_class_loader_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	62
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	63 typeArrayKlass* ak = typeArrayKlass::allocate(null_loader_data, type, sym, CHECK_NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	64
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	65 // Add all classes to our internal class loader list here,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	66 // including classes in the bootstrap (NULL) class loader.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	67 // GC walks these as strong roots.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	68 null_loader_data->add_class(ak);
0 a61af66fc99e Initial load duke parents: diff changeset	69
a61af66fc99e Initial load duke parents: diff changeset	70 // Call complete_create_array_klass after all instance variables have been initialized.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	71 complete_create_array_klass(ak, ak->super(), CHECK_NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	72
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	73 return ak;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	74 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	75
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	76 typeArrayKlass* typeArrayKlass::allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	77 assert(typeArrayKlass::header_size() <= InstanceKlass::header_size(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	78 "array klasses must be same size as InstanceKlass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	79
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	80 int size = arrayKlass::static_size(typeArrayKlass::header_size());
0 a61af66fc99e Initial load duke parents: diff changeset	81
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	82 return new (loader_data, size, THREAD) typeArrayKlass(type, name);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	83 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	84
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	85 typeArrayKlass::typeArrayKlass(BasicType type, Symbol* name) : arrayKlass(name) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	86 set_layout_helper(array_layout_helper(type));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	87 assert(oop_is_array(), "sanity");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	88 assert(oop_is_typeArray(), "sanity");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	89
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	90 set_max_length(arrayOopDesc::max_array_length(type));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	91 assert(size() >= typeArrayKlass::header_size(), "bad size");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	92
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	93 set_class_loader_data(ClassLoaderData::the_null_class_loader_data());
0 a61af66fc99e Initial load duke parents: diff changeset	94 }
a61af66fc99e Initial load duke parents: diff changeset	95
3961 a92cdbac8b9e 7081933: Use zeroing elimination optimization for large array kvn parents: 3774 diff changeset	96 typeArrayOop typeArrayKlass::allocate_common(int length, bool do_zero, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	97 assert(log2_element_size() >= 0, "bad scale");
a61af66fc99e Initial load duke parents: diff changeset	98 if (length >= 0) {
a61af66fc99e Initial load duke parents: diff changeset	99 if (length <= max_length()) {
a61af66fc99e Initial load duke parents: diff changeset	100 size_t size = typeArrayOopDesc::object_size(layout_helper(), length);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	101 KlassHandle h_k(THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	102 typeArrayOop t;
a61af66fc99e Initial load duke parents: diff changeset	103 CollectedHeap* ch = Universe::heap();
3961 a92cdbac8b9e 7081933: Use zeroing elimination optimization for large array kvn parents: 3774 diff changeset	104 if (do_zero) {
a92cdbac8b9e 7081933: Use zeroing elimination optimization for large array kvn parents: 3774 diff changeset	105 t = (typeArrayOop)CollectedHeap::array_allocate(h_k, (int)size, length, CHECK_NULL);
a92cdbac8b9e 7081933: Use zeroing elimination optimization for large array kvn parents: 3774 diff changeset	106 } else {
a92cdbac8b9e 7081933: Use zeroing elimination optimization for large array kvn parents: 3774 diff changeset	107 t = (typeArrayOop)CollectedHeap::array_allocate_nozero(h_k, (int)size, length, CHECK_NULL);
a92cdbac8b9e 7081933: Use zeroing elimination optimization for large array kvn parents: 3774 diff changeset	108 }
0 a61af66fc99e Initial load duke parents: diff changeset	109 return t;
a61af66fc99e Initial load duke parents: diff changeset	110 } else {
876 1413494da700 6850957: Honor -XX:OnOutOfMemoryError when array size exceeds VM limit martin parents: 579 diff changeset	111 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: 3961 diff changeset	112 JvmtiExport::post_array_size_exhausted();
0 a61af66fc99e Initial load duke parents: diff changeset	113 THROW_OOP_0(Universe::out_of_memory_error_array_size());
a61af66fc99e Initial load duke parents: diff changeset	114 }
a61af66fc99e Initial load duke parents: diff changeset	115 } else {
a61af66fc99e Initial load duke parents: diff changeset	116 THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
a61af66fc99e Initial load duke parents: diff changeset	117 }
a61af66fc99e Initial load duke parents: diff changeset	118 }
a61af66fc99e Initial load duke parents: diff changeset	119
a61af66fc99e Initial load duke parents: diff changeset	120 oop typeArrayKlass::multi_allocate(int rank, jint* last_size, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	121 // For typeArrays this is only called for the last dimension
a61af66fc99e Initial load duke parents: diff changeset	122 assert(rank == 1, "just checking");
a61af66fc99e Initial load duke parents: diff changeset	123 int length = *last_size;
a61af66fc99e Initial load duke parents: diff changeset	124 return allocate(length, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	125 }
a61af66fc99e Initial load duke parents: diff changeset	126
a61af66fc99e Initial load duke parents: diff changeset	127
a61af66fc99e Initial load duke parents: diff changeset	128 void typeArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	129 assert(s->is_typeArray(), "must be type array");
a61af66fc99e Initial load duke parents: diff changeset	130
a61af66fc99e Initial load duke parents: diff changeset	131 // Check destination
a61af66fc99e Initial load duke parents: diff changeset	132 if (!d->is_typeArray() \|\| element_type() != typeArrayKlass::cast(d->klass())->element_type()) {
a61af66fc99e Initial load duke parents: diff changeset	133 THROW(vmSymbols::java_lang_ArrayStoreException());
a61af66fc99e Initial load duke parents: diff changeset	134 }
a61af66fc99e Initial load duke parents: diff changeset	135
a61af66fc99e Initial load duke parents: diff changeset	136 // Check is all offsets and lengths are non negative
a61af66fc99e Initial load duke parents: diff changeset	137 if (src_pos < 0 \|\| dst_pos < 0 \|\| length < 0) {
a61af66fc99e Initial load duke parents: diff changeset	138 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
a61af66fc99e Initial load duke parents: diff changeset	139 }
a61af66fc99e Initial load duke parents: diff changeset	140 // Check if the ranges are valid
a61af66fc99e Initial load duke parents: diff changeset	141 if ( (((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length())
a61af66fc99e Initial load duke parents: diff changeset	142 \|\| (((unsigned int) length + (unsigned int) dst_pos) > (unsigned int) d->length()) ) {
a61af66fc99e Initial load duke parents: diff changeset	143 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
a61af66fc99e Initial load duke parents: diff changeset	144 }
1334 b5d78a3b8843 6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes kvn parents: 876 diff changeset	145 // Check zero copy
b5d78a3b8843 6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes kvn parents: 876 diff changeset	146 if (length == 0)
b5d78a3b8843 6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes kvn parents: 876 diff changeset	147 return;
0 a61af66fc99e Initial load duke parents: diff changeset	148
a61af66fc99e Initial load duke parents: diff changeset	149 // This is an attempt to make the copy_array fast.
a61af66fc99e Initial load duke parents: diff changeset	150 int l2es = log2_element_size();
a61af66fc99e Initial load duke parents: diff changeset	151 int ihs = array_header_in_bytes() / wordSize;
1334 b5d78a3b8843 6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes kvn parents: 876 diff changeset	152 char* src = (char) ((oop)s + ihs) + ((size_t)src_pos << l2es);
b5d78a3b8843 6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes kvn parents: 876 diff changeset	153 char* dst = (char) ((oop)d + ihs) + ((size_t)dst_pos << l2es);
b5d78a3b8843 6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes kvn parents: 876 diff changeset	154 Copy::conjoint_memory_atomic(src, dst, (size_t)length << l2es);
0 a61af66fc99e Initial load duke parents: diff changeset	155 }
a61af66fc99e Initial load duke parents: diff changeset	156
a61af66fc99e Initial load duke parents: diff changeset	157
a61af66fc99e Initial load duke parents: diff changeset	158 // create a klass of array holding typeArrays
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	159 Klass* typeArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	160 int dim = dimension();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	161 assert(dim <= n, "check order of chain");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	162 if (dim == n)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	163 return this;
0 a61af66fc99e Initial load duke parents: diff changeset	164
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	165 if (higher_dimension() == NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	166 if (or_null) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	167
a61af66fc99e Initial load duke parents: diff changeset	168 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	169 JavaThread jt = (JavaThread )THREAD;
a61af66fc99e Initial load duke parents: diff changeset	170 {
a61af66fc99e Initial load duke parents: diff changeset	171 MutexLocker mc(Compile_lock, THREAD); // for vtables
a61af66fc99e Initial load duke parents: diff changeset	172 // Atomic create higher dimension and link into list
a61af66fc99e Initial load duke parents: diff changeset	173 MutexLocker mu(MultiArray_lock, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	174
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	175 if (higher_dimension() == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	176 Klass* oak = objArrayKlass::allocate_objArray_klass(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	177 class_loader_data(), dim + 1, this, CHECK_NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	178 objArrayKlass* h_ak = objArrayKlass::cast(oak);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	179 h_ak->set_lower_dimension(this);
2119 d4fca0a6abde 7011386: race in objArrayKlass::array_klass_impl kvn parents: 1972 diff changeset	180 OrderAccess::storestore();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	181 set_higher_dimension(h_ak);
0 a61af66fc99e Initial load duke parents: diff changeset	182 assert(h_ak->oop_is_objArray(), "incorrect initialization of objArrayKlass");
a61af66fc99e Initial load duke parents: diff changeset	183 }
a61af66fc99e Initial load duke parents: diff changeset	184 }
a61af66fc99e Initial load duke parents: diff changeset	185 } else {
a61af66fc99e Initial load duke parents: diff changeset	186 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
a61af66fc99e Initial load duke parents: diff changeset	187 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	188 objArrayKlass* h_ak = objArrayKlass::cast(higher_dimension());
0 a61af66fc99e Initial load duke parents: diff changeset	189 if (or_null) {
a61af66fc99e Initial load duke parents: diff changeset	190 return h_ak->array_klass_or_null(n);
a61af66fc99e Initial load duke parents: diff changeset	191 }
a61af66fc99e Initial load duke parents: diff changeset	192 return h_ak->array_klass(n, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	193 }
a61af66fc99e Initial load duke parents: diff changeset	194
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	195 Klass* typeArrayKlass::array_klass_impl(bool or_null, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	196 return array_klass_impl(or_null, dimension() + 1, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	197 }
a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 int typeArrayKlass::oop_size(oop obj) const {
a61af66fc99e Initial load duke parents: diff changeset	200 assert(obj->is_typeArray(),"must be a type array");
a61af66fc99e Initial load duke parents: diff changeset	201 typeArrayOop t = typeArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	202 return t->object_size();
a61af66fc99e Initial load duke parents: diff changeset	203 }
a61af66fc99e Initial load duke parents: diff changeset	204
a61af66fc99e Initial load duke parents: diff changeset	205 void typeArrayKlass::oop_follow_contents(oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	206 assert(obj->is_typeArray(),"must be a type array");
a61af66fc99e Initial load duke parents: diff changeset	207 // Performance tweak: We skip iterating over the klass pointer since we
a61af66fc99e Initial load duke parents: diff changeset	208 // know that Universe::typeArrayKlass never moves.
a61af66fc99e Initial load duke parents: diff changeset	209 }
a61af66fc99e Initial load duke parents: diff changeset	210
a61af66fc99e Initial load duke parents: diff changeset	211 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	212 void typeArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	213 assert(obj->is_typeArray(),"must be a type array");
a61af66fc99e Initial load duke parents: diff changeset	214 // Performance tweak: We skip iterating over the klass pointer since we
a61af66fc99e Initial load duke parents: diff changeset	215 // know that Universe::typeArrayKlass never moves.
a61af66fc99e Initial load duke parents: diff changeset	216 }
a61af66fc99e Initial load duke parents: diff changeset	217 #endif // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	218
a61af66fc99e Initial load duke parents: diff changeset	219 int typeArrayKlass::oop_adjust_pointers(oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	220 assert(obj->is_typeArray(),"must be a type array");
a61af66fc99e Initial load duke parents: diff changeset	221 typeArrayOop t = typeArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	222 // Performance tweak: We skip iterating over the klass pointer since we
a61af66fc99e Initial load duke parents: diff changeset	223 // know that Universe::typeArrayKlass never moves.
a61af66fc99e Initial load duke parents: diff changeset	224 return t->object_size();
a61af66fc99e Initial load duke parents: diff changeset	225 }
a61af66fc99e Initial load duke parents: diff changeset	226
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	227 int typeArrayKlass::oop_oop_iterate(oop obj, ExtendedOopClosure* blk) {
0 a61af66fc99e Initial load duke parents: diff changeset	228 assert(obj->is_typeArray(),"must be a type array");
a61af66fc99e Initial load duke parents: diff changeset	229 typeArrayOop t = typeArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	230 // Performance tweak: We skip iterating over the klass pointer since we
a61af66fc99e Initial load duke parents: diff changeset	231 // know that Universe::typeArrayKlass never moves.
a61af66fc99e Initial load duke parents: diff changeset	232 return t->object_size();
a61af66fc99e Initial load duke parents: diff changeset	233 }
a61af66fc99e Initial load duke parents: diff changeset	234
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	235 int typeArrayKlass::oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) {
0 a61af66fc99e Initial load duke parents: diff changeset	236 assert(obj->is_typeArray(),"must be a type array");
a61af66fc99e Initial load duke parents: diff changeset	237 typeArrayOop t = typeArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	238 // Performance tweak: We skip iterating over the klass pointer since we
a61af66fc99e Initial load duke parents: diff changeset	239 // know that Universe::typeArrayKlass never moves.
a61af66fc99e Initial load duke parents: diff changeset	240 return t->object_size();
a61af66fc99e Initial load duke parents: diff changeset	241 }
a61af66fc99e Initial load duke parents: diff changeset	242
a61af66fc99e Initial load duke parents: diff changeset	243 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	244 void typeArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	245 ShouldNotReachHere();
0 a61af66fc99e Initial load duke parents: diff changeset	246 assert(obj->is_typeArray(),"must be a type array");
a61af66fc99e Initial load duke parents: diff changeset	247 }
a61af66fc99e Initial load duke parents: diff changeset	248
a61af66fc99e Initial load duke parents: diff changeset	249 int
a61af66fc99e Initial load duke parents: diff changeset	250 typeArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	251 assert(obj->is_typeArray(),"must be a type array");
a61af66fc99e Initial load duke parents: diff changeset	252 return typeArrayOop(obj)->object_size();
a61af66fc99e Initial load duke parents: diff changeset	253 }
a61af66fc99e Initial load duke parents: diff changeset	254 #endif // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	255
a61af66fc99e Initial load duke parents: diff changeset	256 void typeArrayKlass::initialize(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	257 // Nothing to do. Having this function is handy since objArrayKlasses can be
a61af66fc99e Initial load duke parents: diff changeset	258 // initialized by calling initialize on their bottom_klass, see objArrayKlass::initialize
a61af66fc99e Initial load duke parents: diff changeset	259 }
a61af66fc99e Initial load duke parents: diff changeset	260
a61af66fc99e Initial load duke parents: diff changeset	261 const char* typeArrayKlass::external_name(BasicType type) {
a61af66fc99e Initial load duke parents: diff changeset	262 switch (type) {
a61af66fc99e Initial load duke parents: diff changeset	263 case T_BOOLEAN: return "[Z";
a61af66fc99e Initial load duke parents: diff changeset	264 case T_CHAR: return "[C";
a61af66fc99e Initial load duke parents: diff changeset	265 case T_FLOAT: return "[F";
a61af66fc99e Initial load duke parents: diff changeset	266 case T_DOUBLE: return "[D";
a61af66fc99e Initial load duke parents: diff changeset	267 case T_BYTE: return "[B";
a61af66fc99e Initial load duke parents: diff changeset	268 case T_SHORT: return "[S";
a61af66fc99e Initial load duke parents: diff changeset	269 case T_INT: return "[I";
a61af66fc99e Initial load duke parents: diff changeset	270 case T_LONG: return "[J";
a61af66fc99e Initial load duke parents: diff changeset	271 default: ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	272 }
a61af66fc99e Initial load duke parents: diff changeset	273 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	274 }
a61af66fc99e Initial load duke parents: diff changeset	275
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	276
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	277 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	278
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	279 void typeArrayKlass::print_on(outputStream* st) const {
0 a61af66fc99e Initial load duke parents: diff changeset	280 #ifndef PRODUCT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	281 assert(is_klass(), "must be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	282 print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	283 Klass::print_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	284 #endif //PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	285 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	286
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	287 void typeArrayKlass::print_value_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	288 assert(is_klass(), "must be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	289 st->print("{type array ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	290 switch (element_type()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	291 case T_BOOLEAN: st->print("bool"); break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	292 case T_CHAR: st->print("char"); break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	293 case T_FLOAT: st->print("float"); break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	294 case T_DOUBLE: st->print("double"); break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	295 case T_BYTE: st->print("byte"); break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	296 case T_SHORT: st->print("short"); break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	297 case T_INT: st->print("int"); break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	298 case T_LONG: st->print("long"); break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	299 default: ShouldNotReachHere();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	300 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	301 st->print("}");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	302 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	303
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 5979 diff changeset	304 #ifndef PRODUCT
0 a61af66fc99e Initial load duke parents: diff changeset	305
a61af66fc99e Initial load duke parents: diff changeset	306 static void print_boolean_array(typeArrayOop ta, int print_len, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	307 for (int index = 0; index < print_len; index++) {
a61af66fc99e Initial load duke parents: diff changeset	308 st->print_cr(" - %3d: %s", index, (ta->bool_at(index) == 0) ? "false" : "true");
a61af66fc99e Initial load duke parents: diff changeset	309 }
a61af66fc99e Initial load duke parents: diff changeset	310 }
a61af66fc99e Initial load duke parents: diff changeset	311
a61af66fc99e Initial load duke parents: diff changeset	312
a61af66fc99e Initial load duke parents: diff changeset	313 static void print_char_array(typeArrayOop ta, int print_len, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	314 for (int index = 0; index < print_len; index++) {
a61af66fc99e Initial load duke parents: diff changeset	315 jchar c = ta->char_at(index);
a61af66fc99e Initial load duke parents: diff changeset	316 st->print_cr(" - %3d: %x %c", index, c, isprint(c) ? c : ' ');
a61af66fc99e Initial load duke parents: diff changeset	317 }
a61af66fc99e Initial load duke parents: diff changeset	318 }
a61af66fc99e Initial load duke parents: diff changeset	319
a61af66fc99e Initial load duke parents: diff changeset	320
a61af66fc99e Initial load duke parents: diff changeset	321 static void print_float_array(typeArrayOop ta, int print_len, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	322 for (int index = 0; index < print_len; index++) {
a61af66fc99e Initial load duke parents: diff changeset	323 st->print_cr(" - %3d: %g", index, ta->float_at(index));
a61af66fc99e Initial load duke parents: diff changeset	324 }
a61af66fc99e Initial load duke parents: diff changeset	325 }
a61af66fc99e Initial load duke parents: diff changeset	326
a61af66fc99e Initial load duke parents: diff changeset	327
a61af66fc99e Initial load duke parents: diff changeset	328 static void print_double_array(typeArrayOop ta, int print_len, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	329 for (int index = 0; index < print_len; index++) {
a61af66fc99e Initial load duke parents: diff changeset	330 st->print_cr(" - %3d: %g", index, ta->double_at(index));
a61af66fc99e Initial load duke parents: diff changeset	331 }
a61af66fc99e Initial load duke parents: diff changeset	332 }
a61af66fc99e Initial load duke parents: diff changeset	333
a61af66fc99e Initial load duke parents: diff changeset	334
a61af66fc99e Initial load duke parents: diff changeset	335 static void print_byte_array(typeArrayOop ta, int print_len, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	336 for (int index = 0; index < print_len; index++) {
a61af66fc99e Initial load duke parents: diff changeset	337 jbyte c = ta->byte_at(index);
a61af66fc99e Initial load duke parents: diff changeset	338 st->print_cr(" - %3d: %x %c", index, c, isprint(c) ? c : ' ');
a61af66fc99e Initial load duke parents: diff changeset	339 }
a61af66fc99e Initial load duke parents: diff changeset	340 }
a61af66fc99e Initial load duke parents: diff changeset	341
a61af66fc99e Initial load duke parents: diff changeset	342
a61af66fc99e Initial load duke parents: diff changeset	343 static void print_short_array(typeArrayOop ta, int print_len, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	344 for (int index = 0; index < print_len; index++) {
a61af66fc99e Initial load duke parents: diff changeset	345 int v = ta->ushort_at(index);
a61af66fc99e Initial load duke parents: diff changeset	346 st->print_cr(" - %3d: 0x%x\t %d", index, v, v);
a61af66fc99e Initial load duke parents: diff changeset	347 }
a61af66fc99e Initial load duke parents: diff changeset	348 }
a61af66fc99e Initial load duke parents: diff changeset	349
a61af66fc99e Initial load duke parents: diff changeset	350
a61af66fc99e Initial load duke parents: diff changeset	351 static void print_int_array(typeArrayOop ta, int print_len, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	352 for (int index = 0; index < print_len; index++) {
a61af66fc99e Initial load duke parents: diff changeset	353 jint v = ta->int_at(index);
a61af66fc99e Initial load duke parents: diff changeset	354 st->print_cr(" - %3d: 0x%x %d", index, v, v);
a61af66fc99e Initial load duke parents: diff changeset	355 }
a61af66fc99e Initial load duke parents: diff changeset	356 }
a61af66fc99e Initial load duke parents: diff changeset	357
a61af66fc99e Initial load duke parents: diff changeset	358
a61af66fc99e Initial load duke parents: diff changeset	359 static void print_long_array(typeArrayOop ta, int print_len, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	360 for (int index = 0; index < print_len; index++) {
a61af66fc99e Initial load duke parents: diff changeset	361 jlong v = ta->long_at(index);
a61af66fc99e Initial load duke parents: diff changeset	362 st->print_cr(" - %3d: 0x%x 0x%x", index, high(v), low(v));
a61af66fc99e Initial load duke parents: diff changeset	363 }
a61af66fc99e Initial load duke parents: diff changeset	364 }
a61af66fc99e Initial load duke parents: diff changeset	365
a61af66fc99e Initial load duke parents: diff changeset	366
a61af66fc99e Initial load duke parents: diff changeset	367 void typeArrayKlass::oop_print_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	368 arrayKlass::oop_print_on(obj, st);
a61af66fc99e Initial load duke parents: diff changeset	369 typeArrayOop ta = typeArrayOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	370 int print_len = MIN2((intx) ta->length(), MaxElementPrintSize);
a61af66fc99e Initial load duke parents: diff changeset	371 switch (element_type()) {
a61af66fc99e Initial load duke parents: diff changeset	372 case T_BOOLEAN: print_boolean_array(ta, print_len, st); break;
a61af66fc99e Initial load duke parents: diff changeset	373 case T_CHAR: print_char_array(ta, print_len, st); break;
a61af66fc99e Initial load duke parents: diff changeset	374 case T_FLOAT: print_float_array(ta, print_len, st); break;
a61af66fc99e Initial load duke parents: diff changeset	375 case T_DOUBLE: print_double_array(ta, print_len, st); break;
a61af66fc99e Initial load duke parents: diff changeset	376 case T_BYTE: print_byte_array(ta, print_len, st); break;
a61af66fc99e Initial load duke parents: diff changeset	377 case T_SHORT: print_short_array(ta, print_len, st); break;
a61af66fc99e Initial load duke parents: diff changeset	378 case T_INT: print_int_array(ta, print_len, st); break;
a61af66fc99e Initial load duke parents: diff changeset	379 case T_LONG: print_long_array(ta, print_len, st); break;
a61af66fc99e Initial load duke parents: diff changeset	380 default: ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	381 }
a61af66fc99e Initial load duke parents: diff changeset	382 int remaining = ta->length() - print_len;
a61af66fc99e Initial load duke parents: diff changeset	383 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	384 st->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining);
0 a61af66fc99e Initial load duke parents: diff changeset	385 }
a61af66fc99e Initial load duke parents: diff changeset	386 }
a61af66fc99e Initial load duke parents: diff changeset	387
a61af66fc99e Initial load duke parents: diff changeset	388 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	389
a61af66fc99e Initial load duke parents: diff changeset	390 const char* typeArrayKlass::internal_name() const {
a61af66fc99e Initial load duke parents: diff changeset	391 return Klass::external_name();
a61af66fc99e Initial load duke parents: diff changeset	392 }

Mercurial > hg > truffle

annotate src/share/vm/oops/typeArrayKlass.cpp @ 6862:8a5ea0a9ccc4