Mercurial > hg > truffle
annotate src/share/vm/oops/typeArrayKlass.cpp @ 1972:f95d63e2154a
6989984: Use standard include model for Hospot
Summary: Replaced MakeDeps and the includeDB files with more standardized solutions.
Reviewed-by: coleenp, kvn, kamg
| author | stefank |
|---|---|
| date | Tue, 23 Nov 2010 13:22:55 -0800 |
| parents | 9d7a8ab3736b |
| children | d4fca0a6abde |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 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 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "classfile/vmSymbols.hpp" | |
| 28 #include "gc_interface/collectedHeap.hpp" | |
| 29 #include "gc_interface/collectedHeap.inline.hpp" | |
| 30 #include "memory/resourceArea.hpp" | |
| 31 #include "memory/universe.hpp" | |
| 32 #include "memory/universe.inline.hpp" | |
| 33 #include "oops/instanceKlass.hpp" | |
| 34 #include "oops/klassOop.hpp" | |
| 35 #include "oops/objArrayKlassKlass.hpp" | |
| 36 #include "oops/oop.inline.hpp" | |
| 37 #include "oops/typeArrayKlass.hpp" | |
| 38 #include "oops/typeArrayOop.hpp" | |
| 39 #include "runtime/handles.inline.hpp" | |
| 0 | 40 |
| 41 bool typeArrayKlass::compute_is_subtype_of(klassOop k) { | |
| 42 if (!k->klass_part()->oop_is_typeArray()) { | |
| 43 return arrayKlass::compute_is_subtype_of(k); | |
| 44 } | |
| 45 | |
| 46 typeArrayKlass* tak = typeArrayKlass::cast(k); | |
| 47 if (dimension() != tak->dimension()) return false; | |
| 48 | |
| 49 return element_type() == tak->element_type(); | |
| 50 } | |
| 51 | |
|
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
0
diff
changeset
|
52 klassOop typeArrayKlass::create_klass(BasicType type, int scale, |
|
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
0
diff
changeset
|
53 const char* name_str, TRAPS) { |
| 0 | 54 typeArrayKlass o; |
| 55 | |
| 56 symbolHandle sym(symbolOop(NULL)); | |
| 57 // bootstrapping: don't create sym if symbolKlass not created yet | |
|
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
0
diff
changeset
|
58 if (Universe::symbolKlassObj() != NULL && name_str != NULL) { |
|
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
0
diff
changeset
|
59 sym = oopFactory::new_symbol_handle(name_str, CHECK_NULL); |
| 0 | 60 } |
| 61 KlassHandle klassklass (THREAD, Universe::typeArrayKlassKlassObj()); | |
| 62 | |
| 63 arrayKlassHandle k = base_create_array_klass(o.vtbl_value(), header_size(), klassklass, CHECK_NULL); | |
| 64 typeArrayKlass* ak = typeArrayKlass::cast(k()); | |
| 65 ak->set_name(sym()); | |
| 66 ak->set_layout_helper(array_layout_helper(type)); | |
| 67 assert(scale == (1 << ak->log2_element_size()), "scale must check out"); | |
| 68 assert(ak->oop_is_javaArray(), "sanity"); | |
| 69 assert(ak->oop_is_typeArray(), "sanity"); | |
| 70 ak->set_max_length(arrayOopDesc::max_array_length(type)); | |
| 71 assert(k()->size() > header_size(), "bad size"); | |
| 72 | |
| 73 // Call complete_create_array_klass after all instance variables have been initialized. | |
| 74 KlassHandle super (THREAD, k->super()); | |
| 75 complete_create_array_klass(k, super, CHECK_NULL); | |
| 76 | |
| 77 return k(); | |
| 78 } | |
| 79 | |
| 80 typeArrayOop typeArrayKlass::allocate(int length, TRAPS) { | |
| 81 assert(log2_element_size() >= 0, "bad scale"); | |
| 82 if (length >= 0) { | |
| 83 if (length <= max_length()) { | |
| 84 size_t size = typeArrayOopDesc::object_size(layout_helper(), length); | |
| 85 KlassHandle h_k(THREAD, as_klassOop()); | |
| 86 typeArrayOop t; | |
| 87 CollectedHeap* ch = Universe::heap(); | |
| 88 if (size < ch->large_typearray_limit()) { | |
| 89 t = (typeArrayOop)CollectedHeap::array_allocate(h_k, (int)size, length, CHECK_NULL); | |
| 90 } else { | |
| 91 t = (typeArrayOop)CollectedHeap::large_typearray_allocate(h_k, (int)size, length, CHECK_NULL); | |
| 92 } | |
| 93 assert(t->is_parsable(), "Don't publish unless parsable"); | |
| 94 return t; | |
| 95 } else { | |
|
876
1413494da700
6850957: Honor -XX:OnOutOfMemoryError when array size exceeds VM limit
martin
parents:
579
diff
changeset
|
96 report_java_out_of_memory("Requested array size exceeds VM limit"); |
| 0 | 97 THROW_OOP_0(Universe::out_of_memory_error_array_size()); |
| 98 } | |
| 99 } else { | |
| 100 THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); | |
| 101 } | |
| 102 } | |
| 103 | |
| 104 typeArrayOop typeArrayKlass::allocate_permanent(int length, TRAPS) { | |
| 105 if (length < 0) THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); | |
| 106 int size = typeArrayOopDesc::object_size(layout_helper(), length); | |
| 107 KlassHandle h_k(THREAD, as_klassOop()); | |
| 108 typeArrayOop t = (typeArrayOop) | |
| 109 CollectedHeap::permanent_array_allocate(h_k, size, length, CHECK_NULL); | |
| 110 assert(t->is_parsable(), "Can't publish until parsable"); | |
| 111 return t; | |
| 112 } | |
| 113 | |
| 114 oop typeArrayKlass::multi_allocate(int rank, jint* last_size, TRAPS) { | |
| 115 // For typeArrays this is only called for the last dimension | |
| 116 assert(rank == 1, "just checking"); | |
| 117 int length = *last_size; | |
| 118 return allocate(length, THREAD); | |
| 119 } | |
| 120 | |
| 121 | |
| 122 void typeArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) { | |
| 123 assert(s->is_typeArray(), "must be type array"); | |
| 124 | |
| 125 // Check destination | |
| 126 if (!d->is_typeArray() || element_type() != typeArrayKlass::cast(d->klass())->element_type()) { | |
| 127 THROW(vmSymbols::java_lang_ArrayStoreException()); | |
| 128 } | |
| 129 | |
| 130 // Check is all offsets and lengths are non negative | |
| 131 if (src_pos < 0 || dst_pos < 0 || length < 0) { | |
| 132 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); | |
| 133 } | |
| 134 // Check if the ranges are valid | |
| 135 if ( (((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length()) | |
| 136 || (((unsigned int) length + (unsigned int) dst_pos) > (unsigned int) d->length()) ) { | |
| 137 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); | |
| 138 } | |
|
1334
b5d78a3b8843
6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes
kvn
parents:
876
diff
changeset
|
139 // Check zero copy |
|
b5d78a3b8843
6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes
kvn
parents:
876
diff
changeset
|
140 if (length == 0) |
|
b5d78a3b8843
6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes
kvn
parents:
876
diff
changeset
|
141 return; |
| 0 | 142 |
| 143 // This is an attempt to make the copy_array fast. | |
| 144 int l2es = log2_element_size(); | |
| 145 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
|
146 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
|
147 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
|
148 Copy::conjoint_memory_atomic(src, dst, (size_t)length << l2es); |
| 0 | 149 } |
| 150 | |
| 151 | |
| 152 // create a klass of array holding typeArrays | |
| 153 klassOop typeArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) { | |
| 154 typeArrayKlassHandle h_this(THREAD, as_klassOop()); | |
| 155 return array_klass_impl(h_this, or_null, n, THREAD); | |
| 156 } | |
| 157 | |
| 158 klassOop typeArrayKlass::array_klass_impl(typeArrayKlassHandle h_this, bool or_null, int n, TRAPS) { | |
| 159 int dimension = h_this->dimension(); | |
| 160 assert(dimension <= n, "check order of chain"); | |
| 161 if (dimension == n) | |
| 162 return h_this(); | |
| 163 | |
| 164 objArrayKlassHandle h_ak(THREAD, h_this->higher_dimension()); | |
| 165 if (h_ak.is_null()) { | |
| 166 if (or_null) return NULL; | |
| 167 | |
| 168 ResourceMark rm; | |
| 169 JavaThread *jt = (JavaThread *)THREAD; | |
| 170 { | |
| 171 MutexLocker mc(Compile_lock, THREAD); // for vtables | |
| 172 // Atomic create higher dimension and link into list | |
| 173 MutexLocker mu(MultiArray_lock, THREAD); | |
| 174 | |
| 175 h_ak = objArrayKlassHandle(THREAD, h_this->higher_dimension()); | |
| 176 if (h_ak.is_null()) { | |
| 177 klassOop oak = objArrayKlassKlass::cast( | |
| 178 Universe::objArrayKlassKlassObj())->allocate_objArray_klass( | |
| 179 dimension + 1, h_this, CHECK_NULL); | |
| 180 h_ak = objArrayKlassHandle(THREAD, oak); | |
| 181 h_ak->set_lower_dimension(h_this()); | |
| 182 h_this->set_higher_dimension(h_ak()); | |
| 183 assert(h_ak->oop_is_objArray(), "incorrect initialization of objArrayKlass"); | |
| 184 } | |
| 185 } | |
| 186 } else { | |
| 187 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); | |
| 188 } | |
| 189 if (or_null) { | |
| 190 return h_ak->array_klass_or_null(n); | |
| 191 } | |
| 192 return h_ak->array_klass(n, CHECK_NULL); | |
| 193 } | |
| 194 | |
| 195 klassOop typeArrayKlass::array_klass_impl(bool or_null, TRAPS) { | |
| 196 return array_klass_impl(or_null, dimension() + 1, THREAD); | |
| 197 } | |
| 198 | |
| 199 int typeArrayKlass::oop_size(oop obj) const { | |
| 200 assert(obj->is_typeArray(),"must be a type array"); | |
| 201 typeArrayOop t = typeArrayOop(obj); | |
| 202 return t->object_size(); | |
| 203 } | |
| 204 | |
| 205 void typeArrayKlass::oop_follow_contents(oop obj) { | |
| 206 assert(obj->is_typeArray(),"must be a type array"); | |
| 207 // Performance tweak: We skip iterating over the klass pointer since we | |
| 208 // know that Universe::typeArrayKlass never moves. | |
| 209 } | |
| 210 | |
| 211 #ifndef SERIALGC | |
| 212 void typeArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) { | |
| 213 assert(obj->is_typeArray(),"must be a type array"); | |
| 214 // Performance tweak: We skip iterating over the klass pointer since we | |
| 215 // know that Universe::typeArrayKlass never moves. | |
| 216 } | |
| 217 #endif // SERIALGC | |
| 218 | |
| 219 int typeArrayKlass::oop_adjust_pointers(oop obj) { | |
| 220 assert(obj->is_typeArray(),"must be a type array"); | |
| 221 typeArrayOop t = typeArrayOop(obj); | |
| 222 // Performance tweak: We skip iterating over the klass pointer since we | |
| 223 // know that Universe::typeArrayKlass never moves. | |
| 224 return t->object_size(); | |
| 225 } | |
| 226 | |
| 227 int typeArrayKlass::oop_oop_iterate(oop obj, OopClosure* blk) { | |
| 228 assert(obj->is_typeArray(),"must be a type array"); | |
| 229 typeArrayOop t = typeArrayOop(obj); | |
| 230 // Performance tweak: We skip iterating over the klass pointer since we | |
| 231 // know that Universe::typeArrayKlass never moves. | |
| 232 return t->object_size(); | |
| 233 } | |
| 234 | |
| 235 int typeArrayKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) { | |
| 236 assert(obj->is_typeArray(),"must be a type array"); | |
| 237 typeArrayOop t = typeArrayOop(obj); | |
| 238 // Performance tweak: We skip iterating over the klass pointer since we | |
| 239 // know that Universe::typeArrayKlass never moves. | |
| 240 return t->object_size(); | |
| 241 } | |
| 242 | |
| 243 #ifndef SERIALGC | |
| 244 void typeArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { | |
| 245 assert(obj->is_typeArray(),"must be a type array"); | |
| 246 } | |
| 247 | |
| 248 int | |
| 249 typeArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { | |
| 250 assert(obj->is_typeArray(),"must be a type array"); | |
| 251 return typeArrayOop(obj)->object_size(); | |
| 252 } | |
| 253 | |
| 254 int | |
| 255 typeArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj, | |
| 256 HeapWord* beg_addr, HeapWord* end_addr) { | |
| 257 assert(obj->is_typeArray(),"must be a type array"); | |
| 258 return typeArrayOop(obj)->object_size(); | |
| 259 } | |
| 260 #endif // SERIALGC | |
| 261 | |
| 262 void typeArrayKlass::initialize(TRAPS) { | |
| 263 // Nothing to do. Having this function is handy since objArrayKlasses can be | |
| 264 // initialized by calling initialize on their bottom_klass, see objArrayKlass::initialize | |
| 265 } | |
| 266 | |
| 267 const char* typeArrayKlass::external_name(BasicType type) { | |
| 268 switch (type) { | |
| 269 case T_BOOLEAN: return "[Z"; | |
| 270 case T_CHAR: return "[C"; | |
| 271 case T_FLOAT: return "[F"; | |
| 272 case T_DOUBLE: return "[D"; | |
| 273 case T_BYTE: return "[B"; | |
| 274 case T_SHORT: return "[S"; | |
| 275 case T_INT: return "[I"; | |
| 276 case T_LONG: return "[J"; | |
| 277 default: ShouldNotReachHere(); | |
| 278 } | |
| 279 return NULL; | |
| 280 } | |
| 281 | |
| 282 #ifndef PRODUCT | |
| 283 // Printing | |
| 284 | |
| 285 static void print_boolean_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 286 for (int index = 0; index < print_len; index++) { | |
| 287 st->print_cr(" - %3d: %s", index, (ta->bool_at(index) == 0) ? "false" : "true"); | |
| 288 } | |
| 289 } | |
| 290 | |
| 291 | |
| 292 static void print_char_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 293 for (int index = 0; index < print_len; index++) { | |
| 294 jchar c = ta->char_at(index); | |
| 295 st->print_cr(" - %3d: %x %c", index, c, isprint(c) ? c : ' '); | |
| 296 } | |
| 297 } | |
| 298 | |
| 299 | |
| 300 static void print_float_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 301 for (int index = 0; index < print_len; index++) { | |
| 302 st->print_cr(" - %3d: %g", index, ta->float_at(index)); | |
| 303 } | |
| 304 } | |
| 305 | |
| 306 | |
| 307 static void print_double_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 308 for (int index = 0; index < print_len; index++) { | |
| 309 st->print_cr(" - %3d: %g", index, ta->double_at(index)); | |
| 310 } | |
| 311 } | |
| 312 | |
| 313 | |
| 314 static void print_byte_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 315 for (int index = 0; index < print_len; index++) { | |
| 316 jbyte c = ta->byte_at(index); | |
| 317 st->print_cr(" - %3d: %x %c", index, c, isprint(c) ? c : ' '); | |
| 318 } | |
| 319 } | |
| 320 | |
| 321 | |
| 322 static void print_short_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 323 for (int index = 0; index < print_len; index++) { | |
| 324 int v = ta->ushort_at(index); | |
| 325 st->print_cr(" - %3d: 0x%x\t %d", index, v, v); | |
| 326 } | |
| 327 } | |
| 328 | |
| 329 | |
| 330 static void print_int_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 331 for (int index = 0; index < print_len; index++) { | |
| 332 jint v = ta->int_at(index); | |
| 333 st->print_cr(" - %3d: 0x%x %d", index, v, v); | |
| 334 } | |
| 335 } | |
| 336 | |
| 337 | |
| 338 static void print_long_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 339 for (int index = 0; index < print_len; index++) { | |
| 340 jlong v = ta->long_at(index); | |
| 341 st->print_cr(" - %3d: 0x%x 0x%x", index, high(v), low(v)); | |
| 342 } | |
| 343 } | |
| 344 | |
| 345 | |
| 346 void typeArrayKlass::oop_print_on(oop obj, outputStream* st) { | |
| 347 arrayKlass::oop_print_on(obj, st); | |
| 348 typeArrayOop ta = typeArrayOop(obj); | |
| 349 int print_len = MIN2((intx) ta->length(), MaxElementPrintSize); | |
| 350 switch (element_type()) { | |
| 351 case T_BOOLEAN: print_boolean_array(ta, print_len, st); break; | |
| 352 case T_CHAR: print_char_array(ta, print_len, st); break; | |
| 353 case T_FLOAT: print_float_array(ta, print_len, st); break; | |
| 354 case T_DOUBLE: print_double_array(ta, print_len, st); break; | |
| 355 case T_BYTE: print_byte_array(ta, print_len, st); break; | |
| 356 case T_SHORT: print_short_array(ta, print_len, st); break; | |
| 357 case T_INT: print_int_array(ta, print_len, st); break; | |
| 358 case T_LONG: print_long_array(ta, print_len, st); break; | |
| 359 default: ShouldNotReachHere(); | |
| 360 } | |
| 361 int remaining = ta->length() - print_len; | |
| 362 if (remaining > 0) { | |
| 363 tty->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining); | |
| 364 } | |
| 365 } | |
| 366 | |
| 367 #endif // PRODUCT | |
| 368 | |
| 369 const char* typeArrayKlass::internal_name() const { | |
| 370 return Klass::external_name(); | |
| 371 } |