Mercurial > hg > graal-jvmci-8
comparison src/share/vm/oops/typeArrayKlass.cpp @ 6948:e522a00b91aa
Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works
author | Doug Simon <doug.simon@oracle.com> |
---|---|
date | Mon, 12 Nov 2012 23:14:12 +0100 |
parents | 6e5a59a8e4a7 |
children | db9981fd3124 |
comparison
equal
deleted
inserted
replaced
6711:ae13cc658b80 | 6948:e522a00b91aa |
---|---|
21 * questions. | 21 * questions. |
22 * | 22 * |
23 */ | 23 */ |
24 | 24 |
25 #include "precompiled.hpp" | 25 #include "precompiled.hpp" |
26 #include "classfile/symbolTable.hpp" | |
26 #include "classfile/systemDictionary.hpp" | 27 #include "classfile/systemDictionary.hpp" |
27 #include "classfile/vmSymbols.hpp" | 28 #include "classfile/vmSymbols.hpp" |
28 #include "gc_interface/collectedHeap.hpp" | 29 #include "gc_interface/collectedHeap.hpp" |
29 #include "gc_interface/collectedHeap.inline.hpp" | 30 #include "gc_interface/collectedHeap.inline.hpp" |
31 #include "memory/metadataFactory.hpp" | |
30 #include "memory/resourceArea.hpp" | 32 #include "memory/resourceArea.hpp" |
31 #include "memory/universe.hpp" | 33 #include "memory/universe.hpp" |
32 #include "memory/universe.inline.hpp" | 34 #include "memory/universe.inline.hpp" |
33 #include "oops/instanceKlass.hpp" | 35 #include "oops/instanceKlass.hpp" |
34 #include "oops/klassOop.hpp" | 36 #include "oops/klass.inline.hpp" |
35 #include "oops/objArrayKlassKlass.hpp" | 37 #include "oops/objArrayKlass.hpp" |
36 #include "oops/oop.inline.hpp" | 38 #include "oops/oop.inline.hpp" |
37 #include "oops/typeArrayKlass.hpp" | 39 #include "oops/typeArrayKlass.hpp" |
38 #include "oops/typeArrayOop.hpp" | 40 #include "oops/typeArrayOop.hpp" |
39 #include "runtime/handles.inline.hpp" | 41 #include "runtime/handles.inline.hpp" |
40 | 42 |
41 bool typeArrayKlass::compute_is_subtype_of(klassOop k) { | 43 bool TypeArrayKlass::compute_is_subtype_of(Klass* k) { |
42 if (!k->klass_part()->oop_is_typeArray()) { | 44 if (!k->oop_is_typeArray()) { |
43 return arrayKlass::compute_is_subtype_of(k); | 45 return ArrayKlass::compute_is_subtype_of(k); |
44 } | 46 } |
45 | 47 |
46 typeArrayKlass* tak = typeArrayKlass::cast(k); | 48 TypeArrayKlass* tak = TypeArrayKlass::cast(k); |
47 if (dimension() != tak->dimension()) return false; | 49 if (dimension() != tak->dimension()) return false; |
48 | 50 |
49 return element_type() == tak->element_type(); | 51 return element_type() == tak->element_type(); |
50 } | 52 } |
51 | 53 |
52 klassOop typeArrayKlass::create_klass(BasicType type, int scale, | 54 TypeArrayKlass* TypeArrayKlass::create_klass(BasicType type, |
53 const char* name_str, TRAPS) { | 55 const char* name_str, TRAPS) { |
54 typeArrayKlass o; | |
55 | |
56 Symbol* sym = NULL; | 56 Symbol* sym = NULL; |
57 if (name_str != NULL) { | 57 if (name_str != NULL) { |
58 sym = SymbolTable::new_permanent_symbol(name_str, CHECK_NULL); | 58 sym = SymbolTable::new_permanent_symbol(name_str, CHECK_NULL); |
59 } | 59 } |
60 KlassHandle klassklass (THREAD, Universe::typeArrayKlassKlassObj()); | 60 |
61 | 61 ClassLoaderData* null_loader_data = ClassLoaderData::the_null_class_loader_data(); |
62 arrayKlassHandle k = base_create_array_klass(o.vtbl_value(), header_size(), klassklass, CHECK_NULL); | 62 |
63 typeArrayKlass* ak = typeArrayKlass::cast(k()); | 63 TypeArrayKlass* ak = TypeArrayKlass::allocate(null_loader_data, type, sym, CHECK_NULL); |
64 ak->set_name(sym); | 64 |
65 ak->set_layout_helper(array_layout_helper(type)); | 65 // Add all classes to our internal class loader list here, |
66 assert(scale == (1 << ak->log2_element_size()), "scale must check out"); | 66 // including classes in the bootstrap (NULL) class loader. |
67 assert(ak->oop_is_javaArray(), "sanity"); | 67 // GC walks these as strong roots. |
68 assert(ak->oop_is_typeArray(), "sanity"); | 68 null_loader_data->add_class(ak); |
69 ak->set_max_length(arrayOopDesc::max_array_length(type)); | |
70 assert(k()->size() > header_size(), "bad size"); | |
71 | 69 |
72 // Call complete_create_array_klass after all instance variables have been initialized. | 70 // Call complete_create_array_klass after all instance variables have been initialized. |
73 KlassHandle super (THREAD, k->super()); | 71 complete_create_array_klass(ak, ak->super(), CHECK_NULL); |
74 complete_create_array_klass(k, super, CHECK_NULL); | 72 |
75 | 73 return ak; |
76 return k(); | 74 } |
77 } | 75 |
78 | 76 TypeArrayKlass* TypeArrayKlass::allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS) { |
79 typeArrayOop typeArrayKlass::allocate_common(int length, bool do_zero, TRAPS) { | 77 assert(TypeArrayKlass::header_size() <= InstanceKlass::header_size(), |
78 "array klasses must be same size as InstanceKlass"); | |
79 | |
80 int size = ArrayKlass::static_size(TypeArrayKlass::header_size()); | |
81 | |
82 return new (loader_data, size, THREAD) TypeArrayKlass(type, name); | |
83 } | |
84 | |
85 TypeArrayKlass::TypeArrayKlass(BasicType type, Symbol* name) : ArrayKlass(name) { | |
86 set_layout_helper(array_layout_helper(type)); | |
87 assert(oop_is_array(), "sanity"); | |
88 assert(oop_is_typeArray(), "sanity"); | |
89 | |
90 set_max_length(arrayOopDesc::max_array_length(type)); | |
91 assert(size() >= TypeArrayKlass::header_size(), "bad size"); | |
92 | |
93 set_class_loader_data(ClassLoaderData::the_null_class_loader_data()); | |
94 } | |
95 | |
96 typeArrayOop TypeArrayKlass::allocate_common(int length, bool do_zero, TRAPS) { | |
80 assert(log2_element_size() >= 0, "bad scale"); | 97 assert(log2_element_size() >= 0, "bad scale"); |
81 if (length >= 0) { | 98 if (length >= 0) { |
82 if (length <= max_length()) { | 99 if (length <= max_length()) { |
83 size_t size = typeArrayOopDesc::object_size(layout_helper(), length); | 100 size_t size = typeArrayOopDesc::object_size(layout_helper(), length); |
84 KlassHandle h_k(THREAD, as_klassOop()); | 101 KlassHandle h_k(THREAD, this); |
85 typeArrayOop t; | 102 typeArrayOop t; |
86 CollectedHeap* ch = Universe::heap(); | 103 CollectedHeap* ch = Universe::heap(); |
87 if (do_zero) { | 104 if (do_zero) { |
88 t = (typeArrayOop)CollectedHeap::array_allocate(h_k, (int)size, length, CHECK_NULL); | 105 t = (typeArrayOop)CollectedHeap::array_allocate(h_k, (int)size, length, CHECK_NULL); |
89 } else { | 106 } else { |
90 t = (typeArrayOop)CollectedHeap::array_allocate_nozero(h_k, (int)size, length, CHECK_NULL); | 107 t = (typeArrayOop)CollectedHeap::array_allocate_nozero(h_k, (int)size, length, CHECK_NULL); |
91 } | 108 } |
92 assert(t->is_parsable(), "Don't publish unless parsable"); | |
93 return t; | 109 return t; |
94 } else { | 110 } else { |
95 report_java_out_of_memory("Requested array size exceeds VM limit"); | 111 report_java_out_of_memory("Requested array size exceeds VM limit"); |
96 JvmtiExport::post_array_size_exhausted(); | 112 JvmtiExport::post_array_size_exhausted(); |
97 THROW_OOP_0(Universe::out_of_memory_error_array_size()); | 113 THROW_OOP_0(Universe::out_of_memory_error_array_size()); |
99 } else { | 115 } else { |
100 THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); | 116 THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); |
101 } | 117 } |
102 } | 118 } |
103 | 119 |
104 typeArrayOop typeArrayKlass::allocate_permanent(int length, TRAPS) { | 120 oop TypeArrayKlass::multi_allocate(int rank, jint* last_size, 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 | 121 // For typeArrays this is only called for the last dimension |
116 assert(rank == 1, "just checking"); | 122 assert(rank == 1, "just checking"); |
117 int length = *last_size; | 123 int length = *last_size; |
118 return allocate(length, THREAD); | 124 return allocate(length, THREAD); |
119 } | 125 } |
120 | 126 |
121 | 127 |
122 void typeArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) { | 128 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"); | 129 assert(s->is_typeArray(), "must be type array"); |
124 | 130 |
125 // Check destination | 131 // Check destination |
126 if (!d->is_typeArray() || element_type() != typeArrayKlass::cast(d->klass())->element_type()) { | 132 if (!d->is_typeArray() || element_type() != TypeArrayKlass::cast(d->klass())->element_type()) { |
127 THROW(vmSymbols::java_lang_ArrayStoreException()); | 133 THROW(vmSymbols::java_lang_ArrayStoreException()); |
128 } | 134 } |
129 | 135 |
130 // Check is all offsets and lengths are non negative | 136 // Check is all offsets and lengths are non negative |
131 if (src_pos < 0 || dst_pos < 0 || length < 0) { | 137 if (src_pos < 0 || dst_pos < 0 || length < 0) { |
148 Copy::conjoint_memory_atomic(src, dst, (size_t)length << l2es); | 154 Copy::conjoint_memory_atomic(src, dst, (size_t)length << l2es); |
149 } | 155 } |
150 | 156 |
151 | 157 |
152 // create a klass of array holding typeArrays | 158 // create a klass of array holding typeArrays |
153 klassOop typeArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) { | 159 Klass* TypeArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) { |
154 typeArrayKlassHandle h_this(THREAD, as_klassOop()); | 160 int dim = dimension(); |
155 return array_klass_impl(h_this, or_null, n, THREAD); | 161 assert(dim <= n, "check order of chain"); |
156 } | 162 if (dim == n) |
157 | 163 return this; |
158 klassOop typeArrayKlass::array_klass_impl(typeArrayKlassHandle h_this, bool or_null, int n, TRAPS) { | 164 |
159 int dimension = h_this->dimension(); | 165 if (higher_dimension() == NULL) { |
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; | 166 if (or_null) return NULL; |
167 | 167 |
168 ResourceMark rm; | 168 ResourceMark rm; |
169 JavaThread *jt = (JavaThread *)THREAD; | 169 JavaThread *jt = (JavaThread *)THREAD; |
170 { | 170 { |
171 MutexLocker mc(Compile_lock, THREAD); // for vtables | 171 MutexLocker mc(Compile_lock, THREAD); // for vtables |
172 // Atomic create higher dimension and link into list | 172 // Atomic create higher dimension and link into list |
173 MutexLocker mu(MultiArray_lock, THREAD); | 173 MutexLocker mu(MultiArray_lock, THREAD); |
174 | 174 |
175 h_ak = objArrayKlassHandle(THREAD, h_this->higher_dimension()); | 175 if (higher_dimension() == NULL) { |
176 if (h_ak.is_null()) { | 176 Klass* oak = ObjArrayKlass::allocate_objArray_klass( |
177 klassOop oak = objArrayKlassKlass::cast( | 177 class_loader_data(), dim + 1, this, CHECK_NULL); |
178 Universe::objArrayKlassKlassObj())->allocate_objArray_klass( | 178 ObjArrayKlass* h_ak = ObjArrayKlass::cast(oak); |
179 dimension + 1, h_this, CHECK_NULL); | 179 h_ak->set_lower_dimension(this); |
180 h_ak = objArrayKlassHandle(THREAD, oak); | |
181 h_ak->set_lower_dimension(h_this()); | |
182 OrderAccess::storestore(); | 180 OrderAccess::storestore(); |
183 h_this->set_higher_dimension(h_ak()); | 181 set_higher_dimension(h_ak); |
184 assert(h_ak->oop_is_objArray(), "incorrect initialization of objArrayKlass"); | 182 assert(h_ak->oop_is_objArray(), "incorrect initialization of ObjArrayKlass"); |
185 } | 183 } |
186 } | 184 } |
187 } else { | 185 } else { |
188 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); | 186 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); |
189 } | 187 } |
188 ObjArrayKlass* h_ak = ObjArrayKlass::cast(higher_dimension()); | |
190 if (or_null) { | 189 if (or_null) { |
191 return h_ak->array_klass_or_null(n); | 190 return h_ak->array_klass_or_null(n); |
192 } | 191 } |
193 return h_ak->array_klass(n, CHECK_NULL); | 192 return h_ak->array_klass(n, CHECK_NULL); |
194 } | 193 } |
195 | 194 |
196 klassOop typeArrayKlass::array_klass_impl(bool or_null, TRAPS) { | 195 Klass* TypeArrayKlass::array_klass_impl(bool or_null, TRAPS) { |
197 return array_klass_impl(or_null, dimension() + 1, THREAD); | 196 return array_klass_impl(or_null, dimension() + 1, THREAD); |
198 } | 197 } |
199 | 198 |
200 int typeArrayKlass::oop_size(oop obj) const { | 199 int TypeArrayKlass::oop_size(oop obj) const { |
201 assert(obj->is_typeArray(),"must be a type array"); | 200 assert(obj->is_typeArray(),"must be a type array"); |
202 typeArrayOop t = typeArrayOop(obj); | 201 typeArrayOop t = typeArrayOop(obj); |
203 return t->object_size(); | 202 return t->object_size(); |
204 } | 203 } |
205 | 204 |
206 void typeArrayKlass::oop_follow_contents(oop obj) { | 205 void TypeArrayKlass::oop_follow_contents(oop obj) { |
207 assert(obj->is_typeArray(),"must be a type array"); | 206 assert(obj->is_typeArray(),"must be a type array"); |
208 // Performance tweak: We skip iterating over the klass pointer since we | 207 // Performance tweak: We skip iterating over the klass pointer since we |
209 // know that Universe::typeArrayKlass never moves. | 208 // know that Universe::TypeArrayKlass never moves. |
210 } | 209 } |
211 | 210 |
212 #ifndef SERIALGC | 211 #ifndef SERIALGC |
213 void typeArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) { | 212 void TypeArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) { |
214 assert(obj->is_typeArray(),"must be a type array"); | 213 assert(obj->is_typeArray(),"must be a type array"); |
215 // Performance tweak: We skip iterating over the klass pointer since we | 214 // Performance tweak: We skip iterating over the klass pointer since we |
216 // know that Universe::typeArrayKlass never moves. | 215 // know that Universe::TypeArrayKlass never moves. |
217 } | 216 } |
218 #endif // SERIALGC | 217 #endif // SERIALGC |
219 | 218 |
220 int typeArrayKlass::oop_adjust_pointers(oop obj) { | 219 int TypeArrayKlass::oop_adjust_pointers(oop obj) { |
221 assert(obj->is_typeArray(),"must be a type array"); | 220 assert(obj->is_typeArray(),"must be a type array"); |
222 typeArrayOop t = typeArrayOop(obj); | 221 typeArrayOop t = typeArrayOop(obj); |
223 // Performance tweak: We skip iterating over the klass pointer since we | 222 // Performance tweak: We skip iterating over the klass pointer since we |
224 // know that Universe::typeArrayKlass never moves. | 223 // know that Universe::TypeArrayKlass never moves. |
225 return t->object_size(); | 224 return t->object_size(); |
226 } | 225 } |
227 | 226 |
228 int typeArrayKlass::oop_oop_iterate(oop obj, OopClosure* blk) { | 227 int TypeArrayKlass::oop_oop_iterate(oop obj, ExtendedOopClosure* blk) { |
229 assert(obj->is_typeArray(),"must be a type array"); | 228 assert(obj->is_typeArray(),"must be a type array"); |
230 typeArrayOop t = typeArrayOop(obj); | 229 typeArrayOop t = typeArrayOop(obj); |
231 // Performance tweak: We skip iterating over the klass pointer since we | 230 // Performance tweak: We skip iterating over the klass pointer since we |
232 // know that Universe::typeArrayKlass never moves. | 231 // know that Universe::TypeArrayKlass never moves. |
233 return t->object_size(); | 232 return t->object_size(); |
234 } | 233 } |
235 | 234 |
236 int typeArrayKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) { | 235 int TypeArrayKlass::oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) { |
237 assert(obj->is_typeArray(),"must be a type array"); | 236 assert(obj->is_typeArray(),"must be a type array"); |
238 typeArrayOop t = typeArrayOop(obj); | 237 typeArrayOop t = typeArrayOop(obj); |
239 // Performance tweak: We skip iterating over the klass pointer since we | 238 // Performance tweak: We skip iterating over the klass pointer since we |
240 // know that Universe::typeArrayKlass never moves. | 239 // know that Universe::TypeArrayKlass never moves. |
241 return t->object_size(); | 240 return t->object_size(); |
242 } | 241 } |
243 | 242 |
244 #ifndef SERIALGC | 243 #ifndef SERIALGC |
245 void typeArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { | 244 void TypeArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { |
245 ShouldNotReachHere(); | |
246 assert(obj->is_typeArray(),"must be a type array"); | 246 assert(obj->is_typeArray(),"must be a type array"); |
247 } | 247 } |
248 | 248 |
249 int | 249 int |
250 typeArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { | 250 TypeArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { |
251 assert(obj->is_typeArray(),"must be a type array"); | 251 assert(obj->is_typeArray(),"must be a type array"); |
252 return typeArrayOop(obj)->object_size(); | 252 return typeArrayOop(obj)->object_size(); |
253 } | 253 } |
254 #endif // SERIALGC | 254 #endif // SERIALGC |
255 | 255 |
256 void typeArrayKlass::initialize(TRAPS) { | 256 void TypeArrayKlass::initialize(TRAPS) { |
257 // Nothing to do. Having this function is handy since objArrayKlasses can be | 257 // Nothing to do. Having this function is handy since objArrayKlasses can be |
258 // initialized by calling initialize on their bottom_klass, see objArrayKlass::initialize | 258 // initialized by calling initialize on their bottom_klass, see ObjArrayKlass::initialize |
259 } | 259 } |
260 | 260 |
261 const char* typeArrayKlass::external_name(BasicType type) { | 261 const char* TypeArrayKlass::external_name(BasicType type) { |
262 switch (type) { | 262 switch (type) { |
263 case T_BOOLEAN: return "[Z"; | 263 case T_BOOLEAN: return "[Z"; |
264 case T_CHAR: return "[C"; | 264 case T_CHAR: return "[C"; |
265 case T_FLOAT: return "[F"; | 265 case T_FLOAT: return "[F"; |
266 case T_DOUBLE: return "[D"; | 266 case T_DOUBLE: return "[D"; |
271 default: ShouldNotReachHere(); | 271 default: ShouldNotReachHere(); |
272 } | 272 } |
273 return NULL; | 273 return NULL; |
274 } | 274 } |
275 | 275 |
276 | |
277 // Printing | |
278 | |
279 void TypeArrayKlass::print_on(outputStream* st) const { | |
276 #ifndef PRODUCT | 280 #ifndef PRODUCT |
277 // Printing | 281 assert(is_klass(), "must be klass"); |
282 print_value_on(st); | |
283 Klass::print_on(st); | |
284 #endif //PRODUCT | |
285 } | |
286 | |
287 void TypeArrayKlass::print_value_on(outputStream* st) const { | |
288 assert(is_klass(), "must be klass"); | |
289 st->print("{type array "); | |
290 switch (element_type()) { | |
291 case T_BOOLEAN: st->print("bool"); break; | |
292 case T_CHAR: st->print("char"); break; | |
293 case T_FLOAT: st->print("float"); break; | |
294 case T_DOUBLE: st->print("double"); break; | |
295 case T_BYTE: st->print("byte"); break; | |
296 case T_SHORT: st->print("short"); break; | |
297 case T_INT: st->print("int"); break; | |
298 case T_LONG: st->print("long"); break; | |
299 default: ShouldNotReachHere(); | |
300 } | |
301 st->print("}"); | |
302 } | |
303 | |
304 #ifndef PRODUCT | |
278 | 305 |
279 static void print_boolean_array(typeArrayOop ta, int print_len, outputStream* st) { | 306 static void print_boolean_array(typeArrayOop ta, int print_len, outputStream* st) { |
280 for (int index = 0; index < print_len; index++) { | 307 for (int index = 0; index < print_len; index++) { |
281 st->print_cr(" - %3d: %s", index, (ta->bool_at(index) == 0) ? "false" : "true"); | 308 st->print_cr(" - %3d: %s", index, (ta->bool_at(index) == 0) ? "false" : "true"); |
282 } | 309 } |
335 st->print_cr(" - %3d: 0x%x 0x%x", index, high(v), low(v)); | 362 st->print_cr(" - %3d: 0x%x 0x%x", index, high(v), low(v)); |
336 } | 363 } |
337 } | 364 } |
338 | 365 |
339 | 366 |
340 void typeArrayKlass::oop_print_on(oop obj, outputStream* st) { | 367 void TypeArrayKlass::oop_print_on(oop obj, outputStream* st) { |
341 arrayKlass::oop_print_on(obj, st); | 368 ArrayKlass::oop_print_on(obj, st); |
342 typeArrayOop ta = typeArrayOop(obj); | 369 typeArrayOop ta = typeArrayOop(obj); |
343 int print_len = MIN2((intx) ta->length(), MaxElementPrintSize); | 370 int print_len = MIN2((intx) ta->length(), MaxElementPrintSize); |
344 switch (element_type()) { | 371 switch (element_type()) { |
345 case T_BOOLEAN: print_boolean_array(ta, print_len, st); break; | 372 case T_BOOLEAN: print_boolean_array(ta, print_len, st); break; |
346 case T_CHAR: print_char_array(ta, print_len, st); break; | 373 case T_CHAR: print_char_array(ta, print_len, st); break; |
352 case T_LONG: print_long_array(ta, print_len, st); break; | 379 case T_LONG: print_long_array(ta, print_len, st); break; |
353 default: ShouldNotReachHere(); | 380 default: ShouldNotReachHere(); |
354 } | 381 } |
355 int remaining = ta->length() - print_len; | 382 int remaining = ta->length() - print_len; |
356 if (remaining > 0) { | 383 if (remaining > 0) { |
357 tty->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining); | 384 st->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining); |
358 } | 385 } |
359 } | 386 } |
360 | 387 |
361 #endif // PRODUCT | 388 #endif // PRODUCT |
362 | 389 |
363 const char* typeArrayKlass::internal_name() const { | 390 const char* TypeArrayKlass::internal_name() const { |
364 return Klass::external_name(); | 391 return Klass::external_name(); |
365 } | 392 } |