[vm,dyn_modules] Avoid static calls to bytecode functions from optimized JIT code

Static (direct) calls in the optimized JIT are performed through Code
objects without passing Function objects. This is not compatible with
bytecode interpreter calling conventions, so optimized JIT should
avoid static calls to bytecode functions.

This change disables devirtualized and guarded static calls to
functions declared in bytecode.

TEST=ci

Closes #60716

Change-Id: I95e4fa0706f376355f4fa7aea7fddf44f303e0a0
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/428340
Reviewed-by: Slava Egorov <[email protected]>
Commit-Queue: Alexander Markov <[email protected]>

Author: alexmarkov

runtime/vm/compiler/backend/flow_graph_compiler.cc

@@ -2198,6 +2198,13 @@ void FlowGraphCompiler::EmitTestAndCall(const CallTargets& targets,
       add_megamorphic_call = true;
       break;
     }
+    const Function& function = *targets.TargetAt(i)->target;
+    if (function.is_declared_in_bytecode()) {
+      // Optimized static calls dispatch via Code object without passing
+      // Function object which is incompatible to the bytecode interpreter.
+      add_megamorphic_call = true;
+      continue;
+    }
     compiler::Label next_test;
     if (!complete || !is_last_check) {
       bias = EmitTestAndCallCheckCid(assembler(),
@@ -2207,7 +2214,6 @@ void FlowGraphCompiler::EmitTestAndCall(const CallTargets& targets,
     }
     // Do not use the code from the function, but let the code be patched so
     // that we can record the outgoing edges to other code.
-    const Function& function = *targets.TargetAt(i)->target;
     GenerateStaticDartCall(deopt_id, source_index,
                            UntaggedPcDescriptors::kOther, locs, function,
                            entry_kind);

runtime/vm/compiler/backend/il.cc

@@ -5592,6 +5592,11 @@ Definition* InstanceCallInstr::Canonicalize(FlowGraph* flow_graph) {
 
   ASSERT(new_target->HasSingleTarget());
   const Function& target = new_target->FirstTarget();
+  if (target.is_declared_in_bytecode()) {
+    // Optimized static calls dispatch via Code object without passing
+    // Function object which is incompatible to the bytecode interpreter.
+    return this;
+  }
   StaticCallInstr* specialized = StaticCallInstr::FromCall(
       flow_graph->zone(), this, target, new_target->AggregateCallCount());
   flow_graph->InsertBefore(this, specialized, env(), FlowGraph::kValue);

runtime/vm/compiler/call_specializer.cc

@@ -193,6 +193,11 @@ void CallSpecializer::SpecializePolymorphicInstanceCall(
 
   ASSERT(targets->HasSingleTarget());
   const Function& target = targets->FirstTarget();
+  if (target.is_declared_in_bytecode()) {
+    // Optimized static calls dispatch via Code object without passing
+    // Function object which is incompatible to the bytecode interpreter.
+    return;
+  }
   StaticCallInstr* specialized =
       StaticCallInstr::FromCall(Z, call, target, targets->AggregateCallCount());
   call->ReplaceWith(specialized, current_iterator());

runtime/vm/compiler/jit/jit_call_specializer.cc

@@ -111,8 +111,9 @@ void JitCallSpecializer::VisitInstanceCall(InstanceCallInstr* instr) {
       has_one_target = PolymorphicInstanceCallInstr::ComputeRuntimeType(
                            targets) != Type::null();
     } else {
-      has_one_target =
-          !target.is_polymorphic_target() && !target.IsDynamicallyOverridden();
+      has_one_target = !target.is_polymorphic_target() &&
+                       !target.IsDynamicallyOverridden() &&
+                       !target.is_declared_in_bytecode();
     }
   }