diff a/src/hotspot/share/code/dependencies.hpp b/src/hotspot/share/code/dependencies.hpp
--- a/src/hotspot/share/code/dependencies.hpp
+++ b/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);
