8378519: [lworld] Fold fieldDescriptor / ResolvedFieldEntry checks into the FlatFieldPayload constructor

Reviewed-by: fparain

Author: xmas92

src/hotspot/share/interpreter/interpreterRuntime.cpp

@@ -234,14 +234,6 @@ JRT_END
 
 JRT_BLOCK_ENTRY(void, InterpreterRuntime::read_flat_field(JavaThread* current, oopDesc* obj, ResolvedFieldEntry* entry))
   assert(oopDesc::is_oop(obj), "Sanity check");
-#ifdef ASSERT
-  InstanceKlass* holder = InstanceKlass::cast(entry->field_holder());
-  assert(entry->field_holder()->field_is_flat(entry->field_index()), "Sanity check");
-  fieldDescriptor fd;
-  bool found = holder->find_field_from_offset(entry->field_offset(), false, &fd);
-  assert(found, "Field not found");
-  assert(fd.is_flat(), "Field must be flat");
-#endif // ASSERT
 
   FlatFieldPayload payload(instanceOop(obj), entry);
   if (payload.is_payload_null()) {

src/hotspot/share/oops/flatArrayKlass.hpp

@@ -59,8 +59,13 @@ class FlatArrayKlass : public ObjArrayKlass {
 
   // Casting from Klass*
   static FlatArrayKlass* cast(Klass* k) {
+    return const_cast<FlatArrayKlass*>(cast(const_cast<const Klass*>(k)));
+  }
+
+  static const FlatArrayKlass* cast(const Klass* k) {
+    assert(k != nullptr, "k should not be null");
     assert(k->is_flatArray_klass(), "cast to FlatArrayKlass");
-    return (FlatArrayKlass*) k;
+    return static_cast<const FlatArrayKlass*>(k);
   }
 
   // klass allocation

src/hotspot/share/oops/instanceKlass.cpp

@@ -70,6 +70,7 @@
 #include "oops/instanceOop.hpp"
 #include "oops/instanceStackChunkKlass.hpp"
 #include "oops/klass.inline.hpp"
+#include "oops/layoutKind.hpp"
 #include "oops/markWord.hpp"
 #include "oops/method.hpp"
 #include "oops/oop.inline.hpp"
@@ -100,6 +101,7 @@
 #include "utilities/events.hpp"
 #include "utilities/macros.hpp"
 #include "utilities/nativeStackPrinter.hpp"
+#include "utilities/ostream.hpp"
 #include "utilities/stringUtils.hpp"
 #ifdef COMPILER1
 #include "c1/c1_Compiler.hpp"
@@ -157,6 +159,25 @@ void InlineLayoutInfo::metaspace_pointers_do(MetaspaceClosure* it) {
   it->push(&_klass);
 }
 
+void InlineLayoutInfo::print() const {
+  print_on(tty);
+}
+
+void InlineLayoutInfo::print_on(outputStream* st) const {
+  st->print_cr("_klass: " PTR_FORMAT, p2i(_klass));
+  if (_klass != nullptr) {
+    StreamIndentor si(st);
+    _klass->print_on(st);
+    st->cr();
+  }
+
+  st->print("_layout: ");
+  LayoutKindHelper::print_on(_kind, st);
+  st->cr();
+
+  st->print("_null_marker_offset: %d", _null_marker_offset);
+}
+
 bool InstanceKlass::_finalization_enabled = true;
 
 static inline bool is_class_loader(const Symbol* class_name,
@@ -2177,7 +2198,6 @@ bool InstanceKlass::find_local_field_from_offset(int offset, bool is_static, fie
   return false;
 }
 
-
 bool InstanceKlass::find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const {
   const InstanceKlass* klass = this;
   while (klass != nullptr) {
@@ -2189,6 +2209,45 @@ bool InstanceKlass::find_field_from_offset(int offset, bool is_static, fieldDesc
   return false;
 }
 
+bool InstanceKlass::find_local_flat_field_containing_offset(int offset, fieldDescriptor* fd) const {
+  for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
+    if (!fs.is_flat()) {
+      continue;
+    }
+
+    if (fs.offset() > offset) {
+      continue;
+    }
+
+    const int offset_in_flat_field = offset - fs.offset();
+    const InlineLayoutInfo layout_info = inline_layout_info(fs.index());
+    const int field_size = layout_info.klass()->layout_size_in_bytes(layout_info.kind());
+
+    assert(LayoutKindHelper::is_flat(layout_info.kind()), "Must be flat");
+
+    if (offset_in_flat_field < field_size) {
+      fd->reinitialize(const_cast<InstanceKlass*>(this), fs.to_FieldInfo());
+      assert(!fd->is_static(), "Static fields are not flattened");
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool InstanceKlass::find_flat_field_containing_offset(int offset, fieldDescriptor* fd) const {
+  const InstanceKlass* klass = this;
+  while (klass != nullptr) {
+    if (klass->find_local_flat_field_containing_offset(offset, fd)) {
+      return true;
+    }
+
+    klass = klass->super();
+  }
+
+  return false;
+}
 
 void InstanceKlass::methods_do(void f(Method* method)) {
   // Methods aren't stable until they are loaded.  This can be read outside

src/hotspot/share/oops/instanceKlass.hpp

@@ -169,6 +169,10 @@ class InlineLayoutInfo : public MetaspaceObj {
 
   static ByteSize klass_offset() { return byte_offset_of(InlineLayoutInfo, _klass); }
   static ByteSize null_marker_offset_offset() { return byte_offset_of(InlineLayoutInfo, _null_marker_offset); }
+
+  // Print
+  void print() const;
+  void print_on(outputStream* st) const;
 };
 
 class InstanceKlass: public Klass {
@@ -689,6 +693,9 @@ class InstanceKlass: public Klass {
   bool find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const;
   bool find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const;
 
+  bool find_local_flat_field_containing_offset(int offset, fieldDescriptor* fd) const;
+  bool find_flat_field_containing_offset(int offset, fieldDescriptor* fd) const;
+
  private:
   inline static int quick_search(const Array<Method*>* methods, const Symbol* name);
 

src/hotspot/share/oops/valuePayload.hpp

@@ -121,8 +121,10 @@ class ValuePayload {
   inline oop& container();
   inline oop container() const;
 
-private:
   inline void print_on(outputStream* st) const NOT_DEBUG_RETURN;
+
+private:
+  inline void assert_is_flat_field(const InstanceKlass* klass, int offset) const NOT_DEBUG_RETURN;
   inline void assert_post_construction_invariants() const NOT_DEBUG_RETURN;
   static inline void assert_pre_copy_invariants(const ValuePayload& src,
                                                 const ValuePayload& dst,
@@ -221,6 +223,13 @@ class FlatFieldPayload : public FlatValuePayload {
                           ptrdiff_t offset,
                           InlineLayoutInfo* inline_layout_info);
 
+  inline void assert_post_construction_invariants(instanceOop container,
+                                                  ResolvedFieldEntry* resolved_field_entry,
+                                                  InstanceKlass* klass) const NOT_DEBUG_RETURN;
+  inline void assert_post_construction_invariants(instanceOop container,
+                                                  fieldDescriptor* field_descriptor,
+                                                  InstanceKlass* klass) const NOT_DEBUG_RETURN;
+
 public:
   FlatFieldPayload() = default;
 

src/hotspot/share/oops/valuePayload.inline.hpp

@@ -275,6 +275,47 @@ inline void ValuePayload::print_on(outputStream* st) const {
   }
 }
 
+inline void ValuePayload::assert_is_flat_field(const InstanceKlass* klass, int offset) const {
+  OnVMError on_assertion_failure_field_descriptor([&](outputStream* st) {
+    st->print_cr("=== assert_is_flat_field(" PTR_FORMAT ", %d) failure ===", p2i(klass), offset);
+    StreamIndentor si(st);
+    if (klass != nullptr) {
+      klass->print_on(st);
+      st->cr();
+    }
+  });
+
+  fieldDescriptor field_descriptor;
+  postcond(klass->find_flat_field_containing_offset(offset, &field_descriptor));
+
+  const InlineLayoutInfo inline_layout_info = field_descriptor.field_holder()->inline_layout_info(field_descriptor.index());
+
+  OnVMError on_assertion_failure_inline_layout_info([&](outputStream* st) {
+    st->print_cr("=== assert_is_flat_field(" PTR_FORMAT ", %d) failure ===", p2i(klass), offset);
+      StreamIndentor si(st);
+      st->print("field_descriptor: ");
+      field_descriptor.print_on(st);
+      st->cr();
+      st->print("inline_layout_info: ");
+      inline_layout_info.print_on(st);
+      st->cr();
+  });
+
+  if (inline_layout_info.klass() == this->klass()) {
+    // Found the field in klass
+    postcond(offset == field_descriptor.offset());
+    postcond(inline_layout_info.kind() == layout_kind());
+    postcond(field_descriptor.layout_kind() == layout_kind());
+    postcond(field_descriptor.is_flat());
+  } else {
+    // Nested flat field
+    postcond(offset >= field_descriptor.offset());
+    const InlineKlass* const field_klass = inline_layout_info.klass();
+    const int payload_offset = field_klass->payload_offset();
+    assert_is_flat_field(field_klass, offset - field_descriptor.offset() + payload_offset);
+  }
+}
+
 inline void ValuePayload::assert_post_construction_invariants() const {
   OnVMError on_assertion_failure([&](outputStream* st) {
     st->print_cr("=== assert_post_construction_invariants failure ===");
@@ -283,12 +324,38 @@ inline void ValuePayload::assert_post_construction_invariants() const {
     st->cr();
   });
 
-  postcond(uses_absolute_addr() || container() != nullptr);
   postcond(layout_kind() != LayoutKind::REFERENCE);
   postcond(layout_kind() != LayoutKind::UNKNOWN);
   postcond(klass()->is_layout_supported(layout_kind()));
-  postcond(uses_absolute_addr() || (container()->klass() == klass()) ==
-                                    (layout_kind() == LayoutKind::BUFFERED));
+
+  if (!uses_absolute_addr()) {
+    postcond(container() != nullptr);
+    const Klass* const container_klass = container()->klass();
+    if (container_klass == klass()) {
+      postcond(layout_kind() == LayoutKind::BUFFERED);
+    } else {
+      postcond(layout_kind() != LayoutKind::BUFFERED);
+      if (container_klass->is_mirror_instance_klass()) {
+        fatal("java.lang.Class has no flat fields. Static fields are not flattened");
+      } else if (container_klass->is_instance_klass()) {
+        assert_is_flat_field(InstanceKlass::cast(container_klass), checked_cast<int>(offset()));
+      } else {
+        const FlatArrayKlass* const container_flat_array_klass = FlatArrayKlass::cast(container_klass);
+        if (container_flat_array_klass->element_klass() == klass()) {
+          postcond(container_flat_array_klass->layout_kind() == layout_kind());
+        } else {
+          // Accessing nested flat field
+          const InlineKlass* const element_klass = container_flat_array_klass->element_klass();
+          const int element_offset =
+              (checked_cast<int>(this->offset()) -
+               checked_cast<int>(flatArrayOopDesc::base_offset_in_bytes())) %
+              container_flat_array_klass->element_byte_size();
+          const int payload_offset = element_klass->payload_offset();
+          assert_is_flat_field(element_klass, element_offset + payload_offset);
+        }
+      }
+    }
+  }
 }
 
 inline void ValuePayload::assert_pre_copy_invariants(const ValuePayload& src,
@@ -525,6 +592,40 @@ inline FlatFieldPayload::FlatFieldPayload(instanceOop container,
                                           InlineLayoutInfo* inline_layout_info)
     : FlatValuePayload(container, offset, inline_layout_info->klass(), inline_layout_info->kind()) {}
 
+#ifdef ASSERT
+
+inline void FlatFieldPayload::assert_post_construction_invariants(instanceOop container,
+                                                                  ResolvedFieldEntry* resolved_field_entry,
+                                                                  InstanceKlass* klass) const {
+  OnVMError on_assertion_failure([&](outputStream* st) {
+    st->print_cr("=== assert_post_construction_invariants failure ===");
+    StreamIndentor si(st);
+    print_on(st);
+    st->cr();
+  });
+
+  postcond(container->klass()->is_subclass_of(klass));
+  postcond(klass == resolved_field_entry->field_holder());
+  postcond(resolved_field_entry->is_flat());
+}
+
+inline void FlatFieldPayload::assert_post_construction_invariants(instanceOop container,
+                                                                  fieldDescriptor* field_descriptor,
+                                                                  InstanceKlass* klass) const {
+  OnVMError on_assertion_failure([&](outputStream* st) {
+    st->print_cr("=== assert_post_construction_invariants failure ===");
+    StreamIndentor si(st);
+    print_on(st);
+    st->cr();
+  });
+
+  postcond(container->klass()->is_subclass_of(klass));
+  postcond(klass == field_descriptor->field_holder());
+  postcond(field_descriptor->is_flat());
+}
+
+#endif // ASSERT
+
 inline FlatFieldPayload::FlatFieldPayload(instanceOop container,
                                           fieldDescriptor* field_descriptor)
     : FlatFieldPayload(container, field_descriptor,
@@ -536,7 +637,7 @@ inline FlatFieldPayload::FlatFieldPayload(instanceOop container,
     : FlatFieldPayload(container,
                        field_descriptor->offset(),
                        klass->inline_layout_info_adr(field_descriptor->index())) {
-  postcond(container->klass() == klass);
+  assert_post_construction_invariants(container, field_descriptor, klass);
 }
 
 inline FlatFieldPayload::FlatFieldPayload(instanceOop container,
@@ -551,7 +652,7 @@ inline FlatFieldPayload::FlatFieldPayload(instanceOop container,
     : FlatFieldPayload(container,
                        resolved_field_entry->field_offset(),
                        klass->inline_layout_info_adr(resolved_field_entry->field_index())) {
-  postcond(container->klass()->is_subclass_of(klass));
+  assert_post_construction_invariants(container, resolved_field_entry, klass);
 }
 
 inline instanceOop FlatFieldPayload::container() const {

src/hotspot/share/prims/jni.cpp

@@ -1931,7 +1931,8 @@ JNI_ENTRY_NO_PRESERVE(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldI
     assert(k->is_instance_klass(), "Only instances can have flat fields");
     InstanceKlass* ik = InstanceKlass::cast(k);
     fieldDescriptor fd;
-    ik->find_field_from_offset(offset, false, &fd);
+    bool found = ik->find_field_from_offset(offset, false, &fd);
+    assert(found, "Field not found");
     FlatFieldPayload payload(instanceOop(o), &fd);
     payload.write(inlineOop(JNIHandles::resolve(value)), CHECK);
   }