From 5cd35b5dc7ffd41a82845b8d64000a9dda3580aa Mon Sep 17 00:00:00 2001 From: Marc Chevalier Date: Thu, 9 Jul 2026 12:07:25 +0200 Subject: [PATCH] Trying --- src/hotspot/share/ci/ciInstanceKlass.cpp | 45 ++++++++++++++------ src/hotspot/share/ci/ciReplay.cpp | 54 +++++++++++++++--------- src/hotspot/share/memory/oopFactory.cpp | 2 +- 3 files changed, 69 insertions(+), 32 deletions(-) diff --git a/src/hotspot/share/ci/ciInstanceKlass.cpp b/src/hotspot/share/ci/ciInstanceKlass.cpp index 41adc7de96b..353bba95bed 100644 --- a/src/hotspot/share/ci/ciInstanceKlass.cpp +++ b/src/hotspot/share/ci/ciInstanceKlass.cpp @@ -863,8 +863,21 @@ void StaticFieldPrinter::do_field_helper(fieldDescriptor* fd, oop mirror, bool i break; } case T_ARRAY: // fall-through - case T_OBJECT: - if (!fd->is_null_free_inline_type()) { + case T_OBJECT: { + InstanceKlass* k = nullptr; + ResetNoHandleMark rnhm; + Thread* THREAD = Thread::current(); + SignatureStream ss(fd->signature(), false); + Symbol* name = ss.as_symbol(); + assert(!HAS_PENDING_EXCEPTION, "can resolve klass?"); + InstanceKlass* holder = fd->field_holder(); + if (field_type == T_OBJECT) { + k = SystemDictionary::find_instance_klass(THREAD, name, Handle(THREAD, holder->class_loader())); + // handling of null free inline type + guarantee(k != nullptr && !HAS_PENDING_EXCEPTION, "can resolve klass?"); + } + + if (k == nullptr || !k->is_inline_klass()) { _out->print("%s ", fd->signature()->as_quoted_ascii()); oop value = mirror->obj_field_acquire(fd->offset()); if (value == nullptr) { @@ -886,6 +899,23 @@ void StaticFieldPrinter::do_field_helper(fieldDescriptor* fd, oop mirror, bool i _out->print("%d", a->length()); if (value->is_objArray()) { objArrayOop oa = (objArrayOop)value; + if (value->is_flatArray()) { + FlatArrayKlass* klass = ((flatArrayOop)oa)->klass(); + LayoutKind lk = klass->layout_kind(); + _out->print(" flat"); + if (LayoutKindHelper::is_atomic_flat(lk)) { + _out->print(" atomic"); + } else { + _out->print(" non-atomic"); + } + if (LayoutKindHelper::is_nullable_flat(lk)) { + _out->print(" nullable"); + } else { + _out->print(" null-free"); + } + } else { + _out->print(" ref"); + } const char* klass_name = value->klass()->name()->as_quoted_ascii(); _out->print(" %s", klass_name); } @@ -894,16 +924,6 @@ void StaticFieldPrinter::do_field_helper(fieldDescriptor* fd, oop mirror, bool i } break; } else { - // handling of null free inline type - ResetNoHandleMark rnhm; - Thread* THREAD = Thread::current(); - SignatureStream ss(fd->signature(), false); - Symbol* name = ss.as_symbol(); - assert(!HAS_PENDING_EXCEPTION, "can resolve klass?"); - InstanceKlass* holder = fd->field_holder(); - InstanceKlass* k = SystemDictionary::find_instance_klass(THREAD, name, - Handle(THREAD, holder->class_loader())); - guarantee(k != nullptr && !HAS_PENDING_EXCEPTION, "can resolve klass?"); InlineKlass* vk = InlineKlass::cast(k); oop obj; if (is_flat) { @@ -916,6 +936,7 @@ void StaticFieldPrinter::do_field_helper(fieldDescriptor* fd, oop mirror, bool i vk->do_nonstatic_fields(&print_field); break; } + } default: ShouldNotReachHere(); } diff --git a/src/hotspot/share/ci/ciReplay.cpp b/src/hotspot/share/ci/ciReplay.cpp index be55687cca4..5de0e328931 100644 --- a/src/hotspot/share/ci/ciReplay.cpp +++ b/src/hotspot/share/ci/ciReplay.cpp @@ -515,14 +515,14 @@ class CompileReplay : public StackObj { } obj = ciReplay::obj_field(obj, field); // TODO 8350865 I think we need to handle null-free/flat arrays here - if (obj != nullptr && obj->is_refArray()) { - refArrayOop arr = oop_cast(obj); + if (obj != nullptr && obj->is_objArray()) { + objArrayOop arr = oop_cast(obj); int index = parse_int("index"); if (index >= arr->length()) { report_error("bad array index"); return nullptr; } - obj = arr->obj_at(index); + obj = arr->obj_at(index, THREAD); } } while (obj != nullptr); if (obj == nullptr) { @@ -1139,12 +1139,23 @@ class CompileReplay : public StackObj { value = oopFactory::new_longArray(length, CHECK_(true)); } else if (field_signature[0] == JVM_SIGNATURE_ARRAY && field_signature[1] == JVM_SIGNATURE_CLASS) { - Klass* actual_array_klass = parse_klass(CHECK_(true)); - // TODO 8350865 I think we need to handle null-free/flat arrays here - // This handling will change the array property argument passed to the - // factory below - Klass* kelem = ObjArrayKlass::cast(actual_array_klass)->element_klass(); - value = oopFactory::new_objArray(kelem, length, CHECK_(true)); + const char* flatness = parse_string(); + if (strcmp(flatness, "ref") == 0) { + Klass* actual_array_klass = parse_klass(CHECK_(true)); + Klass* kelem = ObjArrayKlass::cast(actual_array_klass)->element_klass(); + value = oopFactory::new_refArray(kelem, length, CHECK_(true)); + } else if (strcmp(flatness, "flat") == 0) { + const char* atomicity = parse_string(); + const char* nullability = parse_string(); + bool non_atomic = (strcmp(atomicity, "non-atomic") == 0); + bool null_restricted = (strcmp(nullability, "null-free") == 0); + Klass* actual_array_klass = parse_klass(CHECK_(true)); + Klass* kelem = ObjArrayKlass::cast(actual_array_klass)->element_klass(); + ArrayProperties props = ArrayProperties::Default().with_non_atomic(non_atomic).with_null_restricted(null_restricted); + value = oopFactory::new_flatArray(InlineKlass::cast(kelem), length, props, CHECK_(true)); + } else { + report_error("unrecognized array kind"); + } } else { report_error("unhandled array staticfield"); } @@ -1234,17 +1245,22 @@ class CompileReplay : public StackObj { const char* string_value = parse_escaped_string(); double value = atof(string_value); java_mirror->double_field_put(fd.offset(), value); - } else if (fd.is_null_free_inline_type()) { - Klass* kelem = resolve_klass(field_signature, CHECK); - InlineKlass* vk = InlineKlass::cast(kelem); - oop value = vk->allocate_instance(CHECK); - InlineTypeFieldInitializer init_fields(value, this); - vk->do_nonstatic_fields(&init_fields); - java_mirror->obj_field_put(fd.offset(), value); } else { - bool res = process_staticfield_reference(field_signature, java_mirror, &fd, CHECK); - if (!res) { - report_error("unhandled staticfield"); + Klass* kelem = nullptr; + if (fd.field_type() == T_OBJECT) { + kelem = resolve_klass(field_signature, CHECK); + } + if (kelem != nullptr && kelem->is_inline_klass()) { + InlineKlass* vk = InlineKlass::cast(kelem); + oop value = vk->allocate_instance(CHECK); + InlineTypeFieldInitializer init_fields(value, this); + vk->do_nonstatic_fields(&init_fields); + java_mirror->obj_field_put(fd.offset(), value); + } else { + bool res = process_staticfield_reference(field_signature, java_mirror, &fd, CHECK); + if (!res) { + report_error("unhandled staticfield"); + } } } } diff --git a/src/hotspot/share/memory/oopFactory.cpp b/src/hotspot/share/memory/oopFactory.cpp index d7fdffb6c32..c1f9f8dacc8 100644 --- a/src/hotspot/share/memory/oopFactory.cpp +++ b/src/hotspot/share/memory/oopFactory.cpp @@ -117,7 +117,7 @@ objArrayOop oopFactory::new_objArray(Klass* klass, int length, ArrayProperties p } objArrayOop oopFactory::new_objArray(Klass* klass, int length, TRAPS) { - return new_objArray(klass, length, ArrayProperties::Default(), THREAD); + return new_objArray(klass, length, ArrayProperties::Default(), THREAD); } refArrayOop oopFactory::new_refArray(Klass* klass, int length, ArrayProperties properties, TRAPS) {