8366973: [lworld] Deopt/recompilation cycle due to call to method with unloaded return type

Author: TobiHartmann

src/hotspot/cpu/aarch64/aarch64.ad

@@ -3707,7 +3707,7 @@ encode %{
       // Check that stack depth is unchanged: find majik cookie on stack
       __ call_Unimplemented();
     }
-    if (tf()->returns_inline_type_as_fields() && !_method->is_method_handle_intrinsic()) {
+    if (tf()->returns_inline_type_as_fields() && !_method->is_method_handle_intrinsic() && _method->return_type()->is_loaded()) {
       // The last return value is not set by the callee but used to pass the null marker to compiled code.
       // Search for the corresponding projection, get the register and emit code that initialized it.
       uint con = (tf()->range_cc()->cnt() - 1);

src/hotspot/cpu/x86/x86.ad

@@ -2718,7 +2718,7 @@ encode %{
       __ int3();
       __ bind(L);
     }
-    if (tf()->returns_inline_type_as_fields() && !_method->is_method_handle_intrinsic()) {
+    if (tf()->returns_inline_type_as_fields() && !_method->is_method_handle_intrinsic() && _method->return_type()->is_loaded()) {
       // The last return value is not set by the callee but used to pass the null marker to compiled code.
       // Search for the corresponding projection, get the register and emit code that initialized it.
       uint con = (tf()->range_cc()->cnt() - 1);

src/hotspot/share/ci/ciTypeFlow.cpp

@@ -763,17 +763,7 @@ void ciTypeFlow::StateVector::do_invoke(ciBytecodeStream* str,
         // ever sees a non-null value, loading has occurred.
         //
         // See do_getstatic() for similar explanation, as well as bug 4684993.
-        if (InlineTypeReturnedAsFields) {
-          // Return might be in scalarized form but we can't handle it because we
-          // don't know the type. This can happen due to a missing preload attribute.
-          // TODO 8284443 Use PhaseMacroExpand::expand_mh_intrinsic_return for this
-          trap(str, nullptr,
-               Deoptimization::make_trap_request
-               (Deoptimization::Reason_uninitialized,
-                Deoptimization::Action_reinterpret));
-        } else {
-          do_null_assert(return_type->as_klass());
-        }
+        do_null_assert(return_type->as_klass());
       } else {
         push_translate(return_type);
       }

src/hotspot/share/classfile/classFileParser.cpp

@@ -6173,7 +6173,7 @@ void ClassFileParser::post_process_parsed_stream(const ClassFileStream* const st
           THROW_MSG(vmSymbols::java_lang_ClassCircularityError(),
                     err_msg("Class %s cannot have a null-free non-static field of its own type", _class_name->as_C_string()));
         }
-        log_info(class, preload)("Preloading class %s during loading of class %s. "
+        log_info(class, preload)("Preloading of class %s during loading of class %s. "
                                   "Cause: a null-free non-static field is declared with this type",
                                   s->as_C_string(), _class_name->as_C_string());
         InstanceKlass* klass = SystemDictionary::resolve_with_circularity_detection_or_fail(_class_name, s,
@@ -6194,12 +6194,12 @@ void ClassFileParser::post_process_parsed_stream(const ClassFileStream* const st
         log_info(class, preload)("Preloading of class %s during loading of class %s "
                                  "(cause: null-free non-static field) succeeded",
                                  s->as_C_string(), _class_name->as_C_string());
-      } else if (Signature::has_envelope(sig)) {
+      } else if (Signature::has_envelope(sig) && PreloadClasses) {
         // Preloading classes for nullable fields that are listed in the LoadableDescriptors attribute
         // Those classes would be required later for the flattening of nullable inline type fields
         TempNewSymbol name = Signature::strip_envelope(sig);
         if (name != _class_name && is_class_in_loadable_descriptors_attribute(sig)) {
-          log_info(class, preload)("Preloading class %s during loading of class %s. "
+          log_info(class, preload)("Preloading of class %s during loading of class %s. "
                                    "Cause: field type in LoadableDescriptors attribute",
                                    name->as_C_string(), _class_name->as_C_string());
           oop loader = loader_data()->class_loader();
@@ -6214,7 +6214,7 @@ void ClassFileParser::post_process_parsed_stream(const ClassFileStream* const st
                                        name->as_C_string(), _class_name->as_C_string());
             } else {
               // Non value class are allowed by the current spec, but it could be an indication of an issue so let's log a warning
-              log_warning(class, preload)("Preloading class %s during loading of class %s "
+              log_warning(class, preload)("Preloading of class %s during loading of class %s "
                                           "(cause: field type in LoadableDescriptors attribute) but loaded class is not a value class",
                                           name->as_C_string(), _class_name->as_C_string());
             }

src/hotspot/share/classfile/systemDictionary.cpp

@@ -1101,7 +1101,7 @@ bool SystemDictionary::check_shared_class_super_types(InstanceKlass* ik, Handle
 // Some pre-loading does not fail fatally
 bool SystemDictionary::preload_from_null_free_field(InstanceKlass* ik, Handle class_loader, Symbol* sig, int field_index, TRAPS) {
   TempNewSymbol name = Signature::strip_envelope(sig);
-  log_info(class, preload)("Preloading class %s during loading of shared class %s. "
+  log_info(class, preload)("Preloading of class %s during loading of shared class %s. "
                            "Cause: a null-free non-static field is declared with this type",
                            name->as_C_string(), ik->name()->as_C_string());
   InstanceKlass* real_k = SystemDictionary::resolve_with_circularity_detection_or_fail(ik->name(), name,
@@ -1139,7 +1139,7 @@ bool SystemDictionary::preload_from_null_free_field(InstanceKlass* ik, Handle cl
 void SystemDictionary::try_preload_from_loadable_descriptors(InstanceKlass* ik, Handle class_loader, Symbol* sig, int field_index, TRAPS) {
   TempNewSymbol name = Signature::strip_envelope(sig);
   if (name != ik->name() && ik->is_class_in_loadable_descriptors_attribute(sig)) {
-    log_info(class, preload)("Preloading class %s during loading of shared class %s. "
+    log_info(class, preload)("Preloading of class %s during loading of shared class %s. "
                              "Cause: field type in LoadableDescriptors attribute",
                              name->as_C_string(), ik->name()->as_C_string());
     InstanceKlass* real_k = SystemDictionary::resolve_with_circularity_detection_or_fail(ik->name(), name,

src/hotspot/share/oops/inlineKlass.cpp

@@ -596,7 +596,7 @@ oop InlineKlass::realloc_result(const RegisterMap& reg_map, const GrowableArray<
 // Check if we return an inline type in scalarized form, i.e. check if either
 // - The return value is a tagged InlineKlass pointer, or
 // - The return value is an inline type oop that is also returned in scalarized form
-InlineKlass* InlineKlass::returned_inline_klass(const RegisterMap& map, bool* return_oop) {
+InlineKlass* InlineKlass::returned_inline_klass(const RegisterMap& map, bool* return_oop, Method* method) {
   BasicType bt = T_METADATA;
   VMRegPair pair;
   int nb = SharedRuntime::java_return_convention(&bt, &pair, 1);
@@ -619,12 +619,13 @@ InlineKlass* InlineKlass::returned_inline_klass(const RegisterMap& map, bool* re
   // Return value is not tagged, must be a valid oop
   oop o = cast_to_oop(ptr);
   assert(oopDesc::is_oop_or_null(o, true), "Bad oop return: " PTR_FORMAT, ptr);
-  if (return_oop != nullptr && o != nullptr) {
+  if (return_oop != nullptr && o != nullptr && o->is_inline_type()) {
     // Check if inline type is also returned in scalarized form
-    assert(o->is_inline_type(), "Invalid return value");
-    InlineKlass* vk = InlineKlass::cast(o->klass());
-    if (vk->can_be_returned_as_fields()) {
-      return vk;
+    InlineKlass* vk_val = InlineKlass::cast(o->klass());
+    InlineKlass* vk_sig = method->returns_inline_type();
+    if (vk_val->can_be_returned_as_fields() && vk_sig != nullptr) {
+      assert(vk_val == vk_sig, "Unexpected return value");
+      return vk_val;
     }
   }
   return nullptr;

src/hotspot/share/oops/inlineKlass.hpp

@@ -254,7 +254,7 @@ class InlineKlass: public InstanceKlass {
   void save_oop_fields(const RegisterMap& map, GrowableArray<Handle>& handles) const;
   void restore_oop_results(RegisterMap& map, GrowableArray<Handle>& handles) const;
   oop realloc_result(const RegisterMap& reg_map, const GrowableArray<Handle>& handles, TRAPS);
-  static InlineKlass* returned_inline_klass(const RegisterMap& reg_map, bool* return_oop = nullptr);
+  static InlineKlass* returned_inline_klass(const RegisterMap& reg_map, bool* return_oop = nullptr, Method* method = nullptr);
 
   address pack_handler() const {
     return *(address*)adr_pack_handler();

src/hotspot/share/oops/instanceKlass.cpp

@@ -1067,7 +1067,7 @@ bool InstanceKlass::link_class_impl(TRAPS) {
         Symbol* sig = fs.signature();
         TempNewSymbol s = Signature::strip_envelope(sig);
         if (s != name()) {
-          log_info(class, preload)("Preloading class %s during linking of class %s. Cause: a null-free static field is declared with this type", s->as_C_string(), name()->as_C_string());
+          log_info(class, preload)("Preloading of class %s during linking of class %s. Cause: a null-free static field is declared with this type", s->as_C_string(), name()->as_C_string());
           Klass* klass = SystemDictionary::resolve_or_fail(s,
                                                           Handle(THREAD, class_loader()), true,
                                                           CHECK_false);
@@ -1110,14 +1110,14 @@ bool InstanceKlass::link_class_impl(TRAPS) {
     }
 
     // Aggressively preloading all classes from the LoadableDescriptors attribute
-    if (loadable_descriptors() != nullptr) {
+    if (loadable_descriptors() != nullptr && PreloadClasses) {
       HandleMark hm(THREAD);
       for (int i = 0; i < loadable_descriptors()->length(); i++) {
         Symbol* sig = constants()->symbol_at(loadable_descriptors()->at(i));
         if (!Signature::has_envelope(sig)) continue;
         TempNewSymbol class_name = Signature::strip_envelope(sig);
         if (class_name == name()) continue;
-        log_info(class, preload)("Preloading class %s during linking of class %s because of the class is listed in the LoadableDescriptors attribute", sig->as_C_string(), name()->as_C_string());
+        log_info(class, preload)("Preloading of class %s during linking of class %s because of the class is listed in the LoadableDescriptors attribute", sig->as_C_string(), name()->as_C_string());
         oop loader = class_loader();
         Klass* klass = SystemDictionary::resolve_or_null(class_name,
                                                          Handle(THREAD, loader), THREAD);
@@ -1128,7 +1128,7 @@ bool InstanceKlass::link_class_impl(TRAPS) {
           log_info(class, preload)("Preloading of class %s during linking of class %s (cause: LoadableDescriptors attribute) succeeded", class_name->as_C_string(), name()->as_C_string());
           if (!klass->is_inline_klass()) {
             // Non value class are allowed by the current spec, but it could be an indication of an issue so let's log a warning
-              log_warning(class, preload)("Preloading class %s during linking of class %s (cause: LoadableDescriptors attribute) but loaded class is not a value class", class_name->as_C_string(), name()->as_C_string());
+            log_warning(class, preload)("Preloading of class %s during linking of class %s (cause: LoadableDescriptors attribute) but loaded class is not a value class", class_name->as_C_string(), name()->as_C_string());
           }
         } else {
           log_warning(class, preload)("Preloading of class %s during linking of class %s (cause: LoadableDescriptors attribute) failed", class_name->as_C_string(), name()->as_C_string());

src/hotspot/share/oops/method.cpp

@@ -737,16 +737,14 @@ int Method::extra_stack_words() {
 // InlineKlass the method is declared to return. This must not
 // safepoint as it is called with references live on the stack at
 // locations the GC is unaware of.
-InlineKlass* Method::returns_inline_type(Thread* thread) const {
+InlineKlass* Method::returns_inline_type() const {
   assert(InlineTypeReturnedAsFields, "Inline types should never be returned as fields");
   if (is_native()) {
     return nullptr;
   }
   NoSafepointVerifier nsv;
   SignatureStream ss(signature());
-  while (!ss.at_return_type()) {
-    ss.next();
-  }
+  ss.skip_to_return_type();
   return ss.as_inline_klass(method_holder());
 }
 
@@ -1313,7 +1311,7 @@ void Method::link_method(const methodHandle& h_method, TRAPS) {
       SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),
       !native_bind_event_is_interesting);
   }
-  if (InlineTypeReturnedAsFields && returns_inline_type(THREAD) && !has_scalarized_return()) {
+  if (InlineTypeReturnedAsFields && returns_inline_type() && !has_scalarized_return()) {
     set_has_scalarized_return();
   }
 

src/hotspot/share/oops/method.hpp

@@ -516,7 +516,7 @@ class Method : public Metadata {
   Symbol* klass_name() const;                    // returns the name of the method holder
   BasicType result_type() const                  { return constMethod()->result_type(); }
   bool is_returning_oop() const                  { BasicType r = result_type(); return is_reference_type(r); }
-  InlineKlass* returns_inline_type(Thread* thread) const;
+  InlineKlass* returns_inline_type() const;
 
   // Checked exceptions thrown by this method (resolved to mirrors)
   objArrayHandle resolved_checked_exceptions(TRAPS) { return resolved_checked_exceptions_impl(this, THREAD); }