[vm,dyn_modules] Support external/native methods in bytecode

TEST=ci

Change-Id: I2827c95f7b4d4bfa40239369d3675ef6adba4ab2
Cq-Include-Trybots: luci.dart.try:vm-aot-dyn-linux-debug-x64-try,vm-aot-dyn-linux-product-x64-try,vm-dyn-linux-debug-x64-try
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/439545
Commit-Queue: Alexander Markov <[email protected]>
Reviewed-by: Slava Egorov <[email protected]>

Author: alexmarkov

pkg/dart2bytecode/docs/bytecode.md

@@ -789,6 +789,11 @@ type ConstantDynamicCall extends ConstantPoolEntry {
   PackedObject selectorName;
   PackedObject argDesc;
 }
+
+// Occupies 2 entries in the constant pool
+type ConstantExternalCall extends ConstantPoolEntry {
+  Byte tag = 15;
+}
 ```
 
 ### Exceptions table
@@ -1250,6 +1255,11 @@ Lookup and invoke instance method with arguments SP[-(F-1)], ..., SP[0].
 ContantPool[D] is a ConstantDynamicCall specifying selector and
 arguments descriptor.
 
+#### ExternalCall D
+
+Invoke body of an external method.
+ContantPool[D] is a ConstantExternalCall.
+
 #### ReturnTOS
 
 Return to the caller using SP[0] as a result.

pkg/dart2bytecode/lib/assembler.dart

@@ -553,6 +553,11 @@ class BytecodeAssembler {
     _emitInstructionDF(Opcode.kDynamicCall, rd, rf);
   }
 
+  @pragma('vm:prefer-inline')
+  void emitExternalCall(int rd) {
+    _emitInstructionD(Opcode.kExternalCall, rd);
+  }
+
   @pragma('vm:prefer-inline')
   void emitLoadStatic(int rd) {
     _emitInstructionD(Opcode.kLoadStatic, rd);

pkg/dart2bytecode/lib/bytecode_generator.dart

@@ -781,7 +781,11 @@ class BytecodeGenerator extends RecursiveVisitor {
           _genConstructorInitializers(node);
         }
         if (node.isExternal) {
-          _genNoSuchMethodForExternal(node);
+          if (getExternalName(coreTypes, node) != null) {
+            _genExternalCall(node);
+          } else {
+            _genNoSuchMethodForExternal(node);
+          }
         } else {
           _generateNode(node.function?.body);
           // BytecodeAssembler eliminates this bytecode if it is unreachable.
@@ -852,6 +856,31 @@ class BytecodeGenerator extends RecursiveVisitor {
     return false;
   }
 
+  void _genExternalCall(Member node) {
+    final function = node.function!;
+
+    if (locals.hasFactoryTypeArgsVar) {
+      asm.emitPush(locals.getVarIndexInFrame(locals.factoryTypeArgsVar));
+    } else if (locals.hasFunctionTypeArgsVar) {
+      asm.emitPush(locals.functionTypeArgsVarIndexInFrame);
+    }
+    if (locals.hasReceiver) {
+      asm.emitPush(locals.getVarIndexInFrame(locals.receiverVar));
+    }
+    for (var param in function.positionalParameters) {
+      asm.emitPush(locals.getVarIndexInFrame(param));
+    }
+    // Native methods access their parameters by indices, so
+    // native wrappers should pass arguments in the original declaration
+    // order instead of sorted order.
+    for (var param in locals.originalNamedParameters) {
+      asm.emitPush(locals.getVarIndexInFrame(param));
+    }
+
+    final externalCallCpIndex = cp.addExternalCall();
+    asm.emitExternalCall(externalCallCpIndex);
+  }
+
   LibraryIndex get libraryIndex => coreTypes.index;
 
   late Procedure growableListLiteral =

pkg/dart2bytecode/lib/constant_pool.dart

@@ -30,6 +30,7 @@ enum ConstantTag {
   kInterfaceCall,
   kInstantiatedInterfaceCall,
   kDynamicCall,
+  kExternalCall,
 }
 
 String constantTagToString(ConstantTag tag) =>
@@ -84,6 +85,8 @@ abstract class ConstantPoolEntry {
         return new ConstantInstantiatedInterfaceCall.read(reader);
       case ConstantTag.kDynamicCall:
         return new ConstantDynamicCall.read(reader);
+      case ConstantTag.kExternalCall:
+        return new ConstantExternalCall.read(reader);
     }
     throw 'Unexpected constant tag $tag';
   }
@@ -501,6 +504,32 @@ class ConstantDynamicCall extends ConstantPoolEntry {
       this.argDesc == other.argDesc;
 }
 
+class ConstantExternalCall extends ConstantPoolEntry {
+  ConstantExternalCall();
+
+  @override
+  ConstantTag get tag => ConstantTag.kExternalCall;
+
+  @override
+  int get numReservedEntries => 1;
+
+  @override
+  void writeValue(BufferedWriter writer) {}
+
+  ConstantExternalCall.read(BufferedReader reader);
+
+  @override
+  String toString() => 'ExternalCall';
+
+  // Do not merge ConstantExternalCall entries.
+
+  @override
+  int get hashCode => identityHashCode(this);
+
+  @override
+  bool operator ==(other) => identical(this, other);
+}
+
 /// Reserved constant pool entry.
 class _ReservedConstantPoolEntry extends ConstantPoolEntry {
   const _ReservedConstantPoolEntry();
@@ -576,6 +605,8 @@ class ConstantPool {
           ? addDynamicCall(invocationKind, targetName, argDesc)
           : addInterfaceCall(invocationKind, target, argDesc);
 
+  int addExternalCall() => _add(ConstantExternalCall());
+
   int addStaticField(Field field) =>
       _add(new ConstantStaticField(objectTable.getHandle(field)!));
 

pkg/dart2bytecode/lib/dbc.dart

@@ -135,8 +135,8 @@ enum Opcode {
   kUncheckedDirectCall_Wide,
   kInterfaceCall,
   kInterfaceCall_Wide,
-  kUnused23, // Reserved for InterfaceCall1
-  kUnused24, // Reserved for InterfaceCall1_Wide
+  kExternalCall,
+  kExternalCall_Wide,
   kInstantiatedInterfaceCall,
   kInstantiatedInterfaceCall_Wide,
   kUncheckedClosureCall,
@@ -372,6 +372,8 @@ const Map<Opcode, Format> BytecodeFormats = const {
       Encoding.kDF, const [Operand.lit, Operand.imm, Operand.none]),
   Opcode.kDynamicCall: const Format(
       Encoding.kDF, const [Operand.lit, Operand.imm, Operand.none]),
+  Opcode.kExternalCall: const Format(
+      Encoding.kD, const [Operand.lit, Operand.none, Operand.none]),
   Opcode.kReturnTOS: const Format(
       Encoding.k0, const [Operand.none, Operand.none, Operand.none]),
   Opcode.kAssertAssignable: const Format(

runtime/vm/bytecode_reader.cc

@@ -463,6 +463,7 @@ intptr_t BytecodeReaderHelper::ReadConstantPool(const Function& function,
     kInterfaceCall,
     kInstantiatedInterfaceCall,
     kDynamicCall,
+    kExternalCall,
   };
 
   Object& obj = Object::Handle(Z);
@@ -617,6 +618,21 @@ intptr_t BytecodeReaderHelper::ReadConstantPool(const Function& function,
         // The second entry is used for arguments descriptor.
         obj = ReadObject();
       } break;
+      case ConstantPoolTag::kExternalCall: {
+        // ExternalCall constant occupies 2 entries:
+        // trampoline and native function.
+        pool.SetTypeAt(i, ObjectPool::EntryType::kNativeFunction,
+                       ObjectPool::Patchability::kNotPatchable,
+                       ObjectPool::SnapshotBehavior::kNotSnapshotable);
+        pool.SetRawValueAt(i, 0);
+        ++i;
+        ASSERT(i < obj_count);
+        pool.SetTypeAt(i, ObjectPool::EntryType::kNativeFunction,
+                       ObjectPool::Patchability::kNotPatchable,
+                       ObjectPool::SnapshotBehavior::kNotSnapshotable);
+        pool.SetRawValueAt(i, 0);
+        continue;
+      }
       default:
         UNREACHABLE();
     }