1 /*
2 * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "classfile/moduleEntry.hpp"
26 #include "classfile/packageEntry.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "classfile/systemDictionary.hpp"
29 #include "classfile/vmSymbols.hpp"
30 #include "gc/shared/collectedHeap.inline.hpp"
31 #include "memory/iterator.inline.hpp"
32 #include "memory/metadataFactory.hpp"
33 #include "memory/metaspaceClosure.hpp"
34 #include "memory/oopFactory.hpp"
35 #include "memory/resourceArea.hpp"
36 #include "memory/universe.hpp"
37 #include "oops/arrayKlass.inline.hpp"
38 #include "oops/arrayOop.hpp"
39 #include "oops/flatArrayKlass.hpp"
40 #include "oops/flatArrayOop.hpp"
41 #include "oops/flatArrayOop.inline.hpp"
42 #include "oops/inlineKlass.hpp"
43 #include "oops/instanceKlass.hpp"
44 #include "oops/klass.inline.hpp"
45 #include "oops/objArrayKlass.hpp"
46 #include "oops/objArrayOop.inline.hpp"
47 #include "oops/oop.inline.hpp"
48 #include "oops/verifyOopClosure.hpp"
49 #include "runtime/arguments.hpp"
50 #include "runtime/handles.inline.hpp"
51 #include "runtime/mutexLocker.hpp"
52 #include "utilities/copy.hpp"
53 #include "utilities/macros.hpp"
54
55 // Allocation...
56
57 FlatArrayKlass::FlatArrayKlass(Klass* element_klass, Symbol* name, ArrayProperties props, LayoutKind lk) :
58 ObjArrayKlass(1, element_klass, name, Kind, props, markWord::flat_array_prototype(lk)) {
59 assert(element_klass->is_inline_klass(), "Expected Inline");
60 assert(lk == LayoutKind::NON_ATOMIC_FLAT || lk == LayoutKind::ATOMIC_FLAT || lk == LayoutKind::NULLABLE_ATOMIC_FLAT, "Must be a flat layout");
61
62 set_element_klass(InlineKlass::cast(element_klass));
63 set_class_loader_data(element_klass->class_loader_data());
64 set_layout_kind(lk);
65
66 set_layout_helper(array_layout_helper(InlineKlass::cast(element_klass), lk));
67 assert(is_array_klass(), "sanity");
68 assert(is_flatArray_klass(), "sanity");
69
70 #ifdef ASSERT
71 assert(layout_helper_is_array(layout_helper()), "Must be");
72 assert(layout_helper_is_flatArray(layout_helper()), "Must be");
73 assert(layout_helper_element_type(layout_helper()) == T_FLAT_ELEMENT, "Must be");
74 assert(prototype_header().is_flat_array(), "Must be");
75 switch(lk) {
76 case LayoutKind::NON_ATOMIC_FLAT:
77 case LayoutKind::ATOMIC_FLAT:
78 assert(layout_helper_is_null_free(layout_helper()), "Must be");
79 assert(prototype_header().is_null_free_array(), "Must be");
80 break;
81 case LayoutKind::NULLABLE_ATOMIC_FLAT:
82 assert(!layout_helper_is_null_free(layout_helper()), "Must be");
83 assert(!prototype_header().is_null_free_array(), "Must be");
84 break;
85 default:
86 ShouldNotReachHere();
87 break;
88 }
89 #endif // ASSERT
90
91 #ifndef PRODUCT
92 if (PrintFlatArrayLayout) {
93 print();
94 }
95 #endif
96 }
97
98 FlatArrayKlass* FlatArrayKlass::allocate_klass(Klass* eklass, ArrayProperties props, LayoutKind lk, TRAPS) {
99 guarantee((!Universe::is_bootstrapping() || vmClasses::Object_klass_loaded()), "Really ?!");
100 assert(UseArrayFlattening, "Flatten array required");
101 assert(MultiArray_lock->holds_lock(THREAD), "must hold lock after bootstrapping");
102
103 InlineKlass* element_klass = InlineKlass::cast(eklass);
104 assert(element_klass->must_be_atomic() || (!AlwaysAtomicAccesses), "Atomic by-default");
105
106 // Eagerly allocate the direct array supertype.
107 Klass* super_klass = nullptr;
108 Klass* element_super = element_klass->super();
109 if (element_super != nullptr) {
110 // The element type has a direct super. E.g., String[] has direct super of Object[].
111 super_klass = element_klass->array_klass(CHECK_NULL);
112 }
113
114 Symbol* name = ArrayKlass::create_element_klass_array_name(element_klass, CHECK_NULL);
115 ClassLoaderData* loader_data = element_klass->class_loader_data();
116 int size = ArrayKlass::static_size(FlatArrayKlass::header_size());
117 FlatArrayKlass* vak = new (loader_data, size, THREAD) FlatArrayKlass(element_klass, name, props, lk);
118
119 ModuleEntry* module = vak->module();
120 assert(module != nullptr, "No module entry for array");
121 complete_create_array_klass(vak, super_klass, module, CHECK_NULL);
122
123 loader_data->add_class(vak);
124
125 return vak;
126 }
127
128 void FlatArrayKlass::initialize(TRAPS) {
129 element_klass()->initialize(THREAD);
130 }
131
132 void FlatArrayKlass::metaspace_pointers_do(MetaspaceClosure* it) {
133 ObjArrayKlass::metaspace_pointers_do(it);
134 }
135
136 // Oops allocation...
137 objArrayOop FlatArrayKlass::allocate_instance(int length, ArrayProperties props, TRAPS) {
138 assert(UseArrayFlattening, "Must be enabled");
139 check_array_allocation_length(length, max_elements(), CHECK_NULL);
140 int size = flatArrayOopDesc::object_size(layout_helper(), length);
141 flatArrayOop array = (flatArrayOop) Universe::heap()->array_allocate(this, size, length, true, CHECK_NULL);
142 return array;
143 }
144
145 oop FlatArrayKlass::multi_allocate(int rank, jint* last_size, TRAPS) {
146 // FlatArrays only have one dimension
147 ShouldNotReachHere();
148 }
149
150 jint FlatArrayKlass::array_layout_helper(InlineKlass* vk, LayoutKind lk) {
151 BasicType etype = T_FLAT_ELEMENT;
152 int esize = log2i_exact(round_up_power_of_2(vk->layout_size_in_bytes(lk)));
153 int hsize = arrayOopDesc::base_offset_in_bytes(etype);
154 bool null_free = lk != LayoutKind::NULLABLE_ATOMIC_FLAT;
155 int lh = Klass::array_layout_helper(_lh_array_tag_flat_value, null_free, hsize, etype, esize);
156
157 assert(lh < (int)_lh_neutral_value, "must look like an array layout");
158 assert(layout_helper_is_array(lh), "correct kind");
159 assert(layout_helper_is_flatArray(lh), "correct kind");
160 assert(!layout_helper_is_typeArray(lh), "correct kind");
161 assert(layout_helper_is_null_free(lh) == null_free, "correct kind");
162 assert(layout_helper_header_size(lh) == hsize, "correct decode");
163 assert(layout_helper_element_type(lh) == etype, "correct decode");
164 assert(layout_helper_log2_element_size(lh) == esize, "correct decode");
165 assert((1 << esize) < BytesPerLong || is_aligned(hsize, HeapWordsPerLong), "unaligned base");
166
167 return lh;
168 }
169
170 size_t FlatArrayKlass::oop_size(oop obj) const {
171 // In this assert, we cannot safely access the Klass* with compact headers,
172 // because size_given_klass() calls oop_size() on objects that might be
173 // concurrently forwarded, which would overwrite the Klass*.
174 // Also, why we need to pass this layout_helper() to flatArrayOop::object_size.
175 assert(UseCompactObjectHeaders || obj->is_flatArray(),"must be an flat array");
176 flatArrayOop array = flatArrayOop(obj);
177 return array->object_size(layout_helper());
178 }
179
180 // For now return the maximum number of array elements that will not exceed:
181 // nof bytes = "max_jint * HeapWord" since the "oopDesc::oop_iterate_size"
182 // returns "int" HeapWords, need fix for JDK-4718400 and JDK-8233189
183 jint FlatArrayKlass::max_elements() const {
184 // Check the max number of heap words limit first (because of int32_t in oopDesc_oop_size() etc)
185 size_t max_size = max_jint;
186 max_size -= (arrayOopDesc::base_offset_in_bytes(T_FLAT_ELEMENT) >> LogHeapWordSize);
187 max_size = align_down(max_size, MinObjAlignment);
188 max_size <<= LogHeapWordSize; // convert to max payload size in bytes
189 max_size >>= layout_helper_log2_element_size(_layout_helper); // divide by element size (in bytes) = max elements
190 // Within int32_t heap words, still can't exceed Java array element limit
191 if (max_size > max_jint) {
192 max_size = max_jint;
193 }
194 assert((max_size >> LogHeapWordSize) <= max_jint, "Overflow");
195 return (jint) max_size;
196 }
197
198 oop FlatArrayKlass::protection_domain() const {
199 return element_klass()->protection_domain();
200 }
201
202 // Temp hack having this here: need to move towards Access API
203 static bool needs_backwards_copy(arrayOop s, int src_pos,
204 arrayOop d, int dst_pos, int length) {
205 return (s == d) && (dst_pos > src_pos) && (dst_pos - src_pos) < length;
206 }
207
208 void FlatArrayKlass::copy_array(arrayOop s, int src_pos,
209 arrayOop d, int dst_pos, int length, TRAPS) {
210
211 assert(s->is_objArray() || s->is_flatArray(), "must be obj or flat array");
212
213 // Check destination
214 if ((!d->is_flatArray()) && (!d->is_objArray())) {
215 THROW(vmSymbols::java_lang_ArrayStoreException());
216 }
217
218 // Check if all offsets and lengths are non negative
219 if (src_pos < 0 || dst_pos < 0 || length < 0) {
220 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
221 }
222 // Check if the ranges are valid
223 if ( (((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length())
224 || (((unsigned int) length + (unsigned int) dst_pos) > (unsigned int) d->length()) ) {
225 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
226 }
227 // Check zero copy
228 if (length == 0)
229 return;
230
231 ObjArrayKlass* sk = ObjArrayKlass::cast(s->klass());
232 ObjArrayKlass* dk = ObjArrayKlass::cast(d->klass());
233 Klass* d_elem_klass = dk->element_klass();
234 Klass* s_elem_klass = sk->element_klass();
235 /**** CMH: compare and contrast impl, re-factor once we find edge cases... ****/
236
237 if (sk->is_flatArray_klass()) {
238 assert(sk == this, "Unexpected call to copy_array");
239 FlatArrayKlass* fsk = FlatArrayKlass::cast(sk);
240 // Check subtype, all src homogeneous, so just once
241 if (!s_elem_klass->is_subtype_of(d_elem_klass)) {
242 THROW(vmSymbols::java_lang_ArrayStoreException());
243 }
244
245 flatArrayOop sa = flatArrayOop(s);
246 InlineKlass* s_elem_vklass = element_klass();
247
248 // flatArray-to-flatArray
249 if (dk->is_flatArray_klass()) {
250 // element types MUST be exact, subtype check would be dangerous
251 if (d_elem_klass != this->element_klass()) {
252 THROW(vmSymbols::java_lang_ArrayStoreException());
253 }
254
255 FlatArrayKlass* fdk = FlatArrayKlass::cast(dk);
256 InlineKlass* vk = InlineKlass::cast(s_elem_klass);
257 flatArrayOop da = flatArrayOop(d);
258 int src_incr = fsk->element_byte_size();
259 int dst_incr = fdk->element_byte_size();
260
261 if (fsk->layout_kind() == fdk->layout_kind()) {
262 assert(src_incr == dst_incr, "Must be");
263 if (needs_backwards_copy(sa, src_pos, da, dst_pos, length)) {
264 address dst = (address) da->value_at_addr(dst_pos + length - 1, fdk->layout_helper());
265 address src = (address) sa->value_at_addr(src_pos + length - 1, fsk->layout_helper());
266 for (int i = 0; i < length; i++) {
267 // because source and destination have the same layout, bypassing the InlineKlass copy methods
268 // and call AccessAPI directly
269 HeapAccess<>::value_copy(src, dst, vk, fsk->layout_kind());
270 dst -= dst_incr;
271 src -= src_incr;
272 }
273 } else {
274 // source and destination share same layout, direct copy from array to array is possible
275 address dst = (address) da->value_at_addr(dst_pos, fdk->layout_helper());
276 address src = (address) sa->value_at_addr(src_pos, fsk->layout_helper());
277 for (int i = 0; i < length; i++) {
278 // because source and destination have the same layout, bypassing the InlineKlass copy methods
279 // and call AccessAPI directly
280 HeapAccess<>::value_copy(src, dst, vk, fsk->layout_kind());
281 dst += dst_incr;
282 src += src_incr;
283 }
284 }
285 } else {
286 flatArrayHandle hd(THREAD, da);
287 flatArrayHandle hs(THREAD, sa);
288 // source and destination layouts mismatch, simpler solution is to copy through an intermediate buffer (heap instance)
289 bool need_null_check = fsk->layout_kind() == LayoutKind::NULLABLE_ATOMIC_FLAT && fdk->layout_kind() != LayoutKind::NULLABLE_ATOMIC_FLAT;
290 oop buffer = vk->allocate_instance(CHECK);
291 address dst = (address) hd->value_at_addr(dst_pos, fdk->layout_helper());
292 address src = (address) hs->value_at_addr(src_pos, fsk->layout_helper());
293 for (int i = 0; i < length; i++) {
294 if (need_null_check) {
295 if (vk->is_payload_marked_as_null(src)) {
296 THROW(vmSymbols::java_lang_NullPointerException());
297 }
298 }
299 vk->copy_payload_to_addr(src, vk->payload_addr(buffer), fsk->layout_kind(), true);
300 if (vk->has_nullable_atomic_layout()) {
301 // Setting null marker to not zero for non-nullable source layouts
302 vk->mark_payload_as_non_null(vk->payload_addr(buffer));
303 }
304 vk->copy_payload_to_addr(vk->payload_addr(buffer), dst, fdk->layout_kind(), true);
305 dst += dst_incr;
306 src += src_incr;
307 }
308 }
309 } else { // flatArray-to-objArray
310 assert(dk->is_refArray_klass(), "Expected objArray here");
311 // Need to allocate each new src elem payload -> dst oop
312 objArrayHandle dh(THREAD, (objArrayOop)d);
313 flatArrayHandle sh(THREAD, sa);
314 InlineKlass* vk = InlineKlass::cast(s_elem_klass);
315 for (int i = 0; i < length; i++) {
316 oop o = sh->obj_at(src_pos + i, CHECK);
317 dh->obj_at_put(dst_pos + i, o);
318 }
319 }
320 } else {
321 assert(s->is_objArray(), "Expected objArray");
322 objArrayOop sa = objArrayOop(s);
323 assert(d->is_flatArray(), "Expected flatArray"); // objArray-to-flatArray
324 InlineKlass* d_elem_vklass = InlineKlass::cast(d_elem_klass);
325 flatArrayOop da = flatArrayOop(d);
326 FlatArrayKlass* fdk = FlatArrayKlass::cast(da->klass());
327 InlineKlass* vk = InlineKlass::cast(d_elem_klass);
328
329 for (int i = 0; i < length; i++) {
330 da->obj_at_put( dst_pos + i, sa->obj_at(src_pos + i), CHECK);
331 }
332 }
333 }
334
335 ModuleEntry* FlatArrayKlass::module() const {
336 assert(element_klass() != nullptr, "FlatArrayKlass returned unexpected nullptr bottom_klass");
337 // The array is defined in the module of its bottom class
338 return element_klass()->module();
339 }
340
341 PackageEntry* FlatArrayKlass::package() const {
342 assert(element_klass() != nullptr, "FlatArrayKlass returned unexpected nullptr bottom_klass");
343 return element_klass()->package();
344 }
345
346 bool FlatArrayKlass::can_be_primary_super_slow() const {
347 return true;
348 }
349
350 GrowableArray<Klass*>* FlatArrayKlass::compute_secondary_supers(int num_extra_slots,
351 Array<InstanceKlass*>* transitive_interfaces) {
352 assert(transitive_interfaces == nullptr, "sanity");
353 // interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... };
354 Array<Klass*>* elem_supers = element_klass()->secondary_supers();
355 int num_elem_supers = elem_supers == nullptr ? 0 : elem_supers->length();
356 int num_secondaries = num_extra_slots + 2 + num_elem_supers;
357 GrowableArray<Klass*>* secondaries = new GrowableArray<Klass*>(num_elem_supers+2);
358
359 secondaries->push(vmClasses::Cloneable_klass());
360 secondaries->push(vmClasses::Serializable_klass());
361 for (int i = 0; i < num_elem_supers; i++) {
362 Klass* elem_super = (Klass*) elem_supers->at(i);
363 Klass* array_super = elem_super->array_klass_or_null();
364 assert(array_super != nullptr, "must already have been created");
365 secondaries->push(array_super);
366 }
367 return secondaries;
368 }
369
370 u2 FlatArrayKlass::compute_modifier_flags() const {
371 // The modifier for an flatArray is the same as its element
372 // With the addition of ACC_IDENTITY
373 u2 element_flags = element_klass()->compute_modifier_flags();
374
375 u2 identity_flag = (Arguments::enable_preview()) ? JVM_ACC_IDENTITY : 0;
376
377 return (element_flags & (JVM_ACC_PUBLIC | JVM_ACC_PRIVATE | JVM_ACC_PROTECTED))
378 | (identity_flag | JVM_ACC_ABSTRACT | JVM_ACC_FINAL);
379 }
380
381 void FlatArrayKlass::print_on(outputStream* st) const {
382 #ifndef PRODUCT
383 assert(!is_refArray_klass(), "Unimplemented");
384
385 st->print("Flat Type Array: ");
386 Klass::print_on(st);
387
388 st->print(" - element klass: ");
389 element_klass()->print_value_on(st);
390 st->cr();
391
392 int elem_size = element_byte_size();
393 st->print(" - element size %i ", elem_size);
394 st->print("aligned layout size %i", 1 << layout_helper_log2_element_size(layout_helper()));
395 st->cr();
396 #endif //PRODUCT
397 }
398
399 void FlatArrayKlass::print_value_on(outputStream* st) const {
400 assert(is_klass(), "must be klass");
401
402 element_klass()->print_value_on(st);
403 st->print("[]");
404 }
405
406
407 #ifndef PRODUCT
408 void FlatArrayKlass::oop_print_on(oop obj, outputStream* st) {
409 ArrayKlass::oop_print_on(obj, st);
410 flatArrayOop va = flatArrayOop(obj);
411 InlineKlass* vk = element_klass();
412 int print_len = MIN2(va->length(), MaxElementPrintSize);
413 for(int index = 0; index < print_len; index++) {
414 int off = (address) va->value_at_addr(index, layout_helper()) - cast_from_oop<address>(obj);
415 st->print_cr(" - Index %3d offset %3d: ", index, off);
416 oop obj = cast_to_oop((address)va->value_at_addr(index, layout_helper()) - vk->payload_offset());
417 FieldPrinter print_field(st, obj);
418 vk->do_nonstatic_fields(&print_field);
419 st->cr();
420 }
421 int remaining = va->length() - print_len;
422 if (remaining > 0) {
423 st->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining);
424 }
425 }
426 #endif //PRODUCT
427
428 void FlatArrayKlass::oop_print_value_on(oop obj, outputStream* st) {
429 assert(obj->is_flatArray(), "must be flatArray");
430 st->print("a ");
431 element_klass()->print_value_on(st);
432 int len = flatArrayOop(obj)->length();
433 st->print("[%d] ", len);
434 obj->print_address_on(st);
435 if (PrintMiscellaneous && (WizardMode || Verbose)) {
436 int lh = layout_helper();
437 st->print("{");
438 for (int i = 0; i < len; i++) {
439 if (i > 4) {
440 st->print("..."); break;
441 }
442 st->print(" " INTPTR_FORMAT, (intptr_t)(void*)flatArrayOop(obj)->value_at_addr(i , lh));
443 }
444 st->print(" }");
445 }
446 }
447
448 // Verification
449 class VerifyElementClosure: public BasicOopIterateClosure {
450 public:
451 virtual void do_oop(oop* p) { VerifyOopClosure::verify_oop.do_oop(p); }
452 virtual void do_oop(narrowOop* p) { VerifyOopClosure::verify_oop.do_oop(p); }
453 };
454
455 void FlatArrayKlass::oop_verify_on(oop obj, outputStream* st) {
456 ArrayKlass::oop_verify_on(obj, st);
457 guarantee(obj->is_flatArray(), "must be flatArray");
458
459 if (contains_oops()) {
460 flatArrayOop va = flatArrayOop(obj);
461 VerifyElementClosure ec;
462 va->oop_iterate(&ec);
463 }
464 }
465
466 void FlatArrayKlass::verify_on(outputStream* st) {
467 ArrayKlass::verify_on(st);
468 guarantee(element_klass()->is_inline_klass(), "should be inline type klass");
469 }