src/hotspot/share/code/dependencies.hpp

@@ -112,10 +112,18 @@
      // method were used.  If it evolves (is replaced), the nmethod
      // must be recompiled.  No other dependencies are implied.
      evol_method,
      FIRST_TYPE = evol_method,
  
+     // This dependency means that some argument of this method was
+     // assumed to be always passed in scalarized form. In case of
+     // a mismatch with two super methods (one assuming scalarized
+     // and one assuming non-scalarized), all callers of this method
+     // (via virtual calls) now need to be recompiled.
+     // See CompiledEntrySignature::compute_calling_conventions
+     mismatch_calling_convention,
+ 
      // A context type CX is a leaf it if has no proper subtype.
      leaf_type,
  
      // An abstract class CX has exactly one concrete subtype CC.
      abstract_with_unique_concrete_subtype,

@@ -164,11 +172,11 @@
      all_types           = ((1 << TYPE_LIMIT) - 1) & ((~0u) << FIRST_TYPE),
  
      non_klass_types     = (1 << call_site_target_value),
      klass_types         = all_types & ~non_klass_types,
  
-     non_ctxk_types      = (1 << evol_method) | (1 << call_site_target_value),
+     non_ctxk_types      = (1 << evol_method) | (1 << mismatch_calling_convention) | (1 << call_site_target_value),
      implicit_ctxk_types = 0,
      explicit_ctxk_types = all_types & ~(non_ctxk_types | implicit_ctxk_types),
  
      max_arg_count = 4,   // current maximum number of arguments (incl. ctxk)
  

@@ -177,21 +185,25 @@
      // When present, it is one of the arguments (dep_context_arg).
      //
      // If a dependency does not have a context type, there is a
      // default context, depending on the type of the dependency.
      // This bit signals that a default context has been compressed away.
-     default_context_type_bit = (1<<LG2_TYPE_LIMIT)
+     default_context_type_bit = (1<<LG2_TYPE_LIMIT),
+ 
+     method_types = (1 << evol_method) | (1 << mismatch_calling_convention),
    };
  
    static const char* dep_name(DepType dept);
    static int         dep_args(DepType dept);
  
    static bool is_klass_type(           DepType dept) { return dept_in_mask(dept, klass_types        ); }
  
    static bool has_explicit_context_arg(DepType dept) { return dept_in_mask(dept, explicit_ctxk_types); }
    static bool has_implicit_context_arg(DepType dept) { return dept_in_mask(dept, implicit_ctxk_types); }
  
+   static bool has_method_dep(DepType dept) { return dept_in_mask(dept, method_types); }
+ 
    static int           dep_context_arg(DepType dept) { return has_explicit_context_arg(dept) ? 0 : -1; }
    static int  dep_implicit_context_arg(DepType dept) { return has_implicit_context_arg(dept) ? 0 : -1; }
  
    static void check_valid_dependency_type(DepType dept);
  

@@ -345,10 +357,11 @@
    void assert_common_4(DepType dept, ciKlass* ctxk, ciBaseObject* x1, ciBaseObject* x2, ciBaseObject* x3);
  
   public:
    // Adding assertions to a new dependency set at compile time:
    void assert_evol_method(ciMethod* m);
+   void assert_mismatch_calling_convention(ciMethod* m);
    void assert_leaf_type(ciKlass* ctxk);
    void assert_abstract_with_unique_concrete_subtype(ciKlass* ctxk, ciKlass* conck);
    void assert_unique_concrete_method(ciKlass* ctxk, ciMethod* uniqm);
    void assert_unique_concrete_method(ciKlass* ctxk, ciMethod* uniqm, ciKlass* resolved_klass, ciMethod* resolved_method);
    void assert_unique_implementor(ciInstanceKlass* ctxk, ciInstanceKlass* uniqk);

@@ -418,10 +431,11 @@
    // supposedly abstract class or method suddenly becomes concrete, a
    // dependency on it must fail.
  
    // Checking old assertions at run-time (in the VM only):
    static Klass* check_evol_method(Method* m);
+   static Klass* check_mismatch_calling_convention(Method* m);
    static Klass* check_leaf_type(InstanceKlass* ctxk);
    static Klass* check_abstract_with_unique_concrete_subtype(InstanceKlass* ctxk, Klass* conck, NewKlassDepChange* changes = nullptr);
    static Klass* check_unique_implementor(InstanceKlass* ctxk, Klass* uniqk, NewKlassDepChange* changes = nullptr);
    static Klass* check_unique_concrete_method(InstanceKlass* ctxk, Method* uniqm, NewKlassDepChange* changes = nullptr);
    static Klass* check_unique_concrete_method(InstanceKlass* ctxk, Method* uniqm, Klass* resolved_klass, Method* resolved_method, KlassDepChange* changes = nullptr);